From 1794c389e58ce42e538a88468d7fe6a426dff387 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 05:01:47 +0000
Subject: [PATCH 01/76] Keep the cell draft in its own workbook; Switch Windows
 lists open workbooks

A cell being typed when File > New ran (macOS menu, control channel) stayed
open over the new workbook, and Enter wrote it there; the first workbook
stayed clean and nothing in the UI reached it.

- Every file.* and window command (window.activate, view.newWindow,
  view.hideWindow, view.unhideWindow, view.switchWindows with a doc) first
  commits the cell and text-box drafts as Enter would, or drops a draft its
  workbook refuses, still reporting why. Finder, argv and dropped opens go
  through file.open and get the same.
- The cell editor records its workbook's uid; the grid draws a draft only
  over that workbook, and a commit always goes into it.
- view.switchWindows takes a `doc` uid to bring that workbook forward and
  lists index, doc, title, dirty, active and hidden. Menu-style calls with
  no doc open the View tab's new Switch Windows dropdown.
- macOS: the Window menu lists the open workbooks (unsaved bullet, active
  check), and Quit closes the window so unsaved workbooks are asked about.
---
 apps/gridcraft/src/main.rs        |   2 +-
 apps/gridcraft/src/native_menu.rs |  68 ++++++++++++++--
 crates/engine/src/cmd/extra.rs    |  28 ++++++-
 crates/engine/src/lib.rs          |   6 ++
 crates/engine/src/tests.rs        |  31 ++++++++
 crates/ui-egui/src/editor.rs      |  15 ++--
 crates/ui-egui/src/grid.rs        |   3 +-
 crates/ui-egui/src/lib.rs         | 127 ++++++++++++++++++++++++------
 crates/ui-egui/src/ribbon.rs      |  19 +++++
 crates/ui-egui/tests/file_menu.rs |  77 ++++++++++++++++++
 10 files changed, 337 insertions(+), 39 deletions(-)

diff --git a/apps/gridcraft/src/main.rs b/apps/gridcraft/src/main.rs
index 7c0eb04e6..8aad9aeb8 100644
--- a/apps/gridcraft/src/main.rs
+++ b/apps/gridcraft/src/main.rs
@@ -34,7 +34,7 @@ impl eframe::App for App {
             if self.1.is_none() && std::env::var_os("GRIDCRAFT_NO_NATIVE_MENU").is_none() {
                 self.1 = Some(native_menu::NativeMenu::install(ctx));
             }
-            if let Some(m) = &self.1 {
+            if let Some(m) = &mut self.1 {
                 m.poll(&mut self.0, ctx);
             }
             apple_events::poll(&self.2, &mut self.0, ctx);
diff --git a/apps/gridcraft/src/native_menu.rs b/apps/gridcraft/src/native_menu.rs
index 6985af3c0..2c2866379 100644
--- a/apps/gridcraft/src/native_menu.rs
+++ b/apps/gridcraft/src/native_menu.rs
@@ -4,7 +4,7 @@
 use std::str::FromStr;
 use std::sync::mpsc::{Receiver, channel};
 
-use gridcraft_ui_egui::SheetApp;
+use gridcraft_ui_egui::{OpenWindow, SheetApp};
 use muda::accelerator::Accelerator;
 use muda::{CheckMenuItem, Menu, MenuEvent, MenuItem, PredefinedMenuItem, Submenu};
 use serde_json::{Value, json};
@@ -168,7 +168,16 @@ fn tree() -> Vec<(&'static str, Vec<Entry>)> {
                 ("Calculate Now", "formulas.calculateNow", None),
             ],
         ),
-        ("Window", vec![("New Window", "view.newWindow", None), ("Next Sheet", "sheet.next", None), ("Previous Sheet", "sheet.previous", None)]),
+        // The open workbooks follow the separator (`NativeMenu::sync_windows`).
+        (
+            "Window",
+            vec![
+                ("New Window", "view.newWindow", None),
+                ("Next Sheet", "sheet.next", None),
+                ("Previous Sheet", "sheet.previous", None),
+                ("-", "", None),
+            ],
+        ),
         (
             "Help",
             vec![
@@ -185,8 +194,19 @@ pub struct NativeMenu {
     _menu: Menu,
     events: Receiver<MenuEvent>,
     theme_items: Vec<(&'static str, CheckMenuItem)>,
+    window_menu: Option<Submenu>,
+    /// The Window menu's workbook items and what they last showed.
+    window_items: Vec<CheckMenuItem>,
+    windows: Vec<OpenWindow>,
 }
 
+/// Menu id of the Window menu item that brings workbook `doc` forward.
+const WINDOW_ITEM: &str = "window:doc:";
+
+/// The Quit item: closing the window asks about unsaved workbooks first, which AppKit's own
+/// Quit (terminate:) would skip.
+const QUIT: &str = "app.quit";
+
 fn select_theme(app: &mut SheetApp, id: &str) -> bool {
     let mode = match id {
         "theme:system" => "system",
@@ -212,7 +232,7 @@ impl NativeMenu {
             &PredefinedMenuItem::hide_others(None),
             &PredefinedMenuItem::show_all(None),
             &PredefinedMenuItem::separator(),
-            &PredefinedMenuItem::quit(None),
+            &MenuItem::with_id(QUIT, "Quit GridCraft", true, Accelerator::from_str("CMD+Q").ok()),
         ]);
         let _ = menu.append(&app_menu);
         let mut theme_items = Vec::new();
@@ -247,7 +267,7 @@ impl NativeMenu {
         // NSApp's windowsMenu is where macOS adds Move & Resize, Fill and Center, the targets of the
         // system tiling shortcuts (Fn+Ctrl+arrows, Fn+F). Only once the menu is NSApp's: muda looks
         // the submenu up in the installed main menu.
-        if let Some(window) = window_menu {
+        if let Some(window) = &window_menu {
             window.set_as_windows_menu_for_nsapp();
         }
         let (tx, rx) = channel();
@@ -256,12 +276,47 @@ impl NativeMenu {
             let _ = tx.send(e);
             ctx.request_repaint();
         }));
-        NativeMenu { _menu: menu, events: rx, theme_items }
+        NativeMenu { _menu: menu, events: rx, theme_items, window_menu, window_items: Vec::new(), windows: Vec::new() }
     }
 
-    pub fn poll(&self, app: &mut SheetApp, ctx: &egui::Context) {
+    /// Keeps the Window menu's list of open workbooks (title, unsaved bullet, active check) in
+    /// step with the session.
+    fn sync_windows(&mut self, app: &SheetApp) {
+        let windows = app.open_windows();
+        if windows == self.windows {
+            return;
+        }
+        let Some(menu) = &self.window_menu else { return };
+        let same_docs = windows.len() == self.windows.len() && windows.iter().zip(&self.windows).all(|(a, b)| a.doc == b.doc);
+        if same_docs {
+            for (item, w) in self.window_items.iter().zip(&windows) {
+                item.set_text(w.label());
+                item.set_checked(w.active);
+            }
+        } else {
+            for item in self.window_items.drain(..) {
+                let _ = menu.remove(&item);
+            }
+            for w in &windows {
+                let item = CheckMenuItem::with_id(format!("{WINDOW_ITEM}{}", w.doc), w.label(), true, w.active, None);
+                let _ = menu.append(&item);
+                self.window_items.push(item);
+            }
+        }
+        self.windows = windows;
+    }
+
+    pub fn poll(&mut self, app: &mut SheetApp, ctx: &egui::Context) {
         while let Ok(ev) = self.events.try_recv() {
             let id = ev.id.as_ref().to_string();
+            if id == QUIT {
+                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+                continue;
+            }
+            if let Some(doc) = id.strip_prefix(WINDOW_ITEM).and_then(|d| d.parse::<u64>().ok()) {
+                app.run_or_alert("view.switchWindows", json!({"doc": doc}));
+                continue;
+            }
             // Text selection belongs to the inline editor, not the worksheet clipboard/undo.
             if app.text_box_editor.is_some() {
                 let clipboard = match id.as_str() {
@@ -321,6 +376,7 @@ impl NativeMenu {
                 item.set_checked(checked);
             }
         }
+        self.sync_windows(app);
     }
 }
 
diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index c44094cdd..debb62eeb 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -145,7 +145,15 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "view.arrangeAll", "Arrange All", ["View", "Window"], None, "{}", has_doc, |_, _| ok()),
         cmd!(noundo "view.hideWindow", "Hide", ["View", "Window"], None, "{}", has_doc, hide_window),
         cmd!(noundo "view.unhideWindow", "Unhide…", ["View", "Window"], None, "{index?}", has_doc, unhide_window),
-        cmd!(query "view.switchWindows", "Switch Windows", ["View", "Window"], None, "{} → open windows", always, switch_windows),
+        cmd!(
+            noundo "view.switchWindows",
+            "Switch Windows",
+            ["View", "Window"],
+            None,
+            "{doc?} → open workbooks [{index, doc, title, dirty, active, hidden}]; with `doc` (a workbook's `doc` id from the list) makes that workbook active first",
+            always,
+            switch_windows
+        ),
         cmd!(noundo "view.ruler", "Ruler", ["View", "Show"], None, "{on?} → {on}: rulers in Page Layout view (an application option)", has_doc, ruler),
         cmd!(query "view.macros", "Macros", ["View", "Macros"], None, "{} → scripts", has_doc, all_scripts),
         // Table tools
@@ -808,12 +816,26 @@ fn unhide_window(s: &mut Session, p: &Json) -> Result<Json> {
     ok()
 }
 
-fn switch_windows(s: &mut Session, _: &Json) -> Result<Json> {
+fn switch_windows(s: &mut Session, p: &Json) -> Result<Json> {
+    if let Some(doc) = p.get("doc").filter(|v| !v.is_null()) {
+        let i = doc.as_u64().and_then(|uid| s.document_index(uid)).ok_or_else(|| bad("view.switchWindows", "no open workbook has that `doc` id"))?;
+        s.hidden_windows.retain(|x| *x != i);
+        s.set_active(i);
+    }
     Ok(Json::Array(
         s.documents()
             .iter()
             .enumerate()
-            .map(|(i, d)| json!({"index": i, "title": d.display_title(), "active": i == s.active_index(), "hidden": s.hidden_windows.contains(&i)}))
+            .map(|(i, d)| {
+                json!({
+                    "index": i,
+                    "doc": d.uid,
+                    "title": d.display_title(),
+                    "dirty": d.is_dirty(),
+                    "active": i == s.active_index(),
+                    "hidden": s.hidden_windows.contains(&i),
+                })
+            })
             .collect(),
     ))
 }
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 10c6cb87c..aeeaa9bdb 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -106,6 +106,8 @@ pub struct DocState {
     pub path: Option<String>,
     pub saved: Arc<Workbook>,
     pub revision: u64,
+    /// Identifies this open workbook for the rest of the session: it never changes while the
+    /// workbook is open (saving, renaming, reordering) and is never reused for another one.
     pub uid: u64,
     pub title: String,
     /// Per-sheet selection memory.
@@ -336,6 +338,10 @@ impl Session {
     pub fn active(&self) -> Option<&DocState> {
         self.docs.get(self.active)
     }
+    /// Where the open workbook with this [`DocState::uid`] is in [`Session::documents`].
+    pub fn document_index(&self, uid: u64) -> Option<usize> {
+        self.docs.iter().position(|d| d.uid == uid)
+    }
     pub fn active_mut(&mut self) -> Option<&mut DocState> {
         self.docs.get_mut(self.active)
     }
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index d6a99be91..07a32209f 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -4459,3 +4459,34 @@ fn html_export_without_pictures_or_charts_has_no_fixed_geometry() {
     let html = crate::io::to_html(&s.doc().unwrap().wb, 0).unwrap();
     assert!(!html.contains("<colgroup>") && !html.contains("table-layout") && !html.contains("<svg") && !html.contains("<img"), "{html}");
 }
+
+#[test]
+fn switch_windows_lists_workbooks_by_stable_id_and_switches_to_one() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "A1", "input": "first"})).unwrap();
+    let book1 = s.doc().unwrap().uid;
+    s.execute("file.new", json!({})).unwrap();
+    s.execute("file.new", json!({})).unwrap();
+    let book3 = s.doc().unwrap().uid;
+    let list = s.execute("view.switchWindows", json!({})).unwrap();
+    let rows = list.as_array().unwrap();
+    assert_eq!(rows.len(), 3);
+    assert_eq!((rows[0]["doc"].as_u64(), rows[0]["title"].as_str(), rows[0]["dirty"].as_bool()), (Some(book1), Some("Book1"), Some(true)));
+    assert_eq!((rows[2]["dirty"].as_bool(), rows[2]["active"].as_bool()), (Some(false), Some(true)));
+
+    // Closing a workbook shifts the indexes but not the ids.
+    s.execute("window.activate", json!({"index": 1})).unwrap();
+    s.execute("file.close", json!({"force": true})).unwrap();
+    assert_eq!(s.document_index(book3), Some(1));
+    let list = s.execute("view.switchWindows", json!({"doc": book1})).unwrap();
+    assert_eq!(s.doc().unwrap().uid, book1);
+    assert_eq!(v(&s, "A1"), Value::text("first"));
+    assert_eq!(list[0]["active"].as_bool(), Some(true));
+    s.execute("file.save", json!({"path": std::env::temp_dir().join(format!("gridcraft-uid-{}.xlsx", std::process::id()))})).unwrap();
+    assert_eq!(s.doc().unwrap().uid, book1, "saving keeps the id");
+    let _ = std::fs::remove_file(std::env::temp_dir().join(format!("gridcraft-uid-{}.xlsx", std::process::id())));
+
+    assert!(s.execute("view.switchWindows", json!({"doc": book3 + 1000})).is_err());
+    assert!(s.execute("view.switchWindows", json!({"doc": "Book1"})).is_err());
+    assert_eq!(s.doc().unwrap().uid, book1, "a bad id leaves the active workbook alone");
+}
diff --git a/crates/ui-egui/src/editor.rs b/crates/ui-egui/src/editor.rs
index 8984ad53c..eeeaf12da 100644
--- a/crates/ui-egui/src/editor.rs
+++ b/crates/ui-egui/src/editor.rs
@@ -18,6 +18,8 @@ pub const REF_COLORS: [Color32; 8] = [
 
 #[derive(Clone, Debug)]
 pub struct EditState {
+    /// The workbook (`DocState::uid`) the draft belongs to: it is drawn and committed only there.
+    pub doc: u64,
     pub sheet: usize,
     /// Syntax of this edit, captured when it starts (prevents a language switch reinterpreting it).
     pub locale: gridcraft_engine::formula::FormulaLocale,
@@ -46,9 +48,10 @@ pub struct EditState {
 }
 
 impl EditState {
-    pub fn new(sheet: usize, cell: CellRef, text: String, enter_mode: bool, from_formula_bar: bool) -> EditState {
+    pub fn new(doc: u64, sheet: usize, cell: CellRef, text: String, enter_mode: bool, from_formula_bar: bool) -> EditState {
         let caret = text.chars().count();
         EditState {
+            doc,
             sheet,
             locale: Default::default(),
             cell,
@@ -365,7 +368,7 @@ mod tests {
 
     #[test]
     fn point_mode() {
-        let mut e = EditState::new(0, CellRef::new(0, 0), "=SUM(".into(), true, false);
+        let mut e = EditState::new(1, 0, CellRef::new(0, 0), "=SUM(".into(), true, false);
         assert!(e.can_point());
         e.insert_ref("A1");
         assert_eq!(e.text, "=SUM(A1");
@@ -375,19 +378,19 @@ mod tests {
         e.caret += 1;
         e.point = None;
         assert!(e.can_point());
-        let e2 = EditState::new(0, CellRef::new(0, 0), "hello".into(), true, false);
+        let e2 = EditState::new(1, 0, CellRef::new(0, 0), "hello".into(), true, false);
         assert!(!e2.can_point());
     }
 
     #[test]
     fn autocomplete_and_hints() {
         let names: Vec<String> = ["SUM", "SUMIF", "SUMPRODUCT", "AVERAGE"].iter().map(|s| s.to_string()).collect();
-        let mut e = EditState::new(0, CellRef::new(0, 0), "=su".into(), true, false);
+        let mut e = EditState::new(1, 0, CellRef::new(0, 0), "=su".into(), true, false);
         e.update_autocomplete(&names);
         assert_eq!(e.autocomplete.len(), 3);
         assert!(e.accept_autocomplete());
         assert_eq!(e.text, "=SUM(");
-        let e = EditState::new(0, CellRef::new(0, 0), "=IF(A1>0,SUM(B1,".into(), true, false);
+        let e = EditState::new(1, 0, CellRef::new(0, 0), "=IF(A1>0,SUM(B1,".into(), true, false);
         assert_eq!(e.current_function(), Some(("SUM".into(), 1)));
     }
 
@@ -423,7 +426,7 @@ mod tests {
 
     #[test]
     fn inserting_a_union_keeps_each_reference_separately_pointed() {
-        let mut edit = EditState::new(0, CellRef::new(0, 0), "=SUM(".into(), true, false);
+        let mut edit = EditState::new(1, 0, CellRef::new(0, 0), "=SUM(".into(), true, false);
         edit.insert_ref("C:C");
         edit.append_ref("E:E");
         assert_eq!(edit.text, "=SUM(C:C,E:E");
diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index a0efbfae7..145b9f583 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -1744,6 +1744,7 @@ pub(crate) fn paint_selection(
     // Editing a formula: outline its references instead of the selection.
     if let Some(ed) = &app.editor
         && ed.is_formula()
+        && app.session.active().is_some_and(|d| d.uid == ed.doc)
     {
         let origin = app.session.active().and_then(|d| d.wb.sheet(ed.sheet)).map_or(sh.name.as_str(), |o| o.name.as_str());
         for (_, _, r, sheet, idx) in crate::editor::formula_refs(&ed.text) {
@@ -3045,7 +3046,7 @@ fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Response, geo:
 
 fn in_cell_editor(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet, wb: &Workbook) {
     let Some(ed) = app.editor.as_ref() else { return };
-    if ed.sheet != wb.active_sheet {
+    if app.view_key() != Some((ed.doc, ed.sheet)) {
         return;
     }
     let cell = ed.cell;
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index faae9bfae..001abaad5 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -166,6 +166,23 @@ pub struct Notice {
     pub action: Option<(String, String)>,
 }
 
+/// One open workbook, as View › Switch Windows and the macOS Window menu list it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct OpenWindow {
+    /// The workbook's `DocState::uid`, the `doc` param of `view.switchWindows`.
+    pub doc: u64,
+    pub title: String,
+    pub dirty: bool,
+    pub active: bool,
+}
+
+impl OpenWindow {
+    /// The title, with a bullet after it while the workbook has unsaved changes.
+    pub fn label(&self) -> String {
+        if self.dirty { format!("{} •", self.title) } else { self.title.clone() }
+    }
+}
+
 /// Host services the platform shell provides (file pickers, opening URLs).
 #[derive(Default)]
 pub struct Services {
@@ -296,6 +313,9 @@ pub struct SheetApp {
     /// Every unsaved workbook has been answered for quitting (or `app.quit` asked): the next
     /// window close goes through.
     pub allow_close: bool,
+    /// View › Switch Windows opens its list on the next frame the View tab draws (asked for by a
+    /// key tip, the command search or a menu, possibly while another tab was showing).
+    pub(crate) open_switch_windows: bool,
 }
 
 impl SheetApp {
@@ -342,6 +362,7 @@ impl SheetApp {
             tab_run: None,
             started: now_ms(),
             allow_close: false,
+            open_switch_windows: false,
         }
     }
 
@@ -387,30 +408,30 @@ impl SheetApp {
     }
 
     fn run_command(&mut self, id: &str, params: Json) -> Result<Json, String> {
+        let switches_window = id.starts_with("window.")
+            || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
+            || (id == "view.switchWindows" && params.get("doc").is_some_and(|d| !d.is_null()));
+        if id.starts_with("file.") || switches_window {
+            self.settle_drafts();
+        }
         if matches!(id, "file.save" | "file.saveAs" | "file.saveBytes") {
             self.store_view_state();
         }
-        if id.starts_with("file.")
-            || matches!(
-                id,
-                "window.activate"
-                    | "sheet.activate"
-                    | "sheet.next"
-                    | "sheet.previous"
-                    | "sheet.move"
-                    | "sheet.hide"
-                    | "sheet.unhide"
-                    | "view.newWindow"
-                    | "view.hideWindow"
-                    | "view.unhideWindow"
-                    | "home.insertSheet"
-                    | "home.deleteSheet"
-                    | "edit.undo"
-                    | "edit.redo"
-                    | "object.delete"
-                    | "object.move"
-            )
-        {
+        if matches!(
+            id,
+            "sheet.activate"
+                | "sheet.next"
+                | "sheet.previous"
+                | "sheet.move"
+                | "sheet.hide"
+                | "sheet.unhide"
+                | "home.insertSheet"
+                | "home.deleteSheet"
+                | "edit.undo"
+                | "edit.redo"
+                | "object.delete"
+                | "object.move"
+        ) {
             self.commit_text_box_edit()?;
         }
         if let Some(r) = self.run_ui_command(id, &params) {
@@ -546,6 +567,14 @@ impl SheetApp {
         if id == "insert.recommendedCharts" && params.get("type").is_none() {
             return self.open_dialog("recommendedCharts", json!({}));
         }
+        // Switch Windows with no workbook named (key tip, command search) opens the View tab's
+        // list to choose from; programmatic callers of `run` get the list back.
+        if id == "view.switchWindows" && params.get("doc").is_none_or(Json::is_null) {
+            self.ui.ribbon_tab = "View".into();
+            self.ui.ribbon_collapsed = false;
+            self.open_switch_windows = true;
+            return;
+        }
         if let Err(e) = self.run(id, params) {
             self.alert(e);
         }
@@ -882,6 +911,17 @@ impl SheetApp {
         }
     }
 
+    /// The open workbooks in order, for the Switch Windows lists.
+    pub fn open_windows(&self) -> Vec<OpenWindow> {
+        let active = self.session.active_index();
+        self.session
+            .documents()
+            .iter()
+            .enumerate()
+            .map(|(i, d)| OpenWindow { doc: d.uid, title: d.display_title(), dirty: d.is_dirty(), active: i == active })
+            .collect()
+    }
+
     pub fn view_key(&self) -> Option<(u64, usize)> {
         self.session.active().map(|d| (d.uid, d.wb.active_sheet))
     }
@@ -961,7 +1001,7 @@ impl SheetApp {
             Some(t) => (t, true),
             None => (current.clone(), false),
         };
-        let mut ed = editor::EditState::new(d.wb.active_sheet, at, text, replace, from_formula_bar);
+        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet, at, text, replace, from_formula_bar);
         ed.locale = locale;
         if replace && self.ui.autocomplete && !ed.is_formula() {
             ed.completion = editor::column_completion(sh, at, &ed.text);
@@ -971,7 +1011,45 @@ impl SheetApp {
     }
 
     /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
+    ///
+    /// The draft goes into the workbook it was typed in. If another workbook is showing, that
+    /// workbook stays active afterwards, and a draft its own workbook refuses (validation, a bad
+    /// formula) is dropped rather than left open over the wrong grid.
     pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
+        let Some(doc) = self.editor.as_ref().map(|ed| ed.doc) else { return true };
+        let shown = self.session.active().map(|d| d.uid);
+        if shown == Some(doc) {
+            return self.commit_edit_here(dr, dc, array, fill_selection);
+        }
+        let Some(owner) = self.session.document_index(doc) else {
+            self.cancel_edit();
+            return true;
+        };
+        let back = self.session.active_index();
+        self.session.set_active(owner);
+        if !self.commit_edit_here(dr, dc, array, fill_selection) {
+            self.cancel_edit();
+        }
+        self.session.set_active(back);
+        true
+    }
+
+    /// Settles the cell and text-box drafts before a command that can show another workbook or
+    /// write this one to a file: each is committed as Enter would, or dropped when it can't be
+    /// (the refusal is still reported), so a draft never lands in another workbook.
+    fn settle_drafts(&mut self) {
+        if !self.commit_edit(0, 0, false, false) {
+            self.cancel_edit();
+        }
+        if let Err(e) = self.commit_text_box_edit() {
+            self.cancel_text_box_edit();
+            if self.message.is_none() {
+                self.message = Some(("Text Box".into(), clean_error(&e)));
+            }
+        }
+    }
+
+    fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
         let Some(ed) = self.editor.take() else { return true };
         self.session.mode = gridcraft_engine::Mode::Ready;
         let text = match &ed.completion {
@@ -1276,6 +1354,11 @@ impl SheetApp {
         }
         let t0 = now_ms();
         text_box::before_ui(self, &ctx);
+        // Another workbook came forward without going through a command (which settles drafts
+        // first): the draft goes into its own workbook instead of floating over this one.
+        if self.editor.as_ref().is_some_and(|ed| self.session.active().map(|d| d.uid) != Some(ed.doc)) {
+            self.commit_edit(0, 0, false, false);
+        }
         // The language the widgets translate with this frame (see `i18n::current`).
         i18n::set_current(&ctx, self.ui.language);
         let t = theme::Tokens::get(&ctx);
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index 356381d66..d90b642ea 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -2336,6 +2336,7 @@ fn view(app: &mut SheetApp, ui: &mut Ui) {
             ],
         );
     });
+    switch_windows(app, ui);
     ui.vertical(|ui| {
         ui.label(lang.tr("Display theme"));
         let mode = app.ui.theme_mode();
@@ -2391,6 +2392,24 @@ fn view(app: &mut SheetApp, ui: &mut Ui) {
     });
 }
 
+/// View › Switch Windows: the open workbooks, the active one checked and unsaved ones marked;
+/// choosing one brings it forward.
+fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
+    let anchor = big_button(ui, Icon::Book, "Switch\nWindows", "Switch Windows", true);
+    anchor.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), "Switch Windows"));
+    control_keytip(app, ui, &anchor, "view.switchWindows");
+    let forced = std::mem::take(&mut app.open_switch_windows);
+    egui::Popup::menu(&anchor).open_memory(popup_command(forced, anchor.clicked())).show(|ui| {
+        for w in app.open_windows() {
+            let label = format!("{}{}", if w.active { "✓ " } else { "    " }, w.label());
+            if ui.add(egui::Button::selectable(w.active, label).min_size(vec2(220.0, 22.0))).clicked() {
+                act(app, "view.switchWindows", json!({"doc": w.doc}));
+                ui.close();
+            }
+        }
+    });
+}
+
 fn automate(app: &mut SheetApp, ui: &mut Ui) {
     if big_button(ui, Icon::Script, "Macros", "Macros and scripts in this workbook (Alt+F8)", false).clicked() {
         app.open_dialog("macros", json!({}));
diff --git a/crates/ui-egui/tests/file_menu.rs b/crates/ui-egui/tests/file_menu.rs
index 047efe1b1..415e09902 100644
--- a/crates/ui-egui/tests/file_menu.rs
+++ b/crates/ui-egui/tests/file_menu.rs
@@ -289,6 +289,83 @@ fn closing_the_window_can_save_first_and_a_saved_workbook_closes_at_once() {
     let _ = std::fs::remove_dir_all(&dir);
 }
 
+#[test]
+fn quitting_with_one_of_two_workbooks_unsaved_asks_once() {
+    let mut h = harness(Services::default());
+    h.state_mut().run("cell.set", serde_json::json!({"cell": "A1", "input": "42"})).unwrap();
+    h.state_mut().run("file.new", serde_json::json!({})).unwrap();
+    h.run_steps(2);
+
+    let sent = request_window_close(&mut h);
+    assert!(sent.contains(&egui::ViewportCommand::CancelClose), "{sent:?}");
+    assert_eq!(h.state().dialog.as_ref().map(|d| d.name()), Some("saveChanges"));
+    assert_eq!(h.state().session.active_index(), 0, "the unsaved workbook comes forward");
+    let sent = click_commands(&mut h, "Cancel");
+    assert!(!sent.contains(&egui::ViewportCommand::Close), "Cancel stops the quit");
+    assert_eq!(h.state().session.documents().len(), 2, "Cancel keeps both workbooks");
+
+    request_window_close(&mut h);
+    let sent = click_commands(&mut h, "Don't Save");
+    assert!(sent.contains(&egui::ViewportCommand::Close), "the saved workbook isn't asked about: {sent:?}");
+    assert!(h.state().dialog.is_none());
+}
+
+/// Book1 has a cell being typed when File › New runs (the macOS menu runs the command directly).
+fn typing_in_book1_then_new(h: &mut egui_kittest::Harness<'static, SheetApp>) -> u64 {
+    h.input_mut().events.push(egui::Event::Text("hello".into()));
+    h.run_steps(2);
+    assert!(h.state().editor.is_some());
+    let book1 = h.state().session.doc().unwrap().uid;
+    h.state_mut().run_or_alert("file.new", serde_json::json!({}));
+    h.run_steps(3);
+    book1
+}
+
+fn a1(h: &egui_kittest::Harness<'static, SheetApp>, doc: usize) -> Value {
+    h.state().session.documents()[doc].wb.active().unwrap().value(CellRef::new(0, 0))
+}
+
+#[test]
+fn new_workbook_keeps_the_typed_cell_in_the_first_and_switch_windows_brings_it_back() {
+    let mut h = harness(Services::default());
+    let book1 = typing_in_book1_then_new(&mut h);
+    assert!(h.state().editor.is_none(), "the draft doesn't follow into Book2");
+    assert_eq!(h.state().session.documents().len(), 2);
+    assert_eq!(h.state().session.active_index(), 1);
+    assert_eq!(a1(&h, 0), Value::text("hello"), "the draft is committed into Book1, as Enter would");
+    assert!(h.state().session.documents()[0].is_dirty(), "so quitting asks about Book1");
+    assert_eq!(a1(&h, 1), Value::Empty);
+    h.key_press(egui::Key::Enter);
+    h.run_steps(2);
+    assert_eq!(a1(&h, 1), Value::Empty, "Enter in Book2 writes nothing left over");
+
+    // The key tip or command search opens the View tab's list; Book1 shows its unsaved bullet.
+    h.state_mut().run_or_alert("view.switchWindows", serde_json::json!({}));
+    h.run_steps(3);
+    assert_eq!(h.state().ui.ribbon_tab, "View");
+    h.get_by_label_contains("Book1 •").click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.doc().unwrap().uid, book1);
+    assert_eq!(h.state().session.documents().len(), 2);
+    assert!(h.state().message.is_none());
+}
+
+#[test]
+fn a_draft_its_workbook_refuses_is_dropped_when_switching_away() {
+    let mut h = harness(Services::default());
+    let book1 = typing_in_book1_then_new(&mut h);
+    h.state_mut().session.execute("data.validation", serde_json::json!({"range": "A1", "type": "list", "formula1": "\"Red,Green\""})).unwrap();
+    h.input_mut().events.push(egui::Event::Text("Purple".into()));
+    h.run_steps(2);
+    assert!(h.state().editor.is_some());
+    h.state_mut().run_or_alert("view.switchWindows", serde_json::json!({"doc": book1}));
+    h.run_steps(2);
+    assert!(h.state().editor.is_none());
+    assert_eq!(h.state().session.doc().unwrap().uid, book1, "the switch still happens");
+    assert_eq!(a1(&h, 1), Value::Empty, "Book2 is unchanged");
+    assert!(h.state().message.is_some(), "the refusal is reported");
+}
+
 fn pdf_picker_harness(dir: &std::path::Path) -> (Arc<Mutex<Vec<String>>>, egui_kittest::Harness<'static, SheetApp>) {
     let asked = Arc::new(Mutex::new(Vec::<String>::new()));
     let (capture, target) = (asked.clone(), dir.to_path_buf());

From a0d54b49d47c081b33dc18c44b65da74a3916413 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 05:12:23 +0000
Subject: [PATCH 02/76] A refused cell draft stops the command; an untouched F2
 draft changes nothing

- File and window commands stop when the workbook refuses the cell or
  text-box draft (validation Stop, bad formula, protected text box): the
  draft stays open in its cell with the reason shown, to fix or Esc. The
  per-frame backstop brings a refused draft's workbook back to the front.
- An F2 draft committed with its text unchanged writes nothing: no undo
  step, and the workbook stays clean through Save, Print or New.
- macOS Window menu: the active workbook's check is put back every poll,
  since choosing a check item flips it.
---
 apps/gridcraft/src/native_menu.rs | 39 ++++++++++++++++------------
 crates/ui-egui/src/editor.rs      |  5 ++++
 crates/ui-egui/src/lib.rs         | 43 ++++++++++++++++++-------------
 crates/ui-egui/tests/file_menu.rs | 38 ++++++++++++++++++++++++---
 4 files changed, 86 insertions(+), 39 deletions(-)

diff --git a/apps/gridcraft/src/native_menu.rs b/apps/gridcraft/src/native_menu.rs
index 2c2866379..877c82fd8 100644
--- a/apps/gridcraft/src/native_menu.rs
+++ b/apps/gridcraft/src/native_menu.rs
@@ -283,27 +283,32 @@ impl NativeMenu {
     /// step with the session.
     fn sync_windows(&mut self, app: &SheetApp) {
         let windows = app.open_windows();
-        if windows == self.windows {
-            return;
+        if windows != self.windows
+            && let Some(menu) = &self.window_menu
+        {
+            let same_docs = windows.len() == self.windows.len() && windows.iter().zip(&self.windows).all(|(a, b)| a.doc == b.doc);
+            if same_docs {
+                for (item, w) in self.window_items.iter().zip(&windows) {
+                    item.set_text(w.label());
+                }
+            } else {
+                for item in self.window_items.drain(..) {
+                    let _ = menu.remove(&item);
+                }
+                for w in &windows {
+                    let item = CheckMenuItem::with_id(format!("{WINDOW_ITEM}{}", w.doc), w.label(), true, w.active, None);
+                    let _ = menu.append(&item);
+                    self.window_items.push(item);
+                }
+            }
+            self.windows = windows;
         }
-        let Some(menu) = &self.window_menu else { return };
-        let same_docs = windows.len() == self.windows.len() && windows.iter().zip(&self.windows).all(|(a, b)| a.doc == b.doc);
-        if same_docs {
-            for (item, w) in self.window_items.iter().zip(&windows) {
-                item.set_text(w.label());
+        // AppKit flips a check item when it is chosen, so the active check is put back every poll.
+        for (item, w) in self.window_items.iter().zip(&self.windows) {
+            if item.is_checked() != w.active {
                 item.set_checked(w.active);
             }
-        } else {
-            for item in self.window_items.drain(..) {
-                let _ = menu.remove(&item);
-            }
-            for w in &windows {
-                let item = CheckMenuItem::with_id(format!("{WINDOW_ITEM}{}", w.doc), w.label(), true, w.active, None);
-                let _ = menu.append(&item);
-                self.window_items.push(item);
-            }
         }
-        self.windows = windows;
     }
 
     pub fn poll(&mut self, app: &mut SheetApp, ctx: &egui::Context) {
diff --git a/crates/ui-egui/src/editor.rs b/crates/ui-egui/src/editor.rs
index eeeaf12da..3f23e8bed 100644
--- a/crates/ui-egui/src/editor.rs
+++ b/crates/ui-egui/src/editor.rs
@@ -45,11 +45,15 @@ pub struct EditState {
     pub completion: Option<String>,
     /// Move the caret to the end on the next frame.
     pub caret_to_end: bool,
+    /// The cell's text when an F2-style edit began. Committing it unchanged leaves the cell alone
+    /// (no undo step, the workbook stays clean). `None` for an edit started by typing.
+    pub original: Option<String>,
 }
 
 impl EditState {
     pub fn new(doc: u64, sheet: usize, cell: CellRef, text: String, enter_mode: bool, from_formula_bar: bool) -> EditState {
         let caret = text.chars().count();
+        let original = (!enter_mode).then(|| text.clone());
         EditState {
             doc,
             sheet,
@@ -68,6 +72,7 @@ impl EditState {
             sync_caret: true,
             caret_to_end: true,
             completion: None,
+            original,
         }
     }
 
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 001abaad5..cc478168e 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -412,7 +412,7 @@ impl SheetApp {
             || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
             || (id == "view.switchWindows" && params.get("doc").is_some_and(|d| !d.is_null()));
         if id.starts_with("file.") || switches_window {
-            self.settle_drafts();
+            self.settle_drafts()?;
         }
         if matches!(id, "file.save" | "file.saveAs" | "file.saveBytes") {
             self.store_view_state();
@@ -575,8 +575,11 @@ impl SheetApp {
             self.open_switch_windows = true;
             return;
         }
-        if let Err(e) = self.run(id, params) {
-            self.alert(e);
+        match self.run(id, params) {
+            // A refused cell draft already shows its own message (with the rule's title).
+            Err(e) if self.message.as_ref().is_some_and(|(_, m)| *m == e) => {}
+            Err(e) => self.alert(e),
+            Ok(_) => {}
         }
     }
 
@@ -1013,8 +1016,8 @@ impl SheetApp {
     /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
     ///
     /// The draft goes into the workbook it was typed in. If another workbook is showing, that
-    /// workbook stays active afterwards, and a draft its own workbook refuses (validation, a bad
-    /// formula) is dropped rather than left open over the wrong grid.
+    /// workbook stays active afterwards; a draft its own workbook refuses (validation, a bad
+    /// formula) brings that workbook back to the front with the draft still open.
     pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
         let Some(doc) = self.editor.as_ref().map(|ed| ed.doc) else { return true };
         let shown = self.session.active().map(|d| d.uid);
@@ -1028,25 +1031,21 @@ impl SheetApp {
         let back = self.session.active_index();
         self.session.set_active(owner);
         if !self.commit_edit_here(dr, dc, array, fill_selection) {
-            self.cancel_edit();
+            // Refused: its workbook stays in front with the draft open and the reason shown.
+            return false;
         }
         self.session.set_active(back);
         true
     }
 
-    /// Settles the cell and text-box drafts before a command that can show another workbook or
-    /// write this one to a file: each is committed as Enter would, or dropped when it can't be
-    /// (the refusal is still reported), so a draft never lands in another workbook.
-    fn settle_drafts(&mut self) {
+    /// Commits the cell and text-box drafts, as Enter would, before a command that can show
+    /// another workbook or write this one to a file, so a draft never lands in another workbook.
+    /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
+    fn settle_drafts(&mut self) -> Result<(), String> {
         if !self.commit_edit(0, 0, false, false) {
-            self.cancel_edit();
-        }
-        if let Err(e) = self.commit_text_box_edit() {
-            self.cancel_text_box_edit();
-            if self.message.is_none() {
-                self.message = Some(("Text Box".into(), clean_error(&e)));
-            }
+            return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
         }
+        self.commit_text_box_edit()
     }
 
     fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
@@ -1056,6 +1055,13 @@ impl SheetApp {
             Some(full) if full.to_lowercase().starts_with(&ed.text.to_lowercase()) => full.clone(),
             _ => ed.text.clone(),
         };
+        // F2 then Enter (or a file command) on an untouched draft: nothing to write.
+        if !fill_selection && !array && ed.original.as_ref() == Some(&text) {
+            if dr != 0 || dc != 0 {
+                self.move_after_enter(dr, dc);
+            }
+            return true;
+        }
         let text = match self.session.active().map(|d| formula_locale::canonical(&text, ed.locale, &d.wb, ed.sheet, ed.cell)) {
             Some(Ok(text)) => text,
             Some(Err(error)) => {
@@ -1355,7 +1361,8 @@ impl SheetApp {
         let t0 = now_ms();
         text_box::before_ui(self, &ctx);
         // Another workbook came forward without going through a command (which settles drafts
-        // first): the draft goes into its own workbook instead of floating over this one.
+        // first): the draft goes into its own workbook instead of floating over this one. If that
+        // workbook refuses it, it comes back to the front with the draft open.
         if self.editor.as_ref().is_some_and(|ed| self.session.active().map(|d| d.uid) != Some(ed.doc)) {
             self.commit_edit(0, 0, false, false);
         }
diff --git a/crates/ui-egui/tests/file_menu.rs b/crates/ui-egui/tests/file_menu.rs
index 415e09902..5c447cb63 100644
--- a/crates/ui-egui/tests/file_menu.rs
+++ b/crates/ui-egui/tests/file_menu.rs
@@ -351,19 +351,49 @@ fn new_workbook_keeps_the_typed_cell_in_the_first_and_switch_windows_brings_it_b
 }
 
 #[test]
-fn a_draft_its_workbook_refuses_is_dropped_when_switching_away() {
+fn a_draft_its_workbook_refuses_stops_the_switch_and_stays_open() {
     let mut h = harness(Services::default());
     let book1 = typing_in_book1_then_new(&mut h);
+    let book2 = h.state().session.doc().unwrap().uid;
     h.state_mut().session.execute("data.validation", serde_json::json!({"range": "A1", "type": "list", "formula1": "\"Red,Green\""})).unwrap();
     h.input_mut().events.push(egui::Event::Text("Purple".into()));
     h.run_steps(2);
-    assert!(h.state().editor.is_some());
     h.state_mut().run_or_alert("view.switchWindows", serde_json::json!({"doc": book1}));
     h.run_steps(2);
-    assert!(h.state().editor.is_none());
-    assert_eq!(h.state().session.doc().unwrap().uid, book1, "the switch still happens");
+    assert_eq!(h.state().session.doc().unwrap().uid, book2, "the switch doesn't happen");
+    assert_eq!(h.state().editor.as_ref().map(|ed| ed.text.as_str()), Some("Purple"), "the draft stays open to fix");
     assert_eq!(a1(&h, 1), Value::Empty, "Book2 is unchanged");
     assert!(h.state().message.is_some(), "the refusal is reported");
+
+    // Esc drops the draft; then the switch goes through.
+    h.state_mut().message = None;
+    h.state_mut().cancel_edit();
+    h.state_mut().run_or_alert("view.switchWindows", serde_json::json!({"doc": book1}));
+    h.run_steps(2);
+    assert_eq!(h.state().session.doc().unwrap().uid, book1);
+    assert!(h.state().message.is_none());
+}
+
+#[test]
+fn an_untouched_f2_draft_leaves_the_workbook_clean_on_a_file_command() {
+    let dir = std::env::temp_dir().join(format!("gridcraft-f2-draft-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Book.xlsx").to_string_lossy().into_owned();
+    let mut h = harness(Services::default());
+    h.state_mut().run("cell.set", serde_json::json!({"cell": "A1", "input": "=1+2"})).unwrap();
+    h.state_mut().run("file.save", serde_json::json!({"path": &path})).unwrap();
+    h.run_steps(2);
+    let undo = h.state().session.doc().unwrap().undo.len();
+    h.key_press(egui::Key::F2);
+    h.run_steps(2);
+    assert_eq!(h.state().editor.as_ref().map(|ed| ed.text.as_str()), Some("=1+2"));
+    h.state_mut().run_or_alert("file.new", serde_json::json!({}));
+    h.run_steps(2);
+    assert!(h.state().editor.is_none());
+    let book1 = &h.state().session.documents()[0];
+    assert!(!book1.is_dirty(), "nothing was typed, so nothing changed");
+    assert_eq!(book1.undo.len(), undo, "and no undo step was added");
+    let _ = std::fs::remove_dir_all(&dir);
 }
 
 fn pdf_picker_harness(dir: &std::path::Path) -> (Arc<Mutex<Vec<String>>>, egui_kittest::Harness<'static, SheetApp>) {

From 4bafd4e8ee5f38b068720156b9057eed5ed82a80 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 05:12:23 +0000
Subject: [PATCH 03/76] Docs: Switch Windows and drafts kept in their workbook
 (UI parity, progress log)

---
 ROADMAP.md        | 4 +++-
 docs/ui-parity.md | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 2e04e9123..9617ef1e6 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-21 · **Change:** minor (Page Setup paper sizes: JIS B4/B5/B6, the Japanese postcards and envelopes, and A6; long flat operator chains up to Excel's formula limit) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save) · **Target:** Microsoft Excel (Microsoft 365)
 
 GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX
 is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web.
@@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | What landed |
 |---|---|
+| 2026-10-22 | Typing in a cell and then choosing File › New no longer strands the first workbook: the entry is committed into its own workbook before any File or window command (a refused entry stays open and stops the command), View › Switch Windows and the macOS Window menu list the open workbooks with unsaved markers, `view.switchWindows {doc}` switches by a stable workbook id, and the macOS Quit item asks about unsaved workbooks |
 | 2026-10-21 | Page Setup paper sizes match Japanese Excel: `B4`/`B5`/`B6` are the JIS sizes (ISO B4/B5/B6 stay reachable by name), so a Japanese B5 worksheet prints at 182×257 mm; Japanese Postcard (100×148 mm), Double Postcard (148×200 mm), Envelope #3/#4 (120×235/90×205 mm), Kaku #2/#3 (240×332/216×277 mm) and A6 are added, both sizes reach the PDF page (`file.exportPdf`/`file.print` MediaBox) and the size survives an XLSX round-trip; the Page Layout Size menu lists them. `B4`/`B5` used to be the ISO sizes, which is changed here |
 | 2026-10-20 | Japanese interface catalog covers every key the Brazilian Portuguese catalog translates: the 398-label shared core plus 545 dialog, message, Backstage and menu strings (943 total, ~43% of ~2,200). A test parses `pt.rs`'s source, so the two catalogs stay in step |
 | 2026-10-20 | Interface translated into Dutch (518 labels: ribbon, context menus, File view, dialog titles, Options); `nl`, `nl-NL`, `nl-BE` locale tags resolve to Dutch |
@@ -220,6 +221,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | Progress log: drafts stay in their workbook, Switch Windows, macOS Quit asks to save |
 | 2026-10-21 | minor | Page Setup paper sizes: JIS B4/B5/B6 (ISO by name), Japanese postcards and envelopes, A6; PDF page size follows, XLSX round-trips |
 | 2026-10-20 | minor | Dutch (nl) listed under other shipped languages; progress log row |
 | 2026-10-19 | minor | Progress log: long flat operator chains (#916) |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 07797d70d..b70682ac3 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-21 · **Change:** minor (Esc and Enter close a data validation alert over the cell editor; Ctrl+Enter fill gives each cell the automatic number format typing gives it; keytip letters typed with Alt held, #1846; Number Stored as Text indicator and Convert to Number) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (Switch Windows lists the open workbooks; a cell being typed stays in its own workbook through New, Open and window switches; macOS Quit asks about unsaved workbooks) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md).
 **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured
@@ -34,6 +34,7 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes
 | Dark mode, system appearance | yes | yes | done (10-09) |
 | Page Layout view (paper view with rulers and header editing) | yes | yes (#329, 10-11): per-sheet view saved in XLSX, pages with margins and gaps on the print pagination, "Click to add data" pages, rulers (inches or centimetres), headers and footers drawn and edited in place with a Header & Footer tab | margins drag on the rulers (#792, with header and footer margins); header/footer pictures, Different First Page / Odd & Even missing (1–3 h) |
 | Multiple windows per workbook | yes | no (#162) | see [hardware-parity.md](hardware-parity.md) |
+| Switch Windows, unsaved workbooks on quit | yes | yes (10-22): View › Switch Windows and the macOS Window menu list the open workbooks (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {doc}`); a cell being typed is entered into its own workbook before New, Open, Close, Save, Print and window switches, and a refused entry stays open and stops the command; quitting (window close, Cmd+Q, the macOS Quit item) asks Save / Don't Save / Cancel for each unsaved workbook | one OS window for all workbooks (#162) |
 
 ## Grid interaction
 
@@ -176,6 +177,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | New workbook no longer loses the first one: the cell being typed is entered into its own workbook before any File or window command (an entry the workbook refuses stays open and the command doesn't run; an untouched F2 draft changes nothing), the editor is tied to its workbook, View › Switch Windows and the macOS Window menu list the open workbooks, and the macOS Quit item asks about unsaved workbooks like the close button |
 | 2026-10-21 | minor | Background error checking, first part (#1994): a constant whose text would be a number if typed (signs, thousands, currency, percent, exponent, parenthesised negative) gets Excel's green corner triangle; the active cell then shows a warning button whose menu names the problem and offers Convert to Number for the selection (`formulas.convertToNumber`). Dates, times and fractions kept as text and formula results are not flagged, as in Excel |
 | 2026-10-21 | minor | Paste Special laid out as Excel's: Paste and Operation options each in two columns inside a frame, Skip blanks and Transpose side by side, Paste Link as a button that pastes references at once; labels translated (the generic form didn't translate them) and the window no longer runs past the screen |
 | 2026-10-21 | minor | Form dialogs (conditional-format quick rules, New Name, Remove Duplicates, Text to Columns and every other `Dialog::form`) fit their content: OK and Cancel sit in a row under the last field instead of a right-to-left layout that took the screen's whole height and left the buttons floating halfway down |

From 45d1d1acc0dc87d0104d0634c42deae009721775 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 14:50:53 +0000
Subject: [PATCH 04/76] G2: windows on workbooks in the engine; New Window
 shares the workbook

Session keeps a window list (stable ids, per-window selection, active sheet
and per-sheet selections swapped into the workbook without dirtying it)
in place of the index-based hidden list and the copying New Window.
Titles read Name:1 / Name:2 for a workbook with several windows.
File > Close closes one window of several; window.close, window.list and
window ids for window.activate, view.switchWindows, view.hideWindow and
view.unhideWindow. Control channel and MCP tools take window/doc ids;
scroll positions and cell drafts belong to their window.
---
 ROADMAP.md                                   |   4 +-
 apps/gridcraft/src/native_menu.rs            |  16 +-
 crates/engine/src/cmd/extra.rs               |  72 ++--
 crates/engine/src/cmd/file.rs                |  50 ++-
 crates/engine/src/lib.rs                     |  39 ++-
 crates/engine/src/tests.rs                   | 114 ++++++-
 crates/engine/src/windows.rs                 | 342 +++++++++++++++++++
 crates/engine/tests/command_sequence_fuzz.rs |   3 +-
 crates/mcp/src/headless.rs                   |  24 +-
 crates/mcp/src/tests.rs                      |  29 ++
 crates/mcp/src/tools.rs                      |  64 +++-
 crates/ui-egui/src/control.rs                |  44 ++-
 crates/ui-egui/src/dialogs.rs                |   4 +-
 crates/ui-egui/src/editor.rs                 |   4 +
 crates/ui-egui/src/lib.rs                    |  84 +++--
 crates/ui-egui/src/ribbon.rs                 |   2 +-
 crates/ui-egui/tests/file_menu.rs            |  62 ++++
 docs/control-protocol.md                     |  20 +-
 docs/mcp.md                                  |   5 +
 docs/ui-parity.md                            |   5 +-
 20 files changed, 872 insertions(+), 115 deletions(-)
 create mode 100644 crates/engine/src/windows.rs

diff --git a/ROADMAP.md b/ROADMAP.md
index 9617ef1e6..bf25cc3a9 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save; New Window shares the workbook) · **Target:** Microsoft Excel (Microsoft 365)
 
 GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX
 is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web.
@@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | What landed |
 |---|---|
+| 2026-10-22 | View › New Window opens a second window on the same workbook (it used to open a copy whose Save overwrote the original): each window has its own selection, active sheet and scroll, titles read "Book1:1" / "Book1:2", and Switch Windows, Hide, Unhide and Close act per window. The control channel, CLI `send` and MCP tools take an optional `window` or `doc` id and default to the active window; `window.list` (MCP `list_windows`) lists the windows |
 | 2026-10-22 | Typing in a cell and then choosing File › New no longer strands the first workbook: the entry is committed into its own workbook before any File or window command (a refused entry stays open and stops the command), View › Switch Windows and the macOS Window menu list the open workbooks with unsaved markers, `view.switchWindows {doc}` switches by a stable workbook id, and the macOS Quit item asks about unsaved workbooks |
 | 2026-10-21 | Page Setup paper sizes match Japanese Excel: `B4`/`B5`/`B6` are the JIS sizes (ISO B4/B5/B6 stay reachable by name), so a Japanese B5 worksheet prints at 182×257 mm; Japanese Postcard (100×148 mm), Double Postcard (148×200 mm), Envelope #3/#4 (120×235/90×205 mm), Kaku #2/#3 (240×332/216×277 mm) and A6 are added, both sizes reach the PDF page (`file.exportPdf`/`file.print` MediaBox) and the size survives an XLSX round-trip; the Page Layout Size menu lists them. `B4`/`B5` used to be the ISO sizes, which is changed here |
 | 2026-10-20 | Japanese interface catalog covers every key the Brazilian Portuguese catalog translates: the 398-label shared core plus 545 dialog, message, Backstage and menu strings (943 total, ~43% of ~2,200). A test parses `pt.rs`'s source, so the two catalogs stay in step |
@@ -221,6 +222,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | Progress log: New Window shares the workbook; window ids for scripts and MCP |
 | 2026-10-22 | minor | Progress log: drafts stay in their workbook, Switch Windows, macOS Quit asks to save |
 | 2026-10-21 | minor | Page Setup paper sizes: JIS B4/B5/B6 (ISO by name), Japanese postcards and envelopes, A6; PDF page size follows, XLSX round-trips |
 | 2026-10-20 | minor | Dutch (nl) listed under other shipped languages; progress log row |
diff --git a/apps/gridcraft/src/native_menu.rs b/apps/gridcraft/src/native_menu.rs
index 877c82fd8..826a12b31 100644
--- a/apps/gridcraft/src/native_menu.rs
+++ b/apps/gridcraft/src/native_menu.rs
@@ -195,13 +195,13 @@ pub struct NativeMenu {
     events: Receiver<MenuEvent>,
     theme_items: Vec<(&'static str, CheckMenuItem)>,
     window_menu: Option<Submenu>,
-    /// The Window menu's workbook items and what they last showed.
+    /// The Window menu's window items and what they last showed.
     window_items: Vec<CheckMenuItem>,
     windows: Vec<OpenWindow>,
 }
 
 /// Menu id of the Window menu item that brings workbook `doc` forward.
-const WINDOW_ITEM: &str = "window:doc:";
+const WINDOW_ITEM: &str = "window:id:";
 
 /// The Quit item: closing the window asks about unsaved workbooks first, which AppKit's own
 /// Quit (terminate:) would skip.
@@ -279,15 +279,15 @@ impl NativeMenu {
         NativeMenu { _menu: menu, events: rx, theme_items, window_menu, window_items: Vec::new(), windows: Vec::new() }
     }
 
-    /// Keeps the Window menu's list of open workbooks (title, unsaved bullet, active check) in
+    /// Keeps the Window menu's list of open windows (title, unsaved bullet, active check) in
     /// step with the session.
     fn sync_windows(&mut self, app: &SheetApp) {
         let windows = app.open_windows();
         if windows != self.windows
             && let Some(menu) = &self.window_menu
         {
-            let same_docs = windows.len() == self.windows.len() && windows.iter().zip(&self.windows).all(|(a, b)| a.doc == b.doc);
-            if same_docs {
+            let same_windows = windows.len() == self.windows.len() && windows.iter().zip(&self.windows).all(|(a, b)| a.window == b.window);
+            if same_windows {
                 for (item, w) in self.window_items.iter().zip(&windows) {
                     item.set_text(w.label());
                 }
@@ -296,7 +296,7 @@ impl NativeMenu {
                     let _ = menu.remove(&item);
                 }
                 for w in &windows {
-                    let item = CheckMenuItem::with_id(format!("{WINDOW_ITEM}{}", w.doc), w.label(), true, w.active, None);
+                    let item = CheckMenuItem::with_id(format!("{WINDOW_ITEM}{}", w.window), w.label(), true, w.active, None);
                     let _ = menu.append(&item);
                     self.window_items.push(item);
                 }
@@ -318,8 +318,8 @@ impl NativeMenu {
                 ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                 continue;
             }
-            if let Some(doc) = id.strip_prefix(WINDOW_ITEM).and_then(|d| d.parse::<u64>().ok()) {
-                app.run_or_alert("view.switchWindows", json!({"doc": doc}));
+            if let Some(window) = id.strip_prefix(WINDOW_ITEM).and_then(|w| w.parse::<u64>().ok()) {
+                app.run_or_alert("view.switchWindows", json!({"window": window}));
                 continue;
             }
             // Text selection belongs to the inline editor, not the worksheet clipboard/undo.
diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index debb62eeb..395345543 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -141,16 +141,16 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         cmd!(noundo "view.customViews", "Custom Views…", ["View", "Workbook Views"], None, "{save?: name, show?: name, delete?: name} → list", has_doc, custom_views),
         cmd!(noundo "view.split", "Split", ["View", "Window"], None, "{} (toggles a split at the active cell; shown as frozen panes in this version)", has_doc, split),
-        cmd!(noundo "view.newWindow", "New Window", ["View", "Window"], None, "{} opens a second window on the same workbook (a linked copy)", has_doc, new_window),
+        cmd!(noundo "view.newWindow", "New Window", ["View", "Window"], None, "{} → {window, doc, title}: opens another window on the active workbook (the same workbook: saving from either window saves it)", has_doc, new_window),
         cmd!(noundo "view.arrangeAll", "Arrange All", ["View", "Window"], None, "{}", has_doc, |_, _| ok()),
-        cmd!(noundo "view.hideWindow", "Hide", ["View", "Window"], None, "{}", has_doc, hide_window),
-        cmd!(noundo "view.unhideWindow", "Unhide…", ["View", "Window"], None, "{index?}", has_doc, unhide_window),
+        cmd!(noundo "view.hideWindow", "Hide", ["View", "Window"], None, "{window?, doc?} (the active window by default)", has_doc, hide_window),
+        cmd!(noundo "view.unhideWindow", "Unhide…", ["View", "Window"], None, "{window?, doc?, index?} (the most recently hidden window by default)", has_doc, unhide_window),
         cmd!(
             noundo "view.switchWindows",
             "Switch Windows",
             ["View", "Window"],
             None,
-            "{doc?} → open workbooks [{index, doc, title, dirty, active, hidden}]; with `doc` (a workbook's `doc` id from the list) makes that workbook active first",
+            "{window?, doc?} → open windows [{window, doc, index, title, dirty, active, hidden}]; with `window` (an id from the list), or `doc` (a workbook id: its most recent window), shows and activates that window first",
             always,
             switch_windows
         ),
@@ -790,54 +790,46 @@ fn split(s: &mut Session, _: &Json) -> Result<Json> {
 }
 
 fn new_window(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc()?.clone();
-    let mut copy = crate::DocState::new((*d.wb).clone(), d.path.clone(), format!("{}:2", d.display_title()));
-    copy.selection = d.selection.clone();
-    let i = s.add_document(copy);
-    Ok(json!({"index": i}))
+    let id = s.new_window()?;
+    let doc = s.window(id).map(|w| w.doc_uid);
+    Ok(json!({"window": id, "doc": doc, "title": s.window_title(id)}))
 }
 
-fn hide_window(s: &mut Session, _: &Json) -> Result<Json> {
-    s.hidden_windows.push(s.active_index());
-    let n = s.documents().len();
-    if n > 1 {
-        let next = (0..n).find(|i| !s.hidden_windows.contains(i)).unwrap_or(0);
-        s.set_active(next);
-    }
+/// The window a window command names: `window` (an id), else `doc` (a workbook id: its most
+/// recent window), else the active window.
+pub(crate) fn window_param(s: &Session, cmd: &str, p: &Json) -> Result<u64> {
+    let t = crate::Target::from_json(p).map_err(|e| bad(cmd, e.to_string()))?;
+    s.target_window(t).map_err(|e| bad(cmd, e.to_string()))
+}
+
+fn hide_window(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = window_param(s, "view.hideWindow", p)?;
+    s.hide_window(id);
     ok()
 }
 
 fn unhide_window(s: &mut Session, p: &Json) -> Result<Json> {
-    let i = u32_param(p, "index").map(|v| v as usize).or_else(|| s.hidden_windows.last().copied());
-    if let Some(i) = i {
-        s.hidden_windows.retain(|x| *x != i);
-        s.set_active(i);
+    let id = if p.get("window").is_some_and(|v| !v.is_null()) || p.get("doc").is_some_and(|v| !v.is_null()) {
+        Some(window_param(s, "view.unhideWindow", p)?)
+    } else if let Some(i) = u32_param(p, "index") {
+        // A workbook's position in the document list.
+        let uid = s.documents().get(i as usize).map(|d| d.uid).ok_or_else(|| bad("view.unhideWindow", "no such window"))?;
+        s.windows().iter().filter(|w| w.doc_uid == uid && w.hidden).map(|w| w.id).next_back().or_else(|| s.doc_window(uid))
+    } else {
+        s.last_hidden_window()
+    };
+    if let Some(id) = id {
+        s.unhide_window(id);
     }
     ok()
 }
 
 fn switch_windows(s: &mut Session, p: &Json) -> Result<Json> {
-    if let Some(doc) = p.get("doc").filter(|v| !v.is_null()) {
-        let i = doc.as_u64().and_then(|uid| s.document_index(uid)).ok_or_else(|| bad("view.switchWindows", "no open workbook has that `doc` id"))?;
-        s.hidden_windows.retain(|x| *x != i);
-        s.set_active(i);
+    if p.get("window").is_some_and(|v| !v.is_null()) || p.get("doc").is_some_and(|v| !v.is_null()) {
+        let id = window_param(s, "view.switchWindows", p)?;
+        s.unhide_window(id);
     }
-    Ok(Json::Array(
-        s.documents()
-            .iter()
-            .enumerate()
-            .map(|(i, d)| {
-                json!({
-                    "index": i,
-                    "doc": d.uid,
-                    "title": d.display_title(),
-                    "dirty": d.is_dirty(),
-                    "active": i == s.active_index(),
-                    "hidden": s.hidden_windows.contains(&i),
-                })
-            })
-            .collect(),
-    ))
+    Ok(s.window_list())
 }
 
 fn table_resize(s: &mut Session, p: &Json) -> Result<Json> {
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index a61c6298f..1f50b908b 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -12,7 +12,7 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "file.save", "Save", ["File"], Some("Cmd+S"), "{path?} (xlsx by default; .csv/.tsv/.json/.html/.pdf by extension)", has_doc, save),
         cmd!(noundo "file.saveAs", "Save As…", ["File"], Some("Cmd+Shift+S"), "{path} (.xlsx, .csv, .tsv, .json, .html, or .pdf: a PDF of the active sheet)", has_doc, save_as),
         cmd!(query "file.saveBytes", "Encode Workbook", [], None, "{format?: xlsx|csv|tsv|json|html} → {base64}", has_doc, save_bytes),
-        cmd!(noundo "file.close", "Close", ["File"], Some("Cmd+W"), "{force?: bool}", has_doc, close),
+        cmd!(noundo "file.close", "Close", ["File"], Some("Cmd+W"), "{force?: bool, document?: bool} (closes the active window, or with `document` the workbook and all its windows; the workbook closes with its last window)", has_doc, close),
         cmd!(noundo "file.exportCsv", "Export as CSV", ["File", "Export"], None, "{path, sheet?}", has_doc, |s, p| export(s, p, "csv")),
         cmd!(noundo "file.exportHtml", "Save as Web Page", ["File", "Export"], None, "{path}", has_doc, |s, p| export(s, p, "html")),
         cmd!("file.properties", "Properties", ["File"], None, "{title?, subject?, author?, company?, keywords?, description?}", has_doc, properties),
@@ -25,7 +25,9 @@ pub fn specs() -> Vec<CommandSpec> {
             always,
             options
         ),
-        cmd!(noundo "window.activate", "Switch Window", ["Window"], None, "{index}", has_doc, activate_window),
+        cmd!(noundo "window.activate", "Switch Window", ["Window"], None, "{window} | {doc} | {index} (a window id, a workbook id, or the workbook's position in the list)", has_doc, activate_window),
+        cmd!(noundo "window.close", "Close Window", ["Window"], None, "{window?, doc?, force?: bool} → {closed, document}: closes a window (the active one by default); its workbook closes with its last window, asking first when it has unsaved changes unless `force`", has_doc, close_window),
+        cmd!(query "window.list", "Windows", ["Window"], None, "{} → [{window, doc, index, title, dirty, active, hidden}]", always, |s, _| Ok(s.window_list())),
     ]
 }
 
@@ -159,7 +161,16 @@ fn save_bytes(s: &mut Session, p: &Json) -> Result<Json> {
     Ok(json!({"name": name, "base64": crate::io::base64_encode(&bytes), "bytes": bytes.len()}))
 }
 
+/// File › Close closes the active window; the workbook closes with its last window.
 fn close(s: &mut Session, p: &Json) -> Result<Json> {
+    if !bool_param(p, "document").unwrap_or(false)
+        && let Some(id) = s.active_window()
+        && let Some(doc) = s.window(id).map(|w| w.doc_uid)
+        && s.windows().iter().filter(|w| w.doc_uid == doc).count() > 1
+    {
+        s.close_window(id);
+        return Ok(json!({"closed": true, "document": false}));
+    }
     let force = bool_param(p, "force").unwrap_or(false);
     let d = s.doc()?;
     if d.is_dirty() && !force {
@@ -220,10 +231,35 @@ fn options(s: &mut Session, _: &Json) -> Result<Json> {
 }
 
 fn activate_window(s: &mut Session, p: &Json) -> Result<Json> {
-    let i = u32_param(p, "index").ok_or_else(|| bad("window.activate", "missing `index`"))? as usize;
-    if i >= s.documents().len() {
-        return Err(bad("window.activate", "no such window"));
-    }
-    s.set_active(i);
+    let id = match u32_param(p, "index").filter(|_| p.get("window").is_none_or(Json::is_null) && p.get("doc").is_none_or(Json::is_null)) {
+        Some(i) => {
+            let uid = s.documents().get(i as usize).map(|d| d.uid).ok_or_else(|| bad("window.activate", "no such window"))?;
+            s.doc_window(uid).ok_or_else(|| bad("window.activate", "no such window"))?
+        }
+        None if p.get("window").is_none_or(Json::is_null) && p.get("doc").is_none_or(Json::is_null) => {
+            return Err(bad("window.activate", "missing `window`"));
+        }
+        None => super::extra::window_param(s, "window.activate", p)?,
+    };
+    s.unhide_window(id);
     ok()
 }
+
+fn close_window(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = super::extra::window_param(s, "window.close", p)?;
+    let doc = s.window(id).map(|w| w.doc_uid).unwrap_or_default();
+    if s.windows().iter().filter(|w| w.doc_uid == doc).count() > 1 {
+        s.close_window(id);
+        return Ok(json!({"closed": true, "document": false}));
+    }
+    let force = bool_param(p, "force").unwrap_or(false);
+    let d = s.documents().iter().find(|d| d.uid == doc).ok_or(crate::EngineError::NoDocument)?;
+    if d.is_dirty() && !force {
+        let title = d.display_title();
+        s.activate_window(id);
+        s.ui_requests.push(crate::UiRequest::Dialog("saveChanges".into(), json!({"title": title})));
+        return Ok(json!({"closed": false, "dirty": true}));
+    }
+    s.close_window(id);
+    Ok(json!({"closed": true, "document": true}))
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index aeeaa9bdb..74924d542 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -22,6 +22,7 @@ pub mod pivot_calc;
 pub mod sample;
 pub mod selection;
 pub mod tables;
+pub mod windows;
 
 use std::sync::Arc;
 
@@ -38,6 +39,7 @@ pub use gridcraft_formula as formula;
 pub use gridcraft_model as model;
 pub use gridcraft_numfmt as numfmt;
 pub use selection::Selection;
+pub use windows::{Target, TargetGuard, WindowState, WindowView};
 
 #[derive(Debug, thiserror::Error)]
 pub enum EngineError {
@@ -286,7 +288,15 @@ pub type TextWidth = Arc<dyn Fn(&str, &model::Font, bool) -> f32 + Send + Sync>;
 #[derive(Default)]
 pub struct Session {
     docs: Vec<DocState>,
+    /// Index in `docs` of the active window's workbook.
     active: usize,
+    /// Windows on the open workbooks ([`windows`]); every workbook has at least one.
+    windows: Vec<WindowState>,
+    active_window: Option<u64>,
+    /// Last window id handed out.
+    next_window: u64,
+    /// Window activation counter (most recently used order).
+    activation: u64,
     pub clipboard: Option<Clipboard>,
     pub prefs: Prefs,
     pub mode: Mode,
@@ -304,8 +314,6 @@ pub struct Session {
     pub hide_ruler: bool,
     /// Journal position where action recording started.
     pub recording: Option<usize>,
-    /// Windows hidden with View › Hide.
-    pub hidden_windows: Vec<usize>,
     /// Draw tab tool: "" (select), "pen" or "eraser"; pen colour and width.
     pub draw_tool: String,
     pub draw_color: String,
@@ -330,9 +338,15 @@ impl Session {
     pub fn active_index(&self) -> usize {
         self.active
     }
+    /// Makes the workbook at `i` active, in its most recently active window (unless the active
+    /// window already shows it).
     pub fn set_active(&mut self, i: usize) {
-        if i < self.docs.len() {
-            self.active = i;
+        let Some(uid) = self.docs.get(i).map(|d| d.uid) else { return };
+        if self.active == i && self.active_window.and_then(|w| self.window(w)).is_some_and(|w| w.doc_uid == uid) {
+            return;
+        }
+        if let Some(w) = self.doc_window(uid) {
+            self.activate_window(w);
         }
     }
     pub fn active(&self) -> Option<&DocState> {
@@ -351,16 +365,23 @@ impl Session {
     pub fn doc_mut(&mut self) -> Result<&mut DocState> {
         self.active_mut().ok_or(EngineError::NoDocument)
     }
+    /// Opens a workbook in a new window, which becomes the active one.
     pub fn add_document(&mut self, d: DocState) -> usize {
+        let uid = d.uid;
         self.docs.push(d);
-        self.active = self.docs.len() - 1;
-        self.active
+        let w = self.push_window(uid);
+        self.activate_window(w);
+        self.docs.len() - 1
     }
+    /// Closes a workbook and its windows; the most recently active remaining window comes forward.
     pub fn close_document(&mut self, i: usize) {
         if i < self.docs.len() {
-            self.docs.remove(i);
-            if self.active >= self.docs.len() {
-                self.active = self.docs.len().saturating_sub(1);
+            let d = self.docs.remove(i);
+            self.windows.retain(|w| w.doc_uid != d.uid);
+            if self.active_window.is_some_and(|w| self.window(w).is_none()) {
+                self.activate_recent();
+            } else if let Some(di) = self.active_window.and_then(|w| self.window(w)).and_then(|w| self.document_index(w.doc_uid)) {
+                self.active = di;
             }
         }
     }
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 07a32209f..6f7f7f4bc 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -2501,7 +2501,10 @@ fn every_command_survives_empty_params() {
     let mut s = Session::new();
     s.execute("file.new", json!({"sample": "sales"})).unwrap();
     for spec in crate::command_specs() {
-        if matches!(spec.id, "file.close" | "file.open" | "file.save" | "file.saveAs" | "file.exportCsv" | "file.exportHtml" | "insert.picture") {
+        if matches!(
+            spec.id,
+            "file.close" | "window.close" | "file.open" | "file.save" | "file.saveAs" | "file.exportCsv" | "file.exportHtml" | "insert.picture"
+        ) {
             continue;
         }
         let _ = s.execute(spec.id, json!({}));
@@ -4490,3 +4493,112 @@ fn switch_windows_lists_workbooks_by_stable_id_and_switches_to_one() {
     assert!(s.execute("view.switchWindows", json!({"doc": "Book1"})).is_err());
     assert_eq!(s.doc().unwrap().uid, book1, "a bad id leaves the active workbook alone");
 }
+
+#[test]
+fn new_window_shares_the_workbook_and_closes_window_by_window() {
+    let mut s = s();
+    let book = s.doc().unwrap().uid;
+    assert_eq!(s.windows().len(), 1, "a new workbook opens in one window");
+    let first = s.active_window().unwrap();
+    assert_eq!(s.window_title(first).as_deref(), Some("Book1"));
+
+    let r = s.execute("view.newWindow", json!({})).unwrap();
+    let second = r["window"].as_u64().unwrap();
+    assert_eq!(s.documents().len(), 1, "no copy of the workbook");
+    assert_eq!((s.windows().len(), s.active_window()), (2, Some(second)));
+    assert_eq!(s.window_title(first).as_deref(), Some("Book1:1"));
+    assert_eq!(s.window_title(second).as_deref(), Some("Book1:2"));
+    assert!(!s.doc().unwrap().is_dirty());
+
+    // An edit in window 2 is in window 1's workbook, and saving from window 2 saves it.
+    s.execute("cell.set", json!({"cell": "A1", "input": "shared"})).unwrap();
+    let path = std::env::temp_dir().join(format!("gridcraft-windows-{}.xlsx", std::process::id()));
+    s.execute("file.save", json!({"path": path})).unwrap();
+    s.execute("window.activate", json!({"window": first})).unwrap();
+    assert_eq!((s.doc().unwrap().uid, v(&s, "A1")), (book, Value::text("shared")));
+    assert!(!s.doc().unwrap().is_dirty(), "saved from the other window");
+    assert_eq!(s.doc().unwrap().path.as_deref(), path.to_str());
+    let _ = std::fs::remove_file(&path);
+
+    // Closing one window keeps the workbook and renumbers the titles; the last one closes it.
+    s.execute("cell.set", json!({"cell": "A2", "input": "unsaved"})).unwrap();
+    let r = s.execute("file.close", json!({})).unwrap();
+    assert_eq!((r["closed"].as_bool(), r["document"].as_bool()), (Some(true), Some(false)), "no prompt for one of two windows");
+    assert_eq!((s.windows().len(), s.active_window()), (1, Some(second)));
+    assert_eq!(s.window_title(second).as_deref(), Some(s.doc().unwrap().display_title().as_str()));
+    let r = s.execute("window.close", json!({})).unwrap();
+    assert_eq!(r["closed"].as_bool(), Some(false), "the last window asks about unsaved changes");
+    assert_eq!(s.documents().len(), 1);
+    s.execute("window.close", json!({"force": true})).unwrap();
+    assert!(s.documents().is_empty() && s.windows().is_empty() && s.active_window().is_none());
+}
+
+#[test]
+fn switching_windows_swaps_their_views_without_dirtying_the_workbook() {
+    let mut s = s();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    let path = std::env::temp_dir().join(format!("gridcraft-window-views-{}.xlsx", std::process::id()));
+    s.execute("file.save", json!({"path": path})).unwrap();
+    let _ = std::fs::remove_file(&path);
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    s.execute("selection.set", json!({"range": "B2:C3"})).unwrap();
+    let first = s.active_window().unwrap();
+    let second = s.execute("view.newWindow", json!({})).unwrap()["window"].as_u64().unwrap();
+    s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
+    s.execute("selection.set", json!({"range": "D4"})).unwrap();
+    assert!(!s.doc().unwrap().is_dirty());
+
+    s.execute("window.activate", json!({"window": first})).unwrap();
+    let d = s.doc().unwrap();
+    assert_eq!((d.wb.active_sheet, d.selection.a1()), (0, "B2:C3".to_string()));
+    assert!(!d.is_dirty(), "a window's sheet and selection are not document changes");
+    s.execute("view.switchWindows", json!({"window": second})).unwrap();
+    let d = s.doc().unwrap();
+    assert_eq!((d.wb.active_sheet, d.selection.a1()), (1, "D4".to_string()));
+    assert!(!d.is_dirty());
+
+    // A routed command acts in its window and leaves the active one showing.
+    s.execute_in(crate::Target::Window(first), "cell.set", json!({"cell": "A1", "input": "in window 1"})).unwrap();
+    assert_eq!(s.active_window(), Some(second));
+    assert_eq!(s.doc().unwrap().wb.sheets[0].value(CellRef::parse("A1").unwrap()), Value::text("in window 1"));
+    assert_eq!(s.doc().unwrap().selection.a1(), "D4");
+}
+
+#[test]
+fn hide_unhide_and_switch_by_window_id() {
+    let mut s = s();
+    let book1 = s.doc().unwrap().uid;
+    let w1 = s.active_window().unwrap();
+    let w2 = s.execute("view.newWindow", json!({})).unwrap()["window"].as_u64().unwrap();
+    s.execute("file.new", json!({})).unwrap();
+    let w3 = s.active_window().unwrap();
+    s.execute("view.hideWindow", json!({})).unwrap();
+    assert_eq!(s.active_window(), Some(w2), "the most recent visible window comes forward");
+    let list = s.execute("window.list", json!({})).unwrap();
+    let rows = list.as_array().unwrap();
+    assert_eq!(rows.len(), 3);
+    assert_eq!((rows[0]["window"].as_u64(), rows[0]["title"].as_str(), rows[0]["doc"].as_u64()), (Some(w1), Some("Book1:1"), Some(book1)));
+    assert_eq!((rows[2]["title"].as_str(), rows[2]["hidden"].as_bool()), (Some("Book2"), Some(true)));
+    assert_eq!(rows[1]["active"].as_bool(), Some(true));
+    s.execute("view.unhideWindow", json!({})).unwrap();
+    assert_eq!(s.active_window(), Some(w3));
+    assert!(!s.window(w3).unwrap().hidden);
+    // A workbook id goes to that workbook's most recent window.
+    s.execute("view.switchWindows", json!({"doc": book1})).unwrap();
+    assert_eq!(s.active_window(), Some(w2));
+    assert!(s.execute("window.activate", json!({"window": 999})).is_err());
+    assert_eq!(s.active_window(), Some(w2));
+}
+
+#[test]
+fn open_replaces_an_untouched_blank_workbook_and_its_windows() {
+    let mut s = s();
+    s.execute("view.newWindow", json!({})).unwrap();
+    let path = std::env::temp_dir().join(format!("gridcraft-open-blank-{}.csv", std::process::id()));
+    std::fs::write(&path, "a,b\n1,2\n").unwrap();
+    s.execute("file.open", json!({"path": path})).unwrap();
+    let _ = std::fs::remove_file(&path);
+    assert_eq!(s.documents().len(), 1);
+    assert_eq!(s.windows().len(), 1, "the blank workbook's windows closed with it");
+    assert_eq!(s.windows()[0].doc_uid, s.doc().unwrap().uid);
+}
diff --git a/crates/engine/src/windows.rs b/crates/engine/src/windows.rs
new file mode 100644
index 000000000..8dcb92011
--- /dev/null
+++ b/crates/engine/src/windows.rs
@@ -0,0 +1,342 @@
+//! Windows on open workbooks.
+//!
+//! Every open workbook has one or more windows (View › New Window adds another on the same
+//! workbook). A window has its own selection, active sheet and per-sheet selections. The active
+//! window's view lives in its [`DocState`] (`selection`, `wb.active_sheet`, `sheet_selections`),
+//! where every command reads it; each other window keeps its view in [`WindowState`] until it is
+//! activated. Swapping a view in or out never makes the workbook dirty: per-window view state is
+//! not a document change.
+
+use serde_json::{Value as Json, json};
+
+use crate::{DocState, EngineError, Result, Selection, Session};
+
+/// The view state one window keeps while another window on its workbook is showing.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct WindowView {
+    pub selection: Selection,
+    pub active_sheet: usize,
+    /// The active sheet's name, so a sheet inserted, deleted or moved meanwhile in another
+    /// window still finds it.
+    pub sheet_name: String,
+    pub sheet_selections: Vec<Selection>,
+}
+
+/// One window on an open workbook.
+#[derive(Clone, Debug)]
+pub struct WindowState {
+    /// Identifies the window for the rest of the session; never reused.
+    pub id: u64,
+    /// The [`DocState::uid`] of the workbook it shows.
+    pub doc_uid: u64,
+    /// View › Hide.
+    pub hidden: bool,
+    /// `None` while this window's view is the one in the document (the active window, or the
+    /// workbook's most recently active window); exactly one window per workbook has `None`.
+    view: Option<WindowView>,
+    /// Activation order: higher was active more recently.
+    last_active: u64,
+}
+
+impl WindowView {
+    fn capture(d: &DocState) -> WindowView {
+        WindowView {
+            selection: d.selection.clone(),
+            active_sheet: d.wb.active_sheet,
+            sheet_name: d.wb.sheets.get(d.wb.active_sheet).map(|s| s.name.clone()).unwrap_or_default(),
+            sheet_selections: d.sheet_selections.clone(),
+        }
+    }
+
+    fn apply(self, d: &mut DocState) {
+        let sheets = &d.wb.sheets;
+        let at = if sheets.get(self.active_sheet).is_some_and(|s| s.name == self.sheet_name) {
+            self.active_sheet
+        } else {
+            sheets.iter().position(|s| s.name == self.sheet_name).unwrap_or(self.active_sheet)
+        };
+        let at = at.min(sheets.len().saturating_sub(1));
+        if d.wb.active_sheet != at {
+            let dirty = d.is_dirty();
+            std::sync::Arc::make_mut(&mut d.wb).active_sheet = at;
+            if !dirty {
+                d.saved = d.wb.clone();
+            }
+        }
+        d.selection = self.selection;
+        d.sheet_selections = self.sheet_selections;
+    }
+}
+
+/// Which window a command from a script or agent acts on.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Target {
+    /// The active window.
+    #[default]
+    Active,
+    /// A window by [`WindowState::id`].
+    Window(u64),
+    /// A workbook by [`DocState::uid`]: its most recently active window.
+    Doc(u64),
+}
+
+impl Target {
+    /// Reads `window` or `doc` from a JSON object (control channel envelopes, MCP arguments).
+    /// Neither present is [`Target::Active`]; a value that isn't an id is an error.
+    pub fn from_json(p: &Json) -> Result<Target> {
+        let id = |k: &str| -> Result<Option<u64>> {
+            match p.get(k) {
+                None | Some(Json::Null) => Ok(None),
+                Some(v) => v.as_u64().map(Some).ok_or_else(|| EngineError::Other(format!("`{k}` must be a window or workbook id number"))),
+            }
+        };
+        Ok(match (id("window")?, id("doc")?) {
+            (Some(w), _) => Target::Window(w),
+            (None, Some(d)) => Target::Doc(d),
+            (None, None) => Target::Active,
+        })
+    }
+}
+
+/// What [`Session::leave_target`] restores.
+#[derive(Debug)]
+#[must_use]
+pub struct TargetGuard {
+    id: u64,
+    back: Option<u64>,
+}
+
+impl Session {
+    /// The open windows, in the order they were opened.
+    pub fn windows(&self) -> &[WindowState] {
+        &self.windows
+    }
+
+    /// The active window's id (`None` with no workbook open).
+    pub fn active_window(&self) -> Option<u64> {
+        self.active_window
+    }
+
+    pub fn window(&self, id: u64) -> Option<&WindowState> {
+        self.windows.iter().find(|w| w.id == id)
+    }
+
+    /// A workbook's windows in opening order.
+    fn windows_of(&self, doc: u64) -> impl Iterator<Item = &WindowState> {
+        self.windows.iter().filter(move |w| w.doc_uid == doc)
+    }
+
+    /// The window title: the workbook's name when it has one window, "Name:1", "Name:2"… in
+    /// opening order when it has several.
+    pub fn window_title(&self, id: u64) -> Option<String> {
+        let w = self.window(id)?;
+        let d = self.docs.iter().find(|d| d.uid == w.doc_uid)?;
+        let name = d.display_title();
+        let mut n = 0;
+        let mut at = 0;
+        for x in self.windows_of(w.doc_uid) {
+            n += 1;
+            if x.id == id {
+                at = n;
+            }
+        }
+        Some(if n > 1 { format!("{name}:{at}") } else { name })
+    }
+
+    /// The most recently active window of a workbook, preferring one that isn't hidden.
+    pub fn doc_window(&self, doc: u64) -> Option<u64> {
+        self.windows_of(doc).max_by_key(|w| (!w.hidden, w.last_active)).map(|w| w.id)
+    }
+
+    /// Resolves a [`Target`] to a window id.
+    pub fn target_window(&self, t: Target) -> Result<u64> {
+        match t {
+            Target::Active => self.active_window.ok_or(EngineError::NoDocument),
+            Target::Window(id) => self.window(id).map(|w| w.id).ok_or_else(|| EngineError::Other(format!("no open window has id {id}"))),
+            Target::Doc(uid) => self.doc_window(uid).ok_or_else(|| EngineError::Other(format!("no open workbook has id {uid}"))),
+        }
+    }
+
+    pub(crate) fn push_window(&mut self, doc_uid: u64) -> u64 {
+        self.next_window = self.next_window.saturating_add(1);
+        let id = self.next_window;
+        self.windows.push(WindowState { id, doc_uid, hidden: false, view: None, last_active: 0 });
+        id
+    }
+
+    /// Makes a window active, swapping its view into its workbook. Unknown ids are ignored.
+    pub fn activate_window(&mut self, id: u64) {
+        let Some(wi) = self.windows.iter().position(|w| w.id == id) else { return };
+        let Some(w) = self.windows.get(wi) else { return };
+        let doc = w.doc_uid;
+        if w.view.is_some()
+            && let Some(di) = self.document_index(doc)
+        {
+            let live = self.windows.iter().position(|x| x.doc_uid == doc && x.view.is_none());
+            let incoming = self.windows.get_mut(wi).and_then(|w| w.view.take());
+            if let Some(d) = self.docs.get_mut(di) {
+                if let Some(li) = live
+                    && let Some(lw) = self.windows.get_mut(li)
+                {
+                    lw.view = Some(WindowView::capture(d));
+                }
+                if let Some(v) = incoming {
+                    v.apply(d);
+                }
+            }
+        }
+        self.activation = self.activation.saturating_add(1);
+        let stamp = self.activation;
+        if let Some(w) = self.windows.get_mut(wi) {
+            w.last_active = stamp;
+        }
+        self.active_window = Some(id);
+        if let Some(di) = self.document_index(doc) {
+            self.active = di;
+        }
+    }
+
+    /// Activates the most recently active window that isn't hidden, else any window, else none.
+    pub(crate) fn activate_recent(&mut self) {
+        let next = self.windows.iter().max_by_key(|w| (!w.hidden, w.last_active)).map(|w| w.id);
+        match next {
+            Some(id) => self.activate_window(id),
+            None => {
+                self.active_window = None;
+                self.active = 0;
+            }
+        }
+    }
+
+    /// View › New Window: another window on the active window's workbook, showing what it shows.
+    pub fn new_window(&mut self) -> Result<u64> {
+        let current = self.active_window.ok_or(EngineError::NoDocument)?;
+        let doc = self.window(current).map(|w| w.doc_uid).ok_or(EngineError::NoDocument)?;
+        let view = self.doc().map(WindowView::capture)?;
+        // The new window takes over the live view (identical at this point); the old one keeps a copy.
+        if let Some(w) = self.windows.iter_mut().find(|w| w.doc_uid == doc && w.view.is_none()) {
+            w.view = Some(view);
+        }
+        let id = self.push_window(doc);
+        self.activate_window(id);
+        Ok(id)
+    }
+
+    /// Closes one window. The workbook stays open while it has another window; closing its last
+    /// window closes the workbook (unsaved changes are the caller's to ask about).
+    pub fn close_window(&mut self, id: u64) {
+        let Some(wi) = self.windows.iter().position(|w| w.id == id) else { return };
+        let doc = self.windows.get(wi).map(|w| w.doc_uid).unwrap_or_default();
+        if self.windows_of(doc).count() <= 1 {
+            if let Some(di) = self.document_index(doc) {
+                self.close_document(di);
+            }
+            return;
+        }
+        let closed = self.windows.remove(wi);
+        if closed.view.is_none() {
+            // Its view was the one in the document: the workbook's next window takes it over.
+            if let Some(next) = self.windows.iter().filter(|w| w.doc_uid == doc).max_by_key(|w| w.last_active).map(|w| w.id) {
+                let incoming = self.windows.iter_mut().find(|w| w.id == next).and_then(|w| w.view.take());
+                if let Some(v) = incoming
+                    && let Some(d) = self.docs.iter_mut().find(|d| d.uid == doc)
+                {
+                    v.apply(d);
+                }
+            }
+        }
+        if self.active_window == Some(id) {
+            self.activate_recent();
+        }
+    }
+
+    /// View › Hide on a window; the most recent visible window comes forward.
+    pub fn hide_window(&mut self, id: u64) {
+        let Some(w) = self.windows.iter_mut().find(|w| w.id == id) else { return };
+        w.hidden = true;
+        if self.active_window == Some(id) && self.windows.iter().any(|w| !w.hidden) {
+            self.activate_recent();
+        }
+    }
+
+    /// View › Unhide: shows a hidden window and activates it.
+    pub fn unhide_window(&mut self, id: u64) {
+        let Some(w) = self.windows.iter_mut().find(|w| w.id == id) else { return };
+        w.hidden = false;
+        self.activate_window(id);
+    }
+
+    /// The most recently hidden window.
+    pub fn last_hidden_window(&self) -> Option<u64> {
+        self.windows.iter().filter(|w| w.hidden).max_by_key(|w| w.last_active).map(|w| w.id)
+    }
+
+    /// The windows as scripts and the Switch Windows lists see them:
+    /// `[{window, doc, index, title, dirty, active, hidden}]`, `index` being the workbook's
+    /// position in [`Session::documents`].
+    pub fn window_list(&self) -> Json {
+        Json::Array(
+            self.windows
+                .iter()
+                .filter_map(|w| {
+                    let index = self.document_index(w.doc_uid)?;
+                    let d = self.docs.get(index)?;
+                    Some(json!({
+                        "window": w.id,
+                        "doc": w.doc_uid,
+                        "index": index,
+                        "title": self.window_title(w.id).unwrap_or_default(),
+                        "dirty": d.is_dirty(),
+                        "active": self.active_window == Some(w.id),
+                        "hidden": w.hidden,
+                    }))
+                })
+                .collect(),
+        )
+    }
+
+    /// Runs `f` with the target window active, then brings back the window that was active, so a
+    /// script acting on another window doesn't change what the user is looking at. When `f`
+    /// itself switched windows (`window.activate`, `file.new`, a close), its choice stands.
+    pub fn with_target<T>(&mut self, t: Target, f: impl FnOnce(&mut Session) -> T) -> Result<T> {
+        let guard = self.enter_target(t)?;
+        let r = f(self);
+        self.leave_target(guard);
+        Ok(r)
+    }
+
+    /// The first half of [`Session::with_target`], for callers whose closure can't borrow the
+    /// session alone (the UI runs commands through its app): activates the target window and
+    /// returns what [`Session::leave_target`] needs to bring the previous one back.
+    pub fn enter_target(&mut self, t: Target) -> Result<Option<TargetGuard>> {
+        if t == Target::Active {
+            return Ok(None);
+        }
+        let id = self.target_window(t)?;
+        let back = self.active_window;
+        self.activate_window(id);
+        Ok(Some(TargetGuard { id, back }))
+    }
+
+    pub fn leave_target(&mut self, guard: Option<TargetGuard>) {
+        let Some(TargetGuard { id, back: Some(back) }) = guard else { return };
+        if self.active_window == Some(id) && back != id && self.window(back).is_some() {
+            self.activate_window(back);
+        }
+    }
+
+    /// [`Session::execute`] on a target window.
+    pub fn execute_in(&mut self, t: Target, id: &str, params: Json) -> Result<Json> {
+        self.with_target(t, |s| s.execute(id, params))?
+    }
+
+    /// [`Session::execute_headless`] on a target window.
+    pub fn execute_headless_in(&mut self, t: Target, id: &str, params: Json) -> Result<Json> {
+        self.with_target(t, |s| s.execute_headless(id, params))?
+    }
+}
+
+/// Commands that take `window`/`doc` as their own parameters rather than as a target.
+pub fn is_window_command(id: &str) -> bool {
+    id.starts_with("window.") || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow" | "view.switchWindows")
+}
diff --git a/crates/engine/tests/command_sequence_fuzz.rs b/crates/engine/tests/command_sequence_fuzz.rs
index f8cb603cb..1724b9b9d 100644
--- a/crates/engine/tests/command_sequence_fuzz.rs
+++ b/crates/engine/tests/command_sequence_fuzz.rs
@@ -59,7 +59,8 @@ const EXCLUDED: &[(&str, &str)] = &[
     ("file.exportPdf", "renders a PDF: slow, and may write files"),
     ("file.print", "renders a PDF: slow"),
     ("window.activate", "switches documents"),
-    ("view.newWindow", "opens another document"),
+    ("window.close", "closes the document under test"),
+    ("view.newWindow", "opens another window, whose view swaps with the first"),
     ("insert.picture", "reads files"),
     ("pageLayout.background", "reads files"),
     ("formulas.calculationOptions", "manual and iterative calculation differ from a full recalc by design"),
diff --git a/crates/mcp/src/headless.rs b/crates/mcp/src/headless.rs
index 5f96fbd25..28a5cecce 100644
--- a/crates/mcp/src/headless.rs
+++ b/crates/mcp/src/headless.rs
@@ -1,6 +1,6 @@
 //! An in-process engine session that answers the engine-level control-channel methods itself.
 
-use gridcraft_engine::Session;
+use gridcraft_engine::{Session, Target};
 use serde_json::{Value, json};
 
 use crate::backend::Backend;
@@ -33,9 +33,9 @@ impl Headless {
         Self { session }
     }
 
-    fn execute(&mut self, id: &str, params: Value) -> Result<Value, String> {
+    fn execute(&mut self, target: Target, id: &str, params: Value) -> Result<Value, String> {
         // Programmatic calls never open dialogs; anything a command queued for a UI is dropped.
-        self.session.execute_headless(id, params).map_err(|e| e.to_string())
+        self.session.execute_headless_in(target, id, params).map_err(|e| e.to_string())
     }
 
     fn commands(&self, params: &Value) -> Value {
@@ -68,14 +68,28 @@ impl Backend for Headless {
                 if !(p.is_object() || p.is_null()) {
                     return Err(format!("engine.execute: `params` of `{id}` must be an object"));
                 }
-                self.execute(&id, p)
+                let target = Target::from_json(&params).map_err(|e| e.to_string())?;
+                self.execute(target, &id, p)
             }
             "engine.commands" => Ok(self.commands(&params)),
             "engine.journal" => Ok(Value::Array(self.session.journal.iter().map(|(id, p)| json!({"command": id, "params": p})).collect())),
             m if m.starts_with("ui.") || m.starts_with("app.screenshot") => Err(format!("{m}: {NO_UI}")),
             // Read-only engine methods (`document.inspect`, `sheet.read`, `cell.get`, …) are
             // commands with the same id.
-            m if gridcraft_engine::find_command(m).is_some() => self.execute(m, params),
+            // Their params may name a `window` or `doc` to act in, except for the window commands,
+            // whose own params those are.
+            m if gridcraft_engine::find_command(m).is_some() => {
+                if gridcraft_engine::windows::is_window_command(m) {
+                    return self.execute(Target::Active, m, params);
+                }
+                let target = Target::from_json(&params).map_err(|e| e.to_string())?;
+                let mut params = params;
+                if let Some(o) = params.as_object_mut() {
+                    o.remove("window");
+                    o.remove("doc");
+                }
+                self.execute(target, m, params)
+            }
             other => Err(format!("unknown method `{other}`")),
         }
     }
diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs
index c699ccf69..5ceeea0ce 100644
--- a/crates/mcp/src/tests.rs
+++ b/crates/mcp/src/tests.rs
@@ -106,6 +106,7 @@ fn tools_list_has_schemas() {
         "redo",
         "screenshot",
         "list_functions",
+        "list_windows",
     ] {
         assert!(names.contains(&want), "missing tool {want}");
     }
@@ -548,3 +549,31 @@ fn invalid_sort_keys_are_invalid_params() {
     }
     ok(&mut s, "sort_range", json!({"range": "A1:A3", "keys": ["A", {"column": "A", "order": "desc"}]}));
 }
+
+#[test]
+fn a_window_argument_routes_tools_to_that_window() {
+    let mut s = server();
+    ok(&mut s, "set_cell", json!({"cell": "A1", "input": "book one"}));
+    ok(&mut s, "new_workbook", json!({}));
+    let windows = ok(&mut s, "list_windows", json!({}));
+    let rows = windows.as_array().unwrap();
+    assert_eq!(rows.len(), 2, "{windows}");
+    let (w1, book1) = (rows[0]["window"].as_u64().unwrap(), rows[0]["doc"].as_u64().unwrap());
+    assert_eq!((rows[0]["title"].as_str(), rows[1]["active"].as_bool()), (Some("Book1"), Some(true)));
+
+    // Book2 stays active; reads and writes go to Book1's window.
+    ok(&mut s, "set_cell", json!({"cell": "B1", "input": "=A1", "window": w1}));
+    let got = ok(&mut s, "get_cell", json!({"cell": "B1", "doc": book1}));
+    assert!(got.to_string().contains("book one"), "{got}");
+    let book2 = ok(&mut s, "read_range", json!({"range": "A1:B1"}));
+    assert!(!book2.to_string().contains("book one"), "{book2}");
+    let info = ok(&mut s, "inspect_workbook", json!({"window": w1}));
+    assert!(info.to_string().contains("Book1"), "{info}");
+    assert!(fails(&mut s, "get_cell", json!({"cell": "A1", "window": 999})).contains("no open window"));
+
+    // A second window on Book1 gets a numbered title.
+    ok(&mut s, "execute_command", json!({"command": "view.newWindow", "window": w1}));
+    let titles: Vec<String> =
+        ok(&mut s, "list_windows", json!({})).as_array().unwrap().iter().map(|r| r["title"].as_str().unwrap().to_string()).collect();
+    assert_eq!(titles, ["Book1:1", "Book2", "Book1:2"]);
+}
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index a6879b3ff..b422b5f34 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -106,8 +106,26 @@ const BORDER_PRESETS: &[&str] = &[
     "diagonalUp",
 ];
 
-/// All tools, in `tools/list` order.
+/// Tools that don't act on one workbook, so they take no `window`/`doc` target.
+const UNTARGETED: &[&str] = &["list_commands", "list_functions", "list_windows", "new_workbook", "open_workbook", "screenshot"];
+
+/// All tools, in `tools/list` order. Tools that act on a workbook take an optional `window` or
+/// `doc` id (from list_windows) and default to the active window.
 pub fn tool_definitions() -> Vec<Value> {
+    let mut tools = base_tool_definitions();
+    for t in &mut tools {
+        if UNTARGETED.iter().any(|n| t["name"] == *n) {
+            continue;
+        }
+        if let Some(props) = t["inputSchema"]["properties"].as_object_mut() {
+            props.insert("window".into(), int("Window id from list_windows (default: the active window)"));
+            props.insert("doc".into(), int("Workbook id from list_windows: its most recent window (default: the active window)"));
+        }
+    }
+    tools
+}
+
+fn base_tool_definitions() -> Vec<Value> {
     let empty = || obj(json!({}), &[]);
     vec![
         // ----- generic -----
@@ -125,6 +143,14 @@ pub fn tool_definitions() -> Vec<Value> {
             ),
             false,
         ),
+        tool(
+            "list_windows",
+            "List windows",
+            "List the open windows: window id, workbook (`doc`) id, title (\"Book1\", or \"Book1:2\" for a workbook's second \
+             window), unsaved changes, active and hidden. Pass a `window` or `doc` id to other tools to act there.",
+            empty(),
+            true,
+        ),
         tool(
             "list_commands",
             "List commands",
@@ -608,6 +634,7 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Args) -> Result<Value, String>
             exec(b, cmd, p)
         }
         "list_commands" => b.call("engine.commands", pick(a, &["search"])),
+        "list_windows" => exec(b, "window.list", json!({})),
         "inspect_workbook" => b.call("document.inspect", json!({})),
         "read_range" => b.call("sheet.read", pick(a, &["range", "sheet", "formulas", "formatted"])),
         "write_range" => exec(b, "range.setValues", pick(a, &["range", "values"])),
@@ -638,6 +665,35 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Args) -> Result<Value, String>
     }
 }
 
+/// Sends every engine call of one tool to the window its `window`/`doc` argument names.
+struct Targeted<'a> {
+    inner: &'a mut dyn Backend,
+    target: Map<String, Value>,
+}
+
+impl Backend for Targeted<'_> {
+    fn call(&mut self, method: &str, params: Value) -> Result<Value, String> {
+        let envelope = if method == "engine.execute" {
+            params
+        } else if gridcraft_engine::find_command(method).is_some() {
+            json!({"command": method, "params": params})
+        } else {
+            return self.inner.call(method, params);
+        };
+        let mut envelope = envelope;
+        if let Some(o) = envelope.as_object_mut() {
+            o.extend(self.target.clone());
+        }
+        self.inner.call("engine.execute", envelope)
+    }
+    fn has_ui(&self) -> bool {
+        self.inner.has_ui()
+    }
+    fn describe(&self) -> String {
+        self.inner.describe()
+    }
+}
+
 /// Runs one tool. Failures become `isError` results with a readable message.
 pub fn call_tool(b: &mut dyn Backend, name: &str, args: &Value) -> ToolResult {
     let empty = Map::new();
@@ -646,7 +702,11 @@ pub fn call_tool(b: &mut dyn Backend, name: &str, args: &Value) -> ToolResult {
         Value::Null => &empty,
         _ => return ToolResult::error("tool arguments must be a JSON object"),
     };
-    match dispatch(b, name, a) {
+    let target: Map<String, Value> =
+        ["window", "doc"].iter().filter_map(|k| a.get(*k).filter(|v| !v.is_null()).map(|v| (k.to_string(), v.clone()))).collect();
+    let r =
+        if target.is_empty() || UNTARGETED.contains(&name) { dispatch(b, name, a) } else { dispatch(&mut Targeted { inner: b, target }, name, a) };
+    match r {
         Ok(v) => ToolResult::json(&v),
         Err(e) => ToolResult::error(format!("{name}: {e}")),
     }
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 11d535ac4..bf1dedac1 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -104,6 +104,38 @@ fn run(app: &mut SheetApp, id: &str, params: Json) -> Result<Json, String> {
     r
 }
 
+/// [`run`] in another window (`window` or `doc` from the request), bringing back the active
+/// window afterwards unless the command itself switched windows.
+fn run_in(app: &mut SheetApp, target: gridcraft_engine::Target, id: &str, params: Json) -> Result<Json, String> {
+    let guard = app.session.enter_target(target).map_err(|e| e.to_string())?;
+    let r = run(app, id, params);
+    app.session.leave_target(guard);
+    r
+}
+
+/// A command called by its id as the method. Its params may name a `window` or `doc` to act in,
+/// except for the window commands, whose own params those are.
+fn direct(app: &mut SheetApp, id: &str, p: &Json, via_app: bool) -> Result<Json, String> {
+    let mut params = p.clone();
+    let target = if gridcraft_engine::windows::is_window_command(id) {
+        gridcraft_engine::Target::Active
+    } else {
+        let t = gridcraft_engine::Target::from_json(p).map_err(|e| e.to_string())?;
+        if let Some(o) = params.as_object_mut() {
+            o.remove("window");
+            o.remove("doc");
+        }
+        t
+    };
+    if via_app {
+        return run_in(app, target, id, params);
+    }
+    let guard = app.session.enter_target(target).map_err(|e| e.to_string())?;
+    let r = app.session.run(id, params);
+    app.session.leave_target(guard);
+    r
+}
+
 pub fn inspect(app: &SheetApp, ctx: &egui::Context) -> Json {
     let r = ctx.content_rect();
     let v = app.view();
@@ -120,6 +152,8 @@ pub fn inspect(app: &SheetApp, ctx: &egui::Context) -> Json {
         "mode": format!("{:?}", app.session.mode),
         "documents": app.session.documents().iter().map(|d| json!({"title": d.display_title(), "dirty": d.is_dirty()})).collect::<Vec<_>>(),
         "activeDocument": app.session.active_index(),
+        "windows": app.session.window_list(),
+        "activeWindow": app.session.active_window(),
         "perf": {"frameMs": app.perf.frame_ms, "gridMs": app.perf.grid_ms, "fps": app.perf.fps},
     })
 }
@@ -222,7 +256,11 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) -
         "engine.execute" | "command" | "ui.menu.invoke" => {
             let Some(id) = s("command").or(s("id")) else { return err("missing `command`") };
             let params = p.get("params").cloned().unwrap_or(json!({}));
-            wrap(run(app, id, if params.is_null() { json!({}) } else { params }))
+            let target = match gridcraft_engine::Target::from_json(p) {
+                Ok(t) => t,
+                Err(e) => return err(e),
+            };
+            wrap(run_in(app, target, id, if params.is_null() { json!({}) } else { params }))
         }
         "engine.commands" => {
             let mut v: Vec<Json> = app.session.commands().into_iter().map(|c| serde_json::to_value(c).unwrap_or_default()).collect();
@@ -256,7 +294,7 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) -
             ok(Json::Array(filter_commands(v, s("search"))))
         }
         "engine.journal" => ok(json!(app.session.journal.iter().map(|(id, p)| json!({"command": id, "params": p})).collect::<Vec<_>>())),
-        "document.inspect" | "sheet.read" | "cell.get" | "selection.stats" => wrap(app.session.run(method, p.clone())),
+        "document.inspect" | "sheet.read" | "cell.get" | "selection.stats" => wrap(direct(app, method, p, false)),
         "ui.inspect" => ok(inspect(app, ctx)),
         "ui.ribbon" => {
             app.ui.ribbon_tab = s("tab").unwrap_or("Home").to_string();
@@ -440,7 +478,7 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) -
             ok(Json::Null)
         }
         // Anything else that names a command runs it.
-        other if gridcraft_engine::find_command(other).is_some() => wrap(run(app, other, p.clone())),
+        other if gridcraft_engine::find_command(other).is_some() => wrap(direct(app, other, p, true)),
         other => err(format!("unknown method `{other}`")),
     };
     ctx.request_repaint();
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 612ca93b2..be474d37f 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -1327,7 +1327,7 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
                     let quitting = d.values.get("quit").and_then(Json::as_bool) == Some(true);
                     ui.horizontal(|ui| {
                         if ui.button("Don't Save").clicked() {
-                            app.run_or_alert("file.close", json!({"force": true}));
+                            app.run_or_alert("file.close", json!({"force": true, "document": true}));
                             if quitting {
                                 app.continue_quit(ui.ctx());
                             }
@@ -1340,7 +1340,7 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
                         if ui.button("Save").clicked() && app.commit_edit(0, 0, false, false) {
                             app.run_or_alert("file.save", json!({}));
                             if app.session.active().is_some_and(|x| !x.is_dirty()) {
-                                app.run_or_alert("file.close", json!({"force": true}));
+                                app.run_or_alert("file.close", json!({"force": true, "document": true}));
                                 if quitting {
                                     app.continue_quit(ui.ctx());
                                 }
diff --git a/crates/ui-egui/src/editor.rs b/crates/ui-egui/src/editor.rs
index 3f23e8bed..95e74d959 100644
--- a/crates/ui-egui/src/editor.rs
+++ b/crates/ui-egui/src/editor.rs
@@ -20,6 +20,9 @@ pub const REF_COLORS: [Color32; 8] = [
 pub struct EditState {
     /// The workbook (`DocState::uid`) the draft belongs to: it is drawn and committed only there.
     pub doc: u64,
+    /// The window it was typed in: switching to another window, even on the same workbook,
+    /// commits it there first (`None` until the app sets it).
+    pub window: Option<u64>,
     pub sheet: usize,
     /// Syntax of this edit, captured when it starts (prevents a language switch reinterpreting it).
     pub locale: gridcraft_engine::formula::FormulaLocale,
@@ -56,6 +59,7 @@ impl EditState {
         let original = (!enter_mode).then(|| text.clone());
         EditState {
             doc,
+            window: None,
             sheet,
             locale: Default::default(),
             cell,
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index cc478168e..d330d1fcf 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -166,10 +166,12 @@ pub struct Notice {
     pub action: Option<(String, String)>,
 }
 
-/// One open workbook, as View › Switch Windows and the macOS Window menu list it.
+/// One open window, as View › Switch Windows and the macOS Window menu list it.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct OpenWindow {
-    /// The workbook's `DocState::uid`, the `doc` param of `view.switchWindows`.
+    /// The window's id, the `window` param of `view.switchWindows`.
+    pub window: u64,
+    /// Its workbook's `DocState::uid`.
     pub doc: u64,
     pub title: String,
     pub dirty: bool,
@@ -177,7 +179,8 @@ pub struct OpenWindow {
 }
 
 impl OpenWindow {
-    /// The title, with a bullet after it while the workbook has unsaved changes.
+    /// The title ("Book1", or "Book1:2" for a workbook's second window), with a bullet after it
+    /// while the workbook has unsaved changes.
     pub fn label(&self) -> String {
         if self.dirty { format!("{} •", self.title) } else { self.title.clone() }
     }
@@ -256,6 +259,7 @@ pub struct SheetApp {
     pub ui: UiState,
     /// The window chrome to draw (see [`Chrome`]).
     pub chrome: Chrome,
+    /// Scroll position per (window id, sheet index).
     pub views: HashMap<(u64, usize), SheetView>,
     pub editor: Option<editor::EditState>,
     pub text_box_editor: Option<text_box::EditState>,
@@ -410,7 +414,7 @@ impl SheetApp {
     fn run_command(&mut self, id: &str, params: Json) -> Result<Json, String> {
         let switches_window = id.starts_with("window.")
             || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
-            || (id == "view.switchWindows" && params.get("doc").is_some_and(|d| !d.is_null()));
+            || (id == "view.switchWindows" && ["window", "doc"].iter().any(|k| params.get(*k).is_some_and(|d| !d.is_null())));
         if id.starts_with("file.") || switches_window {
             self.settle_drafts()?;
         }
@@ -567,9 +571,9 @@ impl SheetApp {
         if id == "insert.recommendedCharts" && params.get("type").is_none() {
             return self.open_dialog("recommendedCharts", json!({}));
         }
-        // Switch Windows with no workbook named (key tip, command search) opens the View tab's
+        // Switch Windows with no window named (key tip, command search) opens the View tab's
         // list to choose from; programmatic callers of `run` get the list back.
-        if id == "view.switchWindows" && params.get("doc").is_none_or(Json::is_null) {
+        if id == "view.switchWindows" && ["window", "doc"].iter().all(|k| params.get(*k).is_none_or(Json::is_null)) {
             self.ui.ribbon_tab = "View".into();
             self.ui.ribbon_collapsed = false;
             self.open_switch_windows = true;
@@ -914,27 +918,36 @@ impl SheetApp {
         }
     }
 
-    /// The open workbooks in order, for the Switch Windows lists.
+    /// The open windows in order, for the Switch Windows lists.
     pub fn open_windows(&self) -> Vec<OpenWindow> {
-        let active = self.session.active_index();
+        let active = self.session.active_window();
         self.session
-            .documents()
+            .windows()
             .iter()
-            .enumerate()
-            .map(|(i, d)| OpenWindow { doc: d.uid, title: d.display_title(), dirty: d.is_dirty(), active: i == active })
+            .filter_map(|w| {
+                let d = self.session.documents().iter().find(|d| d.uid == w.doc_uid)?;
+                let title = self.session.window_title(w.id)?;
+                Some(OpenWindow { window: w.id, doc: d.uid, title, dirty: d.is_dirty(), active: active == Some(w.id) })
+            })
             .collect()
     }
 
+    /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
     pub fn view_key(&self) -> Option<(u64, usize)> {
         self.session.active().map(|d| (d.uid, d.wb.active_sheet))
     }
 
+    /// The active window and sheet: each window scrolls on its own.
+    fn scroll_key(&self) -> Option<(u64, usize)> {
+        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet))
+    }
+
     pub fn view(&self) -> SheetView {
-        self.view_key().and_then(|k| self.views.get(&k).copied()).unwrap_or_else(|| self.saved_view())
+        self.scroll_key().and_then(|k| self.views.get(&k).copied()).unwrap_or_else(|| self.saved_view())
     }
 
     pub fn view_mut(&mut self) -> Option<&mut SheetView> {
-        let k = self.view_key()?;
+        let k = self.scroll_key()?;
         let saved = self.saved_view();
         Some(self.views.entry(k).or_insert(saved))
     }
@@ -956,10 +969,11 @@ impl SheetApp {
     /// cell to the engine so a save writes them (`sheetView topLeftCell`). Normal view only:
     /// Page Layout view scrolls over pages, not cells.
     pub fn store_view_state(&mut self) {
+        let window = self.session.active_window();
         let Some(d) = self.session.active_mut() else { return };
         let mut tops = Vec::new();
-        for (&(uid, si), v) in &self.views {
-            let Some(sh) = d.wb.sheets.get(si).filter(|sh| uid == d.uid && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
+        for (&(w, si), v) in &self.views {
+            let Some(sh) = d.wb.sheets.get(si).filter(|sh| Some(w) == window && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
                 continue;
             };
             let (fr, fc) = sh.freeze.unwrap_or((0, 0));
@@ -1005,6 +1019,7 @@ impl SheetApp {
             None => (current.clone(), false),
         };
         let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet, at, text, replace, from_formula_bar);
+        ed.window = self.session.active_window();
         ed.locale = locale;
         if replace && self.ui.autocomplete && !ed.is_formula() {
             ed.completion = editor::column_completion(sh, at, &ed.text);
@@ -1015,29 +1030,38 @@ impl SheetApp {
 
     /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
     ///
-    /// The draft goes into the workbook it was typed in. If another workbook is showing, that
-    /// workbook stays active afterwards; a draft its own workbook refuses (validation, a bad
-    /// formula) brings that workbook back to the front with the draft still open.
+    /// The draft goes into the window and workbook it was typed in. If another window is
+    /// showing, that window stays active afterwards; a draft its own workbook refuses
+    /// (validation, a bad formula) brings its window back to the front with the draft still open.
     pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
-        let Some(doc) = self.editor.as_ref().map(|ed| ed.doc) else { return true };
-        let shown = self.session.active().map(|d| d.uid);
-        if shown == Some(doc) {
+        let Some((doc, window)) = self.editor.as_ref().map(|ed| (ed.doc, ed.window)) else { return true };
+        if !self.draft_elsewhere() {
             return self.commit_edit_here(dr, dc, array, fill_selection);
         }
-        let Some(owner) = self.session.document_index(doc) else {
+        // Its window, or (when that window closed) its workbook's most recent one.
+        let Some(owner) = window.filter(|w| self.session.window(*w).is_some()).or_else(|| self.session.doc_window(doc)) else {
             self.cancel_edit();
             return true;
         };
-        let back = self.session.active_index();
-        self.session.set_active(owner);
+        let back = self.session.active_window();
+        self.session.activate_window(owner);
         if !self.commit_edit_here(dr, dc, array, fill_selection) {
-            // Refused: its workbook stays in front with the draft open and the reason shown.
+            // Refused: its window stays in front with the draft open and the reason shown.
             return false;
         }
-        self.session.set_active(back);
+        if let Some(back) = back {
+            self.session.activate_window(back);
+        }
         true
     }
 
+    /// The cell draft belongs to a window or workbook other than the one showing.
+    fn draft_elsewhere(&self) -> bool {
+        self.editor.as_ref().is_some_and(|ed| {
+            self.session.active().map(|d| d.uid) != Some(ed.doc) || ed.window.is_some_and(|w| self.session.active_window() != Some(w))
+        })
+    }
+
     /// Commits the cell and text-box drafts, as Enter would, before a command that can show
     /// another workbook or write this one to a file, so a draft never lands in another workbook.
     /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
@@ -1360,10 +1384,10 @@ impl SheetApp {
         }
         let t0 = now_ms();
         text_box::before_ui(self, &ctx);
-        // Another workbook came forward without going through a command (which settles drafts
-        // first): the draft goes into its own workbook instead of floating over this one. If that
-        // workbook refuses it, it comes back to the front with the draft open.
-        if self.editor.as_ref().is_some_and(|ed| self.session.active().map(|d| d.uid) != Some(ed.doc)) {
+        // Another window came forward without going through a command (which settles drafts
+        // first): the draft goes into its own window instead of floating over this one. If its
+        // workbook refuses it, its window comes back to the front with the draft open.
+        if self.draft_elsewhere() {
             self.commit_edit(0, 0, false, false);
         }
         // The language the widgets translate with this frame (see `i18n::current`).
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index d90b642ea..6bd45e18f 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -2403,7 +2403,7 @@ fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
         for w in app.open_windows() {
             let label = format!("{}{}", if w.active { "✓ " } else { "    " }, w.label());
             if ui.add(egui::Button::selectable(w.active, label).min_size(vec2(220.0, 22.0))).clicked() {
-                act(app, "view.switchWindows", json!({"doc": w.doc}));
+                act(app, "view.switchWindows", json!({"window": w.window}));
                 ui.close();
             }
         }
diff --git a/crates/ui-egui/tests/file_menu.rs b/crates/ui-egui/tests/file_menu.rs
index 5c447cb63..fa9350f7a 100644
--- a/crates/ui-egui/tests/file_menu.rs
+++ b/crates/ui-egui/tests/file_menu.rs
@@ -484,3 +484,65 @@ fn save_a_copy_with_a_bare_name_asks_where_to_save_it() {
     assert_eq!(asked.lock().unwrap().len(), 1);
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+#[test]
+fn new_window_shows_the_same_workbook_and_a_draft_settles_in_its_own_window() {
+    let mut h = harness(Services::default());
+    h.state_mut().run("selection.set", serde_json::json!({"range": "B2"})).unwrap();
+    let first = h.state().session.active_window().unwrap();
+    h.state_mut().run_or_alert("view.newWindow", serde_json::json!({}));
+    h.run_steps(2);
+    let second = h.state().session.active_window().unwrap();
+    let book = h.state().session.doc().unwrap().uid;
+    assert_ne!(first, second);
+    assert_eq!(h.state().session.documents().len(), 1, "one workbook, two windows");
+    let titles: Vec<String> = h.state().open_windows().iter().map(|w| w.title.clone()).collect();
+    assert_eq!(titles, ["Book1:1", "Book1:2"]);
+
+    // A draft typed in window 2 is entered in window 2's cell before window 1 comes forward.
+    h.state_mut().run("selection.set", serde_json::json!({"range": "D4"})).unwrap();
+    h.input_mut().events.push(egui::Event::Text("typed".into()));
+    h.run_steps(2);
+    h.state_mut().run_or_alert("view.switchWindows", serde_json::json!({"window": first}));
+    h.run_steps(2);
+    assert!(h.state().editor.is_none(), "the draft doesn't follow into window 1");
+    assert_eq!(h.state().session.active_window(), Some(first));
+    let d = h.state().session.doc().unwrap();
+    assert_eq!(d.wb.active().unwrap().value(CellRef::parse("D4").unwrap()), Value::text("typed"));
+    assert_eq!(d.selection.active, CellRef::parse("B2").unwrap(), "window 1 keeps its own selection");
+
+    // Quitting asks once about the workbook, whichever window shows it.
+    request_window_close(&mut h);
+    let sent = click_commands(&mut h, "Don't Save");
+    assert!(sent.contains(&egui::ViewportCommand::Close), "{sent:?}");
+    assert!(h.state().session.document_index(book).is_none(), "both windows closed with the workbook");
+}
+
+#[test]
+fn control_requests_route_to_a_window_and_list_windows() {
+    use gridcraft_ui_egui::control::{Outcome, handle};
+    let mut h = harness(Services::default());
+    let first = h.state().session.active_window().unwrap();
+    h.state_mut().run_or_alert("file.new", serde_json::json!({}));
+    h.run_steps(2);
+    let ctx = h.ctx.clone();
+    let call = |h: &mut egui_kittest::Harness<'static, SheetApp>, method: &str, p: serde_json::Value| match handle(h.state_mut(), &ctx, method, &p) {
+        Outcome::Done(v) => v,
+        Outcome::Screenshot { .. } => serde_json::Value::Null,
+    };
+    let r = call(&mut h, "engine.execute", serde_json::json!({"command": "cell.set", "params": {"cell": "A1", "input": "one"}, "window": first}));
+    assert_eq!(r["ok"], true, "{r}");
+    assert_eq!(a1(&h, 0), Value::text("one"));
+    assert_eq!(a1(&h, 1), Value::Empty);
+    assert_eq!(h.state().session.active_index(), 1, "Book2 stays in front");
+    let r = call(&mut h, "cell.get", serde_json::json!({"cell": "A1", "window": first}));
+    assert!(r["result"].to_string().contains("one"), "{r}");
+
+    let r = call(&mut h, "window.list", serde_json::json!({}));
+    let rows = r["result"].as_array().unwrap();
+    assert_eq!(rows.len(), 2, "{r}");
+    assert_eq!((rows[0]["window"].as_u64(), rows[0]["title"].as_str(), rows[0]["dirty"].as_bool()), (Some(first), Some("Book1"), Some(true)));
+    assert_eq!(rows[1]["active"].as_bool(), Some(true));
+    let r = call(&mut h, "engine.execute", serde_json::json!({"command": "cell.get", "params": {"cell": "A1"}, "window": 999}));
+    assert_eq!(r["ok"], false, "{r}");
+}
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index 0c24e9252..00bbc8fc5 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -23,13 +23,14 @@ connection; nothing sent after it runs. Blank lines are skipped.
 
 | Method | Params | What it does |
 |---|---|---|
-| `engine.execute` | `{command, params}` | Runs any engine command (see `engine.commands` or `gridcraft-cli commands`). `edit.goTo`, `edit.goToSpecial`, `selection.set` and `selection.move` scroll the active cell into view, as Go To does in the window |
+| `engine.execute` | `{command, params, window?, doc?}` | Runs any engine command (see `engine.commands` or `gridcraft-cli commands`) in the active window, or in the window named by `window` (a window id) or `doc` (a workbook id: its most recent window). The active window stays in front afterwards unless the command itself switches windows. `edit.goTo`, `edit.goToSpecial`, `selection.set` and `selection.move` scroll the active cell into view, as Go To does in the window |
+| `window.list` | | The open windows: `[{window, doc, index, title, dirty, active, hidden}]`. `title` is the workbook name, or "Book1:1", "Book1:2"… when a workbook has several windows; `index` is the workbook's position among the open workbooks |
 | `engine.commands` | `{search?}` | Every command: id, label, ribbon path, shortcut, params doc, enabled; `search` keeps those whose id, label or ribbon path contains it (case-insensitive) |
 | `engine.journal` | | Commands run so far (replayable). Passwords (`password`, `…Password` params) are left out, so a replayed Protect Sheet has no password. Capped at 10,000 entries and 64 MB (serialized); past either cap the oldest entries go |
 | `document.inspect` | | Workbook summary: sheets, used ranges, tables, charts, names, selection, undo labels |
 | `sheet.read` | `{range?, sheet?, formulas?, formatted?}` | Values (or formulas / displayed text) of a range |
 | `cell.get` | `{cell?}` | One cell: value, formula, displayed text, style, merge, comment, link |
-| `ui.inspect` | | UI state: ribbon tab, editor, open dialog, Backstage page, message, grid rect, scroll, perf |
+| `ui.inspect` | | UI state: ribbon tab, editor, open dialog, Backstage page, message, grid rect, scroll, perf, `windows` (as `window.list`) and `activeWindow` |
 | `ui.click` / `ui.drag` / `ui.move` | `{x, y, toX?, toY?, button?, count?, shift?, cmd?, alt?}` | Real pointer input in window points; refused with an error if it would leave more than 10,000 pointer events queued |
 | `ui.cell.click` / `ui.cell.drag` | `{cell}` / `{from, to}` | Pointer input at a cell's centre (works in point mode while editing); same 10,000-event queue limit |
 | `ui.key` / `ui.text` | `{key, shift?, cmd?, alt?, ctrl?}` / `{text}` | Keyboard input (typing in the grid starts editing) |
@@ -42,7 +43,20 @@ connection; nothing sent after it runs. Blank lines are skipped.
 | `ui.resize` / `ui.focus` | `{width, height}` | Window control |
 | `app.open` / `app.save` / `app.quit` | `{path, password?}` / `{path?}` | Files and lifetime. `password` opens a password-protected workbook; without it, such a workbook returns an error (never a dialog) |
 
-Any other method name that is a command id (e.g. `home.bold`) runs that command.
+Any other method name that is a command id (e.g. `home.bold`) runs that command. Its params may
+include `window` or `doc` to run it in that window, as with `engine.execute`; the window commands
+(`window.*`, `view.newWindow`, `view.hideWindow`, `view.unhideWindow`, `view.switchWindows`) read
+them as their own parameters.
+
+### Windows
+
+Every open workbook has one or more windows; View › New Window (`view.newWindow`) adds another
+on the same workbook, and saving from any of them saves that workbook. Each window has its own
+selection, active sheet and scroll position; switching windows never marks the workbook as
+changed. `window.activate {window}`, `view.switchWindows {window}` and `view.unhideWindow
+{window}` bring a window forward; `window.close {window?, force?}` closes one (the workbook
+closes with its last window, asking about unsaved changes unless `force`); `file.close` closes
+the active window, or with `{document: true}` the workbook and all its windows.
 
 Use `engine.execute` with `{command: "view.theme", params: {mode: "system"}}`
 to choose the display theme; `mode` accepts `"system"`, `"light"`, or `"dark"`.
diff --git a/docs/mcp.md b/docs/mcp.md
index 1877cf228..8c45182c9 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -41,6 +41,7 @@ with a file open.
 |---|---|---|
 | `execute_command` | `command`, `params?` | Runs **any** engine command (`cell.set`, `home.bold`, `data.removeDuplicates`, …). |
 | `list_commands` | `search?` | Command ids, labels, ribbon paths, shortcuts and parameter docs. |
+| `list_windows` | — | Open windows: window id, workbook (`doc`) id, title ("Book1", or "Book1:2" for a workbook's second window), unsaved changes, active, hidden. |
 | `inspect_workbook` | — | Sheets, used ranges, tables, charts, names, selection, history. |
 | `read_range` | `range?`, `sheet?`, `formulas?`, `formatted?` | Rows of values (default: the used range). |
 | `write_range` | `range`, `values` (2-D) | `range.setValues`; strings starting with `=` are formulas. |
@@ -57,6 +58,10 @@ with a file open.
 | `screenshot` | `path` | PNG of the window (Remote only). |
 | `list_functions` | `search?`, `category?` | Worksheet functions with signatures. |
 
+Every tool that acts on a workbook (all but `list_commands`, `list_functions`, `list_windows`, `open_workbook`,
+`new_workbook` and `screenshot`) also takes `window` or `doc`, an id from `list_windows`, and acts in that window
+(for `doc`, the workbook's most recent window) without bringing it forward. Without them it acts in the active window.
+
 Results are one text block holding pretty JSON; failures set `isError: true` with a readable message. Unknown tools,
 missing required arguments and wrong argument types are JSON-RPC `-32602` errors; malformed JSON is `-32700`; unknown
 methods `-32601`.
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index b70682ac3..839984959 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (Switch Windows lists the open workbooks; a cell being typed stays in its own workbook through New, Open and window switches; macOS Quit asks about unsaved workbooks) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (New Window opens a second window on the same workbook, titled Name:1 / Name:2; Switch Windows lists the open windows; a cell being typed stays in its own window through New, Open and window switches; macOS Quit asks about unsaved workbooks) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md).
 **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured
@@ -34,7 +34,7 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes
 | Dark mode, system appearance | yes | yes | done (10-09) |
 | Page Layout view (paper view with rulers and header editing) | yes | yes (#329, 10-11): per-sheet view saved in XLSX, pages with margins and gaps on the print pagination, "Click to add data" pages, rulers (inches or centimetres), headers and footers drawn and edited in place with a Header & Footer tab | margins drag on the rulers (#792, with header and footer margins); header/footer pictures, Different First Page / Odd & Even missing (1–3 h) |
 | Multiple windows per workbook | yes | no (#162) | see [hardware-parity.md](hardware-parity.md) |
-| Switch Windows, unsaved workbooks on quit | yes | yes (10-22): View › Switch Windows and the macOS Window menu list the open workbooks (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {doc}`); a cell being typed is entered into its own workbook before New, Open, Close, Save, Print and window switches, and a refused entry stays open and stops the command; quitting (window close, Cmd+Q, the macOS Quit item) asks Save / Don't Save / Cancel for each unsaved workbook | one OS window for all workbooks (#162) |
+| Switch Windows, New Window, unsaved workbooks on quit | yes | yes (10-22): View › New Window opens another window on the same workbook (no copy: saving from either saves it), each with its own selection, active sheet and scroll; a workbook with several windows titles them "Book1:1", "Book1:2"; File › Close closes one of them without asking and asks only for the last; View › Switch Windows and the macOS Window menu list the open windows (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {window}`, or `{doc}` for a workbook's most recent window); a cell being typed is entered into its own window and workbook before New, Open, Close, Save, Print and window switches (also between two windows on one workbook), and a refused entry stays open and stops the command; quitting (window close, Cmd+Q, the macOS Quit item) asks Save / Don't Save / Cancel for each unsaved workbook | one OS window for all workbooks (#162) |
 
 ## Grid interaction
 
@@ -177,6 +177,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | New Window opens a second window on the same workbook instead of a copy that saved over the original; windows keep their own selection, sheet and scroll; titles Name:1 / Name:2; Switch Windows, Hide and Unhide work by window; File › Close closes one window of several without asking |
 | 2026-10-22 | minor | New workbook no longer loses the first one: the cell being typed is entered into its own workbook before any File or window command (an entry the workbook refuses stays open and the command doesn't run; an untouched F2 draft changes nothing), the editor is tied to its workbook, View › Switch Windows and the macOS Window menu list the open workbooks, and the macOS Quit item asks about unsaved workbooks like the close button |
 | 2026-10-21 | minor | Background error checking, first part (#1994): a constant whose text would be a number if typed (signs, thousands, currency, percent, exponent, parenthesised negative) gets Excel's green corner triangle; the active cell then shows a warning button whose menu names the problem and offers Convert to Number for the selection (`formulas.convertToNumber`). Dates, times and fractions kept as text and formula results are not flagged, as in Excel |
 | 2026-10-21 | minor | Paste Special laid out as Excel's: Paste and Operation options each in two columns inside a frame, Skip blanks and Transpose side by side, Paste Link as a button that pastes references at once; labels translated (the generic form didn't translate them) and the window no longer runs past the screen |

From 5bd5d241a0825a4af8551cc28c6c97b9b31f2d66 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 16:21:59 +0000
Subject: [PATCH 05/76] G3: a native window per workbook window

Each engine window is drawn in its own native window through craft-window's
immediate-viewport driver (desktop only; the web app keeps one window). The
root viewport shows one window and adopts another when its window closes.

- WindowUi: the cell draft, text-box draft, dialog, Backstage, message,
  toast, notice, grid state, name box, key tips, selected chart, Tab run and
  edit mode are per window. SheetApp's fields hold the active window's; the
  others are parked and swapped in when a window is drawn or activated, and
  after any command that switched windows.
- Session::show_window makes a window current for drawing without counting
  as an activation.
- The ribbon in each window acts on it; menu bar commands and scripts go to
  the window focused last. Leaving a window enters its draft as Enter would.
- A window's close button runs window.close: one of several windows on a
  workbook closes without asking, a workbook's last asks when unsaved.
  SheetApp::request_quit (macOS Quit item, Dock quit) asks about each unsaved
  workbook in its window; Cancel stops. Save Changes answers moved to
  SheetApp::answer_save_changes.
- The last window closed quits on Windows and Linux; macOS hides the root
  and keeps running until New or Open.
- Fonts are bound for every open workbook, since each may be showing.

craft-window is pinned to the aiongg/craft-libs window-list branch until it
merges into storytold/craft-libs.
---
 Cargo.lock                          |  10 +
 Cargo.toml                          |   4 +
 ROADMAP.md                          |   4 +-
 apps/gridcraft/src/apple_events.rs  |   3 +-
 apps/gridcraft/src/main.rs          |  20 +-
 apps/gridcraft/src/native_menu.rs   |  14 +-
 crates/engine/src/windows.rs        |  20 +-
 crates/ui-egui/Cargo.toml           |   1 +
 crates/ui-egui/src/dialogs.rs       |  25 +--
 crates/ui-egui/src/doc_windows.rs   | 227 ++++++++++++++++++++++
 crates/ui-egui/src/lib.rs           | 148 +++++++++++++--
 crates/ui-egui/src/window_ui.rs     | 133 +++++++++++++
 crates/ui-egui/tests/doc_windows.rs | 284 ++++++++++++++++++++++++++++
 docs/hardware-parity.md             |   5 +-
 docs/ui-parity.md                   |   7 +-
 15 files changed, 840 insertions(+), 65 deletions(-)
 create mode 100644 crates/ui-egui/src/doc_windows.rs
 create mode 100644 crates/ui-egui/src/window_ui.rs
 create mode 100644 crates/ui-egui/tests/doc_windows.rs

diff --git a/Cargo.lock b/Cargo.lock
index e041aafbc..77b3b801a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -758,6 +758,15 @@ dependencies = [
  "egui",
 ]
 
+[[package]]
+name = "craft-window"
+version = "0.1.0"
+source = "git+https://github.com/aiongg/craft-libs?rev=4fbdea5fcf86ba893d9bc03685d4531cfdd4efc2#4fbdea5fcf86ba893d9bc03685d4531cfdd4efc2"
+dependencies = [
+ "egui",
+ "wayland-client",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.2"
@@ -1636,6 +1645,7 @@ name = "gridcraft-ui-egui"
 version = "0.10.0"
 dependencies = [
  "craft-ui",
+ "craft-window",
  "egui",
  "egui_kittest",
  "epaint_default_fonts",
diff --git a/Cargo.toml b/Cargo.toml
index e8a6dc67e..b28d7eb33 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,6 +54,10 @@ sys-locale = "0.3"
 skrifa = { version = "0.44", default-features = false, features = ["std"] }
 # Real font bytes for tests (Ubuntu Light, compiled into epaint).
 epaint_default_fonts = "0.36"
+# One native window per workbook: the window list, Window menu titles and the immediate-viewport
+# driver (craft-libs). Pinned to the aiongg fork's `window-list` branch; repins to
+# storytold/craft-libs once that branch merges there.
+craft-window = { version = "0.1.0", git = "https://github.com/aiongg/craft-libs", rev = "4fbdea5fcf86ba893d9bc03685d4531cfdd4efc2", default-features = false, features = ["egui"] }
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
diff --git a/ROADMAP.md b/ROADMAP.md
index bf25cc3a9..38c394fb0 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save; New Window shares the workbook) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (a native window per workbook window; no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save; New Window shares the workbook) · **Target:** Microsoft Excel (Microsoft 365)
 
 GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX
 is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web.
@@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | What landed |
 |---|---|
+| 2026-10-22 | On the desktop every workbook window is a native window of its own: New, Open and New Window open one, each keeps its own cell draft, dialog and ribbon, and the macOS menu bar acts on the window focused last. Closing one of several windows on a workbook doesn't ask; closing a workbook's last window, or quitting, asks about unsaved changes in that window. The last window closed quits on Windows and Linux; macOS keeps running with the menu bar. First craft-libs `craft-window` use (window list and viewport driver) |
 | 2026-10-22 | View › New Window opens a second window on the same workbook (it used to open a copy whose Save overwrote the original): each window has its own selection, active sheet and scroll, titles read "Book1:1" / "Book1:2", and Switch Windows, Hide, Unhide and Close act per window. The control channel, CLI `send` and MCP tools take an optional `window` or `doc` id and default to the active window; `window.list` (MCP `list_windows`) lists the windows |
 | 2026-10-22 | Typing in a cell and then choosing File › New no longer strands the first workbook: the entry is committed into its own workbook before any File or window command (a refused entry stays open and stops the command), View › Switch Windows and the macOS Window menu list the open workbooks with unsaved markers, `view.switchWindows {doc}` switches by a stable workbook id, and the macOS Quit item asks about unsaved workbooks |
 | 2026-10-21 | Page Setup paper sizes match Japanese Excel: `B4`/`B5`/`B6` are the JIS sizes (ISO B4/B5/B6 stay reachable by name), so a Japanese B5 worksheet prints at 182×257 mm; Japanese Postcard (100×148 mm), Double Postcard (148×200 mm), Envelope #3/#4 (120×235/90×205 mm), Kaku #2/#3 (240×332/216×277 mm) and A6 are added, both sizes reach the PDF page (`file.exportPdf`/`file.print` MediaBox) and the size survives an XLSX round-trip; the Page Layout Size menu lists them. `B4`/`B5` used to be the ISO sizes, which is changed here |
@@ -222,6 +223,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | Progress log: a native window per workbook window |
 | 2026-10-22 | minor | Progress log: New Window shares the workbook; window ids for scripts and MCP |
 | 2026-10-22 | minor | Progress log: drafts stay in their workbook, Switch Windows, macOS Quit asks to save |
 | 2026-10-21 | minor | Page Setup paper sizes: JIS B4/B5/B6 (ISO by name), Japanese postcards and envelopes, A6; PDF page size follows, XLSX round-trips |
diff --git a/apps/gridcraft/src/apple_events.rs b/apps/gridcraft/src/apple_events.rs
index 405ee89a0..4d596f957 100644
--- a/apps/gridcraft/src/apple_events.rs
+++ b/apps/gridcraft/src/apple_events.rs
@@ -43,7 +43,8 @@ pub fn poll(inbox: &Inbox, app: &mut SheetApp, ctx: &egui::Context) {
                     app.open_path(p);
                 }
             }
-            Event::Quit => ctx.send_viewport_cmd(egui::ViewportCommand::Close),
+            // Quit from the Dock or the system: each unsaved workbook is asked about in its window.
+            Event::Quit => app.request_quit(ctx),
         }
     }
 }
diff --git a/apps/gridcraft/src/main.rs b/apps/gridcraft/src/main.rs
index 8aad9aeb8..c0b50038d 100644
--- a/apps/gridcraft/src/main.rs
+++ b/apps/gridcraft/src/main.rs
@@ -22,24 +22,27 @@ use std::cell::RefCell;
 use std::rc::Rc;
 
 use gridcraft_engine::Session;
+use gridcraft_ui_egui::doc_windows::DocWindows;
 use gridcraft_ui_egui::{Services, SheetApp};
 use serde_json::json;
 
-struct App(SheetApp, #[cfg(target_os = "macos")] Option<native_menu::NativeMenu>, #[cfg(target_os = "macos")] fmv_macos_events::Inbox);
+/// The app, its native window per workbook window, and (macOS) the menu bar and Finder events.
+struct App(SheetApp, DocWindows, #[cfg(target_os = "macos")] Option<native_menu::NativeMenu>, #[cfg(target_os = "macos")] fmv_macos_events::Inbox);
 
 impl eframe::App for App {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         #[cfg(target_os = "macos")]
         {
-            if self.1.is_none() && std::env::var_os("GRIDCRAFT_NO_NATIVE_MENU").is_none() {
-                self.1 = Some(native_menu::NativeMenu::install(ctx));
+            if self.2.is_none() && std::env::var_os("GRIDCRAFT_NO_NATIVE_MENU").is_none() {
+                self.2 = Some(native_menu::NativeMenu::install(ctx));
             }
-            if let Some(m) = &mut self.1 {
-                m.poll(&mut self.0, ctx);
+            if let Some(m) = &mut self.2 {
+                m.poll(&mut self.0, ctx, self.1.focused_viewport());
             }
-            apple_events::poll(&self.2, &mut self.0, ctx);
+            apple_events::poll(&self.3, &mut self.0, ctx);
         }
         self.0.logic(ctx);
+        self.1.logic(&mut self.0, ctx);
         self.0.poll_printing(ctx);
         if ctx.input(|input| input.viewport().close_requested()) && self.0.printing.busy() {
             ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
@@ -55,7 +58,7 @@ impl eframe::App for App {
         }
     }
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-        self.0.ui(ui);
+        self.1.show(&mut self.0, ui);
     }
     fn on_exit(&mut self) {
         print::finish_pending_jobs();
@@ -320,6 +323,7 @@ fn main() -> eframe::Result<()> {
     if let Some(i) = icon() {
         viewport = viewport.with_icon(i);
     }
+    let window_builder = viewport.clone();
     let options = eframe::NativeOptions { viewport, ..Default::default() };
     // Before eframe creates the wgpu instance: Windows starts on DirectX 12, or OpenGL when
     // DirectX 12 has no GPU driver, and never touches Vulkan unless asked (see graphics.rs).
@@ -357,8 +361,10 @@ fn main() -> eframe::Result<()> {
                         Err(e) => log::error!("control channel on port {port}: {e}"),
                     }
                 }
+                let windows = DocWindows::new(&mut app, window_builder.clone(), DocWindows::platform_quits_with_last_window());
                 Ok(Box::new(App(
                     app,
+                    windows,
                     #[cfg(target_os = "macos")]
                     None,
                     #[cfg(target_os = "macos")]
diff --git a/apps/gridcraft/src/native_menu.rs b/apps/gridcraft/src/native_menu.rs
index 826a12b31..9559c47d7 100644
--- a/apps/gridcraft/src/native_menu.rs
+++ b/apps/gridcraft/src/native_menu.rs
@@ -203,8 +203,8 @@ pub struct NativeMenu {
 /// Menu id of the Window menu item that brings workbook `doc` forward.
 const WINDOW_ITEM: &str = "window:id:";
 
-/// The Quit item: closing the window asks about unsaved workbooks first, which AppKit's own
-/// Quit (terminate:) would skip.
+/// The Quit item: asks about each unsaved workbook in its window first
+/// (`SheetApp::request_quit`), which AppKit's own Quit (terminate:) would skip.
 const QUIT: &str = "app.quit";
 
 fn select_theme(app: &mut SheetApp, id: &str) -> bool {
@@ -311,11 +311,13 @@ impl NativeMenu {
         }
     }
 
-    pub fn poll(&mut self, app: &mut SheetApp, ctx: &egui::Context) {
+    /// Runs the chosen menu items. Commands go to the active window, the most recently focused;
+    /// `viewport` is its egui viewport, for the items that act on its input.
+    pub fn poll(&mut self, app: &mut SheetApp, ctx: &egui::Context, viewport: egui::ViewportId) {
         while let Ok(ev) = self.events.try_recv() {
             let id = ev.id.as_ref().to_string();
             if id == QUIT {
-                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+                app.request_quit(ctx);
                 continue;
             }
             if let Some(window) = id.strip_prefix(WINDOW_ITEM).and_then(|w| w.parse::<u64>().ok()) {
@@ -331,11 +333,11 @@ impl NativeMenu {
                     _ => None,
                 };
                 if let Some(command) = clipboard {
-                    ctx.send_viewport_cmd(command);
+                    ctx.send_viewport_cmd_to(viewport, command);
                     continue;
                 }
                 if id == "edit.undo" || id == "edit.redo" {
-                    ctx.input_mut(|i| {
+                    ctx.input_mut_for(viewport, |i| {
                         i.events.push(egui::Event::Key {
                             key: egui::Key::Z,
                             physical_key: None,
diff --git a/crates/engine/src/windows.rs b/crates/engine/src/windows.rs
index 8dcb92011..4441166db 100644
--- a/crates/engine/src/windows.rs
+++ b/crates/engine/src/windows.rs
@@ -166,6 +166,16 @@ impl Session {
 
     /// Makes a window active, swapping its view into its workbook. Unknown ids are ignored.
     pub fn activate_window(&mut self, id: u64) {
+        self.enter_window(id, true);
+    }
+
+    /// Makes a window the one commands act on while the interface draws it, without counting as
+    /// an activation: the most recently active window of each workbook stays the same.
+    pub fn show_window(&mut self, id: u64) {
+        self.enter_window(id, false);
+    }
+
+    fn enter_window(&mut self, id: u64, recent: bool) {
         let Some(wi) = self.windows.iter().position(|w| w.id == id) else { return };
         let Some(w) = self.windows.get(wi) else { return };
         let doc = w.doc_uid;
@@ -185,10 +195,12 @@ impl Session {
                 }
             }
         }
-        self.activation = self.activation.saturating_add(1);
-        let stamp = self.activation;
-        if let Some(w) = self.windows.get_mut(wi) {
-            w.last_active = stamp;
+        if recent {
+            self.activation = self.activation.saturating_add(1);
+            let stamp = self.activation;
+            if let Some(w) = self.windows.get_mut(wi) {
+                w.last_active = stamp;
+            }
         }
         self.active_window = Some(id);
         if let Some(di) = self.document_index(doc) {
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index 85a24dda9..626d5e7fa 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -33,6 +33,7 @@ gridcraft-xlsx = { workspace = true, features = ["test-support"] }
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # The desktop's preferred language for the first-run interface language.
 sys-locale = { workspace = true }
+craft-window = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 # Read the browser's preferred language for the first-run web interface language.
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index be474d37f..55c0819df 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -1323,29 +1323,14 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
                 }
                 "saveChanges" => {
                     ui.label(format!("Do you want to save the changes you made to {}?", d.values.get("title").and_then(Json::as_str).unwrap_or("this workbook")));
-                    // Asked while quitting: once answered, the next unsaved workbook is asked about.
                     let quitting = d.values.get("quit").and_then(Json::as_bool) == Some(true);
                     ui.horizontal(|ui| {
-                        if ui.button("Don't Save").clicked() {
-                            app.run_or_alert("file.close", json!({"force": true, "document": true}));
-                            if quitting {
-                                app.continue_quit(ui.ctx());
+                        for (label, answer) in
+                            [("Don't Save", crate::SaveAnswer::DontSave), ("Cancel", crate::SaveAnswer::Cancel), ("Save", crate::SaveAnswer::Save)]
+                        {
+                            if ui.button(label).clicked() && app.answer_save_changes(answer, quitting, ui.ctx()) {
+                                open = false;
                             }
-                            open = false;
-                        }
-                        if ui.button("Cancel").clicked() {
-                            open = false;
-                        }
-                        // File operations must include the cell the user is still editing (as the File > Save menu item already does).
-                        if ui.button("Save").clicked() && app.commit_edit(0, 0, false, false) {
-                            app.run_or_alert("file.save", json!({}));
-                            if app.session.active().is_some_and(|x| !x.is_dirty()) {
-                                app.run_or_alert("file.close", json!({"force": true, "document": true}));
-                                if quitting {
-                                    app.continue_quit(ui.ctx());
-                                }
-                            }
-                            open = false;
                         }
                     });
                 }
diff --git a/crates/ui-egui/src/doc_windows.rs b/crates/ui-egui/src/doc_windows.rs
new file mode 100644
index 000000000..88ba3967a
--- /dev/null
+++ b/crates/ui-egui/src/doc_windows.rs
@@ -0,0 +1,227 @@
+//! Desktop: each workbook window is a native window of its own.
+//!
+//! The engine owns the windows ([`Session::windows`]); [`DocWindows`] mirrors the visible ones in
+//! a [`WindowList`] and draws each through [`Viewports`]: the root viewport shows one window and
+//! every other window is an immediate viewport. Before a window draws, it becomes the engine's
+//! window and its interface state is swapped in ([`SheetApp::show_window`]); after the frame the
+//! focused window is active again, so menu commands, scripts and shortcuts outside a window's own
+//! input go to the window the user worked in last.
+//!
+//! Close and quit:
+//! - A window's close button closes that window (`window.close`): one of several windows on a
+//!   workbook closes without asking; a workbook's last window asks Save / Don't Save / Cancel when
+//!   it has unsaved changes.
+//! - Quit ([`SheetApp::request_quit`]) asks about each unsaved workbook in its window; Cancel stops.
+//! - When the root's window closes while others are open, another window moves into the root.
+//! - With no window left, the app quits, or (macOS) keeps running with its root hidden and the
+//!   menu bar showing until a workbook is created or opened.
+//!
+//! [`Session::windows`]: gridcraft_engine::Session::windows
+
+use craft_window::{Frame, Viewports, WindowEvent, WindowId, WindowList};
+use serde_json::json;
+
+use crate::SheetApp;
+
+/// The native windows (see the module docs).
+pub struct DocWindows {
+    /// Engine window id per native window.
+    list: WindowList<u64>,
+    viewports: Viewports,
+    /// The builder new windows start from: the root window's size, icon and frame settings.
+    base: egui::ViewportBuilder,
+    /// Quit when the last window closes (Windows, Linux); macOS keeps running without a window.
+    quit_with_last_window: bool,
+    /// The root viewport is hidden because no window is open.
+    root_hidden: bool,
+}
+
+impl DocWindows {
+    /// Takes over `app`'s windows. `base` is the root window's builder, used for new windows.
+    pub fn new(app: &mut SheetApp, base: egui::ViewportBuilder, quit_with_last_window: bool) -> DocWindows {
+        app.native_windows = true;
+        // The root window keeps the desktop's frame, so every window does.
+        DocWindows { list: WindowList::new(), viewports: Viewports::new(Frame::Desktop), base, quit_with_last_window, root_hidden: false }
+    }
+
+    /// The platform default for the last window closing: macOS keeps running, others quit.
+    pub fn platform_quits_with_last_window() -> bool {
+        !cfg!(target_os = "macos")
+    }
+
+    /// The native window showing engine window `window`.
+    fn find(&self, window: u64) -> Option<WindowId> {
+        self.list.find(|w| *w == window)
+    }
+
+    /// The engine window drawn in the root viewport.
+    pub fn root_window(&self) -> Option<u64> {
+        self.viewports.root().and_then(|w| self.list.get(w).copied())
+    }
+
+    /// The engine windows that have a native window, in opening order.
+    pub fn shown_windows(&self) -> Vec<u64> {
+        self.list.iter().map(|(_, w)| *w).collect()
+    }
+
+    /// The egui viewport showing engine window `window`.
+    pub fn viewport_of(&self, window: u64) -> Option<egui::ViewportId> {
+        self.find(window).map(|id| self.viewports.viewport_id(id))
+    }
+
+    /// The egui viewport of the focused window, where menu commands that act on input (copy,
+    /// paste, undo in a text box) go.
+    pub fn focused_viewport(&self) -> egui::ViewportId {
+        self.list.active().map(|w| self.viewports.viewport_id(w)).unwrap_or(egui::ViewportId::ROOT)
+    }
+
+    /// Call each frame after [`SheetApp::logic`], also while the root is hidden (eframe runs only
+    /// the logic then): shows windows created or opened by menu commands, files and scripts.
+    pub fn logic(&mut self, app: &mut SheetApp, ctx: &egui::Context) {
+        self.sync(app, ctx);
+    }
+
+    /// Mirrors the engine's visible windows: closed or hidden windows lose their native window
+    /// (the root adopting another), new ones get one, and a window a command activated comes to
+    /// the front. With no window left, quits or hides the root.
+    fn sync(&mut self, app: &mut SheetApp, ctx: &egui::Context) {
+        let visible = visible_windows(app);
+        let gone: Vec<WindowId> = self.list.iter().filter(|(_, w)| !visible.contains(w)).map(|(id, _)| id).collect();
+        let mut root_closed = false;
+        for id in gone {
+            root_closed |= self.viewports.root() == Some(id);
+            self.list.close(id);
+        }
+        if root_closed {
+            // The window the engine brought forward, else the most recently focused.
+            let next = app.session.active_window().and_then(|w| self.find(w)).or_else(|| self.list.active());
+            match next {
+                Some(id) => self.viewports.adopt(ctx, &self.list, id),
+                None => self.viewports.set_root(None),
+            }
+        }
+        for w in visible {
+            if self.find(w).is_none() {
+                self.list.open(w);
+            }
+        }
+        if self.viewports.root().is_none() {
+            let first = app.session.active_window().and_then(|w| self.find(w)).or_else(|| self.list.active());
+            self.viewports.set_root(first);
+        }
+        if self.list.is_empty() {
+            if self.quit_with_last_window {
+                if !app.allow_close {
+                    app.allow_close = true;
+                    ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Close);
+                }
+            } else if !self.root_hidden {
+                self.root_hidden = true;
+                ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Visible(false));
+            }
+            return;
+        }
+        if self.root_hidden {
+            self.root_hidden = false;
+            ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Visible(true));
+            ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Focus);
+        }
+        // A command or script activated another window: bring its native window forward.
+        if let Some(id) = app.session.active_window().and_then(|w| self.find(w))
+            && self.list.active() != Some(id)
+        {
+            self.list.focus(id);
+            self.viewports.focus(ctx, id);
+        }
+    }
+
+    /// Draws every window. Call from the root viewport's UI each frame, in place of
+    /// [`SheetApp::ui`].
+    pub fn show(&mut self, app: &mut SheetApp, ui: &mut egui::Ui) {
+        let ctx = ui.ctx().clone();
+        self.sync(app, &ctx);
+        let focused = self.list.active().and_then(|id| self.list.get(id).copied());
+        app.focus_window = focused;
+        let titles: std::collections::HashMap<u64, String> = self.list.iter().map(|(_, w)| (*w, window_title(app, *w))).collect();
+        let base = &self.base;
+        // The window a command run in some window's UI activated (File › New, Switch Windows, a close).
+        let mut requested: Option<u64> = None;
+        let events = self.viewports.show(
+            ui,
+            &mut self.list,
+            |_, w| base.clone().with_title(titles.get(w).cloned().unwrap_or_default()),
+            |ui, _, w| {
+                app.show_window(*w);
+                // Files dropped on a window open as workbooks (the root's arrive through the app's
+                // raw input hook; a child window's input reaches only its own pass).
+                let dropped: Vec<String> = ui
+                    .ctx()
+                    .input(|i| i.raw.dropped_files.iter().filter_map(|f| f.path().to_str().map(str::to_string)).filter(|p| !p.is_empty()).collect());
+                for path in dropped {
+                    app.open_path(&path);
+                }
+                app.ui(ui);
+                if app.session.active_window() != Some(*w) {
+                    requested = app.session.active_window();
+                }
+            },
+        );
+        for event in events {
+            match event {
+                WindowEvent::Focused(_) => {}
+                WindowEvent::CloseRequested(id) => {
+                    if let Some(w) = self.close_requested(app, &ctx, id) {
+                        requested = Some(w);
+                    }
+                }
+            }
+        }
+        let target = requested.or_else(|| self.list.active().and_then(|id| self.list.get(id).copied()));
+        if let Some(target) = target.filter(|w| app.session.window(*w).is_some()) {
+            if requested.is_none()
+                && let Some(previous) = focused.filter(|p| *p != target && app.session.window(*p).is_some())
+            {
+                // The user moved to another window: the previous window's draft is entered there,
+                // as Enter would. One its workbook refuses stays open in that window.
+                app.enter_window(previous);
+                let _ = app.settle_drafts();
+            }
+            app.enter_window(target);
+        }
+        self.sync(app, &ctx);
+        app.focus_window = self.list.active().and_then(|id| self.list.get(id).copied());
+    }
+
+    /// A window's close button. Returns the window to bring forward when the close needs an
+    /// answer (or moved focus); `None` when nothing changed.
+    fn close_requested(&mut self, app: &mut SheetApp, ctx: &egui::Context, id: WindowId) -> Option<u64> {
+        let is_root = self.viewports.root() == Some(id);
+        if app.allow_close {
+            // Quitting: every workbook has been answered for; the root's close ends the app.
+            return None;
+        }
+        if is_root {
+            // eframe would end the app with the root window; closing it is the app's decision.
+            ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::CancelClose);
+        }
+        let window = *self.list.get(id)?;
+        app.enter_window(window);
+        app.run_or_alert("window.close", json!({"window": window}));
+        app.session.active_window()
+    }
+}
+
+/// The windows that get a native window: every window not hidden (View › Hide), or the active one
+/// when all are hidden, so the app still has a window to unhide them from.
+fn visible_windows(app: &SheetApp) -> Vec<u64> {
+    let shown: Vec<u64> = app.session.windows().iter().filter(|w| !w.hidden).map(|w| w.id).collect();
+    if shown.is_empty() { app.session.active_window().into_iter().collect() } else { shown }
+}
+
+/// A native window's title: the window's ("Book1", "Book1:2"), marked while its workbook has
+/// unsaved changes.
+fn window_title(app: &SheetApp, window: u64) -> String {
+    let title = app.session.window_title(window).unwrap_or_default();
+    let dirty = app.session.window(window).and_then(|w| app.session.documents().iter().find(|d| d.uid == w.doc_uid)).is_some_and(|d| d.is_dirty());
+    if dirty { format!("{title} — Edited") } else { title }
+}
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index d330d1fcf..f405a3d18 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -13,6 +13,8 @@ pub mod chartview;
 pub mod control;
 pub mod credits;
 pub mod dialogs;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod doc_windows;
 pub mod editor;
 mod floating_pictures;
 pub mod fonts;
@@ -34,6 +36,9 @@ pub mod tabs;
 pub mod text_box;
 pub mod theme;
 pub mod widgets;
+mod window_ui;
+
+pub use window_ui::WindowUi;
 
 use std::collections::HashMap;
 
@@ -166,6 +171,14 @@ pub struct Notice {
     pub action: Option<(String, String)>,
 }
 
+/// An answer to the Save Changes question.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SaveAnswer {
+    Save,
+    DontSave,
+    Cancel,
+}
+
 /// One open window, as View › Switch Windows and the macOS Window menu list it.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct OpenWindow {
@@ -282,8 +295,8 @@ pub struct SheetApp {
     fonts_set: bool,
     /// Workbook fonts bound into the current font set; a change rebinds (installed fonts only).
     fonts_bound: Vec<String>,
-    /// The (doc uid, revision) `fonts_bound` was computed for, so the style table is walked only
-    /// when the workbook changes.
+    /// The open workbooks' (uid, revision), folded, that `fonts_bound` was computed for, so the
+    /// style tables are walked only when a workbook changes.
     fonts_seen: (u64, u64),
     /// Set while a font-set change is pending activation: skip this frame's paint, like the
     /// startup `fonts_ready` gate (egui applies new definitions at the next pass).
@@ -320,6 +333,17 @@ pub struct SheetApp {
     /// View › Switch Windows opens its list on the next frame the View tab draws (asked for by a
     /// key tip, the command search or a menu, possibly while another tab was showing).
     pub(crate) open_switch_windows: bool,
+    /// The window whose interface state the per-window fields above hold (see [`WindowUi`]).
+    ui_window: Option<u64>,
+    /// The other windows' interface state, by window id.
+    parked: HashMap<u64, WindowUi>,
+    /// Each window is a native window of its own ([`doc_windows`] on the desktop): a window's
+    /// close button closes that window, and quitting is asked for separately. Without it (web,
+    /// tests, embedding hosts) one window shows the active workbook window, and its close button
+    /// quits.
+    pub native_windows: bool,
+    /// The native window that has focus, which menu commands and screenshots go to.
+    pub(crate) focus_window: Option<u64>,
 }
 
 impl SheetApp {
@@ -367,6 +391,10 @@ impl SheetApp {
             started: now_ms(),
             allow_close: false,
             open_switch_windows: false,
+            ui_window: None,
+            parked: HashMap::new(),
+            native_windows: false,
+            focus_window: None,
         }
     }
 
@@ -385,11 +413,12 @@ impl SheetApp {
         theme::apply(ctx, dark);
     }
 
-    /// The font names the active workbook uses: every style's font plus the theme's heading/body
-    /// fonts. These are the families [`fonts`] binds an installed file for.
+    /// The font names the open workbooks use: every style's font plus the theme's heading/body
+    /// fonts. These are the families [`fonts`] binds an installed file for. Every workbook's, as
+    /// each may be showing in a window of its own.
     pub fn used_fonts(&self) -> Vec<String> {
         let mut names: Vec<String> = Vec::new();
-        if let Some(d) = self.session.active() {
+        for d in self.session.documents() {
             names.extend(d.wb.styles.iter().map(|(_, s)| s.font.name.clone()));
             names.push(d.wb.theme.major_font.clone());
             names.push(d.wb.theme.minor_font.clone());
@@ -441,7 +470,14 @@ impl SheetApp {
         if let Some(r) = self.run_ui_command(id, &params) {
             return r;
         }
+        let before = self.session.active_window();
         let r = self.session.run(id, params);
+        if id.starts_with("file.") && self.session.active_window() != before {
+            // File › New or Open from the Backstage view: the window it was in goes back to its sheet.
+            self.backstage = None;
+        }
+        // Requests the command made (a dialog, a draft) belong to the window it left active.
+        self.follow_active_window();
         self.after_engine();
         // The new chart is selected, as after inserting any object, so Delete removes it, not its data.
         if id == "insert.chart"
@@ -1065,7 +1101,7 @@ impl SheetApp {
     /// Commits the cell and text-box drafts, as Enter would, before a command that can show
     /// another workbook or write this one to a file, so a draft never lands in another workbook.
     /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
-    fn settle_drafts(&mut self) -> Result<(), String> {
+    pub(crate) fn settle_drafts(&mut self) -> Result<(), String> {
         if !self.commit_edit(0, 0, false, false) {
             return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
         }
@@ -1216,7 +1252,7 @@ impl SheetApp {
     /// Holds back a window close (the close button, Alt+F4, the OS quitting the app) while a
     /// workbook has unsaved changes, and asks about them first.
     fn guard_window_close(&mut self, ctx: &egui::Context) {
-        if self.allow_close || !ctx.input(|i| i.viewport().close_requested()) {
+        if self.native_windows || self.allow_close || !ctx.input(|i| i.viewport().close_requested()) {
             return;
         }
         // A cell still being edited is part of the workbook, as for File › Close.
@@ -1237,21 +1273,75 @@ impl SheetApp {
         }
     }
 
-    /// Asks about the next unsaved workbook before quitting, or closes the window once none is left.
+    /// Asks about the next unsaved workbook before quitting, in its window, or closes the app
+    /// once none is left.
     pub(crate) fn continue_quit(&mut self, ctx: &egui::Context) {
-        match self.session.documents().iter().position(|d| d.is_dirty()) {
-            Some(i) => {
-                self.session.set_active(i);
+        let dirty = self.session.documents().iter().find(|d| d.is_dirty()).map(|d| d.uid);
+        match dirty.and_then(|uid| self.session.doc_window(uid)) {
+            Some(window) => {
+                // Its window comes forward (the native window too: see `doc_windows`).
+                self.enter_window(window);
                 let title = self.session.active().map(|d| d.display_title()).unwrap_or_default();
                 self.open_dialog("saveChanges", json!({"title": title, "quit": true}));
             }
             None => {
                 self.allow_close = true;
-                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+                ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Close);
             }
         }
     }
 
+    /// Answers the Save Changes question about the active workbook (its buttons). While quitting,
+    /// the next unsaved workbook is asked about once this one is answered; Cancel stops the quit.
+    /// Returns whether the question is settled: Save keeps it open when the cell being edited
+    /// can't be entered.
+    pub fn answer_save_changes(&mut self, answer: SaveAnswer, quitting: bool, ctx: &egui::Context) -> bool {
+        match answer {
+            SaveAnswer::Cancel => {}
+            SaveAnswer::DontSave => {
+                self.run_or_alert("file.close", json!({"force": true, "document": true}));
+                if quitting {
+                    self.continue_quit(ctx);
+                }
+            }
+            SaveAnswer::Save => {
+                // File operations include the cell still being edited, as File › Save does.
+                if !self.commit_edit(0, 0, false, false) {
+                    return false;
+                }
+                self.run_or_alert("file.save", json!({}));
+                if self.session.active().is_some_and(|x| !x.is_dirty()) {
+                    self.run_or_alert("file.close", json!({"force": true, "document": true}));
+                    if quitting {
+                        self.continue_quit(ctx);
+                    }
+                }
+            }
+        }
+        true
+    }
+
+    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, then asks
+    /// about each unsaved workbook in its window; Cancel on any of them stops the quit. A draft its
+    /// workbook refuses stops the quit too, with its window in front and the reason shown.
+    pub fn request_quit(&mut self, ctx: &egui::Context) {
+        while let Some(window) = self.parked_window_with_draft() {
+            self.enter_window(window);
+            if self.settle_drafts().is_err() {
+                return;
+            }
+        }
+        if self.settle_drafts().is_err() {
+            return;
+        }
+        if let Some(d) = self.dialog.as_mut().filter(|d| d.name() == "saveChanges") {
+            // Already asking about a workbook (File › Close): answering it goes on to quit.
+            d.values.insert("quit".into(), json!(true));
+            return;
+        }
+        self.continue_quit(ctx);
+    }
+
     /// Per-frame logic (control channel, screenshots). Call before `ui`.
     pub fn logic(&mut self, ctx: &egui::Context) {
         if self.session.text_width.is_none() {
@@ -1288,7 +1378,11 @@ impl SheetApp {
             // Bind the workbook's installed fonts once the background scan has finished. Adding
             // fonts re-applies the font set, which egui activates at the next pass, so skip this
             // frame's paint (same one-frame cost as startup). Only when the workbook changed.
-            let seen = self.session.active().map(|d| (d.uid, d.revision)).unwrap_or((0, 0));
+            let seen = self
+                .session
+                .documents()
+                .iter()
+                .fold((0u64, 0u64), |(uid, rev), d| (uid.wrapping_mul(31).wrapping_add(d.uid), rev.wrapping_mul(31).wrapping_add(d.revision)));
             if seen != self.fonts_seen {
                 let used = self.used_fonts();
                 self.fonts_seen = seen;
@@ -1322,9 +1416,10 @@ impl SheetApp {
             ctx.options_mut(|o| o.zoom_with_keyboard = false);
         }
         // egui closes the window on Ctrl+Q (and with Shift or Alt held too) without asking to save
-        // (#1443). Excel for Windows has no such key (Ctrl+Q is Quick Analysis); macOS keeps Cmd+Q,
-        // the app's Quit there.
-        if ctx.os() != egui::os::OperatingSystem::Mac && ctx.options(|o| !o.quit_shortcuts.is_empty()) {
+        // (#1443). Excel for Windows has no such key (Ctrl+Q is Quick Analysis). With a native
+        // window per workbook egui's Cmd+Q would close only the window it was typed in: the menu
+        // bar's Quit item has the key instead (it asks about unsaved workbooks first).
+        if (ctx.os() != egui::os::OperatingSystem::Mac || self.native_windows) && ctx.options(|o| !o.quit_shortcuts.is_empty()) {
             ctx.options_mut(|o| o.quit_shortcuts.clear());
         }
         let zoom = self.ui.zoom_factor();
@@ -1357,9 +1452,12 @@ impl SheetApp {
             }
             self.after_engine();
         }
-        if self.session.active().is_none() {
+        // One window always shows a workbook, unless each workbook has a native window of its own
+        // (`doc_windows` decides what having none left means).
+        if self.session.active().is_none() && !self.native_windows {
             self.session.new_workbook();
         }
+        self.follow_active_window();
     }
 
     pub fn raw_input_hook(&mut self, raw: &mut egui::RawInput) {
@@ -1383,6 +1481,10 @@ impl SheetApp {
             return;
         }
         let t0 = now_ms();
+        // A script may have switched windows since the last frame.
+        self.follow_active_window();
+        // Native windows: menu commands and screenshots go to the focused one.
+        let focused = !self.native_windows || self.focus_window == self.ui_window;
         text_box::before_ui(self, &ctx);
         // Another window came forward without going through a command (which settles drafts
         // first): the draft goes into its own window instead of floating over this one. If its
@@ -1428,8 +1530,10 @@ impl SheetApp {
         dialogs::show(self, &ctx);
         widgets::message_box(self, &ctx);
         widgets::toast(self, &ctx);
-        control::issue_screenshots(self, &ctx);
-        control::collect_screenshots(self, &ctx);
+        if focused {
+            control::issue_screenshots(self, &ctx);
+            control::collect_screenshots(self, &ctx);
+        }
         if !ctx.input(|i| i.focused) {
             // Nothing else to do.
         }
@@ -1453,8 +1557,10 @@ impl SheetApp {
             self.store_view_state();
             let _ = self.session.run("file.save", json!({}));
         }
-        // Window title.
-        if let Some(d) = self.session.active() {
+        // Window title (native windows get theirs from `doc_windows`).
+        if !self.native_windows
+            && let Some(d) = self.session.active()
+        {
             let title = format!("{}{}", d.display_title(), if d.is_dirty() { " — Edited" } else { "" });
             if self.grid.last_title.as_deref() != Some(title.as_str()) {
                 ctx.send_viewport_cmd(egui::ViewportCommand::Title(title.clone()));
diff --git a/crates/ui-egui/src/window_ui.rs b/crates/ui-egui/src/window_ui.rs
new file mode 100644
index 000000000..96aa83c79
--- /dev/null
+++ b/crates/ui-egui/src/window_ui.rs
@@ -0,0 +1,133 @@
+//! The interface state each window keeps for itself.
+//!
+//! [`SheetApp`]'s per-window fields (the cell draft, dialog, Backstage view, grid gestures…) hold
+//! the state of one window: the engine's active window. Every other window's state is parked in a
+//! [`WindowUi`] and swapped in when that window is activated or drawn, the way the engine swaps a
+//! window's selection and sheet into its workbook. So a draft, a dialog or a message stays in the
+//! window it belongs to.
+
+use gridcraft_engine::core::CellRef;
+
+use crate::{Notice, SheetApp, backstage, dialogs, editor, grid, keytips, text_box};
+
+/// One window's parked interface state (see the module docs).
+#[derive(Default)]
+pub struct WindowUi {
+    editor: Option<editor::EditState>,
+    text_box_editor: Option<text_box::EditState>,
+    dialog: Option<dialogs::Dialog>,
+    backstage: Option<backstage::Backstage>,
+    message: Option<(String, String)>,
+    toast: Option<(String, f64)>,
+    notice: Option<Notice>,
+    grid: grid::GridState,
+    name_box: Option<String>,
+    keytips: keytips::KeyTips,
+    selected_chart: Option<u32>,
+    tab_run: Option<(u64, usize, u32, CellRef)>,
+    open_switch_windows: bool,
+    /// The status bar's Ready/Enter/Edit, which follows the window's cell draft.
+    mode: gridcraft_engine::Mode,
+}
+
+impl WindowUi {
+    /// A new window's state. The last border, fill and font colour picked carry over, as they are
+    /// the user's recent choices rather than the window's.
+    fn fresh(like: &grid::GridState) -> WindowUi {
+        WindowUi {
+            grid: grid::GridState {
+                last_border: like.last_border.clone(),
+                last_fill: like.last_fill.clone(),
+                last_font_color: like.last_font_color.clone(),
+                ..Default::default()
+            },
+            ..Default::default()
+        }
+    }
+}
+
+impl SheetApp {
+    /// Exchanges the per-window fields with `w`. Destructured in full, so a field added to
+    /// [`WindowUi`] can't be left out of the swap.
+    fn swap_window_ui(&mut self, w: &mut WindowUi) {
+        let WindowUi {
+            editor,
+            text_box_editor,
+            dialog,
+            backstage,
+            message,
+            toast,
+            notice,
+            grid,
+            name_box,
+            keytips,
+            selected_chart,
+            tab_run,
+            open_switch_windows,
+            mode,
+        } = w;
+        std::mem::swap(&mut self.editor, editor);
+        std::mem::swap(&mut self.text_box_editor, text_box_editor);
+        std::mem::swap(&mut self.dialog, dialog);
+        std::mem::swap(&mut self.backstage, backstage);
+        std::mem::swap(&mut self.message, message);
+        std::mem::swap(&mut self.toast, toast);
+        std::mem::swap(&mut self.notice, notice);
+        std::mem::swap(&mut self.grid, grid);
+        std::mem::swap(&mut self.name_box, name_box);
+        std::mem::swap(&mut self.keytips, keytips);
+        std::mem::swap(&mut self.selected_chart, selected_chart);
+        std::mem::swap(&mut self.tab_run, tab_run);
+        std::mem::swap(&mut self.open_switch_windows, open_switch_windows);
+        std::mem::swap(&mut self.session.mode, mode);
+    }
+
+    /// The window whose interface state is in the per-window fields.
+    pub fn ui_window(&self) -> Option<u64> {
+        self.ui_window
+    }
+
+    /// Brings the per-window fields in line with the engine's active window, after a command (or
+    /// a script) switched windows: the previous window's state is parked, the active one's swapped
+    /// in (a window never seen before starts fresh). A closed window's state is dropped.
+    pub fn follow_active_window(&mut self) {
+        let active = self.session.active_window();
+        if active == self.ui_window {
+            return;
+        }
+        let Some(previous) = self.ui_window else {
+            // The first window: the fields are already its state.
+            self.ui_window = active;
+            return;
+        };
+        let mut outgoing = WindowUi::fresh(&self.grid);
+        self.swap_window_ui(&mut outgoing);
+        if self.session.window(previous).is_some() {
+            self.parked.insert(previous, outgoing);
+        }
+        if let Some(mut incoming) = active.and_then(|w| self.parked.remove(&w)) {
+            self.swap_window_ui(&mut incoming);
+        }
+        self.ui_window = active;
+        let session = &self.session;
+        self.parked.retain(|w, _| session.window(*w).is_some());
+    }
+
+    /// Activates window `id` (it becomes the most recently active) with its interface state.
+    pub fn enter_window(&mut self, id: u64) {
+        self.session.activate_window(id);
+        self.follow_active_window();
+    }
+
+    /// Makes window `id` and its interface state current while it is drawn, without changing
+    /// which window counts as most recently active.
+    pub fn show_window(&mut self, id: u64) {
+        self.session.show_window(id);
+        self.follow_active_window();
+    }
+
+    /// Whether a window other than the current one has a cell or text-box draft open.
+    pub fn parked_window_with_draft(&self) -> Option<u64> {
+        self.parked.iter().filter(|(_, w)| w.editor.is_some() || w.text_box_editor.is_some()).map(|(id, _)| *id).min()
+    }
+}
diff --git a/crates/ui-egui/tests/doc_windows.rs b/crates/ui-egui/tests/doc_windows.rs
new file mode 100644
index 000000000..ff8e2d631
--- /dev/null
+++ b/crates/ui-egui/tests/doc_windows.rs
@@ -0,0 +1,284 @@
+//! One native window per workbook window: each window keeps its own interface state, and closing
+//! or quitting asks about unsaved workbooks only when a workbook would close.
+//!
+//! The windows are drawn through a test backend that, like eframe, runs each immediate viewport
+//! as a nested pass with its own input, so a close button can be pressed on one window.
+#![cfg(not(target_arch = "wasm32"))]
+
+use std::cell::RefCell;
+
+use egui::{Context, RawInput, ViewportCommand, ViewportEvent, ViewportId, ViewportInfo};
+use gridcraft_engine::{Session, core::CellRef, core::Value};
+use gridcraft_ui_egui::doc_windows::DocWindows;
+use gridcraft_ui_egui::{SaveAnswer, SheetApp};
+use serde_json::json;
+
+thread_local! {
+    /// Each viewport's input for the next frame (focus, close button).
+    static INFOS: RefCell<egui::ViewportIdMap<ViewportInfo>> = RefCell::new(egui::ViewportIdMap::default());
+    /// The viewport commands the app sent this frame.
+    static SENT: RefCell<Vec<(ViewportId, ViewportCommand)>> = const { RefCell::new(Vec::new()) };
+}
+
+fn record(mut out: egui::FullOutput) {
+    out.textures_delta.clear(); // not painted
+    SENT.with(|s| {
+        let mut s = s.borrow_mut();
+        for (id, v) in &out.viewport_output {
+            s.extend(v.commands.iter().map(|c| (*id, c.clone())));
+        }
+    });
+}
+
+struct Desk {
+    ctx: Context,
+    app: SheetApp,
+    windows: DocWindows,
+}
+
+impl Desk {
+    fn new(quit_with_last_window: bool) -> Desk {
+        INFOS.with(|i| i.borrow_mut().clear());
+        let ctx = Context::default();
+        ctx.set_embed_viewports(false);
+        Context::set_immediate_viewport_renderer(|ctx, viewport| {
+            let id = viewport.ids.this;
+            let mut input = RawInput { viewport_id: id, ..RawInput::default() };
+            input.viewports = INFOS.with(|i| i.borrow().clone());
+            input.viewports.entry(id).or_default().parent = Some(viewport.ids.parent);
+            let mut cb = viewport.viewport_ui_cb;
+            record(ctx.run_ui(input, |ui| cb(ui)));
+        });
+        let mut session = Session::new();
+        session.new_workbook();
+        let mut app = SheetApp::new(session, Default::default());
+        let windows = DocWindows::new(&mut app, egui::ViewportBuilder::default(), quit_with_last_window);
+        let mut desk = Desk { ctx, app, windows };
+        desk.frames(3);
+        desk
+    }
+
+    /// One frame as eframe runs it; `act` runs first, inside the frame. Returns the viewport
+    /// commands sent.
+    fn frame_with(&mut self, act: impl FnOnce(&mut SheetApp, &Context)) -> Vec<(ViewportId, ViewportCommand)> {
+        SENT.with(|s| s.borrow_mut().clear());
+        let mut input = RawInput { viewport_id: ViewportId::ROOT, ..RawInput::default() };
+        input.viewports = INFOS.with(|i| i.borrow().clone());
+        input.viewports.entry(ViewportId::ROOT).or_default();
+        let Desk { ctx, app, windows } = self;
+        let mut act = Some(act);
+        let out = ctx.clone().run_ui(input, |ui| {
+            let ctx = ui.ctx().clone();
+            if let Some(act) = act.take() {
+                act(app, &ctx);
+            }
+            app.logic(&ctx);
+            windows.logic(app, &ctx);
+            windows.show(app, ui);
+        });
+        record(out);
+        // Close buttons are one-shot events.
+        INFOS.with(|i| i.borrow_mut().values_mut().for_each(|v| v.events.clear()));
+        SENT.with(|s| s.borrow().clone())
+    }
+
+    fn frames(&mut self, n: usize) -> Vec<(ViewportId, ViewportCommand)> {
+        (0..n).flat_map(|_| self.frame_with(|_, _| {})).collect()
+    }
+
+    fn viewport(&self, window: u64) -> ViewportId {
+        self.windows.viewport_of(window).unwrap_or_else(|| panic!("window {window} has no native window"))
+    }
+
+    /// The user presses window `window`'s close button.
+    fn close(&mut self, window: u64) -> Vec<(ViewportId, ViewportCommand)> {
+        let vp = self.viewport(window);
+        INFOS.with(|i| i.borrow_mut().entry(vp).or_default().events.push(ViewportEvent::Close));
+        let mut sent = self.frame_with(|_, _| {});
+        sent.extend(self.frames(2));
+        sent
+    }
+
+    /// Answers the Save Changes question showing in the active window, as its button does.
+    fn answer(&mut self, answer: SaveAnswer) -> Vec<(ViewportId, ViewportCommand)> {
+        let mut sent = self.frame_with(|app, ctx| {
+            let d = app.dialog.take().unwrap_or_else(|| panic!("no question is showing"));
+            assert_eq!(d.name(), "saveChanges");
+            let quitting = d.values.get("quit").and_then(serde_json::Value::as_bool) == Some(true);
+            app.answer_save_changes(answer, quitting, ctx);
+        });
+        sent.extend(self.frames(2));
+        sent
+    }
+
+    fn window_of(&self, doc: usize) -> u64 {
+        let uid = self.app.session.documents()[doc].uid;
+        self.app.session.doc_window(uid).unwrap_or_default()
+    }
+}
+
+fn sent_to(sent: &[(ViewportId, ViewportCommand)], vp: ViewportId, cmd: &ViewportCommand) -> bool {
+    sent.iter().any(|(id, c)| *id == vp && c == cmd)
+}
+
+#[test]
+fn each_window_keeps_its_own_selection_and_draft() {
+    let mut desk = Desk::new(true);
+    desk.app.run("file.new", json!({})).unwrap();
+    desk.frames(3);
+    let (w1, w2) = (desk.window_of(0), desk.window_of(1));
+    assert_eq!(desk.windows.shown_windows(), [w1, w2], "a native window per workbook");
+    assert_ne!(desk.viewport(w1), desk.viewport(w2));
+
+    desk.app.enter_window(w1);
+    desk.app.run("selection.set", json!({"range": "B2"})).unwrap();
+    desk.app.begin_edit(Some("one".into()), false);
+    desk.frames(2);
+    desk.app.enter_window(w2);
+    desk.app.run("selection.set", json!({"range": "D4"})).unwrap();
+    desk.app.begin_edit(Some("two".into()), false);
+    desk.frames(3);
+
+    for (w, cell, text) in [(w1, "B2", "one"), (w2, "D4", "two")] {
+        desk.app.enter_window(w);
+        assert_eq!(desk.app.editor.as_ref().map(|ed| ed.text.as_str()), Some(text), "window {w} keeps its draft");
+        assert!(desk.app.grid.rect.is_some(), "window {w} drew its own grid");
+        assert_eq!(desk.app.session.doc().unwrap().selection.active, CellRef::parse(cell).unwrap(), "window {w} keeps its selection");
+    }
+    assert!(desk.app.session.documents().iter().all(|d| !d.is_dirty()), "drawing the other window commits no draft");
+}
+
+#[test]
+fn closing_one_of_two_windows_on_a_workbook_does_not_ask() {
+    let mut desk = Desk::new(true);
+    desk.app.run("cell.set", json!({"cell": "A1", "input": "42"})).unwrap();
+    desk.app.run("view.newWindow", json!({})).unwrap();
+    desk.frames(3);
+    let windows = desk.windows.shown_windows();
+    assert_eq!(windows.len(), 2, "New Window opens a native window");
+    let child = windows.iter().copied().find(|w| Some(*w) != desk.windows.root_window()).unwrap();
+
+    let sent = desk.close(child);
+    assert!(desk.app.dialog.is_none(), "the workbook stays open in its other window: nothing to ask");
+    assert_eq!(desk.app.session.documents().len(), 1);
+    assert_eq!(desk.app.session.windows().len(), 1);
+    assert!(desk.app.session.documents()[0].is_dirty(), "its changes are kept");
+    assert_eq!(desk.windows.shown_windows().len(), 1);
+    assert!(!sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "{sent:?}");
+}
+
+#[test]
+fn closing_the_last_window_of_an_unsaved_workbook_asks_and_the_app_quits_after() {
+    let mut desk = Desk::new(true);
+    desk.app.run("cell.set", json!({"cell": "A1", "input": "42"})).unwrap();
+    desk.frames(2);
+    let w = desk.window_of(0);
+    let sent = desk.close(w);
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::CancelClose), "the window stays open to ask: {sent:?}");
+    assert_eq!(desk.app.dialog.as_ref().map(|d| d.name()), Some("saveChanges"));
+    assert_eq!(desk.app.session.documents().len(), 1);
+
+    let sent = desk.answer(SaveAnswer::Cancel);
+    assert!(!sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "Cancel keeps it open");
+    assert_eq!(desk.app.session.documents().len(), 1);
+
+    desk.close(w);
+    let sent = desk.answer(SaveAnswer::DontSave);
+    assert!(desk.app.session.documents().is_empty());
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "the last window closed: the app quits: {sent:?}");
+    assert!(desk.app.allow_close);
+}
+
+#[test]
+fn without_quitting_on_the_last_window_the_app_hides_and_new_shows_it_again() {
+    let mut desk = Desk::new(false);
+    let w = desk.window_of(0);
+    let sent = desk.close(w);
+    assert!(desk.app.session.documents().is_empty(), "a clean workbook closes without asking");
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Visible(false)), "{sent:?}");
+    assert!(!sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "the app keeps running: {sent:?}");
+    assert!(desk.app.session.documents().is_empty(), "and doesn't make a workbook of its own");
+
+    let sent = desk.frame_with(|app, _| app.run_or_alert("file.new", json!({})));
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Visible(true)), "{sent:?}");
+    assert_eq!(desk.windows.root_window(), Some(desk.window_of(0)));
+}
+
+#[test]
+fn quit_asks_about_each_unsaved_workbook_in_its_window_and_cancel_stops() {
+    let mut desk = Desk::new(true);
+    desk.app.run("cell.set", json!({"cell": "A1", "input": "1"})).unwrap();
+    desk.app.run("file.new", json!({})).unwrap();
+    desk.app.run("cell.set", json!({"cell": "A1", "input": "2"})).unwrap();
+    desk.frames(3);
+    let (w1, w2) = (desk.window_of(0), desk.window_of(1));
+    assert_eq!(desk.app.session.active_window(), Some(w2));
+
+    let sent = desk.frame_with(|app, ctx| app.request_quit(ctx));
+    assert_eq!(desk.app.session.active_window(), Some(w1), "Book1's window comes forward to ask");
+    assert!(sent_to(&sent, desk.viewport(w1), &ViewportCommand::Focus), "{sent:?}");
+    assert_eq!(desk.app.dialog.as_ref().map(|d| d.name()), Some("saveChanges"));
+    let sent = desk.answer(SaveAnswer::Cancel);
+    assert!(!sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "Cancel stops the quit: {sent:?}");
+    assert_eq!(desk.app.session.documents().len(), 2);
+    assert!(desk.app.dialog.is_none());
+
+    desk.frame_with(|app, ctx| app.request_quit(ctx));
+    let sent = desk.answer(SaveAnswer::DontSave);
+    assert!(!sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "Book2 is still unsaved: {sent:?}");
+    assert_eq!(desk.app.session.active_window(), Some(w2), "then Book2's window asks");
+    assert_eq!(desk.app.dialog.as_ref().map(|d| d.name()), Some("saveChanges"));
+    let sent = desk.answer(SaveAnswer::DontSave);
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "both answered: the app quits: {sent:?}");
+}
+
+#[test]
+fn the_root_adopts_the_remaining_window_with_its_workbook_and_state() {
+    let mut desk = Desk::new(true);
+    desk.app.run("file.new", json!({})).unwrap();
+    desk.frames(3);
+    let (w1, w2) = (desk.window_of(0), desk.window_of(1));
+    assert_eq!(desk.windows.root_window(), Some(w1));
+    let book2 = desk.app.session.documents()[1].uid;
+    desk.app.enter_window(w2);
+    desk.app.run("selection.set", json!({"range": "C3"})).unwrap();
+    desk.app.begin_edit(Some("kept".into()), false);
+    desk.frames(2);
+
+    let sent = desk.close(w1);
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::CancelClose), "closing the root's window doesn't end the app: {sent:?}");
+    assert!(!sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "{sent:?}");
+    assert_eq!(desk.windows.root_window(), Some(w2), "Book2's window moves into the root");
+    assert_eq!(desk.windows.shown_windows(), [w2]);
+    assert_eq!(desk.app.session.documents().len(), 1);
+    assert_eq!(desk.app.session.doc().unwrap().uid, book2);
+    assert_eq!(desk.app.editor.as_ref().map(|ed| ed.text.as_str()), Some("kept"), "its draft is still open");
+    assert_eq!(desk.app.session.doc().unwrap().selection.active, CellRef::parse("C3").unwrap());
+    assert_eq!(desk.app.session.doc().unwrap().wb.active().unwrap().value(CellRef::parse("C3").unwrap()), Value::Empty);
+}
+
+#[test]
+fn menu_commands_follow_the_focused_window_and_leaving_a_window_enters_its_draft() {
+    let mut desk = Desk::new(true);
+    desk.app.run("file.new", json!({})).unwrap();
+    desk.frames(3);
+    let (w1, w2) = (desk.window_of(0), desk.window_of(1));
+    desk.app.begin_edit(Some("typed".into()), false);
+    desk.frames(2);
+    assert_eq!(desk.app.session.active_window(), Some(w2));
+
+    // The user clicks into Book1's window.
+    let (v1, v2) = (desk.viewport(w1), desk.viewport(w2));
+    INFOS.with(|i| {
+        let mut i = i.borrow_mut();
+        i.entry(v1).or_default().focused = Some(true);
+        i.entry(v2).or_default().focused = Some(false);
+    });
+    desk.frames(2);
+    assert_eq!(desk.app.session.active_window(), Some(w1), "commands from the menu bar go to the window focused last");
+    assert!(desk.app.editor.is_none(), "Book1's window has no draft");
+    let book2 = &desk.app.session.documents()[1];
+    assert_eq!(book2.wb.active().unwrap().value(CellRef::new(0, 0)), Value::text("typed"), "the draft was entered in its own window");
+    desk.app.run("cell.set", json!({"cell": "B1", "input": "menu"})).unwrap();
+    assert_eq!(desk.app.session.documents()[0].wb.active().unwrap().value(CellRef::new(0, 1)), Value::text("menu"));
+}
diff --git a/docs/hardware-parity.md b/docs/hardware-parity.md
index 3f9135c49..f19b4a49d 100644
--- a/docs/hardware-parity.md
+++ b/docs/hardware-parity.md
@@ -1,6 +1,6 @@
 # Hardware parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (direct desktop printing through craft-print) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (a native window per workbook window) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 The hardware Excel uses, per platform, against GridCraft. Part of
 [target-app-parity.md](target-app-parity.md). **Hardware: ~40% ready, 25–40 h** (estimated).
@@ -11,7 +11,7 @@ The hardware Excel uses, per platform, against GridCraft. Part of
 | GPU rendering of the grid and charts | DirectX / Metal accelerated drawing | wgpu: Metal · DirectX 12 (default since 10-08; OpenGL when DirectX 12 has no GPU driver or fails to start; Vulkan only on request, so the Intel UHD `igvk64.dll` crash (#120) can't happen; shaders compiled with FXC, so no DXC runtime is needed, #339) · Vulkan/GL · Vulkan/GL · WebGPU or WebGL2 | At parity in kind. Driver problems: screen flashing on Windows 11 (#76): 2–4 h |
 | Pen and touch (Draw tab) | Pen pressure and tilt, eraser end, touch mode, Ink to Shape, ink replay | Pen, highlighter, eraser, Ink to Shape with mouse/pen input; **no pressure or tilt**, no touch mode | Pressure-sensitive strokes where winit reports force; touch-friendly ribbon spacing: 4–6 h |
 | Trackpad and mouse | Smooth scrolling, pinch zoom, horizontal scroll, Magic Mouse | Smooth scrolling and zoom via egui | Verify pinch zoom on each platform: 1–2 h |
-| Multiple windows and monitors | One window per workbook, New Window for the same workbook, per-monitor DPI | One window; multiple workbooks switch inside it (#162; PR #171) | Native window per workbook, New Window, Arrange All across monitors: 6–8 h |
+| Multiple windows and monitors | One window per workbook, New Window for the same workbook, per-monitor DPI | A native window per workbook window on the desktop, New Window for the same workbook; new windows cascade from the last one on its monitor (web: one window) | Arrange All across monitors; verify per-monitor DPI with windows on two monitors: 2–3 h |
 | High-DPI and display scaling | yes | yes (display scale matched to desktop density; View › Interface size 75–200 % on top, #230) | — |
 | Accessibility hardware (screen readers, braille displays, switch control) | Narrator, JAWS, NVDA, VoiceOver | AccessKit enabled in eframe; grid cells and ribbon not yet exposed as an accessible tree | Counted under UI ([ui-parity.md](ui-parity.md)) |
 | Printers | System print with driver options | Desktop submits through craft-print with printer choice, copies, duplex and grayscale; web browser printing | Counted under print |
@@ -20,6 +20,7 @@ The hardware Excel uses, per platform, against GridCraft. Part of
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | Multiple windows: each workbook window is a native window of its own (desktop). |
 | 2026-10-12 | minor | Desktop File > Print now discovers printers and submits PDF jobs through pinned craft-print with printer choice, copies, duplex and grayscale; browser printing and PDF export remain available. Remaining print parity includes page ranges and driver-specific tray/options UI; physical printer fidelity needs hardware validation. |
 | 2026-10-11 | trivial | Windows: DirectX 12 shaders compiled with FXC, no DXC runtime needed (#339, #354) |
 | 2026-10-11 | trivial | Windows: OpenGL fallback when DirectX 12 has no GPU or fails to start; Vulkan never by default (#120) |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 839984959..817b5b915 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (New Window opens a second window on the same workbook, titled Name:1 / Name:2; Switch Windows lists the open windows; a cell being typed stays in its own window through New, Open and window switches; macOS Quit asks about unsaved workbooks) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (every workbook window is a native window of its own on the desktop, with its own draft, dialog and ribbon; closing one of several windows on a workbook doesn't ask; Quit asks about each unsaved workbook in its window; the last window closed quits on Windows and Linux, macOS keeps running) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md).
 **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured
@@ -33,8 +33,8 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes
 | Backstage (File) view: Info, New with templates, Open recent, Export, Options | yes | yes (#174, 10-11): the File tab opens a full-window view (Esc or the back arrow return) with Home, New (blank + the three samples), Open (recent + Browse; the recent list tells when each workbook was last changed, 10-12), Info (location, properties, Protect Workbook), Save, Save As, Print (page preview, active sheet or workbook, fit to page, Page Setup), Export (PDF, CSV, web page), Close and Options (`file.options`: theme, language, formula bar, AutoSave, calculation) | no Account, Share or template gallery beyond the samples; Options applies at once (no OK/Cancel dialog) and holds only the settings GridCraft has |
 | Dark mode, system appearance | yes | yes | done (10-09) |
 | Page Layout view (paper view with rulers and header editing) | yes | yes (#329, 10-11): per-sheet view saved in XLSX, pages with margins and gaps on the print pagination, "Click to add data" pages, rulers (inches or centimetres), headers and footers drawn and edited in place with a Header & Footer tab | margins drag on the rulers (#792, with header and footer margins); header/footer pictures, Different First Page / Odd & Even missing (1–3 h) |
-| Multiple windows per workbook | yes | no (#162) | see [hardware-parity.md](hardware-parity.md) |
-| Switch Windows, New Window, unsaved workbooks on quit | yes | yes (10-22): View › New Window opens another window on the same workbook (no copy: saving from either saves it), each with its own selection, active sheet and scroll; a workbook with several windows titles them "Book1:1", "Book1:2"; File › Close closes one of them without asking and asks only for the last; View › Switch Windows and the macOS Window menu list the open windows (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {window}`, or `{doc}` for a workbook's most recent window); a cell being typed is entered into its own window and workbook before New, Open, Close, Save, Print and window switches (also between two windows on one workbook), and a refused entry stays open and stops the command; quitting (window close, Cmd+Q, the macOS Quit item) asks Save / Don't Save / Cancel for each unsaved workbook | one OS window for all workbooks (#162) |
+| Multiple windows per workbook | yes | yes (10-22, desktop): each workbook window is a native window of its own (New, Open and New Window open one; titles "Book1", or "Book1:1" / "Book1:2" for a workbook's second window, with " — Edited" while unsaved). Each window keeps its own cell draft, dialog, Backstage view, message and grid state, and its ribbon acts on it; on macOS the menu bar acts on the window focused last. Leaving a window enters its draft as Enter would. A window's close button closes that window: one of several on a workbook closes without asking, a workbook's last asks Save / Don't Save / Cancel when unsaved. Quit asks about each unsaved workbook in its window, and Cancel stops it. The last window closed quits on Windows and Linux; macOS keeps running with the menu bar until New or Open. Web: one window | no Arrange All; a hidden window (View › Hide) has no native window; every window repaints when one does; see [hardware-parity.md](hardware-parity.md) |
+| Switch Windows, New Window, unsaved workbooks on quit | yes | yes (10-22): View › New Window opens another window on the same workbook (no copy: saving from either saves it), each with its own selection, active sheet and scroll; a workbook with several windows titles them "Book1:1", "Book1:2"; File › Close closes one of them without asking and asks only for the last; View › Switch Windows and the macOS Window menu list the open windows (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {window}`, or `{doc}` for a workbook's most recent window); a cell being typed is entered into its own window and workbook before New, Open, Close, Save, Print and window switches (also between two windows on one workbook), and a refused entry stays open and stops the command; quitting (Cmd+Q, the macOS Quit item, the Dock) asks Save / Don't Save / Cancel for each unsaved workbook | |
 
 ## Grid interaction
 
@@ -177,6 +177,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | One native window per workbook window on the desktop: per-window drafts, dialogs and ribbons; menu bar commands go to the focused window; closing one of several windows on a workbook doesn't ask; Quit asks in each unsaved workbook's window; the last window closed quits (Windows, Linux) or leaves macOS running |
 | 2026-10-22 | minor | New Window opens a second window on the same workbook instead of a copy that saved over the original; windows keep their own selection, sheet and scroll; titles Name:1 / Name:2; Switch Windows, Hide and Unhide work by window; File › Close closes one window of several without asking |
 | 2026-10-22 | minor | New workbook no longer loses the first one: the cell being typed is entered into its own workbook before any File or window command (an entry the workbook refuses stays open and the command doesn't run; an untouched F2 draft changes nothing), the editor is tied to its workbook, View › Switch Windows and the macOS Window menu list the open workbooks, and the macOS Quit item asks about unsaved workbooks like the close button |
 | 2026-10-21 | minor | Background error checking, first part (#1994): a constant whose text would be a number if typed (signs, thousands, currency, percent, exponent, parenthesised negative) gets Excel's green corner triangle; the active cell then shows a warning button whose menu names the problem and offers Convert to Number for the selection (`formulas.convertToNumber`). Dates, times and fractions kept as text and formula results are not flagged, as in Excel |

From d4db58cde467f7a412293e55861d390a7f77b4ad Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 16:29:24 +0000
Subject: [PATCH 06/76] G3: feedback from a command that switched windows shows
 in the window it left active

after_engine, show_open_warnings and alert bring the per-window state in line
with the engine's active window first, so a notice, message or toast from
opening a workbook (also by a script on the session) lands in the opened
workbook's window instead of being parked with the previous one.
---
 crates/ui-egui/src/lib.rs           |  7 +++++++
 crates/ui-egui/tests/doc_windows.rs | 25 +++++++++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index f405a3d18..19f69a90f 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -648,6 +648,8 @@ impl SheetApp {
 
     /// Shows a command error: a toast for an unavailable command, else a message box.
     fn alert(&mut self, e: String) {
+        // Shown in the window the user ends up in, also after a command that switched windows.
+        self.follow_active_window();
         if e.contains("is not available right now") {
             self.toast = Some((e, now_ms()));
         } else {
@@ -799,6 +801,8 @@ impl SheetApp {
 
     /// Picks up requests commands made (dialogs, edit mode…).
     pub fn after_engine(&mut self) {
+        // The requests belong to the window the command left active.
+        self.follow_active_window();
         for req in self.session.take_ui_requests() {
             match req {
                 UiRequest::Dialog(name, params) => self.open_dialog(&name, params),
@@ -924,6 +928,9 @@ impl SheetApp {
     /// most important one (a preserved VBA project outranks, say, a skipped optional part).
     /// Kept deliberately generic: any open-time warning can reach the user this way.
     pub fn show_open_warnings(&mut self, r: &Json) {
+        // The opened workbook's window shows them, however it was opened (a script may have run
+        // `file.open` on the session directly).
+        self.follow_active_window();
         let Some(list) = r.get("warnings").and_then(Json::as_array) else {
             self.notice = None;
             return;
diff --git a/crates/ui-egui/tests/doc_windows.rs b/crates/ui-egui/tests/doc_windows.rs
index ff8e2d631..b6d518ce2 100644
--- a/crates/ui-egui/tests/doc_windows.rs
+++ b/crates/ui-egui/tests/doc_windows.rs
@@ -282,3 +282,28 @@ fn menu_commands_follow_the_focused_window_and_leaving_a_window_enters_its_draft
     desk.app.run("cell.set", json!({"cell": "B1", "input": "menu"})).unwrap();
     assert_eq!(desk.app.session.documents()[0].wb.active().unwrap().value(CellRef::new(0, 1)), Value::text("menu"));
 }
+
+#[test]
+fn feedback_from_opening_a_workbook_shows_in_its_new_window() {
+    let mut desk = Desk::new(true);
+    desk.app.run("cell.set", json!({"cell": "A1", "input": "kept"})).unwrap();
+    desk.frames(2);
+    let book1 = desk.window_of(0);
+    let mut wb = gridcraft_engine::model::Workbook::new();
+    wb.vba_project = Some(b"\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1 fake OLE2 vbaProject".to_vec().into());
+    let b64 = gridcraft_engine::io::base64_encode(&gridcraft_engine::io::save_bytes(&wb, "macros.xlsm").unwrap());
+    desk.frame_with(|app, _| {
+        // A script opening the file on the session, then the interface reporting on it.
+        let r = app.session.run("file.open", json!({"name": "macros.xlsm", "base64": b64})).unwrap();
+        app.show_open_warnings(&r);
+        app.run_or_alert("no.such.command", json!({}));
+    });
+    desk.frames(2);
+    let opened = desk.window_of(1);
+    assert_eq!(desk.windows.shown_windows(), [book1, opened]);
+    assert_eq!(desk.app.session.active_window(), Some(opened));
+    assert_eq!(desk.app.notice.as_ref().map(|n| n.kind), Some(gridcraft_ui_egui::NoticeKind::Warning), "the macro notice shows in the opened window");
+    assert!(desk.app.message.is_some(), "and so does the alert");
+    desk.app.enter_window(book1);
+    assert!(desk.app.notice.is_none() && desk.app.message.is_none(), "Book1's window shows neither");
+}

From 2ed3df2bd64d2022d28ce588e6275babd6d654ce Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Thu, 22 Oct 2026 16:50:10 +0000
Subject: [PATCH 07/76] G4: two windows on one workbook without copying it;
 Arrange All

- The workbook's active sheet is an atomic set in place (Workbook::active_sheet /
  set_active_sheet), so a window swap or sheet switch never clones the
  Arc<Workbook> or marks it dirty. Selections already live in DocState and the
  window views. Save records the sheet of the most recently active window.
- A dialog taken out of its window while it runs goes back to that window when
  a command run from it switched windows (dialogs::show, ui.dialog.confirm).
- view.arrangeAll {arrange?: tiled|horizontal|vertical|cascade, activeWorkbook?}
  returns the visible windows, active first; the desktop moves and sizes the
  native windows over the main window's monitor. New Window and Arrange All
  buttons on the View ribbon; Arrange Windows dialog.
- Docs: ui-parity, hardware-parity, gaps #20, target-app-parity, ROADMAP.
---
 ROADMAP.md                                    |   4 +-
 crates/engine/src/cmd/analysis.rs             |   2 +-
 crates/engine/src/cmd/data.rs                 |  18 +--
 crates/engine/src/cmd/draw.rs                 |   4 +-
 crates/engine/src/cmd/edit.rs                 |  27 ++---
 crates/engine/src/cmd/extra.rs                |  51 ++++++--
 crates/engine/src/cmd/file.rs                 |   4 +-
 crates/engine/src/cmd/forecast.rs             |  10 +-
 crates/engine/src/cmd/format.rs               |   2 +-
 crates/engine/src/cmd/formulas.rs             |  16 +--
 crates/engine/src/cmd/insert.rs               |  22 ++--
 crates/engine/src/cmd/inspect.rs              |   2 +-
 crates/engine/src/cmd/mod.rs                  |   6 +-
 crates/engine/src/cmd/pivot.rs                |  16 +--
 crates/engine/src/cmd/print.rs                |   6 +-
 crates/engine/src/cmd/review.rs               |   6 +-
 crates/engine/src/cmd/sheet.rs                |  20 ++--
 crates/engine/src/cmd/slicer.rs               |   6 +-
 crates/engine/src/cmd/solver.rs               |  12 +-
 crates/engine/src/cmd/view.rs                 |   4 +-
 crates/engine/src/cmd/whatif.rs               |  14 +--
 crates/engine/src/io.rs                       |   2 +-
 crates/engine/src/lib.rs                      |   4 +-
 crates/engine/src/sample.rs                   |   2 +-
 crates/engine/src/tests.rs                    |  75 +++++++++++-
 crates/engine/src/windows.rs                  |  30 ++---
 crates/engine/tests/command_sequence_fuzz.rs  |   6 +-
 .../engine/tests/hidden_sheet_navigation.rs   |  12 +-
 crates/model/src/workbook.rs                  |  68 ++++++++++-
 crates/ui-egui/examples/snapshot.rs           |   2 +-
 crates/ui-egui/src/control.rs                 |   3 +-
 crates/ui-egui/src/dialogs.rs                 |  30 ++++-
 crates/ui-egui/src/doc_windows.rs             |  74 +++++++++++-
 crates/ui-egui/src/formula_bar.rs             |   6 +-
 crates/ui-egui/src/grid.rs                    |  33 ++---
 crates/ui-egui/src/lib.rs                     |  27 +++--
 crates/ui-egui/src/panes.rs                   |   2 +-
 crates/ui-egui/src/paper_view.rs              |   8 +-
 crates/ui-egui/src/ribbon.rs                  |  12 +-
 crates/ui-egui/src/tabs.rs                    |  10 +-
 crates/ui-egui/src/text_box.rs                |   2 +-
 crates/ui-egui/src/window_ui.rs               |  13 ++
 crates/ui-egui/tests/commit_after_pointing.rs |   4 +-
 crates/ui-egui/tests/doc_windows.rs           | 113 ++++++++++++++++++
 crates/ui-egui/tests/popup_dismissal.rs       |   2 +-
 crates/ui-egui/tests/sheet_navigator.rs       |   4 +-
 crates/ui-egui/tests/sheet_tabs.rs            |   6 +-
 crates/ui-egui/tests/trace_navigation.rs      |   4 +-
 crates/xlsx/src/read.rs                       |   2 +-
 crates/xlsx/src/write.rs                      |   4 +-
 crates/xlsx/src/xls/mod.rs                    |   2 +-
 crates/xlsx/src/xlsb.rs                       |   2 +-
 docs/gaps.md                                  |   7 +-
 docs/hardware-parity.md                       |   5 +-
 docs/target-app-parity.md                     |   9 +-
 docs/ui-parity.md                             |   7 +-
 56 files changed, 620 insertions(+), 224 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 38c394fb0..782c00e3a 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (a native window per workbook window; no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save; New Window shares the workbook) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (Arrange All; a native window per workbook window; no lost workbook after New: drafts stay in their workbook, Switch Windows, macOS Quit asks to save; New Window shares the workbook) · **Target:** Microsoft Excel (Microsoft 365)
 
 GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX
 is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web.
@@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | What landed |
 |---|---|
+| 2026-10-22 | View › New Window and Arrange All on the ribbon. Arrange All tiles, stacks side by side or top to bottom, or cascades the native windows over the main window's monitor, the active one first. Two windows on one workbook show different sheets without copying the workbook or marking it changed; Save records the sheet of the window used last. A dialog stays in the window it was opened in |
 | 2026-10-22 | On the desktop every workbook window is a native window of its own: New, Open and New Window open one, each keeps its own cell draft, dialog and ribbon, and the macOS menu bar acts on the window focused last. Closing one of several windows on a workbook doesn't ask; closing a workbook's last window, or quitting, asks about unsaved changes in that window. The last window closed quits on Windows and Linux; macOS keeps running with the menu bar. First craft-libs `craft-window` use (window list and viewport driver) |
 | 2026-10-22 | View › New Window opens a second window on the same workbook (it used to open a copy whose Save overwrote the original): each window has its own selection, active sheet and scroll, titles read "Book1:1" / "Book1:2", and Switch Windows, Hide, Unhide and Close act per window. The control channel, CLI `send` and MCP tools take an optional `window` or `doc` id and default to the active window; `window.list` (MCP `list_windows`) lists the windows |
 | 2026-10-22 | Typing in a cell and then choosing File › New no longer strands the first workbook: the entry is committed into its own workbook before any File or window command (a refused entry stays open and stops the command), View › Switch Windows and the macOS Window menu list the open workbooks with unsaved markers, `view.switchWindows {doc}` switches by a stable workbook id, and the macOS Quit item asks about unsaved workbooks |
@@ -223,6 +224,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | Progress log: Arrange All; two windows on one workbook without copying it |
 | 2026-10-22 | minor | Progress log: a native window per workbook window |
 | 2026-10-22 | minor | Progress log: New Window shares the workbook; window ids for scripts and MCP |
 | 2026-10-22 | minor | Progress log: drafts stay in their workbook, Switch Windows, macOS Quit asks to save |
diff --git a/crates/engine/src/cmd/analysis.rs b/crates/engine/src/cmd/analysis.rs
index 8ff7e3582..6225b4934 100644
--- a/crates/engine/src/cmd/analysis.rs
+++ b/crates/engine/src/cmd/analysis.rs
@@ -1182,7 +1182,7 @@ mod tests {
     fn v(s: &Session, a: &str) -> Value {
         let d = s.doc().unwrap();
         let (sh, body) = crate::cmd::split_sheet(a);
-        let si = sh.map(|n| d.wb.sheet_index(&n).unwrap()).unwrap_or(d.wb.active_sheet);
+        let si = sh.map(|n| d.wb.sheet_index(&n).unwrap()).unwrap_or(d.wb.active_sheet());
         d.wb.sheet(si).unwrap().value(CellRef::parse(body).unwrap())
     }
     fn n(s: &Session, a: &str) -> f64 {
diff --git a/crates/engine/src/cmd/data.rs b/crates/engine/src/cmd/data.rs
index 52a716cff..8ffab2b51 100644
--- a/crates/engine/src/cmd/data.rs
+++ b/crates/engine/src/cmd/data.rs
@@ -158,7 +158,7 @@ fn data_target(s: &Session, p: &Json, cmd: &str) -> Result<(usize, RangeRef)> {
     {
         return Err(bad(cmd, format!("`{t}` names a sheet other than `sheet`")));
     }
-    if sheet != d.wb.active_sheet && p.get("range").is_none() {
+    if sheet != d.wb.active_sheet() && p.get("range").is_none() {
         return Err(bad(cmd, "missing `range`: the selection is on the active sheet"));
     }
     Ok((sheet, data_range(s, p)?))
@@ -210,7 +210,7 @@ fn sort_target(s: &Session, p: &Json) -> Result<(usize, RangeRef)> {
     {
         return Err(bad("data.sort", format!("`{t}` names a sheet other than `sheet`")));
     }
-    if sheet != d.wb.active_sheet && p.get("range").is_none() {
+    if sheet != d.wb.active_sheet() && p.get("range").is_none() {
         return Err(bad("data.sort", "missing `range`: the selection is on the active sheet"));
     }
     Ok((sheet, data_range(s, p)?))
@@ -502,7 +502,7 @@ fn toggle_filter(s: &mut Session, p: &Json) -> Result<Json> {
     let (sheet, r) = data_target(s, p, "data.filter")?;
     super::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
     // The active cell belongs to the active sheet: on another sheet the table is the one at `range`.
-    let at = if sheet == s.doc()?.wb.active_sheet { s.doc()?.selection.active } else { r.start };
+    let at = if sheet == s.doc()?.wb.active_sheet() { s.doc()?.selection.active } else { r.start };
     let has = s.doc()?.wb.sheet(sheet).is_some_and(|sh| sh.autofilter.is_some());
     let in_table = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.table_at(at).map(|t| t.name.clone()));
     if let Some(name) = in_table {
@@ -554,7 +554,7 @@ fn install_filter(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 fn filter_by(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     super::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
     let Some(sh) = s.doc()?.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
     let af = match &sh.autofilter {
@@ -741,7 +741,7 @@ pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) {
 }
 
 fn clear_filter(s: &mut Session, _: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
         if let Some(a) = sh.autofilter.as_mut() {
@@ -754,7 +754,7 @@ fn clear_filter(s: &mut Session, _: &Json) -> Result<Json> {
 }
 
 fn reapply(s: &mut Session, _: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         apply_filter(&mut cx.wb, sheet);
         cx.structural = true;
@@ -1258,7 +1258,7 @@ fn validate_cmd(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
     let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
     let input = str_param(p, "input").unwrap_or("");
-    match check_validation(&d.wb, d.wb.active_sheet, at, input) {
+    match check_validation(&d.wb, d.wb.active_sheet(), at, input) {
         None => Ok(json!({"ok": true})),
         Some((dv, msg)) => Ok(json!({"ok": false, "message": msg, "title": dv.error_title, "style": format!("{:?}", dv.error_style)})),
     }
@@ -1266,7 +1266,7 @@ fn validate_cmd(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn circle_invalid(s: &mut Session, _: &Json) -> Result<Json> {
     let d = s.doc()?;
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
     let mut bad_cells = Vec::new();
     for dv in &sh.validations {
@@ -1305,7 +1305,7 @@ fn outline_lines(s: &Session, p: &Json) -> Result<(bool, u32, u32)> {
 fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
     let si = target_sheet(s, p)?;
     // The selection belongs to the active sheet, so another sheet needs its lines.
-    if si != s.doc()?.wb.active_sheet && p.get("rows").is_none() && p.get("cols").is_none() {
+    if si != s.doc()?.wb.active_sheet() && p.get("rows").is_none() && p.get("cols").is_none() {
         return Err(bad(if on { "data.group" } else { "data.ungroup" }, "missing `rows` or `cols`: the selection is on the active sheet"));
     }
     let (rows, a, b) = outline_lines(s, p)?;
diff --git a/crates/engine/src/cmd/draw.rs b/crates/engine/src/cmd/draw.rs
index af3e65e28..a86be3099 100644
--- a/crates/engine/src/cmd/draw.rs
+++ b/crates/engine/src/cmd/draw.rs
@@ -72,7 +72,7 @@ fn stroke(s: &mut Session, p: &Json) -> Result<Json> {
         str_param(p, "color").map(str::to_string).unwrap_or_else(|| if s.draw_color.is_empty() { "#1F5FC9".into() } else { s.draw_color.clone() });
     let width = f64_param(p, "width").map(|w| w as f32).unwrap_or(if s.draw_width <= 0.0 { 2.0 } else { s.draw_width }).clamp(0.5, 40.0);
     let d = s.doc()?;
-    let si = d.wb.active_sheet;
+    let si = d.wb.active_sheet();
     let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
     let cell = CellRef::new(sh.row_at(miny), sh.col_at(minx));
     let dx = (minx - sh.col_left(cell.col)) as f32;
@@ -115,7 +115,7 @@ pub fn ink_points(sh: &Shape) -> Vec<[f32; 2]> {
 }
 
 fn ink_to_shape(s: &mut Session, p: &Json) -> Result<Json> {
-    let si = s.doc()?.wb.active_sheet;
+    let si = s.doc()?.wb.active_sheet();
     let id = u32_param(p, "id");
     edit(s, |cx| {
         let sh = cx.sheet_mut(si)?;
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index e53740712..77c2fb8a0 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -237,7 +237,7 @@ fn cell_set(s: &mut Session, p: &Json) -> Result<Json> {
     {
         return Err(EngineError::Other(m));
     }
-    let active_sheet = s.doc()?.wb.active_sheet;
+    let active_sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         if array {
             // Legacy Ctrl+Shift+Enter array formula over the selection, when the selection holds
@@ -414,23 +414,18 @@ fn selection_set(s: &mut Session, p: &Json) -> Result<Json> {
 impl crate::DocState {
     /// Switches the active sheet, remembering each sheet's selection.
     pub fn wb_switch_sheet(&mut self, i: usize) {
-        if i >= self.wb.sheets.len() || i == self.wb.active_sheet {
+        if i >= self.wb.sheets.len() || i == self.wb.active_sheet() {
             return;
         }
-        let cur = self.wb.active_sheet;
+        let cur = self.wb.active_sheet();
         if self.sheet_selections.len() < self.wb.sheets.len() {
             self.sheet_selections.resize(self.wb.sheets.len(), crate::Selection::default());
         }
         if let Some(slot) = self.sheet_selections.get_mut(cur) {
             *slot = self.selection.clone();
         }
-        // The active sheet is view state: change it without making the workbook dirty.
-        let dirty = self.is_dirty();
-        let wb = std::sync::Arc::make_mut(&mut self.wb);
-        wb.active_sheet = i;
-        if !dirty {
-            self.saved = self.wb.clone();
-        }
+        // View state: set in place, so the workbook is neither copied nor made dirty.
+        self.wb.set_active_sheet(i);
         self.selection = self.sheet_selections.get(i).cloned().unwrap_or_default();
     }
 }
@@ -558,7 +553,7 @@ pub(super) fn go_to(s: &mut Session, p: &Json) -> Result<Json> {
     // A defined name or table?
     let d = s.doc()?;
     let resolved = if RangeRef::parse(split_sheet(reference).1).is_none() {
-        let sheet = d.wb.active_sheet;
+        let sheet = d.wb.active_sheet();
         if let Some(n) = d.wb.name(reference, sheet) {
             n.formula.clone()
         } else if let Some((si, ti)) = d.wb.table(reference) {
@@ -1535,7 +1530,7 @@ fn find(s: &mut Session, p: &Json) -> Result<Json> {
     let workbook = str_param(p, "within") == Some("workbook");
     s.last_find = Some(p.clone());
     let d = s.doc()?;
-    let sheets: Vec<usize> = if workbook { (0..d.wb.sheets.len()).collect() } else { vec![d.wb.active_sheet] };
+    let sheets: Vec<usize> = if workbook { (0..d.wb.sheets.len()).collect() } else { vec![d.wb.active_sheet()] };
     let mut hits: Vec<(usize, CellRef, String)> = Vec::new();
     for si in sheets {
         let Some(sh) = d.wb.sheet(si) else { continue };
@@ -1565,7 +1560,7 @@ fn find(s: &mut Session, p: &Json) -> Result<Json> {
         return Ok(json!({"count": list.len(), "results": list}));
     }
     // Next hit after the active cell.
-    let cur = (d.wb.active_sheet, d.selection.active);
+    let cur = (d.wb.active_sheet(), d.selection.active);
     let key = |si: usize, c: CellRef| if by_cols { (si, c.col, c.row) } else { (si, c.row, c.col) };
     let next = hits.iter().find(|(si, c, _)| key(*si, *c) > key(cur.0, cur.1)).or_else(|| hits.first()).cloned();
     let Some((si, c, t)) = next else { return Err(EngineError::Other("not found".into())) };
@@ -1587,7 +1582,7 @@ fn replace(s: &mut Session, p: &Json) -> Result<Json> {
     let workbook = str_param(p, "within") == Some("workbook");
     let active = s.doc()?.selection.active;
     let n = edit(s, |cx| {
-        let sheets: Vec<usize> = if workbook { (0..cx.wb.sheets.len()).collect() } else { vec![cx.wb.active_sheet] };
+        let sheets: Vec<usize> = if workbook { (0..cx.wb.sheets.len()).collect() } else { vec![cx.wb.active_sheet()] };
         let mut n = 0;
         for si in sheets {
             let cells: Vec<(CellRef, String)> =
@@ -1659,7 +1654,7 @@ fn replace_ci(text: &str, what: &str, with: &str) -> String {
 fn format_painter(s: &mut Session, p: &Json) -> Result<Json> {
     if let Some(dest) = str_param(p, "apply").and_then(RangeRef::parse) {
         let Some((wb, sheet, src, sticky)) = s.format_painter.clone() else { return Err(EngineError::Other("Pick up a format first.".into())) };
-        let dest_sheet = s.doc()?.wb.active_sheet;
+        let dest_sheet = s.doc()?.wb.active_sheet();
         let same = std::sync::Arc::ptr_eq(&wb, &s.doc()?.wb) || s.doc()?.wb.styles == wb.styles;
         edit(s, |cx| {
             let Some(src_sheet) = wb.sheet(sheet) else { return Ok(()) };
@@ -1739,7 +1734,7 @@ fn format_painter(s: &mut Session, p: &Json) -> Result<Json> {
     }
     let sticky = bool_param(p, "sticky").unwrap_or(false);
     let d = s.doc()?;
-    s.format_painter = Some((d.wb.clone(), d.wb.active_sheet, d.selection.current(), sticky));
+    s.format_painter = Some((d.wb.clone(), d.wb.active_sheet(), d.selection.current(), sticky));
     ok()
 }
 
diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index 395345543..506f56443 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -142,7 +142,15 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "view.customViews", "Custom Views…", ["View", "Workbook Views"], None, "{save?: name, show?: name, delete?: name} → list", has_doc, custom_views),
         cmd!(noundo "view.split", "Split", ["View", "Window"], None, "{} (toggles a split at the active cell; shown as frozen panes in this version)", has_doc, split),
         cmd!(noundo "view.newWindow", "New Window", ["View", "Window"], None, "{} → {window, doc, title}: opens another window on the active workbook (the same workbook: saving from either window saves it)", has_doc, new_window),
-        cmd!(noundo "view.arrangeAll", "Arrange All", ["View", "Window"], None, "{}", has_doc, |_, _| ok()),
+        cmd!(
+            noundo "view.arrangeAll",
+            "Arrange All",
+            ["View", "Window"],
+            None,
+            "{arrange?: tiled|horizontal|vertical|cascade, activeWorkbook?: bool} → {arrange, windows}: lays out the visible windows (tiled by default; `activeWorkbook` only the active workbook's), the active window first",
+            has_doc,
+            arrange_all
+        ),
         cmd!(noundo "view.hideWindow", "Hide", ["View", "Window"], None, "{window?, doc?} (the active window by default)", has_doc, hide_window),
         cmd!(noundo "view.unhideWindow", "Unhide…", ["View", "Window"], None, "{window?, doc?, index?} (the most recently hidden window by default)", has_doc, unhide_window),
         cmd!(
@@ -276,7 +284,7 @@ pub fn specs() -> Vec<CommandSpec> {
 
 fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
     let d = s.doc()?;
-    let si = d.wb.active_sheet;
+    let si = d.wb.active_sheet();
     let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
     let idx = match u32_param(p, "chart") {
         Some(id) => sh.charts.iter().position(|c| c.id == id),
@@ -442,7 +450,7 @@ fn select_data(s: &mut Session, p: &Json) -> Result<Json> {
             let (sheet_name, body) = split_sheet(range);
             let src_si = match sheet_name {
                 Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("chart.selectData", "no such sheet"))?,
-                None => d.wb.active_sheet,
+                None => d.wb.active_sheet(),
             };
             let r = RangeRef::parse(body).ok_or_else(|| bad("chart.selectData", "not a range"))?;
             if r.count() > 1_000_000 {
@@ -464,7 +472,7 @@ fn select_data(s: &mut Session, p: &Json) -> Result<Json> {
             let (sheet_name, body) = split_sheet(t);
             let si = match sheet_name {
                 Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("chart.selectData", "no such sheet"))?,
-                None => d.wb.active_sheet,
+                None => d.wb.active_sheet(),
             };
             let r = RangeRef::parse(body).ok_or_else(|| bad("chart.selectData", "`categories` is not a range"))?;
             let name = d.wb.sheet(si).map(|sh| sh.name.clone()).ok_or(EngineError::NoDocument)?;
@@ -546,7 +554,7 @@ fn shape_outline(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 fn with_shape(s: &mut Session, p: &Json, f: impl FnOnce(&mut Shape)) -> Result<Json> {
-    let si = s.doc()?.wb.active_sheet;
+    let si = s.doc()?.wb.active_sheet();
     let id = u32_param(p, "id");
     edit(s, |cx| {
         let shapes = &mut cx.sheet_mut(si)?.shapes;
@@ -564,7 +572,7 @@ fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json> {
     let id = u32_param(p, "id").ok_or_else(|| bad("arrange", "missing `id`"))?;
     let kind = str_param(p, "kind").unwrap_or("shape").to_string();
     let extreme = bool_param(p, "toFront").or(bool_param(p, "toBack")).unwrap_or(false);
-    let si = s.doc()?.wb.active_sheet;
+    let si = s.doc()?.wb.active_sheet();
     fn reorder<T>(v: &mut Vec<T>, i: usize, forward: bool, extreme: bool) {
         if i >= v.len() {
             return;
@@ -630,7 +638,7 @@ fn align(s: &mut Session, p: &Json) -> Result<Json> {
     let ids: Vec<u32> =
         p.get("ids").and_then(Json::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(|x| x as u32)).collect()).unwrap_or_default();
     let how = str_param(p, "align").unwrap_or("left").to_string();
-    let si = s.doc()?.wb.active_sheet;
+    let si = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         let sheet = cx.sheet_mut(si)?;
         let geo: Vec<(u32, f64, f64, f32, f32)> = {
@@ -743,7 +751,7 @@ fn custom_views(s: &mut Session, p: &Json) -> Result<Json> {
     let mut views = stash_map(&d.wb, VIEWS_NAME);
     if let Some(name) = str_param(p, "save") {
         let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-        views[name] = json!({"sheet": d.wb.active_sheet, "selection": d.selection.a1(), "zoom": sh.zoom, "freeze": sh.freeze});
+        views[name] = json!({"sheet": d.wb.active_sheet(), "selection": d.selection.a1(), "zoom": sh.zoom, "freeze": sh.freeze});
         let v = views.clone();
         edit(s, |cx| {
             stash_set(&mut cx.wb, VIEWS_NAME, &v);
@@ -802,6 +810,25 @@ pub(crate) fn window_param(s: &Session, cmd: &str, p: &Json) -> Result<u64> {
     s.target_window(t).map_err(|e| bad(cmd, e.to_string()))
 }
 
+/// View › Arrange All. The engine has no window geometry: it picks the windows and the layout,
+/// and the interface moves its native windows ([`Session::window_list`] order, active first).
+fn arrange_all(s: &mut Session, p: &Json) -> Result<Json> {
+    let arrange = match str_param(p, "arrange").unwrap_or("tiled") {
+        a @ ("tiled" | "horizontal" | "vertical" | "cascade") => a,
+        other => return Err(bad("view.arrangeAll", format!("`arrange` must be tiled, horizontal, vertical or cascade, not `{other}`"))),
+    };
+    let active = s.active_window();
+    let doc = active.and_then(|w| s.window(w)).map(|w| w.doc_uid);
+    let only_active = p.get("activeWorkbook").and_then(Json::as_bool).unwrap_or(false);
+    let mut windows: Vec<u64> = s.windows().iter().filter(|w| !w.hidden && (!only_active || Some(w.doc_uid) == doc)).map(|w| w.id).collect();
+    if let Some(at) = windows.iter().position(|w| Some(*w) == active)
+        && let Some(first) = windows.get_mut(..=at)
+    {
+        first.rotate_right(1);
+    }
+    Ok(json!({"arrange": arrange, "windows": windows}))
+}
+
 fn hide_window(s: &mut Session, p: &Json) -> Result<Json> {
     let id = window_param(s, "view.hideWindow", p)?;
     s.hide_window(id);
@@ -835,7 +862,7 @@ fn switch_windows(s: &mut Session, p: &Json) -> Result<Json> {
 fn table_resize(s: &mut Session, p: &Json) -> Result<Json> {
     let r = str_param(p, "range").and_then(RangeRef::parse).ok_or_else(|| bad("table.resize", "missing `range`"))?;
     let d = s.doc()?;
-    let si = d.wb.active_sheet;
+    let si = d.wb.active_sheet();
     let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
     let ti = match str_param(p, "table") {
         Some(n) => sh.tables.iter().position(|t| t.name.eq_ignore_ascii_case(n)),
@@ -944,7 +971,7 @@ fn from_table_range(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
     let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
     let r = if r.is_single() { crate::selection::current_region(sh, r.start) } else { r };
-    let text = crate::display::range_text(&d.wb, d.wb.active_sheet, r);
+    let text = crate::display::range_text(&d.wb, d.wb.active_sheet(), r);
     from_csv(s, &json!({"text": text, "delimiter": "\t", "sheet": format!("{} (2)", sh.name).chars().take(31).collect::<String>()}))
 }
 
@@ -1117,7 +1144,7 @@ fn theme_fonts(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn background(s: &mut Session, p: &Json) -> Result<Json> {
     if bool_param(p, "clear").unwrap_or(false) {
-        let si = s.doc()?.wb.active_sheet;
+        let si = s.doc()?.wb.active_sheet();
         return edit(s, |cx| {
             cx.sheet_mut(si)?.images.retain(|i| i.alt != "Sheet background");
             Ok(Json::Null)
@@ -1210,7 +1237,7 @@ fn watch_window(s: &mut Session, p: &Json) -> Result<Json> {
         .iter()
         .map(|w| {
             let (sheet, body) = split_sheet(w);
-            let si = sheet.and_then(|n| d.wb.sheet_index(&n)).unwrap_or(d.wb.active_sheet);
+            let si = sheet.and_then(|n| d.wb.sheet_index(&n)).unwrap_or(d.wb.active_sheet());
             let c = CellRef::parse(body).unwrap_or_default();
             let sh = d.wb.sheet(si);
             json!({"cell": w, "value": sh.map(|s| s.value(c).display()), "formula": sh.and_then(|s| s.cell(c)).and_then(|x| x.formula.as_ref()).map(|f| format!("={}", f.text))})
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 1f50b908b..f704714cc 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -185,9 +185,9 @@ fn close(s: &mut Session, p: &Json) -> Result<Json> {
 fn export(s: &mut Session, p: &Json, ext: &str) -> Result<Json> {
     let path = str_param(p, "path").ok_or_else(|| bad("file.export", "missing `path`"))?.to_string();
     let d = s.doc()?;
-    let mut wb = (*d.wb).clone();
+    let wb = (*d.wb).clone();
     if p.get("sheet").is_some() {
-        wb.active_sheet = target_sheet(s, p)?;
+        wb.set_active_sheet(target_sheet(s, p)?);
     }
     let target = if path.ends_with(&format!(".{ext}")) { path.clone() } else { format!("{path}.{ext}") };
     let bytes = crate::io::save_bytes(&wb, &target)?;
diff --git a/crates/engine/src/cmd/forecast.rs b/crates/engine/src/cmd/forecast.rs
index 139d6fc46..b7472fd22 100644
--- a/crates/engine/src/cmd/forecast.rs
+++ b/crates/engine/src/cmd/forecast.rs
@@ -68,7 +68,7 @@ fn range_on(s: &Session, t: &str) -> Result<(usize, RangeRef)> {
     let (sh, body) = split_sheet(t);
     let si = match sh {
         Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad(CMD, format!("no sheet named `{n}`")))?,
-        None => d.wb.active_sheet,
+        None => d.wb.active_sheet(),
     };
     let r = RangeRef::parse(body.trim()).ok_or_else(|| bad(CMD, format!("not a range: `{t}`")))?;
     let r = if r.is_full_cols() || r.is_full_rows() {
@@ -101,7 +101,7 @@ fn source(s: &Session, p: &Json) -> Result<(usize, Vec<CellRef>, Vec<CellRef>)>
                 None => {
                     let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
                     let sel = d.selection.current();
-                    (d.wb.active_sheet, if sel.is_single() { current_region(sh, d.selection.active) } else { sel })
+                    (d.wb.active_sheet(), if sel.is_single() { current_region(sh, d.selection.active) } else { sel })
                 }
             };
             if r.width() < 2 {
@@ -307,7 +307,7 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result<Json> {
     let stats_col = width + 1;
     let chart_col = if opts.statistics { stats_col + 3 } else { width + 1 };
 
-    let at = s.doc()?.wb.active_sheet;
+    let at = s.doc()?.wb.active_sheet();
     let index = edit(s, |cx| {
         let at = at.min(cx.wb.sheets.len());
         let bold = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.font.bold = true);
@@ -440,7 +440,7 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 *sc += 1;
             }
         }
-        cx.wb.active_sheet = at;
+        cx.wb.set_active_sheet(at);
         *cx.sel = crate::Selection::at(CellRef::new(0, 0));
         cx.structural = true;
         Ok(at)
@@ -502,7 +502,7 @@ mod tests {
         assert_eq!(r["periods"], 4);
         let wb = &s.doc().unwrap().wb;
         // Inserted before the data sheet and activated.
-        assert_eq!(wb.active_sheet, 0);
+        assert_eq!(wb.active_sheet(), 0);
         let sh = wb.sheet(0).unwrap();
         assert_eq!(sh.name, r["sheet"].as_str().unwrap());
         assert_eq!(value(&s, 0, "C1"), Value::text("Forecast(Sales)"));
diff --git a/crates/engine/src/cmd/format.rs b/crates/engine/src/cmd/format.rs
index cd28cfbfa..84bc2f3cc 100644
--- a/crates/engine/src/cmd/format.rs
+++ b/crates/engine/src/cmd/format.rs
@@ -1011,7 +1011,7 @@ fn line_targets(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u
         return Ok((sheet, lines));
     }
     let d = s.doc()?;
-    if sheet != d.wb.active_sheet {
+    if sheet != d.wb.active_sheet() {
         return Err(bad(key, format!("missing `{key}`: the selection is on the active sheet")));
     }
     Ok((sheet, d.selection.ranges.iter().map(|r| if rows { (r.start.row, r.end.row) } else { (r.start.col, r.end.col) }).collect()))
diff --git a/crates/engine/src/cmd/formulas.rs b/crates/engine/src/cmd/formulas.rs
index 5334784fa..22db2abd0 100644
--- a/crates/engine/src/cmd/formulas.rs
+++ b/crates/engine/src/cmd/formulas.rs
@@ -102,7 +102,7 @@ fn auto_sum(s: &mut Session, p: &Json) -> Result<Json> {
                 (CellRef::new(out_row, c), format!("={func}({})", RangeRef::new(CellRef::new(sel.start.row, c), CellRef::new(data_end_row, c)).a1()))
             })
             .collect();
-        let sheet = d.wb.active_sheet;
+        let sheet = d.wb.active_sheet();
         edit(s, |cx| {
             for (c, f) in &writes {
                 let cell = super::edit::input_to_cell(f, sheet, *c, &mut cx.wb)?.unwrap_or_default();
@@ -400,7 +400,7 @@ fn name_manager(s: &mut Session, _: &Json) -> Result<Json> {
         .iter()
         .filter(|n| !n.hidden)
         .map(|n| {
-            let sheet = n.scope.unwrap_or(d.wb.active_sheet);
+            let sheet = n.scope.unwrap_or(d.wb.active_sheet());
             // parse_name, not evaluate's parse: a name's top-level commas are unions.
             let v = gridcraft_formula::parse_name(&n.formula)
                 .map_or(Value::Error(CellError::Name), |e| gridcraft_calc::recalc::evaluate_expr(&d.wb, sheet, CellRef::default(), &e));
@@ -477,7 +477,7 @@ fn create_from_selection(s: &mut Session, p: &Json) -> Result<Json> {
 fn trace_precedents(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
     let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
-    let areas = d.calc.graph.precedents_of((d.wb.active_sheet, at));
+    let areas = d.calc.graph.precedents_of((d.wb.active_sheet(), at));
     let v: Vec<Json> = areas.iter().map(|a| json!({"sheet": d.wb.sheet(a.sheet).map(|s| s.name.clone()), "range": a.range.a1()})).collect();
     Ok(Json::Array(v))
 }
@@ -486,7 +486,7 @@ fn trace_dependents(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
     let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
     let mut deps = Vec::new();
-    d.calc.graph.dependents(d.wb.active_sheet, at, &mut deps);
+    d.calc.graph.dependents(d.wb.active_sheet(), at, &mut deps);
     deps.sort();
     deps.dedup();
     let v: Vec<Json> = deps.iter().map(|(si, c)| json!({"sheet": d.wb.sheet(*si).map(|s| s.name.clone()), "cell": c.a1()})).collect();
@@ -499,7 +499,7 @@ fn select_trace_cells(s: &mut Session, p: &Json, precedents: bool) -> Result<Jso
     use std::collections::BTreeSet;
     let d = s.doc()?;
     let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     let all = bool_param(p, "all").unwrap_or(false);
     // (sheet, a1) pairs to select; direct level keeps whole precedent ranges, transitive cells.
     let mut found: BTreeSet<(usize, String)> = BTreeSet::new();
@@ -570,7 +570,7 @@ fn select_dependents(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 fn show_formulas(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     let cur = s.doc()?.wb.sheet(sheet).is_some_and(|sh| sh.show_formulas);
     let on = bool_param(p, "on").unwrap_or(!cur);
     edit(s, |cx| {
@@ -636,7 +636,7 @@ fn error_checking(s: &mut Session, _: &Json) -> Result<Json> {
 fn evaluate_formula(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
     let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     let text = match str_param(p, "formula") {
         Some(f) => f.trim_start_matches('=').to_string(),
         None => {
@@ -675,7 +675,7 @@ fn evaluate(s: &mut Session, p: &Json) -> Result<Json> {
     let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
     let expr = crate::cmd::edit::parse_typed_formula(f.strip_prefix('=').unwrap_or(f))?;
     crate::cmd::edit::check_arg_counts(&expr)?;
-    let v = gridcraft_calc::recalc::evaluate_expr(&d.wb, d.wb.active_sheet, at, &expr);
+    let v = gridcraft_calc::recalc::evaluate_expr(&d.wb, d.wb.active_sheet(), at, &expr);
     Ok(crate::cmd::inspect::value_json(&v))
 }
 
diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs
index aae5a9faa..08369a773 100644
--- a/crates/engine/src/cmd/insert.rs
+++ b/crates/engine/src/cmd/insert.rs
@@ -356,7 +356,7 @@ fn find_table(s: &Session, p: &Json) -> Result<(usize, usize)> {
     if let Some(n) = str_param(p, "table") {
         return d.wb.table(n).ok_or_else(|| bad("table", format!("no table named `{n}`")));
     }
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
     let ti = sh
         .tables
@@ -819,7 +819,7 @@ fn insert_chart(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
     let d = s.doc()?;
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
     let idx = match u32_param(p, "chart") {
         Some(id) => sh.charts.iter().position(|c| c.id == id),
@@ -968,7 +968,7 @@ fn insert_sparkline(s: &mut Session, p: &Json) -> Result<Json> {
         _ => SparklineKind::Line,
     };
     let markers = bool_param(p, "markers").unwrap_or(false);
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
         sh.sparklines.retain(|x| x.cell != loc);
@@ -993,7 +993,7 @@ fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
     if placement == "cell" {
         let mime = validate_cell_picture(&data)?;
         let d = s.doc()?;
-        let sheet = d.wb.active_sheet;
+        let sheet = d.wb.active_sheet();
         let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
         let at = match str_param(p, "at") {
             Some(a) => CellRef::parse(a).ok_or_else(|| bad("insert.picture", "invalid cell address"))?,
@@ -1037,7 +1037,7 @@ fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
         mime,
         alt: str_param(p, "alt").unwrap_or("").into(),
     };
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     edit(s, |cx| {
         cx.sheet_mut(sheet)?.images.push(img);
         Ok(json!({"image": id}))
@@ -1107,7 +1107,7 @@ fn insert_shape(s: &mut Session, p: &Json) -> Result<Json> {
         text: str_param(p, "text").unwrap_or("").into(),
         format: Default::default(),
     };
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     edit(s, |cx| {
         cx.sheet_mut(sheet)?.shapes.push(shape);
         Ok(json!({"shape": id}))
@@ -1125,7 +1125,7 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
         return Err(bad("shape.setText", "`text` is longer than 32,767 characters"));
     }
     let d = s.doc()?;
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     let sh = d.wb.active().ok_or_else(|| bad("shape.setText", "no such text box"))?;
     let shape = sh.shapes.iter().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
     if shape.kind != ShapeKind::TextBox {
@@ -1148,7 +1148,7 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
 fn delete_object(s: &mut Session, p: &Json) -> Result<Json> {
     let id = u32_param(p, "id").ok_or_else(|| bad("object.delete", "missing `id`"))?;
     let kind = str_param(p, "kind").unwrap_or("").to_string();
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
         match kind.as_str() {
@@ -1164,7 +1164,7 @@ fn delete_object(s: &mut Session, p: &Json) -> Result<Json> {
 fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
     let id = u32_param(p, "id").ok_or_else(|| bad("object.move", "missing `id`"))?;
     let kind = str_param(p, "kind").unwrap_or("").to_string();
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     let at = cell_param(s, p, "at")?;
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
@@ -1205,7 +1205,7 @@ fn set_anchor_mode(s: &mut Session, p: &Json) -> Result<Json> {
         return Err(bad("object.setAnchorMode", "kind must be chart, image or shape"));
     }
     let mode = anchor_mode_param(p).ok_or_else(|| bad("object.setAnchorMode", "mode must be moveAndSize, moveOnly or absolute"))?;
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
         let anchor = match kind.as_str() {
@@ -1703,7 +1703,7 @@ fn insert_icon(s: &mut Session, p: &Json) -> Result<Json> {
         text: name,
         format: Default::default(),
     };
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     edit(s, |cx| {
         cx.sheet_mut(sheet)?.shapes.push(shape);
         Ok(json!({"shape": id}))
diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index f373de489..c322f4388 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -63,7 +63,7 @@ fn inspect(s: &mut Session, _: &Json) -> Result<Json> {
         "title": d.display_title(),
         "path": d.path,
         "dirty": d.is_dirty(),
-        "activeSheet": wb.active_sheet,
+        "activeSheet": wb.active_sheet(),
         "sheets": sheets,
         "selection": d.selection.a1(),
         "activeCell": d.selection.active.a1(),
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 1f15ddfb8..3d1b404d0 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -271,7 +271,7 @@ pub(crate) fn target_sheet(s: &Session, p: &Json) -> Result<usize> {
     {
         return d.wb.sheet_index(&sh).ok_or_else(|| bad("range", format!("no sheet named `{sh}`")));
     }
-    Ok(d.wb.active_sheet)
+    Ok(d.wb.active_sheet())
 }
 
 pub(crate) use gridcraft_core::split_sheet;
@@ -280,7 +280,7 @@ pub(crate) use gridcraft_core::split_sheet;
 /// a cell reference, or that names a sheet other than the active one, is an error rather than a
 /// silent fallback to some other cell.
 pub(crate) fn cell_param(s: &Session, p: &Json, key: &str) -> Result<Option<CellRef>> {
-    cell_param_on(s, p, key, s.doc()?.wb.active_sheet)
+    cell_param_on(s, p, key, s.doc()?.wb.active_sheet())
 }
 
 /// Like [`cell_param`], for a command that operates on `sheet` (a `Sheet!` prefix must name it).
@@ -562,7 +562,7 @@ pub fn auto_row_height(wb: &mut Workbook, si: usize, row: u32) {
 
 impl Ctx<'_> {
     pub fn sheet_index(&self) -> usize {
-        self.wb.active_sheet
+        self.wb.active_sheet()
     }
     pub fn sheet_mut(&mut self, i: usize) -> Result<&mut gridcraft_model::Sheet> {
         self.wb.sheet_mut(i).ok_or_else(|| EngineError::Other("no such sheet".into()))
diff --git a/crates/engine/src/cmd/pivot.rs b/crates/engine/src/cmd/pivot.rs
index 43c3aa4b5..3d3c28b44 100644
--- a/crates/engine/src/cmd/pivot.rs
+++ b/crates/engine/src/cmd/pivot.rs
@@ -206,7 +206,7 @@ fn other(msg: impl Into<String>) -> EngineError {
 /// (sheet, index) of the pivot a call targets.
 fn find_pivot(s: &Session, p: &Json) -> Result<(usize, usize)> {
     let d = s.doc()?;
-    let active = d.wb.active_sheet;
+    let active = d.wb.active_sheet();
     if let Some(v) = p.get("pivot").filter(|v| !v.is_null()) {
         let mut order: Vec<usize> = vec![active];
         order.extend((0..d.wb.sheets.len()).filter(|i| *i != active));
@@ -616,7 +616,7 @@ fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
         return Err(other("The workbook is protected and cannot be changed."));
     }
     let source = source_param(s, p)?;
-    let active = s.doc()?.wb.active_sheet;
+    let active = s.doc()?.wb.active_sheet();
     // Validate the source now (header names, size).
     let src = pv::read_source(&s.doc()?.wb, &source, active).map_err(other)?;
     let name = match str_param(p, "name") {
@@ -654,7 +654,7 @@ fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
         let (si, anchor) = match target {
             Some(t) => t,
             None => {
-                let at = cx.wb.active_sheet.min(cx.wb.sheets.len());
+                let at = cx.wb.active_sheet().min(cx.wb.sheets.len());
                 let nm = cx.wb.next_sheet_name();
                 cx.wb.sheets.insert(at, Arc::new(Sheet::new(nm)));
                 for n in cx.wb.names.iter_mut() {
@@ -704,7 +704,7 @@ fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
         sh.pivots.push(pt);
         let pi = sh.pivots.len() - 1;
         let area = pv::refresh(&mut cx.wb, si, pi, replace).map_err(other)?;
-        cx.wb.active_sheet = si;
+        cx.wb.set_active_sheet(si);
         *cx.sel = crate::Selection::at(anchor);
         cx.structural = true;
         let sheet_name = cx.wb.sheet(si).map(|s| s.name.clone()).unwrap_or_default();
@@ -1395,7 +1395,7 @@ fn chart_pivot(s: &Session, p: &Json) -> Result<(usize, usize)> {
                 let sh = gridcraft_core::unquote_sheet(sh);
                 (d.wb.sheet_index(&sh), a)
             }
-            None => (Some(d.wb.active_sheet), t),
+            None => (Some(d.wb.active_sheet()), t),
         };
         if let (Some(si), Some(c)) = (sheet, CellRef::parse(addr.trim().replace('$', "").as_str())) {
             let hit = d.wb.sheet(si).and_then(|sh| sh.pivots.iter().position(|pt| pt.last_range.is_some_and(|r| r.contains(c)) || pt.anchor == c));
@@ -1529,7 +1529,7 @@ fn suggestions(wb: &Workbook, src: &pv::Source) -> Vec<Json> {
 
 fn recommended(s: &mut Session, p: &Json) -> Result<Json> {
     let source = source_param(s, p)?;
-    let active = s.doc()?.wb.active_sheet;
+    let active = s.doc()?.wb.active_sheet();
     let src = pv::read_source(&s.doc()?.wb, &source, active).map_err(other)?;
     let list = suggestions(&s.doc()?.wb, &src);
     let Some(apply) = p.get("apply").and_then(Json::as_u64) else {
@@ -1612,7 +1612,7 @@ mod tests {
         assert_eq!(r["fields"], json!(["Region", "Product", "Date", "Units", "Sales"]));
         let d = s.doc().unwrap();
         assert_eq!(d.wb.sheets.len(), 2);
-        assert_eq!(d.wb.active_sheet, 0, "new sheet goes before the current one");
+        assert_eq!(d.wb.active_sheet(), 0, "new sheet goes before the current one");
         assert_eq!(d.wb.active().unwrap().name, "Sheet2");
         assert!(text(&s, "A3").starts_with("PivotTable1"));
         assert_eq!(pt(&s).source, "Sheet1!$A$1:$E$13");
@@ -1993,7 +1993,7 @@ mod tests {
     }
     fn plotted(s: &Session) -> Vec<Vec<Option<f64>>> {
         let d = s.doc().unwrap();
-        let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet, &pivot_chart(s));
+        let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet(), &pivot_chart(s));
         data.series.into_iter().map(|x| x.values).collect()
     }
 
diff --git a/crates/engine/src/cmd/print.rs b/crates/engine/src/cmd/print.rs
index 4c80f2fa9..35225cbe9 100644
--- a/crates/engine/src/cmd/print.rs
+++ b/crates/engine/src/cmd/print.rs
@@ -370,13 +370,13 @@ pub fn layouts(wb: &Workbook, opts: &PrintOptions) -> Vec<SheetLayout> {
     let sheets: Vec<usize> = if opts.all_sheets {
         (0..wb.sheets.len()).filter(|i| wb.sheet(*i).is_some_and(|s| s.visibility == Visibility::Visible)).collect()
     } else {
-        vec![wb.active_sheet]
+        vec![wb.active_sheet()]
     };
     for si in sheets {
         if pages >= MAX_PAGES {
             break;
         }
-        let ovr = if si == wb.active_sheet { opts.range } else { None };
+        let ovr = if si == wb.active_sheet() { opts.range } else { None };
         if opts.all_sheets && ovr.is_none() && wb.sheet(si).is_some_and(|s| print_range(s).is_none()) {
             continue;
         }
@@ -387,7 +387,7 @@ pub fn layouts(wb: &Workbook, opts: &PrintOptions) -> Vec<SheetLayout> {
         }
     }
     if out.is_empty() && opts.all_sheets {
-        out.extend(layout_sheet(wb, wb.active_sheet, opts, None));
+        out.extend(layout_sheet(wb, wb.active_sheet(), opts, None));
     }
     out
 }
diff --git a/crates/engine/src/cmd/review.rs b/crates/engine/src/cmd/review.rs
index 5464abba5..9811fde9e 100644
--- a/crates/engine/src/cmd/review.rs
+++ b/crates/engine/src/cmd/review.rs
@@ -90,7 +90,7 @@ fn has_comments(s: &Session) -> std::result::Result<(), String> {
 fn step_comment(s: &mut Session, forward: bool) -> Result<Json> {
     let list = comment_cells(s);
     let d = s.doc()?;
-    let here = (d.wb.active_sheet, d.selection.active);
+    let here = (d.wb.active_sheet(), d.selection.active);
     let target = if forward {
         list.iter().find(|c| **c > here).or_else(|| list.first())
     } else {
@@ -374,7 +374,7 @@ mod tests {
 
     fn at(s: &Session) -> (usize, String) {
         let d = s.doc().unwrap();
-        (d.wb.active_sheet, d.selection.active.a1())
+        (d.wb.active_sheet(), d.selection.active.a1())
     }
 
     #[test]
@@ -443,7 +443,7 @@ mod tests {
         );
         let prot: SheetProtection = serde_json::from_str(&old).unwrap();
         assert_eq!((prot.legacy_password_hash, prot.password.is_none()), (Some(password_hash("old")), true));
-        let i = s.doc().unwrap().wb.active_sheet;
+        let i = s.doc().unwrap().wb.active_sheet();
         let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb);
         std::sync::Arc::make_mut(&mut wb.sheets[i]).protection = Some(prot);
         assert!(s.execute("review.unprotectSheet", json!({"password": "new"})).is_err());
diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rs
index 555c2fb79..e68bf6070 100644
--- a/crates/engine/src/cmd/sheet.rs
+++ b/crates/engine/src/cmd/sheet.rs
@@ -687,7 +687,7 @@ fn insert_sheet(s: &mut Session, p: &Json) -> Result<Json> {
     let before = p.get("before").and_then(Json::as_u64).map(|v| v as usize);
     let idx = edit_doc(d, |cx| {
         // Excel inserts before the active sheet; the "+" button appends after it.
-        let at = before.unwrap_or(cx.wb.active_sheet + 1).min(cx.wb.sheets.len());
+        let at = before.unwrap_or(cx.wb.active_sheet() + 1).min(cx.wb.sheets.len());
         cx.wb.sheets.insert(at, Arc::new(Sheet::new(name.clone())));
         // Names scoped to later sheets shift.
         for n in cx.wb.names.iter_mut() {
@@ -697,7 +697,7 @@ fn insert_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 *sc += 1;
             }
         }
-        cx.wb.active_sheet = at;
+        cx.wb.set_active_sheet(at);
         *cx.sel = crate::Selection::default();
         cx.structural = true;
         Ok(at)
@@ -785,8 +785,8 @@ fn delete_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 }
             }
         }
-        if cx.wb.active_sheet >= cx.wb.sheets.len() || cx.wb.active_sheet > i {
-            cx.wb.active_sheet = cx.wb.active_sheet.saturating_sub(1).min(cx.wb.sheets.len().saturating_sub(1));
+        if cx.wb.active_sheet() >= cx.wb.sheets.len() || cx.wb.active_sheet() > i {
+            cx.wb.set_active_sheet(cx.wb.active_sheet().saturating_sub(1).min(cx.wb.sheets.len().saturating_sub(1)));
         }
         *cx.sel = crate::Selection::default();
         cx.structural = true;
@@ -900,12 +900,12 @@ fn move_sheet(s: &mut Session, p: &Json) -> Result<Json> {
             }
             cx.wb.names.extend(copies);
             cx.wb.sheets.insert(at, Arc::new(sh));
-            cx.wb.active_sheet = at;
+            cx.wb.set_active_sheet(at);
         } else {
             let sh = cx.wb.sheets.remove(i);
             let at = to.min(n - 1);
             cx.wb.sheets.insert(at, sh);
-            cx.wb.active_sheet = at;
+            cx.wb.set_active_sheet(at);
             // Sheet-level names follow their sheet.
             for nm in cx.wb.names.iter_mut() {
                 if let Some(sc) = nm.scope.as_mut() {
@@ -942,8 +942,8 @@ fn hide_sheet(s: &mut Session, p: &Json) -> Result<Json> {
     }
     edit(s, |cx| {
         cx.sheet_mut(i)?.visibility = Visibility::Hidden;
-        if cx.wb.active_sheet == i {
-            cx.wb.active_sheet = cx.wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0);
+        if cx.wb.active_sheet() == i {
+            cx.wb.set_active_sheet(cx.wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0));
         }
         Ok(Json::Null)
     })
@@ -964,7 +964,7 @@ fn unhide_sheet(s: &mut Session, p: &Json) -> Result<Json> {
     let i = target_sheet(s, p)?;
     edit(s, |cx| {
         cx.sheet_mut(i)?.visibility = Visibility::Visible;
-        cx.wb.active_sheet = i;
+        cx.wb.set_active_sheet(i);
         Ok(Json::Null)
     })
 }
@@ -978,7 +978,7 @@ fn activate(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn step_sheet(s: &mut Session, dir: isize) -> Result<Json> {
     let d = s.doc()?;
-    let mut i = d.wb.active_sheet;
+    let mut i = d.wb.active_sheet();
     while let Some(next) = i.checked_add_signed(dir) {
         let Some(sheet) = d.wb.sheet(next) else { break };
         if sheet.visibility == Visibility::Visible {
diff --git a/crates/engine/src/cmd/slicer.rs b/crates/engine/src/cmd/slicer.rs
index cb72ded71..10e3cf13c 100644
--- a/crates/engine/src/cmd/slicer.rs
+++ b/crates/engine/src/cmd/slicer.rs
@@ -165,7 +165,7 @@ fn slicer_toggle(s: &mut Session, p: &Json) -> Result<Json> {
     let (idx, id) = find_slicer(s, p)?;
     let value = str_param(p, "value").ok_or_else(|| bad("slicer.toggle", "missing `value`"))?.to_string();
     let multi = bool_param(p, "multi").unwrap_or(false);
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     let (table, column, current) = {
         let d = s.doc()?;
         let sl = d.wb.active().and_then(|sh| sh.slicers.get(idx)).ok_or_else(|| bad("slicer.toggle", "no slicer"))?;
@@ -204,7 +204,7 @@ fn slicer_toggle(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn slicer_select_all(s: &mut Session, p: &Json) -> Result<Json> {
     let (idx, id) = find_slicer(s, p)?;
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     edit(s, |cx| {
         if let Some(sl) = cx.sheet_mut(sheet)?.slicers.get_mut(idx) {
             sl.selected = None;
@@ -217,7 +217,7 @@ fn slicer_select_all(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn slicer_delete(s: &mut Session, p: &Json) -> Result<Json> {
     let (idx, id) = find_slicer(s, p)?;
-    let sheet = s.doc()?.wb.active_sheet;
+    let sheet = s.doc()?.wb.active_sheet();
     // Absolute column of the slicer, so its filter criterion can be removed too.
     let abs_col = s.doc().ok().and_then(|d| {
         let sh = d.wb.active()?;
diff --git a/crates/engine/src/cmd/solver.rs b/crates/engine/src/cmd/solver.rs
index ffd426f5f..bf78b4d4c 100644
--- a/crates/engine/src/cmd/solver.rs
+++ b/crates/engine/src/cmd/solver.rs
@@ -299,7 +299,7 @@ fn parse_model(s: &Session, p: &Json) -> Result<Model> {
     let d = s.doc()?;
     let wb = &d.wb;
     let obj_text = str_param(p, "objective").or_else(|| str_param(p, "setObjective")).or_else(|| str_param(p, "set")).unwrap_or("");
-    let (sheet, obj) = cells_of(wb, obj_text, wb.active_sheet, 1).map_err(|_| EngineError::Other("The objective must be a single cell.".into()))?;
+    let (sheet, obj) = cells_of(wb, obj_text, wb.active_sheet(), 1).map_err(|_| EngineError::Other("The objective must be a single cell.".into()))?;
     let objective = *obj.first().ok_or_else(|| EngineError::Other("The objective must be a single cell.".into()))?;
     let sh = wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
     if sh.cell(objective).is_none_or(|c| c.formula.is_none()) {
@@ -1913,8 +1913,8 @@ fn write_reports(cx: &mut Ctx, at: usize, built: Vec<(String, Lines)>) -> Vec<St
             *sc += count;
         }
     }
-    if cx.wb.active_sheet >= at {
-        cx.wb.active_sheet += count;
+    if cx.wb.active_sheet() >= at {
+        cx.wb.set_active_sheet(cx.wb.active_sheet().saturating_add(count));
     }
     cx.structural = true;
     names
@@ -1939,7 +1939,7 @@ fn report(s: &mut Session, p: &Json) -> Result<Json> {
     let params = match p.get("model") {
         Some(m @ Json::Object(_)) => m.clone(),
         Some(Json::Null) | None => {
-            let mut params = saved_model(&d.wb, d.wb.active_sheet).unwrap_or_else(|| json!({}));
+            let mut params = saved_model(&d.wb, d.wb.active_sheet()).unwrap_or_else(|| json!({}));
             if let (Some(base), Some(over)) = (params.as_object_mut(), p.as_object()) {
                 for (k, v) in over {
                     base.insert(k.clone(), v.clone());
@@ -1988,7 +1988,7 @@ fn report(s: &mut Session, p: &Json) -> Result<Json> {
 
 fn run(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc()?;
-    let active = d.wb.active_sheet;
+    let active = d.wb.active_sheet();
     let mut params = p.clone();
     if bool_param(p, "saved").unwrap_or(false) {
         let saved = saved_model(&d.wb, active).ok_or_else(|| EngineError::Other("This sheet has no saved Solver model.".into()))?;
@@ -2145,7 +2145,7 @@ mod tests {
     /// The first saved-model name scoped to the active sheet.
     fn saved(s: &Session) -> String {
         let d = s.doc().unwrap();
-        d.wb.names.iter().find(|n| n.scope == Some(d.wb.active_sheet)).map(|n| n.name.clone()).unwrap_or_default()
+        d.wb.names.iter().find(|n| n.scope == Some(d.wb.active_sheet())).map(|n| n.name.clone()).unwrap_or_default()
     }
     fn set(s: &mut Session, cells: &[(&str, &str)]) {
         for (c, v) in cells {
diff --git a/crates/engine/src/cmd/view.rs b/crates/engine/src/cmd/view.rs
index f0b2f77d3..e79d79630 100644
--- a/crates/engine/src/cmd/view.rs
+++ b/crates/engine/src/cmd/view.rs
@@ -139,7 +139,7 @@ fn freeze_panes(s: &mut Session, p: &Json) -> Result<Json> {
     }
     let at = match cell_param_on(s, p, "cell", si)? {
         Some(c) => c,
-        None if si == d.wb.active_sheet => d.selection.active,
+        None if si == d.wb.active_sheet() => d.selection.active,
         // The selection belongs to the active sheet.
         None => return Err(bad("view.freezePanes", "missing `cell`: the selection is on the active sheet")),
     };
@@ -190,7 +190,7 @@ fn zoom(s: &mut Session, p: &Json) -> Result<Json> {
     let d = s.doc_mut()?;
     let dirty = d.is_dirty();
     let wb = std::sync::Arc::make_mut(&mut d.wb);
-    let si = wb.active_sheet;
+    let si = wb.active_sheet();
     if let Some(sh) = wb.sheet_mut(si) {
         sh.zoom = z;
     }
diff --git a/crates/engine/src/cmd/whatif.rs b/crates/engine/src/cmd/whatif.rs
index cec845b7a..53b0dc3cc 100644
--- a/crates/engine/src/cmd/whatif.rs
+++ b/crates/engine/src/cmd/whatif.rs
@@ -101,7 +101,7 @@ fn cell_arg(s: &Session, p: &Json, key: &str, cmd: &str) -> Result<(usize, CellR
     let d = s.doc()?;
     let t = str_param(p, key).ok_or_else(|| bad(cmd, format!("missing `{key}`")))?;
     let (sh, body) = split_sheet(t);
-    let si = sheet_named(&d.wb, sh, d.wb.active_sheet, cmd)?;
+    let si = sheet_named(&d.wb, sh, d.wb.active_sheet(), cmd)?;
     let c = CellRef::parse(body.trim()).ok_or_else(|| bad(cmd, format!("`{key}` is not a cell: `{t}`")))?;
     Ok((si, c))
 }
@@ -110,7 +110,7 @@ fn cell_arg(s: &Session, p: &Json, key: &str, cmd: &str) -> Result<(usize, CellR
 /// are trimmed to the used range.
 pub(crate) fn parse_range(wb: &Workbook, t: &str, cmd: &str) -> Result<(usize, RangeRef)> {
     let (sh, body) = split_sheet(t);
-    let si = sheet_named(wb, sh, wb.active_sheet, cmd)?;
+    let si = sheet_named(wb, sh, wb.active_sheet(), cmd)?;
     let r = RangeRef::parse(body.trim()).ok_or_else(|| bad(cmd, format!("not a range: `{t}`")))?;
     Ok((si, trim_to_used(wb, si, r)))
 }
@@ -152,7 +152,7 @@ fn cell_list(wb: &Workbook, t: &str, cmd: &str, cap: usize) -> Result<(usize, Ve
             return Err(bad(cmd, format!("too many cells (at most {cap})")));
         }
     }
-    Ok((sheet.unwrap_or(wb.active_sheet), out))
+    Ok((sheet.unwrap_or(wb.active_sheet()), out))
 }
 
 /// What a JSON value typed into a cell is, as a constant.
@@ -525,7 +525,7 @@ fn scenario_delete(s: &mut Session, p: &Json) -> Result<Json> {
 fn scenario_summary(s: &mut Session, p: &Json) -> Result<Json> {
     const CMD: &str = "data.scenarioSummary";
     let d = s.doc()?;
-    let si = d.wb.active_sheet;
+    let si = d.wb.active_sheet();
     let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
     let scenarios: Vec<Scenario> = load_scenarios(&d.wb).into_iter().filter(|x| x.sheet.eq_ignore_ascii_case(&sh.name)).collect();
     if scenarios.is_empty() {
@@ -799,7 +799,7 @@ fn advanced_filter(s: &mut Session, p: &Json) -> Result<Json> {
         Some(t) => parse_range(&d.wb, t, CMD)?,
         None => {
             let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-            (d.wb.active_sheet, crate::selection::current_region(sh, d.selection.active))
+            (d.wb.active_sheet(), crate::selection::current_region(sh, d.selection.active))
         }
     };
     let criteria = str_param(p, "criteria").filter(|t| !t.trim().is_empty()).map(|t| parse_range(&d.wb, t, CMD)).transpose()?;
@@ -1024,7 +1024,7 @@ fn consolidate(s: &mut Session, p: &Json) -> Result<Json> {
             let (si, r) = parse_range(&d.wb, t, CMD)?;
             (si, r.start)
         }
-        None => (d.wb.active_sheet, d.selection.active),
+        None => (d.wb.active_sheet(), d.selection.active),
     };
     let mut row_keys: Vec<Key> = Vec::new();
     let mut col_keys: Vec<Key> = Vec::new();
@@ -1146,7 +1146,7 @@ mod tests {
     fn v(s: &Session, a: &str) -> Value {
         let d = s.doc().unwrap();
         let (sh, body) = super::split_sheet(a);
-        let si = sh.map(|n| d.wb.sheet_index(&n).unwrap()).unwrap_or(d.wb.active_sheet);
+        let si = sh.map(|n| d.wb.sheet_index(&n).unwrap()).unwrap_or(d.wb.active_sheet());
         d.wb.sheet(si).unwrap().value(CellRef::parse(body).unwrap())
     }
     fn n(s: &Session, a: &str) -> f64 {
diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs
index 5c0bf800b..ef1cc7bb5 100644
--- a/crates/engine/src/io.rs
+++ b/crates/engine/src/io.rs
@@ -234,7 +234,7 @@ pub fn save_bytes(wb: &Workbook, path: &str) -> Result<Vec<u8>> {
 
 /// Encodes a workbook as `kind`, whatever `path`'s extension says.
 pub fn save_bytes_as(wb: &Workbook, path: &str, kind: FileKind) -> Result<Vec<u8>> {
-    let sheet = wb.active_sheet;
+    let sheet = wb.active_sheet();
     match kind {
         // The extension picks the package kind; only the macro-enabled kinds (.xlsm, .xltm) carry
         // the VBA project, so any other name saves without it, as Excel does.
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 74924d542..f55fba080 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -194,14 +194,14 @@ impl DocState {
         !Arc::ptr_eq(&self.wb, &self.saved)
     }
     pub fn sheet_index(&self) -> usize {
-        self.wb.active_sheet
+        self.wb.active_sheet()
     }
     /// Records the view state that is saved with the file (`sheetView topLeftCell`, the active
     /// cell): the first visible cell of the scrolling area per sheet index in `tops`, and the
     /// active sheet's active cell. View state never makes the workbook dirty.
     pub fn store_view(&mut self, tops: &[(usize, CellRef)]) {
         let active = self.selection.active;
-        let si = self.wb.active_sheet;
+        let si = self.wb.active_sheet();
         let changed = tops.iter().any(|(i, c)| self.wb.sheets.get(*i).is_some_and(|sh| sh.view_top_left != *c))
             || self.wb.sheets.get(si).is_some_and(|sh| sh.view_active != active);
         if !changed {
diff --git a/crates/engine/src/sample.rs b/crates/engine/src/sample.rs
index 129fe2171..d5f5b81d0 100644
--- a/crates/engine/src/sample.rs
+++ b/crates/engine/src/sample.rs
@@ -37,7 +37,7 @@ pub fn build(name: &str) -> Option<Workbook> {
         return None;
     }
     let mut wb = (*s.doc().ok()?.wb).clone();
-    wb.active_sheet = 0;
+    wb.set_active_sheet(0);
     if let Some(sh) = wb.sheet_mut(0) {
         sh.view_active = gridcraft_core::CellRef::default();
     }
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 6f7f7f4bc..73ea96743 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -188,7 +188,7 @@ fn chart_category_axis_from_blank_corner_and_select_data() {
     assert_eq!(series(&s), [(Some("Sheet1!$D$2:$D$4".to_string()), "Sheet1!$E$2:$E$4".to_string())]);
     let d = s.doc().unwrap();
     let sh = d.wb.active().unwrap();
-    let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet, sh.charts.last().unwrap());
+    let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet(), sh.charts.last().unwrap());
     assert_eq!(data.categories, ["2020", "2021", "2022"]);
     // The last series can't be removed; "" clears the labels.
     s.execute("chart.selectData", json!({"categories": "", "removeSeries": [0]})).unwrap();
@@ -1608,7 +1608,7 @@ fn slicer_finds_a_named_table_on_another_sheet() {
     s.execute("insert.table", json!({"range": "A1:B3", "name": "Sales"})).unwrap();
     s.execute("home.insertSheet", json!({"name": "Report"})).unwrap();
     let report = s.doc().unwrap().wb.sheet_index("Report").unwrap();
-    assert_eq!(s.doc().unwrap().wb.active_sheet, report);
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), report);
 
     // With another sheet active, `table` still names the table, and the slicer goes on the table's sheet.
     let r = s.execute("insert.slicer", json!({"table": "Sales", "column": "Region", "at": "D2"})).unwrap();
@@ -3843,7 +3843,7 @@ fn line_sizes_and_freeze_panes_take_a_sheet() {
     assert!(data.cols.get(&4).is_some_and(|c| c.hidden));
     assert_eq!(data.default_col_width, 80.0);
     assert_eq!(sheet(&s, 0), before, "the active sheet is untouched");
-    assert_eq!(s.doc().unwrap().wb.active_sheet, 0);
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
 
     s.execute("view.freezePanes", json!({"cell": "Data!B3"})).unwrap();
     assert_eq!(sheet(&s, 1).freeze, Some((2, 1)));
@@ -4550,11 +4550,11 @@ fn switching_windows_swaps_their_views_without_dirtying_the_workbook() {
 
     s.execute("window.activate", json!({"window": first})).unwrap();
     let d = s.doc().unwrap();
-    assert_eq!((d.wb.active_sheet, d.selection.a1()), (0, "B2:C3".to_string()));
+    assert_eq!((d.wb.active_sheet(), d.selection.a1()), (0, "B2:C3".to_string()));
     assert!(!d.is_dirty(), "a window's sheet and selection are not document changes");
     s.execute("view.switchWindows", json!({"window": second})).unwrap();
     let d = s.doc().unwrap();
-    assert_eq!((d.wb.active_sheet, d.selection.a1()), (1, "D4".to_string()));
+    assert_eq!((d.wb.active_sheet(), d.selection.a1()), (1, "D4".to_string()));
     assert!(!d.is_dirty());
 
     // A routed command acts in its window and leaves the active one showing.
@@ -4564,6 +4564,71 @@ fn switching_windows_swaps_their_views_without_dirtying_the_workbook() {
     assert_eq!(s.doc().unwrap().selection.a1(), "D4");
 }
 
+#[test]
+fn window_swaps_share_the_workbook_and_save_records_the_latest_window_sheet() {
+    let mut s = s();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    let path = std::env::temp_dir().join(format!("gridcraft-window-arc-{}.xlsx", std::process::id()));
+    s.execute("file.save", json!({"path": path})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    s.execute("selection.set", json!({"range": "B2"})).unwrap();
+    let first = s.active_window().unwrap();
+    let second = s.execute("view.newWindow", json!({})).unwrap()["window"].as_u64().unwrap();
+    s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
+    s.execute("selection.set", json!({"range": "C3:D4"})).unwrap();
+
+    // Swapping windows, as the interface does before drawing each one, never copies the workbook.
+    let before = s.doc().unwrap().wb.clone();
+    for _ in 0..3 {
+        s.show_window(first);
+        assert_eq!((s.doc().unwrap().wb.active_sheet(), s.doc().unwrap().selection.a1()), (0, "B2".to_string()));
+        s.activate_window(second);
+        assert_eq!((s.doc().unwrap().wb.active_sheet(), s.doc().unwrap().selection.a1()), (1, "C3:D4".to_string()));
+        s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+        s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
+    }
+    let d = s.doc().unwrap();
+    assert!(std::sync::Arc::ptr_eq(&before, &d.wb), "a window swap or sheet switch copied the workbook");
+    assert!(!d.is_dirty());
+
+    // A command run in window 2 edits window 2's sheet at its selection.
+    s.execute("cell.set", json!({"input": "two"})).unwrap();
+    let d = s.doc().unwrap();
+    assert_eq!(d.wb.sheets[1].value(CellRef::parse("C3").unwrap()), Value::text("two"));
+    assert_eq!(d.wb.sheets[0].value(CellRef::parse("B2").unwrap()), Value::Empty);
+    s.show_window(first);
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
+
+    // The most recently active window is window 2: the file records its sheet.
+    s.execute_in(crate::Target::Window(second), "file.save", json!({"path": path})).unwrap();
+    let mut t = Session::new();
+    t.execute("file.open", json!({"path": path})).unwrap();
+    let _ = std::fs::remove_file(&path);
+    assert_eq!(t.doc().unwrap().wb.active_sheet(), 1);
+    s.activate_window(first);
+    s.execute("file.save", json!({"path": path})).unwrap();
+    let mut t = Session::new();
+    t.execute("file.open", json!({"path": path})).unwrap();
+    let _ = std::fs::remove_file(&path);
+    assert_eq!(t.doc().unwrap().wb.active_sheet(), 0);
+}
+
+#[test]
+fn arrange_all_picks_the_visible_windows_active_first() {
+    let mut s = s();
+    let book1 = s.active_window().unwrap();
+    let book1b = s.execute("view.newWindow", json!({})).unwrap()["window"].as_u64().unwrap();
+    s.execute("file.new", json!({})).unwrap();
+    let book2 = s.active_window().unwrap();
+    let r = s.execute("view.arrangeAll", json!({})).unwrap();
+    assert_eq!(r, json!({"arrange": "tiled", "windows": [book2, book1, book1b]}));
+    s.execute("window.activate", json!({"window": book1b})).unwrap();
+    s.execute("view.hideWindow", json!({"window": book2})).unwrap();
+    let r = s.execute("view.arrangeAll", json!({"arrange": "cascade", "activeWorkbook": true})).unwrap();
+    assert_eq!(r, json!({"arrange": "cascade", "windows": [book1b, book1]}));
+    assert!(s.execute("view.arrangeAll", json!({"arrange": "diagonal"})).is_err());
+}
+
 #[test]
 fn hide_unhide_and_switch_by_window_id() {
     let mut s = s();
diff --git a/crates/engine/src/windows.rs b/crates/engine/src/windows.rs
index 4441166db..df43b7d32 100644
--- a/crates/engine/src/windows.rs
+++ b/crates/engine/src/windows.rs
@@ -2,10 +2,11 @@
 //!
 //! Every open workbook has one or more windows (View › New Window adds another on the same
 //! workbook). A window has its own selection, active sheet and per-sheet selections. The active
-//! window's view lives in its [`DocState`] (`selection`, `wb.active_sheet`, `sheet_selections`),
-//! where every command reads it; each other window keeps its view in [`WindowState`] until it is
-//! activated. Swapping a view in or out never makes the workbook dirty: per-window view state is
-//! not a document change.
+//! window's view lives in its [`DocState`] (`selection`, `sheet_selections`) and in the workbook's
+//! active sheet ([`gridcraft_model::workbook::Workbook::active_sheet`]), where every command reads
+//! it; each other window keeps its view in [`WindowState`] until it is activated. Swapping a view
+//! in or out never copies the workbook or makes it dirty: the active sheet is set in place through
+//! the shared `Arc`, and selections live outside the workbook.
 
 use serde_json::{Value as Json, json};
 
@@ -15,7 +16,7 @@ use crate::{DocState, EngineError, Result, Selection, Session};
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct WindowView {
     pub selection: Selection,
-    pub active_sheet: usize,
+    pub sheet: usize,
     /// The active sheet's name, so a sheet inserted, deleted or moved meanwhile in another
     /// window still finds it.
     pub sheet_name: String,
@@ -42,27 +43,20 @@ impl WindowView {
     fn capture(d: &DocState) -> WindowView {
         WindowView {
             selection: d.selection.clone(),
-            active_sheet: d.wb.active_sheet,
-            sheet_name: d.wb.sheets.get(d.wb.active_sheet).map(|s| s.name.clone()).unwrap_or_default(),
+            sheet: d.wb.active_sheet(),
+            sheet_name: d.wb.sheets.get(d.wb.active_sheet()).map(|s| s.name.clone()).unwrap_or_default(),
             sheet_selections: d.sheet_selections.clone(),
         }
     }
 
     fn apply(self, d: &mut DocState) {
         let sheets = &d.wb.sheets;
-        let at = if sheets.get(self.active_sheet).is_some_and(|s| s.name == self.sheet_name) {
-            self.active_sheet
+        let at = if sheets.get(self.sheet).is_some_and(|s| s.name == self.sheet_name) {
+            self.sheet
         } else {
-            sheets.iter().position(|s| s.name == self.sheet_name).unwrap_or(self.active_sheet)
+            sheets.iter().position(|s| s.name == self.sheet_name).unwrap_or(self.sheet)
         };
-        let at = at.min(sheets.len().saturating_sub(1));
-        if d.wb.active_sheet != at {
-            let dirty = d.is_dirty();
-            std::sync::Arc::make_mut(&mut d.wb).active_sheet = at;
-            if !dirty {
-                d.saved = d.wb.clone();
-            }
-        }
+        d.wb.set_active_sheet(at.min(sheets.len().saturating_sub(1)));
         d.selection = self.selection;
         d.sheet_selections = self.sheet_selections;
     }
diff --git a/crates/engine/tests/command_sequence_fuzz.rs b/crates/engine/tests/command_sequence_fuzz.rs
index 1724b9b9d..fd06c70b3 100644
--- a/crates/engine/tests/command_sequence_fuzz.rs
+++ b/crates/engine/tests/command_sequence_fuzz.rs
@@ -373,8 +373,8 @@ fn structure_problem(wb: &Workbook, sel: &gridcraft_engine::Selection) -> Option
     if wb.sheets.is_empty() {
         return Some("no sheets left".into());
     }
-    if wb.active_sheet >= wb.sheets.len() {
-        return Some(format!("active sheet {} of {}", wb.active_sheet, wb.sheets.len()));
+    if wb.active_sheet() >= wb.sheets.len() {
+        return Some(format!("active sheet {} of {}", wb.active_sheet(), wb.sheets.len()));
     }
     let mut tables = BTreeSet::new();
     for (i, sh) in wb.sheets.iter().enumerate() {
@@ -490,7 +490,7 @@ fn watch_list(wb: &Workbook) -> Option<&str> {
 /// reset: undo restores view state as it was, but switching sheets isn't an undoable edit.
 fn canonical(wb: &Workbook) -> Workbook {
     let mut wb = wb.clone();
-    wb.active_sheet = 0;
+    wb.set_active_sheet(0);
     wb.names.retain(|n| n.name != WATCH_NAME);
     for sh in wb.sheets.iter_mut() {
         let sh = Arc::make_mut(sh);
diff --git a/crates/engine/tests/hidden_sheet_navigation.rs b/crates/engine/tests/hidden_sheet_navigation.rs
index f457f4bdb..8869d52ba 100644
--- a/crates/engine/tests/hidden_sheet_navigation.rs
+++ b/crates/engine/tests/hidden_sheet_navigation.rs
@@ -25,7 +25,7 @@ fn next_stays_on_the_last_visible_sheet() {
     for _ in 0..2 {
         session.execute("sheet.next", json!({})).unwrap();
         let doc = session.active().unwrap();
-        assert_eq!(doc.wb.active_sheet, 1);
+        assert_eq!(doc.wb.active_sheet(), 1);
         assert_eq!(doc.selection.active.a1(), "C7");
     }
 }
@@ -36,7 +36,7 @@ fn previous_stays_on_the_first_visible_sheet() {
     for _ in 0..2 {
         session.execute("sheet.previous", json!({})).unwrap();
         let doc = session.active().unwrap();
-        assert_eq!(doc.wb.active_sheet, 2);
+        assert_eq!(doc.wb.active_sheet(), 2);
         assert_eq!(doc.selection.active.a1(), "C7");
     }
 }
@@ -45,10 +45,10 @@ fn previous_stays_on_the_first_visible_sheet() {
 fn navigation_skips_hidden_sheets_in_both_directions() {
     let mut session = workbook(&[1, 2], 0);
     session.execute("sheet.next", json!({})).unwrap();
-    assert_eq!(session.active().unwrap().wb.active_sheet, 3);
+    assert_eq!(session.active().unwrap().wb.active_sheet(), 3);
     session.execute("sheet.previous", json!({})).unwrap();
     let doc = session.active().unwrap();
-    assert_eq!(doc.wb.active_sheet, 0);
+    assert_eq!(doc.wb.active_sheet(), 0);
     assert_eq!(doc.selection.active.a1(), "C7");
 }
 
@@ -58,7 +58,7 @@ fn navigation_with_one_visible_sheet_is_a_noop() {
     for command in ["sheet.previous", "sheet.next"] {
         session.execute(command, json!({})).unwrap();
         let doc = session.active().unwrap();
-        assert_eq!(doc.wb.active_sheet, 1);
+        assert_eq!(doc.wb.active_sheet(), 1);
         assert_eq!(doc.selection.active.a1(), "C7");
     }
 }
@@ -73,6 +73,6 @@ fn very_hidden_sheets_are_skipped_at_interior_and_boundary_positions() {
     }
     for (command, expected) in [("sheet.next", 2), ("sheet.next", 2), ("sheet.previous", 0)] {
         session.execute(command, json!({})).unwrap();
-        assert_eq!(session.active().unwrap().wb.active_sheet, expected);
+        assert_eq!(session.active().unwrap().wb.active_sheet(), expected);
     }
 }
diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs
index 3b943d295..ac6b3131b 100644
--- a/crates/model/src/workbook.rs
+++ b/crates/model/src/workbook.rs
@@ -1,6 +1,7 @@
 //! Workbooks.
 
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use gridcraft_core::DateSystem;
 use gridcraft_formula::Expr;
@@ -147,7 +148,8 @@ pub struct Workbook {
     pub calc: CalcSettings,
     #[serde(default, skip_serializing_if = "is_all")]
     pub show_objects: ShowObjects,
-    pub active_sheet: usize,
+    /// Read and set with [`Workbook::active_sheet`] and [`Workbook::set_active_sheet`].
+    pub active_sheet: ActiveSheet,
     pub props: DocProps,
     /// Workbook structure protection.
     pub protected_structure: bool,
@@ -205,6 +207,57 @@ impl Default for Workbook {
     }
 }
 
+/// The active sheet index of a [`Workbook`].
+///
+/// Every other part of a workbook value is immutable once shared (the engine keeps versions as
+/// `Arc<Workbook>` and tells unsaved changes by pointer). The active sheet is the exception: it
+/// is the view state of the window showing the workbook, and several windows on one workbook
+/// swap their own sheet into it whenever one of them becomes the one commands act on. Keeping it
+/// in an atomic lets that swap happen through the shared `Arc` without cloning the workbook.
+/// Copies (undo versions, a cloned workbook) take the value at the time of the copy.
+#[derive(Default, Serialize, Deserialize)]
+#[serde(from = "usize", into = "usize")]
+pub struct ActiveSheet(AtomicUsize);
+
+impl ActiveSheet {
+    pub fn get(&self) -> usize {
+        self.0.load(Ordering::Relaxed)
+    }
+    pub fn set(&self, i: usize) {
+        self.0.store(i, Ordering::Relaxed);
+    }
+}
+
+impl From<usize> for ActiveSheet {
+    fn from(i: usize) -> ActiveSheet {
+        ActiveSheet(AtomicUsize::new(i))
+    }
+}
+
+impl From<ActiveSheet> for usize {
+    fn from(a: ActiveSheet) -> usize {
+        a.get()
+    }
+}
+
+impl Clone for ActiveSheet {
+    fn clone(&self) -> ActiveSheet {
+        ActiveSheet::from(self.get())
+    }
+}
+
+impl PartialEq for ActiveSheet {
+    fn eq(&self, other: &ActiveSheet) -> bool {
+        self.get() == other.get()
+    }
+}
+
+impl std::fmt::Debug for ActiveSheet {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.get().fmt(f)
+    }
+}
+
 impl Workbook {
     /// A new workbook with one sheet, "Sheet1".
     pub fn new() -> Workbook {
@@ -216,7 +269,7 @@ impl Workbook {
             date_system: DateSystem::D1900,
             calc: CalcSettings::default(),
             show_objects: ShowObjects::All,
-            active_sheet: 0,
+            active_sheet: ActiveSheet::default(),
             props: DocProps::default(),
             protected_structure: false,
             structure_password: None,
@@ -239,8 +292,17 @@ impl Workbook {
     pub fn sheet_index(&self, name: &str) -> Option<usize> {
         self.sheets.iter().position(|s| s.name.eq_ignore_ascii_case(name))
     }
+    /// The index of the sheet the workbook's window shows (the file's active tab).
+    pub fn active_sheet(&self) -> usize {
+        self.active_sheet.get()
+    }
+    /// Changes the active sheet in place, also through a shared `Arc<Workbook>`: it is view state,
+    /// so switching sheets or windows neither copies the workbook nor makes it a new version.
+    pub fn set_active_sheet(&self, i: usize) {
+        self.active_sheet.set(i);
+    }
     pub fn active(&self) -> Option<&Sheet> {
-        self.sheet(self.active_sheet)
+        self.sheet(self.active_sheet())
     }
     /// A fresh sheet name `SheetN` not in use.
     pub fn next_sheet_name(&self) -> String {
diff --git a/crates/ui-egui/examples/snapshot.rs b/crates/ui-egui/examples/snapshot.rs
index dcee71173..3fe935732 100644
--- a/crates/ui-egui/examples/snapshot.rs
+++ b/crates/ui-egui/examples/snapshot.rs
@@ -119,7 +119,7 @@ fn main() {
                     app.open_dialog(name, p);
                 }
                 // Page Layout view: edit the first page's centre header (or footer) section.
-                let active = app.session.active().and_then(|d| d.wb.active().cloned().map(|s| (d.wb.active_sheet, s)));
+                let active = app.session.active().and_then(|d| d.wb.active().cloned().map(|s| (d.wb.active_sheet(), s)));
                 if let (Some(part), Some((si, sh))) = (&hf_edit, active) {
                     let zone = gridcraft_engine::paper::HfZone { footer: part == "footer", section: 1 };
                     gridcraft_ui_egui::paper_view::begin(&mut app, si, &sh, (0, 0), zone);
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index bf1dedac1..ec04f327b 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -343,9 +343,10 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) -
             Some(d) => match d.command {
                 Some(cmd) => {
                     let params = crate::dialogs::build_params(&d);
+                    let home = app.ui_window();
                     let r = app.run(cmd, params);
                     if r.is_err() {
-                        app.dialog = Some(d);
+                        app.return_dialog(home, d);
                     }
                     wrap(r)
                 }
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 55c0819df..d463d8670 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -134,6 +134,20 @@ impl Dialog {
                 }],
                 json!({"shift": "down"}),
             ),
+            "arrangeAll" => Dialog::form(
+                "arrangeAll",
+                "Arrange Windows",
+                "view.arrangeAll",
+                vec![
+                    Choice {
+                        key: "arrange",
+                        label: "Arrange",
+                        options: vec![("tiled", "Tiled"), ("horizontal", "Horizontal"), ("vertical", "Vertical"), ("cascade", "Cascade")],
+                    },
+                    Check { key: "activeWorkbook", label: "Windows of active workbook" },
+                ],
+                json!({"arrange": "tiled", "activeWorkbook": false}),
+            ),
             "insertPaste" => Dialog::form(
                 "insertPaste",
                 "Insert Paste",
@@ -540,7 +554,7 @@ impl Dialog {
             }
             "solver" => {
                 // Starts from the sheet's saved model, else the active cell as objective.
-                let saved = app.session.active().and_then(|doc| gridcraft_engine::cmd::solver::saved_model(&doc.wb, doc.wb.active_sheet));
+                let saved = app.session.active().and_then(|doc| gridcraft_engine::cmd::solver::saved_model(&doc.wb, doc.wb.active_sheet()));
                 let mut values = json!({"objective": active, "goal": "max", "value": "0", "variables": "", "constraints": [], "nonNegative": true, "method": "grg"});
                 if let (Some(m), Some(v)) = (saved.as_ref().and_then(Json::as_object), values.as_object_mut()) {
                     for (k, x) in m {
@@ -776,7 +790,7 @@ impl Dialog {
                 // Chart Design › Select Data: data range, series to keep, category axis labels.
                 let id = p("chart").as_u64();
                 let found = app.session.active().and_then(|doc| {
-                    let si = doc.wb.active_sheet;
+                    let si = doc.wb.active_sheet();
                     let sh = doc.wb.sheet(si)?;
                     let ch = sh.charts.iter().find(|c| Some(u64::from(c.id)) == id)?;
                     let data = gridcraft_chart::resolve(&doc.wb, si, ch);
@@ -1139,6 +1153,7 @@ pub(crate) fn build_params(d: &Dialog) -> Json {
 
 pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
     let Some(mut d) = app.dialog.take() else { return };
+    let home = app.ui_window();
     if d.name == "pasteSpecial" {
         paste_special_shortcuts(&mut d, ctx);
     }
@@ -1415,6 +1430,15 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
     } else if confirm {
         open = false;
     }
+    if app.ui_window() != home {
+        // A command run from the dialog switched windows: whatever it opened shows in the new
+        // window, and this dialog (or the one it returns to) stays in its own.
+        let keep = if open { Some(d) } else { d.back.take().map(|b| *b) };
+        if let Some(keep) = keep {
+            app.return_dialog(home, keep);
+        }
+        return;
+    }
     if let Some(child) = app.dialog.as_mut() {
         // The body opened another dialog (Name Manager › New…). It takes over; this one waits
         // behind it and comes back when it closes, as Excel returns to the Name Manager. Go To
@@ -2032,7 +2056,7 @@ fn insert_function(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confir
     let mut open = true;
     ok_cancel(ui, confirm, &mut open);
     if *confirm && let Some(n) = hits.get(d.list_index).and_then(|f| f["name"].as_str()) {
-        let n = app.session.active().map(|doc| crate::formula_locale::completion_name(n, locale, &doc.wb, doc.wb.active_sheet)).unwrap_or(n);
+        let n = app.session.active().map(|doc| crate::formula_locale::completion_name(n, locale, &doc.wb, doc.wb.active_sheet())).unwrap_or(n);
         let cur = app.editor.as_ref().map(|e| e.text.clone());
         let text = match cur {
             Some(t) if t.starts_with('=') => format!("{t}{n}("),
diff --git a/crates/ui-egui/src/doc_windows.rs b/crates/ui-egui/src/doc_windows.rs
index 88ba3967a..f4dcc2107 100644
--- a/crates/ui-egui/src/doc_windows.rs
+++ b/crates/ui-egui/src/doc_windows.rs
@@ -18,7 +18,7 @@
 //!
 //! [`Session::windows`]: gridcraft_engine::Session::windows
 
-use craft_window::{Frame, Viewports, WindowEvent, WindowId, WindowList};
+use craft_window::{CASCADE_STEP, Frame, Rect, Viewports, WindowEvent, WindowId, WindowList, cascade};
 use serde_json::json;
 
 use crate::SheetApp;
@@ -79,6 +79,33 @@ impl DocWindows {
     /// the logic then): shows windows created or opened by menu commands, files and scripts.
     pub fn logic(&mut self, app: &mut SheetApp, ctx: &egui::Context) {
         self.sync(app, ctx);
+        if let Some((arrange, windows)) = app.arrange_windows.take() {
+            self.arrange(ctx, &arrange, &windows);
+        }
+    }
+
+    /// View › Arrange All: moves and sizes the native windows of `windows` (engine ids, the first
+    /// on top or at the top left) over the root window's monitor.
+    fn arrange(&self, ctx: &egui::Context, arrange: &str, windows: &[u64]) {
+        let ids: Vec<WindowId> = windows.iter().filter_map(|w| self.find(*w)).collect();
+        let (monitor, infos) = ctx.input(|i| (i.viewport().monitor_size, i.raw.viewports.clone()));
+        // Platforms that don't report the monitor (Wayland, tests) get a common laptop screen.
+        let size = monitor.filter(|m| m.x > 0.0 && m.y > 0.0).unwrap_or(egui::vec2(1280.0, 800.0));
+        let mut rects = arrange_rects(arrange, ids.len(), Rect::new(0.0, 0.0, size.x, size.y));
+        if arrange == "cascade" {
+            // The active window goes in front: the last step of the cascade.
+            rects.reverse();
+        }
+        for (id, r) in ids.iter().zip(rects) {
+            let vp = self.viewports.viewport_id(*id);
+            // Inner size is what can be set: take off the frame the window has now.
+            let frame = infos.get(&vp).and_then(|v| Some(v.outer_rect?.size() - v.inner_rect?.size())).unwrap_or(egui::Vec2::ZERO);
+            ctx.send_viewport_cmd_to(vp, egui::ViewportCommand::OuterPosition(egui::pos2(r.x, r.y)));
+            ctx.send_viewport_cmd_to(vp, egui::ViewportCommand::InnerSize((egui::vec2(r.width, r.height) - frame).max(egui::vec2(240.0, 160.0))));
+        }
+        if let Some(first) = ids.first() {
+            self.viewports.focus(ctx, *first);
+        }
     }
 
     /// Mirrors the engine's visible windows: closed or hidden windows lose their native window
@@ -225,3 +252,48 @@ fn window_title(app: &SheetApp, window: u64) -> String {
     let dirty = app.session.window(window).and_then(|w| app.session.documents().iter().find(|d| d.uid == w.doc_uid)).is_some_and(|d| d.is_dirty());
     if dirty { format!("{title} — Edited") } else { title }
 }
+
+/// Outer rectangles for `n` windows arranged within `bounds` as View › Arrange All's `arrange`
+/// says: `tiled` (a grid, the last row's windows widened to fill it), `horizontal` (stacked top
+/// to bottom), `vertical` (side by side) or `cascade` (each one title bar below and right of the
+/// previous, wrapping at the edges).
+pub fn arrange_rects(arrange: &str, n: usize, bounds: Rect) -> Vec<Rect> {
+    if n == 0 {
+        return vec![];
+    }
+    let count = n as f32;
+    match arrange {
+        "horizontal" => {
+            let h = bounds.height / count;
+            (0..n).map(|i| Rect::new(bounds.x, bounds.y + h * i as f32, bounds.width, h)).collect()
+        }
+        "vertical" => {
+            let w = bounds.width / count;
+            (0..n).map(|i| Rect::new(bounds.x + w * i as f32, bounds.y, w, bounds.height)).collect()
+        }
+        "cascade" => {
+            let shift = CASCADE_STEP * (count - 1.0);
+            let size = [(bounds.width - shift).max(bounds.width * 0.5), (bounds.height - shift).max(bounds.height * 0.5)];
+            let mut previous = Rect::new(bounds.x - CASCADE_STEP, bounds.y - CASCADE_STEP, size[0], size[1]);
+            (0..n)
+                .map(|_| {
+                    previous = cascade(previous, size, bounds, CASCADE_STEP);
+                    previous
+                })
+                .collect()
+        }
+        _ => {
+            let cols = (count.sqrt().ceil() as usize).max(1);
+            let rows = n.div_ceil(cols);
+            let h = bounds.height / rows as f32;
+            (0..n)
+                .map(|i| {
+                    let (row, col) = (i / cols, i % cols);
+                    let in_row = if row + 1 == rows { n - row * cols } else { cols };
+                    let w = bounds.width / in_row as f32;
+                    Rect::new(bounds.x + w * col as f32, bounds.y + h * row as f32, w, h)
+                })
+                .collect()
+        }
+    }
+}
diff --git a/crates/ui-egui/src/formula_bar.rs b/crates/ui-egui/src/formula_bar.rs
index b88699f57..5ca1edd12 100644
--- a/crates/ui-egui/src/formula_bar.rs
+++ b/crates/ui-egui/src/formula_bar.rs
@@ -83,7 +83,7 @@ fn active_input(app: &SheetApp) -> String {
         }
         return sh
             .cell(anchor)
-            .map(|c| crate::formula_locale::display(&c.input_text(), app.ui.language.formula_locale(), &d.wb, d.wb.active_sheet))
+            .map(|c| crate::formula_locale::display(&c.input_text(), app.ui.language.formula_locale(), &d.wb, d.wb.active_sheet()))
             .unwrap_or_default();
     }
     if let Some(c) = sh.cell(a) {
@@ -91,7 +91,7 @@ fn active_input(app: &SheetApp) -> String {
             return String::new();
         }
         return if let Some(f) = &c.formula {
-            let shown = crate::formula_locale::display(&c.input_text(), app.ui.language.formula_locale(), &d.wb, d.wb.active_sheet);
+            let shown = crate::formula_locale::display(&c.input_text(), app.ui.language.formula_locale(), &d.wb, d.wb.active_sheet());
             // A legacy array formula shows in braces (`{=A1:A2*2}`), as `Cell::bar_text` does.
             if f.array.is_some() { format!("{{{shown}}}") } else { shown }
         } else {
@@ -126,7 +126,7 @@ fn name_box(app: &mut SheetApp, ui: &mut egui::Ui, t: &Tokens) {
             if !target.is_empty() && target != shown {
                 // A new name for the selection, or a place to go.
                 let is_ref = gridcraft_engine::core::RangeRef::parse(target.split('!').next_back().unwrap_or("")).is_some();
-                let known = app.session.active().is_some_and(|d| d.wb.name(&target, d.wb.active_sheet).is_some() || d.wb.table(&target).is_some());
+                let known = app.session.active().is_some_and(|d| d.wb.name(&target, d.wb.active_sheet()).is_some() || d.wb.table(&target).is_some());
                 let r = if is_ref || known {
                     app.run("edit.goTo", json!({"reference": target}))
                 } else {
diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index 145b9f583..37d12759d 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -563,7 +563,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
     app.grid.rect = Some(rect);
     let Some(d) = app.session.active() else { return };
     let wb: Arc<Workbook> = d.wb.clone();
-    let si = wb.active_sheet;
+    let si = wb.active_sheet();
     let Some(sh) = wb.sheet(si) else { return };
     let sel = d.selection.clone();
     let place = (d.uid, si);
@@ -1803,7 +1803,7 @@ pub(crate) fn paint_selection(
     }
     // Marching ants around the copied range.
     if let Some(clip) = &app.session.clipboard
-        && app.session.active().is_some_and(|d| d.uid == clip.doc_uid && d.wb.active_sheet == clip.sheet)
+        && app.session.active().is_some_and(|d| d.uid == clip.doc_uid && d.wb.active_sheet() == clip.sheet)
         && range_in_pane(clip.range, rows, cols)
     {
         // A multi-area copy marks each area as selected.
@@ -2109,7 +2109,7 @@ fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &
     if primary_clicked
         && !resp.drag_started()
         && let Some(p) = pos
-        && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet, p)
+        && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p)
     {
         app.selected_chart = Some(id);
         match act {
@@ -2307,13 +2307,13 @@ fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &
             && ed.can_point()
         {
             let anchor = if mods.shift && ed.point_at_caret() {
-                ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet).map(|(_, cell)| cell).unwrap_or(c)
+                ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet()).map(|(_, cell)| cell).unwrap_or(c)
             } else {
                 c
             };
             let range = RangeRef::new(anchor, c);
             let text = if range.is_single() { c.a1() } else { range.a1() };
-            let sheet_name = (ed.sheet != wb.active_sheet).then(|| sh.name.clone());
+            let sheet_name = (ed.sheet != wb.active_sheet()).then(|| sh.name.clone());
             let r = match sheet_name {
                 Some(n) => format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&n)),
                 None => text,
@@ -2325,7 +2325,7 @@ fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &
             }
             ed.request_focus = true;
             ed.point_cell = Some(c);
-            ed.point_anchor = Some((wb.active_sheet, anchor));
+            ed.point_anchor = Some((wb.active_sheet(), anchor));
             app.grid.drag = Drag::Select;
             app.grid.drag_select = true;
             if resp.drag_started()
@@ -2614,7 +2614,7 @@ fn format_painter_apply(app: &mut SheetApp) {
 fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, extend: bool, add: bool) -> bool {
     let Some(ed) = app.editor.as_mut().filter(|ed| ed.can_point()) else { return false };
     let edit_sheet = ed.sheet;
-    let active_sheet = wb.active_sheet;
+    let active_sheet = wb.active_sheet();
     let range = if extend {
         ed.point
             .and_then(|point| crate::editor::formula_refs(&ed.text).into_iter().find(|(start, end, ..)| (*start, *end) == point))
@@ -2636,7 +2636,8 @@ fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef,
         range
     };
     let reference = range.a1();
-    let reference = if ed.sheet != wb.active_sheet { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference };
+    let reference =
+        if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference };
     if add {
         ed.append_ref(&reference);
     } else {
@@ -2656,13 +2657,13 @@ fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p
     if let Some(ed) = app.editor.as_mut()
         && ed.point.is_some()
     {
-        if let Some(start) = ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet).map(|(_, cell)| cell).or(ed.point_cell) {
+        if let Some(start) = ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet()).map(|(_, cell)| cell).or(ed.point_cell) {
             let range = RangeRef::new(start, cell);
             let text = if range.is_single() { range.start.a1() } else { range.a1() };
-            let text = if ed.sheet != wb.active_sheet { format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { text };
+            let text = if ed.sheet != wb.active_sheet() { format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { text };
             ed.insert_ref(&text);
             ed.point_cell = Some(cell);
-            ed.point_anchor = Some((wb.active_sheet, start));
+            ed.point_anchor = Some((wb.active_sheet(), start));
         }
     } else if let Some(d) = app.session.active() {
         // Read the current anchor: starting a drag may have just replaced the selection.
@@ -3117,7 +3118,7 @@ fn filter_menu(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_open: bool)
     let Some((col, row, at)) = app.grid.filter_menu else { return };
     let Some(d) = app.session.active() else { return };
     let wb = d.wb.clone();
-    let si = wb.active_sheet;
+    let si = wb.active_sheet();
     let Some(sh) = wb.sheet(si) else { return };
     let _ = geo;
     // Tables get an autofilter on demand.
@@ -3460,12 +3461,12 @@ pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, exte
                 )
             })
             .unwrap_or(from);
-        ed.point_anchor.filter(|(sheet, _)| *sheet == d.wb.active_sheet).map(|(_, cell)| cell).unwrap_or(inferred_anchor)
+        ed.point_anchor.filter(|(sheet, _)| *sheet == d.wb.active_sheet()).map(|(_, cell)| cell).unwrap_or(inferred_anchor)
     } else {
         to
     };
     let text = if extend { RangeRef::new(anchor, to).a1() } else { to.a1() };
-    let sheet = d.wb.active_sheet;
+    let sheet = d.wb.active_sheet();
     ed.insert_ref(&text);
     ed.point_cell = Some(to);
     ed.point_anchor = Some((sheet, anchor));
@@ -3606,7 +3607,7 @@ fn list_picker(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_open: bool)
     let Some(c) = app.grid.list_picker else { return };
     let Some(d) = app.session.active() else { return };
     let wb = d.wb.clone();
-    let si = wb.active_sheet;
+    let si = wb.active_sheet();
     let Some(sh) = wb.sheet(si) else { return };
     let Some(dv) = sh.validations.iter().find(|x| x.ranges.iter().any(|r| r.contains(c))).cloned() else {
         app.grid.list_picker = None;
@@ -3743,7 +3744,7 @@ fn is_checkbox(sh: &Sheet, app: &SheetApp) -> bool {
 
 fn paint_pages(app: &mut SheetApp, p: &Painter, geo: &Geo, sh: &Sheet) {
     let Some(d) = app.session.active() else { return };
-    let key = (d.uid, d.revision, d.wb.active_sheet);
+    let key = (d.uid, d.revision, d.wb.active_sheet());
     if app.grid.pages.as_ref().is_none_or(|(k, _)| *k != key) {
         let pages: Vec<(RangeRef, u32)> = app
             .session
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 19f69a90f..973b12de5 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -342,6 +342,8 @@ pub struct SheetApp {
     /// tests, embedding hosts) one window shows the active workbook window, and its close button
     /// quits.
     pub native_windows: bool,
+    /// View › Arrange All's layout and windows, waiting for the native windows to move.
+    pub arrange_windows: Option<(String, Vec<u64>)>,
     /// The native window that has focus, which menu commands and screenshots go to.
     pub(crate) focus_window: Option<u64>,
 }
@@ -394,6 +396,7 @@ impl SheetApp {
             ui_window: None,
             parked: HashMap::new(),
             native_windows: false,
+            arrange_windows: None,
             focus_window: None,
         }
     }
@@ -479,6 +482,14 @@ impl SheetApp {
         // Requests the command made (a dialog, a draft) belong to the window it left active.
         self.follow_active_window();
         self.after_engine();
+        if id == "view.arrangeAll"
+            && self.native_windows
+            && let Ok(r) = &r
+        {
+            let arrange = r.get("arrange").and_then(Json::as_str).unwrap_or("tiled").to_string();
+            let windows = r.get("windows").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
+            self.arrange_windows = Some((arrange, windows));
+        }
         // The new chart is selected, as after inserting any object, so Delete removes it, not its data.
         if id == "insert.chart"
             && let Ok(r) = &r
@@ -811,7 +822,7 @@ impl SheetApp {
                     let text = text.map(|text| {
                         self.session
                             .active()
-                            .map(|d| formula_locale::display_template(&text, self.ui.language.formula_locale(), &d.wb, d.wb.active_sheet))
+                            .map(|d| formula_locale::display_template(&text, self.ui.language.formula_locale(), &d.wb, d.wb.active_sheet()))
                             .unwrap_or(text)
                     });
                     self.begin_edit(text, false);
@@ -977,12 +988,12 @@ impl SheetApp {
 
     /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
     pub fn view_key(&self) -> Option<(u64, usize)> {
-        self.session.active().map(|d| (d.uid, d.wb.active_sheet))
+        self.session.active().map(|d| (d.uid, d.wb.active_sheet()))
     }
 
     /// The active window and sheet: each window scrolls on its own.
     fn scroll_key(&self) -> Option<(u64, usize)> {
-        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet))
+        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet()))
     }
 
     pub fn view(&self) -> SheetView {
@@ -1053,7 +1064,7 @@ impl SheetApp {
             String::new()
         } else {
             match sh.cell(at) {
-                Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet),
+                Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet()),
                 _ => gridcraft_engine::display::edit_text(&d.wb, sh, at),
             }
         };
@@ -1061,7 +1072,7 @@ impl SheetApp {
             Some(t) => (t, true),
             None => (current.clone(), false),
         };
-        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet, at, text, replace, from_formula_bar);
+        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet(), at, text, replace, from_formula_bar);
         ed.window = self.session.active_window();
         ed.locale = locale;
         if replace && self.ui.autocomplete && !ed.is_formula() {
@@ -1153,7 +1164,7 @@ impl SheetApp {
             self.toast = Some((msg, now_ms()));
         }
         // Point mode can leave another sheet active; the edit belongs to the sheet it started on.
-        if self.session.active().is_some_and(|d| d.wb.active_sheet != ed.sheet)
+        if self.session.active().is_some_and(|d| d.wb.active_sheet() != ed.sheet)
             && let Err(e) = self.session.run("sheet.activate", json!({"sheet": ed.sheet}))
         {
             self.message = Some(("GridCraft".into(), clean_error(&e)));
@@ -1214,7 +1225,7 @@ impl SheetApp {
         let multi = self.session.active().is_some_and(|d| !d.selection.is_single_cell());
         // Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
         // last Tab landed on, which ends the run.
-        let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet, d.selection.active));
+        let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
         let run = self.tab_run.take().filter(|&(uid, sheet, _, at)| here == Some((uid, sheet, at)));
         if multi {
             let fwd = dr > 0 || dc > 0;
@@ -1227,7 +1238,7 @@ impl SheetApp {
             if dr == 0 && dc != 0 {
                 let start = run.map(|r| r.2);
                 self.tab_run = self.session.active().and_then(|d| {
-                    let (uid, sheet) = (d.uid, d.wb.active_sheet);
+                    let (uid, sheet) = (d.uid, d.wb.active_sheet());
                     let col = start.or(here.map(|h| h.2.col))?;
                     Some((uid, sheet, col, d.selection.active))
                 });
diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs
index a8a7e35f4..623803e2a 100644
--- a/crates/ui-egui/src/panes.rs
+++ b/crates/ui-egui/src/panes.rs
@@ -230,7 +230,7 @@ fn format_chart(app: &mut SheetApp, ui: &mut Ui) {
         });
     });
     ui.collapsing("Series", |ui| {
-        let data = app.session.active().map(|d| gridcraft_chart::resolve(&d.wb, d.wb.active_sheet, &chart));
+        let data = app.session.active().map(|d| gridcraft_chart::resolve(&d.wb, d.wb.active_sheet(), &chart));
         for (i, s) in chart.series.iter().enumerate() {
             let name = data.as_ref().and_then(|d| d.series.get(i)).map(|x| x.name.clone()).unwrap_or_else(|| format!("Series {}", i + 1));
             let col =
diff --git a/crates/ui-egui/src/paper_view.rs b/crates/ui-egui/src/paper_view.rs
index 621a97903..c3bc3312d 100644
--- a/crates/ui-egui/src/paper_view.rs
+++ b/crates/ui-egui/src/paper_view.rs
@@ -279,14 +279,14 @@ pub(crate) fn paint_headers_footers(app: &SheetApp, ui: &egui::Ui, p: &Painter,
 pub(crate) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet, wb: &Workbook) {
     // Leaving the sheet or the view commits.
     if let Some(e) = &app.grid.hf_edit
-        && (e.sheet != wb.active_sheet || sh.view != SheetViewMode::PageLayout || geo.paper.is_none())
+        && (e.sheet != wb.active_sheet() || sh.view != SheetViewMode::PageLayout || geo.paper.is_none())
     {
         commit(app);
     }
     let Some(pg) = geo.paper.clone() else { return };
-    ruler_margins(app, ui, geo, &pg, sh, wb.active_sheet);
+    ruler_margins(app, ui, geo, &pg, sh, wb.active_sheet());
     if std::mem::take(&mut app.grid.hf_start) {
-        begin(app, wb.active_sheet, sh, (pg.data_rows.0, pg.data_cols.0), HfZone { footer: false, section: 1 });
+        begin(app, wb.active_sheet(), sh, (pg.data_rows.0, pg.data_cols.0), HfZone { footer: false, section: 1 });
     }
     if resp.clicked_by(egui::PointerButton::Primary)
         && let Some(p) = ui.input(|i| i.pointer.interact_pos())
@@ -294,7 +294,7 @@ pub(crate) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         let (x, y) =
             (geo.scroll.x as f64 + ((p.x - geo.cells.left()) / geo.z) as f64, geo.scroll.y as f64 + ((p.y - geo.cells.top()) / geo.z) as f64);
         match pg.hf_zone_at(x, y) {
-            Some((page, zone)) if geo.cells.contains(p) => begin(app, wb.active_sheet, sh, page, zone),
+            Some((page, zone)) if geo.cells.contains(p) => begin(app, wb.active_sheet(), sh, page, zone),
             _ => {
                 // A click anywhere else ends the edit; the grid then handles the click.
                 if app.grid.hf_edit.is_some() {
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index 6bd45e18f..bea9e7191 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -1930,7 +1930,7 @@ fn formulas(app: &mut SheetApp, ui: &mut Ui) {
                     {
                         let locale = app.ui.language.formula_locale();
                         let name =
-                            app.session.active().map(|d| crate::formula_locale::completion_name(n, locale, &d.wb, d.wb.active_sheet)).unwrap_or(n);
+                            app.session.active().map(|d| crate::formula_locale::completion_name(n, locale, &d.wb, d.wb.active_sheet())).unwrap_or(n);
                         let desc = crate::formula_locale::description(n, locale, app.ui.language).unwrap_or_default();
                         if ui.button(name).on_hover_text(desc).clicked() {
                             app.run_or_alert("formulas.insertFunction", json!({"name": n}));
@@ -2318,6 +2318,16 @@ fn view(app: &mut SheetApp, ui: &mut Ui) {
         act(app, "view.zoomToSelection", json!({"viewWidth": r.width(), "viewHeight": r.height()}));
     }
     sep(ui);
+    let __k = big_button(ui, Icon::NewFile, "New\nWindow", "New Window", false);
+    control_keytip(app, ui, &__k, "view.newWindow");
+    if __k.clicked() {
+        act(app, "view.newWindow", json!({}));
+    }
+    let __k = big_button(ui, Icon::Table, "Arrange\nAll", "Arrange All", false);
+    control_keytip(app, ui, &__k, "view.arrangeAll");
+    if __k.clicked() {
+        app.open_dialog("arrangeAll", json!({}));
+    }
     let fp = big_button(ui, Icon::Freeze, "Freeze\nPanes", "Freeze Panes", true);
     for sequence in
         keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["view.freezePanes", "view.freezeTopRow", "view.freezeFirstColumn"])
diff --git a/crates/ui-egui/src/tabs.rs b/crates/ui-egui/src/tabs.rs
index bc6fcc1d8..14d2dfc6a 100644
--- a/crates/ui-egui/src/tabs.rs
+++ b/crates/ui-egui/src/tabs.rs
@@ -72,7 +72,7 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
             let all = crate::widgets::icon_button(ui, Icon::SheetList, t.text_dim, app.ui.language.tr("All sheets"), vec2(24.0, 24.0));
             all.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, app.ui.language.tr("All sheets")));
             let items = app.session.active().map(|d| navigator_items(&d.wb.sheets)).unwrap_or_default();
-            let active = app.session.active().map(|d| d.wb.active_sheet.to_string()).unwrap_or_default();
+            let active = app.session.active().map(|d| d.wb.active_sheet().to_string()).unwrap_or_default();
             let rows: Vec<(&str, String)> = items.iter().map(|(i, name)| (i.as_str(), name.clone())).collect();
             if let crate::ribbon::ComboResult::Picked(i) = crate::ribbon::editable_combo(ui, &all, "sheet_navigator", &active, &rows, false)
                 && let Ok(i) = i.parse::<usize>()
@@ -86,7 +86,7 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
                     .iter()
                     .enumerate()
                     .filter(|(_, s)| s.visibility == Visibility::Visible)
-                    .map(|(i, s)| (i, s.name.clone(), s.tab_color.and_then(|c| c.resolve(&d.wb.theme)), i == d.wb.active_sheet))
+                    .map(|(i, s)| (i, s.name.clone(), s.tab_color.and_then(|c| c.resolve(&d.wb.theme)), i == d.wb.active_sheet()))
                     .collect();
             // Keep worksheet tabs in their own horizontally scrollable viewport. As in Excel, the
             // tabs get up to 60% of the bar and the grid's horizontal scrollbar the rest; a strip
@@ -94,7 +94,7 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
             let tabs_width = (ui.available_width() * 0.6).max(100.0);
             // Reveal the selected sheet after navigation or layout changes, but
             // allow browsing other tabs without snapping back on every frame.
-            let reveal_key = egui::Id::new((d.uid, d.wb.active_sheet, &sheets, tabs_width.to_bits()));
+            let reveal_key = egui::Id::new((d.uid, d.wb.active_sheet(), &sheets, tabs_width.to_bits()));
             let reveal_id = ui.id().with("worksheet_tabs_reveal");
             let reveal_active = ui.ctx().data_mut(|data| {
                 let changed = data.get_temp::<egui::Id>(reveal_id) != Some(reveal_key);
@@ -451,11 +451,11 @@ mod tests {
         let mut app = crate::SheetApp::new(session, Default::default());
         app.begin_edit(Some("99".into()), false);
         activate_sheet(&mut app, 1);
-        assert_eq!(app.session.active().unwrap().wb.active_sheet, 0, "a value the validation stops must not leave its sheet");
+        assert_eq!(app.session.active().unwrap().wb.active_sheet(), 0, "a value the validation stops must not leave its sheet");
         assert!(app.editor.is_some(), "the edit stays open to be corrected");
         app.editor.as_mut().unwrap().text = "7".into();
         activate_sheet(&mut app, 1);
-        assert_eq!(app.session.active().unwrap().wb.active_sheet, 1, "the corrected value commits and the sheet changes");
+        assert_eq!(app.session.active().unwrap().wb.active_sheet(), 1, "the corrected value commits and the sheet changes");
         let a1 = gridcraft_engine::core::CellRef::parse("A1").unwrap();
         assert!(app.session.active().unwrap().wb.sheet(0).unwrap().cell(a1).is_some(), "the value lands on the first sheet");
     }
diff --git a/crates/ui-egui/src/text_box.rs b/crates/ui-egui/src/text_box.rs
index a0b30c025..229f4ea5f 100644
--- a/crates/ui-egui/src/text_box.rs
+++ b/crates/ui-egui/src/text_box.rs
@@ -44,7 +44,7 @@ impl SheetApp {
             id,
             text: shape.text.clone(),
             uid: d.uid,
-            sheet: d.wb.active_sheet,
+            sheet: d.wb.active_sheet(),
             original: shape.text.clone(),
             request_focus: true,
             rect: None,
diff --git a/crates/ui-egui/src/window_ui.rs b/crates/ui-egui/src/window_ui.rs
index 96aa83c79..bc6f31a3d 100644
--- a/crates/ui-egui/src/window_ui.rs
+++ b/crates/ui-egui/src/window_ui.rs
@@ -126,6 +126,19 @@ impl SheetApp {
         self.follow_active_window();
     }
 
+    /// Puts back a dialog that was taken out of window `home`'s fields while it ran. A command
+    /// run from the dialog may have switched windows meanwhile; the dialog stays in the window it
+    /// was opened in (dropped if that window closed).
+    pub(crate) fn return_dialog(&mut self, home: Option<u64>, d: dialogs::Dialog) {
+        if home == self.ui_window {
+            self.dialog = Some(d);
+        } else if let Some(w) = home.and_then(|h| self.parked.get_mut(&h))
+            && w.dialog.is_none()
+        {
+            w.dialog = Some(d);
+        }
+    }
+
     /// Whether a window other than the current one has a cell or text-box draft open.
     pub fn parked_window_with_draft(&self) -> Option<u64> {
         self.parked.iter().filter(|(_, w)| w.editor.is_some() || w.text_box_editor.is_some()).map(|(id, _)| *id).min()
diff --git a/crates/ui-egui/tests/commit_after_pointing.rs b/crates/ui-egui/tests/commit_after_pointing.rs
index 89e1ccd29..3b29eb7a6 100644
--- a/crates/ui-egui/tests/commit_after_pointing.rs
+++ b/crates/ui-egui/tests/commit_after_pointing.rs
@@ -34,7 +34,7 @@ fn commit_after_pointing_on_another_sheet_writes_to_the_origin_sheet() {
     assert!(h.state_mut().commit_edit(0, 0, false, false));
     let at = CellRef::parse("F8").unwrap();
     let wb = &h.state().session.active().unwrap().wb;
-    assert_eq!(wb.active_sheet, 0, "the origin sheet is shown again");
+    assert_eq!(wb.active_sheet(), 0, "the origin sheet is shown again");
     assert!(wb.sheet(0).unwrap().cell(at).is_some_and(|c| c.formula.is_some()), "formula written on the origin sheet");
     assert!(wb.sheet(1).unwrap().cell(at).is_none(), "the pointed-at sheet is untouched");
 }
@@ -44,7 +44,7 @@ fn ctrl_enter_after_pointing_on_another_sheet_fills_the_origin_selection() {
     let mut h = pointing_on_second_sheet("B2:C3");
     assert!(h.state_mut().commit_edit(0, 0, false, true));
     let wb = &h.state().session.active().unwrap().wb;
-    assert_eq!(wb.active_sheet, 0, "the origin sheet is shown again");
+    assert_eq!(wb.active_sheet(), 0, "the origin sheet is shown again");
     for a1 in ["B2", "C2", "B3", "C3"] {
         let at = CellRef::parse(a1).unwrap();
         assert!(wb.sheet(0).unwrap().cell(at).is_some_and(|c| c.formula.is_some()), "{a1} filled on the origin sheet");
diff --git a/crates/ui-egui/tests/doc_windows.rs b/crates/ui-egui/tests/doc_windows.rs
index b6d518ce2..46427f3bf 100644
--- a/crates/ui-egui/tests/doc_windows.rs
+++ b/crates/ui-egui/tests/doc_windows.rs
@@ -307,3 +307,116 @@ fn feedback_from_opening_a_workbook_shows_in_its_new_window() {
     desk.app.enter_window(book1);
     assert!(desk.app.notice.is_none() && desk.app.message.is_none(), "Book1's window shows neither");
 }
+
+/// Book1 with two sheets, saved, shown in two windows: window 1 on Sheet1 at B2, window 2 on
+/// Sheet2 at D4. Returns the window ids.
+fn two_windows_on_one_workbook(desk: &mut Desk) -> (u64, u64) {
+    desk.app.run("home.insertSheet", json!({})).unwrap();
+    let path = std::env::temp_dir().join(format!("gridcraft-two-windows-{}-{:?}.xlsx", std::process::id(), std::thread::current().id()));
+    desk.app.run("file.save", json!({"path": path})).unwrap();
+    let _ = std::fs::remove_file(&path);
+    desk.app.run("sheet.activate", json!({"sheet": 0})).unwrap();
+    desk.app.run("selection.set", json!({"range": "B2"})).unwrap();
+    desk.frames(2);
+    let w1 = desk.app.session.active_window().unwrap();
+    desk.app.run("view.newWindow", json!({})).unwrap();
+    desk.frames(3);
+    let w2 = desk.app.session.active_window().unwrap();
+    desk.app.run("sheet.activate", json!({"sheet": 1})).unwrap();
+    desk.app.run("selection.set", json!({"range": "D4"})).unwrap();
+    desk.frames(3);
+    (w1, w2)
+}
+
+#[test]
+fn two_windows_on_one_workbook_show_their_own_sheet_and_each_others_edits() {
+    let mut desk = Desk::new(true);
+    let (w1, w2) = two_windows_on_one_workbook(&mut desk);
+    assert_eq!(desk.windows.shown_windows(), [w1, w2], "New Window opens a native window");
+    assert_ne!(desk.viewport(w1), desk.viewport(w2));
+    let titles: Vec<String> = [w1, w2].iter().map(|w| desk.app.session.window_title(*w).unwrap()).collect();
+    assert!(titles[0].ends_with(".xlsx:1") && titles[1].ends_with(".xlsx:2"), "{titles:?}");
+
+    // Drawing both windows every frame swaps their views without copying the workbook.
+    let wb = desk.app.session.doc().unwrap().wb.clone();
+    desk.frames(3);
+    assert!(std::sync::Arc::ptr_eq(&wb, &desk.app.session.doc().unwrap().wb), "a window swap copied the workbook");
+    assert!(!desk.app.session.doc().unwrap().is_dirty());
+    for (w, sheet, cell) in [(w1, 0, "B2"), (w2, 1, "D4")] {
+        desk.app.enter_window(w);
+        let d = desk.app.session.doc().unwrap();
+        assert_eq!((d.wb.active_sheet(), d.selection.active), (sheet, CellRef::parse(cell).unwrap()), "window {w}'s sheet and selection");
+        assert!(desk.app.grid.rect.is_some(), "window {w} drew its grid");
+    }
+
+    // Window 1 refers to Sheet2!D4; window 2 types there; window 1 shows it on the next frame.
+    desk.app.enter_window(w1);
+    desk.app.run("cell.set", json!({"cell": "B2", "input": "=Sheet2!D4*2"})).unwrap();
+    desk.frames(1);
+    desk.app.enter_window(w2);
+    desk.app.run("cell.set", json!({"input": "21"})).unwrap();
+    desk.frames(1);
+    desk.app.enter_window(w1);
+    let d = desk.app.session.doc().unwrap();
+    assert_eq!(d.wb.active_sheet(), 0);
+    assert_eq!(d.wb.active().unwrap().value(CellRef::parse("B2").unwrap()), Value::Number(42.0));
+}
+
+#[test]
+fn a_dialog_stays_with_its_window_across_a_switch() {
+    let mut desk = Desk::new(true);
+    let (w1, w2) = two_windows_on_one_workbook(&mut desk);
+    desk.app.enter_window(w1);
+    desk.app.open_dialog("zoom", json!({}));
+    desk.frames(2);
+    assert_eq!(desk.app.dialog.as_ref().map(|d| d.name()), Some("zoom"));
+
+    // From the menu bar.
+    desk.app.run("view.switchWindows", json!({"window": w2})).unwrap();
+    desk.frames(3);
+    assert_eq!(desk.app.session.active_window(), Some(w2));
+    assert!(desk.app.dialog.is_none(), "window 2 shows no dialog");
+
+    // The user clicks into window 1, then back into window 2.
+    for (w, other) in [(w1, w2), (w2, w1)] {
+        let (v, o) = (desk.viewport(w), desk.viewport(other));
+        INFOS.with(|i| {
+            let mut i = i.borrow_mut();
+            i.entry(v).or_default().focused = Some(true);
+            i.entry(o).or_default().focused = Some(false);
+        });
+        desk.frames(2);
+        assert_eq!(desk.app.session.active_window(), Some(w));
+        let expected = if w == w1 { Some("zoom") } else { None };
+        assert_eq!(desk.app.dialog.as_ref().map(|d| d.name()), expected, "window {w}'s dialog");
+    }
+
+    // A script switching windows while the dialog is open.
+    desk.frame_with(|app, ctx| {
+        let _ = gridcraft_ui_egui::control::handle(app, ctx, "engine.execute", &json!({"command": "window.activate", "params": {"window": w1}}));
+    });
+    desk.frames(2);
+    assert_eq!(desk.app.dialog.as_ref().map(|d| d.name()), Some("zoom"));
+    desk.app.enter_window(w2);
+    assert!(desk.app.dialog.is_none());
+}
+
+#[test]
+fn arrange_all_lays_out_the_native_windows_active_first() {
+    let mut desk = Desk::new(true);
+    let (w1, w2) = two_windows_on_one_workbook(&mut desk);
+    INFOS.with(|i| i.borrow_mut().entry(ViewportId::ROOT).or_default().monitor_size = Some(egui::vec2(1000.0, 800.0)));
+    desk.app.run("view.arrangeAll", json!({"arrange": "vertical"})).unwrap();
+    let sent = desk.frames(1);
+    let at = |x: f32| ViewportCommand::OuterPosition(egui::pos2(x, 0.0));
+    assert!(sent_to(&sent, desk.viewport(w2), &at(0.0)), "the active window goes left: {sent:?}");
+    assert!(sent_to(&sent, desk.viewport(w1), &at(500.0)));
+    assert!(sent_to(&sent, desk.viewport(w1), &ViewportCommand::InnerSize(egui::vec2(500.0, 800.0))));
+
+    // Without parameters, as a script calls it: tiled.
+    let r = desk.app.run("view.arrangeAll", json!({})).unwrap();
+    assert_eq!(r["arrange"], "tiled");
+    let tiled = gridcraft_ui_egui::doc_windows::arrange_rects("tiled", 3, craft_window::Rect::new(0.0, 0.0, 1000.0, 800.0));
+    let r = |x, y, w, h| craft_window::Rect::new(x, y, w, h);
+    assert_eq!(tiled, [r(0.0, 0.0, 500.0, 400.0), r(500.0, 0.0, 500.0, 400.0), r(0.0, 400.0, 1000.0, 400.0)]);
+}
diff --git a/crates/ui-egui/tests/popup_dismissal.rs b/crates/ui-egui/tests/popup_dismissal.rs
index 24d9fafbc..8ea1ec9b1 100644
--- a/crates/ui-egui/tests/popup_dismissal.rs
+++ b/crates/ui-egui/tests/popup_dismissal.rs
@@ -106,7 +106,7 @@ fn filter_closes_when_clicking_another_table_or_sheet() {
         click(&mut h, outside, PointerButton::Primary);
         assert!(!is_open(&h, Menu::Filter), "filter stayed open after switching table/sheet");
         if sheet {
-            assert_eq!(h.state().session.active().unwrap().wb.active_sheet, 1);
+            assert_eq!(h.state().session.active().unwrap().wb.active_sheet(), 1);
         } else {
             assert_eq!(h.state().session.active().unwrap().selection.active.a1(), "H2");
         }
diff --git a/crates/ui-egui/tests/sheet_navigator.rs b/crates/ui-egui/tests/sheet_navigator.rs
index a16e306ed..d8ee2eae1 100644
--- a/crates/ui-egui/tests/sheet_navigator.rs
+++ b/crates/ui-egui/tests/sheet_navigator.rs
@@ -32,7 +32,7 @@ fn harness() -> egui_kittest::Harness<'static, SheetApp> {
 #[test]
 fn typing_a_name_and_enter_activates_that_sheet() {
     let mut h = harness();
-    assert_eq!(h.state().session.active().unwrap().wb.active_sheet, 0);
+    assert_eq!(h.state().session.active().unwrap().wb.active_sheet(), 0);
     h.get_by_label("All sheets").click();
     h.run_steps(4);
     h.input_mut().events.push(Event::Text("summ".into()));
@@ -40,5 +40,5 @@ fn typing_a_name_and_enter_activates_that_sheet() {
     h.input_mut().events.push(Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
     h.input_mut().events.push(Event::Key { key: Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });
     h.run_steps(4);
-    assert_eq!(h.state().session.active().unwrap().wb.active_sheet, 3, "Enter on the filtered row must activate Summary");
+    assert_eq!(h.state().session.active().unwrap().wb.active_sheet(), 3, "Enter on the filtered row must activate Summary");
 }
diff --git a/crates/ui-egui/tests/sheet_tabs.rs b/crates/ui-egui/tests/sheet_tabs.rs
index c3e5d13fb..8b419ecc7 100644
--- a/crates/ui-egui/tests/sheet_tabs.rs
+++ b/crates/ui-egui/tests/sheet_tabs.rs
@@ -80,7 +80,7 @@ fn navigation_arrows_reveal_the_selected_tab() {
     for _ in 0..29 {
         click(&mut h, next);
     }
-    assert_eq!(h.state().session.doc().unwrap().wb.active_sheet, 29);
+    assert_eq!(h.state().session.doc().unwrap().wb.active_sheet(), 29);
     assert_visible(&h, "Tab29");
 }
 
@@ -141,7 +141,7 @@ fn hidden_sheets_long_names_and_window_resize_keep_active_tab_visible() {
     h.set_size(vec2(1000.0, 120.0));
     h.run_steps(20);
     assert_visible(&h, name);
-    assert_eq!(h.state().session.doc().unwrap().wb.active_sheet, 29);
+    assert_eq!(h.state().session.doc().unwrap().wb.active_sheet(), 29);
 }
 
 #[test]
@@ -185,7 +185,7 @@ fn right_clicking_a_tab_activates_its_sheet_so_the_menu_acts_on_it() {
     h.step();
     h.input_mut().events.push(Event::PointerButton { pos: at, button: PointerButton::Secondary, pressed: false, modifiers: Modifiers::NONE });
     h.run_steps(20);
-    assert_eq!(h.state().session.doc().unwrap().wb.active_sheet, 3, "right-clicking Tab03 should activate it");
+    assert_eq!(h.state().session.doc().unwrap().wb.active_sheet(), 3, "right-clicking Tab03 should activate it");
     // The menu now offers Unprotect for the protected sheet that was clicked, not Protect for the one that was active.
     let texts: Vec<String> = h
         .output()
diff --git a/crates/ui-egui/tests/trace_navigation.rs b/crates/ui-egui/tests/trace_navigation.rs
index 11f79fcff..8a74ec87e 100644
--- a/crates/ui-egui/tests/trace_navigation.rs
+++ b/crates/ui-egui/tests/trace_navigation.rs
@@ -107,11 +107,11 @@ fn cross_sheet_precedents_jump_to_the_other_sheet() {
     s.execute("cell.set", json!({"cell": "A1", "input": "=Src!B2*2"})).unwrap();
     // Back on the first sheet, Ctrl+[ from A1 jumps to Src!B2.
     let d = s.active().unwrap();
-    let first = d.wb.active_sheet;
+    let first = d.wb.active_sheet();
     s.execute("selection.set", json!({"range": "A1"})).unwrap();
     let mut h = harness(s);
     key(&mut h, Key::OpenBracket, Modifiers::CTRL);
     let d = h.state().session.active().unwrap();
-    assert_ne!(d.wb.active_sheet, first, "selection jumped to the precedent's sheet");
+    assert_ne!(d.wb.active_sheet(), first, "selection jumped to the precedent's sheet");
     assert_eq!(d.selection.active, CellRef { row: 1, col: 1 }, "B2 on the Src sheet");
 }
diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs
index 774567bf8..9381e010e 100644
--- a/crates/xlsx/src/read.rs
+++ b/crates/xlsx/src/read.rs
@@ -297,7 +297,7 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
         cx.warn("the workbook has no worksheets; added an empty sheet");
         wb.sheets.push(Arc::new(Sheet::new("Sheet1")));
     }
-    wb.active_sheet = file_to_model.get(active_tab).copied().flatten().unwrap_or(0);
+    wb.set_active_sheet(file_to_model.get(active_tab).copied().flatten().unwrap_or(0));
 
     // Defined names. Chartex parts refer to their data through hidden `_xlchart.*` names.
     let mut chart_names: Vec<(String, String)> = vec![];
diff --git a/crates/xlsx/src/write.rs b/crates/xlsx/src/write.rs
index cf208d6cd..d26dddea4 100644
--- a/crates/xlsx/src/write.rs
+++ b/crates/xlsx/src/write.rs
@@ -244,8 +244,8 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
 
     // Which sheet is active (must be visible), and at least one visible sheet.
     let any_visible = wb.sheets.iter().any(|s| s.visibility == Visibility::Visible);
-    let active = if wb.sheets.get(wb.active_sheet).is_some_and(|s| s.visibility == Visibility::Visible) {
-        wb.active_sheet
+    let active = if wb.sheets.get(wb.active_sheet()).is_some_and(|s| s.visibility == Visibility::Visible) {
+        wb.active_sheet()
     } else {
         wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0)
     };
diff --git a/crates/xlsx/src/xls/mod.rs b/crates/xlsx/src/xls/mod.rs
index ceaf3e26d..d46b058cb 100644
--- a/crates/xlsx/src/xls/mod.rs
+++ b/crates/xlsx/src/xls/mod.rs
@@ -198,7 +198,7 @@ pub(crate) fn read_xls_with(bytes: &[u8], mut budget: Budget) -> Result<(Workboo
     }
     wb.calc.precision_as_displayed = g.precision_as_displayed;
     defined_names(&g, &model_index, &mut wb, &mut report);
-    wb.active_sheet = wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0);
+    wb.set_active_sheet(wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0));
     // The overview comes first.
     report.warnings.insert(
         0,
diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs
index 3c8454749..39d9fd9f6 100644
--- a/crates/xlsx/src/xlsb.rs
+++ b/crates/xlsx/src/xlsb.rs
@@ -120,7 +120,7 @@ pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
     if wb.sheets.is_empty() {
         return Err(invalid("no supported worksheets"));
     }
-    wb.active_sheet = wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0);
+    wb.set_active_sheet(wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0));
     Ok((wb, report))
 }
 
diff --git a/docs/gaps.md b/docs/gaps.md
index 7e2e40dc0..da4703326 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Gaps
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-20 · **Change:** minor (the Japanese catalog covers the dialogs, messages and menus) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (§20: a native window per workbook window, New Window and Arrange All) · **Target:** Microsoft Excel (Microsoft 365)
 
 Every known shortfall against Excel, one entry each, ranked by user impact (what blocks someone
 using GridCraft for real work first). This is the work list: pick from the top, check the open
@@ -156,7 +156,9 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha-
   **Estimate:** 15–23 h.
 
 ### 20. Multiple windows; pen pressure (H)
-- One window (#162, PR #171); no pressure or tilt in ink. **Estimate:** 10–14 h.
+- Desktop windows done: a native window per workbook window, New Window on the same workbook,
+  Switch Windows, Arrange All. Left: Arrange All across monitors, one window on the web, no
+  pressure or tilt in ink. **Estimate:** 5–8 h.
   [hardware-parity.md](hardware-parity.md)
 
 ### 21. Automation and add-ins (F)
@@ -178,6 +180,7 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha-
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | §20: a native window per workbook window, New Window on the same workbook and Arrange All on the desktop; left: Arrange All across monitors, the web's one window, pen pressure (estimate 10–14 h → 5–8 h) |
 | 2026-10-20 | minor | §11: the Japanese catalog covers the dialogs, messages and menus — 943 keys (~43%), matching the pt-BR coverage; a test keeps the two catalogs in step |
 | 2026-10-17 | minor | §6: the five reports it tracked are closed and their PRs merged (#57, #133, #139, #140, #134; PRs #148, #155, #156, #157); the entry stays open for §15's oracle suite |
 | 2026-10-15 | minor | §13: Solver prepares reports before committing the solution, model and report sheets together; report refusal preserves the workbook and Undo/Redo (#1050) |
diff --git a/docs/hardware-parity.md b/docs/hardware-parity.md
index f19b4a49d..71cf001d5 100644
--- a/docs/hardware-parity.md
+++ b/docs/hardware-parity.md
@@ -1,6 +1,6 @@
 # Hardware parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (a native window per workbook window) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (Arrange All) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 The hardware Excel uses, per platform, against GridCraft. Part of
 [target-app-parity.md](target-app-parity.md). **Hardware: ~40% ready, 25–40 h** (estimated).
@@ -11,7 +11,7 @@ The hardware Excel uses, per platform, against GridCraft. Part of
 | GPU rendering of the grid and charts | DirectX / Metal accelerated drawing | wgpu: Metal · DirectX 12 (default since 10-08; OpenGL when DirectX 12 has no GPU driver or fails to start; Vulkan only on request, so the Intel UHD `igvk64.dll` crash (#120) can't happen; shaders compiled with FXC, so no DXC runtime is needed, #339) · Vulkan/GL · Vulkan/GL · WebGPU or WebGL2 | At parity in kind. Driver problems: screen flashing on Windows 11 (#76): 2–4 h |
 | Pen and touch (Draw tab) | Pen pressure and tilt, eraser end, touch mode, Ink to Shape, ink replay | Pen, highlighter, eraser, Ink to Shape with mouse/pen input; **no pressure or tilt**, no touch mode | Pressure-sensitive strokes where winit reports force; touch-friendly ribbon spacing: 4–6 h |
 | Trackpad and mouse | Smooth scrolling, pinch zoom, horizontal scroll, Magic Mouse | Smooth scrolling and zoom via egui | Verify pinch zoom on each platform: 1–2 h |
-| Multiple windows and monitors | One window per workbook, New Window for the same workbook, per-monitor DPI | A native window per workbook window on the desktop, New Window for the same workbook; new windows cascade from the last one on its monitor (web: one window) | Arrange All across monitors; verify per-monitor DPI with windows on two monitors: 2–3 h |
+| Multiple windows and monitors | One window per workbook, New Window for the same workbook, per-monitor DPI | A native window per workbook window on the desktop, New Window for the same workbook; new windows cascade from the last one on its monitor; View › Arrange All tiles, stacks or cascades them over the main window's monitor (web: one window) | Arrange All across monitors; verify per-monitor DPI with windows on two monitors: 2–3 h |
 | High-DPI and display scaling | yes | yes (display scale matched to desktop density; View › Interface size 75–200 % on top, #230) | — |
 | Accessibility hardware (screen readers, braille displays, switch control) | Narrator, JAWS, NVDA, VoiceOver | AccessKit enabled in eframe; grid cells and ribbon not yet exposed as an accessible tree | Counted under UI ([ui-parity.md](ui-parity.md)) |
 | Printers | System print with driver options | Desktop submits through craft-print with printer choice, copies, duplex and grayscale; web browser printing | Counted under print |
@@ -20,6 +20,7 @@ The hardware Excel uses, per platform, against GridCraft. Part of
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | View › Arrange All over the main window's monitor. |
 | 2026-10-22 | minor | Multiple windows: each workbook window is a native window of its own (desktop). |
 | 2026-10-12 | minor | Desktop File > Print now discovers printers and submits PDF jobs through pinned craft-print with printer choice, copies, duplex and grayscale; browser printing and PDF export remain available. Remaining print parity includes page ranges and driver-specific tray/options UI; physical printer fidelity needs hardware validation. |
 | 2026-10-11 | trivial | Windows: DirectX 12 shaders compiled with FXC, no DXC runtime needed (#339, #354) |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 08a9124bd..f15a13f42 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # Target-app parity: GridCraft vs Microsoft Excel
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-21 · **Change:** minor (Page Setup paper sizes match Japanese Excel: B4/B5/B6 are the JIS sizes, with ISO B4/B5/B6 by name and the Japanese postcards, envelopes and A6 added; no score change) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-22 · **Change:** minor (several windows: a native window per workbook window, New Window on the same workbook, Arrange All; no score change) · **Target:** Microsoft Excel (Microsoft 365)
 
 This is the authoritative parity assessment. [`ROADMAP.md`](../ROADMAP.md) summarizes it,
 [`gaps.md`](gaps.md) lists every shortfall, and the area checklists hold the detail:
@@ -102,11 +102,11 @@ performance 8, stability 8, localization 4, hardware 2, platforms 2, ecosystem 2
 |---|---|---|---|---|
 | Features | 45 | ~59% | 300–485 | Table above |
 | File formats | 15 | ~50% | 80–120 | XLSX read/write is broad but unproven on a real corpus and in Excel; XLSB and ODS are values-only import; no XLS, XML Spreadsheet 2003, SYLK, DIF, PRN; VBA dropped; 100 MB XLSX fails (#175). [file-format-parity.md](file-format-parity.md) |
-| UI/UX fidelity | 12 | ~55% | 50–80 | Excel-style ribbon, galleries, dialogs, formula bar, status bar; 59 commands with shortcuts vs Excel's 200+; key tips on part of the Home tab only; short context menu; single window. [ui-parity.md](ui-parity.md) |
+| UI/UX fidelity | 12 | ~55% | 50–80 | Excel-style ribbon, galleries, dialogs, formula bar, status bar; 59 commands with shortcuts vs Excel's 200+; key tips on part of the Home tab only; short context menu; a native window per workbook window on the desktop (one on the web). [ui-parity.md](ui-parity.md) |
 | Performance | 8 | ~35% | 35–55 | [Performance](#performance) |
 | Stability | 8 | ~60% | 15–25 | Never-crash rules enforced by lint, every command fuzzed with hostile params, random command sequences fuzzed against undo/redo, XLSX round-trip and full-recalc invariants, last-resort guard in `Session::execute`. Field reports: Windows Intel GPU crash (#120), error on close (#117), freeze opening from Finder (#166), screen flashing (#76) |
 | Localization | 4 | ~10% | 100–165 | Ribbon-only catalog in five languages (ja, zh, ko, pt-BR, ru; ~12% of strings each), CJK/Thai/Hebrew font fallback, no shaping or RTL. [localization-parity.md](localization-parity.md) |
-| Hardware | 2 | ~40% | 25–40 | GPU UI via wgpu; single-threaded calc; no pen pressure; one window. [hardware-parity.md](hardware-parity.md) |
+| Hardware | 2 | ~40% | 25–40 | GPU UI via wgpu; single-threaded calc; no pen pressure; a native window per workbook window, Arrange All on one monitor. [hardware-parity.md](hardware-parity.md) |
 | Platforms | 2 | ~80% | 30–60 | [Platforms](#platforms) |
 | Ecosystem / add-ins | 2 | ~10% | 25–40 | [Ecosystem and AI](#ecosystem-and-ai) |
 | AI features | 2 | ~15% | 30–50 | [Ecosystem and AI](#ecosystem-and-ai) |
@@ -144,7 +144,7 @@ Discounts for what still stops real work:
 
 | Discount | Factor | Evidence |
 |---|---|---|
-| Interaction fidelity | × 0.90 | 59 command shortcuts vs Excel's 200+; key tips only on part of the Home tab (#43); rectangular selection bug (#28); charts can't be resized (#190); one window (#162); missing horizontal scrollbar report (#176) |
+| Interaction fidelity | × 0.90 | 59 command shortcuts vs Excel's 200+; key tips only on part of the Home tab (#43); rectangular selection bug (#28); charts can't be resized (#190); missing horizontal scrollbar report (#176) |
 | Stability on real machines | × 0.92 | Never-crash lints, fuzzed commands and the `Session::execute` guard; but field reports of a startup crash on Intel UHD (#120), an error on close (#117), a freeze opening from Finder (#166) and screen flashing (#76) |
 | File exchange with Excel users | × 0.88 | Excel opening our output is unverified across features; unmodelled parts dropped on save; advanced chart kinds lose their type; 100 MB files fail (#175); `.xls` and encrypted files are refused with a clear message (#17) rather than opened. Harsher than a drawing app's discount because spreadsheets are exchanged constantly |
 
@@ -334,6 +334,7 @@ The inventory carried over from the 2026-10-07 ROADMAP.md, updated for what land
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | Several windows on the desktop: a native window per workbook window, New Window on the same workbook, Switch Windows and Arrange All; "one window" removed from UI/UX fidelity, Hardware and the interaction-fidelity discount; no score change |
 | 2026-10-21 | minor | Page Setup paper sizes: `B4`/`B5`/`B6` are the JIS sizes Japanese Excel uses (ISO B4/B5/B6 by name), and Japanese Postcard, Japanese Double Postcard, the chou/kaku envelopes and A6 are added; PDF MediaBox and `file.print` follow, and the Size menu lists them |
 | 2026-10-18 | trivial | Stale chart notes: all chart kinds survive XLSX round-trip (PRs #158, #161) and trendlines landed |
 | 2026-10-16 | minor | Advanced Filter copy-to clears only its actual output and rejects overflow without changing cells (#1031) |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 817b5b915..d34b8c464 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (every workbook window is a native window of its own on the desktop, with its own draft, dialog and ribbon; closing one of several windows on a workbook doesn't ask; Quit asks about each unsaved workbook in its window; the last window closed quits on Windows and Linux, macOS keeps running) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (View › Arrange All lays out the native windows; two windows on one workbook show different sheets without copying it; a dialog stays in its window) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md).
 **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured
@@ -33,8 +33,8 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes
 | Backstage (File) view: Info, New with templates, Open recent, Export, Options | yes | yes (#174, 10-11): the File tab opens a full-window view (Esc or the back arrow return) with Home, New (blank + the three samples), Open (recent + Browse; the recent list tells when each workbook was last changed, 10-12), Info (location, properties, Protect Workbook), Save, Save As, Print (page preview, active sheet or workbook, fit to page, Page Setup), Export (PDF, CSV, web page), Close and Options (`file.options`: theme, language, formula bar, AutoSave, calculation) | no Account, Share or template gallery beyond the samples; Options applies at once (no OK/Cancel dialog) and holds only the settings GridCraft has |
 | Dark mode, system appearance | yes | yes | done (10-09) |
 | Page Layout view (paper view with rulers and header editing) | yes | yes (#329, 10-11): per-sheet view saved in XLSX, pages with margins and gaps on the print pagination, "Click to add data" pages, rulers (inches or centimetres), headers and footers drawn and edited in place with a Header & Footer tab | margins drag on the rulers (#792, with header and footer margins); header/footer pictures, Different First Page / Odd & Even missing (1–3 h) |
-| Multiple windows per workbook | yes | yes (10-22, desktop): each workbook window is a native window of its own (New, Open and New Window open one; titles "Book1", or "Book1:1" / "Book1:2" for a workbook's second window, with " — Edited" while unsaved). Each window keeps its own cell draft, dialog, Backstage view, message and grid state, and its ribbon acts on it; on macOS the menu bar acts on the window focused last. Leaving a window enters its draft as Enter would. A window's close button closes that window: one of several on a workbook closes without asking, a workbook's last asks Save / Don't Save / Cancel when unsaved. Quit asks about each unsaved workbook in its window, and Cancel stops it. The last window closed quits on Windows and Linux; macOS keeps running with the menu bar until New or Open. Web: one window | no Arrange All; a hidden window (View › Hide) has no native window; every window repaints when one does; see [hardware-parity.md](hardware-parity.md) |
-| Switch Windows, New Window, unsaved workbooks on quit | yes | yes (10-22): View › New Window opens another window on the same workbook (no copy: saving from either saves it), each with its own selection, active sheet and scroll; a workbook with several windows titles them "Book1:1", "Book1:2"; File › Close closes one of them without asking and asks only for the last; View › Switch Windows and the macOS Window menu list the open windows (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {window}`, or `{doc}` for a workbook's most recent window); a cell being typed is entered into its own window and workbook before New, Open, Close, Save, Print and window switches (also between two windows on one workbook), and a refused entry stays open and stops the command; quitting (Cmd+Q, the macOS Quit item, the Dock) asks Save / Don't Save / Cancel for each unsaved workbook | |
+| Multiple windows per workbook | yes | yes (10-22, desktop): each workbook window is a native window of its own (New, Open and New Window open one; titles "Book1", or "Book1:1" / "Book1:2" for a workbook's second window, with " — Edited" while unsaved). Each window keeps its own cell draft, dialog, Backstage view, message and grid state, and its ribbon acts on it; on macOS the menu bar acts on the window focused last. Leaving a window enters its draft as Enter would. A window's close button closes that window: one of several on a workbook closes without asking, a workbook's last asks Save / Don't Save / Cancel when unsaved. Quit asks about each unsaved workbook in its window, and Cancel stops it. The last window closed quits on Windows and Linux; macOS keeps running with the menu bar until New or Open. View › Arrange All (dialog: Tiled, Horizontal, Vertical, Cascade, Windows of active workbook; `view.arrangeAll` tiles by default) lays the visible windows out over the main window's monitor, the active one first. Web: one window | Arrange All uses one monitor; a hidden window (View › Hide) has no native window; every window repaints when one does; see [hardware-parity.md](hardware-parity.md) |
+| Switch Windows, New Window, unsaved workbooks on quit | yes | yes (10-22): View › New Window opens another window on the same workbook (no copy: saving from either saves it), each with its own selection, active sheet and scroll (showing different sheets copies nothing and leaves the workbook unchanged; Save records the sheet of the window used last); a workbook with several windows titles them "Book1:1", "Book1:2"; File › Close closes one of them without asking and asks only for the last; View › Switch Windows and the macOS Window menu list the open windows (active one checked, unsaved ones marked •) and bring the chosen one forward (`view.switchWindows {window}`, or `{doc}` for a workbook's most recent window); a cell being typed is entered into its own window and workbook before New, Open, Close, Save, Print and window switches (also between two windows on one workbook), and a refused entry stays open and stops the command; quitting (Cmd+Q, the macOS Quit item, the Dock) asks Save / Don't Save / Cancel for each unsaved workbook | |
 
 ## Grid interaction
 
@@ -177,6 +177,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | minor | View › New Window and Arrange All on the View ribbon; Arrange All tiles, stacks or cascades the native windows; two windows on one workbook keep their own sheet without copying the workbook; a dialog opened in one window stays there when a command run from it switches windows |
 | 2026-10-22 | minor | One native window per workbook window on the desktop: per-window drafts, dialogs and ribbons; menu bar commands go to the focused window; closing one of several windows on a workbook doesn't ask; Quit asks in each unsaved workbook's window; the last window closed quits (Windows, Linux) or leaves macOS running |
 | 2026-10-22 | minor | New Window opens a second window on the same workbook instead of a copy that saved over the original; windows keep their own selection, sheet and scroll; titles Name:1 / Name:2; Switch Windows, Hide and Unhide work by window; File › Close closes one window of several without asking |
 | 2026-10-22 | minor | New workbook no longer loses the first one: the cell being typed is entered into its own workbook before any File or window command (an entry the workbook refuses stays open and the command doesn't run; an untouched F2 draft changes nothing), the editor is tied to its workbook, View › Switch Windows and the macOS Window menu list the open workbooks, and the macOS Quit item asks about unsaved workbooks like the close button |

From 14dd23db6ceff8cb3a51508c00edffb8adaac905 Mon Sep 17 00:00:00 2001
From: skylar <hi@skylar.cc>
Date: Sun, 25 Oct 2026 16:36:12 -0600
Subject: [PATCH 08/76] chore(deps): refresh serde_json, arboard, muda,
 winresource, sha2

---
 Cargo.lock | 136 ++++++++++++-----------------------------------------
 1 file changed, 31 insertions(+), 105 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 63d2260e7..1edb8da90 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -206,9 +206,9 @@ dependencies = [
 
 [[package]]
 name = "arboard"
-version = "3.6.1"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+checksum = "aeb9553e62312c8756a5979254fc6d7da8bbeb5986a1e17037fab932f7037917"
 dependencies = [
  "clipboard-win",
  "image",
@@ -220,7 +220,7 @@ dependencies = [
  "objc2-foundation 0.3.2",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
  "wl-clipboard-rs",
  "x11rb",
 ]
@@ -1395,7 +1395,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1989,7 +1989,7 @@ dependencies = [
  "gridcraft-formula",
  "serde",
  "serde_json",
- "sha2 0.11.0",
+ "sha2 0.11.1",
  "thiserror 2.0.21",
 ]
 
@@ -2054,7 +2054,7 @@ dependencies = [
  "gridcraft-model",
  "quick-xml 0.41.0",
  "sha1 0.11.0",
- "sha2 0.11.0",
+ "sha2 0.11.1",
  "thiserror 2.0.21",
  "zip 3.0.0",
 ]
@@ -2763,9 +2763,9 @@ dependencies = [
 
 [[package]]
 name = "muda"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a7b000cca0783af26837fe2ebd9ddf1c42279463c085b97622ee1d2f444b89e"
+checksum = "4340e89c178916e62879c5c36b7f699019369be413e496178a6983ce91b8bc03"
 dependencies = [
  "crossbeam-channel",
  "dpi",
@@ -3287,7 +3287,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3689,7 +3689,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3996,7 +3996,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4055,7 +4055,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4201,9 +4201,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.151"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
 dependencies = [
  "itoa",
  "memchr",
@@ -4290,9 +4290,9 @@ dependencies = [
 
 [[package]]
 name = "sha2"
-version = "0.11.0"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19"
 dependencies = [
  "cfg-if",
  "cpufeatures 0.3.1",
@@ -4783,10 +4783,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.4.3",
+ "getrandom 0.3.4",
  "once_cell",
  "rustix 1.1.5",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -5738,7 +5738,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -5859,7 +5859,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets",
 ]
 
 [[package]]
@@ -5868,16 +5868,7 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.5",
+ "windows-targets",
 ]
 
 [[package]]
@@ -5895,31 +5886,14 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm 0.53.1",
- "windows_aarch64_msvc 0.53.1",
- "windows_i686_gnu 0.53.1",
- "windows_i686_gnullvm 0.53.1",
- "windows_i686_msvc 0.53.1",
- "windows_x86_64_gnu 0.53.1",
- "windows_x86_64_gnullvm 0.53.1",
- "windows_x86_64_msvc 0.53.1",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
@@ -5937,96 +5911,48 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "winit"
 version = "0.30.13"
@@ -6119,9 +6045,9 @@ dependencies = [
 
 [[package]]
 name = "winresource"
-version = "0.1.31"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087"
+checksum = "a2bc6d36480b829272a5bdabf08e6dca8004761c1da7e35efef800540c66221b"
 dependencies = [
  "toml",
  "version_check",

From 6f0e43c21c5fd71b8ac6c30ac86d447f7671240f Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Sun, 25 Oct 2026 19:37:08 -0400
Subject: [PATCH 09/76] Linux: default to XWayland for file drag-and-drop on
 Wayland desktops (#165)

* Linux: default to XWayland for file drag-and-drop on Wayland desktops

* Ignore an empty DISPLAY before forcing X11
---
 Cargo.lock                 |  1 +
 apps/gridcraft/Cargo.toml  |  3 +++
 apps/gridcraft/src/main.rs | 12 ++++++++++++
 3 files changed, 16 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 1edb8da90..4e7cf4a26 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1885,6 +1885,7 @@ dependencies = [
  "pollster 1.0.1",
  "rfd",
  "serde_json",
+ "winit",
  "winresource",
 ]
 
diff --git a/apps/gridcraft/Cargo.toml b/apps/gridcraft/Cargo.toml
index d7be2fb15..52b577cc5 100644
--- a/apps/gridcraft/Cargo.toml
+++ b/apps/gridcraft/Cargo.toml
@@ -24,6 +24,9 @@ chrono = { workspace = true }
 # Icon + VERSIONINFO for gridcraft.exe; build.rs only uses it when the target is Windows.
 winresource = "0.1"
 
+[target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
+winit = { version = "0.30", default-features = false, features = ["x11"] }
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 craft-print = { git = "https://github.com/storytold/craft-libs", rev = "25da1314d443171b4adeaad2cd9454b273f35c6f" }
 craft-update = { workspace = true }
diff --git a/apps/gridcraft/src/main.rs b/apps/gridcraft/src/main.rs
index 2b0c9113b..14375944c 100644
--- a/apps/gridcraft/src/main.rs
+++ b/apps/gridcraft/src/main.rs
@@ -336,6 +336,18 @@ fn main() -> eframe::Result<()> {
         viewport = viewport.with_icon(i);
     }
     let options = eframe::NativeOptions { viewport, ..Default::default() };
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let mut options = options;
+    // winit has no file drag-and-drop on Wayland (only on X11), so dropping files from the file
+    // manager showed a "no" cursor. Run through XWayland when it's there; GRIDCRAFT_WAYLAND=1
+    // keeps the native Wayland backend.
+    #[cfg(all(unix, not(target_os = "macos")))]
+    if std::env::var_os("DISPLAY").is_some_and(|d| !d.is_empty()) && std::env::var_os("GRIDCRAFT_WAYLAND").is_none() {
+        options.event_loop_builder = Some(Box::new(|b| {
+            use winit::platform::x11::EventLoopBuilderExtX11;
+            b.with_x11();
+        }));
+    }
     // Before eframe creates the wgpu instance: Windows starts on DirectX 12, or OpenGL when
     // DirectX 12 has no GPU driver, and never touches Vulkan unless asked (see graphics.rs).
     #[cfg(target_os = "windows")]

From 0b6d243946db1352a1be7de9570b8e2d47c0ee01 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sun, 25 Oct 2026 16:47:19 -0700
Subject: [PATCH 10/76] Format Chart Area: Chart Type offers the stacked and
 100% stacked types and marks the current one

The Chart Type section of the Format Chart Area pane listed nine types,
with stacked column as the only stacked one, so a chart could not be
switched there to stacked bar, 100% stacked column or bar, stacked
line, or stacked or 100% stacked area. It now lists them after their
family's entries, and "Stacked" is renamed "Stacked Column".

Each entry is drawn selected when it is the chart's current type, as
the Legend entries are, using the same type and subtype mapping that
chart.set applies.
---
 crates/ui-egui/src/panes.rs                  | 11 ++-
 crates/ui-egui/tests/it/format_chart_type.rs | 91 ++++++++++++++++++++
 crates/ui-egui/tests/it/main.rs              |  1 +
 3 files changed, 101 insertions(+), 2 deletions(-)
 create mode 100644 crates/ui-egui/tests/it/format_chart_type.rs

diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs
index 65d169c87..4cf5bbbc1 100644
--- a/crates/ui-egui/src/panes.rs
+++ b/crates/ui-egui/src/panes.rs
@@ -185,16 +185,23 @@ fn format_chart(app: &mut SheetApp, ui: &mut Ui) {
         ui.horizontal_wrapped(|ui| {
             for (l, k, s) in [
                 ("Column", "column", ""),
-                ("Stacked", "column", "stacked"),
+                ("Stacked Column", "column", "stacked"),
+                ("100% Stacked Column", "column", "stacked100"),
                 ("Bar", "bar", ""),
+                ("Stacked Bar", "bar", "stacked"),
+                ("100% Stacked Bar", "bar", "stacked100"),
                 ("Line", "line", "markers"),
+                ("Stacked Line", "line", "stacked"),
                 ("Area", "area", ""),
+                ("Stacked Area", "area", "stacked"),
+                ("100% Stacked Area", "area", "stacked100"),
                 ("Pie", "pie", ""),
                 ("Doughnut", "doughnut", ""),
                 ("Scatter", "scatter", ""),
                 ("Radar", "radar", ""),
             ] {
-                if ui.button(l).clicked() {
+                let cur = chart.kind == gridcraft_engine::cmd::insert::chart_kind(k, s);
+                if ui.selectable_label(cur, l).clicked() {
                     app.run_or_alert("chart.set", json!({"chart": id, "type": k, "subtype": s}));
                 }
             }
diff --git a/crates/ui-egui/tests/it/format_chart_type.rs b/crates/ui-egui/tests/it/format_chart_type.rs
new file mode 100644
index 000000000..ae19e1091
--- /dev/null
+++ b/crates/ui-egui/tests/it/format_chart_type.rs
@@ -0,0 +1,91 @@
+//! The Format Chart Area pane's Chart Type section changes the chart's type and marks the current one.
+
+use egui::accesskit::{Role, Toggled};
+use egui_kittest::kittest::{NodeT, Queryable};
+use gridcraft_engine::Session;
+use gridcraft_engine::model::ChartKind;
+use gridcraft_ui_egui::SheetApp;
+use serde_json::json;
+
+type Harness = egui_kittest::Harness<'static, SheetApp>;
+
+/// A two-series chart made with `insert.chart`'s `type` `t` and `subtype` `sub`, with Format Chart Area open on its Chart Type section.
+fn open_chart_type(t: &str, sub: &str) -> (Harness, u32) {
+    let mut session = Session::new();
+    session.new_workbook();
+    session.execute("range.setValues", json!({"range": "A1", "values": [["Quarter", "North", "South"], ["Q1", 10, 30], ["Q2", 30, 10]]})).unwrap();
+    session.execute("selection.set", json!({"range": "A1:C3"})).unwrap();
+    let chart = session.execute("insert.chart", json!({"type": t, "subtype": sub, "at": "E3"})).unwrap();
+    let id = chart["chart"].as_u64().unwrap() as u32;
+    let mut h = crate::support::harness(session, 4);
+    h.state_mut().selected_chart = Some(id);
+    h.state_mut().grid.pane = Some("formatChart".into());
+    h.run_steps(2);
+    h.get_by_role_and_label(Role::DisclosureTriangle, "Chart Type").click();
+    h.run_steps(2);
+    (h, id)
+}
+
+fn kind(h: &Harness, id: u32) -> ChartKind {
+    h.state().session.active().unwrap().wb.active().unwrap().charts.iter().find(|c| c.id == id).unwrap().kind
+}
+
+/// Whether the pane's `label` button is drawn as the chart's current type. The pane sits on the
+/// right, past the Chart Type header's left edge; the ribbon's buttons are elsewhere.
+fn marked(h: &Harness, label: &str) -> bool {
+    let left = h.get_by_role_and_label(Role::DisclosureTriangle, "Chart Type").rect().left();
+    let button = h.get_all_by_role_and_label(Role::Button, label).find(|n| n.rect().left() >= left - 1.0).unwrap();
+    button.accesskit_node().toggled() == Some(Toggled::True)
+}
+
+fn click(h: &mut Harness, label: &str) {
+    let left = h.get_by_role_and_label(Role::DisclosureTriangle, "Chart Type").rect().left();
+    h.get_all_by_role_and_label(Role::Button, label).find(|n| n.rect().left() >= left - 1.0).unwrap().click();
+    h.run_steps(2);
+}
+
+#[test]
+fn chart_type_offers_the_stacked_and_hundred_percent_stacked_types() {
+    let (mut h, id) = open_chart_type("column", "");
+    for (label, want) in [
+        ("Stacked Column", ChartKind::ColumnStacked),
+        ("100% Stacked Column", ChartKind::ColumnStacked100),
+        ("Stacked Bar", ChartKind::BarStacked),
+        ("100% Stacked Bar", ChartKind::BarStacked100),
+        ("Stacked Line", ChartKind::LineStacked),
+        ("Stacked Area", ChartKind::AreaStacked),
+        ("100% Stacked Area", ChartKind::AreaStacked100),
+        ("Column", ChartKind::ColumnClustered),
+    ] {
+        click(&mut h, label);
+        assert_eq!(kind(&h, id), want, "{label} changes the chart's type");
+    }
+}
+
+#[test]
+fn chart_type_marks_the_chart_s_current_type() {
+    for (t, sub, label) in
+        [("bar", "stacked100", "100% Stacked Bar"), ("area", "stacked", "Stacked Area"), ("column", "", "Column"), ("line", "markers", "Line")]
+    {
+        let (h, _) = open_chart_type(t, sub);
+        for other in [
+            "Column",
+            "Stacked Column",
+            "100% Stacked Column",
+            "Bar",
+            "Stacked Bar",
+            "100% Stacked Bar",
+            "Line",
+            "Stacked Line",
+            "Area",
+            "Stacked Area",
+            "100% Stacked Area",
+            "Pie",
+            "Doughnut",
+            "Scatter",
+            "Radar",
+        ] {
+            assert_eq!(marked(&h, other), other == label, "{other} on a {t} {sub} chart");
+        }
+    }
+}
diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs
index 53625015e..5eeb4c411 100644
--- a/crates/ui-egui/tests/it/main.rs
+++ b/crates/ui-egui/tests/it/main.rs
@@ -37,6 +37,7 @@ mod filter_menu_enter;
 mod find_dialog_focus;
 mod floating_pictures;
 mod font_size_box;
+mod format_chart_type;
 mod format_painter;
 mod formula_bar;
 mod formula_bar_expand;

From 52cf825395b8a64c1d93affac2ce7f9a8202b504 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Sun, 25 Oct 2026 21:37:09 -0400
Subject: [PATCH 11/76] refactor: split complex functions for Sonar S3776
 (#2609)

Extract helpers from auto_sum (selection and single-cell guess), update_cursor
(drag, hover, freeze, and header-edge cursors) and read_styles (dxf reader).
No behaviour change.
---
 crates/engine/src/cmd/formulas.rs | 162 +++++++++++++++++-------------
 crates/ui-egui/src/grid.rs        |  84 ++++++++++------
 crates/xlsx/src/styles.rs         |  96 +++++++++---------
 3 files changed, 191 insertions(+), 151 deletions(-)

diff --git a/crates/engine/src/cmd/formulas.rs b/crates/engine/src/cmd/formulas.rs
index beb80f497..dc523d333 100644
--- a/crates/engine/src/cmd/formulas.rs
+++ b/crates/engine/src/cmd/formulas.rs
@@ -96,75 +96,73 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-fn auto_sum(s: &mut Session, p: &Json) -> Result<Json> {
-    let func = str_param(p, "function").unwrap_or("SUM").to_ascii_uppercase();
-    let d = s.doc()?;
-    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-    let sel = match str_param(p, "range") {
-        Some(_) => target_range(s, p)?,
-        None => d.selection.current(),
-    };
-    if !sel.is_single() {
-        // A selection: totals go in its empty last row or column, as Excel's do, and otherwise
-        // past it: to the right of a single row, below each column of anything taller. Columns
-        // past the sheet's data get no total (a whole-row selection doesn't write 16,384
-        // formulas), nor do rows past it, and all totals are one edit (one undo step).
-        let Some(used) = sh.cells.used_range() else { return ok() };
-        let empty = |row: u32, col: u32| sh.value(CellRef::new(row, col)).is_empty();
-        let sum = |from: CellRef, to: CellRef| format!("={func}({})", RangeRef::new(from, to).a1());
-        let last_col = used.end.col.min(sel.end.col);
-        let mut writes: Vec<(CellRef, String)> = Vec::new();
-        if sel.start.row == sel.end.row {
-            // One row: its total goes in its last cell when that is empty, else just after it.
-            let row = sel.start.row;
-            let end_col = if sel.is_full_rows() { last_col } else { sel.end.col };
-            let (data_end, out) = if end_col > sel.start.col && empty(row, end_col) { (end_col - 1, end_col) } else { (end_col, end_col + 1) };
-            if out >= gridcraft_core::MAX_COLS {
-                return Err(EngineError::Other("There's no room to the right of the selection for the total.".into()));
-            }
-            writes.push((CellRef::new(row, out), sum(CellRef::new(row, sel.start.col), CellRef::new(row, data_end))));
-        } else {
-            // An empty last column takes each row's total; rows past the data get none.
-            let rows_end = sel.end.row.min(used.end.row);
-            let right_blank = !sel.is_full_rows() && sel.end.col > sel.start.col && (sel.start.row..=rows_end).all(|r| empty(r, sel.end.col));
-            let data_end_col = if right_blank { sel.end.col - 1 } else { last_col };
-            let last_row_blank = (sel.start.col..=last_col).all(|c| empty(sel.end.row, c));
-            let (data_end_row, out_row) = if last_row_blank { (sel.end.row.saturating_sub(1), sel.end.row) } else { (sel.end.row, sel.end.row + 1) };
-            // Each column's total, below it: unless only the last column is there to take totals.
-            if last_row_blank || !right_blank {
-                if out_row >= gridcraft_core::MAX_ROWS {
-                    return Err(EngineError::Other("There's no room below the selection for the totals.".into()));
-                }
-                for c in sel.start.col..=data_end_col.min(last_col) {
-                    writes.push((CellRef::new(out_row, c), sum(CellRef::new(sel.start.row, c), CellRef::new(data_end_row, c))));
-                }
-            }
-            if right_blank {
-                for r in sel.start.row..=data_end_row.min(rows_end) {
-                    writes.push((CellRef::new(r, sel.end.col), sum(CellRef::new(r, sel.start.col), CellRef::new(r, data_end_col))));
-                }
-                // Both empty: the corner takes the total of the whole block.
-                if last_row_blank {
-                    writes.push((
-                        CellRef::new(sel.end.row, sel.end.col),
-                        sum(CellRef::new(sel.start.row, sel.start.col), CellRef::new(data_end_row, data_end_col)),
-                    ));
-                }
-            }
-        }
-        let sheet = d.wb.active_sheet;
-        edit(s, |cx| {
-            for (c, f) in &writes {
-                let cell = super::edit::input_to_cell(f, sheet, *c, &mut cx.wb)?.unwrap_or_default();
-                cx.sheet_mut(sheet)?.set_cell(*c, cell);
-                cx.touch(sheet, *c);
-            }
-            Ok(())
-        })?;
-        return ok();
+/// Whether a cell on the active sheet is empty.
+fn blank(sh: &gridcraft_model::sheet::Sheet, row: u32, col: u32) -> bool {
+    sh.value(CellRef::new(row, col)).is_empty()
+}
+
+fn sum_formula(func: &str, from: CellRef, to: CellRef) -> String {
+    format!("={func}({})", RangeRef::new(from, to).a1())
+}
+
+/// Totals for a multi-cell selection as `(cell, formula)` writes. `None` when the sheet has no data.
+fn selection_totals(sh: &gridcraft_model::sheet::Sheet, sel: RangeRef, func: &str) -> Result<Option<Vec<(CellRef, String)>>> {
+    // A selection: totals go in its empty last row or column, as Excel's do, and otherwise
+    // past it: to the right of a single row, below each column of anything taller. Columns
+    // past the sheet's data get no total (a whole-row selection doesn't write 16,384
+    // formulas), nor do rows past it, and all totals are one edit (one undo step).
+    let Some(used) = sh.cells.used_range() else { return Ok(None) };
+    if sel.start.row == sel.end.row { single_row_totals(sh, sel, used, func).map(Some) } else { block_totals(sh, sel, used, func).map(Some) }
+}
+
+/// One row: its total goes in its last cell when that is empty, else just after it.
+fn single_row_totals(sh: &gridcraft_model::sheet::Sheet, sel: RangeRef, used: RangeRef, func: &str) -> Result<Vec<(CellRef, String)>> {
+    let row = sel.start.row;
+    let last_col = used.end.col.min(sel.end.col);
+    let end_col = if sel.is_full_rows() { last_col } else { sel.end.col };
+    let (data_end, out) = if end_col > sel.start.col && blank(sh, row, end_col) { (end_col - 1, end_col) } else { (end_col, end_col + 1) };
+    if out >= gridcraft_core::MAX_COLS {
+        return Err(EngineError::Other("There's no room to the right of the selection for the total.".into()));
     }
-    // Single cell: guess the range above, else to the left.
-    let at = sel.start;
+    Ok(vec![(CellRef::new(row, out), sum_formula(func, CellRef::new(row, sel.start.col), CellRef::new(row, data_end)))])
+}
+
+/// A block of rows: each column's total below it, and each row's total in an empty last column.
+fn block_totals(sh: &gridcraft_model::sheet::Sheet, sel: RangeRef, used: RangeRef, func: &str) -> Result<Vec<(CellRef, String)>> {
+    let mut writes: Vec<(CellRef, String)> = Vec::new();
+    let last_col = used.end.col.min(sel.end.col);
+    // An empty last column takes each row's total; rows past the data get none.
+    let rows_end = sel.end.row.min(used.end.row);
+    let right_blank = !sel.is_full_rows() && sel.end.col > sel.start.col && (sel.start.row..=rows_end).all(|r| blank(sh, r, sel.end.col));
+    let data_end_col = if right_blank { sel.end.col - 1 } else { last_col };
+    let last_row_blank = (sel.start.col..=last_col).all(|c| blank(sh, sel.end.row, c));
+    let (data_end_row, out_row) = if last_row_blank { (sel.end.row.saturating_sub(1), sel.end.row) } else { (sel.end.row, sel.end.row + 1) };
+    // Each column's total, below it: unless only the last column is there to take totals.
+    if last_row_blank || !right_blank {
+        if out_row >= gridcraft_core::MAX_ROWS {
+            return Err(EngineError::Other("There's no room below the selection for the totals.".into()));
+        }
+        for c in sel.start.col..=data_end_col.min(last_col) {
+            writes.push((CellRef::new(out_row, c), sum_formula(func, CellRef::new(sel.start.row, c), CellRef::new(data_end_row, c))));
+        }
+    }
+    if right_blank {
+        for r in sel.start.row..=data_end_row.min(rows_end) {
+            writes.push((CellRef::new(r, sel.end.col), sum_formula(func, CellRef::new(r, sel.start.col), CellRef::new(r, data_end_col))));
+        }
+        // Both empty: the corner takes the total of the whole block.
+        if last_row_blank {
+            writes.push((
+                CellRef::new(sel.end.row, sel.end.col),
+                sum_formula(func, CellRef::new(sel.start.row, sel.start.col), CellRef::new(data_end_row, data_end_col)),
+            ));
+        }
+    }
+    Ok(writes)
+}
+
+/// The range a single cell's AutoSum guesses: the numbers above it, else the numbers to its left.
+fn guessed_range(sh: &gridcraft_model::sheet::Sheet, at: CellRef) -> Option<RangeRef> {
     let numeric = |c: CellRef| sh.value(c).is_number();
     let mut range = None;
     if at.row > 0 && (numeric(CellRef::new(at.row - 1, at.col)) || at.col == 0 || !numeric(CellRef::new(at.row, at.col - 1))) {
@@ -186,7 +184,33 @@ fn auto_sum(s: &mut Session, p: &Json) -> Result<Json> {
         }
         range = Some(RangeRef::new(CellRef::new(at.row, left), CellRef::new(at.row, at.col - 1)));
     }
-    let text = match range {
+    range
+}
+
+fn auto_sum(s: &mut Session, p: &Json) -> Result<Json> {
+    let func = str_param(p, "function").unwrap_or("SUM").to_ascii_uppercase();
+    let d = s.doc()?;
+    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+    let sel = match str_param(p, "range") {
+        Some(_) => target_range(s, p)?,
+        None => d.selection.current(),
+    };
+    if !sel.is_single() {
+        let Some(writes) = selection_totals(sh, sel, &func)? else { return ok() };
+        let sheet = d.wb.active_sheet;
+        edit(s, |cx| {
+            for (c, f) in &writes {
+                let cell = super::edit::input_to_cell(f, sheet, *c, &mut cx.wb)?.unwrap_or_default();
+                cx.sheet_mut(sheet)?.set_cell(*c, cell);
+                cx.touch(sheet, *c);
+            }
+            Ok(())
+        })?;
+        return ok();
+    }
+    // Single cell: guess the range above, else to the left.
+    let at = sel.start;
+    let text = match guessed_range(sh, at) {
         Some(r) => format!("={func}({})", r.a1()),
         None => {
             s.ui_requests.push(crate::UiRequest::EditCell(Some(format!("={func}()"))));
diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index d13b6e4df..1c5704ee3 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -2046,38 +2046,46 @@ fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Response, geo:
     }
     // A held drag owns the cursor even outside the grid; a press below egui's threshold still
     // has Drag::None and uses hover. A click can briefly leave a drag state after release.
-    if resp.dragged() && pointer.primary_down() {
-        let cursor = match app.grid.drag {
-            Drag::None => None,
-            Drag::Select => Some(CursorIcon::Cell),
-            Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default),
-            Drag::Fill { .. } => Some(CursorIcon::Crosshair),
-            Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { resize: false, .. } => Some(CursorIcon::Move),
-            Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn),
-            Drag::ResizeRow { .. } => Some(CursorIcon::ResizeRow),
-            Drag::Freeze { cols, .. } => Some(if cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical }),
-            Drag::Object { resize: true, .. } => Some(CursorIcon::ResizeNwSe),
-        };
-        if let Some(cursor) = cursor {
-            ctx.set_cursor_icon(cursor);
-            return;
-        }
+    if resp.dragged()
+        && pointer.primary_down()
+        && let Some(cursor) = drag_cursor(&app.grid.drag)
+    {
+        ctx.set_cursor_icon(cursor);
+        return;
     }
     if !resp.hovered() {
         return;
     }
     let Some(p) = pos else { return };
+    hover_cursor(app, ctx, resp, &pointer, geo, sh, p);
+}
+
+/// The cursor a held drag shows, or `None` when the drag leaves it to hover.
+fn drag_cursor(drag: &Drag) -> Option<CursorIcon> {
+    match drag {
+        Drag::None => None,
+        Drag::Select => Some(CursorIcon::Cell),
+        Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default),
+        Drag::Fill { .. } => Some(CursorIcon::Crosshair),
+        Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { resize: false, .. } => Some(CursorIcon::Move),
+        Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn),
+        Drag::ResizeRow { .. } => Some(CursorIcon::ResizeRow),
+        Drag::Freeze { cols, .. } => Some(if *cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical }),
+        Drag::Object { resize: true, .. } => Some(CursorIcon::ResizeNwSe),
+    }
+}
+
+/// The cursor over the grid when no drag owns it: freeze bars, header edges, the fill handle, cells.
+fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, pointer: &egui::PointerState, geo: &Geo, sh: &Sheet, p: Pos2) {
+    let (freeze_cols, freeze_rows) = freeze_handles(geo);
     if freeze_cols.contains(p) || freeze_rows.contains(p) {
-        let cols = freeze_cols.contains(p);
-        ctx.set_cursor_icon(if cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical });
-        if app.grid.drag == Drag::None && !pointer.any_down() {
-            let tip = if cols { "Drag to freeze columns" } else { "Drag to freeze rows" };
-            resp.clone().on_hover_text_at_pointer(crate::i18n::current(ctx).tr(tip));
-        }
+        freeze_cursor(app, ctx, resp, pointer, freeze_cols.contains(p));
         return;
     }
+    let in_cells = geo.in_cells(p);
     let in_col_header = p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left();
     let in_row_header = p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top();
+    let near_col_edge = in_col_header && col_edge(geo, sh, p.x).is_some();
     let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default();
     let cur_rect = geo.range_rect(sh, sel.current());
     let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0));
@@ -2089,16 +2097,8 @@ fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Response, geo:
     let near_corner = selected_object.is_some_and(|(_, _, rect)| (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS);
     if app.grid.drag == Drag::None && near_corner {
         ctx.set_cursor_icon(CursorIcon::ResizeNwSe);
-    } else if (in_col_header && col_edge(geo, sh, p.x).is_some()) || (in_row_header && row_edge(geo, sh, p.y).is_some()) {
-        let near_col_edge = in_col_header && col_edge(geo, sh, p.x).is_some();
-        // Just past a hidden column or row, Excel shows a split cursor: dragging or
-        // double-clicking there unhides it.
-        let hidden = app.grid.drag == Drag::None
-            && if near_col_edge { hidden_col_edge(geo, sh, p.x).is_some() } else { hidden_row_edge(geo, sh, p.y).is_some() };
-        match pointer.hover_pos() {
-            Some(at) if hidden => paint_split_cursor(ctx, at, near_col_edge),
-            _ => ctx.set_cursor_icon(if near_col_edge { CursorIcon::ResizeColumn } else { CursorIcon::ResizeRow }),
-        }
+    } else if near_col_edge || (in_row_header && row_edge(geo, sh, p.y).is_some()) {
+        header_edge_cursor(app, ctx, pointer, geo, sh, p, near_col_edge);
     } else if on_handle && app.editor.is_none() {
         ctx.set_cursor_icon(CursorIcon::Crosshair);
         if app.grid.drag == Drag::None && !pointer.any_down() {
@@ -2115,6 +2115,26 @@ fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Response, geo:
     }
 }
 
+/// The resize cursor for dragging a freeze bar.
+fn freeze_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, pointer: &egui::PointerState, cols: bool) {
+    ctx.set_cursor_icon(if cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical });
+    if app.grid.drag == Drag::None && !pointer.any_down() {
+        let tip = if cols { "Drag to freeze columns" } else { "Drag to freeze rows" };
+        resp.clone().on_hover_text_at_pointer(crate::i18n::current(ctx).tr(tip));
+    }
+}
+
+/// The resize cursor over a column or row header edge. Just past a hidden column or row, Excel
+/// shows a split cursor: dragging or double-clicking there unhides it.
+fn header_edge_cursor(app: &SheetApp, ctx: &egui::Context, pointer: &egui::PointerState, geo: &Geo, sh: &Sheet, p: Pos2, near_col_edge: bool) {
+    let hidden =
+        app.grid.drag == Drag::None && if near_col_edge { hidden_col_edge(geo, sh, p.x).is_some() } else { hidden_row_edge(geo, sh, p.y).is_some() };
+    match pointer.hover_pos() {
+        Some(at) if hidden => paint_split_cursor(ctx, at, near_col_edge),
+        _ => ctx.set_cursor_icon(if near_col_edge { CursorIcon::ResizeColumn } else { CursorIcon::ResizeRow }),
+    }
+}
+
 fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet, wb: &Workbook) {
     // Text selection and editing must not also move the object or edit worksheet cells.
     if app.text_box_editor.is_some() || app.grid.hf_edit.is_some() {
diff --git a/crates/xlsx/src/styles.rs b/crates/xlsx/src/styles.rs
index 0baff5c0f..c1f93aca9 100644
--- a/crates/xlsx/src/styles.rs
+++ b/crates/xlsx/src/styles.rs
@@ -359,59 +359,55 @@ pub fn read_styles(root: &El, checkboxes: &[bool], minor_font: &str) -> StylesIn
             }
         }
     }
-    let dxfs = root
-        .child("dxfs")
-        .map(|d| {
-            d.kids("dxf")
-                .map(|x| {
-                    let mut s = Style::default();
-                    if let Some(e) = x.child("font") {
-                        let f = read_font(e, &palette);
-                        // Differential fonts rarely name a face; unless stated, keep the default face and size.
-                        let has_size = e.child("sz").and_then(|n| n.attr_f64("val")).is_some();
-                        let has_name = e.child("name").and_then(|n| n.attr("val")).is_some();
-                        let name = if has_name { f.name.clone() } else { s.font.name.clone() };
-                        let size = if has_size { f.size } else { s.font.size };
-                        let def = Font::default();
-                        let st = &mut s.dxf_stated;
-                        st.bold = e.child("b").is_some() && !f.bold;
-                        st.italic = e.child("i").is_some() && !f.italic;
-                        st.strike = e.child("strike").is_some() && !f.strike;
-                        st.underline = e.child("u").is_some() && f.underline == Underline::None;
-                        st.size = has_size && size == def.size;
-                        st.name = has_name && name == def.name;
-                        st.scheme = e.child_val("scheme").map(str::to_string);
-                        // A differential font's scheme is in `dxf_stated`.
-                        s.font = Font { name, size, minor: s.font.minor, ..f };
-                    }
-                    if let Some(n) = x.child("numFmt") {
-                        if let Some(code) = n.attr("formatCode") {
-                            s.num_fmt = NumFmt::new(code);
-                        } else if let Some(id) = n.attr_u32("numFmtId") {
-                            s.num_fmt = num_fmt_code(id, &fmts);
-                        }
-                    }
-                    if let Some(f) = x.child("fill") {
-                        s.fill = read_fill(f, &palette, true);
-                    }
-                    if let Some(b) = x.child("border") {
-                        s.borders = read_border(b, &palette);
-                    }
-                    if let Some(a) = x.child("alignment") {
-                        s.align = read_alignment(a);
-                    }
-                    if let Some(p) = x.child("protection") {
-                        s.protection = read_protection(p);
-                        s.dxf_stated.protection = s.protection == Protection::default();
-                    }
-                    s
-                })
-                .collect()
-        })
-        .unwrap_or_default();
+    let dxfs = root.child("dxfs").map(|d| d.kids("dxf").map(|x| read_dxf(x, &palette, &fmts)).collect()).unwrap_or_default();
     StylesIn { xfs, dxfs, palette, named, num_fmts: fmts }
 }
 
+/// One differential format (`dxf`): the style it sets over a cell's own.
+fn read_dxf(x: &El, palette: &[u32], fmts: &HashMap<u32, String>) -> Style {
+    let mut s = Style::default();
+    if let Some(e) = x.child("font") {
+        let f = read_font(e, palette);
+        // Differential fonts rarely name a face; unless stated, keep the default face and size.
+        let has_size = e.child("sz").and_then(|n| n.attr_f64("val")).is_some();
+        let has_name = e.child("name").and_then(|n| n.attr("val")).is_some();
+        let name = if has_name { f.name.clone() } else { s.font.name.clone() };
+        let size = if has_size { f.size } else { s.font.size };
+        let def = Font::default();
+        let st = &mut s.dxf_stated;
+        st.bold = e.child("b").is_some() && !f.bold;
+        st.italic = e.child("i").is_some() && !f.italic;
+        st.strike = e.child("strike").is_some() && !f.strike;
+        st.underline = e.child("u").is_some() && f.underline == Underline::None;
+        st.size = has_size && size == def.size;
+        st.name = has_name && name == def.name;
+        st.scheme = e.child_val("scheme").map(str::to_string);
+        // A differential font's scheme is in `dxf_stated`.
+        s.font = Font { name, size, minor: s.font.minor, ..f };
+    }
+    if let Some(n) = x.child("numFmt") {
+        if let Some(code) = n.attr("formatCode") {
+            s.num_fmt = NumFmt::new(code);
+        } else if let Some(id) = n.attr_u32("numFmtId") {
+            s.num_fmt = num_fmt_code(id, fmts);
+        }
+    }
+    if let Some(f) = x.child("fill") {
+        s.fill = read_fill(f, palette, true);
+    }
+    if let Some(b) = x.child("border") {
+        s.borders = read_border(b, palette);
+    }
+    if let Some(a) = x.child("alignment") {
+        s.align = read_alignment(a);
+    }
+    if let Some(p) = x.child("protection") {
+        s.protection = read_protection(p);
+        s.dxf_stated.protection = s.protection == Protection::default();
+    }
+    s
+}
+
 // ---------------------------------------------------------------- writing
 
 pub fn color_attrs(c: &Color) -> String {

From 42bbf6baa26a57f094411f17d1ab039cc91905a0 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Sun, 25 Oct 2026 21:39:17 -0400
Subject: [PATCH 12/76] refactor: split complex functions for Sonar S3776
 (#2612)

Extract group_bracket from outline layout and move_marks from data
outline_settings. No behaviour change.
---
 crates/engine/src/cmd/data.rs | 54 +++++++++++++++++++----------------
 crates/ui-egui/src/outline.rs | 54 +++++++++++++++++++----------------
 2 files changed, 59 insertions(+), 49 deletions(-)

diff --git a/crates/engine/src/cmd/data.rs b/crates/engine/src/cmd/data.rs
index 721357fec..4828edeba 100644
--- a/crates/engine/src/cmd/data.rs
+++ b/crates/engine/src/cmd/data.rs
@@ -1454,6 +1454,34 @@ fn show_levels(s: &mut Session, p: &Json) -> Result<Json> {
 
 /// Data ▸ Outline ▸ Settings: whether summary rows sit below their detail and summary columns
 /// right of it. A changed direction moves each collapsed group's mark (+) to its new summary line.
+/// Moves the collapsed marks of a line axis to the summary line on its new side (`on` is the new
+/// setting, `was_before` the old one). A line that nested groups share keeps its mark on the outermost
+/// group whose detail is all hidden, or the outermost when none is.
+fn move_marks(map: &mut std::collections::BTreeMap<u32, LineInfo>, was_before: bool, on: bool) {
+    let mut marked: Vec<outline::OutlineGroup> =
+        outline::groups_with(map, was_before).into_iter().filter(|g| g.has_summary() && map.get(&g.summary()).is_some_and(|e| e.collapsed)).collect();
+    // A mark on a line that nested groups share moves with the outermost of them whose
+    // detail is all hidden, or with the outermost when none is.
+    let mut owner: std::collections::BTreeMap<u32, (bool, u8)> = std::collections::BTreeMap::new();
+    for g in &marked {
+        let key = (!g.collapsed, g.level);
+        let best = owner.entry(g.summary()).or_insert(key);
+        *best = (*best).min(key);
+    }
+    marked.retain(|g| owner.get(&g.summary()) == Some(&(!g.collapsed, g.level)));
+    for g in &marked {
+        if let Some(e) = map.get_mut(&g.summary()) {
+            e.collapsed = false;
+        }
+    }
+    for g in marked {
+        let g = outline::OutlineGroup { summary_before: !on, ..g };
+        if g.has_summary() {
+            map.entry(g.summary()).or_default().collapsed = true;
+        }
+    }
+}
+
 fn outline_settings(s: &mut Session, p: &Json) -> Result<Json> {
     let si = target_sheet(s, p)?;
     edit(s, |cx| {
@@ -1469,31 +1497,7 @@ fn outline_settings(s: &mut Session, p: &Json) -> Result<Json> {
             if was_before != on {
                 continue;
             }
-            let map = if rows { &mut sh.rows } else { &mut sh.cols };
-            let mut marked: Vec<outline::OutlineGroup> = outline::groups_with(map, was_before)
-                .into_iter()
-                .filter(|g| g.has_summary() && map.get(&g.summary()).is_some_and(|e| e.collapsed))
-                .collect();
-            // A mark on a line that nested groups share moves with the outermost of them whose
-            // detail is all hidden, or with the outermost when none is.
-            let mut owner: std::collections::BTreeMap<u32, (bool, u8)> = std::collections::BTreeMap::new();
-            for g in &marked {
-                let key = (!g.collapsed, g.level);
-                let best = owner.entry(g.summary()).or_insert(key);
-                *best = (*best).min(key);
-            }
-            marked.retain(|g| owner.get(&g.summary()) == Some(&(!g.collapsed, g.level)));
-            for g in &marked {
-                if let Some(e) = map.get_mut(&g.summary()) {
-                    e.collapsed = false;
-                }
-            }
-            for g in marked {
-                let g = outline::OutlineGroup { summary_before: !on, ..g };
-                if g.has_summary() {
-                    map.entry(g.summary()).or_default().collapsed = true;
-                }
-            }
+            move_marks(if rows { &mut sh.rows } else { &mut sh.cols }, was_before, on);
         }
         Ok(json!({"summaryBelow": sh.summary_below, "summaryRight": sh.summary_right}))
     })
diff --git a/crates/ui-egui/src/outline.rs b/crates/ui-egui/src/outline.rs
index 9096d1611..d192cee22 100644
--- a/crates/ui-egui/src/outline.rs
+++ b/crates/ui-egui/src/outline.rs
@@ -165,6 +165,35 @@ impl Dir<'_> {
 }
 
 /// The band's buttons and brackets for this frame.
+/// The bracket for one group's detail, and its tick, on the lane `across`; `button` is the group's
+/// summary button when it is on screen.
+fn group_bracket(out: &mut Layout, dir: &Dir, grp: &OutlineGroup, button: Option<f32>, across: f32, side: f32) {
+    let first = dir.first_visible(grp.start, grp.end);
+    let Some((first_line, (a0, _))) = first else { return };
+    if grp.summary_before {
+        // From the button down (or across) to the last detail line, with the tick there.
+        let a0 = button.map_or(a0, |mid| mid + side / 2.0);
+        let end = dir.start(grp.end) + dir.size(grp.end);
+        let a1 = end.min(dir.hi);
+        if a1 <= a0 {
+            return;
+        }
+        let tick = (end <= dir.hi).then(|| [dir.point(a1 - 0.5, across), dir.point(a1 - 0.5, across + side / 2.0)]);
+        out.brackets.push(Bracket { line: [dir.point(a0, across), dir.point(a1 - 0.5, across)], tick });
+        return;
+    }
+    let a1 = match button {
+        Some(mid) => mid - side / 2.0,
+        None => dir.start(grp.summary()).min(dir.hi),
+    };
+    if a1 <= a0 {
+        return;
+    }
+    let start_shown = first_line == grp.start && (a0 - dir.start(grp.start)).abs() < 0.5;
+    let tick = start_shown.then(|| [dir.point(a0 + 0.5, across), dir.point(a0 + 0.5, across + side / 2.0)]);
+    out.brackets.push(Bracket { line: [dir.point(a0 + 0.5, across), dir.point(a1, across)], tick });
+}
+
 pub fn layout(geo: &Geo, sh: &Sheet) -> Layout {
     let mut out = Layout::default();
     let zoom = (geo.z / DISPLAY_SCALE).max(0.1);
@@ -212,30 +241,7 @@ pub fn layout(geo: &Geo, sh: &Sheet) -> Layout {
                 continue;
             }
             // The bracket, over the part of the detail that is on screen.
-            let first = dir.first_visible(grp.start, grp.end);
-            let Some((first_line, (a0, _))) = first else { continue };
-            if grp.summary_before {
-                // From the button down (or across) to the last detail line, with the tick there.
-                let a0 = button.map_or(a0, |mid| mid + side / 2.0);
-                let end = dir.start(grp.end) + dir.size(grp.end);
-                let a1 = end.min(dir.hi);
-                if a1 <= a0 {
-                    continue;
-                }
-                let tick = (end <= dir.hi).then(|| [dir.point(a1 - 0.5, across), dir.point(a1 - 0.5, across + side / 2.0)]);
-                out.brackets.push(Bracket { line: [dir.point(a0, across), dir.point(a1 - 0.5, across)], tick });
-                continue;
-            }
-            let a1 = match button {
-                Some(mid) => mid - side / 2.0,
-                None => dir.start(grp.summary()).min(dir.hi),
-            };
-            if a1 <= a0 {
-                continue;
-            }
-            let start_shown = first_line == grp.start && (a0 - dir.start(grp.start)).abs() < 0.5;
-            let tick = start_shown.then(|| [dir.point(a0 + 0.5, across), dir.point(a0 + 0.5, across + side / 2.0)]);
-            out.brackets.push(Bracket { line: [dir.point(a0 + 0.5, across), dir.point(a1, across)], tick });
+            group_bracket(&mut out, dir, grp, button, across, side);
         }
     }
     out

From 22aec7e667216de3f29e3e938993edb101555381 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 02:24:45 +0000
Subject: [PATCH 13/76] G1: build on current main

Scripts can't run the View tab's window commands (Switch Windows, New Window, Hide, Unhide):
they change the active workbook, as window.* steps do. The Switch Windows button names its
accessibility role with egui::Role (egui 0.37).
---
 crates/engine/src/cmd/extra.rs | 2 +-
 crates/engine/src/tests.rs     | 3 +++
 crates/ui-egui/src/ribbon.rs   | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index 891273b43..954583a99 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -1058,7 +1058,7 @@ fn denied_script_step(id: &str, params: &Json) -> Option<String> {
     }
     // Scripts are scoped to their workbook: a step that switches the active window would
     // point every later step at another open document, so those are refused too.
-    if id.starts_with("window.") {
+    if id.starts_with("window.") || matches!(id, "view.switchWindows" | "view.newWindow" | "view.hideWindow" | "view.unhideWindow") {
         return Some(format!("scripts can't run `{id}`: it reaches outside the workbook"));
     }
     if params.get("path").is_some() {
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 6648b9b7e..6ca6db43a 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -4907,6 +4907,9 @@ fn a_script_cannot_switch_windows() {
     s.execute("automate.trustScripts", json!({"trusted": true})).unwrap();
     let err = s.execute("automate.runScript", json!({"name": "t"})).expect_err("script switching windows");
     assert!(err.to_string().contains("window.activate"), "{err}");
+    s.execute("automate.newScript", json!({"name": "sw", "commands": [{"command": "view.switchWindows", "params": {"doc": 1}}]})).unwrap();
+    let err = s.execute("automate.runScript", json!({"name": "sw"})).expect_err("script switching windows from the View tab");
+    assert!(err.to_string().contains("view.switchWindows"), "{err}");
     // A benign script runs.
     s.execute("automate.newScript", json!({"name": "ok", "commands": [{"command": "cell.set", "params": {"cell": "A1", "input": "=1+1"}}]})).unwrap();
     s.execute("automate.runScript", json!({"name": "ok"})).unwrap();
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index af7114c19..a3c3b69f3 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -2600,7 +2600,7 @@ fn view(app: &mut SheetApp, ui: &mut Ui) {
 /// choosing one brings it forward.
 fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
     let anchor = big_button(ui, Icon::Book, "Switch\nWindows", "Switch Windows", true);
-    anchor.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), "Switch Windows"));
+    anchor.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Switch Windows"));
     control_keytip(app, ui, &anchor, "view.switchWindows");
     let forced = std::mem::take(&mut app.open_switch_windows);
     egui::Popup::menu(&anchor).open_memory(popup_command(forced, anchor.clicked())).show(|ui| {

From 94fcbf8b4c50196e2c8b0c8eb0792c5042ba087b Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 02:37:42 +0000
Subject: [PATCH 14/76] G3: craft-libs at e8b4dde5 (craft-libs#340)

craft-update, craft-window, craft-ui and craft-print all come from one craft-libs revision, the
head of storytold/craft-libs#340 on the aiongg fork, until #340 merges.
---
 Cargo.lock                | 249 ++++++++++++++++++++++++++++++++++----
 Cargo.toml                |  10 +-
 apps/gridcraft/Cargo.toml |   4 +-
 crates/ui-egui/Cargo.toml |   7 +-
 4 files changed, 241 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4e7cf4a26..21b2f04dc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -220,7 +220,7 @@ dependencies = [
  "objc2-foundation 0.3.2",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
  "wl-clipboard-rs",
  "x11rb",
 ]
@@ -742,6 +742,15 @@ dependencies = [
  "x509-cert",
 ]
 
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "codespan-reporting"
 version = "0.13.1"
@@ -877,13 +886,41 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "craft-fonts-build"
+version = "0.1.0"
+source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+
+[[package]]
+name = "craft-i18n"
+version = "0.1.0"
+source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+dependencies = [
+ "fixed_decimal",
+ "icu_decimal",
+ "icu_locale_core",
+ "icu_locale_fallback",
+ "icu_normalizer",
+ "icu_plurals",
+ "icu_properties",
+ "icu_provider",
+ "icu_provider_adapters",
+ "icu_provider_blob",
+ "log",
+ "objc2-foundation 0.3.2",
+ "sys-locale",
+ "unicode-bidi",
+ "windows-registry",
+ "writeable",
+]
+
 [[package]]
 name = "craft-print"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=25da1314d443171b4adeaad2cd9454b273f35c6f#25da1314d443171b4adeaad2cd9454b273f35c6f"
+source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
 dependencies = [
  "craft-winprint-gdi",
- "miniz_oxide 0.8.9",
+ "miniz_oxide 0.9.1",
  "roxmltree",
  "tempfile",
  "winprint",
@@ -893,15 +930,27 @@ dependencies = [
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=25da1314d443171b4adeaad2cd9454b273f35c6f#25da1314d443171b4adeaad2cd9454b273f35c6f"
+source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
 dependencies = [
+ "craft-fonts-build",
+ "craft-i18n",
  "egui",
+ "epaint",
+ "js-sys",
+ "log",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-foundation 0.3.2",
+ "skrifa",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=495e5971bc024aa96e6ed318cb6e7cd3a0103184#495e5971bc024aa96e6ed318cb6e7cd3a0103184"
+source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
 dependencies = [
  "chrono",
  "dunce",
@@ -923,6 +972,17 @@ dependencies = [
  "zip 9.1.0",
 ]
 
+[[package]]
+name = "craft-window"
+version = "0.1.0"
+source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+dependencies = [
+ "egui",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "wayland-client",
+]
+
 [[package]]
 name = "craft-winprint-gdi"
 version = "0.1.0"
@@ -1395,7 +1455,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1476,6 +1536,17 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
 
+[[package]]
+name = "fixed_decimal"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2214fb00f669ee96bee5bb29dfb1ddabe058b2bc426817efc79afa03c9bc55ae"
+dependencies = [
+ "displaydoc",
+ "smallvec",
+ "writeable",
+]
+
 [[package]]
 name = "fixedbitset"
 version = "0.5.7"
@@ -2011,6 +2082,7 @@ version = "0.12.1"
 dependencies = [
  "craft-ui",
  "craft-update",
+ "craft-window",
  "egui",
  "egui_kittest",
  "epaint_default_fonts",
@@ -2307,6 +2379,23 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "icu_decimal"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08"
+dependencies = [
+ "displaydoc",
+ "fixed_decimal",
+ "icu_locale_core",
+ "icu_pattern",
+ "icu_plurals",
+ "icu_provider",
+ "serde",
+ "writeable",
+ "zerovec",
+]
+
 [[package]]
 name = "icu_locale_core"
 version = "2.3.0"
@@ -2315,11 +2404,32 @@ checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
 dependencies = [
  "displaydoc",
  "litemap",
+ "serde",
  "tinystr",
  "writeable",
  "zerovec",
 ]
 
+[[package]]
+name = "icu_locale_fallback"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"
+dependencies = [
+ "icu_locale_core",
+ "icu_locale_fallback_data",
+ "icu_provider",
+ "potential_utf",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_fallback_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"
+
 [[package]]
 name = "icu_normalizer"
 version = "2.3.0"
@@ -2331,6 +2441,9 @@ dependencies = [
  "icu_properties",
  "icu_provider",
  "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
  "zerovec",
 ]
 
@@ -2340,6 +2453,32 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
 
+[[package]]
+name = "icu_pattern"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc43ce0e76ee8cb0482dc6e2dbb9b76278e8038f45daabf2a2877577e2ceb18f"
+dependencies = [
+ "displaydoc",
+ "either",
+ "serde",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_plurals"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593"
+dependencies = [
+ "displaydoc",
+ "fixed_decimal",
+ "icu_provider",
+ "serde",
+ "zerovec",
+]
+
 [[package]]
 name = "icu_properties"
 version = "2.3.0"
@@ -2369,6 +2508,9 @@ checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
+ "postcard",
+ "serde",
+ "stable_deref_trait",
  "writeable",
  "yoke",
  "zerofrom",
@@ -2376,6 +2518,30 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "icu_provider_adapters"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df887bc4f55dbc773c7c45a0c7dfa75be886f7b7812830a71ab7271cc1801820"
+dependencies = [
+ "icu_locale_fallback",
+ "icu_provider",
+]
+
+[[package]]
+name = "icu_provider_blob"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5916b44fac319d3f58e4d8d805a627df19e27937b582cd99fcde3bb6b7ce1b0e"
+dependencies = [
+ "icu_provider",
+ "postcard",
+ "serde",
+ "writeable",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -2663,6 +2829,9 @@ name = "litemap"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "litrs"
@@ -3288,7 +3457,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3537,12 +3706,24 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "serde",
+]
+
 [[package]]
 name = "potential_utf"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
 dependencies = [
+ "serde_core",
+ "writeable",
  "zerovec",
 ]
 
@@ -3690,7 +3871,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3949,9 +4130,12 @@ dependencies = [
 
 [[package]]
 name = "roxmltree"
-version = "0.20.0"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
+checksum = "9da7f59328b09405b181fee1018925fad50f157afb43c0c0f5c522c256dd5907"
+dependencies = [
+ "memchr",
+]
 
 [[package]]
 name = "rustc-hash"
@@ -3997,7 +4181,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4056,7 +4240,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4742,7 +4926,10 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4"
 dependencies = [
+ "js-sys",
  "libc",
+ "wasm-bindgen",
+ "web-sys",
 ]
 
 [[package]]
@@ -4784,10 +4971,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.5",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4890,6 +5077,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
 dependencies = [
  "displaydoc",
+ "serde_core",
  "zerovec",
 ]
 
@@ -5224,6 +5412,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
 [[package]]
 name = "utf8-zero"
 version = "0.8.1"
@@ -5739,7 +5933,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6084,11 +6278,20 @@ dependencies = [
  "wayland-protocols-wlr",
 ]
 
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
 [[package]]
 name = "writeable"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
+dependencies = [
+ "either",
+]
 
 [[package]]
 name = "x11-dl"
@@ -6204,9 +6407,9 @@ dependencies = [
 
 [[package]]
 name = "yoke"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+checksum = "417ef3fcf6c300b7dbd25c85531a746931c02ad536f3cf4786ed1e88223340b3"
 dependencies = [
  "stable_deref_trait",
  "yoke-derive",
@@ -6399,16 +6602,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
 dependencies = [
  "displaydoc",
+ "litemap",
+ "serde_core",
  "yoke",
  "zerofrom",
+ "zerovec",
 ]
 
 [[package]]
 name = "zerovec"
-version = "0.11.8"
+version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
+checksum = "f58a2799cfe9a1670c7ea8edbd52ef8edb93cb37a7f83bf31ba9e35d9dae6a40"
 dependencies = [
+ "serde",
  "yoke",
  "zerofrom",
  "zerovec-derive",
@@ -6416,9 +6623,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.6"
+version = "0.11.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
+checksum = "c3743ddbf47738d929cd1ae2e199d40d0162979dfe31aef8ae646d2bf00bf97a"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 5ceb7e9f0..451106ae8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,10 @@ gridcraft-engine = { path = "crates/engine" }
 gridcraft-ui-egui = { path = "crates/ui-egui" }
 gridcraft-mcp = { path = "crates/mcp" }
 gridcraft-pdf = { path = "crates/pdf" }
-craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "495e5971bc024aa96e6ed318cb6e7cd3a0103184", features = ["egui"] }
+# Every craft-libs crate (craft-update and craft-window here, craft-ui in ui-egui, craft-print in
+# the app) comes from one craft-libs revision: the head of storytold/craft-libs#340 on the aiongg
+# fork. They repin to storytold/craft-libs main once #340 merges.
+craft-update = { git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4", version = "=0.1.0", features = ["egui"] }
 
 # foundation
 thiserror = "2"
@@ -58,9 +61,8 @@ skrifa = { version = "0.44", default-features = false, features = ["std"] }
 # Real font bytes for tests (Ubuntu Light, compiled into epaint).
 epaint_default_fonts = "0.37"
 # One native window per workbook: the window list, Window menu titles and the immediate-viewport
-# driver (craft-libs). Pinned to the aiongg fork's `window-list` branch; repins to
-# storytold/craft-libs once that branch merges there.
-craft-window = { version = "0.1.0", git = "https://github.com/aiongg/craft-libs", rev = "4fbdea5fcf86ba893d9bc03685d4531cfdd4efc2", default-features = false, features = ["egui"] }
+# driver. Same craft-libs revision as craft-update above.
+craft-window = { version = "0.1.0", git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4", default-features = false, features = ["egui"] }
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
diff --git a/apps/gridcraft/Cargo.toml b/apps/gridcraft/Cargo.toml
index 52b577cc5..61d197d7d 100644
--- a/apps/gridcraft/Cargo.toml
+++ b/apps/gridcraft/Cargo.toml
@@ -28,7 +28,9 @@ winresource = "0.1"
 winit = { version = "0.30", default-features = false, features = ["x11"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-craft-print = { git = "https://github.com/storytold/craft-libs", rev = "25da1314d443171b4adeaad2cd9454b273f35c6f" }
+# Same craft-libs revision as the workspace's craft-update and craft-window (see the root
+# Cargo.toml): the head of storytold/craft-libs#340 on the aiongg fork.
+craft-print = { git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4" }
 craft-update = { workspace = true }
 rfd = { workspace = true }
 arboard = { workspace = true }
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index 1c3531db3..33c967b84 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -9,9 +9,10 @@ description = "GridCraft egui frontend (Excel-style UI); swappable — nothing b
 workspace = true
 
 [dependencies]
-# The shared capture slot (`craft_ui::capture`) comes from the same reviewed immutable
-# craft-libs revision as the desktop's craft-print dependency.
-craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "25da1314d443171b4adeaad2cd9454b273f35c6f" }
+# The shared capture slot (`craft_ui::capture`) comes from the one craft-libs revision every
+# craft-libs dependency uses (see the root Cargo.toml): the head of storytold/craft-libs#340 on
+# the aiongg fork, repinned to storytold/craft-libs main once #340 merges.
+craft-ui = { git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4" }
 gridcraft-engine = { workspace = true }
 gridcraft-chart = { workspace = true }
 # `monochrome_emoji_fonts` restores the Noto Emoji and emoji-icon faces that 0.37 moved behind

From 7085aa1c472ab287c7da43f84e4053ca14888cc0 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 02:45:24 +0000
Subject: [PATCH 15/76] G3: build on current main

Screenshots are admitted in logic for the root viewport and issued from its pass, so nothing
reads the focused native window any more; the field goes.
---
 crates/ui-egui/src/doc_windows.rs | 2 --
 crates/ui-egui/src/lib.rs         | 3 ---
 2 files changed, 5 deletions(-)

diff --git a/crates/ui-egui/src/doc_windows.rs b/crates/ui-egui/src/doc_windows.rs
index 88ba3967a..bc4ad064e 100644
--- a/crates/ui-egui/src/doc_windows.rs
+++ b/crates/ui-egui/src/doc_windows.rs
@@ -141,7 +141,6 @@ impl DocWindows {
         let ctx = ui.ctx().clone();
         self.sync(app, &ctx);
         let focused = self.list.active().and_then(|id| self.list.get(id).copied());
-        app.focus_window = focused;
         let titles: std::collections::HashMap<u64, String> = self.list.iter().map(|(_, w)| (*w, window_title(app, *w))).collect();
         let base = &self.base;
         // The window a command run in some window's UI activated (File › New, Switch Windows, a close).
@@ -189,7 +188,6 @@ impl DocWindows {
             app.enter_window(target);
         }
         self.sync(app, &ctx);
-        app.focus_window = self.list.active().and_then(|id| self.list.get(id).copied());
     }
 
     /// A window's close button. Returns the window to bring forward when the close needs an
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 53bb7a95d..9f163d052 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -374,8 +374,6 @@ pub struct SheetApp {
     /// tests, embedding hosts) one window shows the active workbook window, and its close button
     /// quits.
     pub native_windows: bool,
-    /// The native window that has focus, which menu commands and screenshots go to.
-    pub(crate) focus_window: Option<u64>,
     /// The update check, the startup prompt and a running self-update (desktop only).
     #[cfg(not(target_arch = "wasm32"))]
     updates_rt: updates_ui::Runtime,
@@ -436,7 +434,6 @@ impl SheetApp {
             ui_window: None,
             parked: HashMap::new(),
             native_windows: false,
-            focus_window: None,
             #[cfg(not(target_arch = "wasm32"))]
             updates_rt: Default::default(),
         }

From 5900247075248464cb1a9439bc0408353de9b162 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 02:56:59 +0000
Subject: [PATCH 16/76] =?UTF-8?q?G1:=20Switch=20Windows=20draws=20its=20ch?=
 =?UTF-8?q?eck=20with=20the=20chrome=20fallback=20when=20no=20face=20has?=
 =?UTF-8?q?=20=E2=9C=93?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 crates/ui-egui/src/ribbon.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index a3c3b69f3..cb1573c1f 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -2605,7 +2605,7 @@ fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
     let forced = std::mem::take(&mut app.open_switch_windows);
     egui::Popup::menu(&anchor).open_memory(popup_command(forced, anchor.clicked())).show(|ui| {
         for w in app.open_windows() {
-            let label = format!("{}{}", if w.active { "✓ " } else { "    " }, w.label());
+            let label = theme::available_text(ui, &format!("{}{}", if w.active { "✓ " } else { "    " }, w.label()));
             if ui.add(egui::Button::selectable(w.active, label).min_size(vec2(220.0, 22.0))).clicked() {
                 act(app, "view.switchWindows", json!({"doc": w.doc}));
                 ui.close();

From 320bcfcf54565d6be797f87a3762bff0ac96030c Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 03:16:42 +0000
Subject: [PATCH 17/76] G1: regenerate the key tip tests

---
 crates/ui-egui/tests/it/keytips_generated.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/ui-egui/tests/it/keytips_generated.rs b/crates/ui-egui/tests/it/keytips_generated.rs
index 60368239a..498c1a5d8 100644
--- a/crates/ui-egui/tests/it/keytips_generated.rs
+++ b/crates/ui-egui/tests/it/keytips_generated.rs
@@ -2647,7 +2647,7 @@ fn keytip_wvr_() {
 fn keytip_ww_() {
     let mut h = harness(blank());
     sequence(&mut h, "WW", false);
-    assert!(h.state().message.is_none() && h.state().toast.is_none(), "WW must run view.switchWindows cleanly");
+    assert!(h.state().session.journal.iter().any(|(id, _)| id == "view.switchWindows"), "WW must journal view.switchWindows");
 }
 
 #[test]

From c7911c836a650c60afa5af6a2b5f7275195fb9a2 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 03:28:46 +0000
Subject: [PATCH 18/76] G3: craft-libs at storytold main b926b5c0

---
 Cargo.lock                | 12 ++++++------
 Cargo.toml                |  7 +++----
 apps/gridcraft/Cargo.toml |  4 ++--
 crates/ui-egui/Cargo.toml |  5 ++---
 4 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 21b2f04dc..53b2326da 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -889,12 +889,12 @@ dependencies = [
 [[package]]
 name = "craft-fonts-build"
 version = "0.1.0"
-source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
 
 [[package]]
 name = "craft-i18n"
 version = "0.1.0"
-source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
 dependencies = [
  "fixed_decimal",
  "icu_decimal",
@@ -917,7 +917,7 @@ dependencies = [
 [[package]]
 name = "craft-print"
 version = "0.1.0"
-source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
 dependencies = [
  "craft-winprint-gdi",
  "miniz_oxide 0.9.1",
@@ -930,7 +930,7 @@ dependencies = [
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
-source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
 dependencies = [
  "craft-fonts-build",
  "craft-i18n",
@@ -950,7 +950,7 @@ dependencies = [
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
 dependencies = [
  "chrono",
  "dunce",
@@ -975,7 +975,7 @@ dependencies = [
 [[package]]
 name = "craft-window"
 version = "0.1.0"
-source = "git+https://github.com/aiongg/craft-libs?rev=e8b4dde5137fe41823326b55018c31302218d3a4#e8b4dde5137fe41823326b55018c31302218d3a4"
+source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
 dependencies = [
  "egui",
  "objc2 0.6.5",
diff --git a/Cargo.toml b/Cargo.toml
index 451106ae8..e23c106e6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,9 +25,8 @@ gridcraft-ui-egui = { path = "crates/ui-egui" }
 gridcraft-mcp = { path = "crates/mcp" }
 gridcraft-pdf = { path = "crates/pdf" }
 # Every craft-libs crate (craft-update and craft-window here, craft-ui in ui-egui, craft-print in
-# the app) comes from one craft-libs revision: the head of storytold/craft-libs#340 on the aiongg
-# fork. They repin to storytold/craft-libs main once #340 merges.
-craft-update = { git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4", version = "=0.1.0", features = ["egui"] }
+# the app) comes from one storytold/craft-libs revision.
+craft-update = { git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7", version = "=0.1.0", features = ["egui"] }
 
 # foundation
 thiserror = "2"
@@ -62,7 +61,7 @@ skrifa = { version = "0.44", default-features = false, features = ["std"] }
 epaint_default_fonts = "0.37"
 # One native window per workbook: the window list, Window menu titles and the immediate-viewport
 # driver. Same craft-libs revision as craft-update above.
-craft-window = { version = "0.1.0", git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4", default-features = false, features = ["egui"] }
+craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7", default-features = false, features = ["egui"] }
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
diff --git a/apps/gridcraft/Cargo.toml b/apps/gridcraft/Cargo.toml
index 61d197d7d..8429070b7 100644
--- a/apps/gridcraft/Cargo.toml
+++ b/apps/gridcraft/Cargo.toml
@@ -29,8 +29,8 @@ winit = { version = "0.30", default-features = false, features = ["x11"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Same craft-libs revision as the workspace's craft-update and craft-window (see the root
-# Cargo.toml): the head of storytold/craft-libs#340 on the aiongg fork.
-craft-print = { git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4" }
+# Cargo.toml).
+craft-print = { git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7" }
 craft-update = { workspace = true }
 rfd = { workspace = true }
 arboard = { workspace = true }
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index 33c967b84..ac1a67c33 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -10,9 +10,8 @@ workspace = true
 
 [dependencies]
 # The shared capture slot (`craft_ui::capture`) comes from the one craft-libs revision every
-# craft-libs dependency uses (see the root Cargo.toml): the head of storytold/craft-libs#340 on
-# the aiongg fork, repinned to storytold/craft-libs main once #340 merges.
-craft-ui = { git = "https://github.com/aiongg/craft-libs", rev = "e8b4dde5137fe41823326b55018c31302218d3a4" }
+# craft-libs dependency uses (see the root Cargo.toml).
+craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7" }
 gridcraft-engine = { workspace = true }
 gridcraft-chart = { workspace = true }
 # `monochrome_emoji_fonts` restores the Noto Emoji and emoji-icon faces that 0.37 moved behind

From 380be36ac30bafb0d76fb3350e6c863d26f3320b Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 03:33:34 +0000
Subject: [PATCH 19/76] G1: the W, W key tip opens Switch Windows through its
 control

---
 crates/ui-egui/src/keytips/keytip_table/generated.rs | 2 +-
 crates/ui-egui/src/keytips/keytips.json              | 2 +-
 crates/ui-egui/src/ribbon.rs                         | 2 +-
 crates/ui-egui/tests/it/keytips_generated.rs         | 3 ++-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/ui-egui/src/keytips/keytip_table/generated.rs b/crates/ui-egui/src/keytips/keytip_table/generated.rs
index c35a3bbad..ef0011861 100644
--- a/crates/ui-egui/src/keytips/keytip_table/generated.rs
+++ b/crates/ui-egui/src/keytips/keytip_table/generated.rs
@@ -356,7 +356,7 @@ pub const SEQUENCES: &[(&str, Entry)] = &[
     ("WVH", Entry::Finish(Action::Command("view.headings"))),       // Excel: Toggle Headings; containment(Headings)
     ("WVN", Entry::Finish(Action::Pending("view.navigation"))),     // pending; Excel: Navigation; Navigation pane; reserved until the command lands
     ("WVR", Entry::Finish(Action::Command("view.ruler"))),          // Excel: Ruler
-    ("WW", Entry::Finish(Action::Command("view.switchWindows"))),   // Excel: Switch Windows
+    ("WW", Entry::Finish(Action::Control("view.switchWindows"))),   // Excel: Switch Windows
     ("JAM", Entry::Finish(Action::Command("chart.formatSelection"))), // Excel: Chart format: Format Selection pane; containment(Format Selection)
     ("JCA", Entry::Finish(Action::Command("chart.addElement"))),    // Excel: Chart: Add Chart Element; containment(Add Chart Element)
     ("JCC", Entry::Finish(Action::Command("chart.changeType"))),    // Excel: Chart: Change Chart Type; containment(Change Chart Type)
diff --git a/crates/ui-egui/src/keytips/keytips.json b/crates/ui-egui/src/keytips/keytips.json
index 5be64f867..f0e2c8f99 100644
--- a/crates/ui-egui/src/keytips/keytips.json
+++ b/crates/ui-egui/src/keytips/keytips.json
@@ -2471,7 +2471,7 @@
   },
   {
    "seq": "WW",
-   "kind": "command",
+   "kind": "control",
    "target": "view.switchWindows",
    "excel": "Switch Windows",
    "note": ""
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index cb1573c1f..673cb6b3b 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -2602,7 +2602,7 @@ fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
     let anchor = big_button(ui, Icon::Book, "Switch\nWindows", "Switch Windows", true);
     anchor.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Switch Windows"));
     control_keytip(app, ui, &anchor, "view.switchWindows");
-    let forced = std::mem::take(&mut app.open_switch_windows);
+    let forced = std::mem::take(&mut app.open_switch_windows) | invoke(app, "view.switchWindows");
     egui::Popup::menu(&anchor).open_memory(popup_command(forced, anchor.clicked())).show(|ui| {
         for w in app.open_windows() {
             let label = theme::available_text(ui, &format!("{}{}", if w.active { "✓ " } else { "    " }, w.label()));
diff --git a/crates/ui-egui/tests/it/keytips_generated.rs b/crates/ui-egui/tests/it/keytips_generated.rs
index 498c1a5d8..a22fabc98 100644
--- a/crates/ui-egui/tests/it/keytips_generated.rs
+++ b/crates/ui-egui/tests/it/keytips_generated.rs
@@ -2647,7 +2647,8 @@ fn keytip_wvr_() {
 fn keytip_ww_() {
     let mut h = harness(blank());
     sequence(&mut h, "WW", false);
-    assert!(h.state().session.journal.iter().any(|(id, _)| id == "view.switchWindows"), "WW must journal view.switchWindows");
+    assert!(h.state().message.is_none() && h.state().toast.is_none(), "WW must route to its control without an error box");
+    assert_eq!(h.state().keytips.prefix(), None);
 }
 
 #[test]

From d8c5f5885fc5320f8f1023d5fdc9f484a185ba86 Mon Sep 17 00:00:00 2001
From: "Dylan M. Taylor" <dylan@dylanmtaylor.com>
Date: Mon, 26 Oct 2026 09:48:03 -0400
Subject: [PATCH 20/76] refactor: reduce cognitive complexity in options,
 python highlighter, i18n scanner, loop search (#2611)

* refactor: split complex functions for Sonar S3776

Extract helpers from backstage options (general, calculation and iteration
sections), code_editor python (string scanning), xtask i18n literals
(escape and string readers) and calc recalc loops_among (SCC search).
No behaviour change.

* Restore the loop count that loops_among's refactor dropped

The S3776 split moved the loop-detection body into loops_among without
the 'let n = circ.len()' it reads, so calc failed to compile and the
Sonar build broke. Restore the binding from main.

* Extract the SCC pop step from components() to reduce cognitive complexity (S3776)

Generated with Codebuff
Co-Authored-By: Codebuff <noreply@codebuff.com>

---------

Co-authored-by: Codebuff <noreply@codebuff.com>
---
 crates/calc/src/recalc.rs         | 120 +++++++++++++++++-------------
 crates/ui-egui/src/backstage.rs   |  65 +++++++++-------
 crates/ui-egui/src/code_editor.rs |  49 ++++++------
 xtask/src/i18n_report.rs          |  88 ++++++++++++----------
 4 files changed, 184 insertions(+), 138 deletions(-)

diff --git a/crates/calc/src/recalc.rs b/crates/calc/src/recalc.rs
index 4cbbcc8b4..17a0e6649 100644
--- a/crates/calc/src/recalc.rs
+++ b/crates/calc/src/recalc.rs
@@ -927,6 +927,70 @@ impl Host for PassHost<'_> {
     }
 }
 
+/// Pops one finished component off Tarjan's stack, labelling its nodes with `comp_index`. The
+/// component is everything up to and including `root`.
+fn pop_component(stack: &mut Vec<usize>, on_stack: &mut [bool], comp: &mut [usize], comp_index: usize, root: usize) {
+    while let Some(w) = stack.pop() {
+        on_stack[w] = false;
+        comp[w] = comp_index;
+        if w == root {
+            break;
+        }
+    }
+}
+
+/// Strongly connected components of a graph given as adjacency lists (Tarjan, iterative): each
+/// node's component index, and the number of nodes in each component.
+fn components(edges: &[Vec<usize>]) -> (Vec<usize>, Vec<usize>) {
+    let n = edges.len();
+    let (mut low, mut num) = (vec![0usize; n], vec![usize::MAX; n]);
+    let (mut on_stack, mut stack, mut comp) = (vec![false; n], Vec::new(), vec![usize::MAX; n]);
+    let (mut next, mut comps) = (0usize, 0usize);
+    for root in 0..n {
+        if num[root] != usize::MAX {
+            continue;
+        }
+        let mut call: Vec<(usize, usize)> = vec![(root, 0)];
+        num[root] = next;
+        low[root] = next;
+        next += 1;
+        stack.push(root);
+        on_stack[root] = true;
+        while let Some(top) = call.last_mut() {
+            let v = top.0;
+            if let Some(&w) = edges.get(v).and_then(|e| e.get(top.1)) {
+                top.1 += 1;
+                if num[w] == usize::MAX {
+                    num[w] = next;
+                    low[w] = next;
+                    next += 1;
+                    stack.push(w);
+                    on_stack[w] = true;
+                    call.push((w, 0));
+                } else if on_stack[w] {
+                    low[v] = low[v].min(num[w]);
+                }
+                continue;
+            }
+            call.pop();
+            if let Some(&(u, _)) = call.last() {
+                low[u] = low[u].min(low[v]);
+            }
+            if low[v] == num[v] {
+                pop_component(&mut stack, &mut on_stack, &mut comp, comps, v);
+                comps += 1;
+            }
+        }
+    }
+    let mut size = vec![0usize; comps];
+    for &c in &comp {
+        if let Some(s) = size.get_mut(c) {
+            *s += 1;
+        }
+    }
+    (comp, size)
+}
+
 impl Calc {
     pub fn new() -> Self {
         Self::default()
@@ -967,6 +1031,7 @@ impl Calc {
         if circ.is_empty() {
             return Vec::new();
         }
+        let n = circ.len();
         let index: HashMap<Key, usize> = circ.iter().enumerate().map(|(i, k)| (*k, i)).collect();
         // Edges from a cell to the `#CIRC!` formulas that read it; loops are the same either way.
         let mut deps = Vec::new();
@@ -981,59 +1046,8 @@ impl Calc {
                 e
             })
             .collect();
-        // Tarjan's strongly connected components, iterative.
-        let n = circ.len();
-        let (mut low, mut num) = (vec![0usize; n], vec![usize::MAX; n]);
-        let (mut on_stack, mut stack, mut comp) = (vec![false; n], Vec::new(), vec![usize::MAX; n]);
-        let (mut next, mut comps) = (0usize, 0usize);
-        for root in 0..n {
-            if num[root] != usize::MAX {
-                continue;
-            }
-            let mut call: Vec<(usize, usize)> = vec![(root, 0)];
-            num[root] = next;
-            low[root] = next;
-            next += 1;
-            stack.push(root);
-            on_stack[root] = true;
-            while let Some(top) = call.last_mut() {
-                let v = top.0;
-                if let Some(&w) = edges.get(v).and_then(|e| e.get(top.1)) {
-                    top.1 += 1;
-                    if num[w] == usize::MAX {
-                        num[w] = next;
-                        low[w] = next;
-                        next += 1;
-                        stack.push(w);
-                        on_stack[w] = true;
-                        call.push((w, 0));
-                    } else if on_stack[w] {
-                        low[v] = low[v].min(num[w]);
-                    }
-                    continue;
-                }
-                call.pop();
-                if let Some(&(u, _)) = call.last() {
-                    low[u] = low[u].min(low[v]);
-                }
-                if low[v] == num[v] {
-                    while let Some(w) = stack.pop() {
-                        on_stack[w] = false;
-                        comp[w] = comps;
-                        if w == v {
-                            break;
-                        }
-                    }
-                    comps += 1;
-                }
-            }
-        }
-        let mut size = vec![0usize; comps];
-        for &c in &comp {
-            if let Some(s) = size.get_mut(c) {
-                *s += 1;
-            }
-        }
+        // Loop members: nodes in a component of more than one, or with an edge to themselves.
+        let (comp, size) = components(&edges);
         let on_loop = |i: usize| comp.get(i).and_then(|c| size.get(*c)).is_some_and(|s| *s > 1) || edges.get(i).is_some_and(|e| e.contains(&i));
         // A formula with dynamic references (INDIRECT, OFFSET) may close a loop the graph can't see.
         let mut out: Vec<Key> =
diff --git a/crates/ui-egui/src/backstage.rs b/crates/ui-egui/src/backstage.rs
index ec097c201..f17d476ef 100644
--- a/crates/ui-egui/src/backstage.rs
+++ b/crates/ui-egui/src/backstage.rs
@@ -957,6 +957,35 @@ pub fn export_as(app: &mut SheetApp, fmt: &str) -> bool {
 fn options(app: &mut SheetApp, ui: &mut Ui) {
     let lang = app.ui.language;
     section(ui, lang, "Options|General");
+    general_options(app, ui, lang);
+    ui.add_space(6.0);
+    let mut formula_bar = app.session.prefs.formula_bar;
+    if ui.checkbox(&mut formula_bar, lang.tr("Show formula bar")).changed() {
+        app.run_or_alert("view.formulaBar", json!({"on": formula_bar}));
+    }
+    ui.add_space(18.0);
+    section(ui, lang, "Options|Editing");
+    let mut autocomplete = app.ui.autocomplete;
+    if ui.checkbox(&mut autocomplete, lang.tr("Enable AutoComplete for cell values")).changed() {
+        app.run_or_alert("options.autoComplete", json!({"on": autocomplete}));
+    }
+    ui.add_space(18.0);
+    section(ui, lang, "Options|Save");
+    let mut autosave = app.ui.autosave;
+    if ui.checkbox(&mut autosave, lang.tr("Save .xlsx workbooks automatically after every change")).changed() {
+        app.toggle_autosave();
+    }
+    let Some(calc) = app.session.active().map(|d| d.wb.calc.clone()) else { return };
+    ui.add_space(18.0);
+    section(ui, lang, "Formulas");
+    ui.label(lang.tr("Workbook calculation"));
+    calc_options(app, ui, lang, &calc);
+    ui.add_space(6.0);
+    dim(ui, lang.tr("Calculation settings are saved with the workbook."));
+}
+
+/// The display theme and interface language controls of the General section.
+fn general_options(app: &mut SheetApp, ui: &mut Ui, lang: Language) {
     egui::Grid::new("backstage_options_general").num_columns(2).spacing(vec2(18.0, 10.0)).show(ui, |ui| {
         let label = ui.label(lang.tr("Display theme"));
         let mode = app.ui.theme_mode();
@@ -993,27 +1022,10 @@ fn options(app: &mut SheetApp, ui: &mut Ui) {
             .labelled_by(label.id);
         ui.end_row();
     });
-    ui.add_space(6.0);
-    let mut formula_bar = app.session.prefs.formula_bar;
-    if ui.checkbox(&mut formula_bar, lang.tr("Show formula bar")).changed() {
-        app.run_or_alert("view.formulaBar", json!({"on": formula_bar}));
-    }
-    ui.add_space(18.0);
-    section(ui, lang, "Options|Editing");
-    let mut autocomplete = app.ui.autocomplete;
-    if ui.checkbox(&mut autocomplete, lang.tr("Enable AutoComplete for cell values")).changed() {
-        app.run_or_alert("options.autoComplete", json!({"on": autocomplete}));
-    }
-    ui.add_space(18.0);
-    section(ui, lang, "Options|Save");
-    let mut autosave = app.ui.autosave;
-    if ui.checkbox(&mut autosave, lang.tr("Save .xlsx workbooks automatically after every change")).changed() {
-        app.toggle_autosave();
-    }
-    let Some(calc) = app.session.active().map(|d| d.wb.calc.clone()) else { return };
-    ui.add_space(18.0);
-    section(ui, lang, "Formulas");
-    ui.label(lang.tr("Workbook calculation"));
+}
+
+/// The calculation mode, and iterative calculation, of the active workbook.
+fn calc_options(app: &mut SheetApp, ui: &mut Ui, lang: Language, calc: &gridcraft_engine::model::CalcSettings) {
     use gridcraft_engine::model::CalcMode;
     for (mode, id, label) in [
         (CalcMode::Automatic, "automatic", "Automatic"),
@@ -1030,6 +1042,13 @@ fn options(app: &mut SheetApp, ui: &mut Ui) {
         app.run_or_alert("formulas.calculationOptions", json!({"iterative": iterative}));
     }
     // Maximum Iterations and Maximum Change apply only while iteration is on, as in Excel.
+    iteration_options(app, ui, lang, calc, iterative);
+    // TODO: add "Set precision as displayed" here once `formulas.calculationOptions` takes
+    // `precisionAsDisplayed` (PR #1366); the model already stores it.
+}
+
+/// Maximum Iterations and Maximum Change, live only while iterative calculation is on.
+fn iteration_options(app: &mut SheetApp, ui: &mut Ui, lang: Language, calc: &gridcraft_engine::model::CalcSettings, iterative: bool) {
     ui.add_enabled_ui(iterative, |ui| {
         ui.horizontal(|ui| {
             ui.add_space(24.0);
@@ -1070,10 +1089,6 @@ fn options(app: &mut SheetApp, ui: &mut Ui) {
             });
         });
     });
-    // TODO: add "Set precision as displayed" here once `formulas.calculationOptions` takes
-    // `precisionAsDisplayed` (PR #1366); the model already stores it.
-    ui.add_space(6.0);
-    dim(ui, lang.tr("Calculation settings are saved with the workbook."));
 }
 
 /// Refuses a typed setting with a message, leaving the workbook as it was. The Enter that
diff --git a/crates/ui-egui/src/code_editor.rs b/crates/ui-egui/src/code_editor.rs
index 6f02b4044..e462e46ef 100644
--- a/crates/ui-egui/src/code_editor.rs
+++ b/crates/ui-egui/src/code_editor.rs
@@ -78,6 +78,32 @@ pub fn highlight(text: &str, lang: Lang) -> Vec<(Range<usize>, Token)> {
     }
 }
 
+/// End (exclusive, in chars) of the Python string literal opening with quote `c` at char `i`.
+fn python_string_end(chars: &[(usize, char)], i: usize, c: char) -> usize {
+    let triple = chars.get(i + 1).is_some_and(|(_, d)| *d == c) && chars.get(i + 2).is_some_and(|(_, d)| *d == c);
+    let mut j = if triple { i + 3 } else { i + 1 };
+    loop {
+        match chars.get(j) {
+            None => break,
+            Some((_, '\\')) => j += 2,
+            Some((_, '\n')) if !triple => break,
+            Some((_, d)) if *d == c => {
+                if !triple {
+                    j += 1;
+                    break;
+                }
+                if chars.get(j + 1).is_some_and(|(_, d)| *d == c) && chars.get(j + 2).is_some_and(|(_, d)| *d == c) {
+                    j += 3;
+                    break;
+                }
+                j += 1;
+            }
+            Some(_) => j += 1,
+        }
+    }
+    j.min(chars.len())
+}
+
 fn python(text: &str) -> Vec<(Range<usize>, Token)> {
     let chars: Vec<(usize, char)> = text.char_indices().collect();
     let end_of = |i: usize| chars.get(i).map(|(b, _)| *b).unwrap_or(text.len());
@@ -92,28 +118,7 @@ fn python(text: &str) -> Vec<(Range<usize>, Token)> {
             out.push((start..end_of(j), Token::Comment));
             i = j;
         } else if c == '"' || c == '\'' {
-            let triple = chars.get(i + 1).is_some_and(|(_, d)| *d == c) && chars.get(i + 2).is_some_and(|(_, d)| *d == c);
-            let mut j = if triple { i + 3 } else { i + 1 };
-            loop {
-                match chars.get(j) {
-                    None => break,
-                    Some((_, '\\')) => j += 2,
-                    Some((_, '\n')) if !triple => break,
-                    Some((_, d)) if *d == c => {
-                        if !triple {
-                            j += 1;
-                            break;
-                        }
-                        if chars.get(j + 1).is_some_and(|(_, d)| *d == c) && chars.get(j + 2).is_some_and(|(_, d)| *d == c) {
-                            j += 3;
-                            break;
-                        }
-                        j += 1;
-                    }
-                    Some(_) => j += 1,
-                }
-            }
-            let j = j.min(chars.len());
+            let j = python_string_end(&chars, i, c);
             out.push((start..end_of(j), Token::String));
             i = j;
         } else if c.is_ascii_digit() || (c == '.' && chars.get(i + 1).is_some_and(|(_, d)| d.is_ascii_digit())) {
diff --git a/xtask/src/i18n_report.rs b/xtask/src/i18n_report.rs
index 344ed7569..99cbaa9ee 100644
--- a/xtask/src/i18n_report.rs
+++ b/xtask/src/i18n_report.rs
@@ -116,6 +116,55 @@ pub fn catalog_keys(source: &str) -> BTreeSet<String> {
     keys
 }
 
+/// The character a `\u{...}` escape stands for, if it names a valid code point.
+fn unicode_escape(chars: &mut std::iter::Peekable<std::str::CharIndices<'_>>) -> Option<char> {
+    let mut hex = String::new();
+    for (_, c) in chars.by_ref() {
+        match c {
+            '}' => break,
+            '{' => {}
+            c => hex.push(c),
+        }
+    }
+    u32::from_str_radix(&hex, 16).ok().and_then(char::from_u32)
+}
+
+/// The value of a string literal whose opening quote was just read, and the byte offset past
+/// its closing quote (`len`, the source's length, when it is never closed).
+fn string_literal(chars: &mut std::iter::Peekable<std::str::CharIndices<'_>>, len: usize) -> (String, usize) {
+    let mut value = String::new();
+    let mut end = len;
+    while let Some((j, c)) = chars.next() {
+        match c {
+            '"' => {
+                end = j + 1;
+                break;
+            }
+            '\\' => match chars.next().map(|(_, c)| c) {
+                Some('n') => value.push('\n'),
+                Some('t') => value.push('\t'),
+                Some('r') => value.push('\r'),
+                Some('0') => value.push('\0'),
+                Some(c @ ('\\' | '"' | '\'')) => value.push(c),
+                Some('u') => {
+                    if let Some(c) = unicode_escape(chars) {
+                        value.push(c);
+                    }
+                }
+                // A line continuation skips the newline and the next line's indentation.
+                Some('\n') => {
+                    while chars.peek().is_some_and(|(_, c)| c.is_whitespace()) {
+                        chars.next();
+                    }
+                }
+                _ => {}
+            },
+            c => value.push(c),
+        }
+    }
+    (value, end)
+}
+
 /// Every string literal outside `//` comments: its decoded value, and the byte range from its
 /// opening quote to just past its closing one.
 fn literals(source: &str) -> Vec<(String, usize, usize)> {
@@ -133,44 +182,7 @@ fn literals(source: &str) -> Vec<(String, usize, usize)> {
         if c != '"' {
             continue;
         }
-        let mut value = String::new();
-        let mut end = source.len();
-        while let Some((j, c)) = chars.next() {
-            match c {
-                '"' => {
-                    end = j + 1;
-                    break;
-                }
-                '\\' => match chars.next().map(|(_, c)| c) {
-                    Some('n') => value.push('\n'),
-                    Some('t') => value.push('\t'),
-                    Some('r') => value.push('\r'),
-                    Some('0') => value.push('\0'),
-                    Some(c @ ('\\' | '"' | '\'')) => value.push(c),
-                    Some('u') => {
-                        let mut hex = String::new();
-                        for (_, c) in chars.by_ref() {
-                            match c {
-                                '}' => break,
-                                '{' => {}
-                                c => hex.push(c),
-                            }
-                        }
-                        if let Some(c) = u32::from_str_radix(&hex, 16).ok().and_then(char::from_u32) {
-                            value.push(c);
-                        }
-                    }
-                    // A line continuation skips the newline and the next line's indentation.
-                    Some('\n') => {
-                        while chars.peek().is_some_and(|(_, c)| c.is_whitespace()) {
-                            chars.next();
-                        }
-                    }
-                    _ => {}
-                },
-                c => value.push(c),
-            }
-        }
+        let (value, end) = string_literal(&mut chars, source.len());
         out.push((value, i, end));
     }
     out

From e95c29b1fe89e5cf56a5fdce6b1c908ab46ff261 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:25 +0000
Subject: [PATCH 21/76] refactor(engine): move crates/engine/src/cmd/mod.rs to
 crates/engine/src/cmd.rs

---
 crates/engine/src/{cmd/mod.rs => cmd.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/engine/src/{cmd/mod.rs => cmd.rs} (100%)

diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd.rs
similarity index 100%
rename from crates/engine/src/cmd/mod.rs
rename to crates/engine/src/cmd.rs

From 24a18620d29806e5ec2b8417c1b40862ee7d533e Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:26 +0000
Subject: [PATCH 22/76] refactor(xlsx): move crates/xlsx/src/xls/mod.rs to
 crates/xlsx/src/xls.rs

---
 crates/xlsx/src/{xls/mod.rs => xls.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/xlsx/src/{xls/mod.rs => xls.rs} (100%)

diff --git a/crates/xlsx/src/xls/mod.rs b/crates/xlsx/src/xls.rs
similarity index 100%
rename from crates/xlsx/src/xls/mod.rs
rename to crates/xlsx/src/xls.rs

From b3e2a6a2be001e033296cb08dcac0b151efdcffe Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:26 +0000
Subject: [PATCH 23/76] refactor(xlsx): move crates/xlsx/src/tests/mod.rs to
 crates/xlsx/src/tests.rs

---
 crates/xlsx/src/{tests/mod.rs => tests.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename crates/xlsx/src/{tests/mod.rs => tests.rs} (100%)

diff --git a/crates/xlsx/src/tests/mod.rs b/crates/xlsx/src/tests.rs
similarity index 100%
rename from crates/xlsx/src/tests/mod.rs
rename to crates/xlsx/src/tests.rs

From 58e33dfef69cefa1a75e4e1523914ce92a3dff3a Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:32 +0000
Subject: [PATCH 24/76] refactor(gridcraft): move logging tests to
 logging/tests.rs

---
 apps/gridcraft/src/logging.rs       | 301 +---------------------------
 apps/gridcraft/src/logging/tests.rs | 298 +++++++++++++++++++++++++++
 2 files changed, 299 insertions(+), 300 deletions(-)
 create mode 100644 apps/gridcraft/src/logging/tests.rs

diff --git a/apps/gridcraft/src/logging.rs b/apps/gridcraft/src/logging.rs
index a0f62d164..413797378 100644
--- a/apps/gridcraft/src/logging.rs
+++ b/apps/gridcraft/src/logging.rs
@@ -295,303 +295,4 @@ pub fn install() -> Option<&'static AppLogger> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    use std::time::{Duration, UNIX_EPOCH};
-
-    fn temp_dir(tag: &str) -> PathBuf {
-        static N: AtomicUsize = AtomicUsize::new(0);
-        let d = std::env::temp_dir().join(format!("gridcraft-logging-{tag}-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
-        let _ = std::fs::remove_dir_all(&d);
-        d
-    }
-
-    fn read(path: &Path) -> String {
-        std::fs::read_to_string(path).expect("read log")
-    }
-
-    fn record(logger: &AppLogger, level: log::Level, target: &str, msg: &str) {
-        use log::Log;
-        logger.log(&log::Record::builder().level(level).target(target).args(format_args!("{msg}")).build());
-    }
-
-    #[test]
-    fn the_default_filter_shows_gridcraft_info_and_other_crates_warnings() {
-        let f = Filter::parse(DEFAULT_FILTER);
-        assert_eq!(f.level_for("gridcraft"), LevelFilter::Info);
-        assert_eq!(f.level_for("gridcraft::control_server"), LevelFilter::Info);
-        assert_eq!(f.level_for("gridcraft_engine::sample"), LevelFilter::Info);
-        assert_eq!(f.level_for("gridcraft_ui_egui::control"), LevelFilter::Info);
-        assert_eq!(f.level_for("wgpu_core::device"), LevelFilter::Warn);
-        assert_eq!(f.level_for("naga"), LevelFilter::Warn);
-        assert_eq!(f.max(), LevelFilter::Info);
-    }
-
-    #[test]
-    fn directives_follow_env_logger_and_the_most_specific_one_wins() {
-        let f = Filter::parse("info,wgpu_core=error,gridcraft_calc=trace,gridcraft_calc::recalc=off");
-        assert_eq!(f.level_for("eframe"), LevelFilter::Info);
-        assert_eq!(f.level_for("wgpu_core::instance"), LevelFilter::Error);
-        assert_eq!(f.level_for("gridcraft_calc::graph"), LevelFilter::Trace);
-        assert_eq!(f.level_for("gridcraft_calc::recalc"), LevelFilter::Off);
-        assert_eq!(f.max(), LevelFilter::Trace);
-        // A module name is matched at `::` boundaries, not as a bare prefix.
-        assert_eq!(f.level_for("wgpu_core_extra"), LevelFilter::Info);
-        // A trailing `*` is a prefix.
-        assert_eq!(Filter::parse("gridcraft*=debug").level_for("gridcraft_xlsx::read"), LevelFilter::Debug);
-        assert_eq!(Filter::parse("gridcraft*=debug").level_for("eframe"), LevelFilter::Error);
-        // A bare target name sets that target to the most verbose level, as env_logger does.
-        assert_eq!(Filter::parse("naga").level_for("naga::front"), LevelFilter::Trace);
-        assert_eq!(Filter::parse("naga").level_for("eframe"), LevelFilter::Error);
-        // Levels are case-insensitive and surrounding blanks are ignored.
-        assert_eq!(Filter::parse(" WARN , gridcraft = Debug ").level_for("gridcraft"), LevelFilter::Debug);
-        assert_eq!(Filter::parse(" WARN , gridcraft = Debug ").level_for("eframe"), LevelFilter::Warn);
-    }
-
-    #[test]
-    fn hostile_specs_never_panic_and_fall_back_sensibly() {
-        let long = "x".repeat(100_000);
-        let many = "a=info,".repeat(10_000);
-        for spec in [
-            "",
-            ",,,",
-            "=",
-            "==",
-            "=debug",
-            "gridcraft=",
-            "nonsense=loud",
-            "🦀=info",
-            "*",
-            "*=",
-            "=*",
-            "a=b=c",
-            "warn,,gridcraft=DEBUG",
-            "\0",
-            "é::ü=trace",
-            &long,
-            &many,
-        ] {
-            let f = Filter::parse(spec);
-            for target in ["", "gridcraft", "🦀", "a::b", "*"] {
-                let _ = f.level_for(target);
-            }
-            let _ = f.max();
-        }
-        assert_eq!(Filter::parse("warn,,gridcraft=DEBUG").level_for("gridcraft"), LevelFilter::Debug);
-        // An unknown level is skipped: that target keeps the default.
-        assert_eq!(Filter::parse("nonsense=loud").level_for("nonsense"), LevelFilter::Error);
-        assert_eq!(Filter::parse("gridcraft=").level_for("gridcraft"), LevelFilter::Error);
-        assert_eq!(Filter::parse("=debug").max(), LevelFilter::Error);
-        assert_eq!(Filter::parse("🦀=info").level_for("🦀::claw"), LevelFilter::Info);
-    }
-
-    #[test]
-    fn timestamps_are_utc_with_milliseconds() {
-        assert_eq!(timestamp(UNIX_EPOCH), "1970-01-01T00:00:00.000Z");
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_millis(1_791_446_357_728)), "2026-10-08T07:59:17.728Z");
-        // Leap day, and the day after it.
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_164_800)), "2024-02-29T00:00:00.000Z");
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_251_199)), "2024-02-29T23:59:59.000Z");
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_251_200)), "2024-03-01T00:00:00.000Z");
-        // 2000 is a leap year (divisible by 400), 2100 is not.
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(951_782_400)), "2000-02-29T00:00:00.000Z");
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(4_107_542_400)), "2100-03-01T00:00:00.000Z");
-        // Before the epoch (a clock set wrong) clamps instead of panicking.
-        assert_eq!(timestamp(UNIX_EPOCH - Duration::from_secs(5)), "1970-01-01T00:00:00.000Z");
-        // A clock set absurdly far ahead (past chrono's own range) keeps its real year rather than
-        // collapsing to the epoch. Windows' SystemTime can't hold such an instant, so it is built
-        // with a checked add and only asserted where it exists.
-        if let Some(far) = UNIX_EPOCH.checked_add(Duration::from_secs(u64::MAX / 2)) {
-            assert_eq!(timestamp(far), "292277026596-12-04T15:30:07.000Z");
-        }
-        if let Some(far) = UNIX_EPOCH.checked_add(Duration::from_secs(10_000_000_000_000)) {
-            assert_eq!(timestamp(far), "318857-05-20T17:46:40.000Z");
-        }
-        // Years past 9999 keep the plain zero-padded year (no `+`).
-        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(253_402_300_800)), "10000-01-01T00:00:00.000Z");
-    }
-
-    #[test]
-    fn a_line_carries_time_level_thread_target_and_message() {
-        assert_eq!(
-            format_line("2026-10-08T07:59:17.728Z", log::Level::Warn, "main", "gridcraft", "book.xlsx: file not found"),
-            "2026-10-08T07:59:17.728Z WARN  [main] gridcraft: book.xlsx: file not found\n"
-        );
-        // A multi-line message keeps its lines; the record still ends in one newline.
-        assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\nb\n"));
-    }
-
-    #[test]
-    fn rotation_keeps_the_previous_logs_and_starts_an_empty_file() {
-        let dir = temp_dir("rotate");
-        for run in 1..=4 {
-            let (path, _file) = rotate(&dir).expect("rotate");
-            assert_eq!(path, dir.join(LOG_FILE));
-            assert_eq!(read(&path), "");
-            std::fs::write(&path, format!("run {run}")).expect("write");
-        }
-        assert_eq!(read(&dir.join(LOG_FILE)), "run 4");
-        assert_eq!(read(&dir.join("gridcraft.1.log")), "run 3");
-        assert_eq!(read(&dir.join("gridcraft.2.log")), "run 2");
-        assert!(!dir.join("gridcraft.3.log").exists(), "only {KEEP} old logs are kept");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn rotation_into_an_unusable_directory_is_an_error_not_a_panic() {
-        let dir = temp_dir("blocked");
-        std::fs::create_dir_all(dir.parent().expect("parent")).expect("tmp");
-        std::fs::write(&dir, "a file where the directory should be").expect("block");
-        assert!(rotate(&dir).is_err());
-        let _ = std::fs::remove_file(&dir);
-    }
-
-    #[test]
-    fn lines_logged_before_the_file_exists_are_written_when_it_is_attached() {
-        let dir = temp_dir("pending");
-        let (path, file) = rotate(&dir).expect("rotate");
-        let mut sink = Sink::new(MAX_FILE_BYTES);
-        sink.write("early 1\n");
-        sink.write("early 2\n");
-        sink.attach(file);
-        sink.write("late\n");
-        assert_eq!(read(&path), "early 1\nearly 2\nlate\n");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn the_pending_buffer_is_bounded_and_says_how_much_it_dropped() {
-        let dir = temp_dir("bounded");
-        let (path, file) = rotate(&dir).expect("rotate");
-        let mut sink = Sink::new(MAX_FILE_BYTES);
-        for i in 0..MAX_PENDING + 5 {
-            sink.write(&format!("line {i}\n"));
-        }
-        sink.attach(file);
-        let text = read(&path);
-        assert_eq!(text.lines().filter(|l| l.starts_with("line ")).count(), MAX_PENDING);
-        assert!(text.contains("5 earlier log lines were dropped"), "{text}");
-        assert!(text.contains("line 0\n") && !text.contains(&format!("line {MAX_PENDING}\n")));
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn exactly_a_full_pending_buffer_drops_nothing() {
-        let dir = temp_dir("full");
-        let (path, file) = rotate(&dir).expect("rotate");
-        let mut sink = Sink::new(MAX_FILE_BYTES);
-        for i in 0..MAX_PENDING {
-            sink.write(&format!("line {i}\n"));
-        }
-        sink.attach(file);
-        let text = read(&path);
-        assert_eq!(text.lines().count(), MAX_PENDING);
-        assert!(!text.contains("dropped"), "{text}");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn without_a_file_nothing_is_kept_in_memory() {
-        let mut sink = Sink::new(MAX_FILE_BYTES);
-        sink.write("early\n");
-        sink.no_file();
-        sink.write("late\n");
-        assert!(sink.pending.is_empty() && sink.dropped == 0);
-    }
-
-    #[test]
-    fn the_file_stops_at_its_size_cap_with_one_note() {
-        let dir = temp_dir("cap");
-        let (path, file) = rotate(&dir).expect("rotate");
-        let mut sink = Sink::new(100);
-        sink.attach(file);
-        for i in 0..50 {
-            sink.write(&format!("line {i:02} with some padding\n"));
-        }
-        let text = read(&path);
-        assert_eq!(text.lines().filter(|l| l.starts_with("line ")).count(), 3, "{text}");
-        assert_eq!(text.matches("log file reached").count(), 1, "{text}");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn the_logger_filters_records_and_writes_them_to_the_attached_file() {
-        use log::Log;
-        let dir = temp_dir("logger");
-        let logger = AppLogger::new(Filter::parse(DEFAULT_FILTER), false);
-        record(&logger, log::Level::Info, "gridcraft", "before the settings directory");
-        record(&logger, log::Level::Info, "wgpu_core::device", "too chatty");
-        let path = logger.attach_dir(&dir).expect("attach");
-        assert_eq!(path, dir.join(LOG_FILE));
-        record(&logger, log::Level::Warn, "wgpu_hal::vulkan", "a real warning");
-        record(&logger, log::Level::Error, "gridcraft", "internal error: boom");
-        record(&logger, log::Level::Debug, "gridcraft", "below info");
-        let text = read(&path);
-        let lines: Vec<&str> = text.lines().collect();
-        assert_eq!(lines.len(), 3, "{text}");
-        assert!(lines[0].contains(" INFO  [") && lines[0].ends_with("gridcraft: before the settings directory"), "{text}");
-        assert!(lines[1].ends_with("wgpu_hal::vulkan: a real warning"), "{text}");
-        assert!(lines[2].contains(" ERROR [") && lines[2].ends_with("gridcraft: internal error: boom"), "{text}");
-        assert!(logger.enabled(&log::Metadata::builder().level(log::Level::Info).target("gridcraft_ui_egui").build()));
-        assert!(!logger.enabled(&log::Metadata::builder().level(log::Level::Info).target("naga").build()));
-        // Attaching again rotates: the first log becomes `.1`.
-        logger.attach_dir(&dir).expect("attach again");
-        assert_eq!(read(&dir.join("gridcraft.1.log")), text);
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn records_from_many_threads_are_whole_lines() {
-        let dir = temp_dir("threads");
-        let logger = std::sync::Arc::new(AppLogger::new(Filter::parse("info"), false));
-        let path = logger.attach_dir(&dir).expect("attach");
-        let workers: Vec<_> = (0..8)
-            .map(|t| {
-                let l = std::sync::Arc::clone(&logger);
-                std::thread::spawn(move || {
-                    for i in 0..100 {
-                        record(&l, log::Level::Info, "gridcraft", &format!("thread {t} record {i}"));
-                    }
-                })
-            })
-            .collect();
-        for w in workers {
-            w.join().expect("worker");
-        }
-        let text = read(&path);
-        assert_eq!(text.lines().count(), 800);
-        assert!(text.lines().all(|l| l.contains(" gridcraft: thread ")), "{text}");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn attaching_to_an_unusable_directory_reports_an_error_and_keeps_logging() {
-        let dir = temp_dir("unusable");
-        std::fs::create_dir_all(dir.parent().expect("parent")).expect("tmp");
-        std::fs::write(&dir, "not a directory").expect("block");
-        let logger = AppLogger::new(Filter::parse("info"), false);
-        assert!(logger.attach_dir(&dir).is_err());
-        record(&logger, log::Level::Error, "x", "still fine");
-        // Nothing waits in memory for a file that won't come.
-        assert!(logger.sink.lock().expect("sink").pending.is_empty());
-        let _ = std::fs::remove_file(&dir);
-    }
-
-    #[test]
-    fn a_poisoned_sink_still_logs() {
-        let dir = temp_dir("poison");
-        let logger = std::sync::Arc::new(AppLogger::new(Filter::parse("info"), false));
-        let l = std::sync::Arc::clone(&logger);
-        let _ = std::thread::spawn(move || {
-            let _guard = l.sink.lock().expect("lock");
-            panic!("poison the sink");
-        })
-        .join();
-        assert!(logger.sink.is_poisoned());
-        let path = logger.attach_dir(&dir).expect("attach");
-        record(&logger, log::Level::Warn, "gridcraft", "after the poison");
-        assert!(read(&path).contains("gridcraft: after the poison"));
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-}
+mod tests;
diff --git a/apps/gridcraft/src/logging/tests.rs b/apps/gridcraft/src/logging/tests.rs
new file mode 100644
index 000000000..bfc0f81a1
--- /dev/null
+++ b/apps/gridcraft/src/logging/tests.rs
@@ -0,0 +1,298 @@
+use super::*;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{Duration, UNIX_EPOCH};
+
+fn temp_dir(tag: &str) -> PathBuf {
+    static N: AtomicUsize = AtomicUsize::new(0);
+    let d = std::env::temp_dir().join(format!("gridcraft-logging-{tag}-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
+    let _ = std::fs::remove_dir_all(&d);
+    d
+}
+
+fn read(path: &Path) -> String {
+    std::fs::read_to_string(path).expect("read log")
+}
+
+fn record(logger: &AppLogger, level: log::Level, target: &str, msg: &str) {
+    use log::Log;
+    logger.log(&log::Record::builder().level(level).target(target).args(format_args!("{msg}")).build());
+}
+
+#[test]
+fn the_default_filter_shows_gridcraft_info_and_other_crates_warnings() {
+    let f = Filter::parse(DEFAULT_FILTER);
+    assert_eq!(f.level_for("gridcraft"), LevelFilter::Info);
+    assert_eq!(f.level_for("gridcraft::control_server"), LevelFilter::Info);
+    assert_eq!(f.level_for("gridcraft_engine::sample"), LevelFilter::Info);
+    assert_eq!(f.level_for("gridcraft_ui_egui::control"), LevelFilter::Info);
+    assert_eq!(f.level_for("wgpu_core::device"), LevelFilter::Warn);
+    assert_eq!(f.level_for("naga"), LevelFilter::Warn);
+    assert_eq!(f.max(), LevelFilter::Info);
+}
+
+#[test]
+fn directives_follow_env_logger_and_the_most_specific_one_wins() {
+    let f = Filter::parse("info,wgpu_core=error,gridcraft_calc=trace,gridcraft_calc::recalc=off");
+    assert_eq!(f.level_for("eframe"), LevelFilter::Info);
+    assert_eq!(f.level_for("wgpu_core::instance"), LevelFilter::Error);
+    assert_eq!(f.level_for("gridcraft_calc::graph"), LevelFilter::Trace);
+    assert_eq!(f.level_for("gridcraft_calc::recalc"), LevelFilter::Off);
+    assert_eq!(f.max(), LevelFilter::Trace);
+    // A module name is matched at `::` boundaries, not as a bare prefix.
+    assert_eq!(f.level_for("wgpu_core_extra"), LevelFilter::Info);
+    // A trailing `*` is a prefix.
+    assert_eq!(Filter::parse("gridcraft*=debug").level_for("gridcraft_xlsx::read"), LevelFilter::Debug);
+    assert_eq!(Filter::parse("gridcraft*=debug").level_for("eframe"), LevelFilter::Error);
+    // A bare target name sets that target to the most verbose level, as env_logger does.
+    assert_eq!(Filter::parse("naga").level_for("naga::front"), LevelFilter::Trace);
+    assert_eq!(Filter::parse("naga").level_for("eframe"), LevelFilter::Error);
+    // Levels are case-insensitive and surrounding blanks are ignored.
+    assert_eq!(Filter::parse(" WARN , gridcraft = Debug ").level_for("gridcraft"), LevelFilter::Debug);
+    assert_eq!(Filter::parse(" WARN , gridcraft = Debug ").level_for("eframe"), LevelFilter::Warn);
+}
+
+#[test]
+fn hostile_specs_never_panic_and_fall_back_sensibly() {
+    let long = "x".repeat(100_000);
+    let many = "a=info,".repeat(10_000);
+    for spec in [
+        "",
+        ",,,",
+        "=",
+        "==",
+        "=debug",
+        "gridcraft=",
+        "nonsense=loud",
+        "🦀=info",
+        "*",
+        "*=",
+        "=*",
+        "a=b=c",
+        "warn,,gridcraft=DEBUG",
+        "\0",
+        "é::ü=trace",
+        &long,
+        &many,
+    ] {
+        let f = Filter::parse(spec);
+        for target in ["", "gridcraft", "🦀", "a::b", "*"] {
+            let _ = f.level_for(target);
+        }
+        let _ = f.max();
+    }
+    assert_eq!(Filter::parse("warn,,gridcraft=DEBUG").level_for("gridcraft"), LevelFilter::Debug);
+    // An unknown level is skipped: that target keeps the default.
+    assert_eq!(Filter::parse("nonsense=loud").level_for("nonsense"), LevelFilter::Error);
+    assert_eq!(Filter::parse("gridcraft=").level_for("gridcraft"), LevelFilter::Error);
+    assert_eq!(Filter::parse("=debug").max(), LevelFilter::Error);
+    assert_eq!(Filter::parse("🦀=info").level_for("🦀::claw"), LevelFilter::Info);
+}
+
+#[test]
+fn timestamps_are_utc_with_milliseconds() {
+    assert_eq!(timestamp(UNIX_EPOCH), "1970-01-01T00:00:00.000Z");
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_millis(1_791_446_357_728)), "2026-10-08T07:59:17.728Z");
+    // Leap day, and the day after it.
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_164_800)), "2024-02-29T00:00:00.000Z");
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_251_199)), "2024-02-29T23:59:59.000Z");
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_251_200)), "2024-03-01T00:00:00.000Z");
+    // 2000 is a leap year (divisible by 400), 2100 is not.
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(951_782_400)), "2000-02-29T00:00:00.000Z");
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(4_107_542_400)), "2100-03-01T00:00:00.000Z");
+    // Before the epoch (a clock set wrong) clamps instead of panicking.
+    assert_eq!(timestamp(UNIX_EPOCH - Duration::from_secs(5)), "1970-01-01T00:00:00.000Z");
+    // A clock set absurdly far ahead (past chrono's own range) keeps its real year rather than
+    // collapsing to the epoch. Windows' SystemTime can't hold such an instant, so it is built
+    // with a checked add and only asserted where it exists.
+    if let Some(far) = UNIX_EPOCH.checked_add(Duration::from_secs(u64::MAX / 2)) {
+        assert_eq!(timestamp(far), "292277026596-12-04T15:30:07.000Z");
+    }
+    if let Some(far) = UNIX_EPOCH.checked_add(Duration::from_secs(10_000_000_000_000)) {
+        assert_eq!(timestamp(far), "318857-05-20T17:46:40.000Z");
+    }
+    // Years past 9999 keep the plain zero-padded year (no `+`).
+    assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(253_402_300_800)), "10000-01-01T00:00:00.000Z");
+}
+
+#[test]
+fn a_line_carries_time_level_thread_target_and_message() {
+    assert_eq!(
+        format_line("2026-10-08T07:59:17.728Z", log::Level::Warn, "main", "gridcraft", "book.xlsx: file not found"),
+        "2026-10-08T07:59:17.728Z WARN  [main] gridcraft: book.xlsx: file not found\n"
+    );
+    // A multi-line message keeps its lines; the record still ends in one newline.
+    assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\nb\n"));
+}
+
+#[test]
+fn rotation_keeps_the_previous_logs_and_starts_an_empty_file() {
+    let dir = temp_dir("rotate");
+    for run in 1..=4 {
+        let (path, _file) = rotate(&dir).expect("rotate");
+        assert_eq!(path, dir.join(LOG_FILE));
+        assert_eq!(read(&path), "");
+        std::fs::write(&path, format!("run {run}")).expect("write");
+    }
+    assert_eq!(read(&dir.join(LOG_FILE)), "run 4");
+    assert_eq!(read(&dir.join("gridcraft.1.log")), "run 3");
+    assert_eq!(read(&dir.join("gridcraft.2.log")), "run 2");
+    assert!(!dir.join("gridcraft.3.log").exists(), "only {KEEP} old logs are kept");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn rotation_into_an_unusable_directory_is_an_error_not_a_panic() {
+    let dir = temp_dir("blocked");
+    std::fs::create_dir_all(dir.parent().expect("parent")).expect("tmp");
+    std::fs::write(&dir, "a file where the directory should be").expect("block");
+    assert!(rotate(&dir).is_err());
+    let _ = std::fs::remove_file(&dir);
+}
+
+#[test]
+fn lines_logged_before_the_file_exists_are_written_when_it_is_attached() {
+    let dir = temp_dir("pending");
+    let (path, file) = rotate(&dir).expect("rotate");
+    let mut sink = Sink::new(MAX_FILE_BYTES);
+    sink.write("early 1\n");
+    sink.write("early 2\n");
+    sink.attach(file);
+    sink.write("late\n");
+    assert_eq!(read(&path), "early 1\nearly 2\nlate\n");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn the_pending_buffer_is_bounded_and_says_how_much_it_dropped() {
+    let dir = temp_dir("bounded");
+    let (path, file) = rotate(&dir).expect("rotate");
+    let mut sink = Sink::new(MAX_FILE_BYTES);
+    for i in 0..MAX_PENDING + 5 {
+        sink.write(&format!("line {i}\n"));
+    }
+    sink.attach(file);
+    let text = read(&path);
+    assert_eq!(text.lines().filter(|l| l.starts_with("line ")).count(), MAX_PENDING);
+    assert!(text.contains("5 earlier log lines were dropped"), "{text}");
+    assert!(text.contains("line 0\n") && !text.contains(&format!("line {MAX_PENDING}\n")));
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn exactly_a_full_pending_buffer_drops_nothing() {
+    let dir = temp_dir("full");
+    let (path, file) = rotate(&dir).expect("rotate");
+    let mut sink = Sink::new(MAX_FILE_BYTES);
+    for i in 0..MAX_PENDING {
+        sink.write(&format!("line {i}\n"));
+    }
+    sink.attach(file);
+    let text = read(&path);
+    assert_eq!(text.lines().count(), MAX_PENDING);
+    assert!(!text.contains("dropped"), "{text}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn without_a_file_nothing_is_kept_in_memory() {
+    let mut sink = Sink::new(MAX_FILE_BYTES);
+    sink.write("early\n");
+    sink.no_file();
+    sink.write("late\n");
+    assert!(sink.pending.is_empty() && sink.dropped == 0);
+}
+
+#[test]
+fn the_file_stops_at_its_size_cap_with_one_note() {
+    let dir = temp_dir("cap");
+    let (path, file) = rotate(&dir).expect("rotate");
+    let mut sink = Sink::new(100);
+    sink.attach(file);
+    for i in 0..50 {
+        sink.write(&format!("line {i:02} with some padding\n"));
+    }
+    let text = read(&path);
+    assert_eq!(text.lines().filter(|l| l.starts_with("line ")).count(), 3, "{text}");
+    assert_eq!(text.matches("log file reached").count(), 1, "{text}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn the_logger_filters_records_and_writes_them_to_the_attached_file() {
+    use log::Log;
+    let dir = temp_dir("logger");
+    let logger = AppLogger::new(Filter::parse(DEFAULT_FILTER), false);
+    record(&logger, log::Level::Info, "gridcraft", "before the settings directory");
+    record(&logger, log::Level::Info, "wgpu_core::device", "too chatty");
+    let path = logger.attach_dir(&dir).expect("attach");
+    assert_eq!(path, dir.join(LOG_FILE));
+    record(&logger, log::Level::Warn, "wgpu_hal::vulkan", "a real warning");
+    record(&logger, log::Level::Error, "gridcraft", "internal error: boom");
+    record(&logger, log::Level::Debug, "gridcraft", "below info");
+    let text = read(&path);
+    let lines: Vec<&str> = text.lines().collect();
+    assert_eq!(lines.len(), 3, "{text}");
+    assert!(lines[0].contains(" INFO  [") && lines[0].ends_with("gridcraft: before the settings directory"), "{text}");
+    assert!(lines[1].ends_with("wgpu_hal::vulkan: a real warning"), "{text}");
+    assert!(lines[2].contains(" ERROR [") && lines[2].ends_with("gridcraft: internal error: boom"), "{text}");
+    assert!(logger.enabled(&log::Metadata::builder().level(log::Level::Info).target("gridcraft_ui_egui").build()));
+    assert!(!logger.enabled(&log::Metadata::builder().level(log::Level::Info).target("naga").build()));
+    // Attaching again rotates: the first log becomes `.1`.
+    logger.attach_dir(&dir).expect("attach again");
+    assert_eq!(read(&dir.join("gridcraft.1.log")), text);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn records_from_many_threads_are_whole_lines() {
+    let dir = temp_dir("threads");
+    let logger = std::sync::Arc::new(AppLogger::new(Filter::parse("info"), false));
+    let path = logger.attach_dir(&dir).expect("attach");
+    let workers: Vec<_> = (0..8)
+        .map(|t| {
+            let l = std::sync::Arc::clone(&logger);
+            std::thread::spawn(move || {
+                for i in 0..100 {
+                    record(&l, log::Level::Info, "gridcraft", &format!("thread {t} record {i}"));
+                }
+            })
+        })
+        .collect();
+    for w in workers {
+        w.join().expect("worker");
+    }
+    let text = read(&path);
+    assert_eq!(text.lines().count(), 800);
+    assert!(text.lines().all(|l| l.contains(" gridcraft: thread ")), "{text}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn attaching_to_an_unusable_directory_reports_an_error_and_keeps_logging() {
+    let dir = temp_dir("unusable");
+    std::fs::create_dir_all(dir.parent().expect("parent")).expect("tmp");
+    std::fs::write(&dir, "not a directory").expect("block");
+    let logger = AppLogger::new(Filter::parse("info"), false);
+    assert!(logger.attach_dir(&dir).is_err());
+    record(&logger, log::Level::Error, "x", "still fine");
+    // Nothing waits in memory for a file that won't come.
+    assert!(logger.sink.lock().expect("sink").pending.is_empty());
+    let _ = std::fs::remove_file(&dir);
+}
+
+#[test]
+fn a_poisoned_sink_still_logs() {
+    let dir = temp_dir("poison");
+    let logger = std::sync::Arc::new(AppLogger::new(Filter::parse("info"), false));
+    let l = std::sync::Arc::clone(&logger);
+    let _ = std::thread::spawn(move || {
+        let _guard = l.sink.lock().expect("lock");
+        panic!("poison the sink");
+    })
+    .join();
+    assert!(logger.sink.is_poisoned());
+    let path = logger.attach_dir(&dir).expect("attach");
+    record(&logger, log::Level::Warn, "gridcraft", "after the poison");
+    assert!(read(&path).contains("gridcraft: after the poison"));
+    let _ = std::fs::remove_dir_all(&dir);
+}

From da40ecba3a11461493cd985ffd17feec42078a7f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:39 +0000
Subject: [PATCH 25/76] refactor(gridcraft-cli): move check tests to
 src/check/tests.rs

---
 apps/gridcraft-cli/src/check.rs       | 454 +-------------------------
 apps/gridcraft-cli/src/check/tests.rs | 451 +++++++++++++++++++++++++
 2 files changed, 452 insertions(+), 453 deletions(-)
 create mode 100644 apps/gridcraft-cli/src/check/tests.rs

diff --git a/apps/gridcraft-cli/src/check.rs b/apps/gridcraft-cli/src/check.rs
index bbd3103d8..318b43aad 100644
--- a/apps/gridcraft-cli/src/check.rs
+++ b/apps/gridcraft-cli/src/check.rs
@@ -1353,456 +1353,4 @@ fn print_human(reports: &[FileReport], opts: &Options) {
 }
 
 #[cfg(test)]
-mod tests {
-    #![allow(clippy::unwrap_used)]
-    use std::io::Write as _;
-    use std::sync::Arc;
-
-    use gridcraft_engine::model::Formula;
-
-    use super::*;
-
-    #[test]
-    fn discovery_reports_a_directory_read_error() {
-        let path = std::env::temp_dir().join(format!("gridcraft-check-not-a-directory-{}", std::process::id()));
-        std::fs::write(&path, "not a directory").unwrap();
-        let mut discovery = Discovery::default();
-        let mut seen = std::collections::HashSet::new();
-        assert!(walk(&path, 0, &mut discovery, &mut seen));
-        assert!(discovery.files.is_empty());
-        assert_eq!(discovery.failures.len(), 1);
-        assert_eq!(discovery.failures[0].path, path.to_string_lossy());
-        assert!(discovery.failures[0].error.as_ref().unwrap().contains("cannot read directory"));
-        let _ = std::fs::remove_file(path);
-    }
-
-    #[test]
-    fn discovery_reports_omissions_only_after_the_file_limit() {
-        let mut discovery = Discovery { files: vec![PathBuf::from("book.xlsx"); MAX_FILES - 1], ..Default::default() };
-        assert!(discovery.add_file(PathBuf::from("last.xlsx")));
-        assert!(discovery.failures.is_empty());
-        assert!(!discovery.add_file(PathBuf::from("omitted.xlsx")));
-        assert_eq!(discovery.files.len(), MAX_FILES);
-        assert_eq!(discovery.failures[0].path, "omitted.xlsx");
-        assert!(discovery.failures[0].error.as_ref().unwrap().contains("file limit"));
-    }
-
-    fn at(a1: &str) -> CellRef {
-        CellRef::parse(a1).unwrap()
-    }
-
-    /// A workbook whose cells are `(A1, input, cached value)`: an input starting with `=` is a
-    /// formula with that cached value, anything else a constant.
-    fn book(cells: &[(&str, &str, Value)]) -> Workbook {
-        let mut wb = Workbook::new();
-        let sh = wb.sheet_mut(0).unwrap();
-        for (a1, input, cached) in cells {
-            let cell = if input.starts_with('=') {
-                Cell { value: cached.clone(), formula: Some(Arc::new(Formula::new(input))), ..Default::default() }
-            } else {
-                Cell::value(cached.clone())
-            };
-            sh.set_cell(at(a1), cell);
-        }
-        wb
-    }
-
-    fn check(wb: &Workbook, opts: &Options) -> FileReport {
-        let bytes = gridcraft_engine::io::save_bytes(wb, "t.xlsx").unwrap();
-        check_bytes("t.xlsx", &bytes, opts)
-    }
-
-    fn n(x: f64) -> Value {
-        Value::number(x)
-    }
-
-    #[test]
-    fn matching_cached_values_pass() {
-        let wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("C1", "=A1&\"x\"", Value::text("2x")), ("D1", "=A1>1", Value::Bool(true))]);
-        let r = check(&wb, &Options::default());
-        assert_eq!(r.error, None);
-        assert_eq!((r.calc.formula_cells, r.calc.checked, r.calc.matched, r.calc.mismatched), (3, 3, 3, 0));
-        assert!(r.is_clean(), "{r:?}");
-    }
-
-    #[test]
-    fn wrong_cached_value_is_a_mismatch_and_ranks_its_function() {
-        // Excel "said" SUM gives 7; GridCraft computes 6. C1 reads B1 and is consistent with
-        // Excel's 7, so it mismatches too, but only as a downstream effect.
-        let wb = book(&[("A1", "2", n(2.0)), ("A2", "4", n(4.0)), ("B1", "=SUM(A1:A2)", n(7.0)), ("C1", "=B1+1", n(8.0))]);
-        let r = check(&wb, &Options::default());
-        assert_eq!((r.calc.checked, r.calc.mismatched), (2, 2));
-        let first = &r.calc.mismatches[0];
-        assert_eq!(first.cell, "Sheet1!B1");
-        assert_eq!(first.formula, "=SUM(A1:A2)");
-        assert_eq!((first.expected.clone(), first.actual.clone(), first.kind, first.primary), (n(7.0), n(6.0), "numeric", true));
-        assert!(!r.calc.mismatches[1].primary);
-        assert_eq!(r.calc.functions["SUM"], FnStat { checked: 1, mismatched: 1, primary: 1 });
-        assert_eq!(r.calc.functions["(no function)"], FnStat { checked: 1, mismatched: 1, primary: 0 });
-        assert!(!r.is_clean());
-    }
-
-    #[test]
-    fn errors_compare_by_kind() {
-        let wb = book(&[("A1", "=1/0", Value::Error(CellError::Div0)), ("A2", "=1/0", Value::Error(CellError::NA)), ("A3", "=1/0", n(0.0))]);
-        let r = check(&wb, &Options::default());
-        assert_eq!((r.calc.matched, r.calc.mismatched), (1, 2));
-        assert!(r.calc.mismatches.iter().all(|m| m.kind == "error"));
-        assert_eq!(r.calc.signatures.get("#N/A → #DIV/0!"), Some(&1));
-        assert_eq!(r.calc.signatures.get("number → #DIV/0!"), Some(&1));
-        assert!(values_match(&Value::Error(CellError::NA), &Value::Error(CellError::NA), 0.0));
-        assert!(!values_match(&Value::Error(CellError::NA), &Value::Error(CellError::Value), 0.0));
-    }
-
-    #[test]
-    fn numbers_compare_within_tolerance() {
-        assert!(values_match(&n(3.0000000001), &n(3.0), 1e-9));
-        assert!(!values_match(&n(3.0000000001), &n(3.0), 1e-12));
-        // Absolute near zero.
-        assert!(values_match(&n(1e-12), &n(0.0), 1e-9));
-        assert!(values_match(&n(1e12 + 1.0), &n(1e12), 1e-9));
-        assert!(!values_match(&n(0.0), &Value::Empty, 1.0));
-        assert!(!values_match(&Value::text("1"), &n(1.0), 1.0));
-        assert!(values_match(&Value::text("a"), &Value::text("a"), 0.0));
-        assert!(!values_match(&Value::text("a"), &Value::text("A"), 0.0));
-        assert!(!values_match(&Value::Bool(true), &n(1.0), 1.0));
-        let wb = book(&[("A1", "=1+2", n(3.0000000001))]);
-        assert_eq!(check(&wb, &Options::default()).calc.matched, 1);
-        assert_eq!(check(&wb, &Options { tolerance: 1e-12, ..Default::default() }).calc.mismatched, 1);
-    }
-
-    /// Business Central writes TRUE and FALSE as `<c><f>TRUE()</f><v>1</v></c>`, without `t="b"`:
-    /// the cache holds the right value under a number type, so it matches and is counted apart.
-    #[test]
-    fn booleans_cached_as_numbers_match_and_are_counted_apart() {
-        let wb = book(&[
-            ("A1", "=TRUE()", n(1.0)),
-            ("B1", "=FALSE()", n(0.0)),
-            ("C1", "=TRUE()", Value::Bool(true)),
-            ("D1", "=1=1", n(0.0)),
-            ("E1", "=TRUE()+0", n(1.0)),
-        ]);
-        let r = check(&wb, &Options::default());
-        assert_eq!((r.calc.checked, r.calc.matched, r.calc.mismatched), (5, 4, 1));
-        // A cached 0 for TRUE is still a mismatch, and a number result is compared as a number.
-        assert_eq!(r.calc.mismatches[0].cell, "Sheet1!D1");
-        assert_eq!(r.calc.signatures.get("number → bool"), Some(&1));
-        assert_eq!(r.calc.bool_as_number, 2);
-        let v = report_json(std::slice::from_ref(&r), &Options::default());
-        assert_eq!((v["files"][0]["calc"]["boolAsNumber"].clone(), v["totals"]["boolAsNumber"].clone()), (json!(2), json!(2)));
-        assert!(bool_cached_as_number(&n(1.0), &Value::Bool(true)));
-        assert!(!bool_cached_as_number(&n(1.0), &Value::Bool(false)));
-        assert!(!bool_cached_as_number(&n(2.0), &Value::Bool(true)));
-        assert!(!bool_cached_as_number(&Value::Bool(true), &n(1.0)));
-    }
-
-    #[test]
-    fn missing_cached_values_and_volatile_formulas_are_skipped() {
-        let wb =
-            book(&[("A1", "=1+1", Value::Empty), ("B1", "=NOW()", n(1.0)), ("B2", "=B1+1", n(2.0)), ("B3", "=CELL(\"filename\")", Value::text("x"))]);
-        let r = check(&wb, &Options::default());
-        assert_eq!((r.calc.formula_cells, r.calc.checked, r.calc.no_oracle, r.calc.volatile), (4, 0, 1, 3));
-    }
-
-    #[test]
-    fn full_calc_on_load_means_no_oracle() {
-        // A formula without a cached value makes GridCraft's writer flag the file
-        // `fullCalcOnLoad`, like libraries that store 0 for every formula: B1's wrong "cached"
-        // value must not count as a mismatch then.
-        let wb = book(&[("A1", "=1+1", Value::Empty), ("B1", "=2+2", n(0.0))]);
-        let bytes = gridcraft_engine::io::save_bytes(&wb, "t.xlsx").unwrap();
-        assert!(full_calc_on_load(&bytes));
-        let r = check_bytes("t.xlsx", &bytes, &Options::default());
-        assert!(r.calc.stale_cache);
-        assert_eq!((r.calc.checked, r.calc.no_oracle, r.calc.mismatched), (0, 2, 0));
-        let fresh = gridcraft_engine::io::save_bytes(&book(&[("B1", "=2+2", n(0.0))]), "t.xlsx").unwrap();
-        assert!(!full_calc_on_load(&fresh));
-        assert!(!full_calc_on_load(b"not a zip"));
-    }
-
-    #[test]
-    fn volatile_names_propagate() {
-        let mut wb = book(&[("A1", "=Stamp+1", n(1.0))]);
-        wb.names.push(gridcraft_engine::model::DefinedName {
-            name: "Stamp".into(),
-            scope: None,
-            formula: "TODAY()".into(),
-            comment: String::new(),
-            hidden: false,
-        });
-        assert!(volatile_names(&wb).contains("STAMP"));
-        assert_eq!(check(&wb, &Options::default()).calc.volatile, 1);
-    }
-
-    #[test]
-    fn round_trip_of_a_simple_book_is_clean() {
-        let mut wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("A2", "x", Value::text("x"))]);
-        wb.sheet_mut(0).unwrap().merges.push(gridcraft_engine::core::RangeRef::parse("C1:D2").unwrap());
-        let source = gridcraft_engine::io::save_bytes(&wb, "t.xlsx").unwrap();
-        let rt = round_trip(&wb, &source, &Options::default());
-        assert_eq!(rt.error, None);
-        assert!(rt.is_clean(), "{rt:?}");
-        assert!(rt.categories.iter().any(|c| c.name == "package"));
-    }
-
-    #[test]
-    fn diff_detects_lost_features() {
-        let mut a = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0))]);
-        a.sheet_mut(0).unwrap().merges.push(gridcraft_engine::core::RangeRef::parse("C1:D2").unwrap());
-        let mut b = a.clone();
-        let sh = b.sheet_mut(0).unwrap();
-        sh.merges.clear();
-        sh.set_cell(at("A1"), Cell::value(n(3.0)));
-        sh.set_cell(at("B1"), Cell::value(n(6.0)));
-        b.sheets.push(Arc::new(Sheet::new("Extra")));
-        let cats = diff_workbooks(&a, &b, &Options { max_report: 1, ..Default::default() });
-        let get = |name: &str| cats.iter().find(|c| c.name == name).unwrap();
-        assert_eq!(get("values").diffs, 1);
-        assert_eq!(get("values").examples, ["Sheet1!A1: 2 → 3"]);
-        assert_eq!(get("formulas").examples, ["Sheet1!B1: =A1*3 → "]);
-        assert_eq!(get("merges").examples, ["Sheet1: lost C1:D2"]);
-        assert_eq!(get("sheets").diffs, 1);
-        assert_eq!(get("tables").diffs, 0);
-    }
-
-    #[test]
-    fn diff_detects_changed_cond_format_rule() {
-        use gridcraft_engine::model::{CfRule, CfValueKind, Color, CondFormat};
-        let bar = |gradient: bool, priority: u32| CondFormat {
-            ranges: vec![gridcraft_engine::core::RangeRef::parse("A1").unwrap()],
-            rule: CfRule::DataBar { min: CfValueKind::Min, max: CfValueKind::Max, color: Color::Rgb(0x638EC6), gradient, show_value: true },
-            priority,
-            stop_if_true: false,
-        };
-        let with = |cf: CondFormat| {
-            let mut wb = book(&[("A1", "2", n(2.0))]);
-            wb.sheet_mut(0).unwrap().cond_formats.push(cf);
-            wb
-        };
-        let diffs =
-            |a: &Workbook, b: &Workbook| diff_workbooks(a, b, &Options::default()).into_iter().find(|c| c.name == "condFormats").unwrap().diffs;
-        assert_eq!(diffs(&with(bar(false, 1)), &with(bar(true, 1))), 1);
-        assert_eq!(diffs(&with(bar(true, 1)), &with(bar(true, 1))), 0);
-        assert_eq!(diffs(&with(bar(true, 1)), &with(bar(true, 5))), 0);
-    }
-
-    fn zip_of(parts: &[(&str, &str)]) -> Vec<u8> {
-        let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
-        for (name, body) in parts {
-            z.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
-            z.write_all(body.as_bytes()).unwrap();
-        }
-        z.finish().unwrap().into_inner()
-    }
-
-    #[test]
-    fn package_validation_finds_what_excel_would_repair() {
-        let bytes = zip_of(&[
-            (
-                "[Content_Types].xml",
-                r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="r"/><Override PartName="/xl/workbook.xml" ContentType="w"/><Override PartName="/xl/gone.xml" ContentType="g"/></Types>"#,
-            ),
-            ("_rels/.rels", r#"<Relationships><Relationship Id="rId1" Type="x/officeDocument" Target="xl/workbook.xml"/></Relationships>"#),
-            ("xl/workbook.xml", "<workbook/>"),
-            ("xl/styles.xml", "<styleSheet/>"),
-            (
-                "xl/_rels/workbook.xml.rels",
-                r#"<Relationships><Relationship Id="rId1" Type="x/styles" Target="styles.xml"/><Relationship Id="rId2" Type="x/worksheet" Target="worksheets/sheet1.xml"/><Relationship Id="rId2" Type="x/hyperlink" Target="https://example.com" TargetMode="External"/><Relationship Id="rId3" Type="x/theme" Target="/xl/../xl/styles.xml"/></Relationships>"#,
-            ),
-        ]);
-        let issues = validate_package(&bytes).unwrap();
-        assert_eq!(
-            issues,
-            [
-                "part xl/styles.xml has no content type",
-                "content type override for missing part /xl/gone.xml",
-                "xl/_rels/workbook.xml.rels: rId2 (worksheet) targets missing part xl/worksheets/sheet1.xml",
-                "xl/_rels/workbook.xml.rels: duplicate relationship id rId2",
-            ]
-        );
-        assert!(validate_package(b"not a zip").is_err());
-        let own = gridcraft_engine::io::save_bytes(&book(&[("A1", "=1", n(1.0))]), "t.xlsx").unwrap();
-        assert_eq!(validate_package(&own).unwrap(), Vec::<String>::new());
-    }
-
-    const WB_RELS: &str = "xl/_rels/workbook.xml.rels";
-    const SHEET_RELS: &str = "xl/worksheets/_rels/sheet1.xml.rels";
-    const MADE_UP: &str = r#"<Relationship Id="rId90" Type="http://example.com/relationships/madeUp" Target="madeUp.xml"/>"#;
-    /// Not empty: an empty part isn't a loss.
-    const MADE_UP_PART: (&str, &str) = ("xl/madeUp.xml", "<madeUp><item/></madeUp>");
-
-    /// `bytes` with relationships added to rels parts (created when missing) and `parts` added.
-    fn with_rels(bytes: &[u8], rels: &[(&str, &str)], parts: &[(&str, &str)]) -> Vec<u8> {
-        let mut src = zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
-        let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-        let mut pending: Vec<(&str, &str)> = rels.to_vec();
-        for i in 0..src.len() {
-            let mut f = src.by_index(i).unwrap();
-            let name = f.name().to_string();
-            let mut body = String::new();
-            f.read_to_string(&mut body).unwrap();
-            if let Some(at) = pending.iter().position(|(r, _)| *r == name) {
-                body = body.replace("</Relationships>", &format!("{}</Relationships>", pending.remove(at).1));
-            }
-            out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
-            out.write_all(body.as_bytes()).unwrap();
-        }
-        let created = pending.iter().map(|(r, extra)| {
-            (*r, format!(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">{extra}</Relationships>"#))
-        });
-        for (name, body) in created.collect::<Vec<_>>().iter().map(|(n, b)| (*n, b.as_str())).chain(parts.iter().copied()) {
-            out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
-            out.write_all(body.as_bytes()).unwrap();
-        }
-        out.finish().unwrap().into_inner()
-    }
-
-    /// The `package` examples of checking `source`.
-    fn package_of(source: &[u8]) -> Vec<String> {
-        let r = check_bytes("t.xlsx", source, &Options::default());
-        r.round_trip.categories.iter().find(|c| c.name == "package").unwrap().examples.clone()
-    }
-
-    fn plain() -> Vec<u8> {
-        gridcraft_engine::io::save_bytes(&book(&[("A1", "1", n(1.0))]), "t.xlsx").unwrap()
-    }
-
-    #[test]
-    fn package_reports_relationship_kinds_the_output_lost() {
-        // A kind GridCraft doesn't know is dropped on save; a calculation chain is never written
-        // (Excel rebuilds it), so its absence isn't a loss.
-        let calc_chain = r#"<Relationship Id="rId91" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain" Target="calcChain.xml"/>"#;
-        let source = with_rels(&plain(), &[(WB_RELS, &format!("{MADE_UP}{calc_chain}"))], &[MADE_UP_PART, ("xl/calcChain.xml", "<calcChain/>")]);
-        assert_eq!(package_of(&source), ["lost relationship madeUp"]);
-        assert!(check_bytes("t.xlsx", &plain(), &Options::default()).round_trip.is_clean());
-    }
-
-    // In the three tests below the made-up kind stays lost, so the comparison is known to run.
-
-    #[test]
-    fn an_internal_link_written_as_a_relationship_is_not_a_loss() {
-        // openpyxl writes `#Sheet1!B2` as an external relationship; GridCraft writes `location`.
-        let link = r##"<Relationship Id="rId5" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="#Sheet1!B2" TargetMode="External"/>"##;
-        let source = with_rels(&plain(), &[(WB_RELS, MADE_UP), (SHEET_RELS, link)], &[MADE_UP_PART]);
-        assert_eq!(package_of(&source), ["lost relationship madeUp"]);
-    }
-
-    #[test]
-    fn comments_without_a_comment_are_not_a_loss() {
-        let rels = r#"<Relationship Id="rId6" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="../comments1.xml"/><Relationship Id="rId7" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing" Target="../drawings/vmlDrawing1.vml"/>"#;
-        let comments = r#"<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><authors><author>A</author></authors><commentList/></comments>"#;
-        let vml = r#"<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office"><o:shapelayout><o:idmap data="1"/></o:shapelayout><v:shapetype id="_x0000_t202" path="m,l,21600r21600,l21600,xe"><v:path gradientshapeok="t"/></v:shapetype></xml>"#;
-        let source = with_rels(
-            &plain(),
-            &[(WB_RELS, MADE_UP), (SHEET_RELS, rels)],
-            &[MADE_UP_PART, ("xl/comments1.xml", comments), ("xl/drawings/vmlDrawing1.vml", vml)],
-        );
-        assert_eq!(package_of(&source), ["lost relationship madeUp"]);
-    }
-
-    #[test]
-    fn empty_drawings_and_person_lists_are_not_a_loss() {
-        let drawing = r#"<Relationship Id="rId8" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing1.xml"/>"#;
-        let person =
-            r#"<Relationship Id="rId92" Type="http://schemas.microsoft.com/office/2017/10/relationships/person" Target="persons/person.xml"/>"#;
-        let source = with_rels(
-            &plain(),
-            &[(WB_RELS, &format!("{MADE_UP}{person}")), (SHEET_RELS, drawing)],
-            &[
-                MADE_UP_PART,
-                ("xl/drawings/drawing1.xml", r#"<xdr:wsDr xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"/>"#),
-                ("xl/persons/person.xml", r#"<personList xmlns="http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments"/>"#),
-            ],
-        );
-        assert_eq!(package_of(&source), ["lost relationship madeUp"]);
-    }
-
-    #[test]
-    fn json_lists_warning_messages() {
-        let with = FileReport { path: "a.ods".into(), warnings: vec!["ODS data-only import".into()], ..Default::default() };
-        let without = FileReport { path: "b.xlsx".into(), ..Default::default() };
-        let v = report_json(&[with, without], &Options::default());
-        assert_eq!(v["files"][0]["warnings"], json!(["ODS data-only import"]));
-        assert_eq!(v["files"][1]["warnings"], json!([]));
-    }
-
-    #[test]
-    fn unopenable_files_are_reported() {
-        let r = check_bytes("broken.xlsx", b"PK\x03\x04 not really", &Options::default());
-        assert!(r.error.is_some());
-        assert!(!r.is_clean());
-    }
-
-    #[test]
-    fn json_schema_keys() {
-        let wb = book(&[("A1", "=1+1", n(3.0))]);
-        let reports = vec![check(&wb, &Options::default()), check_bytes("bad.xlsx", b"", &Options::default())];
-        let v = report_json(&reports, &Options::default());
-        let keys = |v: &Json| v.as_object().unwrap().keys().cloned().collect::<BTreeSet<String>>();
-        let set = |k: &[&str]| k.iter().map(|s| s.to_string()).collect::<BTreeSet<String>>();
-        assert_eq!(keys(&v), set(&["schema", "tolerance", "files", "totals", "functions", "signatures"]));
-        assert_eq!(v["schema"], SCHEMA);
-        let f = &v["files"][0];
-        assert_eq!(keys(f), set(&["path", "opened", "error", "warnings", "calc", "roundTrip"]));
-        assert_eq!(
-            keys(&f["calc"]),
-            set(&[
-                "formulaCells",
-                "checked",
-                "matched",
-                "mismatched",
-                "noOracle",
-                "staleCache",
-                "volatile",
-                "boolAsNumber",
-                "mismatches",
-                "functions",
-                "signatures"
-            ])
-        );
-        assert_eq!(f["calc"]["signatures"], json!({"number → number": 1}));
-        assert_eq!(keys(&f["calc"]["mismatches"][0]), set(&["cell", "formula", "expected", "actual", "kind", "functions", "primary"]));
-        assert_eq!(f["calc"]["mismatches"][0]["expected"], json!(3.0));
-        assert_eq!(keys(&f["roundTrip"]), set(&["error", "differing", "categories"]));
-        assert_eq!(
-            keys(&f["roundTrip"]["categories"]),
-            set(&[
-                "sheets",
-                "values",
-                "formulas",
-                "numFmts",
-                "merges",
-                "names",
-                "tables",
-                "condFormats",
-                "validations",
-                "charts",
-                "comments",
-                "hyperlinks",
-                "pivots",
-                "package"
-            ])
-        );
-        assert_eq!(keys(&f["roundTrip"]["categories"]["values"]), set(&["equal", "diffs", "examples"]));
-        assert_eq!(v["files"][1]["opened"], json!(false));
-        assert_eq!(
-            keys(&v["totals"]),
-            set(&[
-                "files",
-                "opened",
-                "failedToOpen",
-                "formulaCells",
-                "checked",
-                "matched",
-                "mismatched",
-                "noOracle",
-                "volatile",
-                "boolAsNumber",
-                "roundTripFailed",
-                "roundTripDiffering",
-                "categoriesDiffering"
-            ])
-        );
-        assert_eq!(keys(&v["functions"][0]), set(&["name", "checked", "mismatched", "primary"]));
-    }
-}
+mod tests;
diff --git a/apps/gridcraft-cli/src/check/tests.rs b/apps/gridcraft-cli/src/check/tests.rs
new file mode 100644
index 000000000..f1df04670
--- /dev/null
+++ b/apps/gridcraft-cli/src/check/tests.rs
@@ -0,0 +1,451 @@
+#![allow(clippy::unwrap_used)]
+use std::io::Write as _;
+use std::sync::Arc;
+
+use gridcraft_engine::model::Formula;
+
+use super::*;
+
+#[test]
+fn discovery_reports_a_directory_read_error() {
+    let path = std::env::temp_dir().join(format!("gridcraft-check-not-a-directory-{}", std::process::id()));
+    std::fs::write(&path, "not a directory").unwrap();
+    let mut discovery = Discovery::default();
+    let mut seen = std::collections::HashSet::new();
+    assert!(walk(&path, 0, &mut discovery, &mut seen));
+    assert!(discovery.files.is_empty());
+    assert_eq!(discovery.failures.len(), 1);
+    assert_eq!(discovery.failures[0].path, path.to_string_lossy());
+    assert!(discovery.failures[0].error.as_ref().unwrap().contains("cannot read directory"));
+    let _ = std::fs::remove_file(path);
+}
+
+#[test]
+fn discovery_reports_omissions_only_after_the_file_limit() {
+    let mut discovery = Discovery { files: vec![PathBuf::from("book.xlsx"); MAX_FILES - 1], ..Default::default() };
+    assert!(discovery.add_file(PathBuf::from("last.xlsx")));
+    assert!(discovery.failures.is_empty());
+    assert!(!discovery.add_file(PathBuf::from("omitted.xlsx")));
+    assert_eq!(discovery.files.len(), MAX_FILES);
+    assert_eq!(discovery.failures[0].path, "omitted.xlsx");
+    assert!(discovery.failures[0].error.as_ref().unwrap().contains("file limit"));
+}
+
+fn at(a1: &str) -> CellRef {
+    CellRef::parse(a1).unwrap()
+}
+
+/// A workbook whose cells are `(A1, input, cached value)`: an input starting with `=` is a
+/// formula with that cached value, anything else a constant.
+fn book(cells: &[(&str, &str, Value)]) -> Workbook {
+    let mut wb = Workbook::new();
+    let sh = wb.sheet_mut(0).unwrap();
+    for (a1, input, cached) in cells {
+        let cell = if input.starts_with('=') {
+            Cell { value: cached.clone(), formula: Some(Arc::new(Formula::new(input))), ..Default::default() }
+        } else {
+            Cell::value(cached.clone())
+        };
+        sh.set_cell(at(a1), cell);
+    }
+    wb
+}
+
+fn check(wb: &Workbook, opts: &Options) -> FileReport {
+    let bytes = gridcraft_engine::io::save_bytes(wb, "t.xlsx").unwrap();
+    check_bytes("t.xlsx", &bytes, opts)
+}
+
+fn n(x: f64) -> Value {
+    Value::number(x)
+}
+
+#[test]
+fn matching_cached_values_pass() {
+    let wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("C1", "=A1&\"x\"", Value::text("2x")), ("D1", "=A1>1", Value::Bool(true))]);
+    let r = check(&wb, &Options::default());
+    assert_eq!(r.error, None);
+    assert_eq!((r.calc.formula_cells, r.calc.checked, r.calc.matched, r.calc.mismatched), (3, 3, 3, 0));
+    assert!(r.is_clean(), "{r:?}");
+}
+
+#[test]
+fn wrong_cached_value_is_a_mismatch_and_ranks_its_function() {
+    // Excel "said" SUM gives 7; GridCraft computes 6. C1 reads B1 and is consistent with
+    // Excel's 7, so it mismatches too, but only as a downstream effect.
+    let wb = book(&[("A1", "2", n(2.0)), ("A2", "4", n(4.0)), ("B1", "=SUM(A1:A2)", n(7.0)), ("C1", "=B1+1", n(8.0))]);
+    let r = check(&wb, &Options::default());
+    assert_eq!((r.calc.checked, r.calc.mismatched), (2, 2));
+    let first = &r.calc.mismatches[0];
+    assert_eq!(first.cell, "Sheet1!B1");
+    assert_eq!(first.formula, "=SUM(A1:A2)");
+    assert_eq!((first.expected.clone(), first.actual.clone(), first.kind, first.primary), (n(7.0), n(6.0), "numeric", true));
+    assert!(!r.calc.mismatches[1].primary);
+    assert_eq!(r.calc.functions["SUM"], FnStat { checked: 1, mismatched: 1, primary: 1 });
+    assert_eq!(r.calc.functions["(no function)"], FnStat { checked: 1, mismatched: 1, primary: 0 });
+    assert!(!r.is_clean());
+}
+
+#[test]
+fn errors_compare_by_kind() {
+    let wb = book(&[("A1", "=1/0", Value::Error(CellError::Div0)), ("A2", "=1/0", Value::Error(CellError::NA)), ("A3", "=1/0", n(0.0))]);
+    let r = check(&wb, &Options::default());
+    assert_eq!((r.calc.matched, r.calc.mismatched), (1, 2));
+    assert!(r.calc.mismatches.iter().all(|m| m.kind == "error"));
+    assert_eq!(r.calc.signatures.get("#N/A → #DIV/0!"), Some(&1));
+    assert_eq!(r.calc.signatures.get("number → #DIV/0!"), Some(&1));
+    assert!(values_match(&Value::Error(CellError::NA), &Value::Error(CellError::NA), 0.0));
+    assert!(!values_match(&Value::Error(CellError::NA), &Value::Error(CellError::Value), 0.0));
+}
+
+#[test]
+fn numbers_compare_within_tolerance() {
+    assert!(values_match(&n(3.0000000001), &n(3.0), 1e-9));
+    assert!(!values_match(&n(3.0000000001), &n(3.0), 1e-12));
+    // Absolute near zero.
+    assert!(values_match(&n(1e-12), &n(0.0), 1e-9));
+    assert!(values_match(&n(1e12 + 1.0), &n(1e12), 1e-9));
+    assert!(!values_match(&n(0.0), &Value::Empty, 1.0));
+    assert!(!values_match(&Value::text("1"), &n(1.0), 1.0));
+    assert!(values_match(&Value::text("a"), &Value::text("a"), 0.0));
+    assert!(!values_match(&Value::text("a"), &Value::text("A"), 0.0));
+    assert!(!values_match(&Value::Bool(true), &n(1.0), 1.0));
+    let wb = book(&[("A1", "=1+2", n(3.0000000001))]);
+    assert_eq!(check(&wb, &Options::default()).calc.matched, 1);
+    assert_eq!(check(&wb, &Options { tolerance: 1e-12, ..Default::default() }).calc.mismatched, 1);
+}
+
+/// Business Central writes TRUE and FALSE as `<c><f>TRUE()</f><v>1</v></c>`, without `t="b"`:
+/// the cache holds the right value under a number type, so it matches and is counted apart.
+#[test]
+fn booleans_cached_as_numbers_match_and_are_counted_apart() {
+    let wb = book(&[
+        ("A1", "=TRUE()", n(1.0)),
+        ("B1", "=FALSE()", n(0.0)),
+        ("C1", "=TRUE()", Value::Bool(true)),
+        ("D1", "=1=1", n(0.0)),
+        ("E1", "=TRUE()+0", n(1.0)),
+    ]);
+    let r = check(&wb, &Options::default());
+    assert_eq!((r.calc.checked, r.calc.matched, r.calc.mismatched), (5, 4, 1));
+    // A cached 0 for TRUE is still a mismatch, and a number result is compared as a number.
+    assert_eq!(r.calc.mismatches[0].cell, "Sheet1!D1");
+    assert_eq!(r.calc.signatures.get("number → bool"), Some(&1));
+    assert_eq!(r.calc.bool_as_number, 2);
+    let v = report_json(std::slice::from_ref(&r), &Options::default());
+    assert_eq!((v["files"][0]["calc"]["boolAsNumber"].clone(), v["totals"]["boolAsNumber"].clone()), (json!(2), json!(2)));
+    assert!(bool_cached_as_number(&n(1.0), &Value::Bool(true)));
+    assert!(!bool_cached_as_number(&n(1.0), &Value::Bool(false)));
+    assert!(!bool_cached_as_number(&n(2.0), &Value::Bool(true)));
+    assert!(!bool_cached_as_number(&Value::Bool(true), &n(1.0)));
+}
+
+#[test]
+fn missing_cached_values_and_volatile_formulas_are_skipped() {
+    let wb =
+        book(&[("A1", "=1+1", Value::Empty), ("B1", "=NOW()", n(1.0)), ("B2", "=B1+1", n(2.0)), ("B3", "=CELL(\"filename\")", Value::text("x"))]);
+    let r = check(&wb, &Options::default());
+    assert_eq!((r.calc.formula_cells, r.calc.checked, r.calc.no_oracle, r.calc.volatile), (4, 0, 1, 3));
+}
+
+#[test]
+fn full_calc_on_load_means_no_oracle() {
+    // A formula without a cached value makes GridCraft's writer flag the file
+    // `fullCalcOnLoad`, like libraries that store 0 for every formula: B1's wrong "cached"
+    // value must not count as a mismatch then.
+    let wb = book(&[("A1", "=1+1", Value::Empty), ("B1", "=2+2", n(0.0))]);
+    let bytes = gridcraft_engine::io::save_bytes(&wb, "t.xlsx").unwrap();
+    assert!(full_calc_on_load(&bytes));
+    let r = check_bytes("t.xlsx", &bytes, &Options::default());
+    assert!(r.calc.stale_cache);
+    assert_eq!((r.calc.checked, r.calc.no_oracle, r.calc.mismatched), (0, 2, 0));
+    let fresh = gridcraft_engine::io::save_bytes(&book(&[("B1", "=2+2", n(0.0))]), "t.xlsx").unwrap();
+    assert!(!full_calc_on_load(&fresh));
+    assert!(!full_calc_on_load(b"not a zip"));
+}
+
+#[test]
+fn volatile_names_propagate() {
+    let mut wb = book(&[("A1", "=Stamp+1", n(1.0))]);
+    wb.names.push(gridcraft_engine::model::DefinedName {
+        name: "Stamp".into(),
+        scope: None,
+        formula: "TODAY()".into(),
+        comment: String::new(),
+        hidden: false,
+    });
+    assert!(volatile_names(&wb).contains("STAMP"));
+    assert_eq!(check(&wb, &Options::default()).calc.volatile, 1);
+}
+
+#[test]
+fn round_trip_of_a_simple_book_is_clean() {
+    let mut wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("A2", "x", Value::text("x"))]);
+    wb.sheet_mut(0).unwrap().merges.push(gridcraft_engine::core::RangeRef::parse("C1:D2").unwrap());
+    let source = gridcraft_engine::io::save_bytes(&wb, "t.xlsx").unwrap();
+    let rt = round_trip(&wb, &source, &Options::default());
+    assert_eq!(rt.error, None);
+    assert!(rt.is_clean(), "{rt:?}");
+    assert!(rt.categories.iter().any(|c| c.name == "package"));
+}
+
+#[test]
+fn diff_detects_lost_features() {
+    let mut a = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0))]);
+    a.sheet_mut(0).unwrap().merges.push(gridcraft_engine::core::RangeRef::parse("C1:D2").unwrap());
+    let mut b = a.clone();
+    let sh = b.sheet_mut(0).unwrap();
+    sh.merges.clear();
+    sh.set_cell(at("A1"), Cell::value(n(3.0)));
+    sh.set_cell(at("B1"), Cell::value(n(6.0)));
+    b.sheets.push(Arc::new(Sheet::new("Extra")));
+    let cats = diff_workbooks(&a, &b, &Options { max_report: 1, ..Default::default() });
+    let get = |name: &str| cats.iter().find(|c| c.name == name).unwrap();
+    assert_eq!(get("values").diffs, 1);
+    assert_eq!(get("values").examples, ["Sheet1!A1: 2 → 3"]);
+    assert_eq!(get("formulas").examples, ["Sheet1!B1: =A1*3 → "]);
+    assert_eq!(get("merges").examples, ["Sheet1: lost C1:D2"]);
+    assert_eq!(get("sheets").diffs, 1);
+    assert_eq!(get("tables").diffs, 0);
+}
+
+#[test]
+fn diff_detects_changed_cond_format_rule() {
+    use gridcraft_engine::model::{CfRule, CfValueKind, Color, CondFormat};
+    let bar = |gradient: bool, priority: u32| CondFormat {
+        ranges: vec![gridcraft_engine::core::RangeRef::parse("A1").unwrap()],
+        rule: CfRule::DataBar { min: CfValueKind::Min, max: CfValueKind::Max, color: Color::Rgb(0x638EC6), gradient, show_value: true },
+        priority,
+        stop_if_true: false,
+    };
+    let with = |cf: CondFormat| {
+        let mut wb = book(&[("A1", "2", n(2.0))]);
+        wb.sheet_mut(0).unwrap().cond_formats.push(cf);
+        wb
+    };
+    let diffs =
+        |a: &Workbook, b: &Workbook| diff_workbooks(a, b, &Options::default()).into_iter().find(|c| c.name == "condFormats").unwrap().diffs;
+    assert_eq!(diffs(&with(bar(false, 1)), &with(bar(true, 1))), 1);
+    assert_eq!(diffs(&with(bar(true, 1)), &with(bar(true, 1))), 0);
+    assert_eq!(diffs(&with(bar(true, 1)), &with(bar(true, 5))), 0);
+}
+
+fn zip_of(parts: &[(&str, &str)]) -> Vec<u8> {
+    let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    for (name, body) in parts {
+        z.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
+        z.write_all(body.as_bytes()).unwrap();
+    }
+    z.finish().unwrap().into_inner()
+}
+
+#[test]
+fn package_validation_finds_what_excel_would_repair() {
+    let bytes = zip_of(&[
+        (
+            "[Content_Types].xml",
+            r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="r"/><Override PartName="/xl/workbook.xml" ContentType="w"/><Override PartName="/xl/gone.xml" ContentType="g"/></Types>"#,
+        ),
+        ("_rels/.rels", r#"<Relationships><Relationship Id="rId1" Type="x/officeDocument" Target="xl/workbook.xml"/></Relationships>"#),
+        ("xl/workbook.xml", "<workbook/>"),
+        ("xl/styles.xml", "<styleSheet/>"),
+        (
+            "xl/_rels/workbook.xml.rels",
+            r#"<Relationships><Relationship Id="rId1" Type="x/styles" Target="styles.xml"/><Relationship Id="rId2" Type="x/worksheet" Target="worksheets/sheet1.xml"/><Relationship Id="rId2" Type="x/hyperlink" Target="https://example.com" TargetMode="External"/><Relationship Id="rId3" Type="x/theme" Target="/xl/../xl/styles.xml"/></Relationships>"#,
+        ),
+    ]);
+    let issues = validate_package(&bytes).unwrap();
+    assert_eq!(
+        issues,
+        [
+            "part xl/styles.xml has no content type",
+            "content type override for missing part /xl/gone.xml",
+            "xl/_rels/workbook.xml.rels: rId2 (worksheet) targets missing part xl/worksheets/sheet1.xml",
+            "xl/_rels/workbook.xml.rels: duplicate relationship id rId2",
+        ]
+    );
+    assert!(validate_package(b"not a zip").is_err());
+    let own = gridcraft_engine::io::save_bytes(&book(&[("A1", "=1", n(1.0))]), "t.xlsx").unwrap();
+    assert_eq!(validate_package(&own).unwrap(), Vec::<String>::new());
+}
+
+const WB_RELS: &str = "xl/_rels/workbook.xml.rels";
+const SHEET_RELS: &str = "xl/worksheets/_rels/sheet1.xml.rels";
+const MADE_UP: &str = r#"<Relationship Id="rId90" Type="http://example.com/relationships/madeUp" Target="madeUp.xml"/>"#;
+/// Not empty: an empty part isn't a loss.
+const MADE_UP_PART: (&str, &str) = ("xl/madeUp.xml", "<madeUp><item/></madeUp>");
+
+/// `bytes` with relationships added to rels parts (created when missing) and `parts` added.
+fn with_rels(bytes: &[u8], rels: &[(&str, &str)], parts: &[(&str, &str)]) -> Vec<u8> {
+    let mut src = zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
+    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut pending: Vec<(&str, &str)> = rels.to_vec();
+    for i in 0..src.len() {
+        let mut f = src.by_index(i).unwrap();
+        let name = f.name().to_string();
+        let mut body = String::new();
+        f.read_to_string(&mut body).unwrap();
+        if let Some(at) = pending.iter().position(|(r, _)| *r == name) {
+            body = body.replace("</Relationships>", &format!("{}</Relationships>", pending.remove(at).1));
+        }
+        out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
+        out.write_all(body.as_bytes()).unwrap();
+    }
+    let created = pending.iter().map(|(r, extra)| {
+        (*r, format!(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">{extra}</Relationships>"#))
+    });
+    for (name, body) in created.collect::<Vec<_>>().iter().map(|(n, b)| (*n, b.as_str())).chain(parts.iter().copied()) {
+        out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
+        out.write_all(body.as_bytes()).unwrap();
+    }
+    out.finish().unwrap().into_inner()
+}
+
+/// The `package` examples of checking `source`.
+fn package_of(source: &[u8]) -> Vec<String> {
+    let r = check_bytes("t.xlsx", source, &Options::default());
+    r.round_trip.categories.iter().find(|c| c.name == "package").unwrap().examples.clone()
+}
+
+fn plain() -> Vec<u8> {
+    gridcraft_engine::io::save_bytes(&book(&[("A1", "1", n(1.0))]), "t.xlsx").unwrap()
+}
+
+#[test]
+fn package_reports_relationship_kinds_the_output_lost() {
+    // A kind GridCraft doesn't know is dropped on save; a calculation chain is never written
+    // (Excel rebuilds it), so its absence isn't a loss.
+    let calc_chain = r#"<Relationship Id="rId91" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain" Target="calcChain.xml"/>"#;
+    let source = with_rels(&plain(), &[(WB_RELS, &format!("{MADE_UP}{calc_chain}"))], &[MADE_UP_PART, ("xl/calcChain.xml", "<calcChain/>")]);
+    assert_eq!(package_of(&source), ["lost relationship madeUp"]);
+    assert!(check_bytes("t.xlsx", &plain(), &Options::default()).round_trip.is_clean());
+}
+
+// In the three tests below the made-up kind stays lost, so the comparison is known to run.
+
+#[test]
+fn an_internal_link_written_as_a_relationship_is_not_a_loss() {
+    // openpyxl writes `#Sheet1!B2` as an external relationship; GridCraft writes `location`.
+    let link = r##"<Relationship Id="rId5" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="#Sheet1!B2" TargetMode="External"/>"##;
+    let source = with_rels(&plain(), &[(WB_RELS, MADE_UP), (SHEET_RELS, link)], &[MADE_UP_PART]);
+    assert_eq!(package_of(&source), ["lost relationship madeUp"]);
+}
+
+#[test]
+fn comments_without_a_comment_are_not_a_loss() {
+    let rels = r#"<Relationship Id="rId6" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="../comments1.xml"/><Relationship Id="rId7" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing" Target="../drawings/vmlDrawing1.vml"/>"#;
+    let comments = r#"<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><authors><author>A</author></authors><commentList/></comments>"#;
+    let vml = r#"<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office"><o:shapelayout><o:idmap data="1"/></o:shapelayout><v:shapetype id="_x0000_t202" path="m,l,21600r21600,l21600,xe"><v:path gradientshapeok="t"/></v:shapetype></xml>"#;
+    let source = with_rels(
+        &plain(),
+        &[(WB_RELS, MADE_UP), (SHEET_RELS, rels)],
+        &[MADE_UP_PART, ("xl/comments1.xml", comments), ("xl/drawings/vmlDrawing1.vml", vml)],
+    );
+    assert_eq!(package_of(&source), ["lost relationship madeUp"]);
+}
+
+#[test]
+fn empty_drawings_and_person_lists_are_not_a_loss() {
+    let drawing = r#"<Relationship Id="rId8" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing1.xml"/>"#;
+    let person =
+        r#"<Relationship Id="rId92" Type="http://schemas.microsoft.com/office/2017/10/relationships/person" Target="persons/person.xml"/>"#;
+    let source = with_rels(
+        &plain(),
+        &[(WB_RELS, &format!("{MADE_UP}{person}")), (SHEET_RELS, drawing)],
+        &[
+            MADE_UP_PART,
+            ("xl/drawings/drawing1.xml", r#"<xdr:wsDr xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"/>"#),
+            ("xl/persons/person.xml", r#"<personList xmlns="http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments"/>"#),
+        ],
+    );
+    assert_eq!(package_of(&source), ["lost relationship madeUp"]);
+}
+
+#[test]
+fn json_lists_warning_messages() {
+    let with = FileReport { path: "a.ods".into(), warnings: vec!["ODS data-only import".into()], ..Default::default() };
+    let without = FileReport { path: "b.xlsx".into(), ..Default::default() };
+    let v = report_json(&[with, without], &Options::default());
+    assert_eq!(v["files"][0]["warnings"], json!(["ODS data-only import"]));
+    assert_eq!(v["files"][1]["warnings"], json!([]));
+}
+
+#[test]
+fn unopenable_files_are_reported() {
+    let r = check_bytes("broken.xlsx", b"PK\x03\x04 not really", &Options::default());
+    assert!(r.error.is_some());
+    assert!(!r.is_clean());
+}
+
+#[test]
+fn json_schema_keys() {
+    let wb = book(&[("A1", "=1+1", n(3.0))]);
+    let reports = vec![check(&wb, &Options::default()), check_bytes("bad.xlsx", b"", &Options::default())];
+    let v = report_json(&reports, &Options::default());
+    let keys = |v: &Json| v.as_object().unwrap().keys().cloned().collect::<BTreeSet<String>>();
+    let set = |k: &[&str]| k.iter().map(|s| s.to_string()).collect::<BTreeSet<String>>();
+    assert_eq!(keys(&v), set(&["schema", "tolerance", "files", "totals", "functions", "signatures"]));
+    assert_eq!(v["schema"], SCHEMA);
+    let f = &v["files"][0];
+    assert_eq!(keys(f), set(&["path", "opened", "error", "warnings", "calc", "roundTrip"]));
+    assert_eq!(
+        keys(&f["calc"]),
+        set(&[
+            "formulaCells",
+            "checked",
+            "matched",
+            "mismatched",
+            "noOracle",
+            "staleCache",
+            "volatile",
+            "boolAsNumber",
+            "mismatches",
+            "functions",
+            "signatures"
+        ])
+    );
+    assert_eq!(f["calc"]["signatures"], json!({"number → number": 1}));
+    assert_eq!(keys(&f["calc"]["mismatches"][0]), set(&["cell", "formula", "expected", "actual", "kind", "functions", "primary"]));
+    assert_eq!(f["calc"]["mismatches"][0]["expected"], json!(3.0));
+    assert_eq!(keys(&f["roundTrip"]), set(&["error", "differing", "categories"]));
+    assert_eq!(
+        keys(&f["roundTrip"]["categories"]),
+        set(&[
+            "sheets",
+            "values",
+            "formulas",
+            "numFmts",
+            "merges",
+            "names",
+            "tables",
+            "condFormats",
+            "validations",
+            "charts",
+            "comments",
+            "hyperlinks",
+            "pivots",
+            "package"
+        ])
+    );
+    assert_eq!(keys(&f["roundTrip"]["categories"]["values"]), set(&["equal", "diffs", "examples"]));
+    assert_eq!(v["files"][1]["opened"], json!(false));
+    assert_eq!(
+        keys(&v["totals"]),
+        set(&[
+            "files",
+            "opened",
+            "failedToOpen",
+            "formulaCells",
+            "checked",
+            "matched",
+            "mismatched",
+            "noOracle",
+            "volatile",
+            "boolAsNumber",
+            "roundTripFailed",
+            "roundTripDiffering",
+            "categoriesDiffering"
+        ])
+    );
+    assert_eq!(keys(&v["functions"][0]), set(&["name", "checked", "mismatched", "primary"]));
+}

From 97c2a984e031066645b12f146420e762faa4db96 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:39 +0000
Subject: [PATCH 26/76] refactor(engine): move cmd/data tests to
 src/cmd/data/tests.rs

---
 crates/engine/src/cmd/data.rs       | 513 +---------------------------
 crates/engine/src/cmd/data/tests.rs | 510 +++++++++++++++++++++++++++
 2 files changed, 511 insertions(+), 512 deletions(-)
 create mode 100644 crates/engine/src/cmd/data/tests.rs

diff --git a/crates/engine/src/cmd/data.rs b/crates/engine/src/cmd/data.rs
index fcab9db71..646d44bd9 100644
--- a/crates/engine/src/cmd/data.rs
+++ b/crates/engine/src/cmd/data.rs
@@ -1578,515 +1578,4 @@ fn subtotal(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn filter_blanks_include_empty_text_and_formula_results() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["id", "f"], ["e", null], ["ef", "=\"\""], ["sp", " "], ["z", 0]]})).unwrap();
-        s.execute("data.filter", json!({"range": "A1:B5"})).unwrap();
-        let r = s.execute("data.filterBy", json!({"column": "B", "values": [], "blanks": true})).unwrap();
-        assert_eq!(r["hiddenRows"], json!(2));
-        let vals = filter_values(&s.doc().unwrap().wb, 0, 1);
-        // The `=""` result joins (Blanks) instead of showing as its own empty entry.
-        assert!(!vals.iter().any(|(t, _)| t.is_empty()), "{vals:?}");
-        let blanks: Vec<_> = vals.into_iter().filter(|(t, _)| t == "(Blanks)").collect();
-        assert_eq!(blanks, vec![("(Blanks)".to_string(), true)]);
-    }
-
-    #[test]
-    fn subtotal_honours_header_false() {
-        // #131: with header:false the first data row was treated as a header and left out of its
-        // group's subtotal and the grand total.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["East", 10], ["East", 20], ["West", 30], ["West", 40]]})).unwrap();
-        s.execute("data.subtotal", json!({"range": "A1:B4", "groupBy": "A", "function": "sum", "columns": ["B"], "header": false})).unwrap();
-        let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-        assert_eq!(get(&mut s, "A1")["value"], json!("East"));
-        assert_eq!(get(&mut s, "A3")["text"], json!("East Total"));
-        assert_eq!(get(&mut s, "B3")["value"], json!(30.0), "East's subtotal counts both East rows");
-        assert_eq!(get(&mut s, "A7")["text"], json!("Grand Total"));
-        assert_eq!(get(&mut s, "B7")["value"], json!(100.0), "the grand total counts every data row");
-    }
-
-    #[test]
-    fn subtotal_puts_summary_rows_below_their_detail() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Sales"], ["East", 10], ["East", 20], ["West", 30]]})).unwrap();
-        s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
-        s.execute("data.subtotal", json!({"range": "A1:B4", "groupBy": "A", "columns": ["B"]})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap().clone();
-        assert!(sh.summary_below, "the totals sit below their groups");
-        // East's detail is rows 2–3 and its total row 4: collapsing level 1 keeps the total showing.
-        s.execute("data.showLevels", json!({"rows": 1})).unwrap();
-        let hidden = |s: &Session, row: u32| s.doc().unwrap().wb.active().unwrap().is_row_hidden(row);
-        assert!(hidden(&s, 1) && hidden(&s, 2), "East's detail rows are hidden");
-        assert!(!hidden(&s, 3), "East Total stays visible");
-        // One undo takes the subtotals and the setting back.
-        s.execute("edit.undo", json!({})).unwrap();
-        s.execute("edit.undo", json!({})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert!(!sh.summary_below);
-        assert_eq!(sh.value(CellRef::new(3, 0)).display(), "West");
-    }
-
-    #[test]
-    fn filter_by_huge_numeric_column_is_rejected_not_overflowed() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "B1", "values": [["Name", "Qty"], ["a", 1], ["b", 2]]})).unwrap();
-        s.execute("data.filter", json!({"range": "B1:C3"})).unwrap();
-        for col in [json!(2), json!(u64::from(u32::MAX)), json!(u64::MAX)] {
-            let err = s.execute("data.filterBy", json!({"column": col, "values": ["a"]})).unwrap_err();
-            assert!(err.to_string().contains("column outside the filter range"), "{col}: {err}");
-        }
-        let ok = s.execute("data.filterBy", json!({"column": 0, "values": ["a"]})).unwrap();
-        assert_eq!(ok["hiddenRows"], json!(1));
-    }
-
-    #[test]
-    fn filter_by_inside_a_table_installs_the_autofilter_and_keeps_the_button() {
-        for sel in [json!({"cell": "A1"}), json!({"cell": "A2"}), json!({"range": "A1:A3"})] {
-            let mut s = Session::new();
-            s.new_workbook();
-            s.execute("range.setValues", json!({"range": "A1", "values": [["H"], ["a"], ["b"]]})).unwrap();
-            s.execute("insert.table", json!({"range": "A1:A3", "header": true})).unwrap();
-            s.execute("selection.set", sel.clone()).unwrap();
-            s.execute("data.filterBy", json!({"column": "A", "values": ["a"]})).unwrap();
-            let sh = s.doc().unwrap().wb.active().unwrap();
-            assert_eq!(sh.autofilter.as_ref().map(|a| a.range.a1()), Some("A1:A3".to_string()), "{sel}");
-            assert!(sh.tables[0].filter_button, "{sel}");
-            assert!(!sh.is_row_hidden(1), "{sel}");
-            assert!(sh.is_row_hidden(2), "{sel}");
-            assert_eq!(sh.value(CellRef::new(2, 0)).display(), "b", "{sel}");
-        }
-    }
-
-    #[test]
-    fn autofilter_range_grows_when_a_value_is_entered_in_the_row_below() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "Qty"], ["d", 4], ["b", 2]]})).unwrap();
-        s.execute("data.filter", json!({"range": "A1:B3"})).unwrap();
-        let range = |s: &Session| s.doc().unwrap().wb.active().unwrap().autofilter.as_ref().map(|a| a.range.a1());
-        s.execute("cell.set", json!({"cell": "A4", "input": "e"})).unwrap();
-        assert_eq!(range(&s), Some("A1:B4".to_string()));
-        s.execute("range.setValues", json!({"range": "A5", "values": [["f", 6]]})).unwrap();
-        assert_eq!(range(&s), Some("A1:B5".to_string()));
-        // A row typed after a blank row does not grow it.
-        s.execute("cell.set", json!({"cell": "A7", "input": "x"})).unwrap();
-        assert_eq!(range(&s), Some("A1:B5".to_string()));
-        // A cell outside the filter's columns does not either.
-        s.execute("cell.set", json!({"cell": "C6", "input": "x"})).unwrap();
-        assert_eq!(range(&s), Some("A1:B5".to_string()));
-        // Empty text is a blank entry, not a value.
-        s.execute("range.setValues", json!({"range": "A6", "parse": false, "values": [[""]]})).unwrap();
-        assert_eq!(range(&s), Some("A1:B5".to_string()));
-        // A formula and Ctrl+Enter (range.fill) are entries too.
-        s.execute("cell.set", json!({"cell": "B6", "input": "=1+1"})).unwrap();
-        assert_eq!(range(&s), Some("A1:B6".to_string()));
-        s.execute("range.fill", json!({"range": "A7:B7", "input": "g"})).unwrap();
-        assert_eq!(range(&s), Some("A1:B7".to_string()));
-    }
-
-    #[test]
-    fn list_validation_without_formula1_is_an_error() {
-        let mut s = Session::new();
-        s.new_workbook();
-        assert!(s.execute("data.validation", json!({"range": "A1:A3", "type": "list", "source": "\"a,b,c\""})).is_err());
-        assert!(s.execute("data.validation", json!({"range": "A1:A3", "type": "list"})).is_err());
-        assert!(s.doc().unwrap().wb.active().unwrap().validations.is_empty());
-        s.execute("data.validation", json!({"range": "A1:A3", "type": "list", "formula1": "\"a,b,c\""})).unwrap();
-        assert_eq!(s.execute("data.validate", json!({"cell": "A1", "input": "a"})).unwrap()["ok"], json!(true));
-    }
-
-    #[test]
-    fn partial_validation_edits_keep_the_rest_of_the_old_rule() {
-        let mut s = Session::new();
-        s.new_workbook();
-        let rule = |range: &str, lo: &str, hi: &str| json!({"range": range, "type": "whole", "operator": "between", "formula1": lo, "formula2": hi});
-        let ok = |s: &mut Session, cell: &str, input: &str| {
-            s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == json!(true)
-        };
-        s.execute("data.validation", rule("B1:B3", "1", "10")).unwrap();
-        s.execute("data.validation", json!({"range": "B2", "clear": true})).unwrap();
-        assert!(ok(&mut s, "B2", "999"));
-        assert!(!ok(&mut s, "B1", "999"));
-        assert!(!ok(&mut s, "B3", "999"));
-        s.execute("data.validation", rule("B2:B4", "100", "200")).unwrap();
-        for cell in ["B2", "B3", "B4"] {
-            assert!(ok(&mut s, cell, "150"), "{cell}");
-            assert!(!ok(&mut s, cell, "5"), "{cell}");
-        }
-        assert!(ok(&mut s, "B1", "5"));
-        assert!(!ok(&mut s, "B1", "150"));
-    }
-
-    #[test]
-    fn showing_detail_gives_zero_width_columns_their_width_back() {
-        // #1714: templates hide grouped columns as `width="0" hidden="1"`; + must show them.
-        let mut s = Session::new();
-        s.new_workbook();
-        let hidden = LineInfo { size: Some(0.0), hidden: true, outline: 1, ..LineInfo::default() };
-        let sh = Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-        for c in 2..=4 {
-            sh.cols.insert(c, hidden);
-        }
-        sh.cols.insert(5, LineInfo { collapsed: true, ..LineInfo::default() });
-        s.execute("data.showDetail", json!({"cols": "C:E", "level": 1})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        for c in 2..=4 {
-            assert_eq!(sh.col_width(c), sh.default_col_width, "column {c}");
-        }
-        // Hiding again hides them; the level buttons show zero-width columns too.
-        s.execute("data.hideDetail", json!({"cols": "C:E", "level": 1})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.active().unwrap().col_width(2), 0.0);
-        Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().cols.insert(3, hidden);
-        s.execute("data.showLevels", json!({"cols": 2})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert_eq!((sh.col_width(2), sh.col_width(3)), (sh.default_col_width, sh.default_col_width));
-    }
-
-    #[test]
-    fn removing_an_autofilter_keeps_manually_hidden_and_collapsed_rows() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["H"], ["a"], ["b"], ["c"]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "A10", "values": [["z"]]})).unwrap();
-        s.execute("data.group", json!({"rows": "2:4"})).unwrap();
-        s.execute("data.hideDetail", json!({"rows": "2:4"})).unwrap();
-        s.execute("home.hideRows", json!({"rows": "10:10"})).unwrap();
-        let hidden = |s: &Session| -> Vec<u32> {
-            let sh = s.doc().unwrap().wb.active().unwrap();
-            sh.rows.iter().filter(|(_, l)| l.hidden).map(|(r, _)| *r).collect()
-        };
-        let before = hidden(&s);
-        assert_eq!(before, [1, 2, 3, 9]);
-        s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
-        s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
-        assert!(s.doc().unwrap().wb.active().unwrap().autofilter.is_none());
-        assert_eq!(hidden(&s), before);
-        assert_eq!(row_state(&s, 4..=4), [(false, true)]);
-    }
-
-    #[test]
-    fn table_dropdown_setup_outside_the_table_keeps_manually_hidden_rows() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["H"], ["a"], ["b"], ["c"]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "A10", "values": [["z"]]})).unwrap();
-        s.execute("insert.table", json!({"range": "A1:A4", "header": true})).unwrap();
-        s.execute("home.hideRows", json!({"rows": "3:3"})).unwrap();
-        s.execute("home.hideRows", json!({"rows": "10:10"})).unwrap();
-        s.execute("selection.set", json!({"range": "E1"})).unwrap();
-        // The table filter dropdown installs an AutoFilter on demand by toggling `data.filter` twice.
-        s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
-        s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert_eq!(sh.rows.iter().filter(|(_, l)| l.hidden).map(|(r, _)| *r).collect::<Vec<_>>(), [2, 9]);
-    }
-
-    /// Rows 5:8 grouped, with 6:7 grouped again inside (0-based 4..=7 and 5..=6).
-    fn nested_rows() -> Session {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("data.group", json!({"rows": "5:8"})).unwrap();
-        s.execute("data.group", json!({"rows": "6:7"})).unwrap();
-        s
-    }
-
-    /// (hidden, collapsed) of 0-based rows.
-    fn row_state(s: &Session, rows: std::ops::RangeInclusive<u32>) -> Vec<(bool, bool)> {
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        rows.map(|r| sh.rows.get(&r).map(|l| (l.hidden, l.collapsed)).unwrap_or_default()).collect()
-    }
-
-    #[test]
-    fn hide_detail_marks_the_summary_collapsed_and_show_detail_keeps_inner_groups_collapsed() {
-        let mut s = nested_rows();
-        s.execute("data.hideDetail", json!({"rows": "6:7", "level": 2})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(false, false), (true, false), (true, false), (false, true), (false, false)]);
-        s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(true, false), (true, false), (true, false), (true, true), (false, true)]);
-        s.execute("data.showDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(false, false), (true, false), (true, false), (false, true), (false, false)]);
-        s.execute("data.showDetail", json!({"rows": "6:7", "level": 2})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(false, false); 5]);
-        // Each step is one undoable command.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(row_state(&s, 5..=7), [(true, false), (true, false), (false, true)]);
-    }
-
-    #[test]
-    fn hide_detail_on_the_summary_row_collapses_the_group_above_it() {
-        let mut s = nested_rows();
-        s.execute("data.hideDetail", json!({"rows": "9:9"})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(true, false), (true, false), (true, false), (true, false), (false, true)]);
-    }
-
-    #[test]
-    fn show_levels_collapses_and_expands_to_a_level() {
-        let mut s = nested_rows();
-        s.execute("data.showLevels", json!({"rows": 1})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(true, false), (true, false), (true, false), (true, true), (false, true)]);
-        s.execute("data.showLevels", json!({"rows": 2})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(false, false), (true, false), (true, false), (false, true), (false, false)]);
-        s.execute("data.showLevels", json!({"rows": 3})).unwrap();
-        assert_eq!(row_state(&s, 4..=8), [(false, false); 5]);
-        // Columns are separate; no level at all is an error rather than a guess.
-        s.execute("data.group", json!({"cols": "C:E"})).unwrap();
-        s.execute("data.showLevels", json!({"cols": 1})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert!((2..=4).all(|c| sh.cols.get(&c).is_some_and(|l| l.hidden)));
-        assert!(sh.cols.get(&5).is_some_and(|l| l.collapsed));
-        assert_eq!(row_state(&s, 4..=4), [(false, false)]);
-        assert!(s.execute("data.showLevels", json!({})).is_err());
-    }
-
-    #[test]
-    fn group_by_columns_for_a_block_of_cells() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("selection.set", json!({"range": "B2:C5"})).unwrap();
-        s.execute("data.group", json!({"by": "cols"})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert!((1..=2).all(|c| sh.cols.get(&c).is_some_and(|l| l.outline == 1)));
-        assert!(sh.rows.values().all(|l| l.outline == 0));
-    }
-
-    #[test]
-    fn group_shortcuts_are_the_windows_ones() {
-        let sc = |id: &str| specs().into_iter().find(|c| c.id == id).and_then(|c| c.shortcut);
-        assert_eq!(sc("data.group"), Some("Alt+Shift+Right"));
-        assert_eq!(sc("data.ungroup"), Some("Alt+Shift+Left"));
-    }
-
-    #[test]
-    fn summary_rows_above_the_detail_take_the_collapsed_mark() {
-        let mut s = nested_rows();
-        let r = s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
-        assert_eq!(r, json!({"summaryBelow": false, "summaryRight": true}));
-        // Row 4 (index 3) is the outer group's summary, row 5 the inner one's.
-        s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        assert_eq!(row_state(&s, 3..=8), [(false, true), (true, false), (true, false), (true, false), (true, false), (false, false)]);
-        s.execute("data.showDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        assert_eq!(row_state(&s, 3..=8), [(false, false); 6]);
-        // Hide Detail on the summary row collapses the group below it.
-        s.execute("data.hideDetail", json!({"rows": "4:4"})).unwrap();
-        assert_eq!(row_state(&s, 3..=4), [(false, true), (true, false)]);
-        s.execute("data.showLevels", json!({"rows": 1})).unwrap();
-        assert_eq!(row_state(&s, 3..=8), [(false, true), (true, true), (true, false), (true, false), (true, false), (false, false)]);
-        // Ungrouping the outer group clears its mark on the row above.
-        s.execute("data.showLevels", json!({"rows": 3})).unwrap();
-        s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        s.execute("data.ungroup", json!({"rows": "5:8"})).unwrap();
-        assert_eq!(row_state(&s, 3..=3), [(false, false)]);
-    }
-
-    #[test]
-    fn changing_the_summary_direction_moves_collapsed_marks() {
-        let mut s = nested_rows();
-        s.execute("data.group", json!({"cols": "C:E"})).unwrap();
-        s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        s.execute("data.hideDetail", json!({"cols": "C:E"})).unwrap();
-        s.execute("data.outlineSettings", json!({"summaryBelow": false, "summaryRight": false})).unwrap();
-        let col_marked = |s: &Session, c: u32| s.doc().unwrap().wb.active().unwrap().cols.get(&c).is_some_and(|l| l.collapsed);
-        assert_eq!(row_state(&s, 3..=8).iter().map(|r| r.1).collect::<Vec<_>>(), [true, false, false, false, false, false]);
-        assert!(col_marked(&s, 1) && !col_marked(&s, 5));
-        s.execute("data.outlineSettings", json!({"summaryBelow": true})).unwrap();
-        assert_eq!(row_state(&s, 3..=8).iter().map(|r| r.1).collect::<Vec<_>>(), [false, false, false, false, false, true]);
-        assert!(col_marked(&s, 1), "columns keep their direction");
-        // One undo step per change; no params leaves the settings as they are.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert!(row_state(&s, 3..=3)[0].1);
-        assert_eq!(s.execute("data.outlineSettings", json!({})).unwrap(), json!({"summaryBelow": false, "summaryRight": false}));
-        // Nested groups that end on one row share its mark: it moves to the outer group only.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("data.group", json!({"rows": "5:8"})).unwrap();
-        s.execute("data.group", json!({"rows": "6:8"})).unwrap();
-        s.execute("data.showLevels", json!({"rows": 1})).unwrap();
-        s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
-        assert_eq!(row_state(&s, 3..=8).iter().map(|r| r.1).collect::<Vec<_>>(), [true, false, false, false, false, false]);
-        s.execute("data.showDetail", json!({"rows": "4:4"})).unwrap();
-        assert_eq!(row_state(&s, 3..=8), [(false, false); 6]);
-        // With only the inner group collapsed, its mark goes to row 5, and the outer group's
-        // Hide and Show Detail keep it collapsed.
-        s.execute("data.outlineSettings", json!({"summaryBelow": true})).unwrap();
-        s.execute("data.hideDetail", json!({"rows": "6:8", "level": 2})).unwrap();
-        s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
-        assert_eq!(row_state(&s, 3..=8), [(false, false), (false, true), (true, false), (true, false), (true, false), (false, false)]);
-        s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        s.execute("data.showDetail", json!({"rows": "5:8", "level": 1})).unwrap();
-        assert_eq!(row_state(&s, 3..=8), [(false, false), (false, true), (true, false), (true, false), (true, false), (false, false)]);
-        // A group on the first row has no row above it to mark.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("data.group", json!({"rows": "1:3"})).unwrap();
-        s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
-        s.execute("data.hideDetail", json!({"rows": "1:3"})).unwrap();
-        assert_eq!(row_state(&s, 0..=3), [(true, false), (true, false), (true, false), (false, false)]);
-    }
-
-    #[test]
-    fn column_sort_rejects_row_key_zero_without_panicking() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("cell.set", json!({"cell": "A1", "input": "2"})).unwrap();
-        for row in [0u64, 1 << 32] {
-            let params = json!({"range": "A1:B2", "header": false, "orientation": "columns", "keys": [{"row": row}]});
-            let err = s.execute("data.sort", params).unwrap_err();
-            assert!(matches!(err, EngineError::BadParams { .. }), "row {row}: {err:?}");
-        }
-    }
-
-    #[test]
-    fn single_row_and_column_parameters() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2], [3, 4]]})).unwrap();
-        s.execute("home.insertRows", json!({"rows": "2"})).unwrap();
-        s.execute("home.insertColumns", json!({"cols": "B"})).unwrap();
-        let v = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["value"].clone();
-        assert_eq!(v(&mut s, "C3"), json!(4.0));
-        s.execute("home.hideRows", json!({"rows": "1"})).unwrap();
-        s.execute("data.group", json!({"cols": "C"})).unwrap();
-        assert!(s.execute("home.deleteRows", json!({"rows": "0"})).is_err());
-        s.execute("home.deleteRows", json!({"rows": "2"})).unwrap();
-        s.execute("home.deleteColumns", json!({"cols": "B"})).unwrap();
-        assert_eq!(v(&mut s, "B2"), json!(4.0));
-    }
-
-    #[test]
-    fn t2c_fixed_widths_are_positions_in_any_order_without_duplicates() {
-        let cases: [(Json, [&str; 4]); 5] = [
-            (json!([6, 3]), ["abc", "def", "ghij", ""]),
-            (json!([3, 3]), ["abc", "defghij", "", ""]),
-            (json!([0]), ["abcdefghij", "", "", ""]),
-            (json!([20]), ["abcdefghij", "", "", ""]),
-            (json!([7, 0, 3, 7, 10]), ["abc", "defg", "hij", ""]),
-        ];
-        for (widths, want) in cases {
-            let mut s = Session::new();
-            s.new_workbook();
-            s.execute("cell.set", json!({"cell": "A1", "input": "abcdefghij"})).unwrap();
-            s.execute("data.textToColumns", json!({"range": "A1:A1", "fixedWidths": widths})).unwrap();
-            let sh = s.doc().unwrap().wb.active().unwrap();
-            let got: Vec<String> = (0..4).map(|c| sh.value(CellRef::new(0, c)).display()).collect();
-            assert_eq!(got, want, "{widths}");
-        }
-    }
-
-    #[test]
-    fn split() {
-        assert_eq!(split_delimited("a,b,,c", &[','], false, '"'), ["a", "b", "", "c"]);
-        assert_eq!(split_delimited("a,b,,c", &[','], true, '"'), ["a", "b", "c"]);
-        assert_eq!(split_delimited("\"x,y\",z", &[','], false, '"'), ["x,y", "z"]);
-    }
-
-    #[test]
-    fn remove_duplicates_without_a_valid_column_is_refused() {
-        // `columns: []` (or only unusable names) used to compare nothing and delete every row
-        // but the first.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["a"], ["b"], ["c"]]})).unwrap();
-        for columns in [json!([]), json!(["ZZZ"])] {
-            let err = s.execute("data.removeDuplicates", json!({"range": "A1:A3", "columns": columns})).unwrap_err();
-            assert!(err.to_string().contains("columns"), "{err}");
-        }
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert_eq!(sh.value(CellRef::new(0, 0)), Value::text("a"));
-        assert_eq!(sh.value(CellRef::new(2, 0)), Value::text("c"));
-    }
-
-    #[test]
-    fn a_list_typed_without_quotes_is_saved_as_a_quoted_list() {
-        // In a file an inline list is a string literal (`"a,b"`); unquoted it reads as a formula.
-        // References, names and formulas stay unquoted, and every rule survives a save and reopen.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "K1:K3", "values": [["Red"], ["Green"], ["Blue"]]})).unwrap();
-        s.execute("formulas.defineName", json!({"name": "Colors", "refersTo": "=Sheet1!$K$1:$K$3"})).unwrap();
-        let rules = [
-            ("A1", "Open,In progress,Closed", r#""Open,In progress,Closed""#),
-            ("B1", r#""Open,In progress,Closed""#, r#""Open,In progress,Closed""#),
-            ("C1", " 1,2,3 ", r#""1,2,3""#),
-            ("D1", r#"Say "hi",Bye"#, r#""Say ""hi"",Bye""#),
-            ("E1", "=$K$1:$K$3", "$K$1:$K$3"),
-            ("F1", "$K$1:$K$3", "$K$1:$K$3"),
-            ("G1", "=Colors", "Colors"),
-            ("H1", "Sheet1!$K$1:$K$3", "Sheet1!$K$1:$K$3"),
-            ("I1", "=OFFSET($K$1,0,0,3,1)", "OFFSET($K$1,0,0,3,1)"),
-        ];
-        for (cell, source, _) in rules {
-            s.execute("data.validation", json!({"range": cell, "type": "list", "formula1": source})).unwrap();
-        }
-        let accepted = [
-            ("A1", "In progress"),
-            ("B1", "Closed"),
-            ("C1", "2"),
-            ("D1", r#"Say "hi""#),
-            ("E1", "Green"),
-            ("F1", "Blue"),
-            ("G1", "Red"),
-            ("H1", "Green"),
-        ];
-        let check = |wb: &Workbook| {
-            for (cell, input) in accepted {
-                let at = CellRef::parse(cell).unwrap();
-                assert!(check_validation(wb, 0, at, input).is_none(), "{cell} refuses {input}");
-                assert!(check_validation(wb, 0, at, "Pending").is_some(), "{cell} accepts Pending");
-            }
-        };
-        let wb = s.doc().unwrap().wb.clone();
-        check(&wb);
-
-        let sheet_xml = |wb: &Workbook| {
-            let bytes = gridcraft_xlsx::write_xlsx(wb).unwrap();
-            let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
-            let mut xml = String::new();
-            std::io::Read::read_to_string(&mut zip.by_name("xl/worksheets/sheet1.xml").unwrap(), &mut xml).unwrap();
-            xml
-        };
-        let xml = sheet_xml(&wb);
-        for (cell, _, saved) in rules {
-            assert!(xml.contains(&format!(r#"sqref="{cell}"><formula1>{saved}</formula1>"#)), "{cell}: {saved} missing from {xml}");
-        }
-        let (reopened, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
-        check(&reopened);
-        assert_eq!(sheet_xml(&reopened), xml, "a second save writes the same rules");
-    }
-
-    #[test]
-    fn a_rule_with_an_unknown_type_operator_or_error_style_is_refused() {
-        // A typo used to give a rule that validates nothing (`type="none"`) or the wrong check,
-        // with no error.
-        let mut s = Session::new();
-        s.new_workbook();
-        for params in [
-            json!({"range": "A1", "type": "lst", "formula1": "\"a,b\""}),
-            json!({"range": "A1", "type": "whole", "operator": "greaterthan", "formula1": "1"}),
-            json!({"range": "A1", "type": "whole", "operator": ">", "formula1": "1"}),
-            json!({"range": "A1", "type": "list", "formula1": "\"a,b\"", "errorStyle": "warn"}),
-        ] {
-            let e = s.execute("data.validation", params.clone()).unwrap_err().to_string();
-            assert!(e.contains("unknown"), "{params}: {e}");
-        }
-        assert!(s.doc().unwrap().wb.active().unwrap().validations.is_empty());
-        for params in [
-            json!({"range": "A1", "type": "any"}),
-            json!({"range": "A2", "type": "whole", "operator": "greaterThan", "formula1": "1"}),
-            json!({"range": "A3", "type": "list", "formula1": "\"a,b\"", "errorStyle": "warning"}),
-        ] {
-            s.execute("data.validation", params).unwrap();
-        }
-        let sh = s.doc().unwrap().wb.active().unwrap().clone();
-        assert_eq!(sh.validations.len(), 3);
-        assert!(check_validation(&s.doc().unwrap().wb, 0, CellRef::parse("A2").unwrap(), "0").is_some());
-    }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/data/tests.rs b/crates/engine/src/cmd/data/tests.rs
new file mode 100644
index 000000000..8708fbf75
--- /dev/null
+++ b/crates/engine/src/cmd/data/tests.rs
@@ -0,0 +1,510 @@
+use super::*;
+
+#[test]
+fn filter_blanks_include_empty_text_and_formula_results() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["id", "f"], ["e", null], ["ef", "=\"\""], ["sp", " "], ["z", 0]]})).unwrap();
+    s.execute("data.filter", json!({"range": "A1:B5"})).unwrap();
+    let r = s.execute("data.filterBy", json!({"column": "B", "values": [], "blanks": true})).unwrap();
+    assert_eq!(r["hiddenRows"], json!(2));
+    let vals = filter_values(&s.doc().unwrap().wb, 0, 1);
+    // The `=""` result joins (Blanks) instead of showing as its own empty entry.
+    assert!(!vals.iter().any(|(t, _)| t.is_empty()), "{vals:?}");
+    let blanks: Vec<_> = vals.into_iter().filter(|(t, _)| t == "(Blanks)").collect();
+    assert_eq!(blanks, vec![("(Blanks)".to_string(), true)]);
+}
+
+#[test]
+fn subtotal_honours_header_false() {
+    // #131: with header:false the first data row was treated as a header and left out of its
+    // group's subtotal and the grand total.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["East", 10], ["East", 20], ["West", 30], ["West", 40]]})).unwrap();
+    s.execute("data.subtotal", json!({"range": "A1:B4", "groupBy": "A", "function": "sum", "columns": ["B"], "header": false})).unwrap();
+    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
+    assert_eq!(get(&mut s, "A1")["value"], json!("East"));
+    assert_eq!(get(&mut s, "A3")["text"], json!("East Total"));
+    assert_eq!(get(&mut s, "B3")["value"], json!(30.0), "East's subtotal counts both East rows");
+    assert_eq!(get(&mut s, "A7")["text"], json!("Grand Total"));
+    assert_eq!(get(&mut s, "B7")["value"], json!(100.0), "the grand total counts every data row");
+}
+
+#[test]
+fn subtotal_puts_summary_rows_below_their_detail() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Sales"], ["East", 10], ["East", 20], ["West", 30]]})).unwrap();
+    s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
+    s.execute("data.subtotal", json!({"range": "A1:B4", "groupBy": "A", "columns": ["B"]})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap().clone();
+    assert!(sh.summary_below, "the totals sit below their groups");
+    // East's detail is rows 2–3 and its total row 4: collapsing level 1 keeps the total showing.
+    s.execute("data.showLevels", json!({"rows": 1})).unwrap();
+    let hidden = |s: &Session, row: u32| s.doc().unwrap().wb.active().unwrap().is_row_hidden(row);
+    assert!(hidden(&s, 1) && hidden(&s, 2), "East's detail rows are hidden");
+    assert!(!hidden(&s, 3), "East Total stays visible");
+    // One undo takes the subtotals and the setting back.
+    s.execute("edit.undo", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert!(!sh.summary_below);
+    assert_eq!(sh.value(CellRef::new(3, 0)).display(), "West");
+}
+
+#[test]
+fn filter_by_huge_numeric_column_is_rejected_not_overflowed() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "B1", "values": [["Name", "Qty"], ["a", 1], ["b", 2]]})).unwrap();
+    s.execute("data.filter", json!({"range": "B1:C3"})).unwrap();
+    for col in [json!(2), json!(u64::from(u32::MAX)), json!(u64::MAX)] {
+        let err = s.execute("data.filterBy", json!({"column": col, "values": ["a"]})).unwrap_err();
+        assert!(err.to_string().contains("column outside the filter range"), "{col}: {err}");
+    }
+    let ok = s.execute("data.filterBy", json!({"column": 0, "values": ["a"]})).unwrap();
+    assert_eq!(ok["hiddenRows"], json!(1));
+}
+
+#[test]
+fn filter_by_inside_a_table_installs_the_autofilter_and_keeps_the_button() {
+    for sel in [json!({"cell": "A1"}), json!({"cell": "A2"}), json!({"range": "A1:A3"})] {
+        let mut s = Session::new();
+        s.new_workbook();
+        s.execute("range.setValues", json!({"range": "A1", "values": [["H"], ["a"], ["b"]]})).unwrap();
+        s.execute("insert.table", json!({"range": "A1:A3", "header": true})).unwrap();
+        s.execute("selection.set", sel.clone()).unwrap();
+        s.execute("data.filterBy", json!({"column": "A", "values": ["a"]})).unwrap();
+        let sh = s.doc().unwrap().wb.active().unwrap();
+        assert_eq!(sh.autofilter.as_ref().map(|a| a.range.a1()), Some("A1:A3".to_string()), "{sel}");
+        assert!(sh.tables[0].filter_button, "{sel}");
+        assert!(!sh.is_row_hidden(1), "{sel}");
+        assert!(sh.is_row_hidden(2), "{sel}");
+        assert_eq!(sh.value(CellRef::new(2, 0)).display(), "b", "{sel}");
+    }
+}
+
+#[test]
+fn autofilter_range_grows_when_a_value_is_entered_in_the_row_below() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "Qty"], ["d", 4], ["b", 2]]})).unwrap();
+    s.execute("data.filter", json!({"range": "A1:B3"})).unwrap();
+    let range = |s: &Session| s.doc().unwrap().wb.active().unwrap().autofilter.as_ref().map(|a| a.range.a1());
+    s.execute("cell.set", json!({"cell": "A4", "input": "e"})).unwrap();
+    assert_eq!(range(&s), Some("A1:B4".to_string()));
+    s.execute("range.setValues", json!({"range": "A5", "values": [["f", 6]]})).unwrap();
+    assert_eq!(range(&s), Some("A1:B5".to_string()));
+    // A row typed after a blank row does not grow it.
+    s.execute("cell.set", json!({"cell": "A7", "input": "x"})).unwrap();
+    assert_eq!(range(&s), Some("A1:B5".to_string()));
+    // A cell outside the filter's columns does not either.
+    s.execute("cell.set", json!({"cell": "C6", "input": "x"})).unwrap();
+    assert_eq!(range(&s), Some("A1:B5".to_string()));
+    // Empty text is a blank entry, not a value.
+    s.execute("range.setValues", json!({"range": "A6", "parse": false, "values": [[""]]})).unwrap();
+    assert_eq!(range(&s), Some("A1:B5".to_string()));
+    // A formula and Ctrl+Enter (range.fill) are entries too.
+    s.execute("cell.set", json!({"cell": "B6", "input": "=1+1"})).unwrap();
+    assert_eq!(range(&s), Some("A1:B6".to_string()));
+    s.execute("range.fill", json!({"range": "A7:B7", "input": "g"})).unwrap();
+    assert_eq!(range(&s), Some("A1:B7".to_string()));
+}
+
+#[test]
+fn list_validation_without_formula1_is_an_error() {
+    let mut s = Session::new();
+    s.new_workbook();
+    assert!(s.execute("data.validation", json!({"range": "A1:A3", "type": "list", "source": "\"a,b,c\""})).is_err());
+    assert!(s.execute("data.validation", json!({"range": "A1:A3", "type": "list"})).is_err());
+    assert!(s.doc().unwrap().wb.active().unwrap().validations.is_empty());
+    s.execute("data.validation", json!({"range": "A1:A3", "type": "list", "formula1": "\"a,b,c\""})).unwrap();
+    assert_eq!(s.execute("data.validate", json!({"cell": "A1", "input": "a"})).unwrap()["ok"], json!(true));
+}
+
+#[test]
+fn partial_validation_edits_keep_the_rest_of_the_old_rule() {
+    let mut s = Session::new();
+    s.new_workbook();
+    let rule = |range: &str, lo: &str, hi: &str| json!({"range": range, "type": "whole", "operator": "between", "formula1": lo, "formula2": hi});
+    let ok = |s: &mut Session, cell: &str, input: &str| {
+        s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == json!(true)
+    };
+    s.execute("data.validation", rule("B1:B3", "1", "10")).unwrap();
+    s.execute("data.validation", json!({"range": "B2", "clear": true})).unwrap();
+    assert!(ok(&mut s, "B2", "999"));
+    assert!(!ok(&mut s, "B1", "999"));
+    assert!(!ok(&mut s, "B3", "999"));
+    s.execute("data.validation", rule("B2:B4", "100", "200")).unwrap();
+    for cell in ["B2", "B3", "B4"] {
+        assert!(ok(&mut s, cell, "150"), "{cell}");
+        assert!(!ok(&mut s, cell, "5"), "{cell}");
+    }
+    assert!(ok(&mut s, "B1", "5"));
+    assert!(!ok(&mut s, "B1", "150"));
+}
+
+#[test]
+fn showing_detail_gives_zero_width_columns_their_width_back() {
+    // #1714: templates hide grouped columns as `width="0" hidden="1"`; + must show them.
+    let mut s = Session::new();
+    s.new_workbook();
+    let hidden = LineInfo { size: Some(0.0), hidden: true, outline: 1, ..LineInfo::default() };
+    let sh = Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
+    for c in 2..=4 {
+        sh.cols.insert(c, hidden);
+    }
+    sh.cols.insert(5, LineInfo { collapsed: true, ..LineInfo::default() });
+    s.execute("data.showDetail", json!({"cols": "C:E", "level": 1})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    for c in 2..=4 {
+        assert_eq!(sh.col_width(c), sh.default_col_width, "column {c}");
+    }
+    // Hiding again hides them; the level buttons show zero-width columns too.
+    s.execute("data.hideDetail", json!({"cols": "C:E", "level": 1})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.active().unwrap().col_width(2), 0.0);
+    Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().cols.insert(3, hidden);
+    s.execute("data.showLevels", json!({"cols": 2})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert_eq!((sh.col_width(2), sh.col_width(3)), (sh.default_col_width, sh.default_col_width));
+}
+
+#[test]
+fn removing_an_autofilter_keeps_manually_hidden_and_collapsed_rows() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["H"], ["a"], ["b"], ["c"]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "A10", "values": [["z"]]})).unwrap();
+    s.execute("data.group", json!({"rows": "2:4"})).unwrap();
+    s.execute("data.hideDetail", json!({"rows": "2:4"})).unwrap();
+    s.execute("home.hideRows", json!({"rows": "10:10"})).unwrap();
+    let hidden = |s: &Session| -> Vec<u32> {
+        let sh = s.doc().unwrap().wb.active().unwrap();
+        sh.rows.iter().filter(|(_, l)| l.hidden).map(|(r, _)| *r).collect()
+    };
+    let before = hidden(&s);
+    assert_eq!(before, [1, 2, 3, 9]);
+    s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
+    s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
+    assert!(s.doc().unwrap().wb.active().unwrap().autofilter.is_none());
+    assert_eq!(hidden(&s), before);
+    assert_eq!(row_state(&s, 4..=4), [(false, true)]);
+}
+
+#[test]
+fn table_dropdown_setup_outside_the_table_keeps_manually_hidden_rows() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["H"], ["a"], ["b"], ["c"]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "A10", "values": [["z"]]})).unwrap();
+    s.execute("insert.table", json!({"range": "A1:A4", "header": true})).unwrap();
+    s.execute("home.hideRows", json!({"rows": "3:3"})).unwrap();
+    s.execute("home.hideRows", json!({"rows": "10:10"})).unwrap();
+    s.execute("selection.set", json!({"range": "E1"})).unwrap();
+    // The table filter dropdown installs an AutoFilter on demand by toggling `data.filter` twice.
+    s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
+    s.execute("data.filter", json!({"range": "A1:A4"})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert_eq!(sh.rows.iter().filter(|(_, l)| l.hidden).map(|(r, _)| *r).collect::<Vec<_>>(), [2, 9]);
+}
+
+/// Rows 5:8 grouped, with 6:7 grouped again inside (0-based 4..=7 and 5..=6).
+fn nested_rows() -> Session {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("data.group", json!({"rows": "5:8"})).unwrap();
+    s.execute("data.group", json!({"rows": "6:7"})).unwrap();
+    s
+}
+
+/// (hidden, collapsed) of 0-based rows.
+fn row_state(s: &Session, rows: std::ops::RangeInclusive<u32>) -> Vec<(bool, bool)> {
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    rows.map(|r| sh.rows.get(&r).map(|l| (l.hidden, l.collapsed)).unwrap_or_default()).collect()
+}
+
+#[test]
+fn hide_detail_marks_the_summary_collapsed_and_show_detail_keeps_inner_groups_collapsed() {
+    let mut s = nested_rows();
+    s.execute("data.hideDetail", json!({"rows": "6:7", "level": 2})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(false, false), (true, false), (true, false), (false, true), (false, false)]);
+    s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(true, false), (true, false), (true, false), (true, true), (false, true)]);
+    s.execute("data.showDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(false, false), (true, false), (true, false), (false, true), (false, false)]);
+    s.execute("data.showDetail", json!({"rows": "6:7", "level": 2})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(false, false); 5]);
+    // Each step is one undoable command.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(row_state(&s, 5..=7), [(true, false), (true, false), (false, true)]);
+}
+
+#[test]
+fn hide_detail_on_the_summary_row_collapses_the_group_above_it() {
+    let mut s = nested_rows();
+    s.execute("data.hideDetail", json!({"rows": "9:9"})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(true, false), (true, false), (true, false), (true, false), (false, true)]);
+}
+
+#[test]
+fn show_levels_collapses_and_expands_to_a_level() {
+    let mut s = nested_rows();
+    s.execute("data.showLevels", json!({"rows": 1})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(true, false), (true, false), (true, false), (true, true), (false, true)]);
+    s.execute("data.showLevels", json!({"rows": 2})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(false, false), (true, false), (true, false), (false, true), (false, false)]);
+    s.execute("data.showLevels", json!({"rows": 3})).unwrap();
+    assert_eq!(row_state(&s, 4..=8), [(false, false); 5]);
+    // Columns are separate; no level at all is an error rather than a guess.
+    s.execute("data.group", json!({"cols": "C:E"})).unwrap();
+    s.execute("data.showLevels", json!({"cols": 1})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert!((2..=4).all(|c| sh.cols.get(&c).is_some_and(|l| l.hidden)));
+    assert!(sh.cols.get(&5).is_some_and(|l| l.collapsed));
+    assert_eq!(row_state(&s, 4..=4), [(false, false)]);
+    assert!(s.execute("data.showLevels", json!({})).is_err());
+}
+
+#[test]
+fn group_by_columns_for_a_block_of_cells() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("selection.set", json!({"range": "B2:C5"})).unwrap();
+    s.execute("data.group", json!({"by": "cols"})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert!((1..=2).all(|c| sh.cols.get(&c).is_some_and(|l| l.outline == 1)));
+    assert!(sh.rows.values().all(|l| l.outline == 0));
+}
+
+#[test]
+fn group_shortcuts_are_the_windows_ones() {
+    let sc = |id: &str| specs().into_iter().find(|c| c.id == id).and_then(|c| c.shortcut);
+    assert_eq!(sc("data.group"), Some("Alt+Shift+Right"));
+    assert_eq!(sc("data.ungroup"), Some("Alt+Shift+Left"));
+}
+
+#[test]
+fn summary_rows_above_the_detail_take_the_collapsed_mark() {
+    let mut s = nested_rows();
+    let r = s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
+    assert_eq!(r, json!({"summaryBelow": false, "summaryRight": true}));
+    // Row 4 (index 3) is the outer group's summary, row 5 the inner one's.
+    s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    assert_eq!(row_state(&s, 3..=8), [(false, true), (true, false), (true, false), (true, false), (true, false), (false, false)]);
+    s.execute("data.showDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    assert_eq!(row_state(&s, 3..=8), [(false, false); 6]);
+    // Hide Detail on the summary row collapses the group below it.
+    s.execute("data.hideDetail", json!({"rows": "4:4"})).unwrap();
+    assert_eq!(row_state(&s, 3..=4), [(false, true), (true, false)]);
+    s.execute("data.showLevels", json!({"rows": 1})).unwrap();
+    assert_eq!(row_state(&s, 3..=8), [(false, true), (true, true), (true, false), (true, false), (true, false), (false, false)]);
+    // Ungrouping the outer group clears its mark on the row above.
+    s.execute("data.showLevels", json!({"rows": 3})).unwrap();
+    s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    s.execute("data.ungroup", json!({"rows": "5:8"})).unwrap();
+    assert_eq!(row_state(&s, 3..=3), [(false, false)]);
+}
+
+#[test]
+fn changing_the_summary_direction_moves_collapsed_marks() {
+    let mut s = nested_rows();
+    s.execute("data.group", json!({"cols": "C:E"})).unwrap();
+    s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    s.execute("data.hideDetail", json!({"cols": "C:E"})).unwrap();
+    s.execute("data.outlineSettings", json!({"summaryBelow": false, "summaryRight": false})).unwrap();
+    let col_marked = |s: &Session, c: u32| s.doc().unwrap().wb.active().unwrap().cols.get(&c).is_some_and(|l| l.collapsed);
+    assert_eq!(row_state(&s, 3..=8).iter().map(|r| r.1).collect::<Vec<_>>(), [true, false, false, false, false, false]);
+    assert!(col_marked(&s, 1) && !col_marked(&s, 5));
+    s.execute("data.outlineSettings", json!({"summaryBelow": true})).unwrap();
+    assert_eq!(row_state(&s, 3..=8).iter().map(|r| r.1).collect::<Vec<_>>(), [false, false, false, false, false, true]);
+    assert!(col_marked(&s, 1), "columns keep their direction");
+    // One undo step per change; no params leaves the settings as they are.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(row_state(&s, 3..=3)[0].1);
+    assert_eq!(s.execute("data.outlineSettings", json!({})).unwrap(), json!({"summaryBelow": false, "summaryRight": false}));
+    // Nested groups that end on one row share its mark: it moves to the outer group only.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("data.group", json!({"rows": "5:8"})).unwrap();
+    s.execute("data.group", json!({"rows": "6:8"})).unwrap();
+    s.execute("data.showLevels", json!({"rows": 1})).unwrap();
+    s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
+    assert_eq!(row_state(&s, 3..=8).iter().map(|r| r.1).collect::<Vec<_>>(), [true, false, false, false, false, false]);
+    s.execute("data.showDetail", json!({"rows": "4:4"})).unwrap();
+    assert_eq!(row_state(&s, 3..=8), [(false, false); 6]);
+    // With only the inner group collapsed, its mark goes to row 5, and the outer group's
+    // Hide and Show Detail keep it collapsed.
+    s.execute("data.outlineSettings", json!({"summaryBelow": true})).unwrap();
+    s.execute("data.hideDetail", json!({"rows": "6:8", "level": 2})).unwrap();
+    s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
+    assert_eq!(row_state(&s, 3..=8), [(false, false), (false, true), (true, false), (true, false), (true, false), (false, false)]);
+    s.execute("data.hideDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    s.execute("data.showDetail", json!({"rows": "5:8", "level": 1})).unwrap();
+    assert_eq!(row_state(&s, 3..=8), [(false, false), (false, true), (true, false), (true, false), (true, false), (false, false)]);
+    // A group on the first row has no row above it to mark.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("data.group", json!({"rows": "1:3"})).unwrap();
+    s.execute("data.outlineSettings", json!({"summaryBelow": false})).unwrap();
+    s.execute("data.hideDetail", json!({"rows": "1:3"})).unwrap();
+    assert_eq!(row_state(&s, 0..=3), [(true, false), (true, false), (true, false), (false, false)]);
+}
+
+#[test]
+fn column_sort_rejects_row_key_zero_without_panicking() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("cell.set", json!({"cell": "A1", "input": "2"})).unwrap();
+    for row in [0u64, 1 << 32] {
+        let params = json!({"range": "A1:B2", "header": false, "orientation": "columns", "keys": [{"row": row}]});
+        let err = s.execute("data.sort", params).unwrap_err();
+        assert!(matches!(err, EngineError::BadParams { .. }), "row {row}: {err:?}");
+    }
+}
+
+#[test]
+fn single_row_and_column_parameters() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2], [3, 4]]})).unwrap();
+    s.execute("home.insertRows", json!({"rows": "2"})).unwrap();
+    s.execute("home.insertColumns", json!({"cols": "B"})).unwrap();
+    let v = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["value"].clone();
+    assert_eq!(v(&mut s, "C3"), json!(4.0));
+    s.execute("home.hideRows", json!({"rows": "1"})).unwrap();
+    s.execute("data.group", json!({"cols": "C"})).unwrap();
+    assert!(s.execute("home.deleteRows", json!({"rows": "0"})).is_err());
+    s.execute("home.deleteRows", json!({"rows": "2"})).unwrap();
+    s.execute("home.deleteColumns", json!({"cols": "B"})).unwrap();
+    assert_eq!(v(&mut s, "B2"), json!(4.0));
+}
+
+#[test]
+fn t2c_fixed_widths_are_positions_in_any_order_without_duplicates() {
+    let cases: [(Json, [&str; 4]); 5] = [
+        (json!([6, 3]), ["abc", "def", "ghij", ""]),
+        (json!([3, 3]), ["abc", "defghij", "", ""]),
+        (json!([0]), ["abcdefghij", "", "", ""]),
+        (json!([20]), ["abcdefghij", "", "", ""]),
+        (json!([7, 0, 3, 7, 10]), ["abc", "defg", "hij", ""]),
+    ];
+    for (widths, want) in cases {
+        let mut s = Session::new();
+        s.new_workbook();
+        s.execute("cell.set", json!({"cell": "A1", "input": "abcdefghij"})).unwrap();
+        s.execute("data.textToColumns", json!({"range": "A1:A1", "fixedWidths": widths})).unwrap();
+        let sh = s.doc().unwrap().wb.active().unwrap();
+        let got: Vec<String> = (0..4).map(|c| sh.value(CellRef::new(0, c)).display()).collect();
+        assert_eq!(got, want, "{widths}");
+    }
+}
+
+#[test]
+fn split() {
+    assert_eq!(split_delimited("a,b,,c", &[','], false, '"'), ["a", "b", "", "c"]);
+    assert_eq!(split_delimited("a,b,,c", &[','], true, '"'), ["a", "b", "c"]);
+    assert_eq!(split_delimited("\"x,y\",z", &[','], false, '"'), ["x,y", "z"]);
+}
+
+#[test]
+fn remove_duplicates_without_a_valid_column_is_refused() {
+    // `columns: []` (or only unusable names) used to compare nothing and delete every row
+    // but the first.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["a"], ["b"], ["c"]]})).unwrap();
+    for columns in [json!([]), json!(["ZZZ"])] {
+        let err = s.execute("data.removeDuplicates", json!({"range": "A1:A3", "columns": columns})).unwrap_err();
+        assert!(err.to_string().contains("columns"), "{err}");
+    }
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert_eq!(sh.value(CellRef::new(0, 0)), Value::text("a"));
+    assert_eq!(sh.value(CellRef::new(2, 0)), Value::text("c"));
+}
+
+#[test]
+fn a_list_typed_without_quotes_is_saved_as_a_quoted_list() {
+    // In a file an inline list is a string literal (`"a,b"`); unquoted it reads as a formula.
+    // References, names and formulas stay unquoted, and every rule survives a save and reopen.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "K1:K3", "values": [["Red"], ["Green"], ["Blue"]]})).unwrap();
+    s.execute("formulas.defineName", json!({"name": "Colors", "refersTo": "=Sheet1!$K$1:$K$3"})).unwrap();
+    let rules = [
+        ("A1", "Open,In progress,Closed", r#""Open,In progress,Closed""#),
+        ("B1", r#""Open,In progress,Closed""#, r#""Open,In progress,Closed""#),
+        ("C1", " 1,2,3 ", r#""1,2,3""#),
+        ("D1", r#"Say "hi",Bye"#, r#""Say ""hi"",Bye""#),
+        ("E1", "=$K$1:$K$3", "$K$1:$K$3"),
+        ("F1", "$K$1:$K$3", "$K$1:$K$3"),
+        ("G1", "=Colors", "Colors"),
+        ("H1", "Sheet1!$K$1:$K$3", "Sheet1!$K$1:$K$3"),
+        ("I1", "=OFFSET($K$1,0,0,3,1)", "OFFSET($K$1,0,0,3,1)"),
+    ];
+    for (cell, source, _) in rules {
+        s.execute("data.validation", json!({"range": cell, "type": "list", "formula1": source})).unwrap();
+    }
+    let accepted = [
+        ("A1", "In progress"),
+        ("B1", "Closed"),
+        ("C1", "2"),
+        ("D1", r#"Say "hi""#),
+        ("E1", "Green"),
+        ("F1", "Blue"),
+        ("G1", "Red"),
+        ("H1", "Green"),
+    ];
+    let check = |wb: &Workbook| {
+        for (cell, input) in accepted {
+            let at = CellRef::parse(cell).unwrap();
+            assert!(check_validation(wb, 0, at, input).is_none(), "{cell} refuses {input}");
+            assert!(check_validation(wb, 0, at, "Pending").is_some(), "{cell} accepts Pending");
+        }
+    };
+    let wb = s.doc().unwrap().wb.clone();
+    check(&wb);
+
+    let sheet_xml = |wb: &Workbook| {
+        let bytes = gridcraft_xlsx::write_xlsx(wb).unwrap();
+        let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+        let mut xml = String::new();
+        std::io::Read::read_to_string(&mut zip.by_name("xl/worksheets/sheet1.xml").unwrap(), &mut xml).unwrap();
+        xml
+    };
+    let xml = sheet_xml(&wb);
+    for (cell, _, saved) in rules {
+        assert!(xml.contains(&format!(r#"sqref="{cell}"><formula1>{saved}</formula1>"#)), "{cell}: {saved} missing from {xml}");
+    }
+    let (reopened, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
+    check(&reopened);
+    assert_eq!(sheet_xml(&reopened), xml, "a second save writes the same rules");
+}
+
+#[test]
+fn a_rule_with_an_unknown_type_operator_or_error_style_is_refused() {
+    // A typo used to give a rule that validates nothing (`type="none"`) or the wrong check,
+    // with no error.
+    let mut s = Session::new();
+    s.new_workbook();
+    for params in [
+        json!({"range": "A1", "type": "lst", "formula1": "\"a,b\""}),
+        json!({"range": "A1", "type": "whole", "operator": "greaterthan", "formula1": "1"}),
+        json!({"range": "A1", "type": "whole", "operator": ">", "formula1": "1"}),
+        json!({"range": "A1", "type": "list", "formula1": "\"a,b\"", "errorStyle": "warn"}),
+    ] {
+        let e = s.execute("data.validation", params.clone()).unwrap_err().to_string();
+        assert!(e.contains("unknown"), "{params}: {e}");
+    }
+    assert!(s.doc().unwrap().wb.active().unwrap().validations.is_empty());
+    for params in [
+        json!({"range": "A1", "type": "any"}),
+        json!({"range": "A2", "type": "whole", "operator": "greaterThan", "formula1": "1"}),
+        json!({"range": "A3", "type": "list", "formula1": "\"a,b\"", "errorStyle": "warning"}),
+    ] {
+        s.execute("data.validation", params).unwrap();
+    }
+    let sh = s.doc().unwrap().wb.active().unwrap().clone();
+    assert_eq!(sh.validations.len(), 3);
+    assert!(check_validation(&s.doc().unwrap().wb, 0, CellRef::parse("A2").unwrap(), "0").is_some());
+}

From 2b808def4f72115549f724dc6c85bb98c48b0467 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:40 +0000
Subject: [PATCH 27/76] refactor(engine): move cmd/edit tests to
 src/cmd/edit/tests.rs

---
 crates/engine/src/cmd/edit.rs       | 308 +---------------------------
 crates/engine/src/cmd/edit/tests.rs | 305 +++++++++++++++++++++++++++
 2 files changed, 306 insertions(+), 307 deletions(-)
 create mode 100644 crates/engine/src/cmd/edit/tests.rs

diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 28ce338d6..32164fb24 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -1910,310 +1910,4 @@ fn begin_edit(s: &mut Session, _: &Json) -> Result<Json> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Sheet1 and Sheet2 with a workbook range name, a name scoped to each sheet, a constant, a
-    /// formula and a hidden name.
-    fn go_to_workbook() -> Session {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("home.insertSheet", json!({"name": "Sheet2"})).unwrap();
-        s.execute("selection.set", json!({"sheet": 0})).unwrap();
-        let define = |s: &mut Session, name: &str, refers: &str, scope: &str| {
-            s.execute("formulas.defineName", json!({"name": name, "refersTo": refers, "scope": scope})).unwrap();
-        };
-        define(&mut s, "Price", "=Sheet1!$B$2:$B$5", "Workbook");
-        define(&mut s, "type", "=Sheet1!$D$2:$D$5", "Workbook");
-        define(&mut s, "Areas", "=Sheet1!$A$1,Sheet1!$C$3:$C$4", "Workbook");
-        define(&mut s, "Local", "=Sheet2!$C$3", "Sheet2");
-        define(&mut s, "Own", "=Sheet1!$E$1", "Sheet1");
-        define(&mut s, "Rate", "=0.07", "Workbook");
-        define(&mut s, "Total", "=SUM(Sheet1!$B$2:$B$5)", "Workbook");
-        let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb);
-        wb.names.push(gridcraft_model::DefinedName {
-            name: "Secret".into(),
-            scope: None,
-            formula: "Sheet1!$Z$9".into(),
-            comment: String::new(),
-            hidden: true,
-        });
-        s
-    }
-
-    /// "The Go to popup window shows named ranges on every worksheet in your workbook." Names
-    /// that are not ranges, and hidden names, are not listed.
-    #[test]
-    fn go_to_lists_the_named_ranges_of_every_sheet() {
-        let mut s = go_to_workbook();
-        let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
-        assert_eq!(list["names"], json!(["Areas", "Own", "Price", "Sheet2!Local", "type"]), "{list}");
-        assert_eq!(list["recent"], json!([]), "{list}");
-        // Seen from Sheet2, its own name is bare and Sheet1's is qualified.
-        s.execute("selection.set", json!({"sheet": 1})).unwrap();
-        let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
-        assert_eq!(list["names"], json!(["Areas", "Local", "Price", "Sheet1!Own", "type"]), "{list}");
-    }
-
-    #[test]
-    fn go_to_a_name_scoped_to_another_sheet_goes_to_that_sheet() {
-        let mut s = go_to_workbook();
-        let out = s.execute("edit.goTo", json!({"reference": "Sheet2!Local"})).unwrap();
-        assert_eq!(out["selection"], "C3", "{out}");
-        assert_eq!(s.doc().unwrap().wb.active_sheet(), 1);
-        // A name of several areas selects all of them.
-        let out = s.execute("edit.goTo", json!({"reference": "Areas"})).unwrap();
-        assert_eq!(out["selection"], "A1,C3:C4", "{out}");
-        assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
-    }
-
-    /// A name matches in any case and any script, as a formula matches it.
-    #[test]
-    fn go_to_matches_a_sheet_name_in_any_case() {
-        let mut s = go_to_workbook();
-        s.execute("formulas.defineName", json!({"name": "Größe", "refersTo": "=Sheet2!$D$4", "scope": "Sheet2"})).unwrap();
-        s.execute("formulas.defineName", json!({"name": "GRÖSSE", "refersTo": "=Sheet1!$F$6", "scope": "Workbook"})).unwrap();
-        let out = s.execute("edit.goTo", json!({"reference": "Sheet2!GRÖSSE"})).unwrap();
-        assert_eq!(out["selection"], "D4", "{out}");
-        // Seen from Sheet2, its own name hides the workbook name it shares.
-        let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
-        assert_eq!(list["names"], json!(["Areas", "Größe", "Local", "Price", "Sheet1!Own", "type"]), "{list}");
-    }
-
-    /// "You can enter multiple named ranges or cell references in the Reference box. Separating
-    /// each with a comma ... Excel will highlight all the ranges."
-    #[test]
-    fn go_to_selects_every_reference_and_name_in_a_list() {
-        let mut s = go_to_workbook();
-        let out = s.execute("edit.goTo", json!({"reference": "B14:C22,F19:G30,H21:H29"})).unwrap();
-        assert_eq!(out["selection"], "B14:C22,F19:G30,H21:H29", "{out}");
-        let out = s.execute("edit.goTo", json!({"reference": "Price, Type"})).unwrap();
-        assert_eq!(out["selection"], "B2:B5,D2:D5", "{out}");
-        let out = s.execute("edit.goTo", json!({"reference": "Sheet2!$A$1,Sheet2!B2"})).unwrap();
-        assert_eq!(out["selection"], "A1,B2", "{out}");
-        assert_eq!(s.doc().unwrap().wb.active_sheet(), 1);
-        // Areas on two sheets, and a part that is not a reference, leave the selection alone.
-        for bad in ["A1,Sheet1!B2", "A1,Rate", "A1,", "Total"] {
-            assert!(s.execute("edit.goTo", json!({"reference": bad})).is_err(), "{bad}");
-            assert_eq!(s.doc().unwrap().selection.a1(), "A1,B2", "{bad}");
-        }
-    }
-
-    #[test]
-    fn go_to_reads_the_parts_of_a_long_reference_one_at_a_time() {
-        let mut parts = reference_parts("A1, 'Q1, Q2'!B2,SUM(C3,D4)");
-        assert_eq!(parts.next(), Some("A1"));
-        assert_eq!(parts.next(), Some("'Q1, Q2'!B2"));
-        assert_eq!(parts.next(), Some("SUM(C3,D4)"));
-        assert_eq!(parts.next(), None);
-        assert_eq!(reference_parts("").collect::<Vec<_>>(), vec![""]);
-        let mut s = go_to_workbook();
-        let err = s.execute("edit.goTo", json!({"reference": "A1,".repeat(GO_TO_MAX_AREAS + 1)})).unwrap_err();
-        assert!(err.to_string().contains("at most"), "{err}");
-        let bad = format!("Total{}", ",".repeat(1_000_000));
-        assert!(s.execute("edit.goTo", json!({"reference": bad})).is_err());
-    }
-
-    /// "The Go to box keeps track of ranges as you enter them, and you can return to any of them."
-    #[test]
-    fn go_to_keeps_the_references_entered_newest_first() {
-        let mut s = go_to_workbook();
-        s.execute("edit.goTo", json!({"reference": "B14:C22,F19:G30", "record": true})).unwrap();
-        s.execute("edit.goTo", json!({"reference": "Sheet2!A5", "record": true})).unwrap();
-        // Names are listed already; a call without `record` (the Name Box) is not kept.
-        s.execute("edit.goTo", json!({"reference": "Price", "record": true})).unwrap();
-        s.execute("edit.goTo", json!({"reference": "Z9"})).unwrap();
-        s.execute("edit.goTo", json!({"reference": "b14:c22,f19:g30", "record": true})).unwrap();
-        let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
-        assert_eq!(list["recent"], json!(["Sheet1!B14:C22,Sheet1!F19:G30", "Sheet2!A5"]), "{list}");
-        // Going back from Sheet2 to a recent reference returns to its sheet.
-        s.execute("selection.set", json!({"sheet": 1})).unwrap();
-        let out = s.execute("edit.goTo", json!({"reference": "Sheet1!B14:C22,Sheet1!F19:G30", "record": true})).unwrap();
-        assert_eq!(out["selection"], "B14:C22,F19:G30", "{out}");
-        assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
-        for i in 0..GO_TO_RECENT + 2 {
-            s.execute("edit.goTo", json!({"reference": format!("A{}", i + 1), "record": true})).unwrap();
-        }
-        let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
-        assert_eq!(list["recent"].as_array().map(Vec::len), Some(GO_TO_RECENT), "{list}");
-        assert_eq!(list["recent"][0], format!("Sheet1!A{}", GO_TO_RECENT + 2), "{list}");
-    }
-
-    #[test]
-    fn cell_set_takes_numbers_for_input_and_value() {
-        // #697: a JSON number for `input` used to clear the cell instead of entering it.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("cell.set", json!({"cell": "A1", "input": 123.5})).unwrap();
-        s.execute("cell.set", json!({"cell": "A2", "value": 77})).unwrap();
-        s.execute("cell.set", json!({"cell": "A3", "input": true})).unwrap();
-        s.execute("cell.set", json!({"cell": "A4", "input": "=A1+A2"})).unwrap();
-        let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-        assert_eq!(get(&mut s, "A1")["value"], json!(123.5));
-        assert_eq!(get(&mut s, "A2")["value"], json!(77.0));
-        assert_eq!(get(&mut s, "A3")["value"], json!(true));
-        assert_eq!(get(&mut s, "A4")["value"], json!(200.5));
-        assert!(s.execute("cell.set", json!({"cell": "A5"})).is_err());
-    }
-
-    /// Every string in `values` went through typed input, read with en-US rules, in silence: a
-    /// caller sending "05.04.2026" from a dd.mm.yyyy export stored 4 May, "2.500" became 2.5 and
-    /// "4.25 %" became a percentage (#2255). `parse: false` stores a string as the text it is.
-    #[test]
-    fn set_values_can_store_strings_as_the_text_they_are() {
-        let mut s = Session::new();
-        s.new_workbook();
-        let strings = ["05.04.2026", "02/11/2026", "2.500", "4.25 %", "=1+1", "'keep"];
-        let row: Vec<Json> = strings.iter().map(|v| json!(v)).collect();
-        let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-
-        // The default is unchanged: the dates swap, the thousands separator is a decimal point.
-        s.execute("range.setValues", json!({"range": "A1", "values": [row.clone()]})).unwrap();
-        assert_eq!(get(&mut s, "A1")["text"], "5/4/2026", "dd.mm.yyyy read as mm.dd.yyyy");
-        assert_eq!(get(&mut s, "C1")["value"], json!(2.5), "\"2.500\" read as a decimal");
-        assert_eq!(get(&mut s, "D1")["value"], json!(0.0425), "\"4.25 %\" read as a percentage");
-
-        // With `parse: false` each string is the text it was given, and a formula is still a
-        // formula.
-        s.execute("range.setValues", json!({"range": "A3", "parse": false, "values": [row.clone()]})).unwrap();
-        for (i, want) in strings.iter().enumerate() {
-            let cell = format!("{}3", (b'A' + i as u8) as char);
-            let got = get(&mut s, &cell);
-            if *want == "=1+1" {
-                assert_eq!(got["value"], json!(2.0), "{cell} is still a formula: {got}");
-                assert_eq!(got["formula"], "=1+1", "{got}");
-            } else {
-                assert_eq!(got["value"], json!(*want), "{cell} is the text it was given: {got}");
-                assert!(got["formula"].is_null(), "{cell} is not a formula: {got}");
-            }
-        }
-        // Numbers and booleans are untouched either way.
-        s.execute("range.setValues", json!({"range": "A5", "parse": false, "values": [[12.5, true, null]]})).unwrap();
-        assert_eq!(get(&mut s, "A5")["value"], json!(12.5));
-        assert_eq!(get(&mut s, "B5")["value"], json!(true));
-        assert_eq!(get(&mut s, "C5")["text"], "");
-        // `parse` is a flag, and anything else is a usage error rather than a quiet default.
-        s.execute("range.setValues", json!({"range": "A7", "parse": true, "values": [["2.500"]]})).unwrap();
-        assert_eq!(get(&mut s, "A7")["value"], json!(2.5));
-        assert!(s.execute("range.setValues", json!({"range": "A8", "parse": "no", "values": [["x"]]})).is_err());
-        assert!(s.execute("range.setValues", json!({"range": "A8", "parse": 0, "values": [["x"]]})).is_err());
-        // A line break still turns on Wrap Text.
-        s.execute("range.setValues", json!({"range": "A9", "parse": false, "values": [["one\ntwo"]]})).unwrap();
-        assert_eq!(get(&mut s, "A9")["value"], json!("one\ntwo"));
-        let d = s.doc().unwrap();
-        let sh = d.wb.active().unwrap();
-        assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A9").unwrap())).align.wrap);
-    }
-
-    #[test]
-    fn legacy_array_entry() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "B2", "values": [[1], [2]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "C4", "input": "old"})).unwrap();
-        s.execute("selection.set", json!({"range": "C2:C4"})).unwrap();
-        s.execute("cell.set", json!({"cell": "C2", "input": "=B2:B3*2", "array": true})).unwrap();
-        let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-        assert_eq!(get(&mut s, "C3")["value"], json!(4.0));
-        // Past the result Excel shows #N/A; the old content of the range is replaced.
-        assert_eq!(get(&mut s, "C4")["text"], "#N/A");
-        let bar = s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse("C2").unwrap()).map(|c| c.bar_text());
-        assert_eq!(bar.as_deref(), Some("{=B2:B3*2}"));
-    }
-
-    #[test]
-    fn an_array_entered_outside_the_selection_covers_only_its_cell() {
-        // Found by the command-sequence fuzzer: the array took the selection's range even with
-        // `cell` elsewhere (or on another sheet), so its formula sat outside its own range and the
-        // selected cells were wiped.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("cell.set", json!({"cell": "K20", "input": "keep"})).unwrap();
-        s.execute("selection.set", json!({"range": "K20:K22"})).unwrap();
-        s.execute("cell.set", json!({"cell": "H5", "input": "=1+1", "array": true})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        let f = sh.cell(CellRef::parse("H5").unwrap()).and_then(|c| c.formula.clone()).unwrap();
-        assert_eq!(f.array, Some(RangeRef::parse("H5").unwrap()));
-        assert_eq!(sh.value(CellRef::parse("K20").unwrap()), Value::text("keep"));
-    }
-
-    #[test]
-    fn wildcards() {
-        assert!(wildcard("hello", "h*o"));
-        assert!(wildcard("hello", "h?llo"));
-        assert!(!wildcard("hello", "h?lo"));
-        assert!(wildcard("a*b", "a~*b"));
-        assert!(!wildcard("axb", "a~*b"));
-        assert!(wildcard("", "*"));
-    }
-
-    #[test]
-    fn tsv() {
-        assert_eq!(parse_tsv("a\tb\n1\t2\n"), vec![vec!["a", "b"], vec!["1", "2"]]);
-        assert_eq!(parse_tsv("\"x\ty\"\tz"), vec![vec!["x\ty", "z"]]);
-        assert_eq!(parse_tsv("\"he said \"\"hi\"\"\""), vec![vec!["he said \"hi\""]]);
-    }
-
-    #[test]
-    fn paste_special_operations_keep_text_errors_and_formulas() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute(
-            "range.setValues",
-            json!({"range": "A1", "values": [["'123", "Total", "=NA()", "=B3*2", 5], [1, null, null, null, null], [null, 4, null, null, null]]}),
-        )
-        .unwrap();
-        let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-        assert_eq!(get(&mut s, "A1")["value"], "123");
-        s.execute("edit.copy", json!({"range": "A2"})).unwrap();
-        s.execute("selection.set", json!({"range": "A1:E1"})).unwrap();
-        s.execute("edit.pasteSpecial", json!({"what": "values", "operation": "multiply"})).unwrap();
-        assert_eq!(get(&mut s, "A1")["value"], json!(123.0));
-        assert_eq!(get(&mut s, "B1")["value"], "Total");
-        assert_eq!(get(&mut s, "C1")["value"]["error"], "#N/A");
-        assert_eq!(get(&mut s, "D1")["formula"], "=(B3*2)*1");
-        assert_eq!(get(&mut s, "D1")["value"], json!(8.0));
-        assert_eq!(get(&mut s, "E1")["value"], json!(5.0));
-    }
-
-    #[test]
-    fn cut_paste_that_overflows_the_grid_moves_nothing() {
-        // #997: the source was emptied first and the cells that fell off the grid were skipped.
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2]]})).unwrap();
-        let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-        s.execute("edit.cut", json!({"range": "A1:A2"})).unwrap();
-        // Transposed, the 2 rows become 2 columns and the second one is past XFD.
-        assert!(s.execute("edit.pasteSpecial", json!({"what": "all", "transpose": true, "at": "XFD1"})).is_err());
-        assert_eq!(get(&mut s, "A1")["value"], json!(1.0));
-        assert_eq!(get(&mut s, "A2")["value"], json!(2.0));
-        // Not transposed, the second row would be past the last row.
-        assert!(s.execute("edit.pasteSpecial", json!({"what": "all", "at": "A1048576"})).is_err());
-        assert_eq!(get(&mut s, "A1")["value"], json!(1.0));
-        assert_eq!(get(&mut s, "A2")["value"], json!(2.0));
-        // Not transposed it still fits in column XFD.
-        s.execute("edit.pasteSpecial", json!({"what": "all", "at": "XFD1"})).unwrap();
-        assert_eq!(get(&mut s, "XFD1")["value"], json!(1.0));
-        assert_eq!(get(&mut s, "XFD2")["value"], json!(2.0));
-    }
-
-    #[test]
-    fn replace_case_insensitive() {
-        assert_eq!(replace_ci("Apple apple APPLE", "apple", "pear"), "pear pear pear");
-    }
-
-    #[test]
-    fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() {
-        // U+212A KELVIN SIGN folds to `k` (3→1 bytes) while U+0130 folds to `i` plus a
-        // combining dot (2→3 bytes): the folded text is the same length but its byte positions
-        // no longer line up with the original, and the old slicing dropped the tail.
-        let mut s = Session::new();
-        s.new_workbook();
-        let text = "\u{212A}\u{0130}\u{0130}";
-        s.execute("cell.set", json!({"cell": "A1", "input": text})).unwrap();
-        s.execute("edit.replace", json!({"what": "k", "with": "x"})).unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text));
-    }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs
new file mode 100644
index 000000000..c9e1e7a93
--- /dev/null
+++ b/crates/engine/src/cmd/edit/tests.rs
@@ -0,0 +1,305 @@
+use super::*;
+
+/// Sheet1 and Sheet2 with a workbook range name, a name scoped to each sheet, a constant, a
+/// formula and a hidden name.
+fn go_to_workbook() -> Session {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("home.insertSheet", json!({"name": "Sheet2"})).unwrap();
+    s.execute("selection.set", json!({"sheet": 0})).unwrap();
+    let define = |s: &mut Session, name: &str, refers: &str, scope: &str| {
+        s.execute("formulas.defineName", json!({"name": name, "refersTo": refers, "scope": scope})).unwrap();
+    };
+    define(&mut s, "Price", "=Sheet1!$B$2:$B$5", "Workbook");
+    define(&mut s, "type", "=Sheet1!$D$2:$D$5", "Workbook");
+    define(&mut s, "Areas", "=Sheet1!$A$1,Sheet1!$C$3:$C$4", "Workbook");
+    define(&mut s, "Local", "=Sheet2!$C$3", "Sheet2");
+    define(&mut s, "Own", "=Sheet1!$E$1", "Sheet1");
+    define(&mut s, "Rate", "=0.07", "Workbook");
+    define(&mut s, "Total", "=SUM(Sheet1!$B$2:$B$5)", "Workbook");
+    let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb);
+    wb.names.push(gridcraft_model::DefinedName {
+        name: "Secret".into(),
+        scope: None,
+        formula: "Sheet1!$Z$9".into(),
+        comment: String::new(),
+        hidden: true,
+    });
+    s
+}
+
+/// "The Go to popup window shows named ranges on every worksheet in your workbook." Names
+/// that are not ranges, and hidden names, are not listed.
+#[test]
+fn go_to_lists_the_named_ranges_of_every_sheet() {
+    let mut s = go_to_workbook();
+    let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
+    assert_eq!(list["names"], json!(["Areas", "Own", "Price", "Sheet2!Local", "type"]), "{list}");
+    assert_eq!(list["recent"], json!([]), "{list}");
+    // Seen from Sheet2, its own name is bare and Sheet1's is qualified.
+    s.execute("selection.set", json!({"sheet": 1})).unwrap();
+    let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
+    assert_eq!(list["names"], json!(["Areas", "Local", "Price", "Sheet1!Own", "type"]), "{list}");
+}
+
+#[test]
+fn go_to_a_name_scoped_to_another_sheet_goes_to_that_sheet() {
+    let mut s = go_to_workbook();
+    let out = s.execute("edit.goTo", json!({"reference": "Sheet2!Local"})).unwrap();
+    assert_eq!(out["selection"], "C3", "{out}");
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), 1);
+    // A name of several areas selects all of them.
+    let out = s.execute("edit.goTo", json!({"reference": "Areas"})).unwrap();
+    assert_eq!(out["selection"], "A1,C3:C4", "{out}");
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
+}
+
+/// A name matches in any case and any script, as a formula matches it.
+#[test]
+fn go_to_matches_a_sheet_name_in_any_case() {
+    let mut s = go_to_workbook();
+    s.execute("formulas.defineName", json!({"name": "Größe", "refersTo": "=Sheet2!$D$4", "scope": "Sheet2"})).unwrap();
+    s.execute("formulas.defineName", json!({"name": "GRÖSSE", "refersTo": "=Sheet1!$F$6", "scope": "Workbook"})).unwrap();
+    let out = s.execute("edit.goTo", json!({"reference": "Sheet2!GRÖSSE"})).unwrap();
+    assert_eq!(out["selection"], "D4", "{out}");
+    // Seen from Sheet2, its own name hides the workbook name it shares.
+    let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
+    assert_eq!(list["names"], json!(["Areas", "Größe", "Local", "Price", "Sheet1!Own", "type"]), "{list}");
+}
+
+/// "You can enter multiple named ranges or cell references in the Reference box. Separating
+/// each with a comma ... Excel will highlight all the ranges."
+#[test]
+fn go_to_selects_every_reference_and_name_in_a_list() {
+    let mut s = go_to_workbook();
+    let out = s.execute("edit.goTo", json!({"reference": "B14:C22,F19:G30,H21:H29"})).unwrap();
+    assert_eq!(out["selection"], "B14:C22,F19:G30,H21:H29", "{out}");
+    let out = s.execute("edit.goTo", json!({"reference": "Price, Type"})).unwrap();
+    assert_eq!(out["selection"], "B2:B5,D2:D5", "{out}");
+    let out = s.execute("edit.goTo", json!({"reference": "Sheet2!$A$1,Sheet2!B2"})).unwrap();
+    assert_eq!(out["selection"], "A1,B2", "{out}");
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), 1);
+    // Areas on two sheets, and a part that is not a reference, leave the selection alone.
+    for bad in ["A1,Sheet1!B2", "A1,Rate", "A1,", "Total"] {
+        assert!(s.execute("edit.goTo", json!({"reference": bad})).is_err(), "{bad}");
+        assert_eq!(s.doc().unwrap().selection.a1(), "A1,B2", "{bad}");
+    }
+}
+
+#[test]
+fn go_to_reads_the_parts_of_a_long_reference_one_at_a_time() {
+    let mut parts = reference_parts("A1, 'Q1, Q2'!B2,SUM(C3,D4)");
+    assert_eq!(parts.next(), Some("A1"));
+    assert_eq!(parts.next(), Some("'Q1, Q2'!B2"));
+    assert_eq!(parts.next(), Some("SUM(C3,D4)"));
+    assert_eq!(parts.next(), None);
+    assert_eq!(reference_parts("").collect::<Vec<_>>(), vec![""]);
+    let mut s = go_to_workbook();
+    let err = s.execute("edit.goTo", json!({"reference": "A1,".repeat(GO_TO_MAX_AREAS + 1)})).unwrap_err();
+    assert!(err.to_string().contains("at most"), "{err}");
+    let bad = format!("Total{}", ",".repeat(1_000_000));
+    assert!(s.execute("edit.goTo", json!({"reference": bad})).is_err());
+}
+
+/// "The Go to box keeps track of ranges as you enter them, and you can return to any of them."
+#[test]
+fn go_to_keeps_the_references_entered_newest_first() {
+    let mut s = go_to_workbook();
+    s.execute("edit.goTo", json!({"reference": "B14:C22,F19:G30", "record": true})).unwrap();
+    s.execute("edit.goTo", json!({"reference": "Sheet2!A5", "record": true})).unwrap();
+    // Names are listed already; a call without `record` (the Name Box) is not kept.
+    s.execute("edit.goTo", json!({"reference": "Price", "record": true})).unwrap();
+    s.execute("edit.goTo", json!({"reference": "Z9"})).unwrap();
+    s.execute("edit.goTo", json!({"reference": "b14:c22,f19:g30", "record": true})).unwrap();
+    let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
+    assert_eq!(list["recent"], json!(["Sheet1!B14:C22,Sheet1!F19:G30", "Sheet2!A5"]), "{list}");
+    // Going back from Sheet2 to a recent reference returns to its sheet.
+    s.execute("selection.set", json!({"sheet": 1})).unwrap();
+    let out = s.execute("edit.goTo", json!({"reference": "Sheet1!B14:C22,Sheet1!F19:G30", "record": true})).unwrap();
+    assert_eq!(out["selection"], "B14:C22,F19:G30", "{out}");
+    assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
+    for i in 0..GO_TO_RECENT + 2 {
+        s.execute("edit.goTo", json!({"reference": format!("A{}", i + 1), "record": true})).unwrap();
+    }
+    let list = s.execute("edit.goTo", json!({"list": true})).unwrap();
+    assert_eq!(list["recent"].as_array().map(Vec::len), Some(GO_TO_RECENT), "{list}");
+    assert_eq!(list["recent"][0], format!("Sheet1!A{}", GO_TO_RECENT + 2), "{list}");
+}
+
+#[test]
+fn cell_set_takes_numbers_for_input_and_value() {
+    // #697: a JSON number for `input` used to clear the cell instead of entering it.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("cell.set", json!({"cell": "A1", "input": 123.5})).unwrap();
+    s.execute("cell.set", json!({"cell": "A2", "value": 77})).unwrap();
+    s.execute("cell.set", json!({"cell": "A3", "input": true})).unwrap();
+    s.execute("cell.set", json!({"cell": "A4", "input": "=A1+A2"})).unwrap();
+    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
+    assert_eq!(get(&mut s, "A1")["value"], json!(123.5));
+    assert_eq!(get(&mut s, "A2")["value"], json!(77.0));
+    assert_eq!(get(&mut s, "A3")["value"], json!(true));
+    assert_eq!(get(&mut s, "A4")["value"], json!(200.5));
+    assert!(s.execute("cell.set", json!({"cell": "A5"})).is_err());
+}
+
+/// Every string in `values` went through typed input, read with en-US rules, in silence: a
+/// caller sending "05.04.2026" from a dd.mm.yyyy export stored 4 May, "2.500" became 2.5 and
+/// "4.25 %" became a percentage (#2255). `parse: false` stores a string as the text it is.
+#[test]
+fn set_values_can_store_strings_as_the_text_they_are() {
+    let mut s = Session::new();
+    s.new_workbook();
+    let strings = ["05.04.2026", "02/11/2026", "2.500", "4.25 %", "=1+1", "'keep"];
+    let row: Vec<Json> = strings.iter().map(|v| json!(v)).collect();
+    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
+
+    // The default is unchanged: the dates swap, the thousands separator is a decimal point.
+    s.execute("range.setValues", json!({"range": "A1", "values": [row.clone()]})).unwrap();
+    assert_eq!(get(&mut s, "A1")["text"], "5/4/2026", "dd.mm.yyyy read as mm.dd.yyyy");
+    assert_eq!(get(&mut s, "C1")["value"], json!(2.5), "\"2.500\" read as a decimal");
+    assert_eq!(get(&mut s, "D1")["value"], json!(0.0425), "\"4.25 %\" read as a percentage");
+
+    // With `parse: false` each string is the text it was given, and a formula is still a
+    // formula.
+    s.execute("range.setValues", json!({"range": "A3", "parse": false, "values": [row.clone()]})).unwrap();
+    for (i, want) in strings.iter().enumerate() {
+        let cell = format!("{}3", (b'A' + i as u8) as char);
+        let got = get(&mut s, &cell);
+        if *want == "=1+1" {
+            assert_eq!(got["value"], json!(2.0), "{cell} is still a formula: {got}");
+            assert_eq!(got["formula"], "=1+1", "{got}");
+        } else {
+            assert_eq!(got["value"], json!(*want), "{cell} is the text it was given: {got}");
+            assert!(got["formula"].is_null(), "{cell} is not a formula: {got}");
+        }
+    }
+    // Numbers and booleans are untouched either way.
+    s.execute("range.setValues", json!({"range": "A5", "parse": false, "values": [[12.5, true, null]]})).unwrap();
+    assert_eq!(get(&mut s, "A5")["value"], json!(12.5));
+    assert_eq!(get(&mut s, "B5")["value"], json!(true));
+    assert_eq!(get(&mut s, "C5")["text"], "");
+    // `parse` is a flag, and anything else is a usage error rather than a quiet default.
+    s.execute("range.setValues", json!({"range": "A7", "parse": true, "values": [["2.500"]]})).unwrap();
+    assert_eq!(get(&mut s, "A7")["value"], json!(2.5));
+    assert!(s.execute("range.setValues", json!({"range": "A8", "parse": "no", "values": [["x"]]})).is_err());
+    assert!(s.execute("range.setValues", json!({"range": "A8", "parse": 0, "values": [["x"]]})).is_err());
+    // A line break still turns on Wrap Text.
+    s.execute("range.setValues", json!({"range": "A9", "parse": false, "values": [["one\ntwo"]]})).unwrap();
+    assert_eq!(get(&mut s, "A9")["value"], json!("one\ntwo"));
+    let d = s.doc().unwrap();
+    let sh = d.wb.active().unwrap();
+    assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A9").unwrap())).align.wrap);
+}
+
+#[test]
+fn legacy_array_entry() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "B2", "values": [[1], [2]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "C4", "input": "old"})).unwrap();
+    s.execute("selection.set", json!({"range": "C2:C4"})).unwrap();
+    s.execute("cell.set", json!({"cell": "C2", "input": "=B2:B3*2", "array": true})).unwrap();
+    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
+    assert_eq!(get(&mut s, "C3")["value"], json!(4.0));
+    // Past the result Excel shows #N/A; the old content of the range is replaced.
+    assert_eq!(get(&mut s, "C4")["text"], "#N/A");
+    let bar = s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse("C2").unwrap()).map(|c| c.bar_text());
+    assert_eq!(bar.as_deref(), Some("{=B2:B3*2}"));
+}
+
+#[test]
+fn an_array_entered_outside_the_selection_covers_only_its_cell() {
+    // Found by the command-sequence fuzzer: the array took the selection's range even with
+    // `cell` elsewhere (or on another sheet), so its formula sat outside its own range and the
+    // selected cells were wiped.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("cell.set", json!({"cell": "K20", "input": "keep"})).unwrap();
+    s.execute("selection.set", json!({"range": "K20:K22"})).unwrap();
+    s.execute("cell.set", json!({"cell": "H5", "input": "=1+1", "array": true})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    let f = sh.cell(CellRef::parse("H5").unwrap()).and_then(|c| c.formula.clone()).unwrap();
+    assert_eq!(f.array, Some(RangeRef::parse("H5").unwrap()));
+    assert_eq!(sh.value(CellRef::parse("K20").unwrap()), Value::text("keep"));
+}
+
+#[test]
+fn wildcards() {
+    assert!(wildcard("hello", "h*o"));
+    assert!(wildcard("hello", "h?llo"));
+    assert!(!wildcard("hello", "h?lo"));
+    assert!(wildcard("a*b", "a~*b"));
+    assert!(!wildcard("axb", "a~*b"));
+    assert!(wildcard("", "*"));
+}
+
+#[test]
+fn tsv() {
+    assert_eq!(parse_tsv("a\tb\n1\t2\n"), vec![vec!["a", "b"], vec!["1", "2"]]);
+    assert_eq!(parse_tsv("\"x\ty\"\tz"), vec![vec!["x\ty", "z"]]);
+    assert_eq!(parse_tsv("\"he said \"\"hi\"\"\""), vec![vec!["he said \"hi\""]]);
+}
+
+#[test]
+fn paste_special_operations_keep_text_errors_and_formulas() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute(
+        "range.setValues",
+        json!({"range": "A1", "values": [["'123", "Total", "=NA()", "=B3*2", 5], [1, null, null, null, null], [null, 4, null, null, null]]}),
+    )
+    .unwrap();
+    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
+    assert_eq!(get(&mut s, "A1")["value"], "123");
+    s.execute("edit.copy", json!({"range": "A2"})).unwrap();
+    s.execute("selection.set", json!({"range": "A1:E1"})).unwrap();
+    s.execute("edit.pasteSpecial", json!({"what": "values", "operation": "multiply"})).unwrap();
+    assert_eq!(get(&mut s, "A1")["value"], json!(123.0));
+    assert_eq!(get(&mut s, "B1")["value"], "Total");
+    assert_eq!(get(&mut s, "C1")["value"]["error"], "#N/A");
+    assert_eq!(get(&mut s, "D1")["formula"], "=(B3*2)*1");
+    assert_eq!(get(&mut s, "D1")["value"], json!(8.0));
+    assert_eq!(get(&mut s, "E1")["value"], json!(5.0));
+}
+
+#[test]
+fn cut_paste_that_overflows_the_grid_moves_nothing() {
+    // #997: the source was emptied first and the cells that fell off the grid were skipped.
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2]]})).unwrap();
+    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
+    s.execute("edit.cut", json!({"range": "A1:A2"})).unwrap();
+    // Transposed, the 2 rows become 2 columns and the second one is past XFD.
+    assert!(s.execute("edit.pasteSpecial", json!({"what": "all", "transpose": true, "at": "XFD1"})).is_err());
+    assert_eq!(get(&mut s, "A1")["value"], json!(1.0));
+    assert_eq!(get(&mut s, "A2")["value"], json!(2.0));
+    // Not transposed, the second row would be past the last row.
+    assert!(s.execute("edit.pasteSpecial", json!({"what": "all", "at": "A1048576"})).is_err());
+    assert_eq!(get(&mut s, "A1")["value"], json!(1.0));
+    assert_eq!(get(&mut s, "A2")["value"], json!(2.0));
+    // Not transposed it still fits in column XFD.
+    s.execute("edit.pasteSpecial", json!({"what": "all", "at": "XFD1"})).unwrap();
+    assert_eq!(get(&mut s, "XFD1")["value"], json!(1.0));
+    assert_eq!(get(&mut s, "XFD2")["value"], json!(2.0));
+}
+
+#[test]
+fn replace_case_insensitive() {
+    assert_eq!(replace_ci("Apple apple APPLE", "apple", "pear"), "pear pear pear");
+}
+
+#[test]
+fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() {
+    // U+212A KELVIN SIGN folds to `k` (3→1 bytes) while U+0130 folds to `i` plus a
+    // combining dot (2→3 bytes): the folded text is the same length but its byte positions
+    // no longer line up with the original, and the old slicing dropped the tail.
+    let mut s = Session::new();
+    s.new_workbook();
+    let text = "\u{212A}\u{0130}\u{0130}";
+    s.execute("cell.set", json!({"cell": "A1", "input": text})).unwrap();
+    s.execute("edit.replace", json!({"what": "k", "with": "x"})).unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text));
+}

From 2396bb4f64d64f257dbac5c1f95f9530cae90313 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:41 +0000
Subject: [PATCH 28/76] refactor(engine): move cmd/pivot tests to
 src/cmd/pivot/tests.rs

---
 crates/engine/src/cmd/pivot.rs       | 997 +--------------------------
 crates/engine/src/cmd/pivot/tests.rs | 994 ++++++++++++++++++++++++++
 2 files changed, 995 insertions(+), 996 deletions(-)
 create mode 100644 crates/engine/src/cmd/pivot/tests.rs

diff --git a/crates/engine/src/cmd/pivot.rs b/crates/engine/src/cmd/pivot.rs
index 164ae4449..feb548702 100644
--- a/crates/engine/src/cmd/pivot.rs
+++ b/crates/engine/src/cmd/pivot.rs
@@ -1695,999 +1695,4 @@ fn recommended(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 #[cfg(test)]
-mod tests {
-    use gridcraft_core::{CellError, CellRef, Value};
-    use serde_json::{Value as Json, json};
-
-    use crate::Session;
-
-    /// Region, Product, Date, Units, Sales — 12 records over 2026.
-    fn sales() -> Session {
-        let mut s = Session::new();
-        s.new_workbook();
-        let rows = json!([
-            ["Region", "Product", "Date", "Units", "Sales"],
-            ["East", "Apples", "1/15/2026", 10, 100],
-            ["West", "Apples", "2/10/2026", 5, 50],
-            ["East", "Pears", "3/3/2026", 8, 120],
-            ["North", "Pears", "4/20/2026", 2, 30],
-            ["West", "Plums", "5/5/2026", 7, 70],
-            ["East", "Plums", "6/30/2026", 4, 60],
-            ["North", "Apples", "7/4/2026", 9, 90],
-            ["West", "Pears", "8/8/2026", 3, 45],
-            ["East", "Apples", "9/9/2026", 6, 60],
-            ["North", "Plums", "10/10/2026", 1, 15],
-            ["West", "Apples", "11/11/2026", 12, 120],
-            ["East", "Pears", "12/12/2026", 5, 75]
-        ]);
-        s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-        s.execute("selection.set", json!({"range": "A1"})).unwrap();
-        s
-    }
-    const TOTAL: f64 = 835.0;
-
-    fn val(s: &Session, a: &str) -> Value {
-        s.doc().unwrap().wb.active().unwrap().value(CellRef::parse(a).unwrap())
-    }
-    fn text(s: &Session, a: &str) -> String {
-        val(s, a).display()
-    }
-    fn pt(s: &Session) -> gridcraft_model::PivotTable {
-        s.doc().unwrap().wb.active().unwrap().pivots.last().unwrap().clone()
-    }
-    /// Finds the row (0-based) whose first report column holds `label`.
-    fn find_row(s: &Session, label: &str) -> Option<u32> {
-        let p = pt(s);
-        let r = p.last_range.unwrap();
-        (r.start.row..=r.end.row).find(|row| val(s, &CellRef::new(*row, r.start.col).a1()).display() == label)
-    }
-
-    #[test]
-    fn insert_creates_placeholder_on_new_sheet() {
-        let mut s = sales();
-        let r = s.execute("insert.pivotTable", json!({})).unwrap();
-        assert_eq!(r["name"], "PivotTable1");
-        assert_eq!(r["anchor"], "A3");
-        assert_eq!(r["fields"], json!(["Region", "Product", "Date", "Units", "Sales"]));
-        let d = s.doc().unwrap();
-        assert_eq!(d.wb.sheets.len(), 2);
-        assert_eq!(d.wb.active_sheet(), 0, "new sheet goes before the current one");
-        assert_eq!(d.wb.active().unwrap().name, "Sheet2");
-        assert!(text(&s, "A3").starts_with("PivotTable1"));
-        assert_eq!(pt(&s).source, "Sheet1!$A$1:$E$13");
-        // One undo step removes it.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 1);
-    }
-
-    #[test]
-    fn region_by_product_sum_of_sales() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({})).unwrap();
-        s.execute("pivot.addField", json!({"field": "region", "area": "rows"})).unwrap();
-        s.execute("pivot.addField", json!({"field": "Product", "area": "columns"})).unwrap();
-        let r = s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
-        assert_eq!(r["range"], "A3:E8");
-        assert_eq!(text(&s, "A3"), "Sum of Sales");
-        assert_eq!(text(&s, "B3"), "Column Labels");
-        assert_eq!(text(&s, "A4"), "Row Labels");
-        assert_eq!(text(&s, "B4"), "Apples");
-        assert_eq!(text(&s, "C4"), "Pears");
-        assert_eq!(text(&s, "D4"), "Plums");
-        assert_eq!(text(&s, "E4"), "Grand Total");
-        assert_eq!(text(&s, "A5"), "East");
-        assert_eq!(text(&s, "A6"), "North");
-        assert_eq!(text(&s, "A7"), "West");
-        assert_eq!(text(&s, "A8"), "Grand Total");
-        assert_eq!(val(&s, "B5"), Value::Number(160.0));
-        assert_eq!(val(&s, "C5"), Value::Number(195.0));
-        assert_eq!(val(&s, "E5"), Value::Number(415.0));
-        assert_eq!(val(&s, "E8"), Value::Number(TOTAL));
-        // Column grand totals add up too.
-        let sum: f64 = ["B8", "C8", "D8"].iter().map(|a| val(&s, a).as_f64().unwrap()).sum();
-        assert_eq!(sum, TOTAL);
-        let rows: f64 = ["E5", "E6", "E7"].iter().map(|a| val(&s, a).as_f64().unwrap()).sum();
-        assert_eq!(rows, TOTAL);
-        // Styles: header bold, grand total bold with a top border.
-        let d = s.doc().unwrap();
-        let sh = d.wb.active().unwrap();
-        assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A4").unwrap())).font.bold);
-        let g = d.wb.styles.get(sh.style_id(CellRef::parse("B8").unwrap()));
-        assert!(g.font.bold && !g.borders.top.is_none());
-        // Listing.
-        let l = s.execute("pivot.list", json!({})).unwrap();
-        assert_eq!(l[0]["values"][0]["name"], "Sum of Sales");
-    }
-
-    #[test]
-    fn multiple_value_fields_make_a_values_dimension() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales", {"field": "Units", "func": "average"}]})).unwrap();
-        assert_eq!(text(&s, "A3"), "Row Labels");
-        assert_eq!(text(&s, "B3"), "Sum of Sales");
-        assert_eq!(text(&s, "C3"), "Average of Units");
-        assert_eq!(text(&s, "A7"), "Grand Total");
-        assert_eq!(val(&s, "B7"), Value::Number(TOTAL));
-        assert_eq!(val(&s, "C7"), Value::Number(72.0 / 12.0));
-        // With a column field the values become the innermost column level.
-        s.execute("pivot.addField", json!({"field": "Product", "area": "columns"})).unwrap();
-        assert_eq!(text(&s, "B4"), "Apples");
-        assert_eq!(text(&s, "B5"), "Sum of Sales");
-        assert_eq!(text(&s, "C5"), "Average of Units");
-        assert_eq!(text(&s, "D4"), "Pears");
-        assert_eq!(text(&s, "H4"), "Total Sum of Sales");
-        assert_eq!(text(&s, "I4"), "Total Average of Units");
-        let last = pt(&s).last_range.unwrap();
-        assert_eq!(val(&s, &CellRef::new(last.end.row, 7).a1()), Value::Number(TOTAL));
-    }
-
-    #[test]
-    fn date_grouping_by_quarter_and_month() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Date"], "values": ["Sales"]})).unwrap();
-        // Ungrouped: one row per date, shown with the source date format.
-        assert_eq!(pt(&s).last_range.unwrap().height(), 14);
-        s.execute("pivot.group", json!({"field": "Date", "by": "quarters"})).unwrap();
-        assert_eq!(text(&s, "A4"), "Qtr1");
-        assert_eq!(text(&s, "A7"), "Qtr4");
-        assert_eq!(val(&s, "B4"), Value::Number(270.0));
-        assert_eq!(val(&s, "B5"), Value::Number(160.0));
-        assert_eq!(val(&s, "B8"), Value::Number(TOTAL));
-        s.execute("pivot.group", json!({"field": "Date", "by": "months"})).unwrap();
-        assert_eq!(text(&s, "A4"), "Jan");
-        assert_eq!(text(&s, "A15"), "Dec");
-        s.execute("pivot.group", json!({"field": "Date", "by": "years"})).unwrap();
-        assert_eq!(text(&s, "A4"), "2026");
-        assert!(s.execute("pivot.group", json!({"field": "Region", "by": "years"})).is_err());
-    }
-
-    #[test]
-    fn filters_and_report_filter_rows() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
-        // Report filter above the body; the body stays at A3.
-        assert_eq!(text(&s, "A1"), "Region");
-        assert_eq!(text(&s, "B1"), "(All)");
-        assert_eq!(text(&s, "A3"), "Row Labels");
-        s.execute("pivot.filter", json!({"field": "Region", "selected": ["East"]})).unwrap();
-        assert_eq!(text(&s, "B1"), "East");
-        let gt = find_row(&s, "Grand Total").unwrap();
-        assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(415.0));
-        s.execute("pivot.filter", json!({"field": "Region", "selected": ["East", "west"]})).unwrap();
-        assert_eq!(text(&s, "B1"), "(Multiple Items)");
-        s.execute("pivot.filter", json!({"field": "Region", "selected": null})).unwrap();
-        let gt = find_row(&s, "Grand Total").unwrap();
-        assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(TOTAL));
-        // Hidden items on a row field.
-        s.execute("pivot.filter", json!({"field": "Product", "selected": ["Apples"]})).unwrap();
-        assert_eq!(text(&s, "A4"), "Apples");
-        assert_eq!(text(&s, "A5"), "Grand Total");
-        assert_eq!(val(&s, "B5"), Value::Number(420.0));
-        assert!(s.execute("pivot.filter", json!({"field": "Product", "selected": []})).is_err());
-    }
-
-    #[test]
-    fn show_values_as() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
-        s.execute("pivot.valueSettings", json!({"field": "Sum of Sales", "showAs": "percentOfGrandTotal"})).unwrap();
-        let east = val(&s, "B4").as_f64().unwrap();
-        assert!((east - 415.0 / TOTAL).abs() < 1e-12);
-        assert_eq!(val(&s, "B7"), Value::Number(1.0));
-        assert_eq!(text(&s, "B7"), "1");
-        let d = s.doc().unwrap();
-        let sh = d.wb.active().unwrap();
-        assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("B4").unwrap())).num_fmt.as_str(), "0.00%");
-        s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "runningTotal"})).unwrap();
-        assert_eq!(val(&s, "B4"), Value::Number(415.0));
-        assert_eq!(val(&s, "B5"), Value::Number(415.0 + 135.0));
-        assert_eq!(val(&s, "B6"), Value::Number(TOTAL));
-        s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "rank"})).unwrap();
-        assert_eq!(val(&s, "B4"), Value::Number(1.0));
-        assert_eq!(val(&s, "B5"), Value::Number(3.0));
-        assert_eq!(val(&s, "B6"), Value::Number(2.0));
-        s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "normal", "func": "max", "numberFormat": "#,##0"})).unwrap();
-        assert_eq!(text(&s, "B3"), "Max of Sales");
-        assert_eq!(val(&s, "B4"), Value::Number(120.0));
-        assert!(s.execute("pivot.valueSettings", json!({"index": 0, "name": "Sales"})).is_err());
-        s.execute("pivot.valueSettings", json!({"index": 0, "name": "Biggest sale"})).unwrap();
-        assert_eq!(text(&s, "B3"), "Biggest sale");
-    }
-
-    #[test]
-    fn compact_vs_tabular_shapes() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales"]})).unwrap();
-        // Compact: one label column; parents carry subtotals at the top; children indented.
-        let r = pt(&s).last_range.unwrap();
-        assert_eq!(r.width(), 2);
-        // header + 3 regions + 9 (region, product) pairs present + grand total
-        assert_eq!(r.height(), 1 + 3 + 9 + 1);
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(val(&s, "B4"), Value::Number(415.0));
-        assert_eq!(text(&s, "A5"), "Apples");
-        let d = s.doc().unwrap();
-        let sh = d.wb.active().unwrap();
-        assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("A5").unwrap())).align.indent, 1);
-        assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A4").unwrap())).font.bold);
-        // Outline: one column per field.
-        s.execute("pivot.layout", json!({"layout": "outline"})).unwrap();
-        let r = pt(&s).last_range.unwrap();
-        assert_eq!(r.width(), 3);
-        assert_eq!(text(&s, "A3"), "Region");
-        assert_eq!(text(&s, "B3"), "Product");
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(text(&s, "B5"), "Apples");
-        // Tabular: first child on its parent's row; "East Total" rows below each group.
-        s.execute("pivot.layout", json!({"layout": "tabular"})).unwrap();
-        let r = pt(&s).last_range.unwrap();
-        assert_eq!(r.width(), 3);
-        assert_eq!(r.height(), 1 + 9 + 3 + 1);
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(text(&s, "B4"), "Apples");
-        assert_eq!(text(&s, "A5"), "");
-        assert_eq!(text(&s, "B5"), "Pears");
-        assert_eq!(text(&s, "A7"), "East Total");
-        assert_eq!(val(&s, "C7"), Value::Number(415.0));
-        // No subtotals, no grand totals.
-        s.execute("pivot.layout", json!({"subtotals": false, "grandTotalsCols": false})).unwrap();
-        assert_eq!(pt(&s).last_range.unwrap().height(), 1 + 9);
-        // Collapse East in compact layout: its children disappear.
-        s.execute("pivot.layout", json!({"layout": "compact", "subtotals": "top"})).unwrap();
-        s.execute("pivot.collapse", json!({"field": "Region", "items": ["East"]})).unwrap();
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(text(&s, "A5"), "North");
-        s.execute("pivot.collapse", json!({"field": "Region", "collapse": false})).unwrap();
-        assert_eq!(text(&s, "A5"), "Apples");
-    }
-
-    #[test]
-    fn values_on_rows_layouts() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales", "Units"]})).unwrap();
-        assert_eq!(text(&s, "C3"), "Sum of Units");
-        // Σ Values after Region: each region holds one line per value field.
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows"})).unwrap();
-        let p = pt(&s);
-        assert!(p.values_on_rows);
-        assert_eq!(p.values_position, None);
-        let r = p.last_range.unwrap();
-        assert_eq!(r.width(), 2);
-        // header + 3 × (region + 2 values) + 2 grand totals
-        assert_eq!(r.height(), 1 + 9 + 2);
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(val(&s, "B4"), Value::Empty);
-        assert_eq!(text(&s, "A5"), "Sum of Sales");
-        assert_eq!(val(&s, "B5"), Value::Number(415.0));
-        assert_eq!(text(&s, "A6"), "Sum of Units");
-        assert_eq!(val(&s, "B6"), Value::Number(33.0));
-        assert_eq!(text(&s, "A13"), "Total Sum of Sales");
-        assert_eq!(val(&s, "B13"), Value::Number(TOTAL));
-        assert_eq!(text(&s, "A14"), "Total Sum of Units");
-        assert_eq!(val(&s, "B14"), Value::Number(72.0));
-        // Tabular, no column field: "Total" heads the data column, as Excel saves it.
-        s.execute("pivot.layout", json!({"layout": "tabular"})).unwrap();
-        assert_eq!(text(&s, "A3"), "Region");
-        assert_eq!(text(&s, "B3"), "Values");
-        assert_eq!(text(&s, "C3"), "Total");
-        s.execute("pivot.layout", json!({"layout": "compact"})).unwrap();
-        // Σ Values before Region: the value fields are the outer items.
-        s.execute("pivot.moveField", json!({"field": "Values", "from": "rows", "to": "rows", "position": 0})).unwrap();
-        assert_eq!(pt(&s).values_position, Some(0));
-        assert_eq!(text(&s, "A4"), "Sum of Sales");
-        assert_eq!(val(&s, "B4"), Value::Empty);
-        assert_eq!(text(&s, "A5"), "East");
-        assert_eq!(val(&s, "B5"), Value::Number(415.0));
-        assert_eq!(text(&s, "A8"), "Sum of Units");
-        assert_eq!(text(&s, "A9"), "East");
-        assert_eq!(val(&s, "B9"), Value::Number(33.0));
-        assert_eq!(text(&s, "A12"), "Total Sum of Sales");
-        assert_eq!(val(&s, "B13"), Value::Number(72.0));
-        // Adding a row field in front keeps Σ Values ahead of Region.
-        s.execute("pivot.addField", json!({"field": "Product", "area": "rows", "position": 0})).unwrap();
-        assert_eq!(pt(&s).values_position, Some(1));
-        s.execute("pivot.removeField", json!({"field": "Product", "area": "rows"})).unwrap();
-        assert_eq!(pt(&s).values_position, Some(0));
-        // No row field: one line per value field and no grand total.
-        s.execute("pivot.removeField", json!({"field": "Region", "area": "rows"})).unwrap();
-        let r = pt(&s).last_range.unwrap();
-        assert_eq!(r.height(), 1 + 2);
-        assert_eq!(text(&s, "A4"), "Sum of Sales");
-        assert_eq!(val(&s, "B4"), Value::Number(TOTAL));
-        assert_eq!(text(&s, "A5"), "Sum of Units");
-        assert_eq!(val(&s, "B5"), Value::Number(72.0));
-        // Back to Columns.
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "rows", "to": "columns"})).unwrap();
-        assert!(!pt(&s).values_on_rows);
-        assert_eq!(text(&s, "A3"), "Sum of Sales");
-        assert_eq!(text(&s, "B3"), "Sum of Units");
-        assert!(s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "filters"})).is_err());
-        assert!(s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "rows", "to": "columns"})).is_err());
-    }
-
-    #[test]
-    fn collapsed_item_puts_values_in_the_values_column() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales", "Units"]})).unwrap();
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows"})).unwrap();
-        s.execute("pivot.collapse", json!({"field": "Region", "items": ["East"]})).unwrap();
-        for layout in ["tabular", "outline"] {
-            s.execute("pivot.layout", json!({"layout": layout})).unwrap();
-            assert_eq!(text(&s, "C3"), "Values", "{layout}");
-            let east = (4..20).find(|r| text(&s, &format!("A{r}")) == "East").unwrap();
-            let first = if layout == "tabular" { east } else { east + 1 };
-            assert_eq!(text(&s, &format!("B{first}")), "", "{layout}");
-            assert_eq!(text(&s, &format!("C{first}")), "Sum of Sales", "{layout}");
-            assert_eq!(val(&s, &format!("D{first}")), Value::Number(415.0), "{layout}");
-            assert_eq!(text(&s, &format!("C{}", first + 1)), "Sum of Units", "{layout}");
-        }
-    }
-
-    #[test]
-    fn values_stay_last_in_columns() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Product"], "columns": ["Region"], "values": ["Sales", "Units"]})).unwrap();
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "columns", "position": 0})).unwrap();
-        let p = pt(&s);
-        assert!(!p.values_on_rows);
-        assert_eq!(p.values_position, None);
-        // Σ Values to Rows and back with a position: still last in Columns.
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows"})).unwrap();
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "rows", "to": "columns", "position": 0})).unwrap();
-        assert_eq!(pt(&s).values_position, None);
-        assert_eq!(text(&s, "B5"), "Sum of Sales");
-        assert_eq!(text(&s, "C5"), "Sum of Units");
-    }
-
-    #[test]
-    fn change_source_keeps_values_ahead_of_its_field() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales", "Units"]})).unwrap();
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows", "position": 1})).unwrap();
-        // The new source has no Region: Σ Values stays ahead of Product.
-        s.execute("pivot.changeSource", json!({"source": "Sheet1!B1:E13"})).unwrap();
-        let p = pt(&s);
-        assert_eq!(p.rows.len(), 1);
-        assert_eq!(p.values_position, Some(0));
-        assert_eq!(text(&s, "A4"), "Sum of Sales");
-        assert_eq!(text(&s, "A5"), "Apples");
-    }
-
-    #[test]
-    fn values_on_rows_between_row_fields() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales", "Units"]})).unwrap();
-        s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows", "position": 1})).unwrap();
-        // Compact: East, then per value field its products, then per-value subtotals of East.
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(text(&s, "A5"), "Sum of Sales");
-        assert_eq!(text(&s, "A6"), "Apples");
-        assert_eq!(val(&s, "B6"), Value::Number(160.0));
-        assert_eq!(text(&s, "A9"), "Sum of Units");
-        assert_eq!(text(&s, "A10"), "Apples");
-        assert_eq!(val(&s, "B10"), Value::Number(16.0));
-        assert_eq!(text(&s, "A13"), "East Sum of Sales");
-        assert_eq!(val(&s, "B13"), Value::Number(415.0));
-        assert_eq!(text(&s, "A14"), "East Sum of Units");
-        assert_eq!(val(&s, "B14"), Value::Number(33.0));
-        let d = s.doc().unwrap();
-        let sh = d.wb.active().unwrap();
-        assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("A5").unwrap())).align.indent, 1);
-        assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("A6").unwrap())).align.indent, 2);
-        // Outline: one column per level, "Values" heads the Σ Values column.
-        s.execute("pivot.layout", json!({"layout": "outline"})).unwrap();
-        assert_eq!(pt(&s).last_range.unwrap().width(), 4);
-        assert_eq!(text(&s, "A3"), "Region");
-        assert_eq!(text(&s, "B3"), "Values");
-        assert_eq!(text(&s, "C3"), "Product");
-        assert_eq!(text(&s, "B5"), "Sum of Sales");
-        assert_eq!(text(&s, "C6"), "Apples");
-        assert_eq!(val(&s, "D6"), Value::Number(160.0));
-        // Tabular: labels start on their parent's row; totals per value field below each group.
-        s.execute("pivot.layout", json!({"layout": "tabular"})).unwrap();
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(text(&s, "B4"), "Sum of Sales");
-        assert_eq!(text(&s, "C4"), "Apples");
-        assert_eq!(val(&s, "D4"), Value::Number(160.0));
-        assert_eq!(text(&s, "B7"), "Sum of Units");
-        assert_eq!(text(&s, "C7"), "Apples");
-        assert_eq!(val(&s, "D7"), Value::Number(16.0));
-        assert_eq!(text(&s, "A10"), "East Sum of Sales");
-        assert_eq!(val(&s, "D10"), Value::Number(415.0));
-        assert_eq!(text(&s, "A11"), "East Sum of Units");
-        let r = pt(&s).last_range.unwrap();
-        let last = r.end.row + 1;
-        assert_eq!(text(&s, &format!("A{}", last - 1)), "Total Sum of Sales");
-        assert_eq!(text(&s, &format!("A{last}")), "Total Sum of Units");
-        assert_eq!(val(&s, &format!("D{last}")), Value::Number(72.0));
-    }
-
-    #[test]
-    fn refresh_after_source_edits() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
-        s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-        s.execute("cell.set", json!({"cell": "E2", "input": "1100"})).unwrap();
-        // Refresh All picks the change up.
-        let r = s.execute("data.refreshAll", json!({})).unwrap();
-        assert_eq!(r["refreshed"], 1);
-        let d = s.doc().unwrap();
-        let si = d.wb.sheet_index("Sheet2").unwrap();
-        let sh = d.wb.sheet(si).unwrap();
-        assert_eq!(sh.value(CellRef::parse("B4").unwrap()), Value::Number(1415.0));
-        assert_eq!(sh.value(CellRef::parse("B7").unwrap()), Value::Number(TOTAL + 1000.0));
-        // pivot.refresh by name; change source to fewer rows.
-        s.execute("pivot.changeSource", json!({"pivot": "PivotTable1", "source": "Sheet1!A1:E3"})).unwrap();
-        let d = s.doc().unwrap();
-        let sh = d.wb.sheet(si).unwrap();
-        assert_eq!(sh.value(CellRef::parse("A6").unwrap()).display(), "Grand Total");
-        assert_eq!(sh.value(CellRef::parse("B6").unwrap()), Value::Number(1150.0));
-        // Old rows were cleared.
-        assert_eq!(sh.value(CellRef::parse("A7").unwrap()), Value::Empty);
-        s.execute("pivot.refresh", json!({"pivot": "PivotTable1"})).unwrap();
-    }
-
-    fn pivot_chart(s: &Session) -> gridcraft_model::Chart {
-        s.doc().unwrap().wb.active().unwrap().charts.last().unwrap().clone()
-    }
-    fn plotted(s: &Session) -> Vec<Vec<Option<f64>>> {
-        let d = s.doc().unwrap();
-        let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet(), &pivot_chart(s));
-        data.series.into_iter().map(|x| x.values).collect()
-    }
-
-    #[test]
-    fn pivot_chart_follows_the_report() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
-        // Any cell of the report picks the PivotTable.
-        let r = s.execute("insert.pivotChart", json!({"pivot": "B5"})).unwrap();
-        assert_eq!(r["series"], 1);
-        let ch = pivot_chart(&s);
-        assert_eq!(ch.pivot.as_deref(), Some("Sheet2!PivotTable1"));
-        assert_eq!(ch.title.as_deref(), Some("Total"));
-        assert_eq!(ch.series[0].values, "Sheet2!$B$4:$B$6");
-        assert_eq!(ch.series[0].categories.as_deref(), Some("Sheet2!$A$4:$A$6"));
-        assert_eq!(plotted(&s), vec![vec![Some(415.0), Some(135.0), Some(285.0)]]);
-        // A column field: one series per item, rebound by the layout change.
-        s.execute("pivot.addField", json!({"field": "Product", "area": "columns"})).unwrap();
-        let ch = pivot_chart(&s);
-        let names: Vec<_> = ch.series.iter().map(|x| x.name.clone().unwrap_or_default()).collect();
-        assert_eq!(names, vec!["\"Apples\"", "\"Pears\"", "\"Plums\""]);
-        assert_eq!(plotted(&s)[0], vec![Some(160.0), Some(90.0), Some(170.0)]);
-        // Nested row fields: the innermost items only, as a union around the parent rows.
-        s.execute("pivot.moveField", json!({"field": "Product", "from": "columns", "to": "rows"})).unwrap();
-        let ch = pivot_chart(&s);
-        assert!(ch.series[0].values.starts_with('('), "{}", ch.series[0].values);
-        let pts = plotted(&s);
-        assert_eq!(pts[0].len(), 9);
-        assert_eq!(pts[0].iter().flatten().sum::<f64>(), TOTAL);
-        // Survives an XLSX round trip as a PivotChart.
-        let wb = (*s.doc().unwrap().wb).clone();
-        let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
-        let si = back.sheet_index("Sheet2").unwrap();
-        assert_eq!(back.sheet(si).unwrap().charts.first().and_then(|c| c.pivot.clone()).as_deref(), Some("Sheet2!PivotTable1"));
-        // Renaming the sheet keeps the link; a refresh still rebinds.
-        s.execute("sheet.rename", json!({"name": "Report"})).unwrap();
-        assert_eq!(pivot_chart(&s).pivot.as_deref(), Some("Report!PivotTable1"));
-        s.execute("pivot.moveField", json!({"field": "Region", "from": "rows", "to": "columns"})).unwrap();
-        assert_eq!(pivot_chart(&s).series.len(), 3);
-        // Deleting the PivotTable leaves an ordinary chart.
-        s.execute("pivot.delete", json!({})).unwrap();
-        assert_eq!(pivot_chart(&s).pivot, None);
-    }
-
-    #[test]
-    fn pivot_chart_errors() {
-        let mut s = sales();
-        // No PivotTable yet.
-        assert!(s.execute("insert.pivotChart", json!({})).is_err());
-        s.execute("insert.pivotTable", json!({"rows": ["Region"]})).unwrap();
-        // Not in the report; no values.
-        assert!(s.execute("insert.pivotChart", json!({"pivot": "Z99"})).is_err());
-        assert!(s.execute("insert.pivotChart", json!({})).unwrap_err().to_string().contains("Values"));
-        s.execute("pivot.addField", json!({"field": "Units", "area": "values"})).unwrap();
-        let r = s.execute("insert.pivotChart", json!({"pivot": "PivotTable1", "type": "line", "title": null})).unwrap();
-        assert_eq!(r["series"], 1);
-        let ch = pivot_chart(&s);
-        assert_eq!(ch.kind, gridcraft_model::ChartKind::Line);
-        assert_eq!(ch.title, None);
-        // One undo step.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert!(s.doc().unwrap().wb.active().unwrap().charts.is_empty());
-    }
-
-    #[test]
-    fn calculated_field_on_sums() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
-        let r = s.execute("pivot.calculatedField", json!({"name": "Price", "formula": "Sales / Units"})).unwrap();
-        assert_eq!(r["formula"], "=Sales / Units");
-        assert_eq!(text(&s, "C3"), "Sum of Price");
-        assert_eq!(text(&s, "A4"), "East");
-        // East: 415 sales over 33 units, from the sums.
-        let east = val(&s, "C4").as_f64().unwrap();
-        assert!((east - 415.0 / 33.0).abs() < 1e-12, "{east}");
-        // The grand total applies the formula to the totals, not the sum of the rows.
-        assert_eq!(text(&s, "A7"), "Grand Total");
-        let total = val(&s, "C7").as_f64().unwrap();
-        assert!((total - TOTAL / 72.0).abs() < 1e-12, "{total}");
-        // Quoted names, functions, and another calculated field.
-        s.execute("pivot.calculatedField", json!({"name": "Rounded", "formula": "=ROUND('Price'*2,1)"})).unwrap();
-        assert_eq!(val(&s, "D4"), Value::Number(25.2));
-        // Division by zero shows #DIV/0! cells.
-        s.execute("pivot.calculatedField", json!({"name": "Zero", "formula": "=Sales/(Units-Units)"})).unwrap();
-        assert_eq!(val(&s, "E4"), Value::Error(CellError::Div0));
-        // Change and delete.
-        s.execute("pivot.calculatedField", json!({"name": "zero", "formula": "=Units*2"})).unwrap();
-        assert_eq!(val(&s, "E4"), Value::Number(66.0));
-        s.execute("pivot.calculatedField", json!({"name": "Zero", "delete": true})).unwrap();
-        assert_eq!(pt(&s).values.len(), 3);
-        assert_eq!(pt(&s).calculated_fields.len(), 2);
-        // The field list shows calculated fields.
-        let f = s.execute("pivot.fields", json!({})).unwrap();
-        assert!(f["fields"].as_array().unwrap().iter().any(|x| x["name"] == "Price" && x["calculated"] == true));
-    }
-
-    #[test]
-    fn calculated_field_errors() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
-        let mut e = |p: Json| s.execute("pivot.calculatedField", p).unwrap_err().to_string();
-        assert!(e(json!({"name": "Bad", "formula": "=Sales*Bogus"})).contains("Bogus"));
-        assert!(e(json!({"name": "Bad", "formula": "=A1*2"})).contains("cells"));
-        assert!(e(json!({"name": "Bad", "formula": "=Sales*("})).contains("error"));
-        assert!(e(json!({"name": "Sales", "formula": "=1"})).contains("already exists"));
-        assert!(e(json!({"name": "Bad"})).contains("formula"));
-        assert!(e(json!({"name": "Gone", "delete": true})).contains("Gone"));
-        // A cycle is refused.
-        s.execute("pivot.calculatedField", json!({"name": "X", "formula": "=Sales"})).unwrap();
-        s.execute("pivot.calculatedField", json!({"name": "Y", "formula": "=X*2"})).unwrap();
-        let err = s.execute("pivot.calculatedField", json!({"name": "X", "formula": "=Y"})).unwrap_err().to_string();
-        assert!(err.contains("itself"), "{err}");
-        // Calculated fields only go to Values; nothing changed after the failures.
-        assert!(s.execute("pivot.addField", json!({"field": "Y", "area": "rows"})).is_err());
-        assert_eq!(pt(&s).calculated_fields.len(), 2);
-        // Without a name the dialog opens (menu-style call).
-        s.ui_requests.clear();
-        s.execute("pivot.calculatedField", json!({})).unwrap();
-        assert!(matches!(s.ui_requests.last(), Some(crate::UiRequest::Dialog(n, _)) if n == "pivotCalculatedField"));
-    }
-
-    #[test]
-    fn replace_protection() {
-        let mut s = sales();
-        s.execute("cell.set", json!({"cell": "H5", "input": "keep me"})).unwrap();
-        let e = s.execute("insert.pivotTable", json!({"destination": "Sheet1!H3", "rows": ["Region"], "values": ["Sales"]})).unwrap_err().to_string();
-        assert!(e.contains("There's already data in Sheet1!H5"), "{e}");
-        assert_eq!(s.doc().unwrap().wb.active().unwrap().pivots.len(), 0);
-        // Growing into data is refused as well.
-        s.execute("insert.pivotTable", json!({"destination": "Sheet1!H3"})).unwrap();
-        assert!(s.execute("pivot.addField", json!({"field": "Region", "area": "rows"})).is_err());
-        s.execute("pivot.addField", json!({"field": "Region", "area": "rows", "replace": true})).unwrap();
-        assert_eq!(text(&s, "H5"), "North");
-        // A second pivot can't overlap the first.
-        let e =
-            s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H6", "replace": true})).unwrap_err().to_string();
-        assert!(e.contains("overlap"), "{e}");
-        // Nor its own source data.
-        let e =
-            s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!B2", "replace": true})).unwrap_err().to_string();
-        assert!(e.contains("source data"), "{e}");
-        // Delete clears the report.
-        s.execute("pivot.delete", json!({})).unwrap();
-        assert_eq!(val(&s, "H5"), Value::Empty);
-        assert!(s.doc().unwrap().wb.active().unwrap().pivots.is_empty());
-    }
-
-    #[test]
-    fn fields_move_remove_sort() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
-        let f = s.execute("pivot.fields", json!({})).unwrap();
-        assert_eq!(f["fields"][0]["name"], "Region");
-        assert_eq!(f["fields"][0]["samples"], json!(["East", "North", "West"]));
-        assert_eq!(f["fields"][0]["areas"], json!(["rows"]));
-        assert_eq!(f["fields"][4]["numeric"], true);
-        assert_eq!(f["fields"][2]["date"], true);
-        s.execute("pivot.sort", json!({"field": "Region", "order": "desc"})).unwrap();
-        assert_eq!(text(&s, "A4"), "West");
-        s.execute("pivot.moveField", json!({"field": "Region", "from": "rows", "to": "columns"})).unwrap();
-        assert_eq!(text(&s, "B4"), "West");
-        s.execute("pivot.removeField", json!({"field": "Sum of Sales", "area": "values"})).unwrap();
-        s.execute("pivot.addField", json!({"field": "Region", "area": "values"})).unwrap();
-        assert_eq!(pt(&s).values[0].name, "Count of Region");
-        s.execute("pivot.removeField", json!({"field": "Region"})).unwrap();
-        assert!(pt(&s).columns.is_empty() && pt(&s).values.is_empty());
-        assert!(text(&s, "A3").contains("choose fields"));
-        assert!(s.execute("pivot.addField", json!({"field": "Nope", "area": "rows"})).is_err());
-        assert!(s.execute("pivot.addField", json!({"field": "Region", "area": "sideways"})).is_err());
-    }
-
-    #[test]
-    fn recommended_and_summarize() {
-        let mut s = sales();
-        let r = s.execute("insert.recommendedPivotTables", json!({})).unwrap();
-        let list = r["suggestions"].as_array().unwrap();
-        assert!((3..=5).contains(&list.len()), "{list:?}");
-        assert_eq!(list[0]["title"], "Sum of Units by Region");
-        let r = s.execute("insert.recommendedPivotTables", json!({"apply": 2})).unwrap();
-        assert!(r["suggestion"]["title"].as_str().unwrap().contains("quarters"));
-        assert_eq!(text(&s, "A4"), "Qtr1");
-        // From a table.
-        s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-        s.execute("insert.table", json!({"range": "A1:E13"})).unwrap();
-        s.execute("selection.set", json!({"range": "B2"})).unwrap();
-        let r = s.execute("table.summarizePivot", json!({"rows": ["Product"], "values": ["Units"]})).unwrap();
-        assert_eq!(pt(&s).source, "Table1");
-        assert_eq!(r["name"], "PivotTable2");
-        let gt = find_row(&s, "Grand Total").unwrap();
-        assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(72.0));
-    }
-
-    #[test]
-    fn repeated_headers_get_numbered_names() {
-        let mut s = Session::new();
-        s.new_workbook();
-        let mut header = vec![json!("a"), json!("A"), json!("a"), json!("a2")];
-        // Thousands of equal headers (a row of check boxes, say) used to take cubic time; this would
-        // hang rather than fail a wall-clock check, which is flaky on a loaded machine.
-        header.extend((0..3000).map(|_| json!("x")));
-        let data: Vec<_> = (0..header.len()).map(|i| json!(i)).collect();
-        let end = CellRef::new(1, header.len() as u32 - 1).a1();
-        s.execute("range.setValues", json!({"range": "A1", "values": [header, data]})).unwrap();
-        let src = crate::pivot::read_source(&s.doc().unwrap().wb, &format!("Sheet1!A1:{end}"), 0).unwrap();
-        assert_eq!(&src.headers[..4], ["a", "A2", "a3", "a22"]);
-        assert_eq!(src.headers[4], "x");
-        assert_eq!(src.headers.last().map(String::as_str), Some("x3000"));
-        // Table column names follow the same rule.
-        s.execute("insert.table", json!({"range": format!("A1:{end}"), "header": true})).unwrap();
-        let text = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["text"].clone();
-        assert_eq!(text(&mut s, "B1"), "A2");
-        let last = CellRef::new(0, 3003).a1();
-        assert_eq!(text(&mut s, &last), "x3000");
-    }
-
-    #[test]
-    fn hostile_params_never_panic() {
-        let mut s = sales();
-        let cmds = [
-            "insert.pivotTable",
-            "insert.recommendedPivotTables",
-            "table.summarizePivot",
-            "pivot.fields",
-            "pivot.fieldList",
-            "pivot.list",
-            "pivot.addField",
-            "pivot.removeField",
-            "pivot.moveField",
-            "pivot.valueSettings",
-            "pivot.filter",
-            "pivot.sort",
-            "pivot.group",
-            "pivot.collapse",
-            "pivot.layout",
-            "pivot.grandTotals",
-            "pivot.subtotals",
-            "pivot.reportLayout",
-            "pivot.style",
-            "pivot.refresh",
-            "data.refreshAll",
-            "pivot.changeSource",
-            "pivot.delete",
-            "pivot.showDetails",
-            "pivot.options",
-        ];
-        let hostile = [
-            json!({}),
-            json!([1, 2]),
-            json!({"pivot": 99999, "field": 5, "area": null}),
-            json!({"source": "ZZZ999999999", "destination": "Nope!A1"}),
-            json!({"source": "A:XFD", "destination": "Sheet1!XFD1048576"}),
-            json!({"source": "''!A1", "destination": "!"}),
-            json!({"field": "Sales", "area": "values", "func": "bogus", "position": 4294967295u64}),
-            json!({"field": "Region", "selected": [null, 1, {"x": 1}], "index": 18446744073709551615u64, "showAs": "rank"}),
-            json!({"apply": 99, "layout": "weird", "subtotals": 7, "style": "x".repeat(500)}),
-            json!({"field": "Date", "by": "decades", "items": "nope", "order": "sideways"}),
-        ];
-        for c in cmds {
-            for h in &hostile {
-                let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    let spec = crate::find_command(c).unwrap();
-                    let _ = (spec.run)(&mut s, h);
-                }));
-                assert!(r.is_ok(), "{c} panicked on {h}");
-            }
-        }
-        // And on a real pivot.
-        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "rows": ["Region"], "values": ["Sales"]})).unwrap();
-        for c in cmds {
-            for h in &hostile {
-                let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    let spec = crate::find_command(c).unwrap();
-                    let _ = (spec.run)(&mut s, h);
-                }));
-                assert!(r.is_ok(), "{c} panicked on {h}");
-            }
-        }
-    }
-
-    #[test]
-    fn empty_header_is_refused() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Region", ""], ["East", 1]]})).unwrap();
-        let e = s.execute("insert.pivotTable", json!({"source": "A1:B2"})).unwrap_err().to_string();
-        assert!(e.contains("field name is not valid"), "{e}");
-        assert!(s.execute("insert.pivotTable", json!({"source": "NoSuchTable"})).is_err());
-    }
-
-    #[test]
-    fn too_many_value_columns_are_refused() {
-        let mut s = Session::new();
-        s.new_workbook();
-        let mut records: Vec<Json> = vec![json!(["Cat", "Sub", "V"])];
-        for r in 0..64 {
-            for c in 0..64 {
-                records.push(json!([format!("c{r}"), format!("s{c}"), 1.0]));
-            }
-        }
-        s.execute("range.setValues", json!({"range": "A1", "values": records})).unwrap();
-        let req = |n: usize| {
-            let values: Vec<Json> = (0..n).map(|_| json!({"field": "V"})).collect();
-            json!({"source": "A1:C4097", "rows": ["Cat"], "columns": ["Sub"], "values": values})
-        };
-        let e = s.execute("insert.pivotTable", req(256)).unwrap_err().to_string();
-        assert!(e.contains("will not fit"), "{e}");
-        assert!(s.execute("insert.pivotTable", req(128)).is_ok());
-    }
-
-    #[test]
-    fn collapsed_column_items_count_as_one_column_group() {
-        let mut s = Session::new();
-        s.new_workbook();
-        let mut records: Vec<Json> = vec![json!(["Grp", "Sub", "V"])];
-        records.extend((0..64).map(|c| json!(["g", format!("s{c}"), 1.0])));
-        s.execute("range.setValues", json!({"range": "A1", "values": records})).unwrap();
-        let values: Vec<Json> = (0..256).map(|_| json!({"field": "V"})).collect();
-        s.execute("insert.pivotTable", json!({"source": "A1:C65", "columns": ["Grp"], "values": values})).unwrap();
-        s.execute("pivot.collapse", json!({"field": "Grp"})).unwrap();
-        // 64 Sub items under the collapsed "g" show as one column group: (1 + grand total) x 256 columns fit.
-        s.execute("pivot.addField", json!({"field": "Sub", "area": "columns"})).unwrap();
-    }
-
-    #[test]
-    fn inserting_or_deleting_lines_moves_the_pivot_with_its_cells() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H10", "rows": ["Region"], "values": ["Sales"]}))
-            .unwrap();
-        assert_eq!(pt(&s).last_range.unwrap().a1(), "H10:I14");
-        // Rows above the report (and below the source) move the report only.
-        s.execute("home.insertRows", json!({"rows": "16:17"})).unwrap();
-        s.execute("home.insertRows", json!({"rows": "6:7"})).unwrap();
-        assert_eq!(text(&s, "H12"), "Row Labels");
-        let l = s.execute("pivot.list", json!({})).unwrap();
-        assert_eq!(l[0]["anchor"], "H12");
-        assert_eq!(l[0]["range"], "H12:I16");
-        assert_eq!(l[0]["source"], "Sheet1!A1:E15");
-        // A row above the source moves both.
-        s.execute("home.insertRows", json!({"rows": "1:1"})).unwrap();
-        let p = pt(&s);
-        assert_eq!(p.source, "Sheet1!A2:E16");
-        assert_eq!(p.anchor.a1(), "H13");
-        s.execute("pivot.refresh", json!({})).unwrap();
-        assert_eq!(pt(&s).last_range.unwrap().a1(), "H13:I17");
-        assert_eq!(text(&s, "H13"), "Row Labels");
-        assert_eq!(val(&s, "I17"), Value::Number(TOTAL));
-        // Deleting a column left of the report moves it left.
-        s.execute("home.deleteColumns", json!({"cols": "F:F"})).unwrap();
-        let p = pt(&s);
-        assert_eq!(p.anchor.a1(), "G13");
-        assert_eq!(p.last_range.unwrap().a1(), "G13:H17");
-        // Deleting rows above moves it up.
-        s.execute("home.deleteRows", json!({"rows": "1:1"})).unwrap();
-        assert_eq!(pt(&s).source, "Sheet1!A1:E15");
-        assert_eq!(pt(&s).anchor.a1(), "G12");
-        s.execute("pivot.refresh", json!({})).unwrap();
-        assert_eq!(text(&s, "G12"), "Row Labels");
-        assert_eq!(val(&s, "H16"), Value::Number(TOTAL));
-    }
-
-    #[test]
-    fn inserting_rows_on_the_source_sheet_moves_another_sheets_pivot_source() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "rows": ["Region"], "values": ["Sales"]})).unwrap();
-        s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-        s.execute("home.insertRows", json!({"rows": "1:2"})).unwrap();
-        let l = s.execute("pivot.list", json!({})).unwrap();
-        assert_eq!(l[0]["source"], "Sheet1!A3:E15");
-        assert_eq!(l[0]["anchor"], "A3");
-        s.execute("pivot.refresh", json!({"pivot": "PivotTable1"})).unwrap();
-    }
-
-    /// The active sheet's first five columns as shown, down to the first blank row.
-    fn sheet_rows(s: &mut Session) -> Vec<Vec<String>> {
-        let mut out = Vec::new();
-        for r in 0..30u32 {
-            let row: Vec<String> = (0..5)
-                .map(|c| s.execute("cell.get", json!({"cell": CellRef::new(r, c).a1()})).unwrap()["text"].as_str().unwrap_or("").to_string())
-                .collect();
-            if row.iter().all(String::is_empty) {
-                break;
-            }
-            out.push(row);
-        }
-        out
-    }
-
-    #[test]
-    fn show_details_lists_a_value_cells_records_on_a_new_sheet() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        // B5 is East × Apples (100 + 60); the active cell is the default.
-        s.execute("selection.set", json!({"range": "B5"})).unwrap();
-        let r = s.execute("pivot.showDetails", json!({})).unwrap();
-        assert_eq!(r["records"], 2);
-        let d = s.doc().unwrap();
-        assert_eq!(d.wb.sheets.len(), 3);
-        assert_eq!(d.wb.active_sheet(), 0, "the new sheet goes before the PivotTable's");
-        assert_eq!(d.wb.active().unwrap().name, "Sheet3");
-        assert_eq!(
-            sheet_rows(&mut s),
-            vec![
-                vec!["Region", "Product", "Date", "Units", "Sales"],
-                vec!["East", "Apples", "1/15/2026", "10", "100"],
-                vec!["East", "Apples", "9/9/2026", "6", "60"],
-            ]
-        );
-        // The dates fit their column instead of showing ####.
-        let sh = s.doc().unwrap().wb.active().unwrap().clone();
-        assert!(sh.col_width(2) > sh.col_width(5), "{} vs {}", sh.col_width(2), sh.col_width(5));
-        // One undo step takes the sheet away.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-        assert_eq!(val(&s, "B5"), Value::Number(160.0));
-    }
-
-    #[test]
-    fn show_details_on_a_total_takes_every_record_it_adds_up() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        let records = |s: &mut Session, cell: &str| {
-            let n = s.execute("pivot.showDetails", json!({"cell": cell})).unwrap()["records"].as_u64().unwrap();
-            s.execute("edit.undo", json!({})).unwrap();
-            n
-        };
-        assert_eq!(records(&mut s, "E5"), 5, "East's row total");
-        assert_eq!(records(&mut s, "C8"), 4, "Pears' column total");
-        assert_eq!(records(&mut s, "E8"), 12, "the grand total");
-        // A subtotal at the top of its group, in a two-level row axis.
-        s.execute("pivot.moveField", json!({"field": "Product", "from": "columns", "to": "rows"})).unwrap();
-        assert_eq!(text(&s, "A4"), "East");
-        assert_eq!(records(&mut s, "B4"), 5);
-        assert_eq!(text(&s, "A6"), "Pears");
-        assert_eq!(records(&mut s, "B6"), 2);
-    }
-
-    #[test]
-    fn show_details_leaves_out_the_records_the_report_filters_out() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
-        s.execute("pivot.filter", json!({"field": "Region", "selected": ["East"]})).unwrap();
-        s.execute("pivot.filter", json!({"field": "Product", "selected": ["Apples"]})).unwrap();
-        let gt = find_row(&s, "Grand Total").unwrap();
-        let r = s.execute("pivot.showDetails", json!({"cell": CellRef::new(gt, 1).a1()})).unwrap();
-        assert_eq!(r["records"], 2);
-        let rows = sheet_rows(&mut s);
-        assert_eq!(rows.len(), 3);
-        assert!(rows.iter().skip(1).all(|row| row[0] == "East" && row[1] == "Apples"), "{rows:?}");
-    }
-
-    #[test]
-    fn show_details_refuses_a_report_its_source_has_moved_on_from() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        // B5 still shows East × Apples (160), but the first East record is now Central's.
-        s.execute("range.setValues", json!({"range": "Sheet1!A2", "values": [["Central"]]})).unwrap();
-        assert_eq!(val(&s, "B5"), Value::Number(160.0));
-        let e = s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap_err().to_string();
-        assert!(e.contains("out of date"), "{e}");
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-        // After a refresh East × Apples (now B6) has the one record left.
-        s.execute("pivot.refresh", json!({})).unwrap();
-        assert_eq!(text(&s, "A6"), "East");
-        assert_eq!(s.execute("pivot.showDetails", json!({"cell": "B6"})).unwrap()["records"], 1);
-    }
-
-    #[test]
-    fn show_details_refuses_a_report_that_would_now_be_shorter() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        // North goes away: the source now gives one row fewer, so row 8 is no longer the Grand Total.
-        s.execute("range.setValues", json!({"range": "Sheet1!A5", "values": [["East"]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "Sheet1!A8", "values": [["East"]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "Sheet1!A11", "values": [["East"]]})).unwrap();
-        assert_eq!(text(&s, "A8"), "Grand Total");
-        let e = s.execute("pivot.showDetails", json!({"cell": "E8"})).unwrap_err().to_string();
-        assert!(e.contains("out of date"), "{e}");
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-    }
-
-    #[test]
-    fn show_details_needs_a_value_cell() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        for cell in ["A3", "B3", "A4", "B4", "A5", "A8", "H20"] {
-            assert!(s.execute("pivot.showDetails", json!({"cell": cell})).is_err(), "{cell}");
-        }
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-    }
-
-    #[test]
-    fn enable_show_details_off_stops_show_details() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        assert_eq!(s.execute("pivot.options", json!({})).unwrap()["enableShowDetails"], true);
-        s.execute("pivot.options", json!({"enableShowDetails": false})).unwrap();
-        assert!(!pt(&s).enable_show_details);
-        assert_eq!(s.execute("pivot.fields", json!({})).unwrap()["enableShowDetails"], false);
-        let e = s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap_err().to_string();
-        assert_eq!(e, "Show Details is turned off for this PivotTable.");
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-        // A label still reports that it is not a value cell.
-        let e = s.execute("pivot.showDetails", json!({"cell": "A5"})).unwrap_err().to_string();
-        assert!(!e.contains("turned off"), "{e}");
-        // Setting the same value again adds no undo step.
-        let after = s.doc().unwrap().revision;
-        s.execute("pivot.options", json!({"enableShowDetails": false})).unwrap();
-        assert_eq!(s.doc().unwrap().revision, after);
-        assert!(s.execute("pivot.options", json!({"enableShowDetails": "no"})).is_err());
-        // One undo turns the option back on.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert!(pt(&s).enable_show_details);
-        assert_eq!(s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap()["records"], 2);
-    }
-
-    #[test]
-    fn enable_show_details_off_is_reported_before_an_out_of_date_report() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        s.execute("pivot.options", json!({"enableShowDetails": false})).unwrap();
-        // The source changes after the report was written, so the report is out of date.
-        s.execute("range.setValues", json!({"range": "Sheet1!A2", "values": [["Central"]]})).unwrap();
-        let e = s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap_err().to_string();
-        assert!(e.contains("turned off") && !e.contains("out of date"), "{e}");
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-    }
-
-    #[test]
-    fn detail_cells_are_the_cells_show_details_takes() {
-        let mut s = sales();
-        s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
-        for layout in 0..2 {
-            if layout == 1 {
-                // A two-level row axis, with subtotals at the top of each group.
-                s.execute("pivot.moveField", json!({"field": "Product", "from": "columns", "to": "rows"})).unwrap();
-            }
-            let d = s.doc().unwrap();
-            let si = d.wb.active_sheet();
-            let pt = &d.wb.active().unwrap().pivots[0];
-            let r = pt.last_range.unwrap();
-            let cells = crate::pivot::detail_cells(&d.wb, pt, si).unwrap();
-            let mut values = 0;
-            for row in 0..r.height() {
-                for col in 0..r.width() {
-                    let one = crate::pivot::detail_records(&d.wb, pt, si, row, col).unwrap();
-                    assert_eq!(cells.contains(&(row, col)), one.is_some(), "layout {layout}, cell ({row}, {col})");
-                    values += usize::from(one.is_some());
-                }
-            }
-            assert!(values > 4, "layout {layout} has value cells");
-        }
-        // An out-of-date report answers as Show Details does.
-        s.execute("range.setValues", json!({"range": "Sheet1!A2", "values": [["Central"]]})).unwrap();
-        let d = s.doc().unwrap();
-        let pt = &d.wb.active().unwrap().pivots[0];
-        assert!(crate::pivot::detail_cells(&d.wb, pt, d.wb.active_sheet()).unwrap_err().contains("out of date"));
-    }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs
new file mode 100644
index 000000000..49aca34d8
--- /dev/null
+++ b/crates/engine/src/cmd/pivot/tests.rs
@@ -0,0 +1,994 @@
+use gridcraft_core::{CellError, CellRef, Value};
+use serde_json::{Value as Json, json};
+
+use crate::Session;
+
+/// Region, Product, Date, Units, Sales — 12 records over 2026.
+fn sales() -> Session {
+    let mut s = Session::new();
+    s.new_workbook();
+    let rows = json!([
+        ["Region", "Product", "Date", "Units", "Sales"],
+        ["East", "Apples", "1/15/2026", 10, 100],
+        ["West", "Apples", "2/10/2026", 5, 50],
+        ["East", "Pears", "3/3/2026", 8, 120],
+        ["North", "Pears", "4/20/2026", 2, 30],
+        ["West", "Plums", "5/5/2026", 7, 70],
+        ["East", "Plums", "6/30/2026", 4, 60],
+        ["North", "Apples", "7/4/2026", 9, 90],
+        ["West", "Pears", "8/8/2026", 3, 45],
+        ["East", "Apples", "9/9/2026", 6, 60],
+        ["North", "Plums", "10/10/2026", 1, 15],
+        ["West", "Apples", "11/11/2026", 12, 120],
+        ["East", "Pears", "12/12/2026", 5, 75]
+    ]);
+    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
+    s.execute("selection.set", json!({"range": "A1"})).unwrap();
+    s
+}
+const TOTAL: f64 = 835.0;
+
+fn val(s: &Session, a: &str) -> Value {
+    s.doc().unwrap().wb.active().unwrap().value(CellRef::parse(a).unwrap())
+}
+fn text(s: &Session, a: &str) -> String {
+    val(s, a).display()
+}
+fn pt(s: &Session) -> gridcraft_model::PivotTable {
+    s.doc().unwrap().wb.active().unwrap().pivots.last().unwrap().clone()
+}
+/// Finds the row (0-based) whose first report column holds `label`.
+fn find_row(s: &Session, label: &str) -> Option<u32> {
+    let p = pt(s);
+    let r = p.last_range.unwrap();
+    (r.start.row..=r.end.row).find(|row| val(s, &CellRef::new(*row, r.start.col).a1()).display() == label)
+}
+
+#[test]
+fn insert_creates_placeholder_on_new_sheet() {
+    let mut s = sales();
+    let r = s.execute("insert.pivotTable", json!({})).unwrap();
+    assert_eq!(r["name"], "PivotTable1");
+    assert_eq!(r["anchor"], "A3");
+    assert_eq!(r["fields"], json!(["Region", "Product", "Date", "Units", "Sales"]));
+    let d = s.doc().unwrap();
+    assert_eq!(d.wb.sheets.len(), 2);
+    assert_eq!(d.wb.active_sheet(), 0, "new sheet goes before the current one");
+    assert_eq!(d.wb.active().unwrap().name, "Sheet2");
+    assert!(text(&s, "A3").starts_with("PivotTable1"));
+    assert_eq!(pt(&s).source, "Sheet1!$A$1:$E$13");
+    // One undo step removes it.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 1);
+}
+
+#[test]
+fn region_by_product_sum_of_sales() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({})).unwrap();
+    s.execute("pivot.addField", json!({"field": "region", "area": "rows"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Product", "area": "columns"})).unwrap();
+    let r = s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
+    assert_eq!(r["range"], "A3:E8");
+    assert_eq!(text(&s, "A3"), "Sum of Sales");
+    assert_eq!(text(&s, "B3"), "Column Labels");
+    assert_eq!(text(&s, "A4"), "Row Labels");
+    assert_eq!(text(&s, "B4"), "Apples");
+    assert_eq!(text(&s, "C4"), "Pears");
+    assert_eq!(text(&s, "D4"), "Plums");
+    assert_eq!(text(&s, "E4"), "Grand Total");
+    assert_eq!(text(&s, "A5"), "East");
+    assert_eq!(text(&s, "A6"), "North");
+    assert_eq!(text(&s, "A7"), "West");
+    assert_eq!(text(&s, "A8"), "Grand Total");
+    assert_eq!(val(&s, "B5"), Value::Number(160.0));
+    assert_eq!(val(&s, "C5"), Value::Number(195.0));
+    assert_eq!(val(&s, "E5"), Value::Number(415.0));
+    assert_eq!(val(&s, "E8"), Value::Number(TOTAL));
+    // Column grand totals add up too.
+    let sum: f64 = ["B8", "C8", "D8"].iter().map(|a| val(&s, a).as_f64().unwrap()).sum();
+    assert_eq!(sum, TOTAL);
+    let rows: f64 = ["E5", "E6", "E7"].iter().map(|a| val(&s, a).as_f64().unwrap()).sum();
+    assert_eq!(rows, TOTAL);
+    // Styles: header bold, grand total bold with a top border.
+    let d = s.doc().unwrap();
+    let sh = d.wb.active().unwrap();
+    assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A4").unwrap())).font.bold);
+    let g = d.wb.styles.get(sh.style_id(CellRef::parse("B8").unwrap()));
+    assert!(g.font.bold && !g.borders.top.is_none());
+    // Listing.
+    let l = s.execute("pivot.list", json!({})).unwrap();
+    assert_eq!(l[0]["values"][0]["name"], "Sum of Sales");
+}
+
+#[test]
+fn multiple_value_fields_make_a_values_dimension() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales", {"field": "Units", "func": "average"}]})).unwrap();
+    assert_eq!(text(&s, "A3"), "Row Labels");
+    assert_eq!(text(&s, "B3"), "Sum of Sales");
+    assert_eq!(text(&s, "C3"), "Average of Units");
+    assert_eq!(text(&s, "A7"), "Grand Total");
+    assert_eq!(val(&s, "B7"), Value::Number(TOTAL));
+    assert_eq!(val(&s, "C7"), Value::Number(72.0 / 12.0));
+    // With a column field the values become the innermost column level.
+    s.execute("pivot.addField", json!({"field": "Product", "area": "columns"})).unwrap();
+    assert_eq!(text(&s, "B4"), "Apples");
+    assert_eq!(text(&s, "B5"), "Sum of Sales");
+    assert_eq!(text(&s, "C5"), "Average of Units");
+    assert_eq!(text(&s, "D4"), "Pears");
+    assert_eq!(text(&s, "H4"), "Total Sum of Sales");
+    assert_eq!(text(&s, "I4"), "Total Average of Units");
+    let last = pt(&s).last_range.unwrap();
+    assert_eq!(val(&s, &CellRef::new(last.end.row, 7).a1()), Value::Number(TOTAL));
+}
+
+#[test]
+fn date_grouping_by_quarter_and_month() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Date"], "values": ["Sales"]})).unwrap();
+    // Ungrouped: one row per date, shown with the source date format.
+    assert_eq!(pt(&s).last_range.unwrap().height(), 14);
+    s.execute("pivot.group", json!({"field": "Date", "by": "quarters"})).unwrap();
+    assert_eq!(text(&s, "A4"), "Qtr1");
+    assert_eq!(text(&s, "A7"), "Qtr4");
+    assert_eq!(val(&s, "B4"), Value::Number(270.0));
+    assert_eq!(val(&s, "B5"), Value::Number(160.0));
+    assert_eq!(val(&s, "B8"), Value::Number(TOTAL));
+    s.execute("pivot.group", json!({"field": "Date", "by": "months"})).unwrap();
+    assert_eq!(text(&s, "A4"), "Jan");
+    assert_eq!(text(&s, "A15"), "Dec");
+    s.execute("pivot.group", json!({"field": "Date", "by": "years"})).unwrap();
+    assert_eq!(text(&s, "A4"), "2026");
+    assert!(s.execute("pivot.group", json!({"field": "Region", "by": "years"})).is_err());
+}
+
+#[test]
+fn filters_and_report_filter_rows() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
+    // Report filter above the body; the body stays at A3.
+    assert_eq!(text(&s, "A1"), "Region");
+    assert_eq!(text(&s, "B1"), "(All)");
+    assert_eq!(text(&s, "A3"), "Row Labels");
+    s.execute("pivot.filter", json!({"field": "Region", "selected": ["East"]})).unwrap();
+    assert_eq!(text(&s, "B1"), "East");
+    let gt = find_row(&s, "Grand Total").unwrap();
+    assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(415.0));
+    s.execute("pivot.filter", json!({"field": "Region", "selected": ["East", "west"]})).unwrap();
+    assert_eq!(text(&s, "B1"), "(Multiple Items)");
+    s.execute("pivot.filter", json!({"field": "Region", "selected": null})).unwrap();
+    let gt = find_row(&s, "Grand Total").unwrap();
+    assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(TOTAL));
+    // Hidden items on a row field.
+    s.execute("pivot.filter", json!({"field": "Product", "selected": ["Apples"]})).unwrap();
+    assert_eq!(text(&s, "A4"), "Apples");
+    assert_eq!(text(&s, "A5"), "Grand Total");
+    assert_eq!(val(&s, "B5"), Value::Number(420.0));
+    assert!(s.execute("pivot.filter", json!({"field": "Product", "selected": []})).is_err());
+}
+
+#[test]
+fn show_values_as() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    s.execute("pivot.valueSettings", json!({"field": "Sum of Sales", "showAs": "percentOfGrandTotal"})).unwrap();
+    let east = val(&s, "B4").as_f64().unwrap();
+    assert!((east - 415.0 / TOTAL).abs() < 1e-12);
+    assert_eq!(val(&s, "B7"), Value::Number(1.0));
+    assert_eq!(text(&s, "B7"), "1");
+    let d = s.doc().unwrap();
+    let sh = d.wb.active().unwrap();
+    assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("B4").unwrap())).num_fmt.as_str(), "0.00%");
+    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "runningTotal"})).unwrap();
+    assert_eq!(val(&s, "B4"), Value::Number(415.0));
+    assert_eq!(val(&s, "B5"), Value::Number(415.0 + 135.0));
+    assert_eq!(val(&s, "B6"), Value::Number(TOTAL));
+    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "rank"})).unwrap();
+    assert_eq!(val(&s, "B4"), Value::Number(1.0));
+    assert_eq!(val(&s, "B5"), Value::Number(3.0));
+    assert_eq!(val(&s, "B6"), Value::Number(2.0));
+    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "normal", "func": "max", "numberFormat": "#,##0"})).unwrap();
+    assert_eq!(text(&s, "B3"), "Max of Sales");
+    assert_eq!(val(&s, "B4"), Value::Number(120.0));
+    assert!(s.execute("pivot.valueSettings", json!({"index": 0, "name": "Sales"})).is_err());
+    s.execute("pivot.valueSettings", json!({"index": 0, "name": "Biggest sale"})).unwrap();
+    assert_eq!(text(&s, "B3"), "Biggest sale");
+}
+
+#[test]
+fn compact_vs_tabular_shapes() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales"]})).unwrap();
+    // Compact: one label column; parents carry subtotals at the top; children indented.
+    let r = pt(&s).last_range.unwrap();
+    assert_eq!(r.width(), 2);
+    // header + 3 regions + 9 (region, product) pairs present + grand total
+    assert_eq!(r.height(), 1 + 3 + 9 + 1);
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(val(&s, "B4"), Value::Number(415.0));
+    assert_eq!(text(&s, "A5"), "Apples");
+    let d = s.doc().unwrap();
+    let sh = d.wb.active().unwrap();
+    assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("A5").unwrap())).align.indent, 1);
+    assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A4").unwrap())).font.bold);
+    // Outline: one column per field.
+    s.execute("pivot.layout", json!({"layout": "outline"})).unwrap();
+    let r = pt(&s).last_range.unwrap();
+    assert_eq!(r.width(), 3);
+    assert_eq!(text(&s, "A3"), "Region");
+    assert_eq!(text(&s, "B3"), "Product");
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(text(&s, "B5"), "Apples");
+    // Tabular: first child on its parent's row; "East Total" rows below each group.
+    s.execute("pivot.layout", json!({"layout": "tabular"})).unwrap();
+    let r = pt(&s).last_range.unwrap();
+    assert_eq!(r.width(), 3);
+    assert_eq!(r.height(), 1 + 9 + 3 + 1);
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(text(&s, "B4"), "Apples");
+    assert_eq!(text(&s, "A5"), "");
+    assert_eq!(text(&s, "B5"), "Pears");
+    assert_eq!(text(&s, "A7"), "East Total");
+    assert_eq!(val(&s, "C7"), Value::Number(415.0));
+    // No subtotals, no grand totals.
+    s.execute("pivot.layout", json!({"subtotals": false, "grandTotalsCols": false})).unwrap();
+    assert_eq!(pt(&s).last_range.unwrap().height(), 1 + 9);
+    // Collapse East in compact layout: its children disappear.
+    s.execute("pivot.layout", json!({"layout": "compact", "subtotals": "top"})).unwrap();
+    s.execute("pivot.collapse", json!({"field": "Region", "items": ["East"]})).unwrap();
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(text(&s, "A5"), "North");
+    s.execute("pivot.collapse", json!({"field": "Region", "collapse": false})).unwrap();
+    assert_eq!(text(&s, "A5"), "Apples");
+}
+
+#[test]
+fn values_on_rows_layouts() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales", "Units"]})).unwrap();
+    assert_eq!(text(&s, "C3"), "Sum of Units");
+    // Σ Values after Region: each region holds one line per value field.
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows"})).unwrap();
+    let p = pt(&s);
+    assert!(p.values_on_rows);
+    assert_eq!(p.values_position, None);
+    let r = p.last_range.unwrap();
+    assert_eq!(r.width(), 2);
+    // header + 3 × (region + 2 values) + 2 grand totals
+    assert_eq!(r.height(), 1 + 9 + 2);
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(val(&s, "B4"), Value::Empty);
+    assert_eq!(text(&s, "A5"), "Sum of Sales");
+    assert_eq!(val(&s, "B5"), Value::Number(415.0));
+    assert_eq!(text(&s, "A6"), "Sum of Units");
+    assert_eq!(val(&s, "B6"), Value::Number(33.0));
+    assert_eq!(text(&s, "A13"), "Total Sum of Sales");
+    assert_eq!(val(&s, "B13"), Value::Number(TOTAL));
+    assert_eq!(text(&s, "A14"), "Total Sum of Units");
+    assert_eq!(val(&s, "B14"), Value::Number(72.0));
+    // Tabular, no column field: "Total" heads the data column, as Excel saves it.
+    s.execute("pivot.layout", json!({"layout": "tabular"})).unwrap();
+    assert_eq!(text(&s, "A3"), "Region");
+    assert_eq!(text(&s, "B3"), "Values");
+    assert_eq!(text(&s, "C3"), "Total");
+    s.execute("pivot.layout", json!({"layout": "compact"})).unwrap();
+    // Σ Values before Region: the value fields are the outer items.
+    s.execute("pivot.moveField", json!({"field": "Values", "from": "rows", "to": "rows", "position": 0})).unwrap();
+    assert_eq!(pt(&s).values_position, Some(0));
+    assert_eq!(text(&s, "A4"), "Sum of Sales");
+    assert_eq!(val(&s, "B4"), Value::Empty);
+    assert_eq!(text(&s, "A5"), "East");
+    assert_eq!(val(&s, "B5"), Value::Number(415.0));
+    assert_eq!(text(&s, "A8"), "Sum of Units");
+    assert_eq!(text(&s, "A9"), "East");
+    assert_eq!(val(&s, "B9"), Value::Number(33.0));
+    assert_eq!(text(&s, "A12"), "Total Sum of Sales");
+    assert_eq!(val(&s, "B13"), Value::Number(72.0));
+    // Adding a row field in front keeps Σ Values ahead of Region.
+    s.execute("pivot.addField", json!({"field": "Product", "area": "rows", "position": 0})).unwrap();
+    assert_eq!(pt(&s).values_position, Some(1));
+    s.execute("pivot.removeField", json!({"field": "Product", "area": "rows"})).unwrap();
+    assert_eq!(pt(&s).values_position, Some(0));
+    // No row field: one line per value field and no grand total.
+    s.execute("pivot.removeField", json!({"field": "Region", "area": "rows"})).unwrap();
+    let r = pt(&s).last_range.unwrap();
+    assert_eq!(r.height(), 1 + 2);
+    assert_eq!(text(&s, "A4"), "Sum of Sales");
+    assert_eq!(val(&s, "B4"), Value::Number(TOTAL));
+    assert_eq!(text(&s, "A5"), "Sum of Units");
+    assert_eq!(val(&s, "B5"), Value::Number(72.0));
+    // Back to Columns.
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "rows", "to": "columns"})).unwrap();
+    assert!(!pt(&s).values_on_rows);
+    assert_eq!(text(&s, "A3"), "Sum of Sales");
+    assert_eq!(text(&s, "B3"), "Sum of Units");
+    assert!(s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "filters"})).is_err());
+    assert!(s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "rows", "to": "columns"})).is_err());
+}
+
+#[test]
+fn collapsed_item_puts_values_in_the_values_column() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales", "Units"]})).unwrap();
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows"})).unwrap();
+    s.execute("pivot.collapse", json!({"field": "Region", "items": ["East"]})).unwrap();
+    for layout in ["tabular", "outline"] {
+        s.execute("pivot.layout", json!({"layout": layout})).unwrap();
+        assert_eq!(text(&s, "C3"), "Values", "{layout}");
+        let east = (4..20).find(|r| text(&s, &format!("A{r}")) == "East").unwrap();
+        let first = if layout == "tabular" { east } else { east + 1 };
+        assert_eq!(text(&s, &format!("B{first}")), "", "{layout}");
+        assert_eq!(text(&s, &format!("C{first}")), "Sum of Sales", "{layout}");
+        assert_eq!(val(&s, &format!("D{first}")), Value::Number(415.0), "{layout}");
+        assert_eq!(text(&s, &format!("C{}", first + 1)), "Sum of Units", "{layout}");
+    }
+}
+
+#[test]
+fn values_stay_last_in_columns() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Product"], "columns": ["Region"], "values": ["Sales", "Units"]})).unwrap();
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "columns", "position": 0})).unwrap();
+    let p = pt(&s);
+    assert!(!p.values_on_rows);
+    assert_eq!(p.values_position, None);
+    // Σ Values to Rows and back with a position: still last in Columns.
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows"})).unwrap();
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "rows", "to": "columns", "position": 0})).unwrap();
+    assert_eq!(pt(&s).values_position, None);
+    assert_eq!(text(&s, "B5"), "Sum of Sales");
+    assert_eq!(text(&s, "C5"), "Sum of Units");
+}
+
+#[test]
+fn change_source_keeps_values_ahead_of_its_field() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales", "Units"]})).unwrap();
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows", "position": 1})).unwrap();
+    // The new source has no Region: Σ Values stays ahead of Product.
+    s.execute("pivot.changeSource", json!({"source": "Sheet1!B1:E13"})).unwrap();
+    let p = pt(&s);
+    assert_eq!(p.rows.len(), 1);
+    assert_eq!(p.values_position, Some(0));
+    assert_eq!(text(&s, "A4"), "Sum of Sales");
+    assert_eq!(text(&s, "A5"), "Apples");
+}
+
+#[test]
+fn values_on_rows_between_row_fields() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region", "Product"], "values": ["Sales", "Units"]})).unwrap();
+    s.execute("pivot.moveField", json!({"field": "Σ Values", "from": "columns", "to": "rows", "position": 1})).unwrap();
+    // Compact: East, then per value field its products, then per-value subtotals of East.
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(text(&s, "A5"), "Sum of Sales");
+    assert_eq!(text(&s, "A6"), "Apples");
+    assert_eq!(val(&s, "B6"), Value::Number(160.0));
+    assert_eq!(text(&s, "A9"), "Sum of Units");
+    assert_eq!(text(&s, "A10"), "Apples");
+    assert_eq!(val(&s, "B10"), Value::Number(16.0));
+    assert_eq!(text(&s, "A13"), "East Sum of Sales");
+    assert_eq!(val(&s, "B13"), Value::Number(415.0));
+    assert_eq!(text(&s, "A14"), "East Sum of Units");
+    assert_eq!(val(&s, "B14"), Value::Number(33.0));
+    let d = s.doc().unwrap();
+    let sh = d.wb.active().unwrap();
+    assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("A5").unwrap())).align.indent, 1);
+    assert_eq!(d.wb.styles.get(sh.style_id(CellRef::parse("A6").unwrap())).align.indent, 2);
+    // Outline: one column per level, "Values" heads the Σ Values column.
+    s.execute("pivot.layout", json!({"layout": "outline"})).unwrap();
+    assert_eq!(pt(&s).last_range.unwrap().width(), 4);
+    assert_eq!(text(&s, "A3"), "Region");
+    assert_eq!(text(&s, "B3"), "Values");
+    assert_eq!(text(&s, "C3"), "Product");
+    assert_eq!(text(&s, "B5"), "Sum of Sales");
+    assert_eq!(text(&s, "C6"), "Apples");
+    assert_eq!(val(&s, "D6"), Value::Number(160.0));
+    // Tabular: labels start on their parent's row; totals per value field below each group.
+    s.execute("pivot.layout", json!({"layout": "tabular"})).unwrap();
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(text(&s, "B4"), "Sum of Sales");
+    assert_eq!(text(&s, "C4"), "Apples");
+    assert_eq!(val(&s, "D4"), Value::Number(160.0));
+    assert_eq!(text(&s, "B7"), "Sum of Units");
+    assert_eq!(text(&s, "C7"), "Apples");
+    assert_eq!(val(&s, "D7"), Value::Number(16.0));
+    assert_eq!(text(&s, "A10"), "East Sum of Sales");
+    assert_eq!(val(&s, "D10"), Value::Number(415.0));
+    assert_eq!(text(&s, "A11"), "East Sum of Units");
+    let r = pt(&s).last_range.unwrap();
+    let last = r.end.row + 1;
+    assert_eq!(text(&s, &format!("A{}", last - 1)), "Total Sum of Sales");
+    assert_eq!(text(&s, &format!("A{last}")), "Total Sum of Units");
+    assert_eq!(val(&s, &format!("D{last}")), Value::Number(72.0));
+}
+
+#[test]
+fn refresh_after_source_edits() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
+    s.execute("cell.set", json!({"cell": "E2", "input": "1100"})).unwrap();
+    // Refresh All picks the change up.
+    let r = s.execute("data.refreshAll", json!({})).unwrap();
+    assert_eq!(r["refreshed"], 1);
+    let d = s.doc().unwrap();
+    let si = d.wb.sheet_index("Sheet2").unwrap();
+    let sh = d.wb.sheet(si).unwrap();
+    assert_eq!(sh.value(CellRef::parse("B4").unwrap()), Value::Number(1415.0));
+    assert_eq!(sh.value(CellRef::parse("B7").unwrap()), Value::Number(TOTAL + 1000.0));
+    // pivot.refresh by name; change source to fewer rows.
+    s.execute("pivot.changeSource", json!({"pivot": "PivotTable1", "source": "Sheet1!A1:E3"})).unwrap();
+    let d = s.doc().unwrap();
+    let sh = d.wb.sheet(si).unwrap();
+    assert_eq!(sh.value(CellRef::parse("A6").unwrap()).display(), "Grand Total");
+    assert_eq!(sh.value(CellRef::parse("B6").unwrap()), Value::Number(1150.0));
+    // Old rows were cleared.
+    assert_eq!(sh.value(CellRef::parse("A7").unwrap()), Value::Empty);
+    s.execute("pivot.refresh", json!({"pivot": "PivotTable1"})).unwrap();
+}
+
+fn pivot_chart(s: &Session) -> gridcraft_model::Chart {
+    s.doc().unwrap().wb.active().unwrap().charts.last().unwrap().clone()
+}
+fn plotted(s: &Session) -> Vec<Vec<Option<f64>>> {
+    let d = s.doc().unwrap();
+    let data = gridcraft_chart::resolve(&d.wb, d.wb.active_sheet(), &pivot_chart(s));
+    data.series.into_iter().map(|x| x.values).collect()
+}
+
+#[test]
+fn pivot_chart_follows_the_report() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    // Any cell of the report picks the PivotTable.
+    let r = s.execute("insert.pivotChart", json!({"pivot": "B5"})).unwrap();
+    assert_eq!(r["series"], 1);
+    let ch = pivot_chart(&s);
+    assert_eq!(ch.pivot.as_deref(), Some("Sheet2!PivotTable1"));
+    assert_eq!(ch.title.as_deref(), Some("Total"));
+    assert_eq!(ch.series[0].values, "Sheet2!$B$4:$B$6");
+    assert_eq!(ch.series[0].categories.as_deref(), Some("Sheet2!$A$4:$A$6"));
+    assert_eq!(plotted(&s), vec![vec![Some(415.0), Some(135.0), Some(285.0)]]);
+    // A column field: one series per item, rebound by the layout change.
+    s.execute("pivot.addField", json!({"field": "Product", "area": "columns"})).unwrap();
+    let ch = pivot_chart(&s);
+    let names: Vec<_> = ch.series.iter().map(|x| x.name.clone().unwrap_or_default()).collect();
+    assert_eq!(names, vec!["\"Apples\"", "\"Pears\"", "\"Plums\""]);
+    assert_eq!(plotted(&s)[0], vec![Some(160.0), Some(90.0), Some(170.0)]);
+    // Nested row fields: the innermost items only, as a union around the parent rows.
+    s.execute("pivot.moveField", json!({"field": "Product", "from": "columns", "to": "rows"})).unwrap();
+    let ch = pivot_chart(&s);
+    assert!(ch.series[0].values.starts_with('('), "{}", ch.series[0].values);
+    let pts = plotted(&s);
+    assert_eq!(pts[0].len(), 9);
+    assert_eq!(pts[0].iter().flatten().sum::<f64>(), TOTAL);
+    // Survives an XLSX round trip as a PivotChart.
+    let wb = (*s.doc().unwrap().wb).clone();
+    let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&wb).unwrap()).unwrap();
+    let si = back.sheet_index("Sheet2").unwrap();
+    assert_eq!(back.sheet(si).unwrap().charts.first().and_then(|c| c.pivot.clone()).as_deref(), Some("Sheet2!PivotTable1"));
+    // Renaming the sheet keeps the link; a refresh still rebinds.
+    s.execute("sheet.rename", json!({"name": "Report"})).unwrap();
+    assert_eq!(pivot_chart(&s).pivot.as_deref(), Some("Report!PivotTable1"));
+    s.execute("pivot.moveField", json!({"field": "Region", "from": "rows", "to": "columns"})).unwrap();
+    assert_eq!(pivot_chart(&s).series.len(), 3);
+    // Deleting the PivotTable leaves an ordinary chart.
+    s.execute("pivot.delete", json!({})).unwrap();
+    assert_eq!(pivot_chart(&s).pivot, None);
+}
+
+#[test]
+fn pivot_chart_errors() {
+    let mut s = sales();
+    // No PivotTable yet.
+    assert!(s.execute("insert.pivotChart", json!({})).is_err());
+    s.execute("insert.pivotTable", json!({"rows": ["Region"]})).unwrap();
+    // Not in the report; no values.
+    assert!(s.execute("insert.pivotChart", json!({"pivot": "Z99"})).is_err());
+    assert!(s.execute("insert.pivotChart", json!({})).unwrap_err().to_string().contains("Values"));
+    s.execute("pivot.addField", json!({"field": "Units", "area": "values"})).unwrap();
+    let r = s.execute("insert.pivotChart", json!({"pivot": "PivotTable1", "type": "line", "title": null})).unwrap();
+    assert_eq!(r["series"], 1);
+    let ch = pivot_chart(&s);
+    assert_eq!(ch.kind, gridcraft_model::ChartKind::Line);
+    assert_eq!(ch.title, None);
+    // One undo step.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.doc().unwrap().wb.active().unwrap().charts.is_empty());
+}
+
+#[test]
+fn calculated_field_on_sums() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    let r = s.execute("pivot.calculatedField", json!({"name": "Price", "formula": "Sales / Units"})).unwrap();
+    assert_eq!(r["formula"], "=Sales / Units");
+    assert_eq!(text(&s, "C3"), "Sum of Price");
+    assert_eq!(text(&s, "A4"), "East");
+    // East: 415 sales over 33 units, from the sums.
+    let east = val(&s, "C4").as_f64().unwrap();
+    assert!((east - 415.0 / 33.0).abs() < 1e-12, "{east}");
+    // The grand total applies the formula to the totals, not the sum of the rows.
+    assert_eq!(text(&s, "A7"), "Grand Total");
+    let total = val(&s, "C7").as_f64().unwrap();
+    assert!((total - TOTAL / 72.0).abs() < 1e-12, "{total}");
+    // Quoted names, functions, and another calculated field.
+    s.execute("pivot.calculatedField", json!({"name": "Rounded", "formula": "=ROUND('Price'*2,1)"})).unwrap();
+    assert_eq!(val(&s, "D4"), Value::Number(25.2));
+    // Division by zero shows #DIV/0! cells.
+    s.execute("pivot.calculatedField", json!({"name": "Zero", "formula": "=Sales/(Units-Units)"})).unwrap();
+    assert_eq!(val(&s, "E4"), Value::Error(CellError::Div0));
+    // Change and delete.
+    s.execute("pivot.calculatedField", json!({"name": "zero", "formula": "=Units*2"})).unwrap();
+    assert_eq!(val(&s, "E4"), Value::Number(66.0));
+    s.execute("pivot.calculatedField", json!({"name": "Zero", "delete": true})).unwrap();
+    assert_eq!(pt(&s).values.len(), 3);
+    assert_eq!(pt(&s).calculated_fields.len(), 2);
+    // The field list shows calculated fields.
+    let f = s.execute("pivot.fields", json!({})).unwrap();
+    assert!(f["fields"].as_array().unwrap().iter().any(|x| x["name"] == "Price" && x["calculated"] == true));
+}
+
+#[test]
+fn calculated_field_errors() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    let mut e = |p: Json| s.execute("pivot.calculatedField", p).unwrap_err().to_string();
+    assert!(e(json!({"name": "Bad", "formula": "=Sales*Bogus"})).contains("Bogus"));
+    assert!(e(json!({"name": "Bad", "formula": "=A1*2"})).contains("cells"));
+    assert!(e(json!({"name": "Bad", "formula": "=Sales*("})).contains("error"));
+    assert!(e(json!({"name": "Sales", "formula": "=1"})).contains("already exists"));
+    assert!(e(json!({"name": "Bad"})).contains("formula"));
+    assert!(e(json!({"name": "Gone", "delete": true})).contains("Gone"));
+    // A cycle is refused.
+    s.execute("pivot.calculatedField", json!({"name": "X", "formula": "=Sales"})).unwrap();
+    s.execute("pivot.calculatedField", json!({"name": "Y", "formula": "=X*2"})).unwrap();
+    let err = s.execute("pivot.calculatedField", json!({"name": "X", "formula": "=Y"})).unwrap_err().to_string();
+    assert!(err.contains("itself"), "{err}");
+    // Calculated fields only go to Values; nothing changed after the failures.
+    assert!(s.execute("pivot.addField", json!({"field": "Y", "area": "rows"})).is_err());
+    assert_eq!(pt(&s).calculated_fields.len(), 2);
+    // Without a name the dialog opens (menu-style call).
+    s.ui_requests.clear();
+    s.execute("pivot.calculatedField", json!({})).unwrap();
+    assert!(matches!(s.ui_requests.last(), Some(crate::UiRequest::Dialog(n, _)) if n == "pivotCalculatedField"));
+}
+
+#[test]
+fn replace_protection() {
+    let mut s = sales();
+    s.execute("cell.set", json!({"cell": "H5", "input": "keep me"})).unwrap();
+    let e = s.execute("insert.pivotTable", json!({"destination": "Sheet1!H3", "rows": ["Region"], "values": ["Sales"]})).unwrap_err().to_string();
+    assert!(e.contains("There's already data in Sheet1!H5"), "{e}");
+    assert_eq!(s.doc().unwrap().wb.active().unwrap().pivots.len(), 0);
+    // Growing into data is refused as well.
+    s.execute("insert.pivotTable", json!({"destination": "Sheet1!H3"})).unwrap();
+    assert!(s.execute("pivot.addField", json!({"field": "Region", "area": "rows"})).is_err());
+    s.execute("pivot.addField", json!({"field": "Region", "area": "rows", "replace": true})).unwrap();
+    assert_eq!(text(&s, "H5"), "North");
+    // A second pivot can't overlap the first.
+    let e =
+        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H6", "replace": true})).unwrap_err().to_string();
+    assert!(e.contains("overlap"), "{e}");
+    // Nor its own source data.
+    let e =
+        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!B2", "replace": true})).unwrap_err().to_string();
+    assert!(e.contains("source data"), "{e}");
+    // Delete clears the report.
+    s.execute("pivot.delete", json!({})).unwrap();
+    assert_eq!(val(&s, "H5"), Value::Empty);
+    assert!(s.doc().unwrap().wb.active().unwrap().pivots.is_empty());
+}
+
+#[test]
+fn fields_move_remove_sort() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    let f = s.execute("pivot.fields", json!({})).unwrap();
+    assert_eq!(f["fields"][0]["name"], "Region");
+    assert_eq!(f["fields"][0]["samples"], json!(["East", "North", "West"]));
+    assert_eq!(f["fields"][0]["areas"], json!(["rows"]));
+    assert_eq!(f["fields"][4]["numeric"], true);
+    assert_eq!(f["fields"][2]["date"], true);
+    s.execute("pivot.sort", json!({"field": "Region", "order": "desc"})).unwrap();
+    assert_eq!(text(&s, "A4"), "West");
+    s.execute("pivot.moveField", json!({"field": "Region", "from": "rows", "to": "columns"})).unwrap();
+    assert_eq!(text(&s, "B4"), "West");
+    s.execute("pivot.removeField", json!({"field": "Sum of Sales", "area": "values"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Region", "area": "values"})).unwrap();
+    assert_eq!(pt(&s).values[0].name, "Count of Region");
+    s.execute("pivot.removeField", json!({"field": "Region"})).unwrap();
+    assert!(pt(&s).columns.is_empty() && pt(&s).values.is_empty());
+    assert!(text(&s, "A3").contains("choose fields"));
+    assert!(s.execute("pivot.addField", json!({"field": "Nope", "area": "rows"})).is_err());
+    assert!(s.execute("pivot.addField", json!({"field": "Region", "area": "sideways"})).is_err());
+}
+
+#[test]
+fn recommended_and_summarize() {
+    let mut s = sales();
+    let r = s.execute("insert.recommendedPivotTables", json!({})).unwrap();
+    let list = r["suggestions"].as_array().unwrap();
+    assert!((3..=5).contains(&list.len()), "{list:?}");
+    assert_eq!(list[0]["title"], "Sum of Units by Region");
+    let r = s.execute("insert.recommendedPivotTables", json!({"apply": 2})).unwrap();
+    assert!(r["suggestion"]["title"].as_str().unwrap().contains("quarters"));
+    assert_eq!(text(&s, "A4"), "Qtr1");
+    // From a table.
+    s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
+    s.execute("insert.table", json!({"range": "A1:E13"})).unwrap();
+    s.execute("selection.set", json!({"range": "B2"})).unwrap();
+    let r = s.execute("table.summarizePivot", json!({"rows": ["Product"], "values": ["Units"]})).unwrap();
+    assert_eq!(pt(&s).source, "Table1");
+    assert_eq!(r["name"], "PivotTable2");
+    let gt = find_row(&s, "Grand Total").unwrap();
+    assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(72.0));
+}
+
+#[test]
+fn repeated_headers_get_numbered_names() {
+    let mut s = Session::new();
+    s.new_workbook();
+    let mut header = vec![json!("a"), json!("A"), json!("a"), json!("a2")];
+    // Thousands of equal headers (a row of check boxes, say) used to take cubic time; this would
+    // hang rather than fail a wall-clock check, which is flaky on a loaded machine.
+    header.extend((0..3000).map(|_| json!("x")));
+    let data: Vec<_> = (0..header.len()).map(|i| json!(i)).collect();
+    let end = CellRef::new(1, header.len() as u32 - 1).a1();
+    s.execute("range.setValues", json!({"range": "A1", "values": [header, data]})).unwrap();
+    let src = crate::pivot::read_source(&s.doc().unwrap().wb, &format!("Sheet1!A1:{end}"), 0).unwrap();
+    assert_eq!(&src.headers[..4], ["a", "A2", "a3", "a22"]);
+    assert_eq!(src.headers[4], "x");
+    assert_eq!(src.headers.last().map(String::as_str), Some("x3000"));
+    // Table column names follow the same rule.
+    s.execute("insert.table", json!({"range": format!("A1:{end}"), "header": true})).unwrap();
+    let text = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["text"].clone();
+    assert_eq!(text(&mut s, "B1"), "A2");
+    let last = CellRef::new(0, 3003).a1();
+    assert_eq!(text(&mut s, &last), "x3000");
+}
+
+#[test]
+fn hostile_params_never_panic() {
+    let mut s = sales();
+    let cmds = [
+        "insert.pivotTable",
+        "insert.recommendedPivotTables",
+        "table.summarizePivot",
+        "pivot.fields",
+        "pivot.fieldList",
+        "pivot.list",
+        "pivot.addField",
+        "pivot.removeField",
+        "pivot.moveField",
+        "pivot.valueSettings",
+        "pivot.filter",
+        "pivot.sort",
+        "pivot.group",
+        "pivot.collapse",
+        "pivot.layout",
+        "pivot.grandTotals",
+        "pivot.subtotals",
+        "pivot.reportLayout",
+        "pivot.style",
+        "pivot.refresh",
+        "data.refreshAll",
+        "pivot.changeSource",
+        "pivot.delete",
+        "pivot.showDetails",
+        "pivot.options",
+    ];
+    let hostile = [
+        json!({}),
+        json!([1, 2]),
+        json!({"pivot": 99999, "field": 5, "area": null}),
+        json!({"source": "ZZZ999999999", "destination": "Nope!A1"}),
+        json!({"source": "A:XFD", "destination": "Sheet1!XFD1048576"}),
+        json!({"source": "''!A1", "destination": "!"}),
+        json!({"field": "Sales", "area": "values", "func": "bogus", "position": 4294967295u64}),
+        json!({"field": "Region", "selected": [null, 1, {"x": 1}], "index": 18446744073709551615u64, "showAs": "rank"}),
+        json!({"apply": 99, "layout": "weird", "subtotals": 7, "style": "x".repeat(500)}),
+        json!({"field": "Date", "by": "decades", "items": "nope", "order": "sideways"}),
+    ];
+    for c in cmds {
+        for h in &hostile {
+            let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                let spec = crate::find_command(c).unwrap();
+                let _ = (spec.run)(&mut s, h);
+            }));
+            assert!(r.is_ok(), "{c} panicked on {h}");
+        }
+    }
+    // And on a real pivot.
+    s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "rows": ["Region"], "values": ["Sales"]})).unwrap();
+    for c in cmds {
+        for h in &hostile {
+            let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                let spec = crate::find_command(c).unwrap();
+                let _ = (spec.run)(&mut s, h);
+            }));
+            assert!(r.is_ok(), "{c} panicked on {h}");
+        }
+    }
+}
+
+#[test]
+fn empty_header_is_refused() {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Region", ""], ["East", 1]]})).unwrap();
+    let e = s.execute("insert.pivotTable", json!({"source": "A1:B2"})).unwrap_err().to_string();
+    assert!(e.contains("field name is not valid"), "{e}");
+    assert!(s.execute("insert.pivotTable", json!({"source": "NoSuchTable"})).is_err());
+}
+
+#[test]
+fn too_many_value_columns_are_refused() {
+    let mut s = Session::new();
+    s.new_workbook();
+    let mut records: Vec<Json> = vec![json!(["Cat", "Sub", "V"])];
+    for r in 0..64 {
+        for c in 0..64 {
+            records.push(json!([format!("c{r}"), format!("s{c}"), 1.0]));
+        }
+    }
+    s.execute("range.setValues", json!({"range": "A1", "values": records})).unwrap();
+    let req = |n: usize| {
+        let values: Vec<Json> = (0..n).map(|_| json!({"field": "V"})).collect();
+        json!({"source": "A1:C4097", "rows": ["Cat"], "columns": ["Sub"], "values": values})
+    };
+    let e = s.execute("insert.pivotTable", req(256)).unwrap_err().to_string();
+    assert!(e.contains("will not fit"), "{e}");
+    assert!(s.execute("insert.pivotTable", req(128)).is_ok());
+}
+
+#[test]
+fn collapsed_column_items_count_as_one_column_group() {
+    let mut s = Session::new();
+    s.new_workbook();
+    let mut records: Vec<Json> = vec![json!(["Grp", "Sub", "V"])];
+    records.extend((0..64).map(|c| json!(["g", format!("s{c}"), 1.0])));
+    s.execute("range.setValues", json!({"range": "A1", "values": records})).unwrap();
+    let values: Vec<Json> = (0..256).map(|_| json!({"field": "V"})).collect();
+    s.execute("insert.pivotTable", json!({"source": "A1:C65", "columns": ["Grp"], "values": values})).unwrap();
+    s.execute("pivot.collapse", json!({"field": "Grp"})).unwrap();
+    // 64 Sub items under the collapsed "g" show as one column group: (1 + grand total) x 256 columns fit.
+    s.execute("pivot.addField", json!({"field": "Sub", "area": "columns"})).unwrap();
+}
+
+#[test]
+fn inserting_or_deleting_lines_moves_the_pivot_with_its_cells() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H10", "rows": ["Region"], "values": ["Sales"]}))
+        .unwrap();
+    assert_eq!(pt(&s).last_range.unwrap().a1(), "H10:I14");
+    // Rows above the report (and below the source) move the report only.
+    s.execute("home.insertRows", json!({"rows": "16:17"})).unwrap();
+    s.execute("home.insertRows", json!({"rows": "6:7"})).unwrap();
+    assert_eq!(text(&s, "H12"), "Row Labels");
+    let l = s.execute("pivot.list", json!({})).unwrap();
+    assert_eq!(l[0]["anchor"], "H12");
+    assert_eq!(l[0]["range"], "H12:I16");
+    assert_eq!(l[0]["source"], "Sheet1!A1:E15");
+    // A row above the source moves both.
+    s.execute("home.insertRows", json!({"rows": "1:1"})).unwrap();
+    let p = pt(&s);
+    assert_eq!(p.source, "Sheet1!A2:E16");
+    assert_eq!(p.anchor.a1(), "H13");
+    s.execute("pivot.refresh", json!({})).unwrap();
+    assert_eq!(pt(&s).last_range.unwrap().a1(), "H13:I17");
+    assert_eq!(text(&s, "H13"), "Row Labels");
+    assert_eq!(val(&s, "I17"), Value::Number(TOTAL));
+    // Deleting a column left of the report moves it left.
+    s.execute("home.deleteColumns", json!({"cols": "F:F"})).unwrap();
+    let p = pt(&s);
+    assert_eq!(p.anchor.a1(), "G13");
+    assert_eq!(p.last_range.unwrap().a1(), "G13:H17");
+    // Deleting rows above moves it up.
+    s.execute("home.deleteRows", json!({"rows": "1:1"})).unwrap();
+    assert_eq!(pt(&s).source, "Sheet1!A1:E15");
+    assert_eq!(pt(&s).anchor.a1(), "G12");
+    s.execute("pivot.refresh", json!({})).unwrap();
+    assert_eq!(text(&s, "G12"), "Row Labels");
+    assert_eq!(val(&s, "H16"), Value::Number(TOTAL));
+}
+
+#[test]
+fn inserting_rows_on_the_source_sheet_moves_another_sheets_pivot_source() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "rows": ["Region"], "values": ["Sales"]})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
+    s.execute("home.insertRows", json!({"rows": "1:2"})).unwrap();
+    let l = s.execute("pivot.list", json!({})).unwrap();
+    assert_eq!(l[0]["source"], "Sheet1!A3:E15");
+    assert_eq!(l[0]["anchor"], "A3");
+    s.execute("pivot.refresh", json!({"pivot": "PivotTable1"})).unwrap();
+}
+
+/// The active sheet's first five columns as shown, down to the first blank row.
+fn sheet_rows(s: &mut Session) -> Vec<Vec<String>> {
+    let mut out = Vec::new();
+    for r in 0..30u32 {
+        let row: Vec<String> = (0..5)
+            .map(|c| s.execute("cell.get", json!({"cell": CellRef::new(r, c).a1()})).unwrap()["text"].as_str().unwrap_or("").to_string())
+            .collect();
+        if row.iter().all(String::is_empty) {
+            break;
+        }
+        out.push(row);
+    }
+    out
+}
+
+#[test]
+fn show_details_lists_a_value_cells_records_on_a_new_sheet() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    // B5 is East × Apples (100 + 60); the active cell is the default.
+    s.execute("selection.set", json!({"range": "B5"})).unwrap();
+    let r = s.execute("pivot.showDetails", json!({})).unwrap();
+    assert_eq!(r["records"], 2);
+    let d = s.doc().unwrap();
+    assert_eq!(d.wb.sheets.len(), 3);
+    assert_eq!(d.wb.active_sheet(), 0, "the new sheet goes before the PivotTable's");
+    assert_eq!(d.wb.active().unwrap().name, "Sheet3");
+    assert_eq!(
+        sheet_rows(&mut s),
+        vec![
+            vec!["Region", "Product", "Date", "Units", "Sales"],
+            vec!["East", "Apples", "1/15/2026", "10", "100"],
+            vec!["East", "Apples", "9/9/2026", "6", "60"],
+        ]
+    );
+    // The dates fit their column instead of showing ####.
+    let sh = s.doc().unwrap().wb.active().unwrap().clone();
+    assert!(sh.col_width(2) > sh.col_width(5), "{} vs {}", sh.col_width(2), sh.col_width(5));
+    // One undo step takes the sheet away.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+    assert_eq!(val(&s, "B5"), Value::Number(160.0));
+}
+
+#[test]
+fn show_details_on_a_total_takes_every_record_it_adds_up() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    let records = |s: &mut Session, cell: &str| {
+        let n = s.execute("pivot.showDetails", json!({"cell": cell})).unwrap()["records"].as_u64().unwrap();
+        s.execute("edit.undo", json!({})).unwrap();
+        n
+    };
+    assert_eq!(records(&mut s, "E5"), 5, "East's row total");
+    assert_eq!(records(&mut s, "C8"), 4, "Pears' column total");
+    assert_eq!(records(&mut s, "E8"), 12, "the grand total");
+    // A subtotal at the top of its group, in a two-level row axis.
+    s.execute("pivot.moveField", json!({"field": "Product", "from": "columns", "to": "rows"})).unwrap();
+    assert_eq!(text(&s, "A4"), "East");
+    assert_eq!(records(&mut s, "B4"), 5);
+    assert_eq!(text(&s, "A6"), "Pears");
+    assert_eq!(records(&mut s, "B6"), 2);
+}
+
+#[test]
+fn show_details_leaves_out_the_records_the_report_filters_out() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
+    s.execute("pivot.filter", json!({"field": "Region", "selected": ["East"]})).unwrap();
+    s.execute("pivot.filter", json!({"field": "Product", "selected": ["Apples"]})).unwrap();
+    let gt = find_row(&s, "Grand Total").unwrap();
+    let r = s.execute("pivot.showDetails", json!({"cell": CellRef::new(gt, 1).a1()})).unwrap();
+    assert_eq!(r["records"], 2);
+    let rows = sheet_rows(&mut s);
+    assert_eq!(rows.len(), 3);
+    assert!(rows.iter().skip(1).all(|row| row[0] == "East" && row[1] == "Apples"), "{rows:?}");
+}
+
+#[test]
+fn show_details_refuses_a_report_its_source_has_moved_on_from() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    // B5 still shows East × Apples (160), but the first East record is now Central's.
+    s.execute("range.setValues", json!({"range": "Sheet1!A2", "values": [["Central"]]})).unwrap();
+    assert_eq!(val(&s, "B5"), Value::Number(160.0));
+    let e = s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap_err().to_string();
+    assert!(e.contains("out of date"), "{e}");
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+    // After a refresh East × Apples (now B6) has the one record left.
+    s.execute("pivot.refresh", json!({})).unwrap();
+    assert_eq!(text(&s, "A6"), "East");
+    assert_eq!(s.execute("pivot.showDetails", json!({"cell": "B6"})).unwrap()["records"], 1);
+}
+
+#[test]
+fn show_details_refuses_a_report_that_would_now_be_shorter() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    // North goes away: the source now gives one row fewer, so row 8 is no longer the Grand Total.
+    s.execute("range.setValues", json!({"range": "Sheet1!A5", "values": [["East"]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "Sheet1!A8", "values": [["East"]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "Sheet1!A11", "values": [["East"]]})).unwrap();
+    assert_eq!(text(&s, "A8"), "Grand Total");
+    let e = s.execute("pivot.showDetails", json!({"cell": "E8"})).unwrap_err().to_string();
+    assert!(e.contains("out of date"), "{e}");
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+}
+
+#[test]
+fn show_details_needs_a_value_cell() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    for cell in ["A3", "B3", "A4", "B4", "A5", "A8", "H20"] {
+        assert!(s.execute("pivot.showDetails", json!({"cell": cell})).is_err(), "{cell}");
+    }
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+}
+
+#[test]
+fn enable_show_details_off_stops_show_details() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    assert_eq!(s.execute("pivot.options", json!({})).unwrap()["enableShowDetails"], true);
+    s.execute("pivot.options", json!({"enableShowDetails": false})).unwrap();
+    assert!(!pt(&s).enable_show_details);
+    assert_eq!(s.execute("pivot.fields", json!({})).unwrap()["enableShowDetails"], false);
+    let e = s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap_err().to_string();
+    assert_eq!(e, "Show Details is turned off for this PivotTable.");
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+    // A label still reports that it is not a value cell.
+    let e = s.execute("pivot.showDetails", json!({"cell": "A5"})).unwrap_err().to_string();
+    assert!(!e.contains("turned off"), "{e}");
+    // Setting the same value again adds no undo step.
+    let after = s.doc().unwrap().revision;
+    s.execute("pivot.options", json!({"enableShowDetails": false})).unwrap();
+    assert_eq!(s.doc().unwrap().revision, after);
+    assert!(s.execute("pivot.options", json!({"enableShowDetails": "no"})).is_err());
+    // One undo turns the option back on.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(pt(&s).enable_show_details);
+    assert_eq!(s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap()["records"], 2);
+}
+
+#[test]
+fn enable_show_details_off_is_reported_before_an_out_of_date_report() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    s.execute("pivot.options", json!({"enableShowDetails": false})).unwrap();
+    // The source changes after the report was written, so the report is out of date.
+    s.execute("range.setValues", json!({"range": "Sheet1!A2", "values": [["Central"]]})).unwrap();
+    let e = s.execute("pivot.showDetails", json!({"cell": "B5"})).unwrap_err().to_string();
+    assert!(e.contains("turned off") && !e.contains("out of date"), "{e}");
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+}
+
+#[test]
+fn detail_cells_are_the_cells_show_details_takes() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Product"], "values": ["Sales"]})).unwrap();
+    for layout in 0..2 {
+        if layout == 1 {
+            // A two-level row axis, with subtotals at the top of each group.
+            s.execute("pivot.moveField", json!({"field": "Product", "from": "columns", "to": "rows"})).unwrap();
+        }
+        let d = s.doc().unwrap();
+        let si = d.wb.active_sheet();
+        let pt = &d.wb.active().unwrap().pivots[0];
+        let r = pt.last_range.unwrap();
+        let cells = crate::pivot::detail_cells(&d.wb, pt, si).unwrap();
+        let mut values = 0;
+        for row in 0..r.height() {
+            for col in 0..r.width() {
+                let one = crate::pivot::detail_records(&d.wb, pt, si, row, col).unwrap();
+                assert_eq!(cells.contains(&(row, col)), one.is_some(), "layout {layout}, cell ({row}, {col})");
+                values += usize::from(one.is_some());
+            }
+        }
+        assert!(values > 4, "layout {layout} has value cells");
+    }
+    // An out-of-date report answers as Show Details does.
+    s.execute("range.setValues", json!({"range": "Sheet1!A2", "values": [["Central"]]})).unwrap();
+    let d = s.doc().unwrap();
+    let pt = &d.wb.active().unwrap().pivots[0];
+    assert!(crate::pivot::detail_cells(&d.wb, pt, d.wb.active_sheet()).unwrap_err().contains("out of date"));
+}

From 1f5c4747df25c4ef70f65e8fec7705bbc46ee37c Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:41 +0000
Subject: [PATCH 29/76] refactor(engine): move cmd/print tests to
 src/cmd/print/tests.rs

---
 crates/engine/src/cmd/print.rs       | 573 +--------------------------
 crates/engine/src/cmd/print/tests.rs | 570 ++++++++++++++++++++++++++
 2 files changed, 571 insertions(+), 572 deletions(-)
 create mode 100644 crates/engine/src/cmd/print/tests.rs

diff --git a/crates/engine/src/cmd/print.rs b/crates/engine/src/cmd/print.rs
index f6bfc6f17..d55841f7b 100644
--- a/crates/engine/src/cmd/print.rs
+++ b/crates/engine/src/cmd/print.rs
@@ -1864,575 +1864,4 @@ fn page_setup(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 #[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    use super::*;
-
-    fn s() -> Session {
-        let mut s = Session::new();
-        s.new_workbook();
-        s
-    }
-    fn pdf_of(s: &mut Session, p: Json) -> (Vec<u8>, u64) {
-        let r = s.execute("file.exportPdf", p).unwrap();
-        let bytes = crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap();
-        (bytes, r["pages"].as_u64().unwrap())
-    }
-    fn contains(hay: &[u8], needle: &str) -> bool {
-        hay.windows(needle.len()).any(|w| w == needle.as_bytes())
-    }
-
-    #[test]
-    fn pdf_export_keeps_safe_links_on_their_printed_pages() {
-        let mut s = s();
-        s.execute("insert.link", json!({"cell": "A1", "target": "https://example.org/report"})).unwrap();
-        s.execute("insert.link", json!({"cell": "A2", "target": "Sheet1!A60"})).unwrap();
-        s.execute("insert.link", json!({"cell": "A3", "target": "file:///private/report"})).unwrap();
-        s.execute("cell.set", json!({"cell": "A60", "input": "Destination"})).unwrap();
-        let (pdf, pages) = pdf_of(&mut s, json!({}));
-        assert_eq!(pages, 2);
-        let text = String::from_utf8_lossy(&pdf);
-        assert_eq!(text.matches("/Subtype /Link").count(), 2);
-        assert!(text.contains("/URI (https://example.org/report)"));
-        assert!(text.contains("/Dest [") && text.contains("/XYZ "));
-        assert!(!text.contains("/URI (file:"));
-
-        // A link to a cell omitted by the selected print range must not point to a nonexistent
-        // destination. The external link in the selected range remains clickable.
-        let (cropped, _) = pdf_of(&mut s, json!({"range": "A1:A3"}));
-        let cropped = String::from_utf8_lossy(&cropped);
-        assert_eq!(cropped.matches("/Subtype /Link").count(), 1);
-        assert!(!cropped.contains("/Dest ["));
-    }
-
-    #[test]
-    fn header_sections_split_join_and_field_names() {
-        let spec = "&L&\"Arial,Bold\"Sales &&Co&CPage &P of &N&R&D";
-        let parts = split_header_footer(spec);
-        assert_eq!(parts, ["&\"Arial,Bold\"Sales &&Co".to_string(), "Page &P of &N".into(), "&D".into()]);
-        assert_eq!(join_header_footer(&parts), spec);
-        // Text before any section code is the centre section, as when printing.
-        assert_eq!(split_header_footer("Report"), [String::new(), "Report".into(), String::new()]);
-        assert_eq!(codes_to_fields("Page &P of &N, &A (&F) &&"), "Page &[Page] of &[Pages], &[Tab] (&[File]) &&");
-        assert_eq!(fields_to_codes("Page &[Page] of &[Pages], &[Tab] (&[File]) &&"), "Page &P of &N, &A (&F) &&");
-        // A dangling ampersand stays literal instead of eating the next section's code.
-        assert_eq!(fields_to_codes("R&"), "R&&");
-        let joined = join_header_footer(&[fields_to_codes("R&"), "x".into(), String::new()]);
-        assert_eq!(split_header_footer(&joined)[0], "R&&");
-        let cx = HfContext { page: 2, pages: 5, sheet: "Data".into(), ..Default::default() };
-        let out = expand_header_footer(&join_header_footer(&[String::new(), fields_to_codes("&[Page] / &[Pages]"), fields_to_codes("&[Tab]")]), &cx);
-        assert_eq!((out[1].text.as_str(), out[2].text.as_str()), ("2 / 5", "Data"));
-        // Hostile input never panics.
-        for t in ["&", "&\"", "&\"unterminated", "&&&", "&[Pag", "\u{1F600}&[Page]"] {
-            let _ = join_header_footer(&split_header_footer(t));
-            let _ = fields_to_codes(&codes_to_fields(t));
-        }
-    }
-
-    #[test]
-    fn header_footer_date_follows_the_workbook_date_system() {
-        let mut wb = Workbook::new();
-        let date_1900 = hf_date_time(&wb).0;
-        wb.date_system = gridcraft_core::DateSystem::D1904;
-        assert_eq!(hf_date_time(&wb).0, date_1900);
-    }
-
-    #[test]
-    fn header_footer_section_edits_are_undoable_and_views_are_per_sheet() {
-        let mut s = s();
-        s.execute("pageLayout.headerFooter", json!({"header": "&LLeft&RRight"})).unwrap();
-        let r = s.execute("pageLayout.headerFooter", json!({"part": "header", "section": "center", "text": "Page &[Page] of &[Pages]"})).unwrap();
-        assert_eq!(r["header"], "&LLeft&CPage &P of &N&RRight");
-        s.execute("pageLayout.headerFooter", json!({"part": "footer", "section": "right", "text": "&[Date]"})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().print.footer, "&R&D");
-        s.execute("edit.undo", json!({})).unwrap();
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().print.header, "&LLeft&RRight");
-        assert!(s.execute("pageLayout.headerFooter", json!({"part": "middle", "text": "x"})).is_err());
-        assert!(s.execute("pageLayout.headerFooter", json!({"section": "top"})).is_err());
-        let long = "x".repeat(1000);
-        s.execute("pageLayout.headerFooter", json!({"part": "header", "section": "left", "text": long})).unwrap();
-        assert!(s.doc().unwrap().wb.sheet(0).unwrap().print.header.chars().count() <= 255);
-        // The view is per sheet and doesn't dirty a clean workbook.
-        let mut fresh = Session::new();
-        fresh.new_workbook();
-        fresh.execute("home.insertSheet", json!({})).unwrap();
-        fresh.doc_mut().unwrap().saved = fresh.doc().unwrap().wb.clone();
-        fresh.execute("view.pageLayout", json!({"sheet": 0})).unwrap();
-        let wb = &fresh.doc().unwrap().wb;
-        assert_eq!((wb.sheet(0).unwrap().view, wb.sheet(1).unwrap().view), (SheetViewMode::PageLayout, SheetViewMode::Normal));
-        assert!(!fresh.doc().unwrap().is_dirty(), "switching views is not an edit");
-        s.execute("view.pageLayout", json!({"sheet": 0})).unwrap();
-        s.execute("view.normal", json!({"sheet": 0})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().view, SheetViewMode::Normal);
-        assert_eq!(s.execute("view.ruler", json!({"on": false})).unwrap()["on"], false);
-        assert!(s.hide_ruler);
-        assert_eq!(s.execute("view.ruler", json!({})).unwrap()["on"], true);
-    }
-
-    #[test]
-    fn page_count_300_rows_letter_portrait() {
-        let mut s = s();
-        let rows: Vec<Vec<Json>> = (1..=300).map(|i| vec![json!(i)]).collect();
-        s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-        // 684pt of printable height / 15pt rows = 45 rows per page → 7 pages.
-        let (pdf, pages) = pdf_of(&mut s, json!({}));
-        assert_eq!(pages, 7);
-        assert!(pdf.starts_with(b"%PDF-1.7"));
-        assert!(contains(&pdf, "/Count 7"));
-        let pv = s.execute("file.printPreview", json!({})).unwrap();
-        assert_eq!(pv["pages"], 7);
-        assert_eq!(pv["pageList"][0]["rows"], "1:45");
-        assert_eq!(pv["pageList"][1]["rows"], "46:90");
-        assert_eq!(s.execute("file.printPreview", json!({"page": 7})).unwrap()["page"]["rows"], "271:300");
-        assert!(s.execute("file.printPreview", json!({"page": 8})).is_err());
-        // Landscape: 504pt / 15 = 33 rows per page → 10 pages.
-        s.execute("pageLayout.pageSetup", json!({"orientation": "landscape"})).unwrap();
-        assert_eq!(pdf_of(&mut s, json!({})).1, 10);
-        // Fit to one page.
-        assert_eq!(pdf_of(&mut s, json!({"fitToPage": true})).1, 1);
-        s.execute("pageLayout.pageSetup", json!({"fitWidth": 1, "fitHeight": 2, "orientation": "portrait"})).unwrap();
-        assert_eq!(pdf_of(&mut s, json!({})).1, 2);
-        // Manual break and repeated title rows.
-        s.execute("pageLayout.pageSetup", json!({"scale": 100, "rowBreaks": [11], "titleRows": "1:1"})).unwrap();
-        let pv = s.execute("file.printPreview", json!({})).unwrap();
-        assert_eq!(pv["pageList"][0]["rows"], "1:10");
-        // Title row takes one line on later pages: 44 body rows.
-        assert_eq!(pv["pageList"][1]["rows"], "11:54");
-    }
-
-    #[test]
-    fn wide_sheet_goes_down_then_over() {
-        let mut s = s();
-        let rows: Vec<Vec<Json>> = (0..60).map(|r| (0..15).map(|c| json!(r * 100 + c)).collect()).collect();
-        s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-        let pv = s.execute("file.printPreview", json!({})).unwrap();
-        // 511.2pt / 48pt = 10 columns per page; 45 rows per page.
-        assert_eq!(pv["pages"], 4);
-        assert_eq!(pv["pageList"][0]["range"], "A1:J45");
-        assert_eq!(pv["pageList"][1]["range"], "A46:J60");
-        assert_eq!(pv["pageList"][2]["range"], "K1:O45");
-    }
-
-    #[test]
-    fn first_and_even_pages_print_their_own_headers() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["a"], ["b"], ["c"], ["d"], ["e"], ["f"]]})).unwrap();
-        s.execute("pageLayout.pageSetup", json!({"rowBreaks": [2, 4]})).unwrap();
-        let r = s
-            .execute(
-                "pageLayout.headerFooter",
-                json!({"header": "&COdd &P", "evenHeader": "&CEven &P", "firstHeader": "&CCover", "differentFirst": true, "differentOddEven": true}),
-            )
-            .unwrap();
-        assert_eq!(r["firstHeader"], "&CCover");
-        let (pdf, pages) = pdf_of(&mut s, json!({}));
-        assert_eq!(pages, 3);
-        assert!(contains(&pdf, "(Cover) Tj") && contains(&pdf, "(Even 2) Tj") && contains(&pdf, "(Odd 3) Tj"));
-        assert!(!contains(&pdf, "(Odd 1) Tj"), "the first page has its own header");
-        // One section of the even-page footer, edited in place.
-        s.execute("pageLayout.headerFooter", json!({"page": "even", "part": "footer", "section": "right", "text": "&[Tab]"})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().print.even_footer, "&R&A");
-        assert!(s.execute("pageLayout.headerFooter", json!({"page": "last", "part": "header", "text": "x"})).is_err());
-        // Turned off, every page prints the odd header again.
-        s.execute("pageLayout.headerFooter", json!({"differentFirst": false, "differentOddEven": false})).unwrap();
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        assert!(contains(&pdf, "(Odd 1) Tj") && contains(&pdf, "(Odd 2) Tj") && !contains(&pdf, "(Cover) Tj"));
-    }
-
-    /// The x position and font size of the first `(text) Tj` in a PDF.
-    fn text_at(pdf: &[u8], text: &str) -> Option<(f32, f32)> {
-        let s = String::from_utf8_lossy(pdf);
-        let before = &s[..s.find(&format!("({text}) Tj"))?];
-        let tf = before.rfind(" Tf")?;
-        let size = before[..tf].rsplit(' ').next()?.parse().ok()?;
-        let tm = before.rfind(" Tm")?;
-        let mut nums = before[..tm].rsplit([' ', '\n']);
-        let _y = nums.next()?;
-        let x = nums.next()?.parse().ok()?;
-        Some((x, size))
-    }
-
-    #[test]
-    fn headers_scale_with_the_sheet_and_align_with_its_margins_unless_turned_off() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap();
-        s.execute("pageLayout.pageSetup", json!({"scale": 50, "left": 1.5, "right": 1.5})).unwrap();
-        s.execute("pageLayout.headerFooter", json!({"header": "&LLeft&C&14Middle"})).unwrap();
-        // Both on (the default): the text prints at half size, from the 1.5-inch left margin.
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        assert_eq!(text_at(&pdf, "Left"), Some((108.0, 5.0)));
-        assert_eq!(text_at(&pdf, "Middle").map(|t| t.1), Some(7.0));
-        let r = s.execute("pageLayout.headerFooter", json!({"scaleWithDoc": false, "alignWithMargins": false})).unwrap();
-        assert_eq!((&r["scaleWithDoc"], &r["alignWithMargins"]), (&json!(false), &json!(false)));
-        // Both off: full size, 0.7 inch from the paper's left edge.
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        assert_eq!(text_at(&pdf, "Left"), Some((50.4, 10.0)));
-        assert_eq!(text_at(&pdf, "Middle").map(|t| t.1), Some(14.0));
-        s.execute("edit.undo", json!({})).unwrap();
-        let pr = &s.doc().unwrap().wb.sheet(0).unwrap().print;
-        assert!(pr.hf_scale_with_doc && pr.hf_align_with_margins);
-    }
-
-    #[test]
-    fn pdf_prints_cjk_text_instead_of_question_marks() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["签字清单", 2]]})).unwrap();
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        assert!(!contains(&pdf, "(????) Tj"), "CJK cell printed as (????) Tj");
-        assert!(contains(&pdf, "<7B7E5B576E055355> Tj"));
-        assert!(contains(&pdf, "(2) Tj"));
-    }
-
-    #[test]
-    fn pdf_contains_text_and_header_codes_expand() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Quarterly Report", null], ["Total", 1234.5]]})).unwrap();
-        s.execute("home.bold", json!({"range": "A1"})).unwrap();
-        s.execute(
-            "pageLayout.pageSetup",
-            json!({"header": "&LLeft &A&CMiddle&RPage &P of &N", "footer": "&C&F", "gridlines": true, "headings": true}),
-        )
-        .unwrap();
-        let (pdf, pages) = pdf_of(&mut s, json!({}));
-        assert_eq!(pages, 1);
-        assert!(contains(&pdf, "(Quarterly Report) Tj"));
-        assert!(contains(&pdf, "(1234.5) Tj"));
-        assert!(contains(&pdf, "(Left Sheet1) Tj"));
-        assert!(contains(&pdf, "(Page 1 of 1) Tj"));
-        assert!(contains(&pdf, "(Book1) Tj"));
-        assert!(contains(&pdf, "/Helvetica-Bold"));
-        let cx = HfContext {
-            page: 3,
-            pages: 9,
-            sheet: "Data".into(),
-            file: "b.xlsx".into(),
-            date: "1/2/2026".into(),
-            time: "9:00 AM".into(),
-            ..Default::default()
-        };
-        let [l, c, r] = expand_header_footer("&L&\"Arial,Bold\"&A &D&C&14&BTitle && more&RP&P+1/&N &T", &cx);
-        assert_eq!(l.text, "Data 1/2/2026");
-        assert!(l.bold);
-        assert_eq!(c.text, "Title & more");
-        assert!(c.bold);
-        assert_eq!(c.size, Some(14.0));
-        assert_eq!(r.text, "P4/9 9:00 AM");
-        assert_eq!(expand_header_footer("plain", &cx)[1].text, "plain");
-        assert_eq!(expand_header_footer("&", &cx)[1].text, "");
-    }
-
-    #[test]
-    fn conditional_number_format_prints() {
-        // #1163: a rule's number format replaces the cell's own, whether that is General or not;
-        // cells the rule doesn't match keep theirs.
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [[1], [3], [4]]})).unwrap();
-        s.execute("home.numberFormat", json!({"range": "A3", "code": "0.0"})).unwrap();
-        let rule = json!({"type": "cellIs", "operator": "greater", "value": "2", "style": {"num_fmt": "0.00"}});
-        s.execute("home.conditionalFormat", json!({"range": "A1:A3", "rule": rule})).unwrap();
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        assert!(contains(&pdf, "(1) Tj"), "an unmatched cell keeps General");
-        assert!(contains(&pdf, "(3.00) Tj") && !contains(&pdf, "(3) Tj"), "General cell under the rule");
-        assert!(contains(&pdf, "(4.00) Tj") && !contains(&pdf, "(4.0) Tj"), "formatted cell under the rule");
-    }
-
-    #[test]
-    fn pdf_uses_indexed_number_format_palette_color() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "A1", "input": "42"})).unwrap();
-        s.execute("home.numberFormat", json!({"range": "A1", "format": "[Color4]0"})).unwrap();
-        let (pdf, pages) = pdf_of(&mut s, json!({}));
-        assert_eq!(pages, 1);
-        assert!(contains(&pdf, "0 1 0 rg"), "expected indexed Color4 green in PDF text stream");
-    }
-
-    #[test]
-    fn export_writes_file() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "B2", "input": "hello"})).unwrap();
-        let dir = std::env::temp_dir().join(format!("gridcraft-print-{}", std::process::id()));
-        std::fs::create_dir_all(&dir).unwrap();
-        let path = dir.join("out.pdf");
-        let r = s.execute("file.exportPdf", json!({"path": path.to_str().unwrap()})).unwrap();
-        assert_eq!(r["pages"], 1);
-        let bytes = std::fs::read(&path).unwrap();
-        assert!(bytes.starts_with(b"%PDF-"));
-        assert!(contains(&bytes, "(hello) Tj"));
-        let _ = std::fs::remove_dir_all(&dir);
-        let r = s.execute("file.print", json!({})).unwrap();
-        assert!(r["base64"].as_str().unwrap().len() > 100);
-    }
-
-    #[test]
-    fn save_as_pdf_writes_a_pdf_and_keeps_the_workbook_file() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "B2", "input": "hello"})).unwrap();
-        let dir = std::env::temp_dir().join(format!("gridcraft-save-pdf-{}", std::process::id()));
-        std::fs::create_dir_all(&dir).unwrap();
-        let path = dir.join("Out.PDF");
-        let r = s.execute("file.saveAs", json!({"path": path.to_str().unwrap()})).unwrap();
-        assert_eq!(r["pages"], 1);
-        let bytes = std::fs::read(&path).unwrap();
-        assert!(bytes.starts_with(b"%PDF-"));
-        assert!(contains(&bytes, "(hello) Tj"));
-        // The PDF is a print, not the workbook's file: Save still asks where to put the workbook.
-        let d = s.doc().unwrap();
-        assert!(d.path.is_none() && d.is_dirty());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn rich_sheet_renders() {
-        let mut s = Session::new();
-        s.execute("file.new", json!({"sample": "sales"})).unwrap();
-        s.execute("range.setValues", json!({"range": "H1", "values": [["A long piece of text that overflows into neighbours"]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "H3", "input": "Wrapped text across several lines in a narrow cell"})).unwrap();
-        s.execute("home.wrapText", json!({"range": "H3"})).unwrap_or_default();
-        s.execute("selection.set", json!({"range": "J5:K6"})).unwrap();
-        s.execute("home.mergeCenter", json!({})).unwrap();
-        s.execute("cell.set", json!({"cell": "J5", "input": "Merged"})).unwrap();
-        s.execute("home.borders", json!({"range": "J5:K6", "preset": "outside", "style": "thick"})).unwrap_or_default();
-        let (pdf, pages) = pdf_of(&mut s, json!({"sheets": "all"}));
-        assert!(pages >= 1);
-        assert!(contains(&pdf, "(Merged) Tj"));
-        assert!(contains(&pdf, "(A long piece of text that overflows into neighbours) Tj"));
-    }
-
-    #[test]
-    fn charts_and_images_are_drawn() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Fruit", "Qty"], ["Apples", 3], ["Pears", 5]]})).unwrap();
-        s.execute("insert.chart", json!({"range": "A1:B3", "type": "pie"})).unwrap_or_default();
-        s.execute("insert.chart", json!({"range": "A1:B3"})).unwrap_or_default();
-        // A 2×2 PNG with transparency.
-        let mut png = Vec::new();
-        let img = image::RgbaImage::from_raw(2, 2, vec![255, 0, 0, 255, 0, 255, 0, 128, 0, 0, 255, 255, 0, 0, 0, 0]).unwrap();
-        image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
-        let d = s.doc_mut().unwrap();
-        let wb = std::sync::Arc::make_mut(&mut d.wb);
-        let id = wb.next_object_id();
-        wb.sheet_mut(0).unwrap().images.push(Image {
-            id,
-            anchor: Anchor { cell: CellRef::new(5, 5), dx: 0.0, dy: 0.0, width: 40.0, height: 40.0, mode: gridcraft_model::AnchorMode::MoveAndSize },
-            data: png.into(),
-            mime: "image/png".into(),
-            alt: String::new(),
-        });
-        let charts = s.doc().unwrap().wb.active().unwrap().charts.len();
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        assert!(contains(&pdf, "/Subtype /Image"));
-        assert!(contains(&pdf, "/SMask"));
-        if charts > 0 {
-            assert!(contains(&pdf, "(Apples) Tj") || contains(&pdf, "(Qty) Tj"));
-        }
-    }
-
-    #[test]
-    fn page_setup_edits_settings() {
-        let mut s = s();
-        let r = s
-            .execute(
-                "pageLayout.pageSetup",
-                json!({"paper": "A4", "orientation": "landscape", "margins": {"left": 1, "top": 0.5}, "right": 0.25, "centerH": true, "printArea": "A1:D20", "titleRows": "1:2", "titleCols": "A:A", "colBreaks": ["C"]}),
-            )
-            .unwrap();
-        assert_eq!(r["paper"], "A4");
-        assert_eq!(r["orientation"], "Landscape");
-        assert_eq!(r["margins"][0], 1.0);
-        assert_eq!(r["margins"][1], 0.25);
-        assert_eq!(r["margins"][2], 0.5);
-        assert_eq!(r["center_h"], true);
-        assert_eq!(r["title_rows"], json!([0, 1]));
-        assert_eq!(r["col_breaks"], json!([2]));
-        let sh = s.doc().unwrap().wb.active().unwrap().print.clone();
-        assert_eq!(sh.print_area, RangeRef::parse("A1:D20"));
-        s.execute("pageLayout.pageSetup", json!({"printArea": ""})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.active().unwrap().print.print_area, None);
-        assert!(s.execute("pageLayout.pageSetup", json!({"paper": "Napkin"})).is_err());
-        assert!(s.execute("pageLayout.pageSetup", json!({"orientation": "sideways"})).is_err());
-        // Undoable as one step.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert!(s.doc().unwrap().wb.active().unwrap().print.print_area.is_some());
-    }
-
-    /// The Japanese paper sizes are the JIS ones: `B4`/`B5`/`B6` changed meaning from ISO, and the
-    /// ISO B series stays reachable by name. The postcards and envelopes are the JIS sizes too.
-    #[test]
-    fn japanese_paper_sizes_are_jis() {
-        for (name, w, h) in [
-            ("A4", 595.28, 841.89), // unchanged
-            ("B4", 728.50, 1031.81),
-            ("B5", 515.91, 728.50),
-            ("B6", 362.83, 515.91),
-            ("B4 (JIS)", 728.50, 1031.81),
-            ("b5-jis", 515.91, 728.50),
-            ("B4 (ISO)", 708.66, 1000.63),
-            ("B5 (ISO)", 498.90, 708.66),
-            ("B6 (ISO)", 354.33, 498.90),
-            ("A6", 297.64, 419.53),
-            ("Japanese Postcard", 283.46, 419.53),
-            ("japanese double postcard", 419.53, 566.93),
-            ("Japanese Envelope #3", 340.16, 666.14),
-            ("chou #4", 255.12, 581.10),
-            ("Japanese Envelope Kaku #2", 680.31, 941.10),
-            ("kaku #3", 612.28, 785.20),
-        ] {
-            let got = paper_size(name);
-            assert!((got.0 - w).abs() < 0.01 && (got.1 - h).abs() < 0.01, "{name}: {got:?}");
-        }
-        // 長形4号 is 90×205 mm (90×225 mm is 長形40号), so its height is 205 mm = 581.10 pt — not the
-        // 225 mm it once had.
-        let chou4 = paper_size("Japanese Envelope #4");
-        assert_eq!((chou4.0, chou4.1), (255.12, 581.10));
-        assert_eq!(chou4, paper_size("chou #4"));
-        // Unknown names keep the old Letter fallback.
-        assert_eq!(paper_size("Napkin"), (612.0, 792.0));
-    }
-
-    /// Page Setup's paper reaches the PDF page: the MediaBox is the paper's, A4 is unchanged, B5 is
-    /// JIS B5, and the Japanese postcard prints at 283.46×419.53 pt. Landscape swaps the sides and
-    /// fit-to-page keeps the paper size.
-    #[test]
-    fn page_setup_paper_sizes_reach_the_pdf_page() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["x"]]})).unwrap();
-        let close = |v: &Json, want: f64| (v.as_f64().unwrap() - want).abs() < 0.01;
-        for (paper, w, h) in [
-            ("A4", 595.28f64, 841.89f64),
-            ("B5", 515.91, 728.50),
-            ("Japanese Postcard", 283.46, 419.53),
-            ("Japanese Double Postcard", 419.53, 566.93),
-            ("Japanese Envelope Kaku #2", 680.31, 941.10),
-        ] {
-            s.execute("pageLayout.pageSetup", json!({"paper": paper, "orientation": "portrait"})).unwrap();
-            let pv = s.execute("file.printPreview", json!({})).unwrap();
-            let page = &pv["pageList"][0];
-            assert_eq!(page["paper"], paper);
-            assert!(close(&page["width"], w) && close(&page["height"], h), "{paper}: {page}");
-            let (pdf, pages) = pdf_of(&mut s, json!({}));
-            assert_eq!(pages, 1);
-            let want = format!("/MediaBox [0 0 {w} {h}]");
-            assert!(contains(&pdf, &want), "{paper}: wanted {want}");
-        }
-        // Landscape swaps the sides, and fit-to-page does not change the paper.
-        s.execute("pageLayout.pageSetup", json!({"paper": "B5", "orientation": "landscape"})).unwrap();
-        let (pdf, pages) = pdf_of(&mut s, json!({}));
-        assert_eq!(pages, 1);
-        assert!(contains(&pdf, "/MediaBox [0 0 728.5 515.91]"));
-        s.execute("pageLayout.pageSetup", json!({"paper": "B5", "orientation": "portrait"})).unwrap();
-        let (pdf, _) = pdf_of(&mut s, json!({"fitToPage": true}));
-        assert!(contains(&pdf, "/MediaBox [0 0 515.91 728.5]"));
-        // `pageLayout.size` still takes any name, and an unknown one prints on Letter as before.
-        s.execute("pageLayout.size", json!({"paper": "Napkin"})).unwrap();
-        let pv = s.execute("file.printPreview", json!({})).unwrap();
-        assert!(close(&pv["pageList"][0]["width"], 612.0) && close(&pv["pageList"][0]["height"], 792.0));
-        // Page Setup refuses an unknown name.
-        assert!(s.execute("pageLayout.pageSetup", json!({"paper": "Napkin"})).is_err());
-    }
-
-    #[test]
-    fn hostile_settings_never_panic_and_cap_pages() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "XFD1048576", "input": "far"})).unwrap();
-        s.execute("cell.set", json!({"cell": "A1", "input": "near"})).unwrap();
-        s.execute("pageLayout.pageSetup", json!({"scale": 400, "margins": {"left": 20, "right": 20, "top": 20, "bottom": 20}})).unwrap();
-        let pv = s.execute("file.printPreview", json!({})).unwrap();
-        assert!(pv["pages"].as_u64().unwrap() <= MAX_PAGES as u64);
-        assert_eq!(pv["pages"].as_u64().unwrap(), MAX_PAGES as u64);
-        let r = s.execute("file.exportPdf", json!({})).unwrap();
-        assert_eq!(r["pages"], MAX_PAGES);
-        s.execute("pageLayout.pageSetup", json!({"fitWidth": 1, "fitHeight": 1, "titleRows": "1:1048576", "titleCols": "A:XFD", "headings": true}))
-            .unwrap();
-        let pv = s.execute("file.printPreview", json!({})).unwrap();
-        assert!(pv["pages"].as_u64().unwrap() <= MAX_PAGES as u64);
-        assert!(s.execute("file.exportPdf", json!({"range": "A1:C3"})).is_ok());
-        assert!(s.execute("file.exportPdf", json!({"range": "nope"})).is_err());
-        assert!(s.execute("file.exportPdf", json!({"sheets": "some"})).is_err());
-        // Empty workbook still prints one blank page.
-        let mut e = Session::new();
-        e.new_workbook();
-        let r = e.execute("file.exportPdf", json!({})).unwrap();
-        assert_eq!(r["pages"], 1);
-        let r = e.execute("file.exportPdf", json!({"sheets": "all"})).unwrap();
-        assert_eq!(r["pages"], 1);
-        // Weird row sizes and huge fonts.
-        s.execute("pageLayout.pageSetup", json!({"fitToPage": false, "scale": 10, "printArea": "A1:B3", "titleRows": "", "titleCols": ""})).unwrap();
-        s.execute("home.fontSize", json!({"range": "A1", "size": 409})).unwrap_or_default();
-        assert!(s.execute("file.exportPdf", json!({})).is_ok());
-    }
-
-    #[test]
-    fn export_pdf_without_a_path_returns_bytes_and_never_opens_a_dialog() {
-        let mut s = s();
-        for params in [json!({}), json!({"path": ""}), json!({"path": null})] {
-            let r = s.execute("file.exportPdf", params).unwrap();
-            assert!(r.get("path").is_none(), "no file is written without a path");
-            let bytes = crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap();
-            assert!(bytes.starts_with(b"%PDF-"));
-        }
-        assert!(s.take_ui_requests().is_empty(), "a programmatic call never queues a dialog");
-        // Headless callers (CLI, MCP) get the same bytes, not an error.
-        assert!(s.execute_headless("file.exportPdf", json!({})).is_ok());
-        // With no workbook open it is a clear error, not a panic.
-        let mut none = Session::new();
-        assert!(none.execute("file.exportPdf", json!({})).is_err());
-    }
-
-    #[test]
-    fn bands_unit() {
-        let b = bands(0, 9, |_| 10.0, |_| 35.0, &[], 100);
-        assert_eq!(b, vec![(0, 2), (3, 5), (6, 8), (9, 9)]);
-        let b = bands(0, 9, |_| 10.0, |_| 35.0, &[5], 100);
-        assert_eq!(b, vec![(0, 2), (3, 4), (5, 7), (8, 9)]);
-        // A line larger than the page gets its own band.
-        let b = bands(0, 2, |r| if r == 1 { 100.0 } else { 10.0 }, |_| 35.0, &[], 100);
-        assert_eq!(b, vec![(0, 0), (1, 1), (2, 2)]);
-        assert_eq!(bands(0, 1_000_000, |_| 10.0, |_| 5.0, &[], 3).len(), 3);
-        let w = wrap_lines("the quick brown fox jumps", Font::Helvetica, 10.0, 50.0);
-        assert!(w.len() >= 2);
-        assert!(w.iter().all(|l| gridcraft_pdf::text_width(Font::Helvetica, 10.0, l) <= 50.0 || !l.contains(' ')));
-        let w = wrap_lines("Supercalifragilistic", Font::Helvetica, 10.0, 20.0);
-        assert!(w.len() > 2);
-    }
-
-    #[test]
-    fn center_across_spans_following_empty_center_across_cells() {
-        let mut styles = StyleTable::default();
-        let across = styles.intern(Style { align: Alignment { h: HAlign::CenterAcross, ..Alignment::default() }, ..Style::default() });
-        let mut sh = Sheet::new("S");
-        for col in 0..3 {
-            sh.set_style(CellRef::new(0, col), across);
-        }
-        sh.set_value(CellRef::new(0, 0), Value::Text("Title".into()));
-        let a1 = CellRef::new(0, 0);
-        assert_eq!(center_across_width(&styles, &sh, a1, &[]), sh.col_width(1) + sh.col_width(2));
-        sh.set_value(CellRef::new(0, 2), Value::Text("x".into()));
-        assert_eq!(center_across_width(&styles, &sh, a1, &[]), sh.col_width(1));
-        let merged = [RangeRef::new(CellRef::new(0, 1), CellRef::new(1, 1))];
-        assert_eq!(center_across_width(&styles, &sh, a1, &merged), 0.0);
-    }
-
-    #[test]
-    fn rotated_wrapped_text_prints_rotated() {
-        // Upright headers over narrow columns (mark sheets) combine rotation with Wrap Text.
-        let mut s = s();
-        let header = "Term 1 : Drama : Continuous Assessment";
-        s.execute("range.setValues", json!({"range": "A1", "values": [[header, header]]})).unwrap();
-        s.execute("home.wrapText", json!({"range": "A1:B1", "on": true})).unwrap();
-        s.execute("home.orientation", json!({"range": "A1", "angle": "up"})).unwrap();
-        s.execute("home.orientation", json!({"range": "B1", "angle": "down"})).unwrap();
-        s.execute("home.columnWidth", json!({"cols": "A:B", "chars": 6})).unwrap();
-        s.execute("home.rowHeight", json!({"rows": "1:1", "height": 267})).unwrap();
-        let (pdf, _) = pdf_of(&mut s, json!({}));
-        let pdf = String::from_utf8_lossy(&pdf);
-        // The page holds only these two cells, so every text block on it is a piece of a header.
-        let blocks: Vec<&str> = pdf.split("BT\n").skip(1).filter(|b| b.contains(" Tj")).collect();
-        let up = blocks.iter().filter(|b| b.contains("\n0 1 -1 0 ")).count();
-        let down = blocks.iter().filter(|b| b.contains("\n0 -1 1 0 ")).count();
-        // Every piece of both headers is rotated, each wrapped along the row height into a few long lines.
-        assert_eq!(up + down, blocks.len(), "a header line printed flat: {blocks:?}");
-        assert!((1..=3).contains(&up) && (1..=3).contains(&down), "up {up}, down {down}: {blocks:?}");
-    }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/print/tests.rs b/crates/engine/src/cmd/print/tests.rs
new file mode 100644
index 000000000..89b7b62a7
--- /dev/null
+++ b/crates/engine/src/cmd/print/tests.rs
@@ -0,0 +1,570 @@
+use serde_json::json;
+
+use super::*;
+
+fn s() -> Session {
+    let mut s = Session::new();
+    s.new_workbook();
+    s
+}
+fn pdf_of(s: &mut Session, p: Json) -> (Vec<u8>, u64) {
+    let r = s.execute("file.exportPdf", p).unwrap();
+    let bytes = crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap();
+    (bytes, r["pages"].as_u64().unwrap())
+}
+fn contains(hay: &[u8], needle: &str) -> bool {
+    hay.windows(needle.len()).any(|w| w == needle.as_bytes())
+}
+
+#[test]
+fn pdf_export_keeps_safe_links_on_their_printed_pages() {
+    let mut s = s();
+    s.execute("insert.link", json!({"cell": "A1", "target": "https://example.org/report"})).unwrap();
+    s.execute("insert.link", json!({"cell": "A2", "target": "Sheet1!A60"})).unwrap();
+    s.execute("insert.link", json!({"cell": "A3", "target": "file:///private/report"})).unwrap();
+    s.execute("cell.set", json!({"cell": "A60", "input": "Destination"})).unwrap();
+    let (pdf, pages) = pdf_of(&mut s, json!({}));
+    assert_eq!(pages, 2);
+    let text = String::from_utf8_lossy(&pdf);
+    assert_eq!(text.matches("/Subtype /Link").count(), 2);
+    assert!(text.contains("/URI (https://example.org/report)"));
+    assert!(text.contains("/Dest [") && text.contains("/XYZ "));
+    assert!(!text.contains("/URI (file:"));
+
+    // A link to a cell omitted by the selected print range must not point to a nonexistent
+    // destination. The external link in the selected range remains clickable.
+    let (cropped, _) = pdf_of(&mut s, json!({"range": "A1:A3"}));
+    let cropped = String::from_utf8_lossy(&cropped);
+    assert_eq!(cropped.matches("/Subtype /Link").count(), 1);
+    assert!(!cropped.contains("/Dest ["));
+}
+
+#[test]
+fn header_sections_split_join_and_field_names() {
+    let spec = "&L&\"Arial,Bold\"Sales &&Co&CPage &P of &N&R&D";
+    let parts = split_header_footer(spec);
+    assert_eq!(parts, ["&\"Arial,Bold\"Sales &&Co".to_string(), "Page &P of &N".into(), "&D".into()]);
+    assert_eq!(join_header_footer(&parts), spec);
+    // Text before any section code is the centre section, as when printing.
+    assert_eq!(split_header_footer("Report"), [String::new(), "Report".into(), String::new()]);
+    assert_eq!(codes_to_fields("Page &P of &N, &A (&F) &&"), "Page &[Page] of &[Pages], &[Tab] (&[File]) &&");
+    assert_eq!(fields_to_codes("Page &[Page] of &[Pages], &[Tab] (&[File]) &&"), "Page &P of &N, &A (&F) &&");
+    // A dangling ampersand stays literal instead of eating the next section's code.
+    assert_eq!(fields_to_codes("R&"), "R&&");
+    let joined = join_header_footer(&[fields_to_codes("R&"), "x".into(), String::new()]);
+    assert_eq!(split_header_footer(&joined)[0], "R&&");
+    let cx = HfContext { page: 2, pages: 5, sheet: "Data".into(), ..Default::default() };
+    let out = expand_header_footer(&join_header_footer(&[String::new(), fields_to_codes("&[Page] / &[Pages]"), fields_to_codes("&[Tab]")]), &cx);
+    assert_eq!((out[1].text.as_str(), out[2].text.as_str()), ("2 / 5", "Data"));
+    // Hostile input never panics.
+    for t in ["&", "&\"", "&\"unterminated", "&&&", "&[Pag", "\u{1F600}&[Page]"] {
+        let _ = join_header_footer(&split_header_footer(t));
+        let _ = fields_to_codes(&codes_to_fields(t));
+    }
+}
+
+#[test]
+fn header_footer_date_follows_the_workbook_date_system() {
+    let mut wb = Workbook::new();
+    let date_1900 = hf_date_time(&wb).0;
+    wb.date_system = gridcraft_core::DateSystem::D1904;
+    assert_eq!(hf_date_time(&wb).0, date_1900);
+}
+
+#[test]
+fn header_footer_section_edits_are_undoable_and_views_are_per_sheet() {
+    let mut s = s();
+    s.execute("pageLayout.headerFooter", json!({"header": "&LLeft&RRight"})).unwrap();
+    let r = s.execute("pageLayout.headerFooter", json!({"part": "header", "section": "center", "text": "Page &[Page] of &[Pages]"})).unwrap();
+    assert_eq!(r["header"], "&LLeft&CPage &P of &N&RRight");
+    s.execute("pageLayout.headerFooter", json!({"part": "footer", "section": "right", "text": "&[Date]"})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().print.footer, "&R&D");
+    s.execute("edit.undo", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().print.header, "&LLeft&RRight");
+    assert!(s.execute("pageLayout.headerFooter", json!({"part": "middle", "text": "x"})).is_err());
+    assert!(s.execute("pageLayout.headerFooter", json!({"section": "top"})).is_err());
+    let long = "x".repeat(1000);
+    s.execute("pageLayout.headerFooter", json!({"part": "header", "section": "left", "text": long})).unwrap();
+    assert!(s.doc().unwrap().wb.sheet(0).unwrap().print.header.chars().count() <= 255);
+    // The view is per sheet and doesn't dirty a clean workbook.
+    let mut fresh = Session::new();
+    fresh.new_workbook();
+    fresh.execute("home.insertSheet", json!({})).unwrap();
+    fresh.doc_mut().unwrap().saved = fresh.doc().unwrap().wb.clone();
+    fresh.execute("view.pageLayout", json!({"sheet": 0})).unwrap();
+    let wb = &fresh.doc().unwrap().wb;
+    assert_eq!((wb.sheet(0).unwrap().view, wb.sheet(1).unwrap().view), (SheetViewMode::PageLayout, SheetViewMode::Normal));
+    assert!(!fresh.doc().unwrap().is_dirty(), "switching views is not an edit");
+    s.execute("view.pageLayout", json!({"sheet": 0})).unwrap();
+    s.execute("view.normal", json!({"sheet": 0})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().view, SheetViewMode::Normal);
+    assert_eq!(s.execute("view.ruler", json!({"on": false})).unwrap()["on"], false);
+    assert!(s.hide_ruler);
+    assert_eq!(s.execute("view.ruler", json!({})).unwrap()["on"], true);
+}
+
+#[test]
+fn page_count_300_rows_letter_portrait() {
+    let mut s = s();
+    let rows: Vec<Vec<Json>> = (1..=300).map(|i| vec![json!(i)]).collect();
+    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
+    // 684pt of printable height / 15pt rows = 45 rows per page → 7 pages.
+    let (pdf, pages) = pdf_of(&mut s, json!({}));
+    assert_eq!(pages, 7);
+    assert!(pdf.starts_with(b"%PDF-1.7"));
+    assert!(contains(&pdf, "/Count 7"));
+    let pv = s.execute("file.printPreview", json!({})).unwrap();
+    assert_eq!(pv["pages"], 7);
+    assert_eq!(pv["pageList"][0]["rows"], "1:45");
+    assert_eq!(pv["pageList"][1]["rows"], "46:90");
+    assert_eq!(s.execute("file.printPreview", json!({"page": 7})).unwrap()["page"]["rows"], "271:300");
+    assert!(s.execute("file.printPreview", json!({"page": 8})).is_err());
+    // Landscape: 504pt / 15 = 33 rows per page → 10 pages.
+    s.execute("pageLayout.pageSetup", json!({"orientation": "landscape"})).unwrap();
+    assert_eq!(pdf_of(&mut s, json!({})).1, 10);
+    // Fit to one page.
+    assert_eq!(pdf_of(&mut s, json!({"fitToPage": true})).1, 1);
+    s.execute("pageLayout.pageSetup", json!({"fitWidth": 1, "fitHeight": 2, "orientation": "portrait"})).unwrap();
+    assert_eq!(pdf_of(&mut s, json!({})).1, 2);
+    // Manual break and repeated title rows.
+    s.execute("pageLayout.pageSetup", json!({"scale": 100, "rowBreaks": [11], "titleRows": "1:1"})).unwrap();
+    let pv = s.execute("file.printPreview", json!({})).unwrap();
+    assert_eq!(pv["pageList"][0]["rows"], "1:10");
+    // Title row takes one line on later pages: 44 body rows.
+    assert_eq!(pv["pageList"][1]["rows"], "11:54");
+}
+
+#[test]
+fn wide_sheet_goes_down_then_over() {
+    let mut s = s();
+    let rows: Vec<Vec<Json>> = (0..60).map(|r| (0..15).map(|c| json!(r * 100 + c)).collect()).collect();
+    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
+    let pv = s.execute("file.printPreview", json!({})).unwrap();
+    // 511.2pt / 48pt = 10 columns per page; 45 rows per page.
+    assert_eq!(pv["pages"], 4);
+    assert_eq!(pv["pageList"][0]["range"], "A1:J45");
+    assert_eq!(pv["pageList"][1]["range"], "A46:J60");
+    assert_eq!(pv["pageList"][2]["range"], "K1:O45");
+}
+
+#[test]
+fn first_and_even_pages_print_their_own_headers() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["a"], ["b"], ["c"], ["d"], ["e"], ["f"]]})).unwrap();
+    s.execute("pageLayout.pageSetup", json!({"rowBreaks": [2, 4]})).unwrap();
+    let r = s
+        .execute(
+            "pageLayout.headerFooter",
+            json!({"header": "&COdd &P", "evenHeader": "&CEven &P", "firstHeader": "&CCover", "differentFirst": true, "differentOddEven": true}),
+        )
+        .unwrap();
+    assert_eq!(r["firstHeader"], "&CCover");
+    let (pdf, pages) = pdf_of(&mut s, json!({}));
+    assert_eq!(pages, 3);
+    assert!(contains(&pdf, "(Cover) Tj") && contains(&pdf, "(Even 2) Tj") && contains(&pdf, "(Odd 3) Tj"));
+    assert!(!contains(&pdf, "(Odd 1) Tj"), "the first page has its own header");
+    // One section of the even-page footer, edited in place.
+    s.execute("pageLayout.headerFooter", json!({"page": "even", "part": "footer", "section": "right", "text": "&[Tab]"})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().print.even_footer, "&R&A");
+    assert!(s.execute("pageLayout.headerFooter", json!({"page": "last", "part": "header", "text": "x"})).is_err());
+    // Turned off, every page prints the odd header again.
+    s.execute("pageLayout.headerFooter", json!({"differentFirst": false, "differentOddEven": false})).unwrap();
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    assert!(contains(&pdf, "(Odd 1) Tj") && contains(&pdf, "(Odd 2) Tj") && !contains(&pdf, "(Cover) Tj"));
+}
+
+/// The x position and font size of the first `(text) Tj` in a PDF.
+fn text_at(pdf: &[u8], text: &str) -> Option<(f32, f32)> {
+    let s = String::from_utf8_lossy(pdf);
+    let before = &s[..s.find(&format!("({text}) Tj"))?];
+    let tf = before.rfind(" Tf")?;
+    let size = before[..tf].rsplit(' ').next()?.parse().ok()?;
+    let tm = before.rfind(" Tm")?;
+    let mut nums = before[..tm].rsplit([' ', '\n']);
+    let _y = nums.next()?;
+    let x = nums.next()?.parse().ok()?;
+    Some((x, size))
+}
+
+#[test]
+fn headers_scale_with_the_sheet_and_align_with_its_margins_unless_turned_off() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap();
+    s.execute("pageLayout.pageSetup", json!({"scale": 50, "left": 1.5, "right": 1.5})).unwrap();
+    s.execute("pageLayout.headerFooter", json!({"header": "&LLeft&C&14Middle"})).unwrap();
+    // Both on (the default): the text prints at half size, from the 1.5-inch left margin.
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    assert_eq!(text_at(&pdf, "Left"), Some((108.0, 5.0)));
+    assert_eq!(text_at(&pdf, "Middle").map(|t| t.1), Some(7.0));
+    let r = s.execute("pageLayout.headerFooter", json!({"scaleWithDoc": false, "alignWithMargins": false})).unwrap();
+    assert_eq!((&r["scaleWithDoc"], &r["alignWithMargins"]), (&json!(false), &json!(false)));
+    // Both off: full size, 0.7 inch from the paper's left edge.
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    assert_eq!(text_at(&pdf, "Left"), Some((50.4, 10.0)));
+    assert_eq!(text_at(&pdf, "Middle").map(|t| t.1), Some(14.0));
+    s.execute("edit.undo", json!({})).unwrap();
+    let pr = &s.doc().unwrap().wb.sheet(0).unwrap().print;
+    assert!(pr.hf_scale_with_doc && pr.hf_align_with_margins);
+}
+
+#[test]
+fn pdf_prints_cjk_text_instead_of_question_marks() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["签字清单", 2]]})).unwrap();
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    assert!(!contains(&pdf, "(????) Tj"), "CJK cell printed as (????) Tj");
+    assert!(contains(&pdf, "<7B7E5B576E055355> Tj"));
+    assert!(contains(&pdf, "(2) Tj"));
+}
+
+#[test]
+fn pdf_contains_text_and_header_codes_expand() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Quarterly Report", null], ["Total", 1234.5]]})).unwrap();
+    s.execute("home.bold", json!({"range": "A1"})).unwrap();
+    s.execute(
+        "pageLayout.pageSetup",
+        json!({"header": "&LLeft &A&CMiddle&RPage &P of &N", "footer": "&C&F", "gridlines": true, "headings": true}),
+    )
+    .unwrap();
+    let (pdf, pages) = pdf_of(&mut s, json!({}));
+    assert_eq!(pages, 1);
+    assert!(contains(&pdf, "(Quarterly Report) Tj"));
+    assert!(contains(&pdf, "(1234.5) Tj"));
+    assert!(contains(&pdf, "(Left Sheet1) Tj"));
+    assert!(contains(&pdf, "(Page 1 of 1) Tj"));
+    assert!(contains(&pdf, "(Book1) Tj"));
+    assert!(contains(&pdf, "/Helvetica-Bold"));
+    let cx = HfContext {
+        page: 3,
+        pages: 9,
+        sheet: "Data".into(),
+        file: "b.xlsx".into(),
+        date: "1/2/2026".into(),
+        time: "9:00 AM".into(),
+        ..Default::default()
+    };
+    let [l, c, r] = expand_header_footer("&L&\"Arial,Bold\"&A &D&C&14&BTitle && more&RP&P+1/&N &T", &cx);
+    assert_eq!(l.text, "Data 1/2/2026");
+    assert!(l.bold);
+    assert_eq!(c.text, "Title & more");
+    assert!(c.bold);
+    assert_eq!(c.size, Some(14.0));
+    assert_eq!(r.text, "P4/9 9:00 AM");
+    assert_eq!(expand_header_footer("plain", &cx)[1].text, "plain");
+    assert_eq!(expand_header_footer("&", &cx)[1].text, "");
+}
+
+#[test]
+fn conditional_number_format_prints() {
+    // #1163: a rule's number format replaces the cell's own, whether that is General or not;
+    // cells the rule doesn't match keep theirs.
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [[1], [3], [4]]})).unwrap();
+    s.execute("home.numberFormat", json!({"range": "A3", "code": "0.0"})).unwrap();
+    let rule = json!({"type": "cellIs", "operator": "greater", "value": "2", "style": {"num_fmt": "0.00"}});
+    s.execute("home.conditionalFormat", json!({"range": "A1:A3", "rule": rule})).unwrap();
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    assert!(contains(&pdf, "(1) Tj"), "an unmatched cell keeps General");
+    assert!(contains(&pdf, "(3.00) Tj") && !contains(&pdf, "(3) Tj"), "General cell under the rule");
+    assert!(contains(&pdf, "(4.00) Tj") && !contains(&pdf, "(4.0) Tj"), "formatted cell under the rule");
+}
+
+#[test]
+fn pdf_uses_indexed_number_format_palette_color() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "A1", "input": "42"})).unwrap();
+    s.execute("home.numberFormat", json!({"range": "A1", "format": "[Color4]0"})).unwrap();
+    let (pdf, pages) = pdf_of(&mut s, json!({}));
+    assert_eq!(pages, 1);
+    assert!(contains(&pdf, "0 1 0 rg"), "expected indexed Color4 green in PDF text stream");
+}
+
+#[test]
+fn export_writes_file() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "B2", "input": "hello"})).unwrap();
+    let dir = std::env::temp_dir().join(format!("gridcraft-print-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("out.pdf");
+    let r = s.execute("file.exportPdf", json!({"path": path.to_str().unwrap()})).unwrap();
+    assert_eq!(r["pages"], 1);
+    let bytes = std::fs::read(&path).unwrap();
+    assert!(bytes.starts_with(b"%PDF-"));
+    assert!(contains(&bytes, "(hello) Tj"));
+    let _ = std::fs::remove_dir_all(&dir);
+    let r = s.execute("file.print", json!({})).unwrap();
+    assert!(r["base64"].as_str().unwrap().len() > 100);
+}
+
+#[test]
+fn save_as_pdf_writes_a_pdf_and_keeps_the_workbook_file() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "B2", "input": "hello"})).unwrap();
+    let dir = std::env::temp_dir().join(format!("gridcraft-save-pdf-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Out.PDF");
+    let r = s.execute("file.saveAs", json!({"path": path.to_str().unwrap()})).unwrap();
+    assert_eq!(r["pages"], 1);
+    let bytes = std::fs::read(&path).unwrap();
+    assert!(bytes.starts_with(b"%PDF-"));
+    assert!(contains(&bytes, "(hello) Tj"));
+    // The PDF is a print, not the workbook's file: Save still asks where to put the workbook.
+    let d = s.doc().unwrap();
+    assert!(d.path.is_none() && d.is_dirty());
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn rich_sheet_renders() {
+    let mut s = Session::new();
+    s.execute("file.new", json!({"sample": "sales"})).unwrap();
+    s.execute("range.setValues", json!({"range": "H1", "values": [["A long piece of text that overflows into neighbours"]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "H3", "input": "Wrapped text across several lines in a narrow cell"})).unwrap();
+    s.execute("home.wrapText", json!({"range": "H3"})).unwrap_or_default();
+    s.execute("selection.set", json!({"range": "J5:K6"})).unwrap();
+    s.execute("home.mergeCenter", json!({})).unwrap();
+    s.execute("cell.set", json!({"cell": "J5", "input": "Merged"})).unwrap();
+    s.execute("home.borders", json!({"range": "J5:K6", "preset": "outside", "style": "thick"})).unwrap_or_default();
+    let (pdf, pages) = pdf_of(&mut s, json!({"sheets": "all"}));
+    assert!(pages >= 1);
+    assert!(contains(&pdf, "(Merged) Tj"));
+    assert!(contains(&pdf, "(A long piece of text that overflows into neighbours) Tj"));
+}
+
+#[test]
+fn charts_and_images_are_drawn() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Fruit", "Qty"], ["Apples", 3], ["Pears", 5]]})).unwrap();
+    s.execute("insert.chart", json!({"range": "A1:B3", "type": "pie"})).unwrap_or_default();
+    s.execute("insert.chart", json!({"range": "A1:B3"})).unwrap_or_default();
+    // A 2×2 PNG with transparency.
+    let mut png = Vec::new();
+    let img = image::RgbaImage::from_raw(2, 2, vec![255, 0, 0, 255, 0, 255, 0, 128, 0, 0, 255, 255, 0, 0, 0, 0]).unwrap();
+    image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let d = s.doc_mut().unwrap();
+    let wb = std::sync::Arc::make_mut(&mut d.wb);
+    let id = wb.next_object_id();
+    wb.sheet_mut(0).unwrap().images.push(Image {
+        id,
+        anchor: Anchor { cell: CellRef::new(5, 5), dx: 0.0, dy: 0.0, width: 40.0, height: 40.0, mode: gridcraft_model::AnchorMode::MoveAndSize },
+        data: png.into(),
+        mime: "image/png".into(),
+        alt: String::new(),
+    });
+    let charts = s.doc().unwrap().wb.active().unwrap().charts.len();
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    assert!(contains(&pdf, "/Subtype /Image"));
+    assert!(contains(&pdf, "/SMask"));
+    if charts > 0 {
+        assert!(contains(&pdf, "(Apples) Tj") || contains(&pdf, "(Qty) Tj"));
+    }
+}
+
+#[test]
+fn page_setup_edits_settings() {
+    let mut s = s();
+    let r = s
+        .execute(
+            "pageLayout.pageSetup",
+            json!({"paper": "A4", "orientation": "landscape", "margins": {"left": 1, "top": 0.5}, "right": 0.25, "centerH": true, "printArea": "A1:D20", "titleRows": "1:2", "titleCols": "A:A", "colBreaks": ["C"]}),
+        )
+        .unwrap();
+    assert_eq!(r["paper"], "A4");
+    assert_eq!(r["orientation"], "Landscape");
+    assert_eq!(r["margins"][0], 1.0);
+    assert_eq!(r["margins"][1], 0.25);
+    assert_eq!(r["margins"][2], 0.5);
+    assert_eq!(r["center_h"], true);
+    assert_eq!(r["title_rows"], json!([0, 1]));
+    assert_eq!(r["col_breaks"], json!([2]));
+    let sh = s.doc().unwrap().wb.active().unwrap().print.clone();
+    assert_eq!(sh.print_area, RangeRef::parse("A1:D20"));
+    s.execute("pageLayout.pageSetup", json!({"printArea": ""})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.active().unwrap().print.print_area, None);
+    assert!(s.execute("pageLayout.pageSetup", json!({"paper": "Napkin"})).is_err());
+    assert!(s.execute("pageLayout.pageSetup", json!({"orientation": "sideways"})).is_err());
+    // Undoable as one step.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.doc().unwrap().wb.active().unwrap().print.print_area.is_some());
+}
+
+/// The Japanese paper sizes are the JIS ones: `B4`/`B5`/`B6` changed meaning from ISO, and the
+/// ISO B series stays reachable by name. The postcards and envelopes are the JIS sizes too.
+#[test]
+fn japanese_paper_sizes_are_jis() {
+    for (name, w, h) in [
+        ("A4", 595.28, 841.89), // unchanged
+        ("B4", 728.50, 1031.81),
+        ("B5", 515.91, 728.50),
+        ("B6", 362.83, 515.91),
+        ("B4 (JIS)", 728.50, 1031.81),
+        ("b5-jis", 515.91, 728.50),
+        ("B4 (ISO)", 708.66, 1000.63),
+        ("B5 (ISO)", 498.90, 708.66),
+        ("B6 (ISO)", 354.33, 498.90),
+        ("A6", 297.64, 419.53),
+        ("Japanese Postcard", 283.46, 419.53),
+        ("japanese double postcard", 419.53, 566.93),
+        ("Japanese Envelope #3", 340.16, 666.14),
+        ("chou #4", 255.12, 581.10),
+        ("Japanese Envelope Kaku #2", 680.31, 941.10),
+        ("kaku #3", 612.28, 785.20),
+    ] {
+        let got = paper_size(name);
+        assert!((got.0 - w).abs() < 0.01 && (got.1 - h).abs() < 0.01, "{name}: {got:?}");
+    }
+    // 長形4号 is 90×205 mm (90×225 mm is 長形40号), so its height is 205 mm = 581.10 pt — not the
+    // 225 mm it once had.
+    let chou4 = paper_size("Japanese Envelope #4");
+    assert_eq!((chou4.0, chou4.1), (255.12, 581.10));
+    assert_eq!(chou4, paper_size("chou #4"));
+    // Unknown names keep the old Letter fallback.
+    assert_eq!(paper_size("Napkin"), (612.0, 792.0));
+}
+
+/// Page Setup's paper reaches the PDF page: the MediaBox is the paper's, A4 is unchanged, B5 is
+/// JIS B5, and the Japanese postcard prints at 283.46×419.53 pt. Landscape swaps the sides and
+/// fit-to-page keeps the paper size.
+#[test]
+fn page_setup_paper_sizes_reach_the_pdf_page() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["x"]]})).unwrap();
+    let close = |v: &Json, want: f64| (v.as_f64().unwrap() - want).abs() < 0.01;
+    for (paper, w, h) in [
+        ("A4", 595.28f64, 841.89f64),
+        ("B5", 515.91, 728.50),
+        ("Japanese Postcard", 283.46, 419.53),
+        ("Japanese Double Postcard", 419.53, 566.93),
+        ("Japanese Envelope Kaku #2", 680.31, 941.10),
+    ] {
+        s.execute("pageLayout.pageSetup", json!({"paper": paper, "orientation": "portrait"})).unwrap();
+        let pv = s.execute("file.printPreview", json!({})).unwrap();
+        let page = &pv["pageList"][0];
+        assert_eq!(page["paper"], paper);
+        assert!(close(&page["width"], w) && close(&page["height"], h), "{paper}: {page}");
+        let (pdf, pages) = pdf_of(&mut s, json!({}));
+        assert_eq!(pages, 1);
+        let want = format!("/MediaBox [0 0 {w} {h}]");
+        assert!(contains(&pdf, &want), "{paper}: wanted {want}");
+    }
+    // Landscape swaps the sides, and fit-to-page does not change the paper.
+    s.execute("pageLayout.pageSetup", json!({"paper": "B5", "orientation": "landscape"})).unwrap();
+    let (pdf, pages) = pdf_of(&mut s, json!({}));
+    assert_eq!(pages, 1);
+    assert!(contains(&pdf, "/MediaBox [0 0 728.5 515.91]"));
+    s.execute("pageLayout.pageSetup", json!({"paper": "B5", "orientation": "portrait"})).unwrap();
+    let (pdf, _) = pdf_of(&mut s, json!({"fitToPage": true}));
+    assert!(contains(&pdf, "/MediaBox [0 0 515.91 728.5]"));
+    // `pageLayout.size` still takes any name, and an unknown one prints on Letter as before.
+    s.execute("pageLayout.size", json!({"paper": "Napkin"})).unwrap();
+    let pv = s.execute("file.printPreview", json!({})).unwrap();
+    assert!(close(&pv["pageList"][0]["width"], 612.0) && close(&pv["pageList"][0]["height"], 792.0));
+    // Page Setup refuses an unknown name.
+    assert!(s.execute("pageLayout.pageSetup", json!({"paper": "Napkin"})).is_err());
+}
+
+#[test]
+fn hostile_settings_never_panic_and_cap_pages() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "XFD1048576", "input": "far"})).unwrap();
+    s.execute("cell.set", json!({"cell": "A1", "input": "near"})).unwrap();
+    s.execute("pageLayout.pageSetup", json!({"scale": 400, "margins": {"left": 20, "right": 20, "top": 20, "bottom": 20}})).unwrap();
+    let pv = s.execute("file.printPreview", json!({})).unwrap();
+    assert!(pv["pages"].as_u64().unwrap() <= MAX_PAGES as u64);
+    assert_eq!(pv["pages"].as_u64().unwrap(), MAX_PAGES as u64);
+    let r = s.execute("file.exportPdf", json!({})).unwrap();
+    assert_eq!(r["pages"], MAX_PAGES);
+    s.execute("pageLayout.pageSetup", json!({"fitWidth": 1, "fitHeight": 1, "titleRows": "1:1048576", "titleCols": "A:XFD", "headings": true}))
+        .unwrap();
+    let pv = s.execute("file.printPreview", json!({})).unwrap();
+    assert!(pv["pages"].as_u64().unwrap() <= MAX_PAGES as u64);
+    assert!(s.execute("file.exportPdf", json!({"range": "A1:C3"})).is_ok());
+    assert!(s.execute("file.exportPdf", json!({"range": "nope"})).is_err());
+    assert!(s.execute("file.exportPdf", json!({"sheets": "some"})).is_err());
+    // Empty workbook still prints one blank page.
+    let mut e = Session::new();
+    e.new_workbook();
+    let r = e.execute("file.exportPdf", json!({})).unwrap();
+    assert_eq!(r["pages"], 1);
+    let r = e.execute("file.exportPdf", json!({"sheets": "all"})).unwrap();
+    assert_eq!(r["pages"], 1);
+    // Weird row sizes and huge fonts.
+    s.execute("pageLayout.pageSetup", json!({"fitToPage": false, "scale": 10, "printArea": "A1:B3", "titleRows": "", "titleCols": ""})).unwrap();
+    s.execute("home.fontSize", json!({"range": "A1", "size": 409})).unwrap_or_default();
+    assert!(s.execute("file.exportPdf", json!({})).is_ok());
+}
+
+#[test]
+fn export_pdf_without_a_path_returns_bytes_and_never_opens_a_dialog() {
+    let mut s = s();
+    for params in [json!({}), json!({"path": ""}), json!({"path": null})] {
+        let r = s.execute("file.exportPdf", params).unwrap();
+        assert!(r.get("path").is_none(), "no file is written without a path");
+        let bytes = crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap();
+        assert!(bytes.starts_with(b"%PDF-"));
+    }
+    assert!(s.take_ui_requests().is_empty(), "a programmatic call never queues a dialog");
+    // Headless callers (CLI, MCP) get the same bytes, not an error.
+    assert!(s.execute_headless("file.exportPdf", json!({})).is_ok());
+    // With no workbook open it is a clear error, not a panic.
+    let mut none = Session::new();
+    assert!(none.execute("file.exportPdf", json!({})).is_err());
+}
+
+#[test]
+fn bands_unit() {
+    let b = bands(0, 9, |_| 10.0, |_| 35.0, &[], 100);
+    assert_eq!(b, vec![(0, 2), (3, 5), (6, 8), (9, 9)]);
+    let b = bands(0, 9, |_| 10.0, |_| 35.0, &[5], 100);
+    assert_eq!(b, vec![(0, 2), (3, 4), (5, 7), (8, 9)]);
+    // A line larger than the page gets its own band.
+    let b = bands(0, 2, |r| if r == 1 { 100.0 } else { 10.0 }, |_| 35.0, &[], 100);
+    assert_eq!(b, vec![(0, 0), (1, 1), (2, 2)]);
+    assert_eq!(bands(0, 1_000_000, |_| 10.0, |_| 5.0, &[], 3).len(), 3);
+    let w = wrap_lines("the quick brown fox jumps", Font::Helvetica, 10.0, 50.0);
+    assert!(w.len() >= 2);
+    assert!(w.iter().all(|l| gridcraft_pdf::text_width(Font::Helvetica, 10.0, l) <= 50.0 || !l.contains(' ')));
+    let w = wrap_lines("Supercalifragilistic", Font::Helvetica, 10.0, 20.0);
+    assert!(w.len() > 2);
+}
+
+#[test]
+fn center_across_spans_following_empty_center_across_cells() {
+    let mut styles = StyleTable::default();
+    let across = styles.intern(Style { align: Alignment { h: HAlign::CenterAcross, ..Alignment::default() }, ..Style::default() });
+    let mut sh = Sheet::new("S");
+    for col in 0..3 {
+        sh.set_style(CellRef::new(0, col), across);
+    }
+    sh.set_value(CellRef::new(0, 0), Value::Text("Title".into()));
+    let a1 = CellRef::new(0, 0);
+    assert_eq!(center_across_width(&styles, &sh, a1, &[]), sh.col_width(1) + sh.col_width(2));
+    sh.set_value(CellRef::new(0, 2), Value::Text("x".into()));
+    assert_eq!(center_across_width(&styles, &sh, a1, &[]), sh.col_width(1));
+    let merged = [RangeRef::new(CellRef::new(0, 1), CellRef::new(1, 1))];
+    assert_eq!(center_across_width(&styles, &sh, a1, &merged), 0.0);
+}
+
+#[test]
+fn rotated_wrapped_text_prints_rotated() {
+    // Upright headers over narrow columns (mark sheets) combine rotation with Wrap Text.
+    let mut s = s();
+    let header = "Term 1 : Drama : Continuous Assessment";
+    s.execute("range.setValues", json!({"range": "A1", "values": [[header, header]]})).unwrap();
+    s.execute("home.wrapText", json!({"range": "A1:B1", "on": true})).unwrap();
+    s.execute("home.orientation", json!({"range": "A1", "angle": "up"})).unwrap();
+    s.execute("home.orientation", json!({"range": "B1", "angle": "down"})).unwrap();
+    s.execute("home.columnWidth", json!({"cols": "A:B", "chars": 6})).unwrap();
+    s.execute("home.rowHeight", json!({"rows": "1:1", "height": 267})).unwrap();
+    let (pdf, _) = pdf_of(&mut s, json!({}));
+    let pdf = String::from_utf8_lossy(&pdf);
+    // The page holds only these two cells, so every text block on it is a piece of a header.
+    let blocks: Vec<&str> = pdf.split("BT\n").skip(1).filter(|b| b.contains(" Tj")).collect();
+    let up = blocks.iter().filter(|b| b.contains("\n0 1 -1 0 ")).count();
+    let down = blocks.iter().filter(|b| b.contains("\n0 -1 1 0 ")).count();
+    // Every piece of both headers is rotated, each wrapped along the row height into a few long lines.
+    assert_eq!(up + down, blocks.len(), "a header line printed flat: {blocks:?}");
+    assert!((1..=3).contains(&up) && (1..=3).contains(&down), "up {up}, down {down}: {blocks:?}");
+}

From 6fee0e9134c6722e50571f7463fac35af8c12e5f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:42 +0000
Subject: [PATCH 30/76] refactor(engine): move cmd/solver tests to
 src/cmd/solver/tests.rs

---
 crates/engine/src/cmd/solver.rs       | 480 +-------------------------
 crates/engine/src/cmd/solver/tests.rs | 477 +++++++++++++++++++++++++
 2 files changed, 478 insertions(+), 479 deletions(-)
 create mode 100644 crates/engine/src/cmd/solver/tests.rs

diff --git a/crates/engine/src/cmd/solver.rs b/crates/engine/src/cmd/solver.rs
index 21dbc1926..191493841 100644
--- a/crates/engine/src/cmd/solver.rs
+++ b/crates/engine/src/cmd/solver.rs
@@ -2127,482 +2127,4 @@ fn run(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 #[cfg(test)]
-mod tests {
-    use gridcraft_core::{CellRef, Value};
-    use serde_json::json;
-
-    use crate::Session;
-
-    fn s() -> Session {
-        let mut s = Session::new();
-        s.new_workbook();
-        s
-    }
-    fn n(s: &Session, a: &str) -> f64 {
-        let d = s.doc().unwrap();
-        d.wb.active().unwrap().value(CellRef::parse(a).unwrap()).as_f64().unwrap_or(f64::NAN)
-    }
-    /// The first saved-model name scoped to the active sheet.
-    fn saved(s: &Session) -> String {
-        let d = s.doc().unwrap();
-        d.wb.names.iter().find(|n| n.scope == Some(d.wb.active_sheet())).map(|n| n.name.clone()).unwrap_or_default()
-    }
-    fn set(s: &mut Session, cells: &[(&str, &str)]) {
-        for (c, v) in cells {
-            s.execute("cell.set", json!({"cell": c, "input": v})).unwrap();
-        }
-    }
-
-    #[test]
-    fn simplex_solves_the_wyndor_glass_lp() {
-        // Hillier & Lieberman's Wyndor Glass problem: max 3x + 5y, x ≤ 4, 2y ≤ 12, 3x + 2y ≤ 18
-        // → x = 2, y = 6, Z = 36.
-        let mut s = s();
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=3*A1+5*A2"), ("B2", "=2*A2"), ("B3", "=3*A1+2*A2")]);
-        let r = s
-            .execute(
-                "data.solver",
-                json!({"objective": "B1", "goal": "max", "variables": "A1:A2", "constraints": ["A1 <= 4", "B2 <= 12", {"lhs": "B3", "op": "<=", "rhs": 18}], "method": "simplex"}),
-            )
-            .unwrap();
-        assert_eq!(r["status"], "optimal", "{r}");
-        assert!((n(&s, "A1") - 2.0).abs() < 1e-9 && (n(&s, "A2") - 6.0).abs() < 1e-9);
-        assert!((n(&s, "B1") - 36.0).abs() < 1e-9);
-        // The model is saved as hidden names, survives XLSX and solves again from them.
-        let names: Vec<String> = s.doc().unwrap().wb.names.iter().map(|n| n.name.clone()).collect();
-        assert!(names.iter().any(|n| n == "solver_opt") && names.iter().any(|n| n == "solver_lhs3"));
-        let b64 = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap()["base64"].as_str().unwrap().to_string();
-        s.execute("file.open", json!({"name": "m.xlsx", "base64": b64})).unwrap();
-        set(&mut s, &[("A1", "0"), ("A2", "0")]);
-        let m = s.execute("data.solver", json!({})).unwrap();
-        assert_eq!(m["model"]["objective"], "B1");
-        assert_eq!(m["model"]["method"], "simplex");
-        let r = s.execute("data.solver", json!({"saved": true})).unwrap();
-        assert_eq!(r["status"], "optimal");
-        assert!((n(&s, "B1") - 36.0).abs() < 1e-9);
-        // Minimise with keep: false leaves the cells alone.
-        set(&mut s, &[("A1", "1"), ("A2", "1")]);
-        let r = s.execute("data.solver", json!({"saved": true, "goal": "min", "keep": false})).unwrap();
-        assert_eq!(r["objective"], 0.0);
-        assert_eq!((n(&s, "A1"), n(&s, "A2")), (1.0, 1.0));
-    }
-
-    #[test]
-    fn integer_and_binary_constraints_use_branch_and_bound() {
-        // max 5x + 4y, 6x + 4y ≤ 24, x + 2y ≤ 6: the LP optimum (3, 1.5) = 21; integers give
-        // (4, 0) = 20.
-        let mut s = s();
-        set(&mut s, &[("B1", "=5*A1+4*A2"), ("B2", "=6*A1+4*A2"), ("B3", "=A1+2*A2")]);
-        let base = json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 24", "B3 <= 6"], "method": "simplex"});
-        let r = s.execute("data.solver", base.clone()).unwrap();
-        assert!((r["objective"].as_f64().unwrap() - 21.0).abs() < 1e-9);
-        let mut p = base.clone();
-        p["constraints"].as_array_mut().unwrap().push(json!("A1:A2 int"));
-        let r = s.execute("data.solver", p).unwrap();
-        assert_eq!(r["status"], "optimal");
-        assert_eq!((n(&s, "A1"), n(&s, "A2"), n(&s, "B1")), (4.0, 0.0, 20.0));
-        // 0/1 knapsack: values 10, 13, 7, weights 5, 6, 4, capacity 10 → items 2 and 3 (20).
-        set(&mut s, &[("D1", "=10*C1+13*C2+7*C3"), ("D2", "=5*C1+6*C2+4*C3")]);
-        let r = s
-            .execute("data.solver", json!({"objective": "D1", "variables": "C1:C3", "constraints": ["D2 <= 10", "C1:C3 bin"], "method": "simplex"}))
-            .unwrap();
-        assert_eq!(r["status"], "optimal");
-        assert_eq!((n(&s, "C1"), n(&s, "C2"), n(&s, "C3"), n(&s, "D1")), (0.0, 1.0, 1.0, 20.0));
-    }
-
-    #[test]
-    fn grg_finds_smooth_optima() {
-        // Largest rectangle with perimeter at most 20: a 5 × 5 square, area 25.
-        let mut s = s();
-        set(&mut s, &[("A1", "1"), ("A2", "1"), ("B1", "=A1*A2"), ("B2", "=2*A1+2*A2")]);
-        let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 20"]})).unwrap();
-        assert_eq!(r["status"], "converged", "{r}");
-        assert!((n(&s, "A1") - 5.0).abs() < 1e-3 && (n(&s, "A2") - 5.0).abs() < 1e-3, "{r}");
-        // Unconstrained minimum of (x − 3)² + (y + 1)² at (3, −1) once negatives are allowed.
-        set(&mut s, &[("C1", "0"), ("C2", "0"), ("D1", "=(C1-3)^2+(C2+1)^2")]);
-        s.execute("data.solver", json!({"objective": "D1", "goal": "min", "variables": "C1:C2", "nonNegative": false})).unwrap();
-        assert!((n(&s, "C1") - 3.0).abs() < 1e-4 && (n(&s, "C2") + 1.0).abs() < 1e-4);
-        // Value Of: x³ = 8 → x = 2.
-        set(&mut s, &[("E1", "1"), ("F1", "=E1^3")]);
-        s.execute("data.solver", json!({"objective": "F1", "goal": "value", "value": 8, "variables": "E1"})).unwrap();
-        assert!((n(&s, "E1") - 2.0).abs() < 1e-4);
-    }
-
-    #[test]
-    fn evolutionary_finds_the_global_minimum_of_non_smooth_and_multimodal_models() {
-        let mut s = s();
-        // |x − 3| + |y + 2| has a kink at its minimum (3, −2).
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=ABS(A1-3)+ABS(A2+2)")]);
-        let p =
-            json!({"objective": "B1", "goal": "min", "variables": "A1:A2", "constraints": ["A1:A2 >= -10", "A1:A2 <= 10"], "method": "evolutionary"});
-        let r = s.execute("data.solver", p.clone()).unwrap();
-        assert!(r["status"] == "converged" || r["status"] == "cannotImprove", "{r}");
-        assert!((n(&s, "A1") - 3.0).abs() < 1e-6 && (n(&s, "A2") + 2.0).abs() < 1e-6, "{r}");
-        // The same seed repeats the run exactly.
-        set(&mut s, &[("A1", "0"), ("A2", "0")]);
-        let again = s.execute("data.solver", p).unwrap();
-        assert_eq!(again["values"], r["values"]);
-        assert_eq!(again["evaluations"], r["evaluations"]);
-        // Rastrigin's function 20 + Σ (x² − 10 cos 2πx) on [−5.12, 5.12]² has its global minimum 0
-        // at the origin among many local minima; GRG from (3.3, −2.7) stops at a local one.
-        set(&mut s, &[("C1", "3.3"), ("C2", "-2.7"), ("D1", "=20+C1^2-10*COS(2*PI()*C1)+C2^2-10*COS(2*PI()*C2)")]);
-        let base = json!({"objective": "D1", "goal": "min", "variables": "C1:C2", "constraints": ["C1:C2 >= -5.12", "C1:C2 <= 5.12"]});
-        s.execute("data.solver", base.clone()).unwrap();
-        assert!(n(&s, "D1") > 0.5, "GRG is local: {}", n(&s, "D1"));
-        set(&mut s, &[("C1", "3.3"), ("C2", "-2.7")]);
-        let mut p = base.clone();
-        p["method"] = json!("evolutionary");
-        let r = s.execute("data.solver", p).unwrap();
-        assert!(n(&s, "D1") < 1e-8 && n(&s, "C1").abs() < 1e-5 && n(&s, "C2").abs() < 1e-5, "{r}");
-        // A stepped model: ROUND makes it flat almost everywhere; the minimum is at 7.2.
-        set(&mut s, &[("E1", "0"), ("F1", "=ABS(ROUND(E1,0)-7)+ABS(E1-7.2)/100")]);
-        s.execute("data.solver", json!({"objective": "F1", "goal": "min", "variables": "E1", "constraints": ["E1 <= 20"], "method": "evolutionary"}))
-            .unwrap();
-        assert!((n(&s, "E1") - 7.2).abs() < 1e-6, "{}", n(&s, "E1"));
-    }
-
-    #[test]
-    fn evolutionary_handles_integers_bounds_and_the_saved_model() {
-        let mut s = s();
-        // The 0/1 knapsack of the branch-and-bound test: items 2 and 3, value 20.
-        set(&mut s, &[("D1", "=10*C1+13*C2+7*C3"), ("D2", "=5*C1+6*C2+4*C3")]);
-        let p = json!({"objective": "D1", "variables": "C1:C3", "constraints": ["D2 <= 10", "C1:C3 bin"], "method": "evolutionary", "populationSize": 30, "randomSeed": 7});
-        let r = s.execute("data.solver", p).unwrap();
-        assert!(r["status"] == "converged" || r["status"] == "cannotImprove", "{r}");
-        assert_eq!((n(&s, "C1"), n(&s, "C2"), n(&s, "C3"), n(&s, "D1")), (0.0, 1.0, 1.0, 20.0));
-        // The method and its options are saved, survive XLSX and solve again.
-        let b64 = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap()["base64"].as_str().unwrap().to_string();
-        s.execute("file.open", json!({"name": "e.xlsx", "base64": b64})).unwrap();
-        let m = s.execute("data.solver", json!({})).unwrap();
-        assert_eq!(m["model"]["method"], "evolutionary");
-        assert_eq!((m["model"]["populationSize"].as_f64(), m["model"]["randomSeed"].as_f64()), (Some(30.0), Some(7.0)));
-        set(&mut s, &[("C1", "0"), ("C2", "0"), ("C3", "0")]);
-        s.execute("data.solver", json!({"saved": true})).unwrap();
-        assert_eq!(n(&s, "D1"), 20.0);
-        // Integer constraints: max x + y with x + 2y ≤ 7 on integers in [0, 10] → (7, 0).
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=A1+A2"), ("B2", "=A1+2*A2")]);
-        let r = s
-            .execute(
-                "data.solver",
-                json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 7", "A1:A2 <= 10", "A1:A2 int"], "method": "evolutionary"}),
-            )
-            .unwrap();
-        assert_eq!((n(&s, "A1"), n(&s, "A2")), (7.0, 0.0), "{r}");
-        // Every variable needs bounds unless requireBounds is off; then it searches around the start.
-        set(&mut s, &[("E1", "1"), ("F1", "=ABS(E1-4)")]);
-        let p = json!({"objective": "F1", "goal": "min", "variables": "E1", "method": "evolutionary"});
-        assert!(s.execute("data.solver", p.clone()).is_err());
-        let mut p = p;
-        p["requireBounds"] = json!(false);
-        s.execute("data.solver", p).unwrap();
-        assert!((n(&s, "E1") - 4.0).abs() < 1e-6);
-        // Infeasible constraints and a tiny budget are reported without changing the cells.
-        set(&mut s, &[("E1", "1")]);
-        let r = s
-            .execute("data.solver", json!({"objective": "F1", "variables": "E1", "constraints": ["E1 <= 3", "F1 >= 10"], "method": "evolutionary"}))
-            .unwrap();
-        assert_eq!(r["status"], "infeasible", "{r}");
-        let r = s
-            .execute(
-                "data.solver",
-                json!({"objective": "F1", "variables": "E1", "constraints": ["E1 <= 3"], "method": "evolutionary", "maxEvaluations": 3}),
-            )
-            .unwrap();
-        assert_eq!(r["status"], "iterationLimit", "{r}");
-        assert_eq!(n(&s, "E1"), 1.0);
-    }
-
-    /// Text or number at `a1` on sheet `name`.
-    fn at(s: &Session, name: &str, a1: &str) -> Value {
-        let d = s.doc().unwrap();
-        d.wb.sheet(d.wb.sheet_index(name).unwrap()).unwrap().value(CellRef::parse(a1).unwrap())
-    }
-
-    /// The row of the first cell holding `text` on sheet `name`.
-    fn row_of(s: &Session, name: &str, text: &str) -> u32 {
-        let d = s.doc().unwrap();
-        let sh = d.wb.sheet(d.wb.sheet_index(name).unwrap()).unwrap();
-        (0..60).find(|r| (0..8).any(|c| sh.value(CellRef::new(*r, c)) == Value::text(text))).unwrap()
-    }
-
-    #[test]
-    fn answer_and_limits_reports_describe_the_wyndor_glass_solution() {
-        // Wyndor Glass with labels: doors and windows across, the three plants' hours down.
-        let mut s = s();
-        s.execute(
-            "range.setValues",
-            json!({"range": "A1", "values": [[null, "Doors", "Windows", "Used", "Available"], ["Batches", 0, 0, null, null], ["Plant 1", 1, 0, null, 4], ["Plant 2", 0, 2, null, 12], ["Plant 3", 3, 2, null, 18], ["Profit", 3, 5, null, null]]}),
-        )
-        .unwrap();
-        for r in 3..=6 {
-            set(&mut s, &[(&format!("D{r}"), &format!("=SUMPRODUCT(B{r}:C{r},$B$2:$C$2)"))]);
-        }
-        let solved = s
-            .execute(
-                "data.solver",
-                json!({"objective": "D6", "variables": "B2:C2", "constraints": ["D3:D5 <= E3:E5"], "method": "simplex", "reports": ["answer", "limits"]}),
-            )
-            .unwrap();
-        assert_eq!(solved["status"], "optimal", "{solved}");
-        assert_eq!(solved["reports"], json!(["Answer Report 1", "Limits Report 1"]));
-        assert_eq!(solved["original"], json!({"B2": 0.0, "C2": 0.0}));
-        let d = s.doc().unwrap();
-        let names: Vec<&str> = d.wb.sheets.iter().map(|x| x.name.as_str()).collect();
-        assert_eq!(names, ["Answer Report 1", "Limits Report 1", "Sheet1"]);
-        assert_eq!(d.wb.active().unwrap().name, "Sheet1", "the model's sheet stays active");
-        assert_eq!(saved(&s), "solver_opt", "the saved model follows its sheet");
-        let a = "Answer Report 1";
-        assert_eq!(at(&s, a, "A1"), Value::text("GridCraft Answer Report"));
-        // Objective: $D$6 "Profit Used", from 0 to 36.
-        let r = row_of(&s, a, "$D$6");
-        assert_eq!(at(&s, a, &format!("C{}", r + 1)), Value::text("Profit Used"));
-        assert_eq!((at(&s, a, &format!("D{}", r + 1)), at(&s, a, &format!("E{}", r + 1))), (Value::number(0.0), Value::number(36.0)));
-        // Variables: doors 0 → 2, windows 0 → 6, continuous.
-        let r = row_of(&s, a, "$B$2") + 1;
-        assert_eq!(at(&s, a, &format!("C{r}")), Value::text("Batches Doors"));
-        assert_eq!(at(&s, a, &format!("E{r}")), Value::number(2.0));
-        assert_eq!(at(&s, a, &format!("F{r}")), Value::text("Contin"));
-        assert_eq!(at(&s, a, &format!("E{}", r + 1)), Value::number(6.0));
-        // Constraints: plant 1 has 2 hours to spare; plants 2 and 3 are binding.
-        let r = row_of(&s, a, "$D$3") + 1;
-        assert_eq!(at(&s, a, &format!("E{r}")), Value::text("$D$3<=$E$3"));
-        assert_eq!((at(&s, a, &format!("F{r}")), at(&s, a, &format!("G{r}"))), (Value::text("Not Binding"), Value::number(2.0)));
-        for k in 1..=2 {
-            assert_eq!((at(&s, a, &format!("F{}", r + k)), at(&s, a, &format!("G{}", r + k))), (Value::text("Binding"), Value::number(0.0)));
-        }
-        // Limits with the other variable held: doors 0..2 (profit 30..36), windows 0..6 (6..36).
-        let l = "Limits Report 1";
-        let r = row_of(&s, l, "$B$2") + 1;
-        let row = |r: u32| ["D", "E", "F", "G", "H"].map(|c| at(&s, l, &format!("{c}{r}")).as_f64().unwrap());
-        assert_eq!(row(r), [2.0, 0.0, 30.0, 2.0, 36.0]);
-        assert_eq!(row(r + 1), [6.0, 0.0, 6.0, 6.0, 36.0]);
-        // data.solverReport writes reports from the saved model and a given solution.
-        let out =
-            s.execute("data.solverReport", json!({"reports": ["answer"], "values": {"B2": 2, "C2": 6}, "original": {"B2": 1, "C2": 1}})).unwrap();
-        assert_eq!(out["sheets"], json!(["Answer Report 2"]));
-        let r = row_of(&s, "Answer Report 2", "$D$6") + 1;
-        assert_eq!(at(&s, "Answer Report 2", &format!("D{r}")), Value::number(8.0));
-        // Undo removes the reports and keeps the solution; refused requests write nothing.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 3);
-        for p in [
-            json!({}),
-            json!({"reports": []}),
-            json!({"reports": "answer"}),
-            json!({"reports": ["population"]}),
-            json!({"reports": ["answer"], "values": {"Z9": 1}}),
-            json!({"reports": ["answer"], "values": {"B2": "x"}}),
-            json!({"reports": ["limits"], "constraints": ["D3:D5 <= E3:E5", "B2:C2 int"]}),
-            json!({"reports": ["limits"], "method": "evolutionary", "constraints": ["D3:D5 <= E3:E5", "B2:C2 <= 10"]}),
-        ] {
-            assert!(s.execute("data.solverReport", p.clone()).is_err(), "{p}");
-        }
-        assert_eq!(s.doc().unwrap().wb.sheets.len(), 3);
-        // With the solve, its reports and the saved model undone (one step), the result still
-        // describes the solution.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!((s.doc().unwrap().wb.sheets.len(), n(&s, "B2")), (1, 0.0));
-        let mut p = solved.clone();
-        p["reports"] = json!(["answer"]);
-        assert_eq!(s.execute("data.solverReport", p).unwrap()["sheets"], json!(["Answer Report 1"]));
-        let r = row_of(&s, "Answer Report 1", "$B$2") + 1;
-        assert_eq!(at(&s, "Answer Report 1", &format!("E{r}")), Value::number(2.0));
-    }
-
-    #[test]
-    fn refused_solver_reports_preserve_the_document_and_history() {
-        for (protected, method, constraints, reports, error) in [
-            (true, "simplex", json!(["A1 <= 4"]), json!(["answer"]), "workbook is protected"),
-            (false, "simplex", json!(["A1 <= 4", "A1 int"]), json!(["answer", "limits"]), "integer or binary"),
-            (false, "evolutionary", json!(["A1 <= 4"]), json!(["answer", "limits"]), "Simplex LP and GRG"),
-        ] {
-            for (keep, save) in [(true, true), (false, true), (true, false), (false, false)] {
-                let mut s = s();
-                set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
-                s.execute(
-                    "data.solver",
-                    json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 2"], "method": "simplex", "keep": false}),
-                )
-                .unwrap();
-                set(&mut s, &[("C1", "redo")]);
-                s.execute("edit.undo", json!({})).unwrap();
-                let d = s.doc_mut().unwrap();
-                std::sync::Arc::make_mut(&mut d.wb).protected_structure = protected;
-                d.saved = d.wb.clone();
-                let before = d.clone();
-                let journal = s.journal.clone();
-                let err = s
-                    .execute(
-                        "data.solver",
-                        json!({"objective": "B1", "variables": "A1", "constraints": constraints, "method": method,
-                            "reports": reports, "keep": keep, "saveModel": save}),
-                    )
-                    .unwrap_err();
-                assert!(err.to_string().contains(error), "{err}");
-                let d = s.doc().unwrap();
-                assert!(std::sync::Arc::ptr_eq(&d.wb, &before.wb), "{method}: keep={keep}, save={save}: {err}");
-                assert!(!d.is_dirty());
-                assert_eq!(d.revision, before.revision);
-                assert_eq!(d.selection, before.selection);
-                assert_eq!(d.sheet_selections, before.sheet_selections);
-                for (after, before) in [(&d.undo, &before.undo), (&d.redo, &before.redo)] {
-                    assert_eq!(after.len(), before.len());
-                    for (a, b) in after.iter().zip(before) {
-                        assert!(std::sync::Arc::ptr_eq(&a.wb, &b.wb));
-                        assert_eq!((&a.label, &a.selection), (&b.label, &b.selection));
-                    }
-                }
-                assert_eq!(s.journal, journal);
-            }
-        }
-    }
-
-    #[test]
-    fn solver_reports_and_optional_solution_and_model_share_one_undo() {
-        for (keep, save) in [(true, true), (false, true), (true, false), (false, false)] {
-            let mut s = s();
-            set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
-            let before = s.doc().unwrap().clone();
-            let out = s
-                .execute(
-                    "data.solver",
-                    json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 4"], "method": "simplex",
-                        "reports": ["answer"], "keep": keep, "saveModel": save}),
-                )
-                .unwrap();
-            assert_eq!(out["status"], "optimal");
-            assert_eq!(out["reports"], json!(["Answer Report 1"]));
-            assert_eq!(out["model"]["objective"], "Sheet1!B1");
-            assert_eq!(n(&s, "A1"), if keep { 4.0 } else { 1.0 });
-            assert_eq!(saved(&s), if save { "solver_opt" } else { "" });
-            assert_eq!(s.doc().unwrap().undo.len(), before.undo.len() + 1);
-            assert_eq!(s.doc().unwrap().wb.active().unwrap().name, "Sheet1");
-            let r = row_of(&s, "Answer Report 1", "$A$1") + 1;
-            assert_eq!(at(&s, "Answer Report 1", &format!("E{r}")), Value::number(4.0));
-            s.execute("edit.undo", json!({})).unwrap();
-            assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before.wb));
-            s.execute("edit.redo", json!({})).unwrap();
-            assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
-            assert_eq!(n(&s, "A1"), if keep { 4.0 } else { 1.0 });
-        }
-    }
-
-    #[test]
-    fn solver_reports_keep_row_autofit_on_the_model_sheet() {
-        let mut s = s();
-        set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
-        s.execute("home.columnWidth", json!({"cols": "A:A", "width": 30})).unwrap();
-        s.execute("home.wrapText", json!({"range": "A1", "on": true})).unwrap();
-        let before = s.doc().unwrap().wb.active().unwrap().row_height(0);
-        s.execute(
-            "data.solver",
-            json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 1000000"], "method": "simplex", "reports": ["answer"]}),
-        )
-        .unwrap();
-        let sh = s.doc().unwrap().wb.active().unwrap();
-        assert_eq!(sh.name, "Sheet1");
-        assert_eq!(sh.value(CellRef::new(0, 0)), Value::number(1_000_000.0));
-        assert!(sh.row_height(0) > before, "the solved wrapped number must re-fit its row after the report shifts its sheet");
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(s.doc().unwrap().wb.active().unwrap().row_height(0), before);
-    }
-
-    #[test]
-    fn solver_report_insertion_keeps_variable_edit_guards() {
-        for array in [false, true] {
-            let mut s = s();
-            set(&mut s, &[("A2", "1"), ("B1", "=2*A2")]);
-            let error = if array {
-                s.execute("selection.set", json!({"range": "A1:A2"})).unwrap();
-                s.execute("cell.set", json!({"input": "=1", "array": true})).unwrap();
-                "part of an array"
-            } else {
-                s.execute("review.protectSheet", json!({})).unwrap();
-                "protected sheet"
-            };
-            let before = s.doc().unwrap().clone();
-            let err = s
-                .execute(
-                    "data.solver",
-                    json!({"objective": "B1", "variables": "A2", "constraints": ["A2 <= 4"], "method": "simplex", "reports": ["answer"]}),
-                )
-                .unwrap_err();
-            assert!(err.to_string().contains(error), "{err}");
-            let d = s.doc().unwrap();
-            assert!(std::sync::Arc::ptr_eq(&d.wb, &before.wb));
-            assert_eq!(d.undo.len(), before.undo.len());
-            assert_eq!(d.sheet_selections, before.sheet_selections);
-        }
-    }
-
-    #[test]
-    fn limits_report_of_a_nonlinear_model() {
-        // The largest rectangle with perimeter at most 20 (5 × 5): with the height held at 5, the
-        // width ranges over 0..5, the area over 0..25.
-        let mut s = s();
-        set(&mut s, &[("A1", "1"), ("A2", "1"), ("B1", "=A1*A2"), ("B2", "=2*A1+2*A2")]);
-        let r =
-            s.execute("data.solver", json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 20"], "reports": ["limits"]})).unwrap();
-        assert_eq!(r["reports"], json!(["Limits Report 1"]), "{r}");
-        let l = "Limits Report 1";
-        let r = row_of(&s, l, "$A$1") + 1;
-        let got: Vec<f64> = ["E", "F", "G", "H"].iter().map(|c| at(&s, l, &format!("{c}{r}")).as_f64().unwrap()).collect();
-        for (g, want) in got.iter().zip([0.0, 0.0, 5.0, 25.0]) {
-            assert!((g - want).abs() < 1e-3, "{got:?}");
-        }
-    }
-
-    #[test]
-    fn infeasible_unbounded_and_nonlinear_models_are_reported() {
-        let mut s = s();
-        set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
-        for method in ["simplex", "grg"] {
-            let r = s
-                .execute("data.solver", json!({"objective": "B1", "variables": "A1", "constraints": ["A1 >= 5", "B1 <= 6"], "method": method}))
-                .unwrap();
-            assert_eq!(r["status"], "infeasible", "{method}: {r}");
-            assert_eq!(r["changed"], false);
-            assert_eq!(n(&s, "A1"), 1.0, "an infeasible model leaves the cells alone");
-        }
-        let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1", "method": "simplex"})).unwrap();
-        assert_eq!(r["status"], "unbounded");
-        let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1", "method": "grg", "maxEvaluations": 5000})).unwrap();
-        assert!(r["status"] == "unbounded" || r["status"] == "iterationLimit", "{r}");
-        set(&mut s, &[("A1", "1"), ("C1", "=A1^2")]);
-        let r = s.execute("data.solver", json!({"objective": "C1", "goal": "min", "variables": "A1", "method": "simplex"})).unwrap();
-        assert_eq!(r["status"], "notLinear");
-    }
-
-    #[test]
-    fn hostile_models_are_refused_without_panicking() {
-        let mut s = s();
-        let r = s.execute("data.solver", json!({})).unwrap();
-        assert!(r["model"].is_null());
-        assert!(s.take_ui_requests().iter().any(|q| matches!(q, crate::UiRequest::Dialog(n, _) if n == "solver")));
-        set(&mut s, &[("B1", "=SUM(A1:A1000)"), ("C1", "5")]);
-        for p in [
-            json!({"objective": "B1", "variables": "A1:A1000"}),
-            json!({"objective": "B1", "variables": "A1:XFD1048576"}),
-            json!({"objective": "C1", "variables": "A1"}),
-            json!({"objective": "B1:B2", "variables": "A1"}),
-            json!({"objective": "B1", "variables": "B1"}),
-            json!({"objective": "B1", "variables": "A1", "goal": "sideways"}),
-            json!({"objective": "B1", "variables": "A1", "goal": "value"}),
-            json!({"objective": "B1", "variables": "A1", "method": "evolutionary"}),
-            json!({"objective": "B1", "variables": "A1", "method": "annealing"}),
-            json!({"objective": "B1", "variables": "A1", "constraints": ["A1 ?? 3"]}),
-            json!({"objective": "B1", "variables": "A1", "constraints": "A1 <= 3"}),
-            json!({"objective": "B1", "variables": "A1", "constraints": ["A1:A3 <= C1:C2"]}),
-            json!({"objective": "B1", "variables": "A1", "constraints": ["C1 int"]}),
-            json!({"objective": "B1", "variables": "A1", "constraints": ["A1:A1048576 <= 1"]}),
-            json!({"objective": "B1", "variables": "A1", "constraints": vec![json!("A1 <= 1"); 1001]}),
-            json!({"objective": "Nope!B1", "variables": "A1"}),
-        ] {
-            assert!(s.execute("data.solver", p.clone()).is_err(), "{p}");
-        }
-        // Huge evaluation requests are capped, and a model erroring everywhere doesn't panic.
-        set(&mut s, &[("D1", "=1/0+A1")]);
-        let r = s.execute("data.solver", json!({"objective": "D1", "variables": "A1", "maxEvaluations": 1e300})).unwrap();
-        assert_ne!(r["status"], "converged");
-    }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/solver/tests.rs b/crates/engine/src/cmd/solver/tests.rs
new file mode 100644
index 000000000..bac1328b7
--- /dev/null
+++ b/crates/engine/src/cmd/solver/tests.rs
@@ -0,0 +1,477 @@
+use gridcraft_core::{CellRef, Value};
+use serde_json::json;
+
+use crate::Session;
+
+fn s() -> Session {
+    let mut s = Session::new();
+    s.new_workbook();
+    s
+}
+fn n(s: &Session, a: &str) -> f64 {
+    let d = s.doc().unwrap();
+    d.wb.active().unwrap().value(CellRef::parse(a).unwrap()).as_f64().unwrap_or(f64::NAN)
+}
+/// The first saved-model name scoped to the active sheet.
+fn saved(s: &Session) -> String {
+    let d = s.doc().unwrap();
+    d.wb.names.iter().find(|n| n.scope == Some(d.wb.active_sheet())).map(|n| n.name.clone()).unwrap_or_default()
+}
+fn set(s: &mut Session, cells: &[(&str, &str)]) {
+    for (c, v) in cells {
+        s.execute("cell.set", json!({"cell": c, "input": v})).unwrap();
+    }
+}
+
+#[test]
+fn simplex_solves_the_wyndor_glass_lp() {
+    // Hillier & Lieberman's Wyndor Glass problem: max 3x + 5y, x ≤ 4, 2y ≤ 12, 3x + 2y ≤ 18
+    // → x = 2, y = 6, Z = 36.
+    let mut s = s();
+    set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=3*A1+5*A2"), ("B2", "=2*A2"), ("B3", "=3*A1+2*A2")]);
+    let r = s
+        .execute(
+            "data.solver",
+            json!({"objective": "B1", "goal": "max", "variables": "A1:A2", "constraints": ["A1 <= 4", "B2 <= 12", {"lhs": "B3", "op": "<=", "rhs": 18}], "method": "simplex"}),
+        )
+        .unwrap();
+    assert_eq!(r["status"], "optimal", "{r}");
+    assert!((n(&s, "A1") - 2.0).abs() < 1e-9 && (n(&s, "A2") - 6.0).abs() < 1e-9);
+    assert!((n(&s, "B1") - 36.0).abs() < 1e-9);
+    // The model is saved as hidden names, survives XLSX and solves again from them.
+    let names: Vec<String> = s.doc().unwrap().wb.names.iter().map(|n| n.name.clone()).collect();
+    assert!(names.iter().any(|n| n == "solver_opt") && names.iter().any(|n| n == "solver_lhs3"));
+    let b64 = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap()["base64"].as_str().unwrap().to_string();
+    s.execute("file.open", json!({"name": "m.xlsx", "base64": b64})).unwrap();
+    set(&mut s, &[("A1", "0"), ("A2", "0")]);
+    let m = s.execute("data.solver", json!({})).unwrap();
+    assert_eq!(m["model"]["objective"], "B1");
+    assert_eq!(m["model"]["method"], "simplex");
+    let r = s.execute("data.solver", json!({"saved": true})).unwrap();
+    assert_eq!(r["status"], "optimal");
+    assert!((n(&s, "B1") - 36.0).abs() < 1e-9);
+    // Minimise with keep: false leaves the cells alone.
+    set(&mut s, &[("A1", "1"), ("A2", "1")]);
+    let r = s.execute("data.solver", json!({"saved": true, "goal": "min", "keep": false})).unwrap();
+    assert_eq!(r["objective"], 0.0);
+    assert_eq!((n(&s, "A1"), n(&s, "A2")), (1.0, 1.0));
+}
+
+#[test]
+fn integer_and_binary_constraints_use_branch_and_bound() {
+    // max 5x + 4y, 6x + 4y ≤ 24, x + 2y ≤ 6: the LP optimum (3, 1.5) = 21; integers give
+    // (4, 0) = 20.
+    let mut s = s();
+    set(&mut s, &[("B1", "=5*A1+4*A2"), ("B2", "=6*A1+4*A2"), ("B3", "=A1+2*A2")]);
+    let base = json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 24", "B3 <= 6"], "method": "simplex"});
+    let r = s.execute("data.solver", base.clone()).unwrap();
+    assert!((r["objective"].as_f64().unwrap() - 21.0).abs() < 1e-9);
+    let mut p = base.clone();
+    p["constraints"].as_array_mut().unwrap().push(json!("A1:A2 int"));
+    let r = s.execute("data.solver", p).unwrap();
+    assert_eq!(r["status"], "optimal");
+    assert_eq!((n(&s, "A1"), n(&s, "A2"), n(&s, "B1")), (4.0, 0.0, 20.0));
+    // 0/1 knapsack: values 10, 13, 7, weights 5, 6, 4, capacity 10 → items 2 and 3 (20).
+    set(&mut s, &[("D1", "=10*C1+13*C2+7*C3"), ("D2", "=5*C1+6*C2+4*C3")]);
+    let r = s
+        .execute("data.solver", json!({"objective": "D1", "variables": "C1:C3", "constraints": ["D2 <= 10", "C1:C3 bin"], "method": "simplex"}))
+        .unwrap();
+    assert_eq!(r["status"], "optimal");
+    assert_eq!((n(&s, "C1"), n(&s, "C2"), n(&s, "C3"), n(&s, "D1")), (0.0, 1.0, 1.0, 20.0));
+}
+
+#[test]
+fn grg_finds_smooth_optima() {
+    // Largest rectangle with perimeter at most 20: a 5 × 5 square, area 25.
+    let mut s = s();
+    set(&mut s, &[("A1", "1"), ("A2", "1"), ("B1", "=A1*A2"), ("B2", "=2*A1+2*A2")]);
+    let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 20"]})).unwrap();
+    assert_eq!(r["status"], "converged", "{r}");
+    assert!((n(&s, "A1") - 5.0).abs() < 1e-3 && (n(&s, "A2") - 5.0).abs() < 1e-3, "{r}");
+    // Unconstrained minimum of (x − 3)² + (y + 1)² at (3, −1) once negatives are allowed.
+    set(&mut s, &[("C1", "0"), ("C2", "0"), ("D1", "=(C1-3)^2+(C2+1)^2")]);
+    s.execute("data.solver", json!({"objective": "D1", "goal": "min", "variables": "C1:C2", "nonNegative": false})).unwrap();
+    assert!((n(&s, "C1") - 3.0).abs() < 1e-4 && (n(&s, "C2") + 1.0).abs() < 1e-4);
+    // Value Of: x³ = 8 → x = 2.
+    set(&mut s, &[("E1", "1"), ("F1", "=E1^3")]);
+    s.execute("data.solver", json!({"objective": "F1", "goal": "value", "value": 8, "variables": "E1"})).unwrap();
+    assert!((n(&s, "E1") - 2.0).abs() < 1e-4);
+}
+
+#[test]
+fn evolutionary_finds_the_global_minimum_of_non_smooth_and_multimodal_models() {
+    let mut s = s();
+    // |x − 3| + |y + 2| has a kink at its minimum (3, −2).
+    set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=ABS(A1-3)+ABS(A2+2)")]);
+    let p =
+        json!({"objective": "B1", "goal": "min", "variables": "A1:A2", "constraints": ["A1:A2 >= -10", "A1:A2 <= 10"], "method": "evolutionary"});
+    let r = s.execute("data.solver", p.clone()).unwrap();
+    assert!(r["status"] == "converged" || r["status"] == "cannotImprove", "{r}");
+    assert!((n(&s, "A1") - 3.0).abs() < 1e-6 && (n(&s, "A2") + 2.0).abs() < 1e-6, "{r}");
+    // The same seed repeats the run exactly.
+    set(&mut s, &[("A1", "0"), ("A2", "0")]);
+    let again = s.execute("data.solver", p).unwrap();
+    assert_eq!(again["values"], r["values"]);
+    assert_eq!(again["evaluations"], r["evaluations"]);
+    // Rastrigin's function 20 + Σ (x² − 10 cos 2πx) on [−5.12, 5.12]² has its global minimum 0
+    // at the origin among many local minima; GRG from (3.3, −2.7) stops at a local one.
+    set(&mut s, &[("C1", "3.3"), ("C2", "-2.7"), ("D1", "=20+C1^2-10*COS(2*PI()*C1)+C2^2-10*COS(2*PI()*C2)")]);
+    let base = json!({"objective": "D1", "goal": "min", "variables": "C1:C2", "constraints": ["C1:C2 >= -5.12", "C1:C2 <= 5.12"]});
+    s.execute("data.solver", base.clone()).unwrap();
+    assert!(n(&s, "D1") > 0.5, "GRG is local: {}", n(&s, "D1"));
+    set(&mut s, &[("C1", "3.3"), ("C2", "-2.7")]);
+    let mut p = base.clone();
+    p["method"] = json!("evolutionary");
+    let r = s.execute("data.solver", p).unwrap();
+    assert!(n(&s, "D1") < 1e-8 && n(&s, "C1").abs() < 1e-5 && n(&s, "C2").abs() < 1e-5, "{r}");
+    // A stepped model: ROUND makes it flat almost everywhere; the minimum is at 7.2.
+    set(&mut s, &[("E1", "0"), ("F1", "=ABS(ROUND(E1,0)-7)+ABS(E1-7.2)/100")]);
+    s.execute("data.solver", json!({"objective": "F1", "goal": "min", "variables": "E1", "constraints": ["E1 <= 20"], "method": "evolutionary"}))
+        .unwrap();
+    assert!((n(&s, "E1") - 7.2).abs() < 1e-6, "{}", n(&s, "E1"));
+}
+
+#[test]
+fn evolutionary_handles_integers_bounds_and_the_saved_model() {
+    let mut s = s();
+    // The 0/1 knapsack of the branch-and-bound test: items 2 and 3, value 20.
+    set(&mut s, &[("D1", "=10*C1+13*C2+7*C3"), ("D2", "=5*C1+6*C2+4*C3")]);
+    let p = json!({"objective": "D1", "variables": "C1:C3", "constraints": ["D2 <= 10", "C1:C3 bin"], "method": "evolutionary", "populationSize": 30, "randomSeed": 7});
+    let r = s.execute("data.solver", p).unwrap();
+    assert!(r["status"] == "converged" || r["status"] == "cannotImprove", "{r}");
+    assert_eq!((n(&s, "C1"), n(&s, "C2"), n(&s, "C3"), n(&s, "D1")), (0.0, 1.0, 1.0, 20.0));
+    // The method and its options are saved, survive XLSX and solve again.
+    let b64 = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap()["base64"].as_str().unwrap().to_string();
+    s.execute("file.open", json!({"name": "e.xlsx", "base64": b64})).unwrap();
+    let m = s.execute("data.solver", json!({})).unwrap();
+    assert_eq!(m["model"]["method"], "evolutionary");
+    assert_eq!((m["model"]["populationSize"].as_f64(), m["model"]["randomSeed"].as_f64()), (Some(30.0), Some(7.0)));
+    set(&mut s, &[("C1", "0"), ("C2", "0"), ("C3", "0")]);
+    s.execute("data.solver", json!({"saved": true})).unwrap();
+    assert_eq!(n(&s, "D1"), 20.0);
+    // Integer constraints: max x + y with x + 2y ≤ 7 on integers in [0, 10] → (7, 0).
+    set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=A1+A2"), ("B2", "=A1+2*A2")]);
+    let r = s
+        .execute(
+            "data.solver",
+            json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 7", "A1:A2 <= 10", "A1:A2 int"], "method": "evolutionary"}),
+        )
+        .unwrap();
+    assert_eq!((n(&s, "A1"), n(&s, "A2")), (7.0, 0.0), "{r}");
+    // Every variable needs bounds unless requireBounds is off; then it searches around the start.
+    set(&mut s, &[("E1", "1"), ("F1", "=ABS(E1-4)")]);
+    let p = json!({"objective": "F1", "goal": "min", "variables": "E1", "method": "evolutionary"});
+    assert!(s.execute("data.solver", p.clone()).is_err());
+    let mut p = p;
+    p["requireBounds"] = json!(false);
+    s.execute("data.solver", p).unwrap();
+    assert!((n(&s, "E1") - 4.0).abs() < 1e-6);
+    // Infeasible constraints and a tiny budget are reported without changing the cells.
+    set(&mut s, &[("E1", "1")]);
+    let r = s
+        .execute("data.solver", json!({"objective": "F1", "variables": "E1", "constraints": ["E1 <= 3", "F1 >= 10"], "method": "evolutionary"}))
+        .unwrap();
+    assert_eq!(r["status"], "infeasible", "{r}");
+    let r = s
+        .execute(
+            "data.solver",
+            json!({"objective": "F1", "variables": "E1", "constraints": ["E1 <= 3"], "method": "evolutionary", "maxEvaluations": 3}),
+        )
+        .unwrap();
+    assert_eq!(r["status"], "iterationLimit", "{r}");
+    assert_eq!(n(&s, "E1"), 1.0);
+}
+
+/// Text or number at `a1` on sheet `name`.
+fn at(s: &Session, name: &str, a1: &str) -> Value {
+    let d = s.doc().unwrap();
+    d.wb.sheet(d.wb.sheet_index(name).unwrap()).unwrap().value(CellRef::parse(a1).unwrap())
+}
+
+/// The row of the first cell holding `text` on sheet `name`.
+fn row_of(s: &Session, name: &str, text: &str) -> u32 {
+    let d = s.doc().unwrap();
+    let sh = d.wb.sheet(d.wb.sheet_index(name).unwrap()).unwrap();
+    (0..60).find(|r| (0..8).any(|c| sh.value(CellRef::new(*r, c)) == Value::text(text))).unwrap()
+}
+
+#[test]
+fn answer_and_limits_reports_describe_the_wyndor_glass_solution() {
+    // Wyndor Glass with labels: doors and windows across, the three plants' hours down.
+    let mut s = s();
+    s.execute(
+        "range.setValues",
+        json!({"range": "A1", "values": [[null, "Doors", "Windows", "Used", "Available"], ["Batches", 0, 0, null, null], ["Plant 1", 1, 0, null, 4], ["Plant 2", 0, 2, null, 12], ["Plant 3", 3, 2, null, 18], ["Profit", 3, 5, null, null]]}),
+    )
+    .unwrap();
+    for r in 3..=6 {
+        set(&mut s, &[(&format!("D{r}"), &format!("=SUMPRODUCT(B{r}:C{r},$B$2:$C$2)"))]);
+    }
+    let solved = s
+        .execute(
+            "data.solver",
+            json!({"objective": "D6", "variables": "B2:C2", "constraints": ["D3:D5 <= E3:E5"], "method": "simplex", "reports": ["answer", "limits"]}),
+        )
+        .unwrap();
+    assert_eq!(solved["status"], "optimal", "{solved}");
+    assert_eq!(solved["reports"], json!(["Answer Report 1", "Limits Report 1"]));
+    assert_eq!(solved["original"], json!({"B2": 0.0, "C2": 0.0}));
+    let d = s.doc().unwrap();
+    let names: Vec<&str> = d.wb.sheets.iter().map(|x| x.name.as_str()).collect();
+    assert_eq!(names, ["Answer Report 1", "Limits Report 1", "Sheet1"]);
+    assert_eq!(d.wb.active().unwrap().name, "Sheet1", "the model's sheet stays active");
+    assert_eq!(saved(&s), "solver_opt", "the saved model follows its sheet");
+    let a = "Answer Report 1";
+    assert_eq!(at(&s, a, "A1"), Value::text("GridCraft Answer Report"));
+    // Objective: $D$6 "Profit Used", from 0 to 36.
+    let r = row_of(&s, a, "$D$6");
+    assert_eq!(at(&s, a, &format!("C{}", r + 1)), Value::text("Profit Used"));
+    assert_eq!((at(&s, a, &format!("D{}", r + 1)), at(&s, a, &format!("E{}", r + 1))), (Value::number(0.0), Value::number(36.0)));
+    // Variables: doors 0 → 2, windows 0 → 6, continuous.
+    let r = row_of(&s, a, "$B$2") + 1;
+    assert_eq!(at(&s, a, &format!("C{r}")), Value::text("Batches Doors"));
+    assert_eq!(at(&s, a, &format!("E{r}")), Value::number(2.0));
+    assert_eq!(at(&s, a, &format!("F{r}")), Value::text("Contin"));
+    assert_eq!(at(&s, a, &format!("E{}", r + 1)), Value::number(6.0));
+    // Constraints: plant 1 has 2 hours to spare; plants 2 and 3 are binding.
+    let r = row_of(&s, a, "$D$3") + 1;
+    assert_eq!(at(&s, a, &format!("E{r}")), Value::text("$D$3<=$E$3"));
+    assert_eq!((at(&s, a, &format!("F{r}")), at(&s, a, &format!("G{r}"))), (Value::text("Not Binding"), Value::number(2.0)));
+    for k in 1..=2 {
+        assert_eq!((at(&s, a, &format!("F{}", r + k)), at(&s, a, &format!("G{}", r + k))), (Value::text("Binding"), Value::number(0.0)));
+    }
+    // Limits with the other variable held: doors 0..2 (profit 30..36), windows 0..6 (6..36).
+    let l = "Limits Report 1";
+    let r = row_of(&s, l, "$B$2") + 1;
+    let row = |r: u32| ["D", "E", "F", "G", "H"].map(|c| at(&s, l, &format!("{c}{r}")).as_f64().unwrap());
+    assert_eq!(row(r), [2.0, 0.0, 30.0, 2.0, 36.0]);
+    assert_eq!(row(r + 1), [6.0, 0.0, 6.0, 6.0, 36.0]);
+    // data.solverReport writes reports from the saved model and a given solution.
+    let out =
+        s.execute("data.solverReport", json!({"reports": ["answer"], "values": {"B2": 2, "C2": 6}, "original": {"B2": 1, "C2": 1}})).unwrap();
+    assert_eq!(out["sheets"], json!(["Answer Report 2"]));
+    let r = row_of(&s, "Answer Report 2", "$D$6") + 1;
+    assert_eq!(at(&s, "Answer Report 2", &format!("D{r}")), Value::number(8.0));
+    // Undo removes the reports and keeps the solution; refused requests write nothing.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 3);
+    for p in [
+        json!({}),
+        json!({"reports": []}),
+        json!({"reports": "answer"}),
+        json!({"reports": ["population"]}),
+        json!({"reports": ["answer"], "values": {"Z9": 1}}),
+        json!({"reports": ["answer"], "values": {"B2": "x"}}),
+        json!({"reports": ["limits"], "constraints": ["D3:D5 <= E3:E5", "B2:C2 int"]}),
+        json!({"reports": ["limits"], "method": "evolutionary", "constraints": ["D3:D5 <= E3:E5", "B2:C2 <= 10"]}),
+    ] {
+        assert!(s.execute("data.solverReport", p.clone()).is_err(), "{p}");
+    }
+    assert_eq!(s.doc().unwrap().wb.sheets.len(), 3);
+    // With the solve, its reports and the saved model undone (one step), the result still
+    // describes the solution.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!((s.doc().unwrap().wb.sheets.len(), n(&s, "B2")), (1, 0.0));
+    let mut p = solved.clone();
+    p["reports"] = json!(["answer"]);
+    assert_eq!(s.execute("data.solverReport", p).unwrap()["sheets"], json!(["Answer Report 1"]));
+    let r = row_of(&s, "Answer Report 1", "$B$2") + 1;
+    assert_eq!(at(&s, "Answer Report 1", &format!("E{r}")), Value::number(2.0));
+}
+
+#[test]
+fn refused_solver_reports_preserve_the_document_and_history() {
+    for (protected, method, constraints, reports, error) in [
+        (true, "simplex", json!(["A1 <= 4"]), json!(["answer"]), "workbook is protected"),
+        (false, "simplex", json!(["A1 <= 4", "A1 int"]), json!(["answer", "limits"]), "integer or binary"),
+        (false, "evolutionary", json!(["A1 <= 4"]), json!(["answer", "limits"]), "Simplex LP and GRG"),
+    ] {
+        for (keep, save) in [(true, true), (false, true), (true, false), (false, false)] {
+            let mut s = s();
+            set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
+            s.execute(
+                "data.solver",
+                json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 2"], "method": "simplex", "keep": false}),
+            )
+            .unwrap();
+            set(&mut s, &[("C1", "redo")]);
+            s.execute("edit.undo", json!({})).unwrap();
+            let d = s.doc_mut().unwrap();
+            std::sync::Arc::make_mut(&mut d.wb).protected_structure = protected;
+            d.saved = d.wb.clone();
+            let before = d.clone();
+            let journal = s.journal.clone();
+            let err = s
+                .execute(
+                    "data.solver",
+                    json!({"objective": "B1", "variables": "A1", "constraints": constraints, "method": method,
+                        "reports": reports, "keep": keep, "saveModel": save}),
+                )
+                .unwrap_err();
+            assert!(err.to_string().contains(error), "{err}");
+            let d = s.doc().unwrap();
+            assert!(std::sync::Arc::ptr_eq(&d.wb, &before.wb), "{method}: keep={keep}, save={save}: {err}");
+            assert!(!d.is_dirty());
+            assert_eq!(d.revision, before.revision);
+            assert_eq!(d.selection, before.selection);
+            assert_eq!(d.sheet_selections, before.sheet_selections);
+            for (after, before) in [(&d.undo, &before.undo), (&d.redo, &before.redo)] {
+                assert_eq!(after.len(), before.len());
+                for (a, b) in after.iter().zip(before) {
+                    assert!(std::sync::Arc::ptr_eq(&a.wb, &b.wb));
+                    assert_eq!((&a.label, &a.selection), (&b.label, &b.selection));
+                }
+            }
+            assert_eq!(s.journal, journal);
+        }
+    }
+}
+
+#[test]
+fn solver_reports_and_optional_solution_and_model_share_one_undo() {
+    for (keep, save) in [(true, true), (false, true), (true, false), (false, false)] {
+        let mut s = s();
+        set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
+        let before = s.doc().unwrap().clone();
+        let out = s
+            .execute(
+                "data.solver",
+                json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 4"], "method": "simplex",
+                    "reports": ["answer"], "keep": keep, "saveModel": save}),
+            )
+            .unwrap();
+        assert_eq!(out["status"], "optimal");
+        assert_eq!(out["reports"], json!(["Answer Report 1"]));
+        assert_eq!(out["model"]["objective"], "Sheet1!B1");
+        assert_eq!(n(&s, "A1"), if keep { 4.0 } else { 1.0 });
+        assert_eq!(saved(&s), if save { "solver_opt" } else { "" });
+        assert_eq!(s.doc().unwrap().undo.len(), before.undo.len() + 1);
+        assert_eq!(s.doc().unwrap().wb.active().unwrap().name, "Sheet1");
+        let r = row_of(&s, "Answer Report 1", "$A$1") + 1;
+        assert_eq!(at(&s, "Answer Report 1", &format!("E{r}")), Value::number(4.0));
+        s.execute("edit.undo", json!({})).unwrap();
+        assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before.wb));
+        s.execute("edit.redo", json!({})).unwrap();
+        assert_eq!(s.doc().unwrap().wb.sheets.len(), 2);
+        assert_eq!(n(&s, "A1"), if keep { 4.0 } else { 1.0 });
+    }
+}
+
+#[test]
+fn solver_reports_keep_row_autofit_on_the_model_sheet() {
+    let mut s = s();
+    set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
+    s.execute("home.columnWidth", json!({"cols": "A:A", "width": 30})).unwrap();
+    s.execute("home.wrapText", json!({"range": "A1", "on": true})).unwrap();
+    let before = s.doc().unwrap().wb.active().unwrap().row_height(0);
+    s.execute(
+        "data.solver",
+        json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 1000000"], "method": "simplex", "reports": ["answer"]}),
+    )
+    .unwrap();
+    let sh = s.doc().unwrap().wb.active().unwrap();
+    assert_eq!(sh.name, "Sheet1");
+    assert_eq!(sh.value(CellRef::new(0, 0)), Value::number(1_000_000.0));
+    assert!(sh.row_height(0) > before, "the solved wrapped number must re-fit its row after the report shifts its sheet");
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().wb.active().unwrap().row_height(0), before);
+}
+
+#[test]
+fn solver_report_insertion_keeps_variable_edit_guards() {
+    for array in [false, true] {
+        let mut s = s();
+        set(&mut s, &[("A2", "1"), ("B1", "=2*A2")]);
+        let error = if array {
+            s.execute("selection.set", json!({"range": "A1:A2"})).unwrap();
+            s.execute("cell.set", json!({"input": "=1", "array": true})).unwrap();
+            "part of an array"
+        } else {
+            s.execute("review.protectSheet", json!({})).unwrap();
+            "protected sheet"
+        };
+        let before = s.doc().unwrap().clone();
+        let err = s
+            .execute(
+                "data.solver",
+                json!({"objective": "B1", "variables": "A2", "constraints": ["A2 <= 4"], "method": "simplex", "reports": ["answer"]}),
+            )
+            .unwrap_err();
+        assert!(err.to_string().contains(error), "{err}");
+        let d = s.doc().unwrap();
+        assert!(std::sync::Arc::ptr_eq(&d.wb, &before.wb));
+        assert_eq!(d.undo.len(), before.undo.len());
+        assert_eq!(d.sheet_selections, before.sheet_selections);
+    }
+}
+
+#[test]
+fn limits_report_of_a_nonlinear_model() {
+    // The largest rectangle with perimeter at most 20 (5 × 5): with the height held at 5, the
+    // width ranges over 0..5, the area over 0..25.
+    let mut s = s();
+    set(&mut s, &[("A1", "1"), ("A2", "1"), ("B1", "=A1*A2"), ("B2", "=2*A1+2*A2")]);
+    let r =
+        s.execute("data.solver", json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 20"], "reports": ["limits"]})).unwrap();
+    assert_eq!(r["reports"], json!(["Limits Report 1"]), "{r}");
+    let l = "Limits Report 1";
+    let r = row_of(&s, l, "$A$1") + 1;
+    let got: Vec<f64> = ["E", "F", "G", "H"].iter().map(|c| at(&s, l, &format!("{c}{r}")).as_f64().unwrap()).collect();
+    for (g, want) in got.iter().zip([0.0, 0.0, 5.0, 25.0]) {
+        assert!((g - want).abs() < 1e-3, "{got:?}");
+    }
+}
+
+#[test]
+fn infeasible_unbounded_and_nonlinear_models_are_reported() {
+    let mut s = s();
+    set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
+    for method in ["simplex", "grg"] {
+        let r = s
+            .execute("data.solver", json!({"objective": "B1", "variables": "A1", "constraints": ["A1 >= 5", "B1 <= 6"], "method": method}))
+            .unwrap();
+        assert_eq!(r["status"], "infeasible", "{method}: {r}");
+        assert_eq!(r["changed"], false);
+        assert_eq!(n(&s, "A1"), 1.0, "an infeasible model leaves the cells alone");
+    }
+    let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1", "method": "simplex"})).unwrap();
+    assert_eq!(r["status"], "unbounded");
+    let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1", "method": "grg", "maxEvaluations": 5000})).unwrap();
+    assert!(r["status"] == "unbounded" || r["status"] == "iterationLimit", "{r}");
+    set(&mut s, &[("A1", "1"), ("C1", "=A1^2")]);
+    let r = s.execute("data.solver", json!({"objective": "C1", "goal": "min", "variables": "A1", "method": "simplex"})).unwrap();
+    assert_eq!(r["status"], "notLinear");
+}
+
+#[test]
+fn hostile_models_are_refused_without_panicking() {
+    let mut s = s();
+    let r = s.execute("data.solver", json!({})).unwrap();
+    assert!(r["model"].is_null());
+    assert!(s.take_ui_requests().iter().any(|q| matches!(q, crate::UiRequest::Dialog(n, _) if n == "solver")));
+    set(&mut s, &[("B1", "=SUM(A1:A1000)"), ("C1", "5")]);
+    for p in [
+        json!({"objective": "B1", "variables": "A1:A1000"}),
+        json!({"objective": "B1", "variables": "A1:XFD1048576"}),
+        json!({"objective": "C1", "variables": "A1"}),
+        json!({"objective": "B1:B2", "variables": "A1"}),
+        json!({"objective": "B1", "variables": "B1"}),
+        json!({"objective": "B1", "variables": "A1", "goal": "sideways"}),
+        json!({"objective": "B1", "variables": "A1", "goal": "value"}),
+        json!({"objective": "B1", "variables": "A1", "method": "evolutionary"}),
+        json!({"objective": "B1", "variables": "A1", "method": "annealing"}),
+        json!({"objective": "B1", "variables": "A1", "constraints": ["A1 ?? 3"]}),
+        json!({"objective": "B1", "variables": "A1", "constraints": "A1 <= 3"}),
+        json!({"objective": "B1", "variables": "A1", "constraints": ["A1:A3 <= C1:C2"]}),
+        json!({"objective": "B1", "variables": "A1", "constraints": ["C1 int"]}),
+        json!({"objective": "B1", "variables": "A1", "constraints": ["A1:A1048576 <= 1"]}),
+        json!({"objective": "B1", "variables": "A1", "constraints": vec![json!("A1 <= 1"); 1001]}),
+        json!({"objective": "Nope!B1", "variables": "A1"}),
+    ] {
+        assert!(s.execute("data.solver", p.clone()).is_err(), "{p}");
+    }
+    // Huge evaluation requests are capped, and a model erroring everywhere doesn't panic.
+    set(&mut s, &[("D1", "=1/0+A1")]);
+    let r = s.execute("data.solver", json!({"objective": "D1", "variables": "A1", "maxEvaluations": 1e300})).unwrap();
+    assert_ne!(r["status"], "converged");
+}

From 8c338b7cbe1376362de72dcca94ec51301bbb8ed Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:42 +0000
Subject: [PATCH 31/76] refactor(engine): move cmd/whatif tests to
 src/cmd/whatif/tests.rs

---
 crates/engine/src/cmd/whatif.rs       | 302 +-------------------------
 crates/engine/src/cmd/whatif/tests.rs | 299 +++++++++++++++++++++++++
 2 files changed, 300 insertions(+), 301 deletions(-)
 create mode 100644 crates/engine/src/cmd/whatif/tests.rs

diff --git a/crates/engine/src/cmd/whatif.rs b/crates/engine/src/cmd/whatif.rs
index 53b0dc3cc..1b9ed0f54 100644
--- a/crates/engine/src/cmd/whatif.rs
+++ b/crates/engine/src/cmd/whatif.rs
@@ -1132,304 +1132,4 @@ fn consolidate(s: &mut Session, p: &Json) -> Result<Json> {
 }
 
 #[cfg(test)]
-mod tests {
-    use gridcraft_core::{CellRef, Value};
-    use serde_json::json;
-
-    use crate::Session;
-
-    fn s() -> Session {
-        let mut s = Session::new();
-        s.new_workbook();
-        s
-    }
-    fn v(s: &Session, a: &str) -> Value {
-        let d = s.doc().unwrap();
-        let (sh, body) = super::split_sheet(a);
-        let si = sh.map(|n| d.wb.sheet_index(&n).unwrap()).unwrap_or(d.wb.active_sheet());
-        d.wb.sheet(si).unwrap().value(CellRef::parse(body).unwrap())
-    }
-    fn n(s: &Session, a: &str) -> f64 {
-        v(s, a).as_f64().unwrap_or(f64::NAN)
-    }
-
-    #[test]
-    fn goal_seek_linear_and_nonlinear() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "B2", "input": "1"})).unwrap();
-        s.execute("cell.set", json!({"cell": "B5", "input": "=B2*3+4"})).unwrap();
-        let r = s.execute("data.goalSeek", json!({"set": "B5", "to": 25, "changing": "B2"})).unwrap();
-        assert_eq!(r["converged"], true);
-        assert!((n(&s, "B2") - 7.0).abs() < 0.001, "{r}");
-        assert!((n(&s, "B5") - 25.0).abs() < 0.001);
-        // One undo step restores the input.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(n(&s, "B2"), 1.0);
-        // Nonlinear: x^2 = 2 from x = 1.
-        s.execute("cell.set", json!({"cell": "C1", "input": "=B2^2"})).unwrap();
-        let r = s.execute("data.goalSeek", json!({"set": "C1", "to": 2, "changing": "B2"})).unwrap();
-        assert_eq!(r["converged"], true);
-        assert!((n(&s, "C1") - 2.0).abs() <= 0.001);
-        // Loan payment: what rate makes PMT = -500?
-        s.execute("range.setValues", json!({"range": "E1", "values": [[0.01], [10000], [24]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "E4", "input": "=PMT(E1/12,E3,E2)"})).unwrap();
-        let r = s.execute("data.goalSeek", json!({"set": "E4", "to": -500, "changing": "E1"})).unwrap();
-        assert_eq!(r["converged"], true, "{r}");
-        assert!((n(&s, "E4") + 500.0).abs() <= 0.001);
-        // Starting at zero.
-        s.execute("cell.set", json!({"cell": "G1", "input": "0"})).unwrap();
-        s.execute("cell.set", json!({"cell": "G2", "input": "=G1*G1*G1-27"})).unwrap();
-        let r = s.execute("data.goalSeek", json!({"set": "G2", "to": 0, "changing": "G1"})).unwrap();
-        assert_eq!(r["converged"], true, "{r}");
-        assert!((n(&s, "G1") - 3.0).abs() < 0.01);
-    }
-
-    #[test]
-    fn goal_seek_errors() {
-        let mut s = s();
-        s.execute("cell.set", json!({"cell": "A1", "input": "5"})).unwrap();
-        s.execute("cell.set", json!({"cell": "A2", "input": "=A1"})).unwrap();
-        assert!(s.execute("data.goalSeek", json!({"set": "A1", "to": 1, "changing": "A1"})).is_err());
-        assert!(s.execute("data.goalSeek", json!({"set": "A2", "to": 1, "changing": "A2"})).is_err());
-        assert!(s.execute("data.goalSeek", json!({"set": "A2", "changing": "A1"})).is_err());
-        // Unreachable target: not converged, but no error and no crash.
-        s.execute("cell.set", json!({"cell": "A3", "input": "=A1^2"})).unwrap();
-        let r = s.execute("data.goalSeek", json!({"set": "A3", "to": -4, "changing": "A1"})).unwrap();
-        assert_eq!(r["converged"], false);
-        assert!(r["iterations"].as_u64().unwrap() <= 100);
-    }
-
-    #[test]
-    fn seek_unit() {
-        let mut f = |x: f64| (x - 1e6) / 3.0;
-        let r = super::seek(0.0, &mut f, 100, 0.001);
-        assert!(r.converged, "{r:?}");
-        let mut g = |x: f64| if x < 0.0 { f64::NAN } else { x.sqrt() - 5.0 };
-        let r = super::seek(1.0, &mut g, 100, 0.001);
-        assert!(r.converged, "{r:?}");
-        let mut h = |_: f64| f64::NAN;
-        let r = super::seek(1.0, &mut h, 100, 0.001);
-        assert!(!r.converged);
-    }
-
-    #[test]
-    fn scenario_show_restores_a_percentage_cells_stored_number() {
-        let mut s = s();
-        s.execute("home.numberFormat", json!({"range": "B2", "format": "Percentage"})).unwrap();
-        s.execute("cell.set", json!({"cell": "B2", "input": "5"})).unwrap();
-        s.execute("data.scenarioAdd", json!({"name": "Low", "changing": "B2"})).unwrap();
-        s.execute("cell.set", json!({"cell": "B2", "input": "9"})).unwrap();
-        s.execute("data.scenarioShow", json!({"name": "Low"})).unwrap();
-        assert_eq!(n(&s, "B2"), 0.05);
-    }
-
-    #[test]
-    fn scenarios() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "B2", "values": [[10], [20]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "B10", "input": "=B2*B3"})).unwrap();
-        s.execute("data.scenarioAdd", json!({"name": "Base", "changing": "B2:B3"})).unwrap();
-        s.execute("data.scenarioAdd", json!({"name": "Best", "changing": "B2:B3", "values": [100, 3], "comment": "optimistic"})).unwrap();
-        assert!(s.execute("data.scenarioAdd", json!({"name": "best", "changing": "B2:B3", "values": [1, 2]})).is_err());
-        assert!(s.execute("data.scenarioAdd", json!({"name": "Bad", "changing": "B2:B3", "values": [1]})).is_err());
-        let l = s.execute("data.scenarioManager", json!({})).unwrap();
-        assert_eq!(l["scenarios"].as_array().unwrap().len(), 2);
-        assert_eq!(l["scenarios"][1]["comment"], "optimistic");
-        s.execute("data.scenarioShow", json!({"name": "Best"})).unwrap();
-        assert_eq!(n(&s, "B10"), 300.0);
-        s.execute("data.scenarioShow", json!({"name": "Base"})).unwrap();
-        assert_eq!(n(&s, "B10"), 200.0);
-        // Stored in a hidden workbook name.
-        let d = s.doc().unwrap();
-        assert!(d.wb.names.iter().any(|n| n.name == super::SCENARIO_NAME && n.hidden));
-        assert_eq!(super::load_scenarios(&d.wb).len(), 2);
-        // Long data is split into 250-character literals and survives an xlsx round trip.
-        s.execute("data.scenarioAdd", json!({"name": "Long", "changing": "B2", "values": [1], "comment": "x".repeat(600)})).unwrap();
-        let f = s.doc().unwrap().wb.names.iter().find(|n| n.name == super::SCENARIO_NAME).unwrap().formula.clone();
-        assert!(f.matches("\"&\"").count() >= 2, "{f}");
-        let b64 = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap()["base64"].as_str().unwrap().to_string();
-        s.execute("file.open", json!({"name": "sc.xlsx", "base64": b64})).unwrap();
-        let l = s.execute("data.scenarioManager", json!({})).unwrap();
-        assert_eq!(l["scenarios"].as_array().unwrap().len(), 3, "{l}");
-        assert_eq!(l["scenarios"][2]["comment"].as_str().unwrap().len(), 600);
-        s.execute("data.scenarioDelete", json!({"name": "Long"})).unwrap();
-        let r = s.execute("data.scenarioSummary", json!({"resultCells": "B10"})).unwrap();
-        assert_eq!(r["sheet"], "Scenario Summary");
-        assert_eq!(s.doc().unwrap().wb.active().unwrap().name, "Scenario Summary");
-        assert_eq!(v(&s, "'Scenario Summary'!D3"), Value::from("Base"));
-        assert_eq!(v(&s, "'Scenario Summary'!B5"), Value::from("$B$2"));
-        assert_eq!(n(&s, "'Scenario Summary'!E5"), 100.0);
-        // Result row: current, Base, Best.
-        assert_eq!(n(&s, "'Scenario Summary'!C8"), 200.0);
-        assert_eq!(n(&s, "'Scenario Summary'!E8"), 300.0);
-        s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-        s.execute("data.scenarioDelete", json!({"name": "Best"})).unwrap();
-        assert_eq!(s.execute("data.scenarioManager", json!({})).unwrap()["scenarios"].as_array().unwrap().len(), 1);
-        s.execute("data.scenarioDelete", json!({"name": "Base"})).unwrap();
-        assert!(s.doc().unwrap().wb.names.iter().all(|n| n.name != super::SCENARIO_NAME));
-        assert!(s.execute("data.scenarioSummary", json!({})).is_err());
-    }
-
-    #[test]
-    fn data_tables() {
-        let mut s = s();
-        // Loan: rate B1, amount B2; payment formula.
-        s.execute("range.setValues", json!({"range": "B1", "values": [[0.05], [1000]]})).unwrap();
-        // One-variable, column oriented: amounts down D3:D5, formula in E2.
-        s.execute("range.setValues", json!({"range": "D3", "values": [[100], [200], [300]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "E2", "input": "=B2*(1+B1)"})).unwrap();
-        s.execute("cell.set", json!({"cell": "F2", "input": "=B2*2"})).unwrap();
-        let r = s.execute("data.dataTable", json!({"range": "D2:F5", "columnInput": "B2"})).unwrap();
-        assert_eq!(r["cells"], 6);
-        assert!((n(&s, "E3") - 105.0).abs() < 1e-9);
-        assert_eq!(n(&s, "F5"), 600.0);
-        // The input cell is untouched.
-        assert_eq!(n(&s, "B2"), 1000.0);
-        // Row oriented: rates across H2:J2, formula in G3.
-        s.execute("range.setValues", json!({"range": "H2", "values": [[0.1, 0.2, 0.3]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "G3", "input": "=B2*(1+B1)"})).unwrap();
-        s.execute("data.dataTable", json!({"range": "G2:J3", "rowInput": "B1"})).unwrap();
-        assert!((n(&s, "J3") - 1300.0).abs() < 1e-9);
-        // Two-variable: formula at L1, rates across, amounts down.
-        s.execute("cell.set", json!({"cell": "L1", "input": "=B2*(1+B1)"})).unwrap();
-        s.execute("range.setValues", json!({"range": "M1", "values": [[0.5, 1]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "L2", "values": [[10], [20]]})).unwrap();
-        let r = s.execute("data.dataTable", json!({"range": "L1:N3", "rowInput": "B1", "columnInput": "B2"})).unwrap();
-        assert_eq!(r["mode"], "twoVariable");
-        assert_eq!(n(&s, "M2"), 15.0);
-        assert_eq!(n(&s, "N3"), 40.0);
-        assert!(s.execute("data.dataTable", json!({"range": "L1:N3"})).is_err());
-        assert!(s.execute("data.dataTable", json!({"range": "A1:XFD100000", "columnInput": "B2"})).is_err());
-        assert!(s.execute("data.dataTable", json!({"range": "L1:N3", "columnInput": "M2"})).is_err());
-    }
-
-    #[test]
-    fn advanced_filter_in_place_and_copy() {
-        let mut s = s();
-        s.execute(
-            "range.setValues",
-            json!({"range": "A1", "values": [["Region", "Sales"], ["East", 50], ["West", 150], ["East", 200], ["North", 120], ["East", 200]]}),
-        )
-        .unwrap();
-        // East AND Sales > 100, OR North.
-        s.execute("range.setValues", json!({"range": "H1", "values": [["Region", "Sales"], ["East", ">100"], ["North", null]]})).unwrap();
-        let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H1:I3"})).unwrap();
-        assert_eq!(r["matched"], 3);
-        let sh = || s.doc().unwrap().wb.active().unwrap().clone();
-        assert!(sh().is_row_hidden(1));
-        assert!(sh().is_row_hidden(2));
-        assert!(!sh().is_row_hidden(3));
-        assert!(!sh().is_row_hidden(4));
-        // Unique, copied.
-        let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H1:I3", "copyTo": "K1", "unique": true})).unwrap();
-        assert_eq!(r["matched"], 2);
-        assert_eq!(r["range"], "K1:L3");
-        assert_eq!(v(&s, "K1"), Value::from("Region"));
-        assert_eq!(v(&s, "K2"), Value::from("East"));
-        assert_eq!(n(&s, "L2"), 200.0);
-        assert_eq!(v(&s, "K3"), Value::from("North"));
-        assert_eq!(v(&s, "K4"), Value::Empty);
-        // Wildcards and exact text.
-        s.execute("range.setValues", json!({"range": "H5", "values": [["Region"], ["*st"]]})).unwrap();
-        let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H5:H6"})).unwrap();
-        assert_eq!(r["matched"], 4);
-        // Computed criterion (blank header): Sales above 100.
-        s.execute("cell.set", json!({"cell": "J8", "input": "=B2>100"})).unwrap();
-        let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "J7:J8"})).unwrap();
-        assert_eq!(r["matched"], 4);
-        // Overlap is rejected.
-        assert!(s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H1:I3", "copyTo": "B2"})).is_err());
-    }
-
-    #[test]
-    fn advanced_filter_copy_preserves_cells_beyond_result() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "Score"], ["A", 1], ["B", 2], ["C", 3]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["B"]]})).unwrap();
-        s.execute("cell.set", json!({"cell": "K4", "input": "Keep me"})).unwrap();
-        let r = s.execute("data.advancedFilter", json!({"range": "A1:B4", "criteria": "H1:H2", "copyTo": "K1"})).unwrap();
-        assert_eq!(r["range"], "K1:L2");
-        assert_eq!(v(&s, "K2"), Value::from("B"));
-        assert_eq!(v(&s, "K4"), Value::from("Keep me"));
-    }
-
-    #[test]
-    fn advanced_filter_copy_rejects_overflow_without_mutation() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "Score"], ["A", 1]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["A"]]})).unwrap();
-        for dest in ["XFD1", "K1048576"] {
-            s.execute("cell.set", json!({"cell": dest, "input": "Keep me"})).unwrap();
-            assert!(s.execute("data.advancedFilter", json!({"range": "A1:B2", "criteria": "H1:H2", "copyTo": dest})).is_err());
-            assert_eq!(v(&s, dest), Value::from("Keep me"));
-        }
-    }
-
-    #[test]
-    fn advanced_filter_copy_allows_output_above_source_when_only_old_clear_area_overlaps() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "C4", "values": [["Name", "Score"], ["A", 1], ["B", 2], ["C", 3]]})).unwrap();
-        s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["A"]]})).unwrap();
-        let r = s.execute("data.advancedFilter", json!({"range": "C4:D7", "criteria": "H1:H2", "copyTo": "B1"})).unwrap();
-        assert_eq!(r["range"], "B1:C2");
-        assert_eq!(v(&s, "C4"), Value::from("Name"));
-        assert_eq!(v(&s, "C2"), Value::Number(1.0));
-    }
-
-    #[test]
-    fn advanced_filter_unique_without_criteria() {
-        let mut s = s();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Name"], ["A"], ["A"], ["B"]]})).unwrap();
-        let r = s.execute("data.advancedFilter", json!({"range": "A1:A4", "copyTo": "C1", "unique": true})).unwrap();
-        assert_eq!(r["matched"], 2);
-        assert_eq!(r["range"], "C1:C3");
-        assert_eq!(v(&s, "C2"), Value::from("A"));
-        assert_eq!(v(&s, "C3"), Value::from("B"));
-    }
-
-    #[test]
-    fn criteria_semantics() {
-        use super::criterion_matches as m;
-        let t = |x: &str| Value::from(x);
-        assert!(m(&Value::Number(150.0), "150", &t(">100")));
-        assert!(!m(&Value::Number(50.0), "50", &t(">100")));
-        assert!(!m(&t("abc"), "abc", &t(">100")));
-        assert!(m(&t("Apple"), "Apple", &t("a")));
-        assert!(m(&t("apple pie"), "apple pie", &t("=apple*")));
-        assert!(!m(&t("apple pie"), "apple pie", &t("=apple")));
-        assert!(m(&Value::Empty, "", &t("=")));
-        assert!(m(&t("x"), "x", &t("<>")));
-        assert!(m(&Value::Number(5.0), "5", &Value::Number(5.0)));
-        assert!(m(&t("b"), "b", &t(">a")));
-        assert!(m(&t("x"), "x", &t("<>y")));
-    }
-
-    #[test]
-    fn consolidate_by_position_and_label() {
-        let mut s = s();
-        s.execute("home.insertSheet", json!({})).unwrap();
-        s.execute("sheet.rename", json!({"name": "East"})).unwrap();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["", "Q1", "Q2"], ["Apples", 10, 20], ["Pears", 5, 6]]})).unwrap();
-        s.execute("home.insertSheet", json!({})).unwrap();
-        s.execute("sheet.rename", json!({"name": "West"})).unwrap();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["", "Q2", "Q3"], ["Pears", 1, 2], ["Plums", 7, 8]]})).unwrap();
-        s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-        let r = s
-            .execute("data.consolidate", json!({"sources": ["East!A1:C3", "West!A1:C3"], "destination": "A1", "topRow": true, "leftColumn": true}))
-            .unwrap();
-        assert_eq!(r["range"], "A1:D4");
-        assert_eq!(v(&s, "Sheet1!B1"), Value::from("Q1"));
-        assert_eq!(v(&s, "Sheet1!D1"), Value::from("Q3"));
-        assert_eq!(v(&s, "Sheet1!A3"), Value::from("Pears"));
-        assert_eq!(n(&s, "Sheet1!C3"), 7.0);
-        assert_eq!(n(&s, "Sheet1!D4"), 8.0);
-        assert_eq!(v(&s, "Sheet1!B4"), Value::Empty);
-        // By position, average.
-        let r = s.execute("data.consolidate", json!({"sources": ["East!B2:C3", "West!B2:C3"], "destination": "F1", "function": "average"})).unwrap();
-        assert_eq!(r["range"], "F1:G2");
-        assert_eq!(n(&s, "Sheet1!F1"), 5.5);
-        assert_eq!(n(&s, "Sheet1!G2"), 7.0);
-        assert!(s.execute("data.consolidate", json!({"sources": []})).is_err());
-        assert!(s.execute("data.consolidate", json!({"sources": ["A1"], "function": "median"})).is_err());
-    }
-}
+mod tests;
diff --git a/crates/engine/src/cmd/whatif/tests.rs b/crates/engine/src/cmd/whatif/tests.rs
new file mode 100644
index 000000000..c1476e401
--- /dev/null
+++ b/crates/engine/src/cmd/whatif/tests.rs
@@ -0,0 +1,299 @@
+use gridcraft_core::{CellRef, Value};
+use serde_json::json;
+
+use crate::Session;
+
+fn s() -> Session {
+    let mut s = Session::new();
+    s.new_workbook();
+    s
+}
+fn v(s: &Session, a: &str) -> Value {
+    let d = s.doc().unwrap();
+    let (sh, body) = super::split_sheet(a);
+    let si = sh.map(|n| d.wb.sheet_index(&n).unwrap()).unwrap_or(d.wb.active_sheet());
+    d.wb.sheet(si).unwrap().value(CellRef::parse(body).unwrap())
+}
+fn n(s: &Session, a: &str) -> f64 {
+    v(s, a).as_f64().unwrap_or(f64::NAN)
+}
+
+#[test]
+fn goal_seek_linear_and_nonlinear() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "B2", "input": "1"})).unwrap();
+    s.execute("cell.set", json!({"cell": "B5", "input": "=B2*3+4"})).unwrap();
+    let r = s.execute("data.goalSeek", json!({"set": "B5", "to": 25, "changing": "B2"})).unwrap();
+    assert_eq!(r["converged"], true);
+    assert!((n(&s, "B2") - 7.0).abs() < 0.001, "{r}");
+    assert!((n(&s, "B5") - 25.0).abs() < 0.001);
+    // One undo step restores the input.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(n(&s, "B2"), 1.0);
+    // Nonlinear: x^2 = 2 from x = 1.
+    s.execute("cell.set", json!({"cell": "C1", "input": "=B2^2"})).unwrap();
+    let r = s.execute("data.goalSeek", json!({"set": "C1", "to": 2, "changing": "B2"})).unwrap();
+    assert_eq!(r["converged"], true);
+    assert!((n(&s, "C1") - 2.0).abs() <= 0.001);
+    // Loan payment: what rate makes PMT = -500?
+    s.execute("range.setValues", json!({"range": "E1", "values": [[0.01], [10000], [24]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "E4", "input": "=PMT(E1/12,E3,E2)"})).unwrap();
+    let r = s.execute("data.goalSeek", json!({"set": "E4", "to": -500, "changing": "E1"})).unwrap();
+    assert_eq!(r["converged"], true, "{r}");
+    assert!((n(&s, "E4") + 500.0).abs() <= 0.001);
+    // Starting at zero.
+    s.execute("cell.set", json!({"cell": "G1", "input": "0"})).unwrap();
+    s.execute("cell.set", json!({"cell": "G2", "input": "=G1*G1*G1-27"})).unwrap();
+    let r = s.execute("data.goalSeek", json!({"set": "G2", "to": 0, "changing": "G1"})).unwrap();
+    assert_eq!(r["converged"], true, "{r}");
+    assert!((n(&s, "G1") - 3.0).abs() < 0.01);
+}
+
+#[test]
+fn goal_seek_errors() {
+    let mut s = s();
+    s.execute("cell.set", json!({"cell": "A1", "input": "5"})).unwrap();
+    s.execute("cell.set", json!({"cell": "A2", "input": "=A1"})).unwrap();
+    assert!(s.execute("data.goalSeek", json!({"set": "A1", "to": 1, "changing": "A1"})).is_err());
+    assert!(s.execute("data.goalSeek", json!({"set": "A2", "to": 1, "changing": "A2"})).is_err());
+    assert!(s.execute("data.goalSeek", json!({"set": "A2", "changing": "A1"})).is_err());
+    // Unreachable target: not converged, but no error and no crash.
+    s.execute("cell.set", json!({"cell": "A3", "input": "=A1^2"})).unwrap();
+    let r = s.execute("data.goalSeek", json!({"set": "A3", "to": -4, "changing": "A1"})).unwrap();
+    assert_eq!(r["converged"], false);
+    assert!(r["iterations"].as_u64().unwrap() <= 100);
+}
+
+#[test]
+fn seek_unit() {
+    let mut f = |x: f64| (x - 1e6) / 3.0;
+    let r = super::seek(0.0, &mut f, 100, 0.001);
+    assert!(r.converged, "{r:?}");
+    let mut g = |x: f64| if x < 0.0 { f64::NAN } else { x.sqrt() - 5.0 };
+    let r = super::seek(1.0, &mut g, 100, 0.001);
+    assert!(r.converged, "{r:?}");
+    let mut h = |_: f64| f64::NAN;
+    let r = super::seek(1.0, &mut h, 100, 0.001);
+    assert!(!r.converged);
+}
+
+#[test]
+fn scenario_show_restores_a_percentage_cells_stored_number() {
+    let mut s = s();
+    s.execute("home.numberFormat", json!({"range": "B2", "format": "Percentage"})).unwrap();
+    s.execute("cell.set", json!({"cell": "B2", "input": "5"})).unwrap();
+    s.execute("data.scenarioAdd", json!({"name": "Low", "changing": "B2"})).unwrap();
+    s.execute("cell.set", json!({"cell": "B2", "input": "9"})).unwrap();
+    s.execute("data.scenarioShow", json!({"name": "Low"})).unwrap();
+    assert_eq!(n(&s, "B2"), 0.05);
+}
+
+#[test]
+fn scenarios() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "B2", "values": [[10], [20]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "B10", "input": "=B2*B3"})).unwrap();
+    s.execute("data.scenarioAdd", json!({"name": "Base", "changing": "B2:B3"})).unwrap();
+    s.execute("data.scenarioAdd", json!({"name": "Best", "changing": "B2:B3", "values": [100, 3], "comment": "optimistic"})).unwrap();
+    assert!(s.execute("data.scenarioAdd", json!({"name": "best", "changing": "B2:B3", "values": [1, 2]})).is_err());
+    assert!(s.execute("data.scenarioAdd", json!({"name": "Bad", "changing": "B2:B3", "values": [1]})).is_err());
+    let l = s.execute("data.scenarioManager", json!({})).unwrap();
+    assert_eq!(l["scenarios"].as_array().unwrap().len(), 2);
+    assert_eq!(l["scenarios"][1]["comment"], "optimistic");
+    s.execute("data.scenarioShow", json!({"name": "Best"})).unwrap();
+    assert_eq!(n(&s, "B10"), 300.0);
+    s.execute("data.scenarioShow", json!({"name": "Base"})).unwrap();
+    assert_eq!(n(&s, "B10"), 200.0);
+    // Stored in a hidden workbook name.
+    let d = s.doc().unwrap();
+    assert!(d.wb.names.iter().any(|n| n.name == super::SCENARIO_NAME && n.hidden));
+    assert_eq!(super::load_scenarios(&d.wb).len(), 2);
+    // Long data is split into 250-character literals and survives an xlsx round trip.
+    s.execute("data.scenarioAdd", json!({"name": "Long", "changing": "B2", "values": [1], "comment": "x".repeat(600)})).unwrap();
+    let f = s.doc().unwrap().wb.names.iter().find(|n| n.name == super::SCENARIO_NAME).unwrap().formula.clone();
+    assert!(f.matches("\"&\"").count() >= 2, "{f}");
+    let b64 = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap()["base64"].as_str().unwrap().to_string();
+    s.execute("file.open", json!({"name": "sc.xlsx", "base64": b64})).unwrap();
+    let l = s.execute("data.scenarioManager", json!({})).unwrap();
+    assert_eq!(l["scenarios"].as_array().unwrap().len(), 3, "{l}");
+    assert_eq!(l["scenarios"][2]["comment"].as_str().unwrap().len(), 600);
+    s.execute("data.scenarioDelete", json!({"name": "Long"})).unwrap();
+    let r = s.execute("data.scenarioSummary", json!({"resultCells": "B10"})).unwrap();
+    assert_eq!(r["sheet"], "Scenario Summary");
+    assert_eq!(s.doc().unwrap().wb.active().unwrap().name, "Scenario Summary");
+    assert_eq!(v(&s, "'Scenario Summary'!D3"), Value::from("Base"));
+    assert_eq!(v(&s, "'Scenario Summary'!B5"), Value::from("$B$2"));
+    assert_eq!(n(&s, "'Scenario Summary'!E5"), 100.0);
+    // Result row: current, Base, Best.
+    assert_eq!(n(&s, "'Scenario Summary'!C8"), 200.0);
+    assert_eq!(n(&s, "'Scenario Summary'!E8"), 300.0);
+    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
+    s.execute("data.scenarioDelete", json!({"name": "Best"})).unwrap();
+    assert_eq!(s.execute("data.scenarioManager", json!({})).unwrap()["scenarios"].as_array().unwrap().len(), 1);
+    s.execute("data.scenarioDelete", json!({"name": "Base"})).unwrap();
+    assert!(s.doc().unwrap().wb.names.iter().all(|n| n.name != super::SCENARIO_NAME));
+    assert!(s.execute("data.scenarioSummary", json!({})).is_err());
+}
+
+#[test]
+fn data_tables() {
+    let mut s = s();
+    // Loan: rate B1, amount B2; payment formula.
+    s.execute("range.setValues", json!({"range": "B1", "values": [[0.05], [1000]]})).unwrap();
+    // One-variable, column oriented: amounts down D3:D5, formula in E2.
+    s.execute("range.setValues", json!({"range": "D3", "values": [[100], [200], [300]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "E2", "input": "=B2*(1+B1)"})).unwrap();
+    s.execute("cell.set", json!({"cell": "F2", "input": "=B2*2"})).unwrap();
+    let r = s.execute("data.dataTable", json!({"range": "D2:F5", "columnInput": "B2"})).unwrap();
+    assert_eq!(r["cells"], 6);
+    assert!((n(&s, "E3") - 105.0).abs() < 1e-9);
+    assert_eq!(n(&s, "F5"), 600.0);
+    // The input cell is untouched.
+    assert_eq!(n(&s, "B2"), 1000.0);
+    // Row oriented: rates across H2:J2, formula in G3.
+    s.execute("range.setValues", json!({"range": "H2", "values": [[0.1, 0.2, 0.3]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "G3", "input": "=B2*(1+B1)"})).unwrap();
+    s.execute("data.dataTable", json!({"range": "G2:J3", "rowInput": "B1"})).unwrap();
+    assert!((n(&s, "J3") - 1300.0).abs() < 1e-9);
+    // Two-variable: formula at L1, rates across, amounts down.
+    s.execute("cell.set", json!({"cell": "L1", "input": "=B2*(1+B1)"})).unwrap();
+    s.execute("range.setValues", json!({"range": "M1", "values": [[0.5, 1]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "L2", "values": [[10], [20]]})).unwrap();
+    let r = s.execute("data.dataTable", json!({"range": "L1:N3", "rowInput": "B1", "columnInput": "B2"})).unwrap();
+    assert_eq!(r["mode"], "twoVariable");
+    assert_eq!(n(&s, "M2"), 15.0);
+    assert_eq!(n(&s, "N3"), 40.0);
+    assert!(s.execute("data.dataTable", json!({"range": "L1:N3"})).is_err());
+    assert!(s.execute("data.dataTable", json!({"range": "A1:XFD100000", "columnInput": "B2"})).is_err());
+    assert!(s.execute("data.dataTable", json!({"range": "L1:N3", "columnInput": "M2"})).is_err());
+}
+
+#[test]
+fn advanced_filter_in_place_and_copy() {
+    let mut s = s();
+    s.execute(
+        "range.setValues",
+        json!({"range": "A1", "values": [["Region", "Sales"], ["East", 50], ["West", 150], ["East", 200], ["North", 120], ["East", 200]]}),
+    )
+    .unwrap();
+    // East AND Sales > 100, OR North.
+    s.execute("range.setValues", json!({"range": "H1", "values": [["Region", "Sales"], ["East", ">100"], ["North", null]]})).unwrap();
+    let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H1:I3"})).unwrap();
+    assert_eq!(r["matched"], 3);
+    let sh = || s.doc().unwrap().wb.active().unwrap().clone();
+    assert!(sh().is_row_hidden(1));
+    assert!(sh().is_row_hidden(2));
+    assert!(!sh().is_row_hidden(3));
+    assert!(!sh().is_row_hidden(4));
+    // Unique, copied.
+    let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H1:I3", "copyTo": "K1", "unique": true})).unwrap();
+    assert_eq!(r["matched"], 2);
+    assert_eq!(r["range"], "K1:L3");
+    assert_eq!(v(&s, "K1"), Value::from("Region"));
+    assert_eq!(v(&s, "K2"), Value::from("East"));
+    assert_eq!(n(&s, "L2"), 200.0);
+    assert_eq!(v(&s, "K3"), Value::from("North"));
+    assert_eq!(v(&s, "K4"), Value::Empty);
+    // Wildcards and exact text.
+    s.execute("range.setValues", json!({"range": "H5", "values": [["Region"], ["*st"]]})).unwrap();
+    let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H5:H6"})).unwrap();
+    assert_eq!(r["matched"], 4);
+    // Computed criterion (blank header): Sales above 100.
+    s.execute("cell.set", json!({"cell": "J8", "input": "=B2>100"})).unwrap();
+    let r = s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "J7:J8"})).unwrap();
+    assert_eq!(r["matched"], 4);
+    // Overlap is rejected.
+    assert!(s.execute("data.advancedFilter", json!({"range": "A1:B6", "criteria": "H1:I3", "copyTo": "B2"})).is_err());
+}
+
+#[test]
+fn advanced_filter_copy_preserves_cells_beyond_result() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "Score"], ["A", 1], ["B", 2], ["C", 3]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["B"]]})).unwrap();
+    s.execute("cell.set", json!({"cell": "K4", "input": "Keep me"})).unwrap();
+    let r = s.execute("data.advancedFilter", json!({"range": "A1:B4", "criteria": "H1:H2", "copyTo": "K1"})).unwrap();
+    assert_eq!(r["range"], "K1:L2");
+    assert_eq!(v(&s, "K2"), Value::from("B"));
+    assert_eq!(v(&s, "K4"), Value::from("Keep me"));
+}
+
+#[test]
+fn advanced_filter_copy_rejects_overflow_without_mutation() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Name", "Score"], ["A", 1]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["A"]]})).unwrap();
+    for dest in ["XFD1", "K1048576"] {
+        s.execute("cell.set", json!({"cell": dest, "input": "Keep me"})).unwrap();
+        assert!(s.execute("data.advancedFilter", json!({"range": "A1:B2", "criteria": "H1:H2", "copyTo": dest})).is_err());
+        assert_eq!(v(&s, dest), Value::from("Keep me"));
+    }
+}
+
+#[test]
+fn advanced_filter_copy_allows_output_above_source_when_only_old_clear_area_overlaps() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "C4", "values": [["Name", "Score"], ["A", 1], ["B", 2], ["C", 3]]})).unwrap();
+    s.execute("range.setValues", json!({"range": "H1", "values": [["Name"], ["A"]]})).unwrap();
+    let r = s.execute("data.advancedFilter", json!({"range": "C4:D7", "criteria": "H1:H2", "copyTo": "B1"})).unwrap();
+    assert_eq!(r["range"], "B1:C2");
+    assert_eq!(v(&s, "C4"), Value::from("Name"));
+    assert_eq!(v(&s, "C2"), Value::Number(1.0));
+}
+
+#[test]
+fn advanced_filter_unique_without_criteria() {
+    let mut s = s();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["Name"], ["A"], ["A"], ["B"]]})).unwrap();
+    let r = s.execute("data.advancedFilter", json!({"range": "A1:A4", "copyTo": "C1", "unique": true})).unwrap();
+    assert_eq!(r["matched"], 2);
+    assert_eq!(r["range"], "C1:C3");
+    assert_eq!(v(&s, "C2"), Value::from("A"));
+    assert_eq!(v(&s, "C3"), Value::from("B"));
+}
+
+#[test]
+fn criteria_semantics() {
+    use super::criterion_matches as m;
+    let t = |x: &str| Value::from(x);
+    assert!(m(&Value::Number(150.0), "150", &t(">100")));
+    assert!(!m(&Value::Number(50.0), "50", &t(">100")));
+    assert!(!m(&t("abc"), "abc", &t(">100")));
+    assert!(m(&t("Apple"), "Apple", &t("a")));
+    assert!(m(&t("apple pie"), "apple pie", &t("=apple*")));
+    assert!(!m(&t("apple pie"), "apple pie", &t("=apple")));
+    assert!(m(&Value::Empty, "", &t("=")));
+    assert!(m(&t("x"), "x", &t("<>")));
+    assert!(m(&Value::Number(5.0), "5", &Value::Number(5.0)));
+    assert!(m(&t("b"), "b", &t(">a")));
+    assert!(m(&t("x"), "x", &t("<>y")));
+}
+
+#[test]
+fn consolidate_by_position_and_label() {
+    let mut s = s();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    s.execute("sheet.rename", json!({"name": "East"})).unwrap();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["", "Q1", "Q2"], ["Apples", 10, 20], ["Pears", 5, 6]]})).unwrap();
+    s.execute("home.insertSheet", json!({})).unwrap();
+    s.execute("sheet.rename", json!({"name": "West"})).unwrap();
+    s.execute("range.setValues", json!({"range": "A1", "values": [["", "Q2", "Q3"], ["Pears", 1, 2], ["Plums", 7, 8]]})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
+    let r = s
+        .execute("data.consolidate", json!({"sources": ["East!A1:C3", "West!A1:C3"], "destination": "A1", "topRow": true, "leftColumn": true}))
+        .unwrap();
+    assert_eq!(r["range"], "A1:D4");
+    assert_eq!(v(&s, "Sheet1!B1"), Value::from("Q1"));
+    assert_eq!(v(&s, "Sheet1!D1"), Value::from("Q3"));
+    assert_eq!(v(&s, "Sheet1!A3"), Value::from("Pears"));
+    assert_eq!(n(&s, "Sheet1!C3"), 7.0);
+    assert_eq!(n(&s, "Sheet1!D4"), 8.0);
+    assert_eq!(v(&s, "Sheet1!B4"), Value::Empty);
+    // By position, average.
+    let r = s.execute("data.consolidate", json!({"sources": ["East!B2:C3", "West!B2:C3"], "destination": "F1", "function": "average"})).unwrap();
+    assert_eq!(r["range"], "F1:G2");
+    assert_eq!(n(&s, "Sheet1!F1"), 5.5);
+    assert_eq!(n(&s, "Sheet1!G2"), 7.0);
+    assert!(s.execute("data.consolidate", json!({"sources": []})).is_err());
+    assert!(s.execute("data.consolidate", json!({"sources": ["A1"], "function": "median"})).is_err());
+}

From e8091a19527d733862e398063ee7706700cb3246 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:42 +0000
Subject: [PATCH 32/76] refactor(engine): move io tests to src/io/tests.rs

---
 crates/engine/src/io.rs       | 570 +---------------------------------
 crates/engine/src/io/tests.rs | 567 +++++++++++++++++++++++++++++++++
 2 files changed, 568 insertions(+), 569 deletions(-)
 create mode 100644 crates/engine/src/io/tests.rs

diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs
index 77467b210..f51fcbe61 100644
--- a/crates/engine/src/io.rs
+++ b/crates/engine/src/io.rs
@@ -744,572 +744,4 @@ pub fn image_size(data: &[u8]) -> Option<(u32, u32)> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn book(rtl: bool, cells: &[(&str, gridcraft_core::Value, gridcraft_model::HAlign)]) -> Workbook {
-        let mut wb = Workbook::new();
-        let ids: Vec<_> = cells.iter().map(|(_, _, h)| wb.styles.derive(gridcraft_model::StyleId::DEFAULT, |st| st.align.h = *h)).collect();
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.right_to_left = rtl;
-        for ((at, value, _), id) in cells.iter().zip(ids) {
-            let c = CellRef::parse(at).unwrap();
-            sh.set_value(c, value.clone());
-            sh.set_style(c, id);
-        }
-        wb
-    }
-
-    fn copied(wb: &Workbook, range: &str) -> String {
-        let r = RangeRef::parse(range).unwrap();
-        range_html(wb, 0, r, &crate::display::range_text(wb, 0, r)).unwrap()
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    fn save_fails_upfront_when_the_temp_name_is_taken() {
-        // Another local user who can write the directory must not be able to point the
-        // save's predictable temporary name at their own file: creation is exclusive.
-        let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-temp-name-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let victim = dir.join("victim.txt");
-        std::fs::write(&victim, b"original").unwrap();
-        let dest = dir.join("book.xlsx");
-        std::os::unix::fs::symlink(&victim, dir.join("book.xlsx.sctmp")).unwrap();
-        let err = write_file(dest.to_str().unwrap(), b"new").unwrap_err();
-        assert_eq!(std::fs::read(&victim).unwrap(), b"original");
-        assert!(!dir.join("book.xlsx").exists(), "{err}");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[cfg(unix)]
-    #[test]
-    fn save_keeps_the_destination_access_restrictions() {
-        use std::os::unix::fs::PermissionsExt;
-        let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-permissions-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let dest = dir.join("private.xlsx");
-        std::fs::write(&dest, b"v1").unwrap();
-        std::fs::set_permissions(&dest, std::fs::Permissions::from_mode(0o600)).unwrap();
-        write_file(dest.to_str().unwrap(), b"v2").unwrap();
-        let mode = std::fs::metadata(&dest).unwrap().permissions().mode() & 0o777;
-        assert_eq!(mode, 0o600);
-        // And a brand-new file is created with the restrictive, not permissive, default.
-        let fresh = dir.join("new.xlsx");
-        write_file(fresh.to_str().unwrap(), b"v").unwrap();
-        let mode = std::fs::metadata(&fresh).unwrap().permissions().mode() & 0o777;
-        assert!(mode & 0o022 == 0, "mode {mode:o}");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    fn open_refuses_directories_and_unknowable_lengths() {
-        let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-open-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        assert!(read_file(dir.to_str().unwrap()).is_err(), "a directory is not a regular file");
-        assert!(read_file(dir.join("missing").to_str().unwrap()).is_err());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn html_export_refuses_an_outsized_grid_instead_of_growing_forever() {
-        // #2387: the used rectangle alone bounds the output (every row writes the whole
-        // column span), so a sparse sheet with one cell at A1 and another far right
-        // 300 rows down is 4.9M cells → refused before a byte of `<td>` is written.
-        let mut wb = Workbook::new();
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.set_value(CellRef::new(0, 0), gridcraft_core::Value::Text("start".into()));
-        sh.set_value(CellRef::new(300, 16383), gridcraft_core::Value::Text("corner".into()));
-        let err = to_html(&wb, 0).unwrap_err();
-        assert!(err.to_string().contains("too tall × wide"), "{err}");
-        // A normal sheet is fine.
-        let mut ok = Workbook::new();
-        ok.sheet_mut(0).unwrap().set_value(CellRef::new(5, 2), gridcraft_core::Value::Text("t".into()));
-        assert!(to_html(&ok, 0).is_ok());
-    }
-
-    #[test]
-    fn html_export_embeds_images_as_data_uris() {
-        let mut wb = Workbook::new();
-        wb.sheet_mut(0).unwrap().images.push(gridcraft_model::Image {
-            id: 1,
-            anchor: gridcraft_model::Anchor { cell: CellRef::new(0, 0), dx: 0.0, dy: 0.0, width: 72.0, height: 36.0, mode: Default::default() },
-            data: vec![1, 2, 3].into(),
-            mime: "image/png".into(),
-            alt: "a \"logo\"".into(),
-        });
-        let html = to_html(&wb, 0).unwrap();
-        assert!(
-            html.contains("<img src=\"data:image/png;base64,AQID\" alt=\"a &quot;logo&quot;\" style=\"position:absolute;left:0px;top:0px;width:72px;height:36px\"></div></body>"),
-            "{html}"
-        );
-        assert!(html.contains("<div style=\"position:relative\"><table"), "{html}");
-        assert!(!to_html(&Workbook::new(), 0).unwrap().contains("<img"), "no images, no <img>");
-    }
-
-    #[test]
-    fn html_export_places_images_at_their_anchor_using_sheet_geometry() {
-        let mut wb = Workbook::new();
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.cols.insert(1, gridcraft_model::LineInfo { size: Some(100.0), ..Default::default() });
-        sh.rows.insert(1, gridcraft_model::LineInfo { size: Some(30.0), ..Default::default() });
-        sh.images.push(gridcraft_model::Image {
-            id: 1,
-            anchor: gridcraft_model::Anchor { cell: CellRef::new(3, 2), dx: 5.0, dy: 7.0, width: 10.0, height: 20.0, mode: Default::default() },
-            data: vec![1].into(),
-            mime: "image/png".into(),
-            alt: String::new(),
-        });
-        sh.set_value(CellRef::new(1, 1), gridcraft_core::Value::Number(1.0));
-        let html = to_html(&wb, 0).unwrap();
-        // The table starts at B2; the picture is at C4: one 100 px column and two rows (30 + 20) further on.
-        assert!(html.contains("<col style=\"width:100px\">"), "{html}");
-        assert!(html.contains("<tr style=\"height:30px\">"), "{html}");
-        assert!(html.contains("left:105px;top:57px;width:10px;height:20px"), "{html}");
-    }
-
-    fn book_with_picture(anchor: &str, cell_at: (u32, u32)) -> Workbook {
-        let mut wb = Workbook::new();
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.set_value(CellRef::new(cell_at.0, cell_at.1), gridcraft_core::Value::Number(1.0));
-        sh.images.push(gridcraft_model::Image {
-            id: 1,
-            anchor: gridcraft_model::Anchor {
-                cell: CellRef::parse(anchor).unwrap(),
-                dx: 0.0,
-                dy: 0.0,
-                width: 10.0,
-                height: 10.0,
-                mode: Default::default(),
-            },
-            data: vec![1].into(),
-            mime: "image/png".into(),
-            alt: String::new(),
-        });
-        wb
-    }
-
-    #[test]
-    fn html_export_places_images_past_hidden_columns_and_rows() {
-        let mut wb = book_with_picture("C3", (0, 0));
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.set_value(CellRef::new(2, 2), gridcraft_core::Value::Number(2.0));
-        sh.cols.insert(1, gridcraft_model::LineInfo { hidden: true, ..Default::default() });
-        sh.rows.insert(1, gridcraft_model::LineInfo { hidden: true, ..Default::default() });
-        let html = to_html(&wb, 0).unwrap();
-        // Column B and row 2 take no room: C3 is one default column and row from A1.
-        assert_eq!(html.matches("<col ").count(), 2, "{html}");
-        assert_eq!(html.matches("<tr ").count(), 2, "{html}");
-        assert!(html.contains("left:64px;top:20px"), "{html}");
-    }
-
-    #[test]
-    fn html_export_places_images_above_and_left_of_the_table() {
-        let html = to_html(&book_with_picture("A1", (2, 2)), 0).unwrap();
-        // The table starts at C3, so a picture at A1 sits before it instead of failing.
-        assert!(html.contains("left:-128px;top:-40px"), "{html}");
-    }
-
-    #[test]
-    fn html_export_marks_right_to_left_sheets() {
-        use gridcraft_core::Value;
-        use gridcraft_model::HAlign;
-        let wb = book(true, &[("A1", Value::text("Hello!"), HAlign::General), ("B1", Value::Number(-5.0), HAlign::General)]);
-        let html = to_html(&wb, 0).unwrap();
-        assert!(html.contains("<body><table dir=\"rtl\">"), "{html}");
-        assert!(html.contains("<td style=\"\" dir=\"auto\">Hello!</td>"), "Latin text keeps its own direction: {html}");
-        assert!(
-            html.contains("<td style=\"text-align:left;\" dir=\"ltr\">-5</td>"),
-            "numbers mirror to the left and keep their sign in front: {html}"
-        );
-        let clip = copied(&wb, "A1:B1");
-        assert!(clip.starts_with("<table dir=\"rtl\" style="), "{clip}");
-        assert_eq!(clip.matches("dir=\"auto\"").count(), 1, "{clip}");
-        assert!(clip.contains("text-align:left;\" dir=\"ltr\">-5</td>"), "{clip}");
-
-        let ltr = book(false, &[("A1", Value::text("Hello!"), HAlign::General)]);
-        assert!(to_html(&ltr, 0).unwrap().contains("<body><table><tr>"));
-        assert!(copied(&ltr, "A1").starts_with("<table style="));
-    }
-
-    #[test]
-    fn html_export_lets_arabic_general_text_align_by_direction() {
-        use gridcraft_core::Value;
-        use gridcraft_model::HAlign;
-        let wb = book(
-            false,
-            &[
-                ("A1", Value::text("مرحبا!"), HAlign::General),
-                ("B1", Value::text("שלום"), HAlign::Left),
-                ("C1", Value::text("مرحبا"), HAlign::Center),
-                ("D1", Value::text("Hello"), HAlign::General),
-            ],
-        );
-        let html = to_html(&wb, 0).unwrap();
-        assert!(html.contains("<td style=\"\" dir=\"auto\">مرحبا!</td>"), "General Arabic text aligns by its direction: {html}");
-        assert!(html.contains("<td style=\"text-align:left;\" dir=\"auto\">שלום</td>"), "explicit alignment stays: {html}");
-        assert!(html.contains("<td style=\"text-align:center;\" dir=\"auto\">مرحبا</td>"), "{html}");
-        assert!(html.contains("<td style=\"text-align:left;\">Hello</td>"), "{html}");
-        assert!(html.contains("<body><table><tr>"), "a left-to-right sheet has no table direction: {html}");
-
-        let clip = copied(&wb, "A1:D1");
-        let cells: Vec<&str> = clip.split("<td ").skip(1).collect();
-        assert_eq!(cells.len(), 4, "{clip}");
-        assert!(cells[0].contains("dir=\"auto\"") && !cells[0].contains("text-align"), "{clip}");
-        assert!(cells[1].contains("text-align:left;") && cells[1].contains("dir=\"auto\""), "{clip}");
-        assert!(cells[3].contains("text-align:left;") && !cells[3].contains("dir="), "{clip}");
-    }
-
-    #[test]
-    fn html_export_of_latin_ltr_sheet_is_unchanged() {
-        use gridcraft_core::Value;
-        use gridcraft_model::HAlign;
-        let mut wb = book(
-            false,
-            &[
-                ("A1", Value::text("Name"), HAlign::General),
-                ("B1", Value::text("Qty"), HAlign::Center),
-                ("A2", Value::text("Apples & <pears>"), HAlign::General),
-                ("B2", Value::Number(3.0), HAlign::General),
-                ("A3", Value::text("Total"), HAlign::Right),
-            ],
-        );
-        wb.sheet_mut(0).unwrap().merges.push(RangeRef::parse("A3:B3").unwrap());
-        assert_eq!(
-            to_html(&wb, 0).unwrap(),
-            "<!doctype html><html><head><meta charset=\"utf-8\"><title>Sheet1</title><style>table{border-collapse:collapse;font-family:Calibri,Carlito,Arial,sans-serif;font-size:11pt}td{border:1px solid #d4d4d4;padding:2px 4px;white-space:nowrap}</style></head><body><table>\
-             <tr><td style=\"text-align:left;\">Name</td><td style=\"text-align:center;\">Qty</td></tr>\
-             <tr><td style=\"text-align:left;\">Apples &amp; &lt;pears&gt;</td><td style=\"text-align:right;\">3</td></tr>\
-             <tr><td style=\"text-align:right;\" rowspan=\"1\" colspan=\"2\">Total</td></tr>\
-             </table></body></html>"
-        );
-        let cell = "border:1px solid #d4d4d4;padding:2px 4px;white-space:pre-wrap;";
-        assert_eq!(
-            copied(&wb, "A1:B2"),
-            format!(
-                "<table style=\"border-collapse:collapse;font-family:Calibri,Carlito,Arial,sans-serif;font-size:11pt\">\
-                 <tr><td style=\"{cell}text-align:left;\">Name</td><td style=\"{cell}text-align:center;\">Qty</td></tr>\
-                 <tr><td style=\"{cell}text-align:left;\">Apples &amp; &lt;pears&gt;</td><td style=\"{cell}text-align:right;\">3</td></tr></table>"
-            )
-        );
-    }
-
-    #[test]
-    fn html_export_fails_instead_of_dropping_cells_past_the_row_limit() {
-        let mut wb = Workbook::new();
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.set_value(CellRef::new(0, 0), gridcraft_core::Value::text("near"));
-        sh.set_value(CellRef::new(149_999, 0), gridcraft_core::Value::text("far"));
-        assert!(save_bytes(&wb, "book.html").is_err());
-        let sh = wb.sheet_mut(0).unwrap();
-        sh.remove_cell(CellRef::new(149_999, 0));
-        sh.set_value(CellRef::new(100_000, 0), gridcraft_core::Value::text("far"));
-        let html = String::from_utf8(save_bytes(&wb, "book.html").unwrap()).unwrap();
-        assert!(html.contains(">near</td>") && html.contains(">far</td>"));
-    }
-
-    #[test]
-    fn macros_are_saved_only_into_xlsm() {
-        let mut wb = Workbook::new();
-        wb.vba_project = Some(b"vba".to_vec().into());
-        let has_macros = |path: &str| {
-            let bytes = save_bytes(&wb, path).unwrap();
-            gridcraft_xlsx::read_xlsx(&bytes).unwrap().0.vba_project.is_some()
-        };
-        assert!(has_macros("book.xlsm"));
-        assert!(has_macros("BOOK.XLSM"));
-        assert!(!has_macros("book.xlsx"), "an .xlsx never carries a VBA project");
-        assert!(has_macros("book.xltm"), "a macro-enabled template keeps the VBA project");
-        assert!(!has_macros("book.xltx"), "a macro-free template never carries a VBA project");
-        assert!(wb.vba_project.is_some(), "the open workbook keeps its macros");
-    }
-
-    #[test]
-    fn csv_named_history_does_not_get_the_reserved_sheet_name() {
-        for file in ["History.csv", "hIsToRy.csv", "history.tsv"] {
-            let (wb, _) = open_bytes(file, b"1\n").unwrap();
-            let name = wb.sheets[0].name.clone();
-            assert!(wb.check_sheet_name(&name, Some(0)).is_ok(), "{file} opened as {name:?}");
-        }
-        let (wb, _) = open_bytes("Sales.csv", b"1\n").unwrap();
-        assert_eq!(wb.sheets[0].name, "Sales");
-    }
-
-    /// A save that can't be put in place (here a folder already has the workbook's name, as
-    /// with a file another app holds locked) fails without leaving `<name>.sctmp` behind.
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    fn failed_save_leaves_no_temporary_file() {
-        let dir = std::env::temp_dir().join(format!("gridcraft-write-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let blocked = dir.join("Book1.xlsx");
-        std::fs::create_dir(&blocked).unwrap();
-        assert!(write_file(blocked.to_str().unwrap(), b"workbook").is_err());
-        assert!(!dir.join("Book1.xlsx.sctmp").exists(), "the temporary file is removed");
-        // An ordinary save still works and leaves only the workbook.
-        let ok = dir.join("Book2.xlsx");
-        write_file(ok.to_str().unwrap(), b"workbook").unwrap();
-        assert_eq!(std::fs::read(&ok).unwrap(), b"workbook");
-        assert!(!dir.join("Book2.xlsx.sctmp").exists());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    /// While a script runs (#2178), file reads and writes are refused whatever command or
-    /// parameter asked for them; nesting and dropping the sandbox restore access.
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    fn script_sandbox_refuses_file_access_until_dropped() {
-        let dir = std::env::temp_dir().join(format!("gridcraft-sandbox-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let existing = dir.join("in.csv");
-        std::fs::write(&existing, b"a,b\n").unwrap();
-        let (existing, out) = (existing.to_string_lossy().to_string(), dir.join("out.xlsx").to_string_lossy().to_string());
-        {
-            let _outer = ScriptSandbox::enter();
-            {
-                let _inner = ScriptSandbox::enter();
-                assert!(read_file(&existing).is_err());
-            }
-            assert!(read_file(&existing).is_err(), "the outer sandbox still holds");
-            assert!(write_file(&out, b"leak").is_err());
-            assert!(!std::path::Path::new(&out).exists());
-        }
-        assert_eq!(read_file(&existing).unwrap(), b"a,b\n");
-        write_file(&out, b"ok").unwrap();
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    /// A minimal compound (CFB/OLE2) file — FAT in sector 0, directory in sector 1 — holding a
-    /// root entry and the given stream names.
-    fn cfb(streams: &[&str]) -> Vec<u8> {
-        let mut b = vec![0u8; 512 * 3];
-        let mut put = |at: usize, v: &[u8]| b[at..at + v.len()].copy_from_slice(v);
-        put(0, &[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
-        put(30, &9u16.to_le_bytes());
-        put(44, &1u32.to_le_bytes());
-        put(48, &1u32.to_le_bytes());
-        put(68, &0xFFFF_FFFEu32.to_le_bytes());
-        for i in 1..109 {
-            put(76 + i * 4, &0xFFFF_FFFFu32.to_le_bytes());
-        }
-        put(512, &0xFFFF_FFFDu32.to_le_bytes());
-        put(516, &0xFFFF_FFFEu32.to_le_bytes());
-        for (k, name) in std::iter::once("Root Entry").chain(streams.iter().copied()).enumerate() {
-            let units: Vec<u8> = name.encode_utf16().flat_map(u16::to_le_bytes).collect();
-            put(1024 + k * 128, &units);
-            put(1024 + k * 128 + 64, &(units.len() as u16 + 2).to_le_bytes());
-        }
-        b
-    }
-
-    /// Cut-list rows as a CAD/CAM program exports them: `;`-separated, CRLF, part codes in the last
-    /// two columns, a part name containing a comma.
-    const CUT_LIST: &str = "1;511;184;P3_L1_led;2162PE;16;1MM_2162PE;1MM_2162PE;;;1244121406FB;\r\n\
-                            1;562.5;510;Komoda, lijevo;2162PE;19;1MM_2162PE;;;;12441214071A;124412140710\r\n";
-
-    #[test]
-    fn csv_save_keeps_the_separator_it_was_opened_with() {
-        let (wb, _) = open_bytes("cut list.csv", CUT_LIST.as_bytes()).unwrap();
-        assert_eq!(wb.csv_delimiter, Some(b';'));
-        assert_eq!(String::from_utf8(save_bytes(&wb, "cut list.csv").unwrap()).unwrap(), CUT_LIST);
-        // Save As another .csv name keeps it too; a comma file stays a comma file (quoting only
-        // fields that contain the separator in use).
-        assert_eq!(String::from_utf8(save_bytes(&wb, "copy.CSV").unwrap()).unwrap(), CUT_LIST);
-        let commas = "\"Komoda, lijevo\",b\r\n1,x;y\r\n";
-        let (wb, _) = open_bytes("plain.csv", commas.as_bytes()).unwrap();
-        assert_eq!(String::from_utf8(save_bytes(&wb, "plain.csv").unwrap()).unwrap(), commas);
-        // A tab-separated file named .csv round-trips with tabs.
-        let tabs = "a\tb\r\n1\t2\r\n";
-        let (wb, _) = open_bytes("tabs.csv", tabs.as_bytes()).unwrap();
-        assert_eq!(String::from_utf8(save_bytes(&wb, "tabs.csv").unwrap()).unwrap(), tabs);
-    }
-
-    #[test]
-    fn csv_save_of_a_workbook_not_read_from_csv_uses_commas() {
-        let mut wb = Workbook::new();
-        if let Some(sh) = wb.sheet_mut(0) {
-            sh.set_value(CellRef::new(0, 0), gridcraft_core::Value::text("a"));
-            sh.set_value(CellRef::new(0, 1), gridcraft_core::Value::Number(1.0));
-        }
-        assert_eq!(save_bytes(&wb, "new.csv").unwrap(), b"a,1\r\n");
-        // Through .xlsx the CSV origin is gone, as in Excel.
-        let (from_csv, _) = open_bytes("cut list.csv", CUT_LIST.as_bytes()).unwrap();
-        let (reopened, _) = open_bytes("book.xlsx", &save_bytes(&from_csv, "book.xlsx").unwrap()).unwrap();
-        assert_eq!(reopened.csv_delimiter, None);
-        assert!(String::from_utf8(save_bytes(&reopened, "again.csv").unwrap()).unwrap().starts_with("1,511,184,"));
-        // A .tsv/.txt saved as .csv gets commas; as .tsv it keeps tabs.
-        let (tsv, _) = open_bytes("list.txt", b"a\tb\r\n").unwrap();
-        assert_eq!(save_bytes(&tsv, "list.csv").unwrap(), b"a,b\r\n");
-        assert_eq!(save_bytes(&tsv, "list.tsv").unwrap(), b"a\tb\r\n");
-    }
-
-    #[test]
-    fn encrypted_workbook_is_reported_not_misread() {
-        let file = gridcraft_xlsx::testing::encrypt_workbook(b"package", "pw");
-        let msg = open_bytes("secret.xlsx", &file).unwrap_err().to_string();
-        assert!(msg.contains(PASSWORD_REQUIRED), "got: {msg}");
-        assert!(!msg.contains("zip"), "must not surface the zip error: {msg}");
-        // A compound file naming the streams but unreadable is damage: no password is asked for,
-        // and none helps.
-        let file = cfb(&["EncryptionInfo", "EncryptedPackage"]);
-        for password in [None, Some("pw")] {
-            let msg = open_bytes_with_password("secret.xlsx", &file, password).unwrap_err().to_string();
-            assert!(msg.contains("damaged") && !msg.contains(PASSWORD_REQUIRED), "got: {msg}");
-        }
-    }
-
-    #[test]
-    fn encryption_no_password_opens_is_reported_without_asking_for_one() {
-        let info: &[u8] = &[3, 0, 2, 0, 4, 0, 0, 0]; // Standard header flags: RC4, not AES
-        let file = gridcraft_xlsx::testing::compound_file(&[("EncryptionInfo", info), ("EncryptedPackage", &[0; 8])]);
-        let msg = open_bytes("rc4.xlsx", &file).unwrap_err().to_string();
-        assert!(msg.contains("RC4") && !msg.contains(PASSWORD_REQUIRED), "got: {msg}");
-        let irm = gridcraft_xlsx::testing::compound_file(&[("EncryptedPackage", &[0; 8])]);
-        let msg = open_bytes("irm.xlsx", &irm).unwrap_err().to_string();
-        assert!(msg.contains("rights-management") && !msg.contains("damaged"), "got: {msg}");
-    }
-
-    #[test]
-    fn other_compound_files_are_not_called_encrypted() {
-        let err = open_bytes("old.doc", &cfb(&["WordDocument", "\u{5}SummaryInformation"])).unwrap_err();
-        let msg = err.to_string();
-        assert!(msg.contains("not an Excel workbook"), "got: {msg}");
-        assert!(!msg.contains("password"), "got: {msg}");
-    }
-
-    /// Save As CSV/TSV writes cells as displayed: number formats applied, formula results,
-    /// whole values in narrow columns (never `#####`), quoting unchanged.
-    #[test]
-    fn csv_writes_displayed_text() {
-        use gridcraft_core::{CellError, Value};
-        use gridcraft_model::{Cell, Formula, LineInfo, NumFmt, StyleId};
-        let mut wb = Workbook::new();
-        let mut styled = |code: &str| wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new(code));
-        let (date, money, pct, frac, text, fixed, thousands) =
-            (styled("yyyy-mm-dd"), styled("$#,##0.00"), styled("0.0%"), styled("# ?/?"), styled("@"), styled("0.00"), styled("#,##0"));
-        let sh = wb.sheet_mut(0).unwrap();
-        let cells = [
-            ("A1", Cell { value: Value::Number(46023.0), formula: None, style: date }),
-            ("B1", Cell { value: Value::Number(1234.5), formula: None, style: money }),
-            ("C1", Cell { value: Value::Number(0.125), formula: None, style: pct }),
-            ("D1", Cell { value: Value::Number(1.5), formula: None, style: frac }),
-            ("E1", Cell { value: Value::text("007"), formula: None, style: text }),
-            ("F1", Cell { value: Value::Error(CellError::NA), formula: None, style: money }),
-            ("G1", Cell { value: Value::Bool(true), formula: None, style: StyleId::DEFAULT }),
-            ("A2", Cell { value: Value::Number(46024.0), style: date, ..Cell::formula(Formula::new("A1+1")) }),
-            ("B2", Cell { value: Value::Number(12345678.9), formula: None, style: fixed }),
-            ("C2", Cell { value: Value::Number(-0.25), formula: None, style: StyleId::DEFAULT }),
-            ("D2", Cell { value: Value::Number(1234567.0), formula: None, style: thousands }),
-        ];
-        for (a, c) in cells {
-            sh.set_cell(CellRef::parse(a).unwrap(), c);
-        }
-        // Column B is far too narrow for its numbers: the grid shows #####, the file must not.
-        sh.cols.insert(1, LineInfo { size: Some(1.0), ..Default::default() });
-        sh.show_formulas = true;
-        let csv = String::from_utf8(save_bytes(&wb, "out.csv").unwrap()).unwrap();
-        assert_eq!(csv, "2026-01-01,\"$1,234.50\",12.5%,1 1/2,007,#N/A,TRUE\r\n2026-01-02,12345678.90,-0.25,\"1,234,567\",,,\r\n");
-        let tsv = String::from_utf8(save_bytes(&wb, "out.tsv").unwrap()).unwrap();
-        assert!(tsv.starts_with("2026-01-01\t$1,234.50\t12.5%\t"), "{tsv}");
-    }
-
-    #[test]
-    fn delimited_exports_preserve_general_precision_and_explicit_number_formats() {
-        use gridcraft_core::Value;
-        use gridcraft_model::{Cell, NumFmt, StyleId};
-        let mut workbook = Workbook::new();
-        let scientific = workbook.styles.derive(StyleId::DEFAULT, |style| style.num_fmt = NumFmt::new("0.00E+00"));
-        let sheet = workbook.sheet_mut(0).unwrap();
-        sheet.set_cell(CellRef::new(0, 0), Cell { value: Value::Number(124412140710.0), ..Default::default() });
-        sheet.set_cell(CellRef::new(0, 1), Cell { value: Value::Number(1.23456789012345), ..Default::default() });
-        sheet.set_cell(CellRef::new(0, 2), Cell { value: Value::Number(124412140710.0), style: scientific, ..Default::default() });
-        for (path, separator) in [("data.csv", ","), ("data.tsv", "\t")] {
-            let output = String::from_utf8(save_bytes(&workbook, path).unwrap()).unwrap();
-            assert_eq!(output, format!("124412140710{separator}1.23456789012345{separator}1.24E+11\r\n"));
-        }
-    }
-
-    #[test]
-    fn template_extension_saves_template_content_type() {
-        let bytes = save_bytes(&Workbook::new(), "Budget.xltx").unwrap();
-        let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
-        let mut types = String::new();
-        std::io::Read::read_to_string(&mut zip.by_name("[Content_Types].xml").unwrap(), &mut types).unwrap();
-        assert!(
-            types.contains(
-                r#"PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml""#
-            ),
-            "{types}"
-        );
-    }
-
-    /// Where `part`'s entry starts in the central directory of `package`.
-    fn central_entry(package: &[u8], part: &str) -> usize {
-        let mut at = 0;
-        while let Some(i) = package.get(at..).and_then(|rest| rest.windows(4).position(|w| w == b"PK\x01\x02")) {
-            let entry = at + i;
-            let len = u16::from_le_bytes([package[entry + 28], package[entry + 29]]) as usize;
-            if &package[entry + 46..entry + 46 + len] == part.as_bytes() {
-                return entry;
-            }
-            at = entry + 46;
-        }
-        panic!("{part} is not in the package");
-    }
-
-    /// `package` with `part` declaring `size` unpacked bytes: the reader refuses the part on the
-    /// declared size, so no real 512 MB part has to be built.
-    fn declaring(mut package: Vec<u8>, part: &str, size: u32) -> Vec<u8> {
-        let at = central_entry(&package, part);
-        package[at + 24..at + 28].copy_from_slice(&size.to_le_bytes());
-        package
-    }
-
-    #[test]
-    fn a_part_over_the_size_limit_says_how_to_get_the_data_in() {
-        let mut wb = Workbook::new();
-        wb.sheet_mut(0).unwrap().set_value(CellRef::new(0, 0), gridcraft_core::Value::text("big"));
-        let package = save_bytes(&wb, "big.xlsx").unwrap();
-        // The size reported in storytold/gridcraft#1242.
-        let msg = open_bytes("big.xlsx", &declaring(package.clone(), "xl/worksheets/sheet1.xml", 540_278_731)).unwrap_err().to_string();
-        assert!(msg.starts_with("We can't open 'big.xlsx': "), "{msg}");
-        assert!(msg.contains("xl/worksheets/sheet1.xml") && msg.contains("515 MB") && msg.contains("512 MB"), "{msg}");
-        assert!(msg.contains("several sheets") && msg.contains("CSV"), "{msg}");
-        assert!(!msg.contains("bytes"), "{msg}");
-        // Splitting sheets doesn't shrink the shared strings, which every sheet uses: only CSV helps.
-        let msg = open_bytes("big.xlsx", &declaring(package.clone(), "xl/sharedStrings.xml", 540_278_731)).unwrap_err().to_string();
-        assert!(msg.contains("xl/sharedStrings.xml") && msg.contains("515 MB") && msg.contains("CSV"), "{msg}");
-        assert!(!msg.contains("several sheets"), "{msg}");
-        // Just over the limit never reads as a size equal to it.
-        let msg = open_bytes("big.xlsx", &declaring(package, "xl/worksheets/sheet1.xml", 512 * 1024 * 1024 + 1)).unwrap_err().to_string();
-        assert!(msg.contains("more than 512 MB"), "{msg}");
-        // A package that fails for another reason keeps its own error, oversized part or not.
-        let mut broken = declaring(save_bytes(&wb, "big.xlsx").unwrap(), "xl/worksheets/sheet1.xml", 540_278_731);
-        let at = central_entry(&broken, "xl/workbook.xml");
-        broken[at + 46 + "xl/workbook.xml".len() - 1] = b'x';
-        let msg = open_bytes("big.xlsx", &broken).unwrap_err().to_string();
-        assert!(msg.starts_with("We can't open 'big.xlsx': ") && !msg.contains("unpacks"), "{msg}");
-    }
-
-    #[test]
-    fn content_wins_over_a_mismatched_extension() {
-        let mut wb = Workbook::new();
-        wb.sheet_mut(0).unwrap().set_value(CellRef::new(0, 0), gridcraft_core::Value::Number(7.0));
-        let package = save_bytes(&wb, "book.xlsx").unwrap();
-        for name in ["book.xlsx", "book.ods", "book.xlsb", "book.csv"] {
-            let (opened, _) = open_bytes(name, &package).unwrap_or_else(|e| panic!("{name}: {e}"));
-            assert_eq!(opened.sheet(0).unwrap().value(CellRef::new(0, 0)), gridcraft_core::Value::Number(7.0), "{name}");
-        }
-        for name in ["data.xlsx", "data.csv"] {
-            let (opened, _) = open_bytes(name, b"a,b\n1,2\n").unwrap_or_else(|e| panic!("{name}: {e}"));
-            assert_eq!(opened.sheet(0).unwrap().value(CellRef::new(0, 1)), gridcraft_core::Value::text("b"), "{name}");
-        }
-    }
-}
+mod tests;
diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs
new file mode 100644
index 000000000..36e5cad89
--- /dev/null
+++ b/crates/engine/src/io/tests.rs
@@ -0,0 +1,567 @@
+use super::*;
+
+fn book(rtl: bool, cells: &[(&str, gridcraft_core::Value, gridcraft_model::HAlign)]) -> Workbook {
+    let mut wb = Workbook::new();
+    let ids: Vec<_> = cells.iter().map(|(_, _, h)| wb.styles.derive(gridcraft_model::StyleId::DEFAULT, |st| st.align.h = *h)).collect();
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.right_to_left = rtl;
+    for ((at, value, _), id) in cells.iter().zip(ids) {
+        let c = CellRef::parse(at).unwrap();
+        sh.set_value(c, value.clone());
+        sh.set_style(c, id);
+    }
+    wb
+}
+
+fn copied(wb: &Workbook, range: &str) -> String {
+    let r = RangeRef::parse(range).unwrap();
+    range_html(wb, 0, r, &crate::display::range_text(wb, 0, r)).unwrap()
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn save_fails_upfront_when_the_temp_name_is_taken() {
+    // Another local user who can write the directory must not be able to point the
+    // save's predictable temporary name at their own file: creation is exclusive.
+    let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-temp-name-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let victim = dir.join("victim.txt");
+    std::fs::write(&victim, b"original").unwrap();
+    let dest = dir.join("book.xlsx");
+    std::os::unix::fs::symlink(&victim, dir.join("book.xlsx.sctmp")).unwrap();
+    let err = write_file(dest.to_str().unwrap(), b"new").unwrap_err();
+    assert_eq!(std::fs::read(&victim).unwrap(), b"original");
+    assert!(!dir.join("book.xlsx").exists(), "{err}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(unix)]
+#[test]
+fn save_keeps_the_destination_access_restrictions() {
+    use std::os::unix::fs::PermissionsExt;
+    let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-permissions-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let dest = dir.join("private.xlsx");
+    std::fs::write(&dest, b"v1").unwrap();
+    std::fs::set_permissions(&dest, std::fs::Permissions::from_mode(0o600)).unwrap();
+    write_file(dest.to_str().unwrap(), b"v2").unwrap();
+    let mode = std::fs::metadata(&dest).unwrap().permissions().mode() & 0o777;
+    assert_eq!(mode, 0o600);
+    // And a brand-new file is created with the restrictive, not permissive, default.
+    let fresh = dir.join("new.xlsx");
+    write_file(fresh.to_str().unwrap(), b"v").unwrap();
+    let mode = std::fs::metadata(&fresh).unwrap().permissions().mode() & 0o777;
+    assert!(mode & 0o022 == 0, "mode {mode:o}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn open_refuses_directories_and_unknowable_lengths() {
+    let dir = std::env::temp_dir().join(format!("gridcraft-fs-safety-open-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    assert!(read_file(dir.to_str().unwrap()).is_err(), "a directory is not a regular file");
+    assert!(read_file(dir.join("missing").to_str().unwrap()).is_err());
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn html_export_refuses_an_outsized_grid_instead_of_growing_forever() {
+    // #2387: the used rectangle alone bounds the output (every row writes the whole
+    // column span), so a sparse sheet with one cell at A1 and another far right
+    // 300 rows down is 4.9M cells → refused before a byte of `<td>` is written.
+    let mut wb = Workbook::new();
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.set_value(CellRef::new(0, 0), gridcraft_core::Value::Text("start".into()));
+    sh.set_value(CellRef::new(300, 16383), gridcraft_core::Value::Text("corner".into()));
+    let err = to_html(&wb, 0).unwrap_err();
+    assert!(err.to_string().contains("too tall × wide"), "{err}");
+    // A normal sheet is fine.
+    let mut ok = Workbook::new();
+    ok.sheet_mut(0).unwrap().set_value(CellRef::new(5, 2), gridcraft_core::Value::Text("t".into()));
+    assert!(to_html(&ok, 0).is_ok());
+}
+
+#[test]
+fn html_export_embeds_images_as_data_uris() {
+    let mut wb = Workbook::new();
+    wb.sheet_mut(0).unwrap().images.push(gridcraft_model::Image {
+        id: 1,
+        anchor: gridcraft_model::Anchor { cell: CellRef::new(0, 0), dx: 0.0, dy: 0.0, width: 72.0, height: 36.0, mode: Default::default() },
+        data: vec![1, 2, 3].into(),
+        mime: "image/png".into(),
+        alt: "a \"logo\"".into(),
+    });
+    let html = to_html(&wb, 0).unwrap();
+    assert!(
+        html.contains("<img src=\"data:image/png;base64,AQID\" alt=\"a &quot;logo&quot;\" style=\"position:absolute;left:0px;top:0px;width:72px;height:36px\"></div></body>"),
+        "{html}"
+    );
+    assert!(html.contains("<div style=\"position:relative\"><table"), "{html}");
+    assert!(!to_html(&Workbook::new(), 0).unwrap().contains("<img"), "no images, no <img>");
+}
+
+#[test]
+fn html_export_places_images_at_their_anchor_using_sheet_geometry() {
+    let mut wb = Workbook::new();
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.cols.insert(1, gridcraft_model::LineInfo { size: Some(100.0), ..Default::default() });
+    sh.rows.insert(1, gridcraft_model::LineInfo { size: Some(30.0), ..Default::default() });
+    sh.images.push(gridcraft_model::Image {
+        id: 1,
+        anchor: gridcraft_model::Anchor { cell: CellRef::new(3, 2), dx: 5.0, dy: 7.0, width: 10.0, height: 20.0, mode: Default::default() },
+        data: vec![1].into(),
+        mime: "image/png".into(),
+        alt: String::new(),
+    });
+    sh.set_value(CellRef::new(1, 1), gridcraft_core::Value::Number(1.0));
+    let html = to_html(&wb, 0).unwrap();
+    // The table starts at B2; the picture is at C4: one 100 px column and two rows (30 + 20) further on.
+    assert!(html.contains("<col style=\"width:100px\">"), "{html}");
+    assert!(html.contains("<tr style=\"height:30px\">"), "{html}");
+    assert!(html.contains("left:105px;top:57px;width:10px;height:20px"), "{html}");
+}
+
+fn book_with_picture(anchor: &str, cell_at: (u32, u32)) -> Workbook {
+    let mut wb = Workbook::new();
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.set_value(CellRef::new(cell_at.0, cell_at.1), gridcraft_core::Value::Number(1.0));
+    sh.images.push(gridcraft_model::Image {
+        id: 1,
+        anchor: gridcraft_model::Anchor {
+            cell: CellRef::parse(anchor).unwrap(),
+            dx: 0.0,
+            dy: 0.0,
+            width: 10.0,
+            height: 10.0,
+            mode: Default::default(),
+        },
+        data: vec![1].into(),
+        mime: "image/png".into(),
+        alt: String::new(),
+    });
+    wb
+}
+
+#[test]
+fn html_export_places_images_past_hidden_columns_and_rows() {
+    let mut wb = book_with_picture("C3", (0, 0));
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.set_value(CellRef::new(2, 2), gridcraft_core::Value::Number(2.0));
+    sh.cols.insert(1, gridcraft_model::LineInfo { hidden: true, ..Default::default() });
+    sh.rows.insert(1, gridcraft_model::LineInfo { hidden: true, ..Default::default() });
+    let html = to_html(&wb, 0).unwrap();
+    // Column B and row 2 take no room: C3 is one default column and row from A1.
+    assert_eq!(html.matches("<col ").count(), 2, "{html}");
+    assert_eq!(html.matches("<tr ").count(), 2, "{html}");
+    assert!(html.contains("left:64px;top:20px"), "{html}");
+}
+
+#[test]
+fn html_export_places_images_above_and_left_of_the_table() {
+    let html = to_html(&book_with_picture("A1", (2, 2)), 0).unwrap();
+    // The table starts at C3, so a picture at A1 sits before it instead of failing.
+    assert!(html.contains("left:-128px;top:-40px"), "{html}");
+}
+
+#[test]
+fn html_export_marks_right_to_left_sheets() {
+    use gridcraft_core::Value;
+    use gridcraft_model::HAlign;
+    let wb = book(true, &[("A1", Value::text("Hello!"), HAlign::General), ("B1", Value::Number(-5.0), HAlign::General)]);
+    let html = to_html(&wb, 0).unwrap();
+    assert!(html.contains("<body><table dir=\"rtl\">"), "{html}");
+    assert!(html.contains("<td style=\"\" dir=\"auto\">Hello!</td>"), "Latin text keeps its own direction: {html}");
+    assert!(
+        html.contains("<td style=\"text-align:left;\" dir=\"ltr\">-5</td>"),
+        "numbers mirror to the left and keep their sign in front: {html}"
+    );
+    let clip = copied(&wb, "A1:B1");
+    assert!(clip.starts_with("<table dir=\"rtl\" style="), "{clip}");
+    assert_eq!(clip.matches("dir=\"auto\"").count(), 1, "{clip}");
+    assert!(clip.contains("text-align:left;\" dir=\"ltr\">-5</td>"), "{clip}");
+
+    let ltr = book(false, &[("A1", Value::text("Hello!"), HAlign::General)]);
+    assert!(to_html(&ltr, 0).unwrap().contains("<body><table><tr>"));
+    assert!(copied(&ltr, "A1").starts_with("<table style="));
+}
+
+#[test]
+fn html_export_lets_arabic_general_text_align_by_direction() {
+    use gridcraft_core::Value;
+    use gridcraft_model::HAlign;
+    let wb = book(
+        false,
+        &[
+            ("A1", Value::text("مرحبا!"), HAlign::General),
+            ("B1", Value::text("שלום"), HAlign::Left),
+            ("C1", Value::text("مرحبا"), HAlign::Center),
+            ("D1", Value::text("Hello"), HAlign::General),
+        ],
+    );
+    let html = to_html(&wb, 0).unwrap();
+    assert!(html.contains("<td style=\"\" dir=\"auto\">مرحبا!</td>"), "General Arabic text aligns by its direction: {html}");
+    assert!(html.contains("<td style=\"text-align:left;\" dir=\"auto\">שלום</td>"), "explicit alignment stays: {html}");
+    assert!(html.contains("<td style=\"text-align:center;\" dir=\"auto\">مرحبا</td>"), "{html}");
+    assert!(html.contains("<td style=\"text-align:left;\">Hello</td>"), "{html}");
+    assert!(html.contains("<body><table><tr>"), "a left-to-right sheet has no table direction: {html}");
+
+    let clip = copied(&wb, "A1:D1");
+    let cells: Vec<&str> = clip.split("<td ").skip(1).collect();
+    assert_eq!(cells.len(), 4, "{clip}");
+    assert!(cells[0].contains("dir=\"auto\"") && !cells[0].contains("text-align"), "{clip}");
+    assert!(cells[1].contains("text-align:left;") && cells[1].contains("dir=\"auto\""), "{clip}");
+    assert!(cells[3].contains("text-align:left;") && !cells[3].contains("dir="), "{clip}");
+}
+
+#[test]
+fn html_export_of_latin_ltr_sheet_is_unchanged() {
+    use gridcraft_core::Value;
+    use gridcraft_model::HAlign;
+    let mut wb = book(
+        false,
+        &[
+            ("A1", Value::text("Name"), HAlign::General),
+            ("B1", Value::text("Qty"), HAlign::Center),
+            ("A2", Value::text("Apples & <pears>"), HAlign::General),
+            ("B2", Value::Number(3.0), HAlign::General),
+            ("A3", Value::text("Total"), HAlign::Right),
+        ],
+    );
+    wb.sheet_mut(0).unwrap().merges.push(RangeRef::parse("A3:B3").unwrap());
+    assert_eq!(
+        to_html(&wb, 0).unwrap(),
+        "<!doctype html><html><head><meta charset=\"utf-8\"><title>Sheet1</title><style>table{border-collapse:collapse;font-family:Calibri,Carlito,Arial,sans-serif;font-size:11pt}td{border:1px solid #d4d4d4;padding:2px 4px;white-space:nowrap}</style></head><body><table>\
+             <tr><td style=\"text-align:left;\">Name</td><td style=\"text-align:center;\">Qty</td></tr>\
+             <tr><td style=\"text-align:left;\">Apples &amp; &lt;pears&gt;</td><td style=\"text-align:right;\">3</td></tr>\
+             <tr><td style=\"text-align:right;\" rowspan=\"1\" colspan=\"2\">Total</td></tr>\
+             </table></body></html>"
+    );
+    let cell = "border:1px solid #d4d4d4;padding:2px 4px;white-space:pre-wrap;";
+    assert_eq!(
+        copied(&wb, "A1:B2"),
+        format!(
+            "<table style=\"border-collapse:collapse;font-family:Calibri,Carlito,Arial,sans-serif;font-size:11pt\">\
+                 <tr><td style=\"{cell}text-align:left;\">Name</td><td style=\"{cell}text-align:center;\">Qty</td></tr>\
+                 <tr><td style=\"{cell}text-align:left;\">Apples &amp; &lt;pears&gt;</td><td style=\"{cell}text-align:right;\">3</td></tr></table>"
+        )
+    );
+}
+
+#[test]
+fn html_export_fails_instead_of_dropping_cells_past_the_row_limit() {
+    let mut wb = Workbook::new();
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.set_value(CellRef::new(0, 0), gridcraft_core::Value::text("near"));
+    sh.set_value(CellRef::new(149_999, 0), gridcraft_core::Value::text("far"));
+    assert!(save_bytes(&wb, "book.html").is_err());
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.remove_cell(CellRef::new(149_999, 0));
+    sh.set_value(CellRef::new(100_000, 0), gridcraft_core::Value::text("far"));
+    let html = String::from_utf8(save_bytes(&wb, "book.html").unwrap()).unwrap();
+    assert!(html.contains(">near</td>") && html.contains(">far</td>"));
+}
+
+#[test]
+fn macros_are_saved_only_into_xlsm() {
+    let mut wb = Workbook::new();
+    wb.vba_project = Some(b"vba".to_vec().into());
+    let has_macros = |path: &str| {
+        let bytes = save_bytes(&wb, path).unwrap();
+        gridcraft_xlsx::read_xlsx(&bytes).unwrap().0.vba_project.is_some()
+    };
+    assert!(has_macros("book.xlsm"));
+    assert!(has_macros("BOOK.XLSM"));
+    assert!(!has_macros("book.xlsx"), "an .xlsx never carries a VBA project");
+    assert!(has_macros("book.xltm"), "a macro-enabled template keeps the VBA project");
+    assert!(!has_macros("book.xltx"), "a macro-free template never carries a VBA project");
+    assert!(wb.vba_project.is_some(), "the open workbook keeps its macros");
+}
+
+#[test]
+fn csv_named_history_does_not_get_the_reserved_sheet_name() {
+    for file in ["History.csv", "hIsToRy.csv", "history.tsv"] {
+        let (wb, _) = open_bytes(file, b"1\n").unwrap();
+        let name = wb.sheets[0].name.clone();
+        assert!(wb.check_sheet_name(&name, Some(0)).is_ok(), "{file} opened as {name:?}");
+    }
+    let (wb, _) = open_bytes("Sales.csv", b"1\n").unwrap();
+    assert_eq!(wb.sheets[0].name, "Sales");
+}
+
+/// A save that can't be put in place (here a folder already has the workbook's name, as
+/// with a file another app holds locked) fails without leaving `<name>.sctmp` behind.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn failed_save_leaves_no_temporary_file() {
+    let dir = std::env::temp_dir().join(format!("gridcraft-write-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let blocked = dir.join("Book1.xlsx");
+    std::fs::create_dir(&blocked).unwrap();
+    assert!(write_file(blocked.to_str().unwrap(), b"workbook").is_err());
+    assert!(!dir.join("Book1.xlsx.sctmp").exists(), "the temporary file is removed");
+    // An ordinary save still works and leaves only the workbook.
+    let ok = dir.join("Book2.xlsx");
+    write_file(ok.to_str().unwrap(), b"workbook").unwrap();
+    assert_eq!(std::fs::read(&ok).unwrap(), b"workbook");
+    assert!(!dir.join("Book2.xlsx.sctmp").exists());
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// While a script runs (#2178), file reads and writes are refused whatever command or
+/// parameter asked for them; nesting and dropping the sandbox restore access.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn script_sandbox_refuses_file_access_until_dropped() {
+    let dir = std::env::temp_dir().join(format!("gridcraft-sandbox-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let existing = dir.join("in.csv");
+    std::fs::write(&existing, b"a,b\n").unwrap();
+    let (existing, out) = (existing.to_string_lossy().to_string(), dir.join("out.xlsx").to_string_lossy().to_string());
+    {
+        let _outer = ScriptSandbox::enter();
+        {
+            let _inner = ScriptSandbox::enter();
+            assert!(read_file(&existing).is_err());
+        }
+        assert!(read_file(&existing).is_err(), "the outer sandbox still holds");
+        assert!(write_file(&out, b"leak").is_err());
+        assert!(!std::path::Path::new(&out).exists());
+    }
+    assert_eq!(read_file(&existing).unwrap(), b"a,b\n");
+    write_file(&out, b"ok").unwrap();
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// A minimal compound (CFB/OLE2) file — FAT in sector 0, directory in sector 1 — holding a
+/// root entry and the given stream names.
+fn cfb(streams: &[&str]) -> Vec<u8> {
+    let mut b = vec![0u8; 512 * 3];
+    let mut put = |at: usize, v: &[u8]| b[at..at + v.len()].copy_from_slice(v);
+    put(0, &[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
+    put(30, &9u16.to_le_bytes());
+    put(44, &1u32.to_le_bytes());
+    put(48, &1u32.to_le_bytes());
+    put(68, &0xFFFF_FFFEu32.to_le_bytes());
+    for i in 1..109 {
+        put(76 + i * 4, &0xFFFF_FFFFu32.to_le_bytes());
+    }
+    put(512, &0xFFFF_FFFDu32.to_le_bytes());
+    put(516, &0xFFFF_FFFEu32.to_le_bytes());
+    for (k, name) in std::iter::once("Root Entry").chain(streams.iter().copied()).enumerate() {
+        let units: Vec<u8> = name.encode_utf16().flat_map(u16::to_le_bytes).collect();
+        put(1024 + k * 128, &units);
+        put(1024 + k * 128 + 64, &(units.len() as u16 + 2).to_le_bytes());
+    }
+    b
+}
+
+/// Cut-list rows as a CAD/CAM program exports them: `;`-separated, CRLF, part codes in the last
+/// two columns, a part name containing a comma.
+const CUT_LIST: &str = "1;511;184;P3_L1_led;2162PE;16;1MM_2162PE;1MM_2162PE;;;1244121406FB;\r\n\
+                            1;562.5;510;Komoda, lijevo;2162PE;19;1MM_2162PE;;;;12441214071A;124412140710\r\n";
+
+#[test]
+fn csv_save_keeps_the_separator_it_was_opened_with() {
+    let (wb, _) = open_bytes("cut list.csv", CUT_LIST.as_bytes()).unwrap();
+    assert_eq!(wb.csv_delimiter, Some(b';'));
+    assert_eq!(String::from_utf8(save_bytes(&wb, "cut list.csv").unwrap()).unwrap(), CUT_LIST);
+    // Save As another .csv name keeps it too; a comma file stays a comma file (quoting only
+    // fields that contain the separator in use).
+    assert_eq!(String::from_utf8(save_bytes(&wb, "copy.CSV").unwrap()).unwrap(), CUT_LIST);
+    let commas = "\"Komoda, lijevo\",b\r\n1,x;y\r\n";
+    let (wb, _) = open_bytes("plain.csv", commas.as_bytes()).unwrap();
+    assert_eq!(String::from_utf8(save_bytes(&wb, "plain.csv").unwrap()).unwrap(), commas);
+    // A tab-separated file named .csv round-trips with tabs.
+    let tabs = "a\tb\r\n1\t2\r\n";
+    let (wb, _) = open_bytes("tabs.csv", tabs.as_bytes()).unwrap();
+    assert_eq!(String::from_utf8(save_bytes(&wb, "tabs.csv").unwrap()).unwrap(), tabs);
+}
+
+#[test]
+fn csv_save_of_a_workbook_not_read_from_csv_uses_commas() {
+    let mut wb = Workbook::new();
+    if let Some(sh) = wb.sheet_mut(0) {
+        sh.set_value(CellRef::new(0, 0), gridcraft_core::Value::text("a"));
+        sh.set_value(CellRef::new(0, 1), gridcraft_core::Value::Number(1.0));
+    }
+    assert_eq!(save_bytes(&wb, "new.csv").unwrap(), b"a,1\r\n");
+    // Through .xlsx the CSV origin is gone, as in Excel.
+    let (from_csv, _) = open_bytes("cut list.csv", CUT_LIST.as_bytes()).unwrap();
+    let (reopened, _) = open_bytes("book.xlsx", &save_bytes(&from_csv, "book.xlsx").unwrap()).unwrap();
+    assert_eq!(reopened.csv_delimiter, None);
+    assert!(String::from_utf8(save_bytes(&reopened, "again.csv").unwrap()).unwrap().starts_with("1,511,184,"));
+    // A .tsv/.txt saved as .csv gets commas; as .tsv it keeps tabs.
+    let (tsv, _) = open_bytes("list.txt", b"a\tb\r\n").unwrap();
+    assert_eq!(save_bytes(&tsv, "list.csv").unwrap(), b"a,b\r\n");
+    assert_eq!(save_bytes(&tsv, "list.tsv").unwrap(), b"a\tb\r\n");
+}
+
+#[test]
+fn encrypted_workbook_is_reported_not_misread() {
+    let file = gridcraft_xlsx::testing::encrypt_workbook(b"package", "pw");
+    let msg = open_bytes("secret.xlsx", &file).unwrap_err().to_string();
+    assert!(msg.contains(PASSWORD_REQUIRED), "got: {msg}");
+    assert!(!msg.contains("zip"), "must not surface the zip error: {msg}");
+    // A compound file naming the streams but unreadable is damage: no password is asked for,
+    // and none helps.
+    let file = cfb(&["EncryptionInfo", "EncryptedPackage"]);
+    for password in [None, Some("pw")] {
+        let msg = open_bytes_with_password("secret.xlsx", &file, password).unwrap_err().to_string();
+        assert!(msg.contains("damaged") && !msg.contains(PASSWORD_REQUIRED), "got: {msg}");
+    }
+}
+
+#[test]
+fn encryption_no_password_opens_is_reported_without_asking_for_one() {
+    let info: &[u8] = &[3, 0, 2, 0, 4, 0, 0, 0]; // Standard header flags: RC4, not AES
+    let file = gridcraft_xlsx::testing::compound_file(&[("EncryptionInfo", info), ("EncryptedPackage", &[0; 8])]);
+    let msg = open_bytes("rc4.xlsx", &file).unwrap_err().to_string();
+    assert!(msg.contains("RC4") && !msg.contains(PASSWORD_REQUIRED), "got: {msg}");
+    let irm = gridcraft_xlsx::testing::compound_file(&[("EncryptedPackage", &[0; 8])]);
+    let msg = open_bytes("irm.xlsx", &irm).unwrap_err().to_string();
+    assert!(msg.contains("rights-management") && !msg.contains("damaged"), "got: {msg}");
+}
+
+#[test]
+fn other_compound_files_are_not_called_encrypted() {
+    let err = open_bytes("old.doc", &cfb(&["WordDocument", "\u{5}SummaryInformation"])).unwrap_err();
+    let msg = err.to_string();
+    assert!(msg.contains("not an Excel workbook"), "got: {msg}");
+    assert!(!msg.contains("password"), "got: {msg}");
+}
+
+/// Save As CSV/TSV writes cells as displayed: number formats applied, formula results,
+/// whole values in narrow columns (never `#####`), quoting unchanged.
+#[test]
+fn csv_writes_displayed_text() {
+    use gridcraft_core::{CellError, Value};
+    use gridcraft_model::{Cell, Formula, LineInfo, NumFmt, StyleId};
+    let mut wb = Workbook::new();
+    let mut styled = |code: &str| wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new(code));
+    let (date, money, pct, frac, text, fixed, thousands) =
+        (styled("yyyy-mm-dd"), styled("$#,##0.00"), styled("0.0%"), styled("# ?/?"), styled("@"), styled("0.00"), styled("#,##0"));
+    let sh = wb.sheet_mut(0).unwrap();
+    let cells = [
+        ("A1", Cell { value: Value::Number(46023.0), formula: None, style: date }),
+        ("B1", Cell { value: Value::Number(1234.5), formula: None, style: money }),
+        ("C1", Cell { value: Value::Number(0.125), formula: None, style: pct }),
+        ("D1", Cell { value: Value::Number(1.5), formula: None, style: frac }),
+        ("E1", Cell { value: Value::text("007"), formula: None, style: text }),
+        ("F1", Cell { value: Value::Error(CellError::NA), formula: None, style: money }),
+        ("G1", Cell { value: Value::Bool(true), formula: None, style: StyleId::DEFAULT }),
+        ("A2", Cell { value: Value::Number(46024.0), style: date, ..Cell::formula(Formula::new("A1+1")) }),
+        ("B2", Cell { value: Value::Number(12345678.9), formula: None, style: fixed }),
+        ("C2", Cell { value: Value::Number(-0.25), formula: None, style: StyleId::DEFAULT }),
+        ("D2", Cell { value: Value::Number(1234567.0), formula: None, style: thousands }),
+    ];
+    for (a, c) in cells {
+        sh.set_cell(CellRef::parse(a).unwrap(), c);
+    }
+    // Column B is far too narrow for its numbers: the grid shows #####, the file must not.
+    sh.cols.insert(1, LineInfo { size: Some(1.0), ..Default::default() });
+    sh.show_formulas = true;
+    let csv = String::from_utf8(save_bytes(&wb, "out.csv").unwrap()).unwrap();
+    assert_eq!(csv, "2026-01-01,\"$1,234.50\",12.5%,1 1/2,007,#N/A,TRUE\r\n2026-01-02,12345678.90,-0.25,\"1,234,567\",,,\r\n");
+    let tsv = String::from_utf8(save_bytes(&wb, "out.tsv").unwrap()).unwrap();
+    assert!(tsv.starts_with("2026-01-01\t$1,234.50\t12.5%\t"), "{tsv}");
+}
+
+#[test]
+fn delimited_exports_preserve_general_precision_and_explicit_number_formats() {
+    use gridcraft_core::Value;
+    use gridcraft_model::{Cell, NumFmt, StyleId};
+    let mut workbook = Workbook::new();
+    let scientific = workbook.styles.derive(StyleId::DEFAULT, |style| style.num_fmt = NumFmt::new("0.00E+00"));
+    let sheet = workbook.sheet_mut(0).unwrap();
+    sheet.set_cell(CellRef::new(0, 0), Cell { value: Value::Number(124412140710.0), ..Default::default() });
+    sheet.set_cell(CellRef::new(0, 1), Cell { value: Value::Number(1.23456789012345), ..Default::default() });
+    sheet.set_cell(CellRef::new(0, 2), Cell { value: Value::Number(124412140710.0), style: scientific, ..Default::default() });
+    for (path, separator) in [("data.csv", ","), ("data.tsv", "\t")] {
+        let output = String::from_utf8(save_bytes(&workbook, path).unwrap()).unwrap();
+        assert_eq!(output, format!("124412140710{separator}1.23456789012345{separator}1.24E+11\r\n"));
+    }
+}
+
+#[test]
+fn template_extension_saves_template_content_type() {
+    let bytes = save_bytes(&Workbook::new(), "Budget.xltx").unwrap();
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+    let mut types = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("[Content_Types].xml").unwrap(), &mut types).unwrap();
+    assert!(
+        types.contains(
+            r#"PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml""#
+        ),
+        "{types}"
+    );
+}
+
+/// Where `part`'s entry starts in the central directory of `package`.
+fn central_entry(package: &[u8], part: &str) -> usize {
+    let mut at = 0;
+    while let Some(i) = package.get(at..).and_then(|rest| rest.windows(4).position(|w| w == b"PK\x01\x02")) {
+        let entry = at + i;
+        let len = u16::from_le_bytes([package[entry + 28], package[entry + 29]]) as usize;
+        if &package[entry + 46..entry + 46 + len] == part.as_bytes() {
+            return entry;
+        }
+        at = entry + 46;
+    }
+    panic!("{part} is not in the package");
+}
+
+/// `package` with `part` declaring `size` unpacked bytes: the reader refuses the part on the
+/// declared size, so no real 512 MB part has to be built.
+fn declaring(mut package: Vec<u8>, part: &str, size: u32) -> Vec<u8> {
+    let at = central_entry(&package, part);
+    package[at + 24..at + 28].copy_from_slice(&size.to_le_bytes());
+    package
+}
+
+#[test]
+fn a_part_over_the_size_limit_says_how_to_get_the_data_in() {
+    let mut wb = Workbook::new();
+    wb.sheet_mut(0).unwrap().set_value(CellRef::new(0, 0), gridcraft_core::Value::text("big"));
+    let package = save_bytes(&wb, "big.xlsx").unwrap();
+    // The size reported in storytold/gridcraft#1242.
+    let msg = open_bytes("big.xlsx", &declaring(package.clone(), "xl/worksheets/sheet1.xml", 540_278_731)).unwrap_err().to_string();
+    assert!(msg.starts_with("We can't open 'big.xlsx': "), "{msg}");
+    assert!(msg.contains("xl/worksheets/sheet1.xml") && msg.contains("515 MB") && msg.contains("512 MB"), "{msg}");
+    assert!(msg.contains("several sheets") && msg.contains("CSV"), "{msg}");
+    assert!(!msg.contains("bytes"), "{msg}");
+    // Splitting sheets doesn't shrink the shared strings, which every sheet uses: only CSV helps.
+    let msg = open_bytes("big.xlsx", &declaring(package.clone(), "xl/sharedStrings.xml", 540_278_731)).unwrap_err().to_string();
+    assert!(msg.contains("xl/sharedStrings.xml") && msg.contains("515 MB") && msg.contains("CSV"), "{msg}");
+    assert!(!msg.contains("several sheets"), "{msg}");
+    // Just over the limit never reads as a size equal to it.
+    let msg = open_bytes("big.xlsx", &declaring(package, "xl/worksheets/sheet1.xml", 512 * 1024 * 1024 + 1)).unwrap_err().to_string();
+    assert!(msg.contains("more than 512 MB"), "{msg}");
+    // A package that fails for another reason keeps its own error, oversized part or not.
+    let mut broken = declaring(save_bytes(&wb, "big.xlsx").unwrap(), "xl/worksheets/sheet1.xml", 540_278_731);
+    let at = central_entry(&broken, "xl/workbook.xml");
+    broken[at + 46 + "xl/workbook.xml".len() - 1] = b'x';
+    let msg = open_bytes("big.xlsx", &broken).unwrap_err().to_string();
+    assert!(msg.starts_with("We can't open 'big.xlsx': ") && !msg.contains("unpacks"), "{msg}");
+}
+
+#[test]
+fn content_wins_over_a_mismatched_extension() {
+    let mut wb = Workbook::new();
+    wb.sheet_mut(0).unwrap().set_value(CellRef::new(0, 0), gridcraft_core::Value::Number(7.0));
+    let package = save_bytes(&wb, "book.xlsx").unwrap();
+    for name in ["book.xlsx", "book.ods", "book.xlsb", "book.csv"] {
+        let (opened, _) = open_bytes(name, &package).unwrap_or_else(|e| panic!("{name}: {e}"));
+        assert_eq!(opened.sheet(0).unwrap().value(CellRef::new(0, 0)), gridcraft_core::Value::Number(7.0), "{name}");
+    }
+    for name in ["data.xlsx", "data.csv"] {
+        let (opened, _) = open_bytes(name, b"a,b\n1,2\n").unwrap_or_else(|e| panic!("{name}: {e}"));
+        assert_eq!(opened.sheet(0).unwrap().value(CellRef::new(0, 1)), gridcraft_core::Value::text("b"), "{name}");
+    }
+}

From 341ae6848e63f35d2e7ff53725b5c8bc110062ba Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:43 +0000
Subject: [PATCH 33/76] refactor(functions): move financial tests to
 src/financial/tests.rs

---
 crates/functions/src/financial.rs       | 325 +-----------------------
 crates/functions/src/financial/tests.rs | 322 +++++++++++++++++++++++
 2 files changed, 323 insertions(+), 324 deletions(-)
 create mode 100644 crates/functions/src/financial/tests.rs

diff --git a/crates/functions/src/financial.rs b/crates/functions/src/financial.rs
index 55c570c06..22c926185 100644
--- a/crates/functions/src/financial.rs
+++ b/crates/functions/src/financial.rs
@@ -1774,327 +1774,4 @@ pub(crate) fn specs() -> Vec<FnSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use crate::Arg;
-    use crate::util::testutil::*;
-    use gridcraft_core::{CellError, DateSystem, Value, date::serial_from_ymd};
-
-    fn d(y: i64, m: i64, dd: i64) -> Arg {
-        n(serial_from_ymd(DateSystem::D1900, y, m, dd).unwrap())
-    }
-
-    #[test]
-    fn tvm() {
-        close_tol(ev("PMT", vec![n(0.08 / 12.0), n(10.0), n(10000.0)]), -1037.032089, 1e-9);
-        close_tol(ev("PMT", vec![n(0.06 / 12.0), n(216.0), n(0.0), n(50000.0)]), -129.0811609, 1e-9);
-        close(ev("PMT", vec![n(0.0), n(10.0), n(1000.0)]), -100.0);
-        is_err(ev("PMT", vec![n(0.1), n(0.0), n(1000.0)]), CellError::Num);
-        close_tol(ev("FV", vec![n(0.06 / 12.0), n(10.0), n(-200.0), n(-500.0), n(1.0)]), 2581.403374, 1e-9);
-        close_tol(ev("FV", vec![n(0.01), n(12.0), n(-1000.0)]), 12682.50301, 1e-9);
-        close(ev("FV", vec![n(0.0), n(10.0), n(-100.0)]), 1000.0);
-        close_tol(ev("PV", vec![n(0.08 / 12.0), n(240.0), n(500.0)]), -59777.14585, 1e-9);
-        close_tol(ev("NPER", vec![n(0.01), n(-100.0), n(-1000.0), n(10000.0), n(1.0)]), 59.6738657, 1e-8);
-        close_tol(ev("NPER", vec![n(0.01), n(-100.0), n(-1000.0), n(10000.0)]), 60.0821229, 1e-8);
-        close_tol(ev("NPER", vec![n(0.01), n(-100.0), n(-1000.0)]), -9.57859404, 1e-8);
-        close_tol(ev("IPMT", vec![n(0.1 / 12.0), n(1.0), n(36.0), n(8000.0)]), -66.66666667, 1e-9);
-        close_tol(ev("IPMT", vec![n(0.1), n(3.0), n(3.0), n(8000.0)]), -292.4471299, 1e-9);
-        is_err(ev("IPMT", vec![n(0.1), n(4.0), n(3.0), n(8000.0)]), CellError::Num);
-        close_tol(ev("PPMT", vec![n(0.1 / 12.0), n(1.0), n(24.0), n(2000.0)]), -75.62318601, 1e-9);
-        close_tol(ev("PPMT", vec![n(0.08), n(10.0), n(10.0), n(200000.0)]), -27598.05346, 1e-9);
-        close_tol(ev("RATE", vec![n(48.0), n(-200.0), n(8000.0)]), 0.0077014725, 1e-7);
-        close_tol(ev("CUMIPMT", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(13.0), n(24.0), n(0.0)]), -11135.23213, 1e-9);
-        close_tol(ev("CUMIPMT", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(1.0), n(1.0), n(0.0)]), -937.5, 1e-9);
-        close_tol(ev("CUMPRINC", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(13.0), n(24.0), n(0.0)]), -934.1071234, 1e-9);
-        close_tol(ev("CUMPRINC", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(1.0), n(1.0), n(0.0)]), -68.27827118, 1e-9);
-        is_err(ev("CUMIPMT", vec![n(0.0), n(360.0), n(125000.0), n(1.0), n(1.0), n(0.0)]), CellError::Num);
-        is_err(ev("CUMIPMT", vec![n(0.01), n(360.0), n(125000.0), n(1.0), n(1.0), n(2.0)]), CellError::Num);
-    }
-
-    /// PMT within about 4 ULPs of Excel's (Value2 of synthetic probes; libm differs by an ULP across
-    /// platforms). The old `(1 + rate)^nper` form was 25 to 91 ULPs off on these, enough to flip a loan schedule's final `IF(p - SUM(r) > 0, ...)`.
-    #[test]
-    fn pmt_matches_excel_within_a_few_ulps() {
-        for (rate, nper, pv, fv, typ, excel) in [
-            (0.141 / 12.0, 12.0, -4653300.0, 0.0, 0.0, 418025.37230211904),
-            (0.005716666666666666, 26.0, 42678411.0, -26010.62, 0.0, -1770235.3828507778),
-            (0.012164, 29.0, 16722649.0, 0.0, 1.0, -679516.0784762775),
-            (0.009916666666666666, 5.0, 8590842.8, 0.0, 0.0, -1769620.32624324),
-            (0.011158333333333333, 36.0, 21457108.0, 49218.26, 1.0, -720095.3912155787),
-            (-0.5, 2.5, 100.0, 0.0, 0.0, -10.736861692729645),
-        ] {
-            let got = ev("PMT", vec![n(rate), n(nper), n(pv), n(fv), n(typ)]);
-            close_tol(got, excel, 1e-15);
-        }
-    }
-
-    /// Edge cases observed in Excel: a rate of -1 or less is #NUM!, a huge nper leaves -pv*rate, and a
-    /// tiny rate no longer loses its low digits in 1 + rate.
-    #[test]
-    fn pmt_edge_cases_follow_excel() {
-        is_err(ev("PMT", vec![n(-2.0), n(3.0), n(100.0)]), CellError::Num);
-        is_err(ev("PMT", vec![n(-1.0), n(3.0), n(100.0)]), CellError::Num);
-        is_err(ev("PMT", vec![n(-2.0), n(2.5), n(100.0)]), CellError::Num);
-        assert_eq!(ev("PMT", vec![n(0.1), n(10000.0), n(100.0)]), Value::Number(-10.0));
-        assert_eq!(ev("PMT", vec![n(5.0), n(1000.0), n(100.0)]), Value::Number(-500.0));
-        assert_eq!(ev("PMT", vec![n(1e-300), n(10.0), n(100.0)]), Value::Number(-10.0));
-        close_tol(ev("PMT", vec![n(1e-12), n(10.0), n(100.0)]), -10.000000000055001, 1e-15);
-        close_tol(ev("PMT", vec![n(1e-300), n(10.0), n(1e12)]), -1e11, 1e-15);
-        close_tol(ev("PMT", vec![n(-0.999), n(5.0), n(100.0)]), -9.990_000_000_000_092e-14, 1e-15);
-        close_tol(ev("PMT", vec![n(0.05), n(-10.0), n(100.0)]), 7.950_457_496_545_667, 1e-15);
-        close_tol(ev("PMT", vec![n(-1e-17), n(1.0), n(1e18), n(-1e18)]), 10.0, 1e-9);
-        close_tol(ev("PMT", vec![n(-0.5), n(60.0), n(1e18)]), -0.433_680_868_994_201_8, 1e-6);
-        close_tol(ev("PMT", vec![n(0.05), n(10.0), n(100.0), n(50.0), n(1.0)]), -16.119701185541427, 1e-15);
-    }
-
-    #[test]
-    fn cash_flows() {
-        close_tol(ev("NPV", vec![n(0.1), n(-10000.0), n(3000.0), n(4200.0), n(6800.0)]), 1188.443412, 1e-9);
-        close_tol(ev("NPV", vec![n(0.08), rf(col(&[8000.0, 9200.0, 10000.0, 12000.0, 14500.0]))]), 41922.06155, 1e-9);
-        is_err(ev("NPV", vec![n(-1.0), n(1.0)]), CellError::Div0);
-        let flows = col(&[-70000.0, 12000.0, 15000.0, 18000.0, 21000.0]);
-        close_tol(ev("IRR", vec![rf(flows)]), -0.021244848, 1e-7);
-        close_tol(ev("IRR", vec![rf(col(&[-70000.0, 12000.0, 15000.0, 18000.0, 21000.0, 26000.0]))]), 0.086630948, 1e-7);
-        close_tol(ev("IRR", vec![rf(col(&[-70000.0, 12000.0, 15000.0])), n(-0.1)]), -0.44350694, 1e-7);
-        is_err(ev("IRR", vec![rf(col(&[1.0, 2.0]))]), CellError::Num);
-        let vals = col(&[-10000.0, 2750.0, 4250.0, 3250.0, 2750.0]);
-        let dates = col(&[39448.0, 39508.0, 39751.0, 39859.0, 39904.0]);
-        close_tol(ev("XNPV", vec![n(0.09), rf(vals.clone()), rf(dates.clone())]), 2086.647602, 1e-9);
-        close_tol(ev("XIRR", vec![rf(vals.clone()), rf(dates)]), 0.373362535, 1e-7);
-        is_err(ev("XNPV", vec![n(0.09), rf(vals), rf(col(&[1.0, 2.0]))]), CellError::Num);
-        let m = col(&[-120000.0, 39000.0, 30000.0, 21000.0, 37000.0, 46000.0]);
-        close_tol(ev("MIRR", vec![rf(m), n(0.1), n(0.12)]), 0.1260943, 1e-6);
-        close_tol(ev("MIRR", vec![rf(col(&[-120000.0, 39000.0, 30000.0, 21000.0])), n(0.1), n(0.12)]), -0.048044655, 1e-7);
-        is_err(ev("MIRR", vec![rf(col(&[1.0, 2.0])), n(0.1), n(0.1)]), CellError::Div0);
-        // Excel 365 gives -1 when every flow is negative: the positive flows are worth nothing.
-        close_tol(ev("MIRR", vec![rf(col(&[-10000.0, -3400.0, -6500.0, -1000.0])), n(0.07), n(0.01)]), -1.0, 1e-12);
-        close(ev("FVSCHEDULE", vec![n(1.0), av(row(&[0.09, 0.11, 0.1]))]), 1.33089);
-        close(ev("EFFECT", vec![n(0.0525), n(4.0)]), 0.0535426673707584);
-        is_err(ev("EFFECT", vec![n(-0.1), n(4.0)]), CellError::Num);
-        close_tol(ev("NOMINAL", vec![n(0.053543), n(4.0)]), 0.052500319, 1e-8);
-        close_tol(ev("ISPMT", vec![n(0.1 / 12.0), n(0.0), n(36.0), n(8000000.0)]), -66666.66667, 1e-9);
-        is_err(ev("ISPMT", vec![n(0.1), n(1.0), n(0.0), n(1.0)]), CellError::Div0);
-        close_tol(ev("PDURATION", vec![n(0.025), n(2000.0), n(2200.0)]), 3.859866163, 1e-9);
-        is_err(ev("PDURATION", vec![n(0.0), n(2000.0), n(2200.0)]), CellError::Num);
-        close_tol(ev("RRI", vec![n(96.0), n(10000.0), n(11000.0)]), 0.0009933, 1e-4);
-        close(ev("DOLLARDE", vec![n(1.02), n(16.0)]), 1.125);
-        close(ev("DOLLARDE", vec![n(1.1), n(32.0)]), 1.3125);
-        close(ev("DOLLARFR", vec![n(1.125), n(16.0)]), 1.02);
-        close(ev("DOLLARFR", vec![n(1.125), n(32.0)]), 1.04);
-        is_err(ev("DOLLARDE", vec![n(1.02), n(0.0)]), CellError::Div0);
-        is_err(ev("DOLLARDE", vec![n(1.02), n(-1.0)]), CellError::Num);
-    }
-
-    #[test]
-    fn depreciation() {
-        close(ev("SLN", vec![n(30000.0), n(7500.0), n(10.0)]), 2250.0);
-        is_err(ev("SLN", vec![n(30000.0), n(7500.0), n(0.0)]), CellError::Div0);
-        close_tol(ev("SYD", vec![n(30000.0), n(7500.0), n(10.0), n(1.0)]), 4090.909091, 1e-9);
-        close_tol(ev("SYD", vec![n(30000.0), n(7500.0), n(10.0), n(10.0)]), 409.0909091, 1e-9);
-        let dbv = |p: f64| ev("DB", vec![n(1000000.0), n(100000.0), n(6.0), n(p), n(7.0)]);
-        close_tol(dbv(1.0), 186083.3333, 1e-9);
-        close_tol(dbv(2.0), 259639.4167, 1e-9);
-        close_tol(dbv(3.0), 176814.4428, 1e-9);
-        close_tol(dbv(7.0), 15845.09847, 1e-9);
-        is_err(dbv(8.0), CellError::Num);
-        close_tol(ev("DDB", vec![n(2400.0), n(300.0), n(3650.0), n(1.0)]), 1.315068493, 1e-8);
-        close(ev("DDB", vec![n(2400.0), n(300.0), n(120.0), n(1.0), n(2.0)]), 40.0);
-        close(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(1.0), n(2.0)]), 480.0);
-        close_tol(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(2.0), n(1.5)]), 306.0, 1e-12);
-        close_tol(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(10.0)]), 22.1225472, 1e-8);
-        is_err(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(11.0)]), CellError::Num);
-        close_tol(ev("VDB", vec![n(2400.0), n(300.0), n(3650.0), n(0.0), n(1.0)]), 1.315068493, 1e-8);
-        close(ev("VDB", vec![n(2400.0), n(300.0), n(120.0), n(0.0), n(1.0)]), 40.0);
-        close(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(0.0), n(1.0)]), 480.0);
-        close_tol(ev("VDB", vec![n(2400.0), n(300.0), n(120.0), n(6.0), n(18.0)]), 396.3060533, 1e-8);
-        close_tol(ev("VDB", vec![n(2400.0), n(300.0), n(120.0), n(6.0), n(18.0), n(1.5)]), 311.8089367, 1e-8);
-        close(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(0.0), n(0.875), n(1.5)]), 315.0);
-        // Over the whole life the total depreciation is cost - salvage.
-        close(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(0.0), n(10.0)]), 2100.0);
-        is_err(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(5.0), n(4.0)]), CellError::Num);
-        close_tol(ev("AMORLINC", vec![n(2400.0), d(2008, 8, 19), d(2008, 12, 31), n(300.0), n(1.0), n(0.15), n(1.0)]), 360.0, 1e-9);
-        close(ev("AMORDEGRC", vec![n(2400.0), d(2008, 8, 19), d(2008, 12, 31), n(300.0), n(1.0), n(0.15), n(1.0)]), 776.0);
-    }
-
-    #[test]
-    fn coupons() {
-        let args = |f: &str| ev(f, vec![d(2011, 1, 25), d(2011, 11, 15), n(2.0), n(1.0)]);
-        close(args("COUPDAYBS"), 71.0);
-        close(args("COUPDAYS"), 181.0);
-        close(args("COUPDAYSNC"), 110.0);
-        close(args("COUPNCD"), 40678.0);
-        close(args("COUPPCD"), 40497.0);
-        close(args("COUPNUM"), 2.0);
-        close(ev("COUPDAYS", vec![d(2011, 1, 25), d(2011, 11, 15), n(2.0), n(0.0)]), 180.0);
-        close(ev("COUPDAYS", vec![d(2011, 1, 25), d(2011, 11, 15), n(4.0), n(3.0)]), 91.25);
-        close(ev("COUPNUM", vec![d(2007, 1, 25), d(2008, 11, 15), n(2.0), n(1.0)]), 4.0);
-        is_err(ev("COUPNUM", vec![d(2012, 1, 25), d(2011, 11, 15), n(2.0)]), CellError::Num);
-        is_err(ev("COUPNUM", vec![d(2011, 1, 25), d(2011, 11, 15), n(3.0)]), CellError::Num);
-        is_err(ev("COUPNUM", vec![d(2011, 1, 25), d(2011, 11, 15), n(2.0), n(5.0)]), CellError::Num);
-        // End-of-month maturity keeps month-end coupon dates.
-        close(ev("COUPPCD", vec![d(2011, 3, 15), d(2011, 11, 30), n(2.0)]), serial_from_ymd(DateSystem::D1900, 2010, 11, 30).unwrap());
-        close(ev("COUPNCD", vec![d(2011, 3, 15), d(2011, 11, 30), n(2.0)]), serial_from_ymd(DateSystem::D1900, 2011, 5, 31).unwrap());
-    }
-
-    #[test]
-    fn securities() {
-        close_tol(ev("DISC", vec![d(2007, 1, 25), d(2007, 6, 15), n(97.975), n(100.0), n(1.0)]), 0.052420213, 1e-8);
-        close_tol(ev("PRICEDISC", vec![d(2008, 2, 16), d(2008, 3, 1), n(0.0525), n(100.0), n(2.0)]), 99.79583333, 1e-9);
-        close_tol(ev("YIELDDISC", vec![d(2008, 2, 16), d(2008, 3, 1), n(99.795), n(100.0), n(2.0)]), 0.052823, 1e-5);
-        close_tol(ev("INTRATE", vec![d(2008, 2, 15), d(2008, 5, 15), n(1000000.0), n(1014420.0), n(2.0)]), 0.05768, 1e-9);
-        close_tol(ev("RECEIVED", vec![d(2008, 2, 15), d(2008, 5, 15), n(1000000.0), n(0.0575), n(2.0)]), 1014584.654, 1e-9);
-        is_err(ev("DISC", vec![d(2008, 2, 15), d(2008, 1, 15), n(97.0), n(100.0)]), CellError::Num);
-        close_tol(ev("TBILLPRICE", vec![d(2008, 3, 31), d(2008, 6, 1), n(0.09)]), 98.45, 1e-12);
-        close_tol(ev("TBILLYIELD", vec![d(2008, 3, 31), d(2008, 6, 1), n(98.45)]), 0.091417, 1e-6);
-        close_tol(ev("TBILLEQ", vec![d(2008, 3, 31), d(2008, 6, 1), n(0.0914)]), 0.094151, 1e-6);
-        is_err(ev("TBILLPRICE", vec![d(2008, 3, 31), d(2009, 6, 1), n(0.09)]), CellError::Num);
-        close_tol(ev("ACCRINTM", vec![d(2008, 4, 1), d(2008, 6, 15), n(0.1), n(1000.0), n(3.0)]), 20.54794521, 1e-9);
-        is_err(ev("ACCRINTM", vec![d(2008, 6, 15), d(2008, 4, 1), n(0.1)]), CellError::Num);
-        close_tol(ev("ACCRINT", vec![d(2008, 3, 1), d(2008, 8, 31), d(2008, 5, 1), n(0.1), n(1000.0), n(2.0), n(0.0)]), 16.66666667, 1e-9);
-        close_tol(ev("ACCRINT", vec![d(2008, 3, 5), d(2008, 8, 31), d(2008, 5, 1), n(0.1), n(1000.0), n(2.0), n(0.0), b(false)]), 15.55555556, 1e-9);
-        close_tol(ev("PRICEMAT", vec![d(2008, 2, 15), d(2008, 4, 13), d(2007, 11, 11), n(0.061), n(0.061), n(0.0)]), 99.98449888, 1e-9);
-        close_tol(ev("YIELDMAT", vec![d(2008, 3, 15), d(2008, 11, 3), d(2007, 11, 8), n(0.0625), n(100.0123), n(0.0)]), 0.060954, 1e-6);
-        close_tol(ev("PRICE", vec![d(2008, 2, 15), d(2017, 11, 15), n(0.0575), n(0.065), n(100.0), n(2.0), n(0.0)]), 94.63436, 1e-7);
-        close_tol(ev("YIELD", vec![d(2008, 2, 15), d(2016, 11, 15), n(0.0575), n(95.04287), n(100.0), n(2.0), n(0.0)]), 0.065, 1e-6);
-        is_err(ev("PRICE", vec![d(2008, 2, 15), d(2017, 11, 15), n(-0.01), n(0.065), n(100.0), n(2.0)]), CellError::Num);
-        close_tol(ev("DURATION", vec![d(2018, 7, 1), d(2048, 1, 1), n(0.08), n(0.09), n(2.0), n(1.0)]), 10.9191453, 1e-8);
-        close_tol(ev("MDURATION", vec![d(2008, 1, 1), d(2016, 1, 1), n(0.08), n(0.09), n(2.0), n(1.0)]), 5.73567, 1e-6);
-        // A one-coupon bond uses the closed form for yield; PRICE and YIELD invert each other.
-        let p = ev("PRICE", vec![d(2008, 2, 15), d(2008, 6, 15), n(0.05), n(0.04), n(100.0), n(2.0)]);
-        let pv = match p {
-            Value::Number(x) => x,
-            _ => panic!(),
-        };
-        close_tol(ev("YIELD", vec![d(2008, 2, 15), d(2008, 6, 15), n(0.05), n(pv), n(100.0), n(2.0)]), 0.04, 1e-9);
-    }
-
-    fn number(v: Value) -> f64 {
-        match v {
-            Value::Number(x) => x,
-            other => panic!("expected a number, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn odd_periods() {
-        // The worked examples on Microsoft's function pages (results as printed there).
-        let first = |x: f64, rest: &[f64]| {
-            let mut a = vec![d(2008, 11, 11), d(2021, 3, 1), d(2008, 10, 15), d(2009, 3, 1), n(x)];
-            a.extend(rest.iter().map(|v| n(*v)));
-            a
-        };
-        close_tol(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 1.0])), 113.60, 0.005 / 113.6);
-        close_tol(ev("ODDFYIELD", first(0.0575, &[84.50, 100.0, 2.0, 0.0])), 0.0772, 0.00005);
-        let lp = vec![d(2008, 2, 7), d(2008, 6, 15), d(2007, 10, 15), n(0.0375), n(0.0405), n(100.0), n(2.0), n(0.0)];
-        close_tol(ev("ODDLPRICE", lp), 99.88, 0.005 / 99.88);
-        let ly = vec![d(2008, 4, 20), d(2008, 6, 15), d(2007, 12, 24), n(0.0375), n(99.875), n(100.0), n(2.0), n(0.0)];
-        close_tol(ev("ODDLYIELD", ly), 0.04519, 0.000005);
-
-        // Yield → price → yield, for a short and a long odd first period and a long odd last period.
-        for (issue, basis) in [(d(2008, 10, 15), 0.0), (d(2007, 1, 20), 1.0), (d(2008, 1, 31), 3.0)] {
-            let args = |x: f64| vec![d(2008, 11, 11), d(2021, 3, 1), issue.clone(), d(2009, 3, 1), n(0.06), n(x), n(100.0), n(2.0), n(basis)];
-            let p = number(ev("ODDFPRICE", args(0.05)));
-            close_tol(ev("ODDFYIELD", args(p)), 0.05, 1e-9);
-        }
-        let last = |x: f64| vec![d(2009, 2, 1), d(2009, 12, 15), d(2008, 3, 15), n(0.04), n(x), n(100.0), n(4.0), n(1.0)];
-        let p = number(ev("ODDLPRICE", last(0.07)));
-        close_tol(ev("ODDLYIELD", last(p)), 0.07, 1e-9);
-
-        // Argument checks: frequency, basis, date order, negative yield, non-positive price.
-        is_err(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 3.0, 1.0])), CellError::Num);
-        is_err(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 5.0])), CellError::Num);
-        is_err(ev("ODDFPRICE", first(0.0785, &[-0.01, 100.0, 2.0, 1.0])), CellError::Num);
-        is_err(ev("ODDFYIELD", first(0.0575, &[0.0, 100.0, 2.0, 0.0])), CellError::Num);
-        is_err(
-            ev("ODDFPRICE", vec![d(2009, 4, 1), d(2021, 3, 1), d(2008, 10, 15), d(2009, 3, 1), n(0.07), n(0.06), n(100.0), n(2.0)]),
-            CellError::Num,
-        );
-        is_err(ev("ODDLPRICE", vec![d(2007, 10, 1), d(2008, 6, 15), d(2007, 10, 15), n(0.0375), n(0.0405), n(100.0), n(2.0)]), CellError::Num);
-        is_err(ev("ODDLYIELD", vec![d(2008, 4, 20), d(2008, 6, 15), d(2007, 12, 24), n(0.0375), n(-1.0), n(100.0), n(2.0)]), CellError::Num);
-        is_err(
-            ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 1.0]).into_iter().take(4).chain([t("x"), n(0.06), n(100.0), n(2.0)]).collect()),
-            CellError::Value,
-        );
-    }
-
-    #[test]
-    fn odd_periods_survive_hostile_input() {
-        // Quarterly quasi-periods across the whole date range, huge rates and yields: a value or
-        // an error, never a panic or a hang.
-        let wide = |x: f64, y: f64| vec![n(2_957_000.0), n(2_958_465.0), n(400.0), n(2_957_900.0), n(x), n(y), n(1e300), n(4.0), n(1.0)];
-        for (x, y) in [(0.05, 0.05), (1e300, 1e300), (0.0, 1e-300)] {
-            let _ = ev("ODDFPRICE", wide(x, y));
-            let _ = ev("ODDFYIELD", wide(x, y));
-        }
-        // The long walk itself works: settled early in an odd first period of ~32,000 quarters,
-        // a small yield round-trips.
-        let long = |y: f64| vec![n(500.0), n(2_958_465.0), n(400.0), n(2_957_900.0), n(0.05), n(y), n(100.0), n(4.0), n(1.0)];
-        let p = number(ev("ODDFPRICE", long(0.0001)));
-        close_tol(ev("ODDFYIELD", long(p)), 0.0001, 1e-9);
-        let last = |x: f64, y: f64| vec![n(2_958_000.0), n(2_958_465.0), n(400.0), n(x), n(y), n(1e300), n(4.0), n(1.0)];
-        for (x, y) in [(0.05, 0.05), (1e300, 1e300), (0.0, f64::MAX)] {
-            let _ = ev("ODDLPRICE", last(x, y));
-            let _ = ev("ODDLYIELD", last(x, y));
-        }
-        is_err(ev("ODDFPRICE", vec![n(-5.0), n(1e20), n(0.0), n(1e10), n(0.05), n(0.05), n(100.0), n(2.0)]), CellError::Num);
-    }
-
-    #[test]
-    fn euroconvert() {
-        // The examples on Microsoft's EUROCONVERT page.
-        let ec = |x: f64, s: &str, tg: &str, rest: Vec<Arg>| {
-            let mut a = vec![n(x), t(s), t(tg)];
-            a.extend(rest);
-            ev("EUROCONVERT", a)
-        };
-        close(ec(1.2, "DEM", "EUR", vec![]), 0.61);
-        close(ec(1.0, "FRF", "EUR", vec![b(true), n(3.0)]), 0.152);
-        close(ec(1.0, "FRF", "EUR", vec![b(false), n(3.0)]), 0.15);
-        close(ec(1.0, "FRF", "DEM", vec![b(true), n(3.0)]), 0.29728616);
-        // Euro to a member currency rounds to the target's calculation precision (lira: 0).
-        close(ec(10.0, "eur", "ITL", vec![]), 19363.0);
-        close(ec(100.0, "EUR", "IEP", vec![b(true)]), 78.7564);
-        // Same currency returns the number untouched.
-        close(ec(1.23456, "DEM", "DEM", vec![]), 1.23456);
-        // Unknown codes and a triangulation precision below 3 are #VALUE!.
-        is_err(ec(1.0, "USD", "EUR", vec![]), CellError::Value);
-        is_err(ec(1.0, "FRF", "DEM", vec![b(true), n(2.0)]), CellError::Value);
-        // Hostile magnitudes give a number or #NUM!, never a panic.
-        is_err(ec(f64::MAX, "EUR", "ITL", vec![]), CellError::Num);
-        close(ec(1.0, "FRF", "DEM", vec![b(true), n(1e300)]), 1.95583 / 6.55957);
-    }
-
-    #[test]
-    fn lifting() {
-        let v = ev("SLN", vec![av(row(&[100.0, 200.0])), n(0.0), n(10.0)]);
-        assert_eq!(rows_of(&v), vec![vec![nv(10.0), nv(20.0)]]);
-        is_err(ev("PMT", vec![t("abc"), n(1.0), n(1.0)]), CellError::Value);
-        is_err(ev("PMT", vec![e(CellError::NA), n(1.0), n(1.0)]), CellError::NA);
-    }
-
-    #[test]
-    fn securities_read_dates_in_the_1904_system() {
-        let d4 = |y, m, dd| n(serial_from_ymd(DateSystem::D1904, y, m, dd).unwrap());
-        let ev4 = |name: &str, args: Vec<Arg>| {
-            let mut ctx = TestCtx { sys: DateSystem::D1904, ..TestCtx::default() };
-            crate::call(crate::lookup(name).unwrap(), &args, &mut ctx)
-        };
-        let (s, m) = (d4(2011, 3, 15), d4(2011, 11, 30));
-        close(ev4("COUPNCD", vec![s.clone(), m.clone(), n(2.0)]), 39232.0);
-        close(ev4("COUPPCD", vec![s.clone(), m.clone(), n(4.0), n(0.0)]), 39140.0);
-        close(ev4("COUPDAYBS", vec![s.clone(), m.clone(), n(4.0), n(0.0)]), 15.0);
-        let accrint = vec![d4(2008, 3, 1), d4(2008, 8, 31), d4(2008, 5, 1), n(0.1), n(1000.0), n(2.0), n(1.0)];
-        close_tol(ev4("ACCRINT", accrint), 16.576086956522, 1e-9);
-        // Results that already matched Excel keep matching.
-        let semi = |name| ev4(name, vec![s.clone(), m.clone(), n(2.0), n(0.0)]);
-        close(semi("COUPPCD"), 39050.0);
-        close(semi("COUPDAYS"), 180.0);
-        close(semi("COUPDAYBS"), 105.0);
-        close(semi("COUPDAYSNC"), 75.0);
-        close(semi("COUPNUM"), 2.0);
-        let price = vec![s.clone(), m.clone(), n(0.0575), n(0.065), n(100.0), n(2.0), n(0.0)];
-        close_tol(ev4("PRICE", price), 99.47768286339101, 1e-9);
-        close_tol(ev4("DURATION", vec![s, m, n(0.08), n(0.09), n(2.0), n(0.0)]), 0.6890136809022, 1e-9);
-        let odd = vec![d4(2008, 11, 11), d4(2021, 3, 1), d4(2008, 10, 15), d4(2009, 3, 1), n(0.0785), n(0.0625), n(100.0), n(2.0), n(1.0)];
-        close_tol(ev4("ODDFPRICE", odd), 113.597717474079, 1e-9);
-    }
-}
+mod tests;
diff --git a/crates/functions/src/financial/tests.rs b/crates/functions/src/financial/tests.rs
new file mode 100644
index 000000000..17f416412
--- /dev/null
+++ b/crates/functions/src/financial/tests.rs
@@ -0,0 +1,322 @@
+use crate::Arg;
+use crate::util::testutil::*;
+use gridcraft_core::{CellError, DateSystem, Value, date::serial_from_ymd};
+
+fn d(y: i64, m: i64, dd: i64) -> Arg {
+    n(serial_from_ymd(DateSystem::D1900, y, m, dd).unwrap())
+}
+
+#[test]
+fn tvm() {
+    close_tol(ev("PMT", vec![n(0.08 / 12.0), n(10.0), n(10000.0)]), -1037.032089, 1e-9);
+    close_tol(ev("PMT", vec![n(0.06 / 12.0), n(216.0), n(0.0), n(50000.0)]), -129.0811609, 1e-9);
+    close(ev("PMT", vec![n(0.0), n(10.0), n(1000.0)]), -100.0);
+    is_err(ev("PMT", vec![n(0.1), n(0.0), n(1000.0)]), CellError::Num);
+    close_tol(ev("FV", vec![n(0.06 / 12.0), n(10.0), n(-200.0), n(-500.0), n(1.0)]), 2581.403374, 1e-9);
+    close_tol(ev("FV", vec![n(0.01), n(12.0), n(-1000.0)]), 12682.50301, 1e-9);
+    close(ev("FV", vec![n(0.0), n(10.0), n(-100.0)]), 1000.0);
+    close_tol(ev("PV", vec![n(0.08 / 12.0), n(240.0), n(500.0)]), -59777.14585, 1e-9);
+    close_tol(ev("NPER", vec![n(0.01), n(-100.0), n(-1000.0), n(10000.0), n(1.0)]), 59.6738657, 1e-8);
+    close_tol(ev("NPER", vec![n(0.01), n(-100.0), n(-1000.0), n(10000.0)]), 60.0821229, 1e-8);
+    close_tol(ev("NPER", vec![n(0.01), n(-100.0), n(-1000.0)]), -9.57859404, 1e-8);
+    close_tol(ev("IPMT", vec![n(0.1 / 12.0), n(1.0), n(36.0), n(8000.0)]), -66.66666667, 1e-9);
+    close_tol(ev("IPMT", vec![n(0.1), n(3.0), n(3.0), n(8000.0)]), -292.4471299, 1e-9);
+    is_err(ev("IPMT", vec![n(0.1), n(4.0), n(3.0), n(8000.0)]), CellError::Num);
+    close_tol(ev("PPMT", vec![n(0.1 / 12.0), n(1.0), n(24.0), n(2000.0)]), -75.62318601, 1e-9);
+    close_tol(ev("PPMT", vec![n(0.08), n(10.0), n(10.0), n(200000.0)]), -27598.05346, 1e-9);
+    close_tol(ev("RATE", vec![n(48.0), n(-200.0), n(8000.0)]), 0.0077014725, 1e-7);
+    close_tol(ev("CUMIPMT", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(13.0), n(24.0), n(0.0)]), -11135.23213, 1e-9);
+    close_tol(ev("CUMIPMT", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(1.0), n(1.0), n(0.0)]), -937.5, 1e-9);
+    close_tol(ev("CUMPRINC", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(13.0), n(24.0), n(0.0)]), -934.1071234, 1e-9);
+    close_tol(ev("CUMPRINC", vec![n(0.09 / 12.0), n(360.0), n(125000.0), n(1.0), n(1.0), n(0.0)]), -68.27827118, 1e-9);
+    is_err(ev("CUMIPMT", vec![n(0.0), n(360.0), n(125000.0), n(1.0), n(1.0), n(0.0)]), CellError::Num);
+    is_err(ev("CUMIPMT", vec![n(0.01), n(360.0), n(125000.0), n(1.0), n(1.0), n(2.0)]), CellError::Num);
+}
+
+/// PMT within about 4 ULPs of Excel's (Value2 of synthetic probes; libm differs by an ULP across
+/// platforms). The old `(1 + rate)^nper` form was 25 to 91 ULPs off on these, enough to flip a loan schedule's final `IF(p - SUM(r) > 0, ...)`.
+#[test]
+fn pmt_matches_excel_within_a_few_ulps() {
+    for (rate, nper, pv, fv, typ, excel) in [
+        (0.141 / 12.0, 12.0, -4653300.0, 0.0, 0.0, 418025.37230211904),
+        (0.005716666666666666, 26.0, 42678411.0, -26010.62, 0.0, -1770235.3828507778),
+        (0.012164, 29.0, 16722649.0, 0.0, 1.0, -679516.0784762775),
+        (0.009916666666666666, 5.0, 8590842.8, 0.0, 0.0, -1769620.32624324),
+        (0.011158333333333333, 36.0, 21457108.0, 49218.26, 1.0, -720095.3912155787),
+        (-0.5, 2.5, 100.0, 0.0, 0.0, -10.736861692729645),
+    ] {
+        let got = ev("PMT", vec![n(rate), n(nper), n(pv), n(fv), n(typ)]);
+        close_tol(got, excel, 1e-15);
+    }
+}
+
+/// Edge cases observed in Excel: a rate of -1 or less is #NUM!, a huge nper leaves -pv*rate, and a
+/// tiny rate no longer loses its low digits in 1 + rate.
+#[test]
+fn pmt_edge_cases_follow_excel() {
+    is_err(ev("PMT", vec![n(-2.0), n(3.0), n(100.0)]), CellError::Num);
+    is_err(ev("PMT", vec![n(-1.0), n(3.0), n(100.0)]), CellError::Num);
+    is_err(ev("PMT", vec![n(-2.0), n(2.5), n(100.0)]), CellError::Num);
+    assert_eq!(ev("PMT", vec![n(0.1), n(10000.0), n(100.0)]), Value::Number(-10.0));
+    assert_eq!(ev("PMT", vec![n(5.0), n(1000.0), n(100.0)]), Value::Number(-500.0));
+    assert_eq!(ev("PMT", vec![n(1e-300), n(10.0), n(100.0)]), Value::Number(-10.0));
+    close_tol(ev("PMT", vec![n(1e-12), n(10.0), n(100.0)]), -10.000000000055001, 1e-15);
+    close_tol(ev("PMT", vec![n(1e-300), n(10.0), n(1e12)]), -1e11, 1e-15);
+    close_tol(ev("PMT", vec![n(-0.999), n(5.0), n(100.0)]), -9.990_000_000_000_092e-14, 1e-15);
+    close_tol(ev("PMT", vec![n(0.05), n(-10.0), n(100.0)]), 7.950_457_496_545_667, 1e-15);
+    close_tol(ev("PMT", vec![n(-1e-17), n(1.0), n(1e18), n(-1e18)]), 10.0, 1e-9);
+    close_tol(ev("PMT", vec![n(-0.5), n(60.0), n(1e18)]), -0.433_680_868_994_201_8, 1e-6);
+    close_tol(ev("PMT", vec![n(0.05), n(10.0), n(100.0), n(50.0), n(1.0)]), -16.119701185541427, 1e-15);
+}
+
+#[test]
+fn cash_flows() {
+    close_tol(ev("NPV", vec![n(0.1), n(-10000.0), n(3000.0), n(4200.0), n(6800.0)]), 1188.443412, 1e-9);
+    close_tol(ev("NPV", vec![n(0.08), rf(col(&[8000.0, 9200.0, 10000.0, 12000.0, 14500.0]))]), 41922.06155, 1e-9);
+    is_err(ev("NPV", vec![n(-1.0), n(1.0)]), CellError::Div0);
+    let flows = col(&[-70000.0, 12000.0, 15000.0, 18000.0, 21000.0]);
+    close_tol(ev("IRR", vec![rf(flows)]), -0.021244848, 1e-7);
+    close_tol(ev("IRR", vec![rf(col(&[-70000.0, 12000.0, 15000.0, 18000.0, 21000.0, 26000.0]))]), 0.086630948, 1e-7);
+    close_tol(ev("IRR", vec![rf(col(&[-70000.0, 12000.0, 15000.0])), n(-0.1)]), -0.44350694, 1e-7);
+    is_err(ev("IRR", vec![rf(col(&[1.0, 2.0]))]), CellError::Num);
+    let vals = col(&[-10000.0, 2750.0, 4250.0, 3250.0, 2750.0]);
+    let dates = col(&[39448.0, 39508.0, 39751.0, 39859.0, 39904.0]);
+    close_tol(ev("XNPV", vec![n(0.09), rf(vals.clone()), rf(dates.clone())]), 2086.647602, 1e-9);
+    close_tol(ev("XIRR", vec![rf(vals.clone()), rf(dates)]), 0.373362535, 1e-7);
+    is_err(ev("XNPV", vec![n(0.09), rf(vals), rf(col(&[1.0, 2.0]))]), CellError::Num);
+    let m = col(&[-120000.0, 39000.0, 30000.0, 21000.0, 37000.0, 46000.0]);
+    close_tol(ev("MIRR", vec![rf(m), n(0.1), n(0.12)]), 0.1260943, 1e-6);
+    close_tol(ev("MIRR", vec![rf(col(&[-120000.0, 39000.0, 30000.0, 21000.0])), n(0.1), n(0.12)]), -0.048044655, 1e-7);
+    is_err(ev("MIRR", vec![rf(col(&[1.0, 2.0])), n(0.1), n(0.1)]), CellError::Div0);
+    // Excel 365 gives -1 when every flow is negative: the positive flows are worth nothing.
+    close_tol(ev("MIRR", vec![rf(col(&[-10000.0, -3400.0, -6500.0, -1000.0])), n(0.07), n(0.01)]), -1.0, 1e-12);
+    close(ev("FVSCHEDULE", vec![n(1.0), av(row(&[0.09, 0.11, 0.1]))]), 1.33089);
+    close(ev("EFFECT", vec![n(0.0525), n(4.0)]), 0.0535426673707584);
+    is_err(ev("EFFECT", vec![n(-0.1), n(4.0)]), CellError::Num);
+    close_tol(ev("NOMINAL", vec![n(0.053543), n(4.0)]), 0.052500319, 1e-8);
+    close_tol(ev("ISPMT", vec![n(0.1 / 12.0), n(0.0), n(36.0), n(8000000.0)]), -66666.66667, 1e-9);
+    is_err(ev("ISPMT", vec![n(0.1), n(1.0), n(0.0), n(1.0)]), CellError::Div0);
+    close_tol(ev("PDURATION", vec![n(0.025), n(2000.0), n(2200.0)]), 3.859866163, 1e-9);
+    is_err(ev("PDURATION", vec![n(0.0), n(2000.0), n(2200.0)]), CellError::Num);
+    close_tol(ev("RRI", vec![n(96.0), n(10000.0), n(11000.0)]), 0.0009933, 1e-4);
+    close(ev("DOLLARDE", vec![n(1.02), n(16.0)]), 1.125);
+    close(ev("DOLLARDE", vec![n(1.1), n(32.0)]), 1.3125);
+    close(ev("DOLLARFR", vec![n(1.125), n(16.0)]), 1.02);
+    close(ev("DOLLARFR", vec![n(1.125), n(32.0)]), 1.04);
+    is_err(ev("DOLLARDE", vec![n(1.02), n(0.0)]), CellError::Div0);
+    is_err(ev("DOLLARDE", vec![n(1.02), n(-1.0)]), CellError::Num);
+}
+
+#[test]
+fn depreciation() {
+    close(ev("SLN", vec![n(30000.0), n(7500.0), n(10.0)]), 2250.0);
+    is_err(ev("SLN", vec![n(30000.0), n(7500.0), n(0.0)]), CellError::Div0);
+    close_tol(ev("SYD", vec![n(30000.0), n(7500.0), n(10.0), n(1.0)]), 4090.909091, 1e-9);
+    close_tol(ev("SYD", vec![n(30000.0), n(7500.0), n(10.0), n(10.0)]), 409.0909091, 1e-9);
+    let dbv = |p: f64| ev("DB", vec![n(1000000.0), n(100000.0), n(6.0), n(p), n(7.0)]);
+    close_tol(dbv(1.0), 186083.3333, 1e-9);
+    close_tol(dbv(2.0), 259639.4167, 1e-9);
+    close_tol(dbv(3.0), 176814.4428, 1e-9);
+    close_tol(dbv(7.0), 15845.09847, 1e-9);
+    is_err(dbv(8.0), CellError::Num);
+    close_tol(ev("DDB", vec![n(2400.0), n(300.0), n(3650.0), n(1.0)]), 1.315068493, 1e-8);
+    close(ev("DDB", vec![n(2400.0), n(300.0), n(120.0), n(1.0), n(2.0)]), 40.0);
+    close(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(1.0), n(2.0)]), 480.0);
+    close_tol(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(2.0), n(1.5)]), 306.0, 1e-12);
+    close_tol(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(10.0)]), 22.1225472, 1e-8);
+    is_err(ev("DDB", vec![n(2400.0), n(300.0), n(10.0), n(11.0)]), CellError::Num);
+    close_tol(ev("VDB", vec![n(2400.0), n(300.0), n(3650.0), n(0.0), n(1.0)]), 1.315068493, 1e-8);
+    close(ev("VDB", vec![n(2400.0), n(300.0), n(120.0), n(0.0), n(1.0)]), 40.0);
+    close(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(0.0), n(1.0)]), 480.0);
+    close_tol(ev("VDB", vec![n(2400.0), n(300.0), n(120.0), n(6.0), n(18.0)]), 396.3060533, 1e-8);
+    close_tol(ev("VDB", vec![n(2400.0), n(300.0), n(120.0), n(6.0), n(18.0), n(1.5)]), 311.8089367, 1e-8);
+    close(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(0.0), n(0.875), n(1.5)]), 315.0);
+    // Over the whole life the total depreciation is cost - salvage.
+    close(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(0.0), n(10.0)]), 2100.0);
+    is_err(ev("VDB", vec![n(2400.0), n(300.0), n(10.0), n(5.0), n(4.0)]), CellError::Num);
+    close_tol(ev("AMORLINC", vec![n(2400.0), d(2008, 8, 19), d(2008, 12, 31), n(300.0), n(1.0), n(0.15), n(1.0)]), 360.0, 1e-9);
+    close(ev("AMORDEGRC", vec![n(2400.0), d(2008, 8, 19), d(2008, 12, 31), n(300.0), n(1.0), n(0.15), n(1.0)]), 776.0);
+}
+
+#[test]
+fn coupons() {
+    let args = |f: &str| ev(f, vec![d(2011, 1, 25), d(2011, 11, 15), n(2.0), n(1.0)]);
+    close(args("COUPDAYBS"), 71.0);
+    close(args("COUPDAYS"), 181.0);
+    close(args("COUPDAYSNC"), 110.0);
+    close(args("COUPNCD"), 40678.0);
+    close(args("COUPPCD"), 40497.0);
+    close(args("COUPNUM"), 2.0);
+    close(ev("COUPDAYS", vec![d(2011, 1, 25), d(2011, 11, 15), n(2.0), n(0.0)]), 180.0);
+    close(ev("COUPDAYS", vec![d(2011, 1, 25), d(2011, 11, 15), n(4.0), n(3.0)]), 91.25);
+    close(ev("COUPNUM", vec![d(2007, 1, 25), d(2008, 11, 15), n(2.0), n(1.0)]), 4.0);
+    is_err(ev("COUPNUM", vec![d(2012, 1, 25), d(2011, 11, 15), n(2.0)]), CellError::Num);
+    is_err(ev("COUPNUM", vec![d(2011, 1, 25), d(2011, 11, 15), n(3.0)]), CellError::Num);
+    is_err(ev("COUPNUM", vec![d(2011, 1, 25), d(2011, 11, 15), n(2.0), n(5.0)]), CellError::Num);
+    // End-of-month maturity keeps month-end coupon dates.
+    close(ev("COUPPCD", vec![d(2011, 3, 15), d(2011, 11, 30), n(2.0)]), serial_from_ymd(DateSystem::D1900, 2010, 11, 30).unwrap());
+    close(ev("COUPNCD", vec![d(2011, 3, 15), d(2011, 11, 30), n(2.0)]), serial_from_ymd(DateSystem::D1900, 2011, 5, 31).unwrap());
+}
+
+#[test]
+fn securities() {
+    close_tol(ev("DISC", vec![d(2007, 1, 25), d(2007, 6, 15), n(97.975), n(100.0), n(1.0)]), 0.052420213, 1e-8);
+    close_tol(ev("PRICEDISC", vec![d(2008, 2, 16), d(2008, 3, 1), n(0.0525), n(100.0), n(2.0)]), 99.79583333, 1e-9);
+    close_tol(ev("YIELDDISC", vec![d(2008, 2, 16), d(2008, 3, 1), n(99.795), n(100.0), n(2.0)]), 0.052823, 1e-5);
+    close_tol(ev("INTRATE", vec![d(2008, 2, 15), d(2008, 5, 15), n(1000000.0), n(1014420.0), n(2.0)]), 0.05768, 1e-9);
+    close_tol(ev("RECEIVED", vec![d(2008, 2, 15), d(2008, 5, 15), n(1000000.0), n(0.0575), n(2.0)]), 1014584.654, 1e-9);
+    is_err(ev("DISC", vec![d(2008, 2, 15), d(2008, 1, 15), n(97.0), n(100.0)]), CellError::Num);
+    close_tol(ev("TBILLPRICE", vec![d(2008, 3, 31), d(2008, 6, 1), n(0.09)]), 98.45, 1e-12);
+    close_tol(ev("TBILLYIELD", vec![d(2008, 3, 31), d(2008, 6, 1), n(98.45)]), 0.091417, 1e-6);
+    close_tol(ev("TBILLEQ", vec![d(2008, 3, 31), d(2008, 6, 1), n(0.0914)]), 0.094151, 1e-6);
+    is_err(ev("TBILLPRICE", vec![d(2008, 3, 31), d(2009, 6, 1), n(0.09)]), CellError::Num);
+    close_tol(ev("ACCRINTM", vec![d(2008, 4, 1), d(2008, 6, 15), n(0.1), n(1000.0), n(3.0)]), 20.54794521, 1e-9);
+    is_err(ev("ACCRINTM", vec![d(2008, 6, 15), d(2008, 4, 1), n(0.1)]), CellError::Num);
+    close_tol(ev("ACCRINT", vec![d(2008, 3, 1), d(2008, 8, 31), d(2008, 5, 1), n(0.1), n(1000.0), n(2.0), n(0.0)]), 16.66666667, 1e-9);
+    close_tol(ev("ACCRINT", vec![d(2008, 3, 5), d(2008, 8, 31), d(2008, 5, 1), n(0.1), n(1000.0), n(2.0), n(0.0), b(false)]), 15.55555556, 1e-9);
+    close_tol(ev("PRICEMAT", vec![d(2008, 2, 15), d(2008, 4, 13), d(2007, 11, 11), n(0.061), n(0.061), n(0.0)]), 99.98449888, 1e-9);
+    close_tol(ev("YIELDMAT", vec![d(2008, 3, 15), d(2008, 11, 3), d(2007, 11, 8), n(0.0625), n(100.0123), n(0.0)]), 0.060954, 1e-6);
+    close_tol(ev("PRICE", vec![d(2008, 2, 15), d(2017, 11, 15), n(0.0575), n(0.065), n(100.0), n(2.0), n(0.0)]), 94.63436, 1e-7);
+    close_tol(ev("YIELD", vec![d(2008, 2, 15), d(2016, 11, 15), n(0.0575), n(95.04287), n(100.0), n(2.0), n(0.0)]), 0.065, 1e-6);
+    is_err(ev("PRICE", vec![d(2008, 2, 15), d(2017, 11, 15), n(-0.01), n(0.065), n(100.0), n(2.0)]), CellError::Num);
+    close_tol(ev("DURATION", vec![d(2018, 7, 1), d(2048, 1, 1), n(0.08), n(0.09), n(2.0), n(1.0)]), 10.9191453, 1e-8);
+    close_tol(ev("MDURATION", vec![d(2008, 1, 1), d(2016, 1, 1), n(0.08), n(0.09), n(2.0), n(1.0)]), 5.73567, 1e-6);
+    // A one-coupon bond uses the closed form for yield; PRICE and YIELD invert each other.
+    let p = ev("PRICE", vec![d(2008, 2, 15), d(2008, 6, 15), n(0.05), n(0.04), n(100.0), n(2.0)]);
+    let pv = match p {
+        Value::Number(x) => x,
+        _ => panic!(),
+    };
+    close_tol(ev("YIELD", vec![d(2008, 2, 15), d(2008, 6, 15), n(0.05), n(pv), n(100.0), n(2.0)]), 0.04, 1e-9);
+}
+
+fn number(v: Value) -> f64 {
+    match v {
+        Value::Number(x) => x,
+        other => panic!("expected a number, got {other:?}"),
+    }
+}
+
+#[test]
+fn odd_periods() {
+    // The worked examples on Microsoft's function pages (results as printed there).
+    let first = |x: f64, rest: &[f64]| {
+        let mut a = vec![d(2008, 11, 11), d(2021, 3, 1), d(2008, 10, 15), d(2009, 3, 1), n(x)];
+        a.extend(rest.iter().map(|v| n(*v)));
+        a
+    };
+    close_tol(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 1.0])), 113.60, 0.005 / 113.6);
+    close_tol(ev("ODDFYIELD", first(0.0575, &[84.50, 100.0, 2.0, 0.0])), 0.0772, 0.00005);
+    let lp = vec![d(2008, 2, 7), d(2008, 6, 15), d(2007, 10, 15), n(0.0375), n(0.0405), n(100.0), n(2.0), n(0.0)];
+    close_tol(ev("ODDLPRICE", lp), 99.88, 0.005 / 99.88);
+    let ly = vec![d(2008, 4, 20), d(2008, 6, 15), d(2007, 12, 24), n(0.0375), n(99.875), n(100.0), n(2.0), n(0.0)];
+    close_tol(ev("ODDLYIELD", ly), 0.04519, 0.000005);
+
+    // Yield → price → yield, for a short and a long odd first period and a long odd last period.
+    for (issue, basis) in [(d(2008, 10, 15), 0.0), (d(2007, 1, 20), 1.0), (d(2008, 1, 31), 3.0)] {
+        let args = |x: f64| vec![d(2008, 11, 11), d(2021, 3, 1), issue.clone(), d(2009, 3, 1), n(0.06), n(x), n(100.0), n(2.0), n(basis)];
+        let p = number(ev("ODDFPRICE", args(0.05)));
+        close_tol(ev("ODDFYIELD", args(p)), 0.05, 1e-9);
+    }
+    let last = |x: f64| vec![d(2009, 2, 1), d(2009, 12, 15), d(2008, 3, 15), n(0.04), n(x), n(100.0), n(4.0), n(1.0)];
+    let p = number(ev("ODDLPRICE", last(0.07)));
+    close_tol(ev("ODDLYIELD", last(p)), 0.07, 1e-9);
+
+    // Argument checks: frequency, basis, date order, negative yield, non-positive price.
+    is_err(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 3.0, 1.0])), CellError::Num);
+    is_err(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 5.0])), CellError::Num);
+    is_err(ev("ODDFPRICE", first(0.0785, &[-0.01, 100.0, 2.0, 1.0])), CellError::Num);
+    is_err(ev("ODDFYIELD", first(0.0575, &[0.0, 100.0, 2.0, 0.0])), CellError::Num);
+    is_err(
+        ev("ODDFPRICE", vec![d(2009, 4, 1), d(2021, 3, 1), d(2008, 10, 15), d(2009, 3, 1), n(0.07), n(0.06), n(100.0), n(2.0)]),
+        CellError::Num,
+    );
+    is_err(ev("ODDLPRICE", vec![d(2007, 10, 1), d(2008, 6, 15), d(2007, 10, 15), n(0.0375), n(0.0405), n(100.0), n(2.0)]), CellError::Num);
+    is_err(ev("ODDLYIELD", vec![d(2008, 4, 20), d(2008, 6, 15), d(2007, 12, 24), n(0.0375), n(-1.0), n(100.0), n(2.0)]), CellError::Num);
+    is_err(
+        ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 1.0]).into_iter().take(4).chain([t("x"), n(0.06), n(100.0), n(2.0)]).collect()),
+        CellError::Value,
+    );
+}
+
+#[test]
+fn odd_periods_survive_hostile_input() {
+    // Quarterly quasi-periods across the whole date range, huge rates and yields: a value or
+    // an error, never a panic or a hang.
+    let wide = |x: f64, y: f64| vec![n(2_957_000.0), n(2_958_465.0), n(400.0), n(2_957_900.0), n(x), n(y), n(1e300), n(4.0), n(1.0)];
+    for (x, y) in [(0.05, 0.05), (1e300, 1e300), (0.0, 1e-300)] {
+        let _ = ev("ODDFPRICE", wide(x, y));
+        let _ = ev("ODDFYIELD", wide(x, y));
+    }
+    // The long walk itself works: settled early in an odd first period of ~32,000 quarters,
+    // a small yield round-trips.
+    let long = |y: f64| vec![n(500.0), n(2_958_465.0), n(400.0), n(2_957_900.0), n(0.05), n(y), n(100.0), n(4.0), n(1.0)];
+    let p = number(ev("ODDFPRICE", long(0.0001)));
+    close_tol(ev("ODDFYIELD", long(p)), 0.0001, 1e-9);
+    let last = |x: f64, y: f64| vec![n(2_958_000.0), n(2_958_465.0), n(400.0), n(x), n(y), n(1e300), n(4.0), n(1.0)];
+    for (x, y) in [(0.05, 0.05), (1e300, 1e300), (0.0, f64::MAX)] {
+        let _ = ev("ODDLPRICE", last(x, y));
+        let _ = ev("ODDLYIELD", last(x, y));
+    }
+    is_err(ev("ODDFPRICE", vec![n(-5.0), n(1e20), n(0.0), n(1e10), n(0.05), n(0.05), n(100.0), n(2.0)]), CellError::Num);
+}
+
+#[test]
+fn euroconvert() {
+    // The examples on Microsoft's EUROCONVERT page.
+    let ec = |x: f64, s: &str, tg: &str, rest: Vec<Arg>| {
+        let mut a = vec![n(x), t(s), t(tg)];
+        a.extend(rest);
+        ev("EUROCONVERT", a)
+    };
+    close(ec(1.2, "DEM", "EUR", vec![]), 0.61);
+    close(ec(1.0, "FRF", "EUR", vec![b(true), n(3.0)]), 0.152);
+    close(ec(1.0, "FRF", "EUR", vec![b(false), n(3.0)]), 0.15);
+    close(ec(1.0, "FRF", "DEM", vec![b(true), n(3.0)]), 0.29728616);
+    // Euro to a member currency rounds to the target's calculation precision (lira: 0).
+    close(ec(10.0, "eur", "ITL", vec![]), 19363.0);
+    close(ec(100.0, "EUR", "IEP", vec![b(true)]), 78.7564);
+    // Same currency returns the number untouched.
+    close(ec(1.23456, "DEM", "DEM", vec![]), 1.23456);
+    // Unknown codes and a triangulation precision below 3 are #VALUE!.
+    is_err(ec(1.0, "USD", "EUR", vec![]), CellError::Value);
+    is_err(ec(1.0, "FRF", "DEM", vec![b(true), n(2.0)]), CellError::Value);
+    // Hostile magnitudes give a number or #NUM!, never a panic.
+    is_err(ec(f64::MAX, "EUR", "ITL", vec![]), CellError::Num);
+    close(ec(1.0, "FRF", "DEM", vec![b(true), n(1e300)]), 1.95583 / 6.55957);
+}
+
+#[test]
+fn lifting() {
+    let v = ev("SLN", vec![av(row(&[100.0, 200.0])), n(0.0), n(10.0)]);
+    assert_eq!(rows_of(&v), vec![vec![nv(10.0), nv(20.0)]]);
+    is_err(ev("PMT", vec![t("abc"), n(1.0), n(1.0)]), CellError::Value);
+    is_err(ev("PMT", vec![e(CellError::NA), n(1.0), n(1.0)]), CellError::NA);
+}
+
+#[test]
+fn securities_read_dates_in_the_1904_system() {
+    let d4 = |y, m, dd| n(serial_from_ymd(DateSystem::D1904, y, m, dd).unwrap());
+    let ev4 = |name: &str, args: Vec<Arg>| {
+        let mut ctx = TestCtx { sys: DateSystem::D1904, ..TestCtx::default() };
+        crate::call(crate::lookup(name).unwrap(), &args, &mut ctx)
+    };
+    let (s, m) = (d4(2011, 3, 15), d4(2011, 11, 30));
+    close(ev4("COUPNCD", vec![s.clone(), m.clone(), n(2.0)]), 39232.0);
+    close(ev4("COUPPCD", vec![s.clone(), m.clone(), n(4.0), n(0.0)]), 39140.0);
+    close(ev4("COUPDAYBS", vec![s.clone(), m.clone(), n(4.0), n(0.0)]), 15.0);
+    let accrint = vec![d4(2008, 3, 1), d4(2008, 8, 31), d4(2008, 5, 1), n(0.1), n(1000.0), n(2.0), n(1.0)];
+    close_tol(ev4("ACCRINT", accrint), 16.576086956522, 1e-9);
+    // Results that already matched Excel keep matching.
+    let semi = |name| ev4(name, vec![s.clone(), m.clone(), n(2.0), n(0.0)]);
+    close(semi("COUPPCD"), 39050.0);
+    close(semi("COUPDAYS"), 180.0);
+    close(semi("COUPDAYBS"), 105.0);
+    close(semi("COUPDAYSNC"), 75.0);
+    close(semi("COUPNUM"), 2.0);
+    let price = vec![s.clone(), m.clone(), n(0.0575), n(0.065), n(100.0), n(2.0), n(0.0)];
+    close_tol(ev4("PRICE", price), 99.47768286339101, 1e-9);
+    close_tol(ev4("DURATION", vec![s, m, n(0.08), n(0.09), n(2.0), n(0.0)]), 0.6890136809022, 1e-9);
+    let odd = vec![d4(2008, 11, 11), d4(2021, 3, 1), d4(2008, 10, 15), d4(2009, 3, 1), n(0.0785), n(0.0625), n(100.0), n(2.0), n(1.0)];
+    close_tol(ev4("ODDFPRICE", odd), 113.597717474079, 1e-9);
+}

From b3711f59ce152646a7f27aac60c3b911e7d20780 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:43 +0000
Subject: [PATCH 34/76] refactor(functions): move math tests to
 src/math/tests.rs

---
 crates/functions/src/math.rs       | 495 +----------------------------
 crates/functions/src/math/tests.rs | 492 ++++++++++++++++++++++++++++
 2 files changed, 493 insertions(+), 494 deletions(-)
 create mode 100644 crates/functions/src/math/tests.rs

diff --git a/crates/functions/src/math.rs b/crates/functions/src/math.rs
index 9824da7bf..964af2e5e 100644
--- a/crates/functions/src/math.rs
+++ b/crates/functions/src/math.rs
@@ -1305,497 +1305,4 @@ pub(crate) fn specs() -> Vec<FnSpec> {
 const NUM_RANGE_REV: &[bool] = &[false, true];
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::util::testutil::*;
-    use CellError::{Div0, NA, Num};
-
-    fn ev1(name: &str, x: f64) -> Value {
-        ev(name, vec![n(x)])
-    }
-    fn ev2(name: &str, x: f64, y: f64) -> Value {
-        ev(name, vec![n(x), n(y)])
-    }
-
-    #[test]
-    fn percentof() {
-        // SUM(subset) / SUM(all): text, booleans and blanks inside ranges are skipped like SUM.
-        let all = arr(vec![vec![nv(10.0)], vec![nv(30.0)], vec![tv("x")], vec![Value::Empty], vec![nv(60.0)]]);
-        let part = arr(vec![vec![nv(10.0)], vec![nv(30.0)]]);
-        close(ev("PERCENTOF", vec![rf(part), rf(all.clone())]), 0.4);
-        close(ev("PERCENTOF", vec![n(25.0), n(200.0)]), 0.125);
-        is_err(ev("PERCENTOF", vec![n(1.0), rf(arr(vec![vec![nv(5.0), nv(-5.0)]]))]), Div0);
-        is_err(ev("PERCENTOF", vec![rf(arr(vec![vec![Value::Error(NA)]])), rf(all)]), NA);
-        is_err(ev("PERCENTOF", vec![t("abc"), n(1.0)]), CellError::Value);
-    }
-
-    #[test]
-    fn sums() {
-        close(ev("SUM", vec![n(1.0), n(2.0), t("3"), b(true)]), 7.0);
-        let r = arr(vec![vec![nv(1.0), tv("x"), Value::Bool(true), Value::Empty, nv(4.0)]]);
-        close(ev("SUM", vec![rf(r.clone())]), 5.0);
-        is_err(ev("SUM", vec![t("abc")]), CellError::Value);
-        is_err(ev("SUM", vec![rf(arr(vec![vec![nv(1.0), Value::Error(Div0)]]))]), Div0);
-        close(ev("SUM", vec![rf(tv("abc"))]), 0.0);
-        close(ev("SUMSQ", vec![n(3.0), n(4.0)]), 25.0);
-        close(ev("PRODUCT", vec![rf(r), n(2.0)]), 8.0);
-        close(ev("PRODUCT", vec![rf(arr(vec![vec![tv("a")]]))]), 0.0);
-        let a1 = arr(vec![vec![nv(3.0), nv(4.0)], vec![nv(8.0), nv(6.0)], vec![nv(1.0), nv(9.0)]]);
-        let a2 = arr(vec![vec![nv(2.0), nv(7.0)], vec![nv(6.0), nv(7.0)], vec![nv(5.0), nv(3.0)]]);
-        close(ev("SUMPRODUCT", vec![rf(a1.clone()), rf(a2)]), 156.0);
-        close(ev("SUMPRODUCT", vec![rf(a1.clone())]), 31.0);
-        is_err(ev("SUMPRODUCT", vec![rf(a1), rf(row(&[1.0, 2.0]))]), CellError::Value);
-        close(ev("SUMPRODUCT", vec![av(row(&[1.0, 2.0])), av(arr(vec![vec![tv("x"), nv(3.0)]]))]), 6.0);
-        let x = row(&[2.0, 3.0, 9.0, 1.0, 8.0, 7.0, 5.0]);
-        let y = row(&[6.0, 5.0, 11.0, 7.0, 5.0, 4.0, 4.0]);
-        close(ev("SUMX2MY2", vec![av(x.clone()), av(y.clone())]), -55.0);
-        close(ev("SUMX2PY2", vec![av(x.clone()), av(y.clone())]), 521.0);
-        close(ev("SUMXMY2", vec![av(x.clone()), av(y)]), 79.0);
-        is_err(ev("SUMXMY2", vec![av(x), av(row(&[1.0]))]), NA);
-    }
-
-    /// SUMPRODUCT cases observed in Excel (FormulaEvalTestData, row "Sumproduct"): scalars and
-    /// single-cell references multiply in, text in a scalar argument is `#VALUE!`, sizes must match.
-    #[test]
-    fn sumproduct_scalar_arguments() {
-        let cases: Vec<(Vec<crate::Arg>, Result<f64, CellError>)> = vec![
-            (vec![n(3.0), rf(nv(534.0)), rf(nv(1.1))], Ok(1762.2)),
-            (vec![rf(nv(1.1)), n(3.0), rf(nv(534.0)), rf(nv(1.1))], Ok(1938.42)),
-            (vec![n(2.0), rf(col(&[1.00001, 2.99999]))], Err(CellError::Value)),
-            (vec![rf(tv("4")), rf(nv(2.0))], Err(CellError::Value)),
-            (vec![t("4"), n(2.0)], Err(CellError::Value)),
-            (vec![rf(nv(3.0)), rf(Value::Error(CellError::Ref))], Err(CellError::Ref)),
-            (vec![av(arr(vec![vec![tv("4")]])), n(2.0)], Ok(0.0)),
-        ];
-        for (args, want) in cases {
-            match want {
-                Ok(x) => close(ev("SUMPRODUCT", args), x),
-                Err(err) => is_err(ev("SUMPRODUCT", args), err),
-            }
-        }
-    }
-
-    #[test]
-    fn rounding() {
-        close(ev2("ROUND", 2.675, 2.0), 2.68);
-        close(ev2("ROUND", -1.5, 0.0), -2.0);
-        close(ev2("ROUND", 1234.567, -2.0), 1200.0);
-        close(ev2("ROUND", 2.15, 1.0), 2.2);
-        close(ev2("ROUNDUP", 3.2, 0.0), 4.0);
-        close(ev2("ROUNDUP", -3.14259, 1.0), -3.2);
-        close(ev2("ROUNDUP", 31415.92654, -2.0), 31500.0);
-        close(ev2("ROUNDDOWN", -3.9, 0.0), -3.0);
-        close(ev2("ROUNDDOWN", 2.71989, 3.0), 2.719);
-        close(ev2("ROUNDDOWN", 31415.92654, -2.0), 31400.0);
-        for digits in [-308.0, -309.0, -400.0] {
-            for x in [1234.0, -1234.0, 0.5] {
-                close(ev2("ROUNDDOWN", x, digits), 0.0);
-                close(ev2("TRUNC", x, digits), 0.0);
-            }
-        }
-        assert!(matches!(ev2("ROUNDUP", 1234.0, -309.0), Value::Error(CellError::Num)));
-        close(ev2("ROUNDUP", 0.1 + 0.2, 1.0), 0.3);
-        close(ev2("TRUNC", 8.987, 2.0), 8.98);
-        close(ev1("TRUNC", -8.9), -8.0);
-        close(ev1("INT", -8.9), -9.0);
-        close(ev1("INT", 8.9), 8.0);
-        close(ev2("MROUND", 10.0, 3.0), 9.0);
-        close(ev2("MROUND", -10.0, -3.0), -9.0);
-        close(ev2("MROUND", 1.3, 0.2), 1.4);
-        is_err(ev2("MROUND", 5.0, -2.0), Num);
-        close(ev2("CEILING", 2.5, 1.0), 3.0);
-        close(ev2("CEILING", -2.5, -2.0), -4.0);
-        close(ev2("CEILING", -2.5, 2.0), -2.0);
-        close(ev2("CEILING", 1.5, 0.1), 1.5);
-        close(ev2("CEILING", 0.234, 0.01), 0.24);
-        is_err(ev2("CEILING", 2.5, -1.0), Num);
-        close(ev2("FLOOR", 3.7, 2.0), 2.0);
-        close(ev2("FLOOR", -2.5, -2.0), -2.0);
-        close(ev2("FLOOR", -2.5, 2.0), -4.0);
-        is_err(ev2("FLOOR", 2.5, -2.0), Num);
-        is_err(ev2("FLOOR", 2.5, 0.0), Div0);
-        close(ev2("FLOOR", 1.58, 0.1), 1.5);
-        close(ev2("FLOOR", 0.234, 0.01), 0.23);
-        close(ev2("CEILING.MATH", 24.3, 5.0), 25.0);
-        close(ev1("CEILING.MATH", 6.7), 7.0);
-        close(ev2("CEILING.MATH", -8.1, 2.0), -8.0);
-        close(ev("CEILING.MATH", vec![n(-5.5), n(2.0), n(-1.0)]), -6.0);
-        close(ev2("FLOOR.MATH", 24.3, 5.0), 20.0);
-        close(ev1("FLOOR.MATH", 6.7), 6.0);
-        close(ev2("FLOOR.MATH", -8.1, 2.0), -10.0);
-        close(ev("FLOOR.MATH", vec![n(-5.5), n(2.0), n(-1.0)]), -4.0);
-        close(ev2("CEILING.PRECISE", -4.6, 2.0), -4.0);
-        close(ev2("CEILING.PRECISE", 4.3, -2.0), 6.0);
-        close(ev2("ISO.CEILING", 4.3, 0.0), 0.0);
-        close(ev2("FLOOR.PRECISE", -3.2, -1.0), -4.0);
-        close(ev1("FLOOR.PRECISE", 3.2), 3.0);
-        close(ev1("EVEN", 1.5), 2.0);
-        close(ev1("EVEN", 3.0), 4.0);
-        close(ev1("EVEN", 2.0), 2.0);
-        close(ev1("EVEN", -1.0), -2.0);
-        close(ev1("EVEN", 0.0), 0.0);
-        close(ev1("ODD", 1.5), 3.0);
-        close(ev1("ODD", 3.0), 3.0);
-        close(ev1("ODD", 2.0), 3.0);
-        close(ev1("ODD", -1.0), -1.0);
-        close(ev1("ODD", -2.0), -3.0);
-        close(ev1("ODD", 0.0), 1.0);
-    }
-
-    #[test]
-    fn mod_tiny_divisor_stays_in_range() {
-        for (x, d) in [(3.0, 1e-300), (-1.0, 1e-300), (3.0, -1e-300), (-1.0, -1e-300)] {
-            match ev2("MOD", x, d) {
-                Value::Number(r) => {
-                    assert!(r == 0.0 || (r < 0.0) == (d < 0.0), "MOD({x}, {d}) = {r}");
-                    assert!(r.abs() < d.abs(), "MOD({x}, {d}) = {r}");
-                }
-                other => panic!("MOD({x}, {d}) = {other:?}"),
-            }
-        }
-    }
-
-    #[test]
-    fn arithmetic() {
-        close(ev2("MOD", 3.0, 2.0), 1.0);
-        close(ev2("MOD", -3.0, 2.0), 1.0);
-        close(ev2("MOD", 3.0, -2.0), -1.0);
-        close(ev2("MOD", -3.0, -2.0), -1.0);
-        close(ev2("MOD", 5.5, 1.0), 0.5);
-        is_err(ev2("MOD", 1.0, 0.0), Div0);
-        close(ev2("QUOTIENT", 5.0, 2.0), 2.0);
-        close(ev2("QUOTIENT", -10.0, 3.0), -3.0);
-        is_err(ev2("QUOTIENT", 1.0, 0.0), Div0);
-        close(ev1("ABS", -4.0), 4.0);
-        close(ev1("SIGN", -0.0001), -1.0);
-        close(ev1("SIGN", 0.0), 0.0);
-        close(ev1("SQRT", 16.0), 4.0);
-        is_err(ev1("SQRT", -16.0), Num);
-        close(ev1("SQRTPI", 1.0), 1.772_453_850_905_516);
-        close(ev2("POWER", 5.0, 2.0), 25.0);
-        close(ev2("POWER", 4.0, 1.25), 5.656_854_249_492_381);
-        close(ev2("POWER", -2.0, 3.0), -8.0);
-        is_err(ev2("POWER", 0.0, 0.0), Num);
-        is_err(ev2("POWER", 0.0, -1.0), Div0);
-        is_err(ev2("POWER", -8.0, 1.0 / 3.0), Num);
-        is_err(ev2("POWER", 10.0, 400.0), Num);
-        close(ev1("EXP", 1.0), std::f64::consts::E);
-        close(ev2("LOG", 8.0, 2.0), 3.0);
-        close(ev1("LOG", 10.0), 1.0);
-        close(ev2("LOG", 81.0, 3.0), 4.0);
-        is_err(ev1("LN", 0.0), Num);
-        is_err(ev2("LOG", 10.0, 1.0), Div0);
-        is_err(ev1("LOG10", -1.0), Num);
-        close(ev1("LN", std::f64::consts::E), 1.0);
-        close(ev1("LOG10", 1e5), 5.0);
-        close(ev("PI", vec![]), PI);
-        close(ev("SQRT", vec![t("16")]), 4.0);
-        is_err(ev("SQRT", vec![t("x")]), CellError::Value);
-    }
-
-    #[test]
-    fn combinatorics() {
-        close(ev1("FACT", 5.0), 120.0);
-        close(ev1("FACT", 1.9), 1.0);
-        close(ev1("FACT", 0.0), 1.0);
-        is_err(ev1("FACT", -1.0), Num);
-        is_err(ev1("FACT", 171.0), Num);
-        close(ev1("FACTDOUBLE", 6.0), 48.0);
-        close(ev1("FACTDOUBLE", 7.0), 105.0);
-        close(ev1("FACTDOUBLE", -1.0), 1.0);
-        is_err(ev1("FACTDOUBLE", -2.0), Num);
-        close(ev2("COMBIN", 8.0, 2.0), 28.0);
-        close(ev2("COMBIN", 8.9, 2.9), 28.0);
-        is_err(ev2("COMBIN", 2.0, 3.0), Num);
-        close(ev2("COMBIN", 60.0, 30.0), 118_264_581_564_861_424.0);
-        close(ev2("COMBINA", 4.0, 3.0), 20.0);
-        close(ev2("COMBINA", 10.0, 3.0), 220.0);
-        close(ev2("PERMUT", 100.0, 3.0), 970_200.0);
-        close(ev2("PERMUT", 3.0, 2.0), 6.0);
-        is_err(ev2("PERMUT", 2.0, 3.0), Num);
-        close(ev2("PERMUTATIONA", 3.0, 2.0), 9.0);
-        close(ev2("GCD", 24.0, 36.0), 12.0);
-        close(ev2("GCD", 5.0, 0.0), 5.0);
-        close(ev2("GCD", 7.0, 1.0), 1.0);
-        is_err(ev2("GCD", -1.0, 5.0), Num);
-        close(ev("GCD", vec![av(row(&[12.0, 18.0, 30.0]))]), 6.0);
-        close(ev2("LCM", 24.0, 36.0), 72.0);
-        close(ev2("LCM", 5.0, 2.0), 10.0);
-        close(ev2("LCM", 5.0, 0.0), 0.0);
-        close(ev("MULTINOMIAL", vec![n(2.0), n(3.0), n(4.0)]), 1260.0);
-        is_err(ev("MULTINOMIAL", vec![n(-1.0), n(2.0)]), Num);
-    }
-
-    #[test]
-    fn trig() {
-        close(ev1("SIN", PI / 2.0), 1.0);
-        close(ev1("COS", 0.0), 1.0);
-        close(ev1("TAN", PI / 4.0), 1.0);
-        is_err(ev1("SIN", 1e10), Num);
-        close(ev1("ASIN", 1.0), PI / 2.0);
-        is_err(ev1("ACOS", 1.5), Num);
-        close(ev1("ACOT", 2.0), 0.463_647_609_000_806);
-        close(ev1("ACOTH", 6.0), 0.168_236_118_310_606);
-        is_err(ev1("ACOTH", 0.5), Num);
-        close(ev1("COT", 30.0), -0.156_119_952_161_659);
-        is_err(ev1("COT", 0.0), Div0);
-        close(ev1("COTH", 2.0), 1.037_314_720_727_548);
-        close(ev1("CSC", 15.0), 1.537_780_562_208_209);
-        close(ev1("CSCH", 1.5), 0.469_642_440_595_653);
-        close(ev1("SEC", 45.0), 1.903_594_407_014_6);
-        close_tol(ev1("SECH", 45.0), 5.725_037_161_098_787e-20, 1e-9);
-        close(ev2("ATAN2", 1.0, 1.0), PI / 4.0);
-        close(ev2("ATAN2", -1.0, -1.0), -3.0 * PI / 4.0);
-        is_err(ev2("ATAN2", 0.0, 0.0), Div0);
-        close(ev1("ASINH", -2.5), -1.647_231_146_371_096);
-        close(ev1("ACOSH", 10.0), 2.993_222_846_126_381);
-        is_err(ev1("ACOSH", 0.5), Num);
-        close(ev1("ATANH", 0.5), 0.549_306_144_334_055);
-        is_err(ev1("ATANH", 1.0), Num);
-        close(ev1("SINH", 1.0), 1.175_201_193_643_801);
-        close(ev1("DEGREES", PI), 180.0);
-        close(ev1("RADIANS", 270.0), 4.712_388_980_384_69);
-    }
-
-    #[test]
-    fn number_systems() {
-        is_text(ev1("ROMAN", 499.0), "CDXCIX");
-        is_text(ev2("ROMAN", 499.0, 1.0), "LDVLIV");
-        is_text(ev2("ROMAN", 499.0, 2.0), "XDIX");
-        is_text(ev2("ROMAN", 499.0, 3.0), "VDIV");
-        is_text(ev2("ROMAN", 499.0, 4.0), "ID");
-        is_text(ev("ROMAN", vec![n(499.0), b(false)]), "ID");
-        is_text(ev1("ROMAN", 1999.0), "MCMXCIX");
-        is_text(ev1("ROMAN", 3999.0), "MMMCMXCIX");
-        is_text(ev1("ROMAN", 0.0), "");
-        is_err(ev1("ROMAN", 4000.0), CellError::Value);
-        is_err(ev1("ROMAN", -1.0), CellError::Value);
-        close(ev("ARABIC", vec![t("LVII")]), 57.0);
-        close(ev("ARABIC", vec![t("mcmxii")]), 1912.0);
-        close(ev("ARABIC", vec![t("")]), 0.0);
-        close(ev("ARABIC", vec![t("-XIV")]), -14.0);
-        is_err(ev("ARABIC", vec![t("ABC")]), CellError::Value);
-        is_text(ev2("BASE", 7.0, 2.0), "111");
-        is_text(ev2("BASE", 100.0, 16.0), "64");
-        is_text(ev("BASE", vec![n(15.0), n(2.0), n(10.0)]), "0000001111");
-        is_text(ev2("BASE", 0.0, 36.0), "0");
-        is_err(ev2("BASE", 7.0, 1.0), Num);
-        is_err(ev2("BASE", -7.0, 2.0), Num);
-        close(ev("DECIMAL", vec![t("FF"), n(16.0)]), 255.0);
-        close(ev("DECIMAL", vec![t("111"), n(2.0)]), 7.0);
-        close(ev("DECIMAL", vec![t("zap"), n(36.0)]), 45745.0);
-        is_err(ev("DECIMAL", vec![t("12"), n(2.0)]), Num);
-    }
-
-    /// Every number where Excel's forms 2 and 3 differ from a plain ratio limit (issue #733):
-    /// form 2 subtracts I from C and X from M, form 3 also V from M.
-    #[test]
-    fn roman_forms_two_and_three_match_excel() {
-        const HUNDREDS: [&str; 10] = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"];
-        const ONES: [&str; 10] = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
-        let mut cases = Vec::new();
-        for thousands in 0..4usize {
-            let m = "M".repeat(thousands);
-            for (h, hundreds) in HUNDREDS.iter().enumerate() {
-                if h != 4 && h != 9 {
-                    cases.push((thousands * 1000 + h * 100 + 99, 2.0, format!("{m}{hundreds}IC")));
-                }
-            }
-            for (o, ones) in ONES.iter().enumerate() {
-                cases.push((thousands * 1000 + 990 + o, 2.0, format!("{m}XM{ones}")));
-            }
-            for (o, ones) in ONES.iter().enumerate().take(5) {
-                cases.push((thousands * 1000 + 995 + o, 3.0, format!("{m}VM{ones}")));
-            }
-        }
-        assert_eq!(cases.len(), 92);
-        for (number, form, want) in &cases {
-            is_text(ev2("ROMAN", *number as f64, *form), want);
-        }
-        // Neighbours that already matched: form 2 still has no VD or ID, form 3 no ID.
-        is_text(ev2("ROMAN", 495.0, 2.0), "XDV");
-        is_text(ev2("ROMAN", 495.0, 3.0), "VD");
-        is_text(ev2("ROMAN", 1499.0, 2.0), "MXDIX");
-        is_text(ev2("ROMAN", 999.0, 0.0), "CMXCIX");
-        is_text(ev2("ROMAN", 999.0, 1.0), "LMVLIV");
-        is_text(ev2("ROMAN", 999.0, 4.0), "IM");
-        is_text(ev2("ROMAN", 995.0, 4.0), "VM");
-        is_text(ev2("ROMAN", 99.0, 1.0), "VCIV");
-        is_text(ev2("ROMAN", 99.0, 4.0), "IC");
-    }
-
-    #[test]
-    fn minverse_scale_relative() {
-        let big = ev("MINVERSE", vec![av(arr(vec![vec![nv(1e20), nv(0.0)], vec![nv(0.0), nv(1e20)]]))]);
-        let r = rows_of(&big);
-        close_tol(r[0][0].clone(), 1e-20, 1e-25);
-        close_tol(r[1][1].clone(), 1e-20, 1e-25);
-        let small = ev("MINVERSE", vec![av(arr(vec![vec![nv(1e-20), nv(0.0)], vec![nv(0.0), nv(1e-20)]]))]);
-        let r = rows_of(&small);
-        close_tol(r[0][0].clone(), 1e20, 1e10);
-    }
-
-    #[test]
-    fn matrices() {
-        let a = arr(vec![vec![nv(1.0), nv(2.0)], vec![nv(3.0), nv(4.0)]]);
-        let b2 = arr(vec![vec![nv(5.0), nv(6.0)], vec![nv(7.0), nv(8.0)]]);
-        assert_eq!(rows_of(&ev("MMULT", vec![av(a.clone()), av(b2)])), vec![vec![nv(19.0), nv(22.0)], vec![nv(43.0), nv(50.0)]]);
-        is_err(ev("MMULT", vec![av(a.clone()), av(row(&[1.0, 2.0]))]), CellError::Value);
-        is_err(ev("MMULT", vec![av(arr(vec![vec![tv("x")]])), av(row(&[1.0]))]), CellError::Value);
-        close(ev("MDETERM", vec![av(a.clone())]), -2.0);
-        let m3 = arr(vec![vec![nv(3.0), nv(6.0), nv(1.0)], vec![nv(1.0), nv(1.0), nv(0.0)], vec![nv(3.0), nv(10.0), nv(2.0)]]);
-        close(ev("MDETERM", vec![av(m3)]), 1.0);
-        let m4 = arr(vec![
-            vec![nv(1.0), nv(3.0), nv(8.0), nv(5.0)],
-            vec![nv(1.0), nv(3.0), nv(6.0), nv(1.0)],
-            vec![nv(1.0), nv(1.0), nv(1.0), nv(0.0)],
-            vec![nv(7.0), nv(3.0), nv(10.0), nv(2.0)],
-        ]);
-        close(ev("MDETERM", vec![av(m4)]), 88.0);
-        is_err(ev("MDETERM", vec![av(row(&[1.0, 2.0]))]), CellError::Value);
-        let inv = ev("MINVERSE", vec![av(arr(vec![vec![nv(4.0), nv(-1.0)], vec![nv(2.0), nv(0.0)]]))]);
-        let r = rows_of(&inv);
-        close(r[0][0].clone(), 0.0);
-        close(r[0][1].clone(), 0.5);
-        close(r[1][0].clone(), -1.0);
-        close(r[1][1].clone(), 2.0);
-        is_err(ev("MINVERSE", vec![av(arr(vec![vec![nv(1.0), nv(2.0)], vec![nv(2.0), nv(4.0)]]))]), Num);
-        assert_eq!(rows_of(&ev1("MUNIT", 2.0)), vec![vec![nv(1.0), nv(0.0)], vec![nv(0.0), nv(1.0)]]);
-        is_err(ev1("MUNIT", 0.0), CellError::Value);
-        is_err(ev1("MUNIT", 1e6), Num);
-        let coeffs = row(&[1.0, -0.5, 1.0 / 24.0, -1.0 / 720.0]);
-        close_tol(ev("SERIESSUM", vec![n(PI / 4.0), n(0.0), n(2.0), av(coeffs)]), 0.707_103_214_823, 1e-9);
-    }
-
-    #[test]
-    fn random() {
-        let mut ctx = TestCtx::default();
-        let spec = crate::lookup("RAND").unwrap();
-        assert!(spec.volatile);
-        for _ in 0..50 {
-            let v = crate::call(spec, &[], &mut ctx);
-            let x = v.as_f64().unwrap();
-            assert!((0.0..1.0).contains(&x));
-        }
-        let spec = crate::lookup("RANDBETWEEN").unwrap();
-        for _ in 0..50 {
-            let x = crate::call(spec, &[n(1.0), n(6.0)], &mut ctx).as_f64().unwrap();
-            assert!((1.0..=6.0).contains(&x) && x.fract() == 0.0);
-        }
-        is_err(ev2("RANDBETWEEN", 5.0, 1.0), Num);
-    }
-
-    #[test]
-    fn lifting() {
-        assert_eq!(rows_of(&ev("ABS", vec![av(row(&[-1.0, 2.0, -3.0]))])), vec![vec![nv(1.0), nv(2.0), nv(3.0)]]);
-        let v = ev("POWER", vec![av(col(&[1.0, 2.0])), av(row(&[2.0, 3.0]))]);
-        assert_eq!(rows_of(&v), vec![vec![nv(1.0), nv(1.0)], vec![nv(4.0), nv(8.0)]]);
-        close(ev("ROUND", vec![av(arr(vec![vec![nv(1.25)]])), n(1.0)]), 1.3);
-    }
-
-    fn data() -> (Value, Value) {
-        let names = arr(vec![vec![tv("apple")], vec![tv("banana")], vec![tv("Apple")], vec![Value::Empty], vec![tv("cherry")]]);
-        let qty = col(&[10.0, 20.0, 30.0, 40.0, 50.0]);
-        (names, qty)
-    }
-
-    #[test]
-    fn criteria_functions() {
-        let (names, qty) = data();
-        close(ev("COUNTIF", vec![rf(names.clone()), t("apple")]), 2.0);
-        close(ev("COUNTIF", vec![rf(names.clone()), t("a*")]), 2.0);
-        close(ev("COUNTIF", vec![rf(names.clone()), t("<>apple")]), 3.0);
-        close(ev("COUNTIF", vec![rf(names.clone()), t("")]), 1.0);
-        close(ev("COUNTIF", vec![rf(qty.clone()), t(">20")]), 3.0);
-        close(ev("COUNTIF", vec![rf(qty.clone()), n(30.0)]), 1.0);
-        let multi = ev("COUNTIF", vec![rf(names.clone()), av(arr(vec![vec![tv("apple"), tv("cherry")]]))]);
-        assert_eq!(rows_of(&multi), vec![vec![nv(2.0), nv(1.0)]]);
-        close(ev("SUMIF", vec![rf(names.clone()), t("apple"), rf(qty.clone())]), 40.0);
-        close(ev("SUMIF", vec![rf(qty.clone()), t(">=30")]), 120.0);
-        close(ev("SUMIF", vec![rf(names.clone()), t("?????"), rf(col(&[1.0]))]), 1.0);
-        close(ev("AVERAGEIF", vec![rf(qty.clone()), t(">20")]), 40.0);
-        is_err(ev("AVERAGEIF", vec![rf(qty.clone()), t(">100")]), Div0);
-        close(ev("SUMIFS", vec![rf(qty.clone()), rf(names.clone()), t("apple"), rf(qty.clone()), t(">15")]), 30.0);
-        close(ev("COUNTIFS", vec![rf(names.clone()), t("*a*"), rf(qty.clone()), t("<25")]), 2.0);
-        close(ev("AVERAGEIFS", vec![rf(qty.clone()), rf(names.clone()), t("<>banana")]), 32.5);
-        close(ev("MAXIFS", vec![rf(qty.clone()), rf(names.clone()), t("apple")]), 30.0);
-        close(ev("MINIFS", vec![rf(qty.clone()), rf(names.clone()), t("apple")]), 10.0);
-        close(ev("MAXIFS", vec![rf(qty.clone()), rf(names.clone()), t("zzz")]), 0.0);
-        is_err(ev("SUMIFS", vec![rf(qty.clone()), rf(row(&[1.0, 2.0])), t("1")]), CellError::Value);
-        is_err(ev("COUNTIFS", vec![rf(qty.clone()), t(">1"), rf(qty)]), CellError::Value);
-        is_err(ev("SUMIF", vec![rf(col(&[1.0, 2.0])), t(">0"), rf(arr(vec![vec![Value::Error(NA)], vec![nv(1.0)]]))]), NA);
-    }
-
-    #[test]
-    fn criteria_over_255_chars_are_value_errors_with_one_pair_and_truncated_with_more() {
-        let ok = "x".repeat(255);
-        let long = "x".repeat(256);
-        let cells = arr(vec![vec![tv(&ok)], vec![tv(&long)]]);
-        let qty = col(&[1.0, 2.0]);
-        close(ev("COUNTIF", vec![rf(cells.clone()), t(&ok)]), 1.0);
-        is_err(ev("COUNTIF", vec![rf(cells.clone()), t(&long)]), CellError::Value);
-        close(ev("SUMIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&ok)]), 1.0);
-        is_err(ev("SUMIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&long)]), CellError::Value);
-        is_err(ev("COUNTIFS", vec![rf(cells.clone()), t(&long)]), CellError::Value);
-        // With two or more pairs Excel matches the first 255 characters: the 255-character cell
-        // (quantity 1), not the 256-character one (quantity 2). Checked on Excel 2016 and 365.
-        let over = format!("{ok}y");
-        close(ev("COUNTIFS", vec![rf(cells.clone()), t(&long), rf(qty.clone()), t(">0")]), 1.0);
-        close(ev("SUMIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&long), rf(qty.clone()), t(">0")]), 1.0);
-        close(ev("SUMIFS", vec![rf(qty.clone()), rf(qty.clone()), t(">0"), rf(cells.clone()), t(&over)]), 1.0);
-        close(ev("AVERAGEIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&long), rf(qty.clone()), t(">0")]), 1.0);
-        close(ev("MAXIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&"x".repeat(300)), rf(qty), t(">0")]), 1.0);
-    }
-
-    #[test]
-    fn criteria_over_255_utf16_units_follow_excel() {
-        // The tester's sheet, identical on Excel 2016 and Microsoft 365: A1:A6 hold these
-        // strings, B is the row number, and each row uses its own string as the criterion.
-        let e = "😀";
-        let strings =
-            [e.repeat(127), e.repeat(128), format!("{}{e}", "a".repeat(254)), format!("{}{e}", "a".repeat(253)), e.repeat(200), "я".repeat(256)];
-        let cells = arr(strings.iter().map(|s| vec![tv(s)]).collect());
-        let rows = col(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
-        // COUNTIF, SUMIF, COUNTIFS with one pair, SUMIFS with a second pair `B,">0"`.
-        let expected: [Option<[f64; 4]>; 6] = [Some([1.0, 1.0, 1.0, 1.0]), None, None, Some([1.0, 4.0, 1.0, 4.0]), None, None];
-        for (s, want) in strings.iter().zip(expected) {
-            let countif = ev("COUNTIF", vec![rf(cells.clone()), t(s)]);
-            let sumif = ev("SUMIF", vec![rf(cells.clone()), t(s), rf(rows.clone())]);
-            let countifs = ev("COUNTIFS", vec![rf(cells.clone()), t(s)]);
-            let sumifs = ev("SUMIFS", vec![rf(rows.clone()), rf(cells.clone()), t(s), rf(rows.clone()), t(">0")]);
-            match want {
-                Some([a, b, c, d]) => {
-                    close(countif, a);
-                    close(sumif, b);
-                    close(countifs, c);
-                    close(sumifs, d);
-                }
-                // Over 255 units: `#VALUE!` with one pair; cut to 255 units with two, which
-                // matches no cell (for emoji it splits a surrogate pair).
-                None => {
-                    is_err(countif, CellError::Value);
-                    is_err(sumif, CellError::Value);
-                    is_err(countifs, CellError::Value);
-                    close(sumifs, 0.0);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn criteria_cut_inside_a_surrogate_pair() {
-        let e = "😀";
-        let cells = arr(vec![vec![tv(&e.repeat(127))], vec![tv(&e.repeat(128))], vec![tv("zzz")], vec![Value::Empty]]);
-        let rows = col(&[1.0, 2.0, 3.0, 4.0]);
-        let sumifs = |crit: String| ev("SUMIFS", vec![rf(rows.clone()), rf(cells.clone()), t(&crit), rf(rows.clone()), t(">0")]);
-        // "=" + 😀×128 is 257 units: the cut after 255 keeps "=" and 127 whole emoji.
-        close(sumifs(format!("={}", e.repeat(128))), 1.0);
-        // With a two-unit prefix the cut keeps 126 emoji and half of the 127th. Such a criterion
-        // equals no cell text: "=" matches nothing and "<>" everything, blanks included.
-        close(sumifs(format!("=a{}", e.repeat(128))), 0.0);
-        close(sumifs(format!("<>{}", e.repeat(128))), 10.0);
-        // Comparisons treat it as sorting just above the 126 kept emoji.
-        close(sumifs(format!(">={}", e.repeat(128))), 1.0 + 2.0);
-        close(sumifs(format!("<={}", e.repeat(128))), 3.0);
-    }
-}
+mod tests;
diff --git a/crates/functions/src/math/tests.rs b/crates/functions/src/math/tests.rs
new file mode 100644
index 000000000..14f72d1e1
--- /dev/null
+++ b/crates/functions/src/math/tests.rs
@@ -0,0 +1,492 @@
+use super::*;
+use crate::util::testutil::*;
+use CellError::{Div0, NA, Num};
+
+fn ev1(name: &str, x: f64) -> Value {
+    ev(name, vec![n(x)])
+}
+fn ev2(name: &str, x: f64, y: f64) -> Value {
+    ev(name, vec![n(x), n(y)])
+}
+
+#[test]
+fn percentof() {
+    // SUM(subset) / SUM(all): text, booleans and blanks inside ranges are skipped like SUM.
+    let all = arr(vec![vec![nv(10.0)], vec![nv(30.0)], vec![tv("x")], vec![Value::Empty], vec![nv(60.0)]]);
+    let part = arr(vec![vec![nv(10.0)], vec![nv(30.0)]]);
+    close(ev("PERCENTOF", vec![rf(part), rf(all.clone())]), 0.4);
+    close(ev("PERCENTOF", vec![n(25.0), n(200.0)]), 0.125);
+    is_err(ev("PERCENTOF", vec![n(1.0), rf(arr(vec![vec![nv(5.0), nv(-5.0)]]))]), Div0);
+    is_err(ev("PERCENTOF", vec![rf(arr(vec![vec![Value::Error(NA)]])), rf(all)]), NA);
+    is_err(ev("PERCENTOF", vec![t("abc"), n(1.0)]), CellError::Value);
+}
+
+#[test]
+fn sums() {
+    close(ev("SUM", vec![n(1.0), n(2.0), t("3"), b(true)]), 7.0);
+    let r = arr(vec![vec![nv(1.0), tv("x"), Value::Bool(true), Value::Empty, nv(4.0)]]);
+    close(ev("SUM", vec![rf(r.clone())]), 5.0);
+    is_err(ev("SUM", vec![t("abc")]), CellError::Value);
+    is_err(ev("SUM", vec![rf(arr(vec![vec![nv(1.0), Value::Error(Div0)]]))]), Div0);
+    close(ev("SUM", vec![rf(tv("abc"))]), 0.0);
+    close(ev("SUMSQ", vec![n(3.0), n(4.0)]), 25.0);
+    close(ev("PRODUCT", vec![rf(r), n(2.0)]), 8.0);
+    close(ev("PRODUCT", vec![rf(arr(vec![vec![tv("a")]]))]), 0.0);
+    let a1 = arr(vec![vec![nv(3.0), nv(4.0)], vec![nv(8.0), nv(6.0)], vec![nv(1.0), nv(9.0)]]);
+    let a2 = arr(vec![vec![nv(2.0), nv(7.0)], vec![nv(6.0), nv(7.0)], vec![nv(5.0), nv(3.0)]]);
+    close(ev("SUMPRODUCT", vec![rf(a1.clone()), rf(a2)]), 156.0);
+    close(ev("SUMPRODUCT", vec![rf(a1.clone())]), 31.0);
+    is_err(ev("SUMPRODUCT", vec![rf(a1), rf(row(&[1.0, 2.0]))]), CellError::Value);
+    close(ev("SUMPRODUCT", vec![av(row(&[1.0, 2.0])), av(arr(vec![vec![tv("x"), nv(3.0)]]))]), 6.0);
+    let x = row(&[2.0, 3.0, 9.0, 1.0, 8.0, 7.0, 5.0]);
+    let y = row(&[6.0, 5.0, 11.0, 7.0, 5.0, 4.0, 4.0]);
+    close(ev("SUMX2MY2", vec![av(x.clone()), av(y.clone())]), -55.0);
+    close(ev("SUMX2PY2", vec![av(x.clone()), av(y.clone())]), 521.0);
+    close(ev("SUMXMY2", vec![av(x.clone()), av(y)]), 79.0);
+    is_err(ev("SUMXMY2", vec![av(x), av(row(&[1.0]))]), NA);
+}
+
+/// SUMPRODUCT cases observed in Excel (FormulaEvalTestData, row "Sumproduct"): scalars and
+/// single-cell references multiply in, text in a scalar argument is `#VALUE!`, sizes must match.
+#[test]
+fn sumproduct_scalar_arguments() {
+    let cases: Vec<(Vec<crate::Arg>, Result<f64, CellError>)> = vec![
+        (vec![n(3.0), rf(nv(534.0)), rf(nv(1.1))], Ok(1762.2)),
+        (vec![rf(nv(1.1)), n(3.0), rf(nv(534.0)), rf(nv(1.1))], Ok(1938.42)),
+        (vec![n(2.0), rf(col(&[1.00001, 2.99999]))], Err(CellError::Value)),
+        (vec![rf(tv("4")), rf(nv(2.0))], Err(CellError::Value)),
+        (vec![t("4"), n(2.0)], Err(CellError::Value)),
+        (vec![rf(nv(3.0)), rf(Value::Error(CellError::Ref))], Err(CellError::Ref)),
+        (vec![av(arr(vec![vec![tv("4")]])), n(2.0)], Ok(0.0)),
+    ];
+    for (args, want) in cases {
+        match want {
+            Ok(x) => close(ev("SUMPRODUCT", args), x),
+            Err(err) => is_err(ev("SUMPRODUCT", args), err),
+        }
+    }
+}
+
+#[test]
+fn rounding() {
+    close(ev2("ROUND", 2.675, 2.0), 2.68);
+    close(ev2("ROUND", -1.5, 0.0), -2.0);
+    close(ev2("ROUND", 1234.567, -2.0), 1200.0);
+    close(ev2("ROUND", 2.15, 1.0), 2.2);
+    close(ev2("ROUNDUP", 3.2, 0.0), 4.0);
+    close(ev2("ROUNDUP", -3.14259, 1.0), -3.2);
+    close(ev2("ROUNDUP", 31415.92654, -2.0), 31500.0);
+    close(ev2("ROUNDDOWN", -3.9, 0.0), -3.0);
+    close(ev2("ROUNDDOWN", 2.71989, 3.0), 2.719);
+    close(ev2("ROUNDDOWN", 31415.92654, -2.0), 31400.0);
+    for digits in [-308.0, -309.0, -400.0] {
+        for x in [1234.0, -1234.0, 0.5] {
+            close(ev2("ROUNDDOWN", x, digits), 0.0);
+            close(ev2("TRUNC", x, digits), 0.0);
+        }
+    }
+    assert!(matches!(ev2("ROUNDUP", 1234.0, -309.0), Value::Error(CellError::Num)));
+    close(ev2("ROUNDUP", 0.1 + 0.2, 1.0), 0.3);
+    close(ev2("TRUNC", 8.987, 2.0), 8.98);
+    close(ev1("TRUNC", -8.9), -8.0);
+    close(ev1("INT", -8.9), -9.0);
+    close(ev1("INT", 8.9), 8.0);
+    close(ev2("MROUND", 10.0, 3.0), 9.0);
+    close(ev2("MROUND", -10.0, -3.0), -9.0);
+    close(ev2("MROUND", 1.3, 0.2), 1.4);
+    is_err(ev2("MROUND", 5.0, -2.0), Num);
+    close(ev2("CEILING", 2.5, 1.0), 3.0);
+    close(ev2("CEILING", -2.5, -2.0), -4.0);
+    close(ev2("CEILING", -2.5, 2.0), -2.0);
+    close(ev2("CEILING", 1.5, 0.1), 1.5);
+    close(ev2("CEILING", 0.234, 0.01), 0.24);
+    is_err(ev2("CEILING", 2.5, -1.0), Num);
+    close(ev2("FLOOR", 3.7, 2.0), 2.0);
+    close(ev2("FLOOR", -2.5, -2.0), -2.0);
+    close(ev2("FLOOR", -2.5, 2.0), -4.0);
+    is_err(ev2("FLOOR", 2.5, -2.0), Num);
+    is_err(ev2("FLOOR", 2.5, 0.0), Div0);
+    close(ev2("FLOOR", 1.58, 0.1), 1.5);
+    close(ev2("FLOOR", 0.234, 0.01), 0.23);
+    close(ev2("CEILING.MATH", 24.3, 5.0), 25.0);
+    close(ev1("CEILING.MATH", 6.7), 7.0);
+    close(ev2("CEILING.MATH", -8.1, 2.0), -8.0);
+    close(ev("CEILING.MATH", vec![n(-5.5), n(2.0), n(-1.0)]), -6.0);
+    close(ev2("FLOOR.MATH", 24.3, 5.0), 20.0);
+    close(ev1("FLOOR.MATH", 6.7), 6.0);
+    close(ev2("FLOOR.MATH", -8.1, 2.0), -10.0);
+    close(ev("FLOOR.MATH", vec![n(-5.5), n(2.0), n(-1.0)]), -4.0);
+    close(ev2("CEILING.PRECISE", -4.6, 2.0), -4.0);
+    close(ev2("CEILING.PRECISE", 4.3, -2.0), 6.0);
+    close(ev2("ISO.CEILING", 4.3, 0.0), 0.0);
+    close(ev2("FLOOR.PRECISE", -3.2, -1.0), -4.0);
+    close(ev1("FLOOR.PRECISE", 3.2), 3.0);
+    close(ev1("EVEN", 1.5), 2.0);
+    close(ev1("EVEN", 3.0), 4.0);
+    close(ev1("EVEN", 2.0), 2.0);
+    close(ev1("EVEN", -1.0), -2.0);
+    close(ev1("EVEN", 0.0), 0.0);
+    close(ev1("ODD", 1.5), 3.0);
+    close(ev1("ODD", 3.0), 3.0);
+    close(ev1("ODD", 2.0), 3.0);
+    close(ev1("ODD", -1.0), -1.0);
+    close(ev1("ODD", -2.0), -3.0);
+    close(ev1("ODD", 0.0), 1.0);
+}
+
+#[test]
+fn mod_tiny_divisor_stays_in_range() {
+    for (x, d) in [(3.0, 1e-300), (-1.0, 1e-300), (3.0, -1e-300), (-1.0, -1e-300)] {
+        match ev2("MOD", x, d) {
+            Value::Number(r) => {
+                assert!(r == 0.0 || (r < 0.0) == (d < 0.0), "MOD({x}, {d}) = {r}");
+                assert!(r.abs() < d.abs(), "MOD({x}, {d}) = {r}");
+            }
+            other => panic!("MOD({x}, {d}) = {other:?}"),
+        }
+    }
+}
+
+#[test]
+fn arithmetic() {
+    close(ev2("MOD", 3.0, 2.0), 1.0);
+    close(ev2("MOD", -3.0, 2.0), 1.0);
+    close(ev2("MOD", 3.0, -2.0), -1.0);
+    close(ev2("MOD", -3.0, -2.0), -1.0);
+    close(ev2("MOD", 5.5, 1.0), 0.5);
+    is_err(ev2("MOD", 1.0, 0.0), Div0);
+    close(ev2("QUOTIENT", 5.0, 2.0), 2.0);
+    close(ev2("QUOTIENT", -10.0, 3.0), -3.0);
+    is_err(ev2("QUOTIENT", 1.0, 0.0), Div0);
+    close(ev1("ABS", -4.0), 4.0);
+    close(ev1("SIGN", -0.0001), -1.0);
+    close(ev1("SIGN", 0.0), 0.0);
+    close(ev1("SQRT", 16.0), 4.0);
+    is_err(ev1("SQRT", -16.0), Num);
+    close(ev1("SQRTPI", 1.0), 1.772_453_850_905_516);
+    close(ev2("POWER", 5.0, 2.0), 25.0);
+    close(ev2("POWER", 4.0, 1.25), 5.656_854_249_492_381);
+    close(ev2("POWER", -2.0, 3.0), -8.0);
+    is_err(ev2("POWER", 0.0, 0.0), Num);
+    is_err(ev2("POWER", 0.0, -1.0), Div0);
+    is_err(ev2("POWER", -8.0, 1.0 / 3.0), Num);
+    is_err(ev2("POWER", 10.0, 400.0), Num);
+    close(ev1("EXP", 1.0), std::f64::consts::E);
+    close(ev2("LOG", 8.0, 2.0), 3.0);
+    close(ev1("LOG", 10.0), 1.0);
+    close(ev2("LOG", 81.0, 3.0), 4.0);
+    is_err(ev1("LN", 0.0), Num);
+    is_err(ev2("LOG", 10.0, 1.0), Div0);
+    is_err(ev1("LOG10", -1.0), Num);
+    close(ev1("LN", std::f64::consts::E), 1.0);
+    close(ev1("LOG10", 1e5), 5.0);
+    close(ev("PI", vec![]), PI);
+    close(ev("SQRT", vec![t("16")]), 4.0);
+    is_err(ev("SQRT", vec![t("x")]), CellError::Value);
+}
+
+#[test]
+fn combinatorics() {
+    close(ev1("FACT", 5.0), 120.0);
+    close(ev1("FACT", 1.9), 1.0);
+    close(ev1("FACT", 0.0), 1.0);
+    is_err(ev1("FACT", -1.0), Num);
+    is_err(ev1("FACT", 171.0), Num);
+    close(ev1("FACTDOUBLE", 6.0), 48.0);
+    close(ev1("FACTDOUBLE", 7.0), 105.0);
+    close(ev1("FACTDOUBLE", -1.0), 1.0);
+    is_err(ev1("FACTDOUBLE", -2.0), Num);
+    close(ev2("COMBIN", 8.0, 2.0), 28.0);
+    close(ev2("COMBIN", 8.9, 2.9), 28.0);
+    is_err(ev2("COMBIN", 2.0, 3.0), Num);
+    close(ev2("COMBIN", 60.0, 30.0), 118_264_581_564_861_424.0);
+    close(ev2("COMBINA", 4.0, 3.0), 20.0);
+    close(ev2("COMBINA", 10.0, 3.0), 220.0);
+    close(ev2("PERMUT", 100.0, 3.0), 970_200.0);
+    close(ev2("PERMUT", 3.0, 2.0), 6.0);
+    is_err(ev2("PERMUT", 2.0, 3.0), Num);
+    close(ev2("PERMUTATIONA", 3.0, 2.0), 9.0);
+    close(ev2("GCD", 24.0, 36.0), 12.0);
+    close(ev2("GCD", 5.0, 0.0), 5.0);
+    close(ev2("GCD", 7.0, 1.0), 1.0);
+    is_err(ev2("GCD", -1.0, 5.0), Num);
+    close(ev("GCD", vec![av(row(&[12.0, 18.0, 30.0]))]), 6.0);
+    close(ev2("LCM", 24.0, 36.0), 72.0);
+    close(ev2("LCM", 5.0, 2.0), 10.0);
+    close(ev2("LCM", 5.0, 0.0), 0.0);
+    close(ev("MULTINOMIAL", vec![n(2.0), n(3.0), n(4.0)]), 1260.0);
+    is_err(ev("MULTINOMIAL", vec![n(-1.0), n(2.0)]), Num);
+}
+
+#[test]
+fn trig() {
+    close(ev1("SIN", PI / 2.0), 1.0);
+    close(ev1("COS", 0.0), 1.0);
+    close(ev1("TAN", PI / 4.0), 1.0);
+    is_err(ev1("SIN", 1e10), Num);
+    close(ev1("ASIN", 1.0), PI / 2.0);
+    is_err(ev1("ACOS", 1.5), Num);
+    close(ev1("ACOT", 2.0), 0.463_647_609_000_806);
+    close(ev1("ACOTH", 6.0), 0.168_236_118_310_606);
+    is_err(ev1("ACOTH", 0.5), Num);
+    close(ev1("COT", 30.0), -0.156_119_952_161_659);
+    is_err(ev1("COT", 0.0), Div0);
+    close(ev1("COTH", 2.0), 1.037_314_720_727_548);
+    close(ev1("CSC", 15.0), 1.537_780_562_208_209);
+    close(ev1("CSCH", 1.5), 0.469_642_440_595_653);
+    close(ev1("SEC", 45.0), 1.903_594_407_014_6);
+    close_tol(ev1("SECH", 45.0), 5.725_037_161_098_787e-20, 1e-9);
+    close(ev2("ATAN2", 1.0, 1.0), PI / 4.0);
+    close(ev2("ATAN2", -1.0, -1.0), -3.0 * PI / 4.0);
+    is_err(ev2("ATAN2", 0.0, 0.0), Div0);
+    close(ev1("ASINH", -2.5), -1.647_231_146_371_096);
+    close(ev1("ACOSH", 10.0), 2.993_222_846_126_381);
+    is_err(ev1("ACOSH", 0.5), Num);
+    close(ev1("ATANH", 0.5), 0.549_306_144_334_055);
+    is_err(ev1("ATANH", 1.0), Num);
+    close(ev1("SINH", 1.0), 1.175_201_193_643_801);
+    close(ev1("DEGREES", PI), 180.0);
+    close(ev1("RADIANS", 270.0), 4.712_388_980_384_69);
+}
+
+#[test]
+fn number_systems() {
+    is_text(ev1("ROMAN", 499.0), "CDXCIX");
+    is_text(ev2("ROMAN", 499.0, 1.0), "LDVLIV");
+    is_text(ev2("ROMAN", 499.0, 2.0), "XDIX");
+    is_text(ev2("ROMAN", 499.0, 3.0), "VDIV");
+    is_text(ev2("ROMAN", 499.0, 4.0), "ID");
+    is_text(ev("ROMAN", vec![n(499.0), b(false)]), "ID");
+    is_text(ev1("ROMAN", 1999.0), "MCMXCIX");
+    is_text(ev1("ROMAN", 3999.0), "MMMCMXCIX");
+    is_text(ev1("ROMAN", 0.0), "");
+    is_err(ev1("ROMAN", 4000.0), CellError::Value);
+    is_err(ev1("ROMAN", -1.0), CellError::Value);
+    close(ev("ARABIC", vec![t("LVII")]), 57.0);
+    close(ev("ARABIC", vec![t("mcmxii")]), 1912.0);
+    close(ev("ARABIC", vec![t("")]), 0.0);
+    close(ev("ARABIC", vec![t("-XIV")]), -14.0);
+    is_err(ev("ARABIC", vec![t("ABC")]), CellError::Value);
+    is_text(ev2("BASE", 7.0, 2.0), "111");
+    is_text(ev2("BASE", 100.0, 16.0), "64");
+    is_text(ev("BASE", vec![n(15.0), n(2.0), n(10.0)]), "0000001111");
+    is_text(ev2("BASE", 0.0, 36.0), "0");
+    is_err(ev2("BASE", 7.0, 1.0), Num);
+    is_err(ev2("BASE", -7.0, 2.0), Num);
+    close(ev("DECIMAL", vec![t("FF"), n(16.0)]), 255.0);
+    close(ev("DECIMAL", vec![t("111"), n(2.0)]), 7.0);
+    close(ev("DECIMAL", vec![t("zap"), n(36.0)]), 45745.0);
+    is_err(ev("DECIMAL", vec![t("12"), n(2.0)]), Num);
+}
+
+/// Every number where Excel's forms 2 and 3 differ from a plain ratio limit (issue #733):
+/// form 2 subtracts I from C and X from M, form 3 also V from M.
+#[test]
+fn roman_forms_two_and_three_match_excel() {
+    const HUNDREDS: [&str; 10] = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"];
+    const ONES: [&str; 10] = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
+    let mut cases = Vec::new();
+    for thousands in 0..4usize {
+        let m = "M".repeat(thousands);
+        for (h, hundreds) in HUNDREDS.iter().enumerate() {
+            if h != 4 && h != 9 {
+                cases.push((thousands * 1000 + h * 100 + 99, 2.0, format!("{m}{hundreds}IC")));
+            }
+        }
+        for (o, ones) in ONES.iter().enumerate() {
+            cases.push((thousands * 1000 + 990 + o, 2.0, format!("{m}XM{ones}")));
+        }
+        for (o, ones) in ONES.iter().enumerate().take(5) {
+            cases.push((thousands * 1000 + 995 + o, 3.0, format!("{m}VM{ones}")));
+        }
+    }
+    assert_eq!(cases.len(), 92);
+    for (number, form, want) in &cases {
+        is_text(ev2("ROMAN", *number as f64, *form), want);
+    }
+    // Neighbours that already matched: form 2 still has no VD or ID, form 3 no ID.
+    is_text(ev2("ROMAN", 495.0, 2.0), "XDV");
+    is_text(ev2("ROMAN", 495.0, 3.0), "VD");
+    is_text(ev2("ROMAN", 1499.0, 2.0), "MXDIX");
+    is_text(ev2("ROMAN", 999.0, 0.0), "CMXCIX");
+    is_text(ev2("ROMAN", 999.0, 1.0), "LMVLIV");
+    is_text(ev2("ROMAN", 999.0, 4.0), "IM");
+    is_text(ev2("ROMAN", 995.0, 4.0), "VM");
+    is_text(ev2("ROMAN", 99.0, 1.0), "VCIV");
+    is_text(ev2("ROMAN", 99.0, 4.0), "IC");
+}
+
+#[test]
+fn minverse_scale_relative() {
+    let big = ev("MINVERSE", vec![av(arr(vec![vec![nv(1e20), nv(0.0)], vec![nv(0.0), nv(1e20)]]))]);
+    let r = rows_of(&big);
+    close_tol(r[0][0].clone(), 1e-20, 1e-25);
+    close_tol(r[1][1].clone(), 1e-20, 1e-25);
+    let small = ev("MINVERSE", vec![av(arr(vec![vec![nv(1e-20), nv(0.0)], vec![nv(0.0), nv(1e-20)]]))]);
+    let r = rows_of(&small);
+    close_tol(r[0][0].clone(), 1e20, 1e10);
+}
+
+#[test]
+fn matrices() {
+    let a = arr(vec![vec![nv(1.0), nv(2.0)], vec![nv(3.0), nv(4.0)]]);
+    let b2 = arr(vec![vec![nv(5.0), nv(6.0)], vec![nv(7.0), nv(8.0)]]);
+    assert_eq!(rows_of(&ev("MMULT", vec![av(a.clone()), av(b2)])), vec![vec![nv(19.0), nv(22.0)], vec![nv(43.0), nv(50.0)]]);
+    is_err(ev("MMULT", vec![av(a.clone()), av(row(&[1.0, 2.0]))]), CellError::Value);
+    is_err(ev("MMULT", vec![av(arr(vec![vec![tv("x")]])), av(row(&[1.0]))]), CellError::Value);
+    close(ev("MDETERM", vec![av(a.clone())]), -2.0);
+    let m3 = arr(vec![vec![nv(3.0), nv(6.0), nv(1.0)], vec![nv(1.0), nv(1.0), nv(0.0)], vec![nv(3.0), nv(10.0), nv(2.0)]]);
+    close(ev("MDETERM", vec![av(m3)]), 1.0);
+    let m4 = arr(vec![
+        vec![nv(1.0), nv(3.0), nv(8.0), nv(5.0)],
+        vec![nv(1.0), nv(3.0), nv(6.0), nv(1.0)],
+        vec![nv(1.0), nv(1.0), nv(1.0), nv(0.0)],
+        vec![nv(7.0), nv(3.0), nv(10.0), nv(2.0)],
+    ]);
+    close(ev("MDETERM", vec![av(m4)]), 88.0);
+    is_err(ev("MDETERM", vec![av(row(&[1.0, 2.0]))]), CellError::Value);
+    let inv = ev("MINVERSE", vec![av(arr(vec![vec![nv(4.0), nv(-1.0)], vec![nv(2.0), nv(0.0)]]))]);
+    let r = rows_of(&inv);
+    close(r[0][0].clone(), 0.0);
+    close(r[0][1].clone(), 0.5);
+    close(r[1][0].clone(), -1.0);
+    close(r[1][1].clone(), 2.0);
+    is_err(ev("MINVERSE", vec![av(arr(vec![vec![nv(1.0), nv(2.0)], vec![nv(2.0), nv(4.0)]]))]), Num);
+    assert_eq!(rows_of(&ev1("MUNIT", 2.0)), vec![vec![nv(1.0), nv(0.0)], vec![nv(0.0), nv(1.0)]]);
+    is_err(ev1("MUNIT", 0.0), CellError::Value);
+    is_err(ev1("MUNIT", 1e6), Num);
+    let coeffs = row(&[1.0, -0.5, 1.0 / 24.0, -1.0 / 720.0]);
+    close_tol(ev("SERIESSUM", vec![n(PI / 4.0), n(0.0), n(2.0), av(coeffs)]), 0.707_103_214_823, 1e-9);
+}
+
+#[test]
+fn random() {
+    let mut ctx = TestCtx::default();
+    let spec = crate::lookup("RAND").unwrap();
+    assert!(spec.volatile);
+    for _ in 0..50 {
+        let v = crate::call(spec, &[], &mut ctx);
+        let x = v.as_f64().unwrap();
+        assert!((0.0..1.0).contains(&x));
+    }
+    let spec = crate::lookup("RANDBETWEEN").unwrap();
+    for _ in 0..50 {
+        let x = crate::call(spec, &[n(1.0), n(6.0)], &mut ctx).as_f64().unwrap();
+        assert!((1.0..=6.0).contains(&x) && x.fract() == 0.0);
+    }
+    is_err(ev2("RANDBETWEEN", 5.0, 1.0), Num);
+}
+
+#[test]
+fn lifting() {
+    assert_eq!(rows_of(&ev("ABS", vec![av(row(&[-1.0, 2.0, -3.0]))])), vec![vec![nv(1.0), nv(2.0), nv(3.0)]]);
+    let v = ev("POWER", vec![av(col(&[1.0, 2.0])), av(row(&[2.0, 3.0]))]);
+    assert_eq!(rows_of(&v), vec![vec![nv(1.0), nv(1.0)], vec![nv(4.0), nv(8.0)]]);
+    close(ev("ROUND", vec![av(arr(vec![vec![nv(1.25)]])), n(1.0)]), 1.3);
+}
+
+fn data() -> (Value, Value) {
+    let names = arr(vec![vec![tv("apple")], vec![tv("banana")], vec![tv("Apple")], vec![Value::Empty], vec![tv("cherry")]]);
+    let qty = col(&[10.0, 20.0, 30.0, 40.0, 50.0]);
+    (names, qty)
+}
+
+#[test]
+fn criteria_functions() {
+    let (names, qty) = data();
+    close(ev("COUNTIF", vec![rf(names.clone()), t("apple")]), 2.0);
+    close(ev("COUNTIF", vec![rf(names.clone()), t("a*")]), 2.0);
+    close(ev("COUNTIF", vec![rf(names.clone()), t("<>apple")]), 3.0);
+    close(ev("COUNTIF", vec![rf(names.clone()), t("")]), 1.0);
+    close(ev("COUNTIF", vec![rf(qty.clone()), t(">20")]), 3.0);
+    close(ev("COUNTIF", vec![rf(qty.clone()), n(30.0)]), 1.0);
+    let multi = ev("COUNTIF", vec![rf(names.clone()), av(arr(vec![vec![tv("apple"), tv("cherry")]]))]);
+    assert_eq!(rows_of(&multi), vec![vec![nv(2.0), nv(1.0)]]);
+    close(ev("SUMIF", vec![rf(names.clone()), t("apple"), rf(qty.clone())]), 40.0);
+    close(ev("SUMIF", vec![rf(qty.clone()), t(">=30")]), 120.0);
+    close(ev("SUMIF", vec![rf(names.clone()), t("?????"), rf(col(&[1.0]))]), 1.0);
+    close(ev("AVERAGEIF", vec![rf(qty.clone()), t(">20")]), 40.0);
+    is_err(ev("AVERAGEIF", vec![rf(qty.clone()), t(">100")]), Div0);
+    close(ev("SUMIFS", vec![rf(qty.clone()), rf(names.clone()), t("apple"), rf(qty.clone()), t(">15")]), 30.0);
+    close(ev("COUNTIFS", vec![rf(names.clone()), t("*a*"), rf(qty.clone()), t("<25")]), 2.0);
+    close(ev("AVERAGEIFS", vec![rf(qty.clone()), rf(names.clone()), t("<>banana")]), 32.5);
+    close(ev("MAXIFS", vec![rf(qty.clone()), rf(names.clone()), t("apple")]), 30.0);
+    close(ev("MINIFS", vec![rf(qty.clone()), rf(names.clone()), t("apple")]), 10.0);
+    close(ev("MAXIFS", vec![rf(qty.clone()), rf(names.clone()), t("zzz")]), 0.0);
+    is_err(ev("SUMIFS", vec![rf(qty.clone()), rf(row(&[1.0, 2.0])), t("1")]), CellError::Value);
+    is_err(ev("COUNTIFS", vec![rf(qty.clone()), t(">1"), rf(qty)]), CellError::Value);
+    is_err(ev("SUMIF", vec![rf(col(&[1.0, 2.0])), t(">0"), rf(arr(vec![vec![Value::Error(NA)], vec![nv(1.0)]]))]), NA);
+}
+
+#[test]
+fn criteria_over_255_chars_are_value_errors_with_one_pair_and_truncated_with_more() {
+    let ok = "x".repeat(255);
+    let long = "x".repeat(256);
+    let cells = arr(vec![vec![tv(&ok)], vec![tv(&long)]]);
+    let qty = col(&[1.0, 2.0]);
+    close(ev("COUNTIF", vec![rf(cells.clone()), t(&ok)]), 1.0);
+    is_err(ev("COUNTIF", vec![rf(cells.clone()), t(&long)]), CellError::Value);
+    close(ev("SUMIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&ok)]), 1.0);
+    is_err(ev("SUMIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&long)]), CellError::Value);
+    is_err(ev("COUNTIFS", vec![rf(cells.clone()), t(&long)]), CellError::Value);
+    // With two or more pairs Excel matches the first 255 characters: the 255-character cell
+    // (quantity 1), not the 256-character one (quantity 2). Checked on Excel 2016 and 365.
+    let over = format!("{ok}y");
+    close(ev("COUNTIFS", vec![rf(cells.clone()), t(&long), rf(qty.clone()), t(">0")]), 1.0);
+    close(ev("SUMIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&long), rf(qty.clone()), t(">0")]), 1.0);
+    close(ev("SUMIFS", vec![rf(qty.clone()), rf(qty.clone()), t(">0"), rf(cells.clone()), t(&over)]), 1.0);
+    close(ev("AVERAGEIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&long), rf(qty.clone()), t(">0")]), 1.0);
+    close(ev("MAXIFS", vec![rf(qty.clone()), rf(cells.clone()), t(&"x".repeat(300)), rf(qty), t(">0")]), 1.0);
+}
+
+#[test]
+fn criteria_over_255_utf16_units_follow_excel() {
+    // The tester's sheet, identical on Excel 2016 and Microsoft 365: A1:A6 hold these
+    // strings, B is the row number, and each row uses its own string as the criterion.
+    let e = "😀";
+    let strings =
+        [e.repeat(127), e.repeat(128), format!("{}{e}", "a".repeat(254)), format!("{}{e}", "a".repeat(253)), e.repeat(200), "я".repeat(256)];
+    let cells = arr(strings.iter().map(|s| vec![tv(s)]).collect());
+    let rows = col(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
+    // COUNTIF, SUMIF, COUNTIFS with one pair, SUMIFS with a second pair `B,">0"`.
+    let expected: [Option<[f64; 4]>; 6] = [Some([1.0, 1.0, 1.0, 1.0]), None, None, Some([1.0, 4.0, 1.0, 4.0]), None, None];
+    for (s, want) in strings.iter().zip(expected) {
+        let countif = ev("COUNTIF", vec![rf(cells.clone()), t(s)]);
+        let sumif = ev("SUMIF", vec![rf(cells.clone()), t(s), rf(rows.clone())]);
+        let countifs = ev("COUNTIFS", vec![rf(cells.clone()), t(s)]);
+        let sumifs = ev("SUMIFS", vec![rf(rows.clone()), rf(cells.clone()), t(s), rf(rows.clone()), t(">0")]);
+        match want {
+            Some([a, b, c, d]) => {
+                close(countif, a);
+                close(sumif, b);
+                close(countifs, c);
+                close(sumifs, d);
+            }
+            // Over 255 units: `#VALUE!` with one pair; cut to 255 units with two, which
+            // matches no cell (for emoji it splits a surrogate pair).
+            None => {
+                is_err(countif, CellError::Value);
+                is_err(sumif, CellError::Value);
+                is_err(countifs, CellError::Value);
+                close(sumifs, 0.0);
+            }
+        }
+    }
+}
+
+#[test]
+fn criteria_cut_inside_a_surrogate_pair() {
+    let e = "😀";
+    let cells = arr(vec![vec![tv(&e.repeat(127))], vec![tv(&e.repeat(128))], vec![tv("zzz")], vec![Value::Empty]]);
+    let rows = col(&[1.0, 2.0, 3.0, 4.0]);
+    let sumifs = |crit: String| ev("SUMIFS", vec![rf(rows.clone()), rf(cells.clone()), t(&crit), rf(rows.clone()), t(">0")]);
+    // "=" + 😀×128 is 257 units: the cut after 255 keeps "=" and 127 whole emoji.
+    close(sumifs(format!("={}", e.repeat(128))), 1.0);
+    // With a two-unit prefix the cut keeps 126 emoji and half of the 127th. Such a criterion
+    // equals no cell text: "=" matches nothing and "<>" everything, blanks included.
+    close(sumifs(format!("=a{}", e.repeat(128))), 0.0);
+    close(sumifs(format!("<>{}", e.repeat(128))), 10.0);
+    // Comparisons treat it as sorting just above the 126 kept emoji.
+    close(sumifs(format!(">={}", e.repeat(128))), 1.0 + 2.0);
+    close(sumifs(format!("<={}", e.repeat(128))), 3.0);
+}

From acade653ba1eb290a5b05997ba5a9fc908e36360 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:44 +0000
Subject: [PATCH 35/76] refactor(functions): move stat tests to
 src/stat/tests.rs

---
 crates/functions/src/stat.rs       | 511 +----------------------------
 crates/functions/src/stat/tests.rs | 508 ++++++++++++++++++++++++++++
 2 files changed, 509 insertions(+), 510 deletions(-)
 create mode 100644 crates/functions/src/stat/tests.rs

diff --git a/crates/functions/src/stat.rs b/crates/functions/src/stat.rs
index 344ba9ff8..554b75271 100644
--- a/crates/functions/src/stat.rs
+++ b/crates/functions/src/stat.rs
@@ -2273,513 +2273,4 @@ pub(crate) fn specs() -> Vec<FnSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::{MAX_REGRESSORS, aggregate_values, aggregate_values_k, check_regression_size};
-    use crate::util::testutil::*;
-    use gridcraft_core::{CellError, Value};
-
-    const D7: f64 = 1e-6;
-
-    fn c(xs: &[f64]) -> crate::Arg {
-        av(col(xs))
-    }
-
-    // The two middle values are finite and their midpoint is representable even when
-    // adding them first would overflow. Exercise both callers of the shared helper.
-    #[test]
-    fn median_finite_midpoint_does_not_overflow() {
-        for (values, expected) in [
-            (vec![1e308, 1e308], 1e308),
-            (vec![-1e308, -1e308], -1e308),
-            (vec![1.6e308, 1e308], 1.3e308),
-            (vec![-1e308, -1.6e308], -1.3e308),
-            (vec![f64::MAX, f64::MAX], f64::MAX),
-            (vec![-f64::MAX, -f64::MAX], -f64::MAX),
-            (vec![-f64::MAX, f64::MAX], 0.0),
-            (vec![1.7e308, -1.7e308, 1e308, 1.6e308], 1.3e308),
-        ] {
-            close(ev("MEDIAN", values.iter().copied().map(n).collect()), expected);
-            close(ev("MEDIAN", vec![rf(col(&values))]), expected);
-            close(aggregate_values(12, &values.iter().copied().map(nv).collect::<Vec<_>>()), expected);
-        }
-    }
-
-    #[test]
-    fn median_midpoint_keeps_small_values_and_argument_semantics() {
-        // Halving each operand unconditionally can lose the smallest numbers. Use exact
-        // equality here: the usual aggregate-test tolerance would accept zero.
-        for value in [f64::MIN_POSITIVE, -f64::MIN_POSITIVE, f64::from_bits(1), -f64::from_bits(1)] {
-            assert_eq!(ev("MEDIAN", vec![n(value), n(value)]), nv(value));
-            assert_eq!(aggregate_values(12, &[nv(value), nv(value)]), nv(value));
-        }
-        close(ev("MEDIAN", vec![c(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0])]), 3.5);
-        close(ev("MEDIAN", vec![c(&[1e308, -1e308, 3.0])]), 3.0);
-        close(ev("MEDIAN", vec![n(1e308)]), 1e308);
-        close(ev("MEDIAN", vec![t("4"), b(true)]), 2.5);
-        close(ev("MEDIAN", vec![rf(arr(vec![vec![nv(1.0), tv("ignored"), Value::Empty, Value::Bool(true), nv(6.0)]]))]), 3.5);
-        is_err(ev("MEDIAN", vec![t("invalid")]), CellError::Value);
-        is_err(ev("MEDIAN", vec![e(CellError::NA), n(1e308)]), CellError::NA);
-        is_err(ev("MEDIAN", vec![rf(arr(vec![vec![tv("ignored"), Value::Empty]]))]), CellError::Num);
-        is_err(aggregate_values(12, &[]), CellError::Num);
-        is_err(aggregate_values(12, &[nv(1e308), Value::Error(CellError::Div0)]), CellError::Div0);
-    }
-
-    #[test]
-    fn averages_and_counts() {
-        close(ev("AVERAGE", vec![n(1.0), n(2.0), n(6.0)]), 3.0);
-        is_err(ev("AVERAGE", vec![rf(arr(vec![vec![tv("a")]]))]), CellError::Div0);
-        let mixed = arr(vec![vec![nv(1.0), tv("x"), Value::Bool(true), Value::Empty, nv(3.0)]]);
-        close(ev("AVERAGE", vec![rf(mixed.clone())]), 2.0);
-        close(ev("AVERAGEA", vec![rf(mixed.clone())]), 1.25);
-        close(ev("AVERAGE", vec![t("4"), b(true)]), 2.5);
-        is_err(ev("AVERAGE", vec![t("abc")]), CellError::Value);
-        is_err(ev("AVERAGE", vec![rf(arr(vec![vec![nv(1.0), Value::Error(CellError::NA)]]))]), CellError::NA);
-        close(ev("COUNT", vec![rf(mixed.clone()), n(4.0), t("5"), t("x")]), 4.0);
-        close(ev("COUNT", vec![e(CellError::Div0)]), 0.0);
-        close(ev("COUNTA", vec![rf(mixed.clone())]), 4.0);
-        close(ev("COUNTA", vec![n(1.0), t("")]), 2.0);
-        let blanks = arr(vec![vec![Value::Empty, tv(""), nv(0.0), tv(" ")]]);
-        close(ev("COUNTBLANK", vec![rf(blanks)]), 2.0);
-        close(ev("MEDIAN", vec![c(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0])]), 3.5);
-        close(ev("MEDIAN", vec![c(&[3.0, 1.0, 2.0])]), 2.0);
-        is_err(ev("MEDIAN", vec![rf(arr(vec![vec![tv("a")]]))]), CellError::Num);
-        close(ev("MODE.SNGL", vec![c(&[5.6, 4.0, 4.0, 3.0, 2.0, 4.0])]), 4.0);
-        close(ev("MODE", vec![c(&[1.0, 2.0, 2.0, 1.0])]), 1.0);
-        is_err(ev("MODE", vec![c(&[1.0, 2.0, 3.0])]), CellError::NA);
-        assert_eq!(rows_of(&ev("MODE.MULT", vec![c(&[1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 2.0, 3.0])])), vec![vec![nv(2.0)], vec![nv(3.0)]]);
-    }
-
-    /// MODE argument semantics in Excel 365, on the inputs of FormulaEvalTestData (row "Mode"):
-    /// text is skipped, typed or referenced, but a single-cell reference to a blank cell is
-    /// `#VALUE!`; the first error from the left wins. The values cached in POI's file come from an
-    /// older Excel and say `#VALUE!` for `MODE(C9,E16,"1",B8)`, `MODE(B8,"1",2,3)` and
-    /// `MODE("1",1,#DIV/0!,2,3)`; Excel 365 gives `#N/A`, `#N/A` and `#DIV/0!`.
-    #[test]
-    fn mode_scalar_arguments() {
-        let data = arr(vec![vec![tv(""), nv(0.0), nv(1.0)], vec![tv("x"), nv(1.0), nv(1.001)], vec![tv("y"), nv(9e9), nv(2.3456)]]);
-        let cases: Vec<(Vec<crate::Arg>, Result<f64, CellError>)> = vec![
-            (vec![n(1.0), n(1.0), n(2.0), n(3.0)], Ok(1.0)),
-            (vec![rf(data)], Ok(1.0)),
-            (vec![rf(arr(vec![vec![nv(-1.1), Value::Empty, tv("1.1")]])), n(-1.1)], Ok(-1.1)),
-            // MODE(C9,E16,"1",B8): E16 holds the text "1.1".
-            (vec![rf(nv(1.1)), rf(tv("1.1")), t("1"), rf(nv(1.0))], Err(CellError::NA)),
-            (vec![rf(nv(1.0)), t("1"), n(2.0), n(3.0)], Err(CellError::NA)),
-            (vec![t("1"), n(1.0), e(CellError::Div0), n(2.0), n(3.0)], Err(CellError::Div0)),
-            // MODE(B9,2,D7) with D7 blank.
-            (vec![rf(nv(2.0)), n(2.0), rf(Value::Empty)], Err(CellError::Value)),
-            (vec![n(1.0), n(1.0), e(CellError::Div0), t("1")], Err(CellError::Div0)),
-        ];
-        for name in ["MODE", "MODE.SNGL"] {
-            for (args, want) in &cases {
-                match want {
-                    Ok(x) => close(ev(name, args.clone()), *x),
-                    Err(err) => is_err(ev(name, args.clone()), *err),
-                }
-            }
-        }
-        is_err(ev("MODE.MULT", vec![rf(nv(1.0)), t("1"), rf(Value::Empty)]), CellError::Value);
-    }
-
-    /// Text and logical values typed as arguments are skipped, not coerced (Excel 365, #736).
-    #[test]
-    fn mode_skips_typed_text_and_logicals() {
-        let cases: Vec<(Vec<crate::Arg>, Result<f64, CellError>)> = vec![
-            (vec![n(1.0), n(1.0), t("x")], Ok(1.0)),
-            (vec![n(1.0), n(2.0), t("x")], Err(CellError::NA)),
-            (vec![n(1.0), t("1"), n(2.0), n(3.0)], Err(CellError::NA)),
-            (vec![t("1"), n(1.0), n(2.0), n(3.0)], Err(CellError::NA)),
-            (vec![t("1"), n(1.0), e(CellError::Div0), n(2.0), n(3.0)], Err(CellError::Div0)),
-            (vec![n(1.0), b(true), b(true), n(2.0)], Err(CellError::NA)),
-            (vec![n(1.0), n(1.0), b(true)], Ok(1.0)),
-        ];
-        for name in ["MODE", "MODE.SNGL"] {
-            for (args, want) in &cases {
-                match want {
-                    Ok(x) => close(ev(name, args.clone()), *x),
-                    Err(err) => is_err(ev(name, args.clone()), *err),
-                }
-            }
-        }
-        assert_eq!(rows_of(&ev("MODE.MULT", vec![n(1.0), t("1"), n(1.0), t("x")])), vec![vec![nv(1.0)]]);
-        is_err(ev("MODE.MULT", vec![n(1.0), b(true), b(true), n(2.0)]), CellError::NA);
-    }
-
-    #[test]
-    fn spread() {
-        let d = [1345.0, 1301.0, 1368.0, 1322.0, 1310.0, 1370.0, 1318.0, 1350.0, 1303.0, 1299.0];
-        close_tol(ev("STDEV.S", vec![c(&d)]), 27.46391572, 1e-9);
-        close_tol(ev("STDEV", vec![c(&d)]), 27.46391572, 1e-9);
-        close_tol(ev("STDEV.P", vec![c(&d)]), 26.05455814, 1e-9);
-        close_tol(ev("STDEVP", vec![c(&d)]), 26.05455814, 1e-9);
-        close_tol(ev("VAR.S", vec![c(&d)]), 754.2666667, 1e-9);
-        close(ev("VAR.P", vec![c(&d)]), 678.84);
-        close(ev("VARP", vec![c(&d)]), 678.84);
-        is_err(ev("STDEV.S", vec![n(1.0)]), CellError::Div0);
-        close(ev("STDEV.P", vec![n(1.0)]), 0.0);
-        let mixed = arr(vec![vec![nv(2.0), Value::Bool(true), tv("x")]]);
-        close(ev("VARA", vec![rf(mixed.clone())]), 1.0);
-        close(ev("VARPA", vec![rf(mixed.clone())]), 2.0 / 3.0);
-        close(ev("STDEVA", vec![rf(mixed.clone())]), 1.0);
-        close(ev("STDEVPA", vec![rf(mixed)]), (2.0f64 / 3.0).sqrt());
-        let s = [4.0, 5.0, 6.0, 7.0, 5.0, 4.0, 3.0];
-        close(ev("DEVSQ", vec![c(&[4.0, 5.0, 8.0, 7.0, 11.0, 4.0, 3.0])]), 48.0);
-        close_tol(ev("AVEDEV", vec![c(&s)]), 1.020408163, 1e-9);
-        let g = [4.0, 5.0, 8.0, 7.0, 11.0, 4.0, 3.0];
-        close_tol(ev("GEOMEAN", vec![c(&g)]), 5.476986969, 1e-9);
-        close_tol(ev("HARMEAN", vec![c(&g)]), 5.028375962, 1e-9);
-        is_err(ev("GEOMEAN", vec![c(&[1.0, 0.0])]), CellError::Num);
-        close_tol(ev("TRIMMEAN", vec![c(&[4.0, 5.0, 6.0, 7.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0, 3.0]), n(0.2)]), 3.777777778, 1e-9);
-        is_err(ev("TRIMMEAN", vec![c(&[1.0]), n(1.0)]), CellError::Num);
-        let k = [3.0, 4.0, 5.0, 2.0, 3.0, 4.0, 5.0, 6.0, 4.0, 7.0];
-        close_tol(ev("KURT", vec![c(&k)]), -0.151799637, 1e-8);
-        close_tol(ev("SKEW", vec![c(&k)]), 0.359543071, 1e-8);
-        close_tol(ev("SKEW.P", vec![c(&k)]), 0.303193339, 1e-8);
-        is_err(ev("KURT", vec![c(&[1.0, 2.0, 3.0])]), CellError::Div0);
-        close_tol(ev("STANDARDIZE", vec![n(42.0), n(40.0), n(1.5)]), 1.333333333, 1e-9);
-        is_err(ev("STANDARDIZE", vec![n(42.0), n(40.0), n(0.0)]), CellError::Num);
-    }
-
-    #[test]
-    fn min_max_order() {
-        close(ev("MIN", vec![c(&[3.0, -1.0, 2.0]), n(0.0)]), -1.0);
-        close(ev("MAX", vec![c(&[3.0, -1.0, 2.0]), n(10.0)]), 10.0);
-        close(ev("MIN", vec![]), 0.0);
-        close(ev("MAX", vec![rf(arr(vec![vec![tv("a")]]))]), 0.0);
-        close(ev("MAXA", vec![rf(arr(vec![vec![nv(-1.0), Value::Bool(true)]]))]), 1.0);
-        close(ev("MINA", vec![rf(arr(vec![vec![nv(1.0), tv("x")]]))]), 0.0);
-        let d = c(&[3.0, 5.0, 3.0, 5.0, 4.0, 4.0, 2.0, 4.0, 6.0, 7.0]);
-        close(ev("LARGE", vec![d.clone(), n(3.0)]), 5.0);
-        close(ev("SMALL", vec![d.clone(), n(4.0)]), 4.0);
-        is_err(ev("LARGE", vec![d.clone(), n(0.0)]), CellError::Num);
-        is_err(ev("SMALL", vec![d.clone(), n(11.0)]), CellError::Num);
-        assert_eq!(rows_of(&ev("LARGE", vec![d, av(row(&[1.0, 2.0]))])), vec![vec![nv(7.0), nv(6.0)]]);
-        let r = c(&[89.0, 88.0, 92.0, 101.0, 94.0, 97.0, 95.0]);
-        close(ev("RANK.AVG", vec![n(94.0), r.clone()]), 4.0);
-        close(ev("RANK.EQ", vec![n(101.0), r.clone()]), 1.0);
-        is_err(ev("RANK", vec![n(1.0), r]), CellError::NA);
-        let r2 = c(&[7.0, 3.5, 3.5, 1.0, 2.0]);
-        close(ev("RANK.EQ", vec![n(7.0), r2.clone(), n(1.0)]), 5.0);
-        close(ev("RANK.EQ", vec![n(3.5), r2.clone(), n(1.0)]), 3.0);
-        close(ev("RANK.AVG", vec![n(3.5), r2, n(1.0)]), 3.5);
-    }
-
-    #[test]
-    fn percentiles() {
-        close(ev("PERCENTILE.INC", vec![c(&[1.0, 3.0, 2.0, 4.0]), n(0.3)]), 1.9);
-        close(ev("PERCENTILE", vec![c(&[1.0, 3.0, 2.0, 4.0]), n(1.0)]), 4.0);
-        is_err(ev("PERCENTILE.INC", vec![c(&[1.0]), n(1.5)]), CellError::Num);
-        let e9 = c(&[1.0, 2.0, 3.0, 6.0, 6.0, 6.0, 7.0, 8.0, 9.0]);
-        close(ev("PERCENTILE.EXC", vec![e9.clone(), n(0.25)]), 2.5);
-        is_err(ev("PERCENTILE.EXC", vec![e9.clone(), n(0.0)]), CellError::Num);
-        is_err(ev("PERCENTILE.EXC", vec![e9.clone(), n(0.01)]), CellError::Num);
-        close(ev("QUARTILE.INC", vec![c(&[1.0, 2.0, 4.0, 7.0, 8.0, 9.0, 10.0, 12.0]), n(1.0)]), 3.5);
-        close(ev("QUARTILE", vec![c(&[1.0, 2.0, 4.0, 7.0, 8.0, 9.0, 10.0, 12.0]), n(4.0)]), 12.0);
-        let q = c(&[6.0, 7.0, 15.0, 36.0, 39.0, 40.0, 41.0, 42.0, 43.0, 47.0, 49.0]);
-        close(ev("QUARTILE.EXC", vec![q.clone(), n(1.0)]), 15.0);
-        close(ev("QUARTILE.EXC", vec![q.clone(), n(3.0)]), 43.0);
-        is_err(ev("QUARTILE.EXC", vec![q, n(4.0)]), CellError::Num);
-        let p = c(&[13.0, 12.0, 11.0, 8.0, 4.0, 3.0, 2.0, 1.0, 1.0, 1.0]);
-        close(ev("PERCENTRANK.INC", vec![p.clone(), n(2.0)]), 0.333);
-        close(ev("PERCENTRANK.INC", vec![p.clone(), n(4.0)]), 0.555);
-        close(ev("PERCENTRANK.INC", vec![p.clone(), n(8.0)]), 0.666);
-        close(ev("PERCENTRANK", vec![p.clone(), n(5.0)]), 0.583);
-        close(ev("PERCENTRANK.INC", vec![p.clone(), n(5.0), n(1.0)]), 0.5);
-        is_err(ev("PERCENTRANK.INC", vec![p.clone(), n(0.5)]), CellError::NA);
-        is_err(ev("PERCENTRANK.INC", vec![p, n(5.0), n(0.0)]), CellError::Num);
-        close(ev("PERCENTRANK.EXC", vec![e9.clone(), n(7.0)]), 0.7);
-        close(ev("PERCENTRANK.EXC", vec![e9.clone(), n(5.43)]), 0.381);
-        close(ev("PERCENTRANK.EXC", vec![e9, n(5.43), n(1.0)]), 0.3);
-        let t = c(&[1.0, 2.0, 3.0]);
-        close(ev("PERCENTRANK", vec![t.clone(), n(2.0), n(400.0)]), 0.5);
-        close(ev("PERCENTRANK.INC", vec![t.clone(), n(2.0), n(400.0)]), 0.5);
-        close(ev("PERCENTRANK.INC", vec![t.clone(), n(1.0), n(400.0)]), 0.0);
-        close(ev("PERCENTRANK.EXC", vec![t, n(2.0), n(400.0)]), 0.5);
-    }
-
-    #[test]
-    fn pairs_and_regression() {
-        close_tol(ev("CORREL", vec![c(&[3.0, 2.0, 4.0, 5.0, 6.0]), c(&[9.0, 7.0, 12.0, 15.0, 17.0])]), 0.997054486, 1e-9);
-        close_tol(ev("PEARSON", vec![c(&[9.0, 7.0, 5.0, 3.0, 1.0]), c(&[10.0, 6.0, 1.0, 5.0, 3.0])]), 0.699379, D7);
-        is_err(ev("CORREL", vec![c(&[1.0, 2.0]), c(&[1.0, 2.0, 3.0])]), CellError::NA);
-        is_err(ev("CORREL", vec![c(&[1.0, 1.0]), c(&[1.0, 2.0])]), CellError::Div0);
-        let y = c(&[2.0, 3.0, 9.0, 1.0, 8.0, 7.0, 5.0]);
-        let x = c(&[6.0, 5.0, 11.0, 7.0, 5.0, 4.0, 4.0]);
-        close_tol(ev("SLOPE", vec![y.clone(), x.clone()]), 0.305555556, 1e-8);
-        close_tol(ev("RSQ", vec![y.clone(), x.clone()]), 0.057950192, 1e-8);
-        close_tol(ev("STEYX", vec![y.clone(), x.clone()]), 3.305718950, 1e-8);
-        close_tol(ev("INTERCEPT", vec![c(&[2.0, 3.0, 9.0, 1.0, 8.0]), c(&[6.0, 5.0, 11.0, 7.0, 5.0])]), 0.048387097, 1e-8);
-        close_tol(ev("FORECAST", vec![n(30.0), c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 10.607253, D7);
-        close_tol(ev("FORECAST.LINEAR", vec![n(30.0), c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 10.607253, D7);
-        close(ev("COVARIANCE.P", vec![c(&[3.0, 2.0, 4.0, 5.0, 6.0]), c(&[9.0, 7.0, 12.0, 15.0, 17.0])]), 5.2);
-        close(ev("COVAR", vec![c(&[3.0, 2.0, 4.0, 5.0, 6.0]), c(&[9.0, 7.0, 12.0, 15.0, 17.0])]), 5.2);
-        close(ev("COVARIANCE.S", vec![c(&[2.0, 4.0, 8.0]), c(&[5.0, 11.0, 12.0])]), 29.0 / 3.0);
-        // Pairs with text are skipped.
-        let xs = arr(vec![vec![nv(1.0)], vec![tv("x")], vec![nv(3.0)]]);
-        close(ev("SLOPE", vec![c(&[2.0, 100.0, 6.0]), rf(xs)]), 2.0);
-    }
-
-    #[test]
-    fn linest_family() {
-        let r = rows_of(&ev("LINEST", vec![c(&[1.0, 9.0, 5.0, 7.0]), c(&[0.0, 4.0, 2.0, 3.0])]));
-        assert_eq!(r.len(), 1);
-        close(r[0][0].clone(), 2.0);
-        close(r[0][1].clone(), 1.0);
-        // Statistics for a simple fit: y = 1,2,4 on x = 1,2,3.
-        let s = rows_of(&ev("LINEST", vec![c(&[1.0, 2.0, 4.0]), c(&[1.0, 2.0, 3.0]), b(true), b(true)]));
-        assert_eq!((s.len(), s[0].len()), (5, 2));
-        close(s[0][0].clone(), 1.5);
-        close(s[0][1].clone(), -2.0 / 3.0);
-        close(s[2][0].clone(), 0.9642857142857143); // r²
-        close(s[3][1].clone(), 1.0); // df
-        close(s[4][0].clone(), 4.5); // ssreg
-        close(s[4][1].clone(), 1.0 / 6.0); // ssresid
-        close(s[2][1].clone(), (1.0f64 / 6.0).sqrt()); // sey
-        close(s[3][0].clone(), 27.0); // F
-        close(s[1][0].clone(), (1.0f64 / 6.0 / 2.0).sqrt()); // se slope
-        // No constant.
-        let z = rows_of(&ev("LINEST", vec![c(&[2.0, 4.0, 6.0]), c(&[1.0, 2.0, 3.0]), b(false)]));
-        close(z[0][0].clone(), 2.0);
-        close(z[0][1].clone(), 0.0);
-        // Two predictors: y = 1 + 2a + 3b.
-        let xs = arr(vec![vec![nv(1.0), nv(0.0)], vec![nv(0.0), nv(1.0)], vec![nv(1.0), nv(1.0)], vec![nv(2.0), nv(1.0)], vec![nv(3.0), nv(5.0)]]);
-        let ys: Vec<f64> = [(1.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (3.0, 5.0)].iter().map(|(a, b)| 1.0 + 2.0 * a + 3.0 * b).collect();
-        let m = rows_of(&ev("LINEST", vec![c(&ys), av(xs)]));
-        close(m[0][0].clone(), 3.0);
-        close(m[0][1].clone(), 2.0);
-        close(m[0][2].clone(), 1.0);
-        let gy = [33100.0, 47300.0, 69000.0, 102000.0, 150000.0, 220000.0];
-        let gx = [11.0, 12.0, 13.0, 14.0, 15.0, 16.0];
-        let l = rows_of(&ev("LOGEST", vec![c(&gy), c(&gx)]));
-        close_tol(l[0][0].clone(), 1.463275628, 1e-9);
-        close_tol(l[0][1].clone(), 495.3047702, 1e-9);
-        let g = rows_of(&ev("GROWTH", vec![c(&gy), c(&gx), c(&[17.0, 18.0])]));
-        close_tol(g[0][0].clone(), 320196.7184, 1e-9);
-        close_tol(g[1][0].clone(), 468536.0539, 1e-9);
-        let ty = [133890.0, 135000.0, 135790.0, 137300.0, 138130.0, 139100.0, 139900.0, 141120.0, 141890.0, 143230.0, 144000.0, 145290.0];
-        let tx: Vec<f64> = (1..=12).map(f64::from).collect();
-        let t1 = ev("TREND", vec![c(&ty), c(&tx), n(13.0)]);
-        close_tol(Value::Number(rows_of(&t1)[0][0].as_f64().unwrap().round()), 146172.0, 1e-9);
-        let fitted = rows_of(&ev("TREND", vec![c(&[1.0, 9.0, 5.0, 7.0]), c(&[0.0, 4.0, 2.0, 3.0])]));
-        close(fitted[1][0].clone(), 9.0);
-        is_err(ev("LOGEST", vec![c(&[1.0, -2.0])]), CellError::Num);
-        is_err(ev("LINEST", vec![c(&[1.0, 2.0]), c(&[1.0, 2.0, 3.0])]), CellError::Ref);
-    }
-
-    // #2177: one predictor row of 16,384 columns built three 16,384² matrices (6 GB) and an O(k³)
-    // inversion; a wider TOROW aborted the process. It is now refused before allocating.
-    #[test]
-    fn linest_family_caps_regressor_count() {
-        let wide = |k: usize| av(arr(vec![(0..k).map(|i| nv(i as f64)).collect()]));
-        let tall = |k: usize| av(arr((0..k).map(|i| vec![nv(i as f64), nv(1.0)]).collect()));
-        for f in ["LINEST", "LOGEST", "TREND", "GROWTH"] {
-            // y is one cell, so every column of x is a predictor.
-            is_err(ev(f, vec![n(1.0), wide(16_384)]), CellError::Value);
-            // y is a row, so every row of x is a predictor.
-            is_err(ev(f, vec![av(arr(vec![vec![nv(1.0), nv(2.0)]])), tall(16_384)]), CellError::Value);
-        }
-        is_err(ev("LINEST", vec![n(1.0), wide(MAX_REGRESSORS + 1)]), CellError::Value);
-        // At the cap the fit still runs (one observation: coefficients are zero, not an error).
-        assert_eq!(rows_of(&ev("LINEST", vec![n(1.0), wide(MAX_REGRESSORS)]))[0].len(), MAX_REGRESSORS + 1);
-        // The rows × k² work bound.
-        assert_eq!(check_regression_size(1_000, MAX_REGRESSORS), Ok(()));
-        assert_eq!(check_regression_size(1_000_000, 100), Err(CellError::Num));
-        assert_eq!(check_regression_size(usize::MAX, 2), Err(CellError::Num));
-        assert_eq!(check_regression_size(10_000_000, 1), Ok(()));
-    }
-
-    #[test]
-    fn frequency_prob() {
-        let f = ev("FREQUENCY", vec![c(&[79.0, 85.0, 78.0, 85.0, 50.0, 81.0, 95.0, 88.0, 97.0]), c(&[70.0, 79.0, 89.0])]);
-        assert_eq!(rows_of(&f), vec![vec![nv(1.0)], vec![nv(2.0)], vec![nv(4.0)], vec![nv(2.0)]]);
-        let x = c(&[0.0, 1.0, 2.0, 3.0]);
-        let p = c(&[0.2, 0.3, 0.1, 0.4]);
-        close(ev("PROB", vec![x.clone(), p.clone(), n(2.0)]), 0.1);
-        close(ev("PROB", vec![x.clone(), p, n(1.0), n(3.0)]), 0.8);
-        is_err(ev("PROB", vec![x.clone(), c(&[0.5, 0.5, 0.5, 0.5]), n(1.0)]), CellError::Num);
-        // Excel: any probability <= 0 is #NUM!, even when it sums to one and lies outside the limits.
-        is_err(ev("PROB", vec![x.clone(), c(&[0.5, 0.0, 0.25, 0.25]), n(0.0), n(3.0)]), CellError::Num);
-        is_err(ev("PROB", vec![x, c(&[0.5, 0.0, 0.25, 0.25]), n(2.0), n(3.0)]), CellError::Num);
-    }
-
-    #[test]
-    fn normal() {
-        close_tol(ev("NORM.DIST", vec![n(42.0), n(40.0), n(1.5), b(true)]), 0.9087888, D7);
-        close_tol(ev("NORM.DIST", vec![n(42.0), n(40.0), n(1.5), b(false)]), 0.10934005, D7);
-        close_tol(ev("NORMDIST", vec![n(42.0), n(40.0), n(1.5), b(true)]), 0.9087888, D7);
-        is_err(ev("NORM.DIST", vec![n(42.0), n(40.0), n(0.0), b(true)]), CellError::Num);
-        close_tol(ev("NORM.INV", vec![n(0.908789), n(40.0), n(1.5)]), 42.000002, D7);
-        close_tol(ev("NORMINV", vec![n(0.908789), n(40.0), n(1.5)]), 42.000002, D7);
-        is_err(ev("NORM.INV", vec![n(1.0), n(0.0), n(1.0)]), CellError::Num);
-        close_tol(ev("NORM.S.DIST", vec![n(1.333333), b(true)]), 0.908788726, 1e-8);
-        close_tol(ev("NORM.S.DIST", vec![n(0.0), b(false)]), 0.398942280, 1e-8);
-        close_tol(ev("NORMSDIST", vec![n(1.333333)]), 0.908788726, 1e-8);
-        close_tol(ev("NORM.S.INV", vec![n(0.908789)]), 1.3333347, D7);
-        close_tol(ev("NORMSINV", vec![n(0.975)]), 1.959963985, 1e-9);
-        close_tol(ev("PHI", vec![n(0.75)]), 0.301137432, 1e-8);
-        close_tol(ev("GAUSS", vec![n(2.0)]), 0.477249868, 1e-8);
-        close_tol(ev("FISHER", vec![n(0.75)]), 0.972955075, 1e-8);
-        close_tol(ev("FISHERINV", vec![n(0.972955)]), 0.75, D7);
-        is_err(ev("FISHER", vec![n(1.0)]), CellError::Num);
-        close_tol(ev("CONFIDENCE.NORM", vec![n(0.05), n(2.5), n(50.0)]), 0.692951912, 1e-8);
-        close_tol(ev("CONFIDENCE", vec![n(0.05), n(2.5), n(50.0)]), 0.692951912, 1e-8);
-        close_tol(ev("CONFIDENCE.T", vec![n(0.05), n(1.0), n(50.0)]), 0.284196855, 1e-8);
-        is_err(ev("CONFIDENCE.T", vec![n(0.05), n(1.0), n(1.0)]), CellError::Div0);
-        let z = c(&[3.0, 6.0, 7.0, 8.0, 6.0, 5.0, 4.0, 2.0, 1.0, 9.0]);
-        close_tol(ev("Z.TEST", vec![z.clone(), n(4.0)]), 0.090574, 1e-5);
-        close_tol(ev("ZTEST", vec![z, n(6.0)]), 0.863043, 1e-5);
-        close_tol(ev("LOGNORM.DIST", vec![n(4.0), n(3.5), n(1.2), b(true)]), 0.0390836, D7);
-        close_tol(ev("LOGNORM.DIST", vec![n(4.0), n(3.5), n(1.2), b(false)]), 0.0176176, D7);
-        close_tol(ev("LOGNORMDIST", vec![n(4.0), n(3.5), n(1.2)]), 0.0390836, D7);
-        close_tol(ev("LOGNORM.INV", vec![n(0.039084), n(3.5), n(1.2)]), 4.0000252, D7);
-        close_tol(ev("LOGINV", vec![n(0.039084), n(3.5), n(1.2)]), 4.0000252, D7);
-    }
-
-    #[test]
-    fn t_chi_f() {
-        close_tol(ev("T.DIST", vec![n(60.0), n(1.0), b(true)]), 0.99469533, D7);
-        close_tol(ev("T.DIST", vec![n(8.0), n(3.0), b(false)]), 0.00073691, 1e-5);
-        close_tol(ev("T.DIST.2T", vec![n(1.959999998), n(60.0)]), 0.054644930, D7);
-        close_tol(ev("T.DIST.RT", vec![n(1.959999998), n(60.0)]), 0.027322465, D7);
-        close_tol(ev("TDIST", vec![n(1.959999998), n(60.0), n(2.0)]), 0.054644930, D7);
-        is_err(ev("TDIST", vec![n(-1.0), n(60.0), n(2.0)]), CellError::Num);
-        is_err(ev("T.DIST", vec![n(1.0), n(0.0), b(true)]), CellError::Num);
-        close_tol(ev("T.INV", vec![n(0.75), n(2.0)]), 0.8164966, D7);
-        close_tol(ev("T.INV", vec![n(0.25), n(2.0)]), -0.8164966, D7);
-        close_tol(ev("T.INV.2T", vec![n(0.546449), n(60.0)]), 0.606533, D7);
-        close_tol(ev("T.INV.2T", vec![n(0.05), n(10.0)]), 2.228138852, 1e-9);
-        close_tol(ev("TINV", vec![n(0.05), n(10.0)]), 2.228138852, 1e-9);
-        let a1 = c(&[3.0, 4.0, 5.0, 8.0, 9.0, 1.0, 2.0, 4.0, 5.0]);
-        let a2 = c(&[6.0, 19.0, 3.0, 2.0, 14.0, 4.0, 5.0, 17.0, 1.0]);
-        close_tol(ev("T.TEST", vec![a1.clone(), a2.clone(), n(2.0), n(1.0)]), 0.196016, 1e-5);
-        close_tol(ev("TTEST", vec![a1.clone(), a2.clone(), n(2.0), n(1.0)]), 0.196016, 1e-5);
-        close_tol(ev("T.TEST", vec![a1.clone(), a2.clone(), n(2.0), n(2.0)]), 0.191995887, 1e-6);
-        close_tol(ev("T.TEST", vec![a1.clone(), a2.clone(), n(1.0), n(3.0)]), 0.1012, 1e-3);
-        is_err(ev("T.TEST", vec![a1, a2, n(3.0), n(1.0)]), CellError::Num);
-        close_tol(ev("CHISQ.DIST", vec![n(0.5), n(1.0), b(true)]), 0.52049988, D7);
-        close_tol(ev("CHISQ.DIST", vec![n(2.0), n(3.0), b(false)]), 0.20755375, D7);
-        close_tol(ev("CHISQ.DIST.RT", vec![n(18.307), n(10.0)]), 0.0500006, 1e-5);
-        close_tol(ev("CHIDIST", vec![n(18.307), n(10.0)]), 0.0500006, 1e-5);
-        close_tol(ev("CHISQ.INV", vec![n(0.93), n(1.0)]), 3.283020287, 1e-8);
-        close_tol(ev("CHISQ.INV", vec![n(0.6), n(2.0)]), 1.832581464, 1e-8);
-        close_tol(ev("CHISQ.INV.RT", vec![n(0.050001), n(10.0)]), 18.30697, D7);
-        close_tol(ev("CHIINV", vec![n(0.050001), n(10.0)]), 18.30697, D7);
-        is_err(ev("CHISQ.DIST", vec![n(-1.0), n(1.0), b(true)]), CellError::Num);
-        let act = arr(vec![vec![nv(58.0), nv(35.0)], vec![nv(11.0), nv(25.0)], vec![nv(10.0), nv(23.0)]]);
-        let exp = arr(vec![vec![nv(45.35), nv(47.65)], vec![nv(17.56), nv(18.44)], vec![nv(16.09), nv(16.91)]]);
-        close_tol(ev("CHISQ.TEST", vec![av(act.clone()), av(exp.clone())]), 0.0003082, 1e-3);
-        close_tol(ev("CHITEST", vec![av(act), av(exp)]), 0.0003082, 1e-3);
-        close_tol(ev("F.DIST", vec![n(15.2069), n(6.0), n(4.0), b(true)]), 0.99, 1e-6);
-        close_tol(ev("F.DIST", vec![n(15.2069), n(6.0), n(4.0), b(false)]), 0.0012238, 1e-5);
-        close_tol(ev("F.DIST.RT", vec![n(15.2069), n(6.0), n(4.0)]), 0.01, 1e-6);
-        close_tol(ev("FDIST", vec![n(15.2069), n(6.0), n(4.0)]), 0.01, 1e-6);
-        close_tol(ev("F.INV", vec![n(0.01), n(6.0), n(4.0)]), 0.10930991, D7);
-        close_tol(ev("F.INV.RT", vec![n(0.01), n(6.0), n(4.0)]), 15.20686, D7);
-        close_tol(ev("FINV", vec![n(0.01), n(6.0), n(4.0)]), 15.20686, D7);
-        close_tol(ev("F.TEST", vec![c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 0.64831785, D7);
-        close_tol(ev("FTEST", vec![c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 0.64831785, D7);
-        is_err(ev("F.DIST", vec![n(1.0), n(0.0), n(4.0), b(true)]), CellError::Num);
-    }
-
-    #[test]
-    fn binom_inv_huge_trials_returns() {
-        // Above 2^53 neighbouring f64 values are more than 1 apart; the bisection must still end.
-        let cases: [(&str, f64, f64, f64); 3] = [("BINOM.INV", 1e17, 0.5, 0.5), ("CRITBINOM", 1e300, 1.0, 0.5), ("BINOM.INV", 1e300, 0.5, 0.5)];
-        for (name, trials, p, alpha) in cases {
-            let (tx, rx) = std::sync::mpsc::channel();
-            std::thread::spawn(move || {
-                let r = ev(name, vec![n(trials), n(p), n(alpha)]);
-                let _ = tx.send(r);
-            });
-            match rx.recv_timeout(std::time::Duration::from_secs(5)) {
-                Ok(Value::Number(_)) | Ok(Value::Error(CellError::Num)) => {}
-                Ok(other) => panic!("{name}({trials},{p},{alpha}) returned {other:?}"),
-                Err(_) => panic!("{name}({trials},{p},{alpha}) did not return within 5 s"),
-            }
-        }
-    }
-
-    #[test]
-    fn discrete() {
-        close_tol(ev("BINOM.DIST", vec![n(6.0), n(10.0), n(0.5), b(false)]), 0.205078125, 1e-12);
-        close_tol(ev("BINOM.DIST", vec![n(6.0), n(10.0), n(0.5), b(true)]), 0.828125, 1e-12);
-        close_tol(ev("BINOMDIST", vec![n(6.0), n(10.0), n(0.5), b(false)]), 0.205078125, 1e-12);
-        is_err(ev("BINOM.DIST", vec![n(11.0), n(10.0), n(0.5), b(false)]), CellError::Num);
-        close_tol(ev("BINOM.DIST.RANGE", vec![n(60.0), n(0.75), n(48.0)]), 0.083974967, 1e-6);
-        close_tol(ev("BINOM.DIST.RANGE", vec![n(60.0), n(0.75), n(45.0), n(50.0)]), 0.523629793, 1e-6);
-        close(ev("BINOM.INV", vec![n(6.0), n(0.5), n(0.75)]), 4.0);
-        close(ev("CRITBINOM", vec![n(6.0), n(0.5), n(0.75)]), 4.0);
-        close(ev("BINOM.INV", vec![n(1e9), n(0.5), n(0.5)]), 5e8);
-        close_tol(ev("POISSON.DIST", vec![n(2.0), n(5.0), b(true)]), 0.124652, 1e-5);
-        close_tol(ev("POISSON.DIST", vec![n(2.0), n(5.0), b(false)]), 0.084224, 1e-5);
-        close_tol(ev("POISSON", vec![n(2.0), n(5.0), b(false)]), 0.084224, 1e-5);
-        is_err(ev("POISSON.DIST", vec![n(-1.0), n(5.0), b(false)]), CellError::Num);
-        close_tol(ev("HYPGEOM.DIST", vec![n(1.0), n(4.0), n(8.0), n(20.0), b(true)]), 0.4654, 1e-4);
-        close_tol(ev("HYPGEOM.DIST", vec![n(1.0), n(4.0), n(8.0), n(20.0), b(false)]), 0.3633, 1e-4);
-        close_tol(ev("HYPGEOMDIST", vec![n(1.0), n(4.0), n(8.0), n(20.0)]), 0.363261094, 1e-8);
-        is_err(ev("HYPGEOMDIST", vec![n(5.0), n(4.0), n(8.0), n(20.0)]), CellError::Num);
-        close_tol(ev("NEGBINOM.DIST", vec![n(10.0), n(5.0), n(0.25), b(true)]), 0.3135141, D7);
-        close_tol(ev("NEGBINOM.DIST", vec![n(10.0), n(5.0), n(0.25), b(false)]), 0.0550487, D7);
-        close_tol(ev("NEGBINOMDIST", vec![n(10.0), n(5.0), n(0.25)]), 0.0550487, D7);
-    }
-
-    #[test]
-    fn continuous() {
-        close_tol(ev("EXPON.DIST", vec![n(0.2), n(10.0), b(true)]), 0.86466472, D7);
-        close_tol(ev("EXPON.DIST", vec![n(0.2), n(10.0), b(false)]), 1.35335283, D7);
-        close_tol(ev("EXPONDIST", vec![n(0.2), n(10.0), b(true)]), 0.86466472, D7);
-        is_err(ev("EXPON.DIST", vec![n(0.2), n(0.0), b(true)]), CellError::Num);
-        close_tol(ev("GAMMA.DIST", vec![n(10.00001131), n(9.0), n(2.0), b(false)]), 0.032639, 1e-5);
-        close_tol(ev("GAMMA.DIST", vec![n(10.00001131), n(9.0), n(2.0), b(true)]), 0.068094, 1e-5);
-        close_tol(ev("GAMMADIST", vec![n(10.00001131), n(9.0), n(2.0), b(true)]), 0.068094, 1e-5);
-        close_tol(ev("GAMMA.INV", vec![n(0.068094), n(9.0), n(2.0)]), 10.0000112, 1e-6);
-        close_tol(ev("GAMMAINV", vec![n(0.068094), n(9.0), n(2.0)]), 10.0000112, 1e-6);
-        close_tol(ev("GAMMALN", vec![n(4.0)]), 1.791759469, 1e-9);
-        close_tol(ev("GAMMALN.PRECISE", vec![n(4.5)]), 2.453736571, 1e-9);
-        is_err(ev("GAMMALN", vec![n(0.0)]), CellError::Num);
-        close_tol(ev("GAMMA", vec![n(2.5)]), 1.329340388, 1e-9);
-        close_tol(ev("GAMMA", vec![n(-0.75)]), -4.834146544, 1e-8);
-        is_err(ev("GAMMA", vec![n(-1.0)]), CellError::Num);
-        is_err(ev("GAMMA", vec![n(0.0)]), CellError::Num);
-        close_tol(ev("BETA.DIST", vec![n(2.0), n(8.0), n(10.0), b(true), n(1.0), n(3.0)]), 0.6854706, D7);
-        close_tol(ev("BETA.DIST", vec![n(2.0), n(8.0), n(10.0), b(false), n(1.0), n(3.0)]), 1.4837646, D7);
-        close_tol(ev("BETADIST", vec![n(2.0), n(8.0), n(10.0), n(1.0), n(3.0)]), 0.6854706, D7);
-        close_tol(ev("BETA.INV", vec![n(0.685470581), n(8.0), n(10.0), n(1.0), n(3.0)]), 2.0, D7);
-        close_tol(ev("BETAINV", vec![n(0.685470581), n(8.0), n(10.0), n(1.0), n(3.0)]), 2.0, D7);
-        is_err(ev("BETA.DIST", vec![n(4.0), n(8.0), n(10.0), b(true), n(1.0), n(3.0)]), CellError::Num);
-        close_tol(ev("WEIBULL.DIST", vec![n(105.0), n(20.0), n(100.0), b(true)]), 0.929581, 1e-5);
-        close_tol(ev("WEIBULL.DIST", vec![n(105.0), n(20.0), n(100.0), b(false)]), 0.035589, 1e-4);
-        close_tol(ev("WEIBULL", vec![n(105.0), n(20.0), n(100.0), b(true)]), 0.929581, 1e-5);
-        // Lifting over an array of x values.
-        let r = rows_of(&ev("NORM.S.DIST", vec![av(row(&[0.0, 1.0])), b(true)]));
-        close(r[0][0].clone(), 0.5);
-        close_tol(r[0][1].clone(), 0.841344746, 1e-8);
-    }
-
-    #[test]
-    fn aggregate_helper() {
-        let vals = vec![nv(1.0), nv(2.0), tv("x"), Value::Empty, Value::Bool(true), nv(6.0)];
-        close(aggregate_values(1, &vals), 3.0);
-        close(aggregate_values(2, &vals), 3.0);
-        close(aggregate_values(3, &vals), 5.0);
-        close(aggregate_values(4, &vals), 6.0);
-        close(aggregate_values(105, &vals), 1.0);
-        close(aggregate_values(6, &vals), 12.0);
-        close(aggregate_values(9, &vals), 9.0);
-        close(aggregate_values(109, &vals), 9.0);
-        close(aggregate_values(11, &vals), 14.0 / 3.0);
-        close(aggregate_values(10, &vals), 7.0);
-        close(aggregate_values(12, &vals), 2.0);
-        is_err(aggregate_values(13, &vals), CellError::NA);
-        is_err(aggregate_values(14, &vals), CellError::Value);
-        is_err(aggregate_values(99, &vals), CellError::Value);
-        is_err(aggregate_values(9, &[nv(1.0), Value::Error(CellError::Div0)]), CellError::Div0);
-        close(aggregate_values_k(14, &vals, &nv(1.0)), 6.0);
-        close(aggregate_values_k(15, &vals, &nv(2.0)), 2.0);
-        close(aggregate_values_k(16, &vals, &nv(0.5)), 2.0);
-        close(aggregate_values_k(17, &vals, &nv(4.0)), 6.0);
-        close(aggregate_values_k(18, &vals, &nv(0.5)), 2.0);
-        close(aggregate_values_k(19, &vals, &nv(2.0)), 2.0);
-        close(aggregate_values_k(9, &vals, &nv(2.0)), 9.0);
-        is_err(aggregate_values_k(14, &vals, &nv(10.0)), CellError::Num);
-    }
-}
+mod tests;
diff --git a/crates/functions/src/stat/tests.rs b/crates/functions/src/stat/tests.rs
new file mode 100644
index 000000000..87ce19fac
--- /dev/null
+++ b/crates/functions/src/stat/tests.rs
@@ -0,0 +1,508 @@
+use super::{MAX_REGRESSORS, aggregate_values, aggregate_values_k, check_regression_size};
+use crate::util::testutil::*;
+use gridcraft_core::{CellError, Value};
+
+const D7: f64 = 1e-6;
+
+fn c(xs: &[f64]) -> crate::Arg {
+    av(col(xs))
+}
+
+// The two middle values are finite and their midpoint is representable even when
+// adding them first would overflow. Exercise both callers of the shared helper.
+#[test]
+fn median_finite_midpoint_does_not_overflow() {
+    for (values, expected) in [
+        (vec![1e308, 1e308], 1e308),
+        (vec![-1e308, -1e308], -1e308),
+        (vec![1.6e308, 1e308], 1.3e308),
+        (vec![-1e308, -1.6e308], -1.3e308),
+        (vec![f64::MAX, f64::MAX], f64::MAX),
+        (vec![-f64::MAX, -f64::MAX], -f64::MAX),
+        (vec![-f64::MAX, f64::MAX], 0.0),
+        (vec![1.7e308, -1.7e308, 1e308, 1.6e308], 1.3e308),
+    ] {
+        close(ev("MEDIAN", values.iter().copied().map(n).collect()), expected);
+        close(ev("MEDIAN", vec![rf(col(&values))]), expected);
+        close(aggregate_values(12, &values.iter().copied().map(nv).collect::<Vec<_>>()), expected);
+    }
+}
+
+#[test]
+fn median_midpoint_keeps_small_values_and_argument_semantics() {
+    // Halving each operand unconditionally can lose the smallest numbers. Use exact
+    // equality here: the usual aggregate-test tolerance would accept zero.
+    for value in [f64::MIN_POSITIVE, -f64::MIN_POSITIVE, f64::from_bits(1), -f64::from_bits(1)] {
+        assert_eq!(ev("MEDIAN", vec![n(value), n(value)]), nv(value));
+        assert_eq!(aggregate_values(12, &[nv(value), nv(value)]), nv(value));
+    }
+    close(ev("MEDIAN", vec![c(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0])]), 3.5);
+    close(ev("MEDIAN", vec![c(&[1e308, -1e308, 3.0])]), 3.0);
+    close(ev("MEDIAN", vec![n(1e308)]), 1e308);
+    close(ev("MEDIAN", vec![t("4"), b(true)]), 2.5);
+    close(ev("MEDIAN", vec![rf(arr(vec![vec![nv(1.0), tv("ignored"), Value::Empty, Value::Bool(true), nv(6.0)]]))]), 3.5);
+    is_err(ev("MEDIAN", vec![t("invalid")]), CellError::Value);
+    is_err(ev("MEDIAN", vec![e(CellError::NA), n(1e308)]), CellError::NA);
+    is_err(ev("MEDIAN", vec![rf(arr(vec![vec![tv("ignored"), Value::Empty]]))]), CellError::Num);
+    is_err(aggregate_values(12, &[]), CellError::Num);
+    is_err(aggregate_values(12, &[nv(1e308), Value::Error(CellError::Div0)]), CellError::Div0);
+}
+
+#[test]
+fn averages_and_counts() {
+    close(ev("AVERAGE", vec![n(1.0), n(2.0), n(6.0)]), 3.0);
+    is_err(ev("AVERAGE", vec![rf(arr(vec![vec![tv("a")]]))]), CellError::Div0);
+    let mixed = arr(vec![vec![nv(1.0), tv("x"), Value::Bool(true), Value::Empty, nv(3.0)]]);
+    close(ev("AVERAGE", vec![rf(mixed.clone())]), 2.0);
+    close(ev("AVERAGEA", vec![rf(mixed.clone())]), 1.25);
+    close(ev("AVERAGE", vec![t("4"), b(true)]), 2.5);
+    is_err(ev("AVERAGE", vec![t("abc")]), CellError::Value);
+    is_err(ev("AVERAGE", vec![rf(arr(vec![vec![nv(1.0), Value::Error(CellError::NA)]]))]), CellError::NA);
+    close(ev("COUNT", vec![rf(mixed.clone()), n(4.0), t("5"), t("x")]), 4.0);
+    close(ev("COUNT", vec![e(CellError::Div0)]), 0.0);
+    close(ev("COUNTA", vec![rf(mixed.clone())]), 4.0);
+    close(ev("COUNTA", vec![n(1.0), t("")]), 2.0);
+    let blanks = arr(vec![vec![Value::Empty, tv(""), nv(0.0), tv(" ")]]);
+    close(ev("COUNTBLANK", vec![rf(blanks)]), 2.0);
+    close(ev("MEDIAN", vec![c(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0])]), 3.5);
+    close(ev("MEDIAN", vec![c(&[3.0, 1.0, 2.0])]), 2.0);
+    is_err(ev("MEDIAN", vec![rf(arr(vec![vec![tv("a")]]))]), CellError::Num);
+    close(ev("MODE.SNGL", vec![c(&[5.6, 4.0, 4.0, 3.0, 2.0, 4.0])]), 4.0);
+    close(ev("MODE", vec![c(&[1.0, 2.0, 2.0, 1.0])]), 1.0);
+    is_err(ev("MODE", vec![c(&[1.0, 2.0, 3.0])]), CellError::NA);
+    assert_eq!(rows_of(&ev("MODE.MULT", vec![c(&[1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 2.0, 3.0])])), vec![vec![nv(2.0)], vec![nv(3.0)]]);
+}
+
+/// MODE argument semantics in Excel 365, on the inputs of FormulaEvalTestData (row "Mode"):
+/// text is skipped, typed or referenced, but a single-cell reference to a blank cell is
+/// `#VALUE!`; the first error from the left wins. The values cached in POI's file come from an
+/// older Excel and say `#VALUE!` for `MODE(C9,E16,"1",B8)`, `MODE(B8,"1",2,3)` and
+/// `MODE("1",1,#DIV/0!,2,3)`; Excel 365 gives `#N/A`, `#N/A` and `#DIV/0!`.
+#[test]
+fn mode_scalar_arguments() {
+    let data = arr(vec![vec![tv(""), nv(0.0), nv(1.0)], vec![tv("x"), nv(1.0), nv(1.001)], vec![tv("y"), nv(9e9), nv(2.3456)]]);
+    let cases: Vec<(Vec<crate::Arg>, Result<f64, CellError>)> = vec![
+        (vec![n(1.0), n(1.0), n(2.0), n(3.0)], Ok(1.0)),
+        (vec![rf(data)], Ok(1.0)),
+        (vec![rf(arr(vec![vec![nv(-1.1), Value::Empty, tv("1.1")]])), n(-1.1)], Ok(-1.1)),
+        // MODE(C9,E16,"1",B8): E16 holds the text "1.1".
+        (vec![rf(nv(1.1)), rf(tv("1.1")), t("1"), rf(nv(1.0))], Err(CellError::NA)),
+        (vec![rf(nv(1.0)), t("1"), n(2.0), n(3.0)], Err(CellError::NA)),
+        (vec![t("1"), n(1.0), e(CellError::Div0), n(2.0), n(3.0)], Err(CellError::Div0)),
+        // MODE(B9,2,D7) with D7 blank.
+        (vec![rf(nv(2.0)), n(2.0), rf(Value::Empty)], Err(CellError::Value)),
+        (vec![n(1.0), n(1.0), e(CellError::Div0), t("1")], Err(CellError::Div0)),
+    ];
+    for name in ["MODE", "MODE.SNGL"] {
+        for (args, want) in &cases {
+            match want {
+                Ok(x) => close(ev(name, args.clone()), *x),
+                Err(err) => is_err(ev(name, args.clone()), *err),
+            }
+        }
+    }
+    is_err(ev("MODE.MULT", vec![rf(nv(1.0)), t("1"), rf(Value::Empty)]), CellError::Value);
+}
+
+/// Text and logical values typed as arguments are skipped, not coerced (Excel 365, #736).
+#[test]
+fn mode_skips_typed_text_and_logicals() {
+    let cases: Vec<(Vec<crate::Arg>, Result<f64, CellError>)> = vec![
+        (vec![n(1.0), n(1.0), t("x")], Ok(1.0)),
+        (vec![n(1.0), n(2.0), t("x")], Err(CellError::NA)),
+        (vec![n(1.0), t("1"), n(2.0), n(3.0)], Err(CellError::NA)),
+        (vec![t("1"), n(1.0), n(2.0), n(3.0)], Err(CellError::NA)),
+        (vec![t("1"), n(1.0), e(CellError::Div0), n(2.0), n(3.0)], Err(CellError::Div0)),
+        (vec![n(1.0), b(true), b(true), n(2.0)], Err(CellError::NA)),
+        (vec![n(1.0), n(1.0), b(true)], Ok(1.0)),
+    ];
+    for name in ["MODE", "MODE.SNGL"] {
+        for (args, want) in &cases {
+            match want {
+                Ok(x) => close(ev(name, args.clone()), *x),
+                Err(err) => is_err(ev(name, args.clone()), *err),
+            }
+        }
+    }
+    assert_eq!(rows_of(&ev("MODE.MULT", vec![n(1.0), t("1"), n(1.0), t("x")])), vec![vec![nv(1.0)]]);
+    is_err(ev("MODE.MULT", vec![n(1.0), b(true), b(true), n(2.0)]), CellError::NA);
+}
+
+#[test]
+fn spread() {
+    let d = [1345.0, 1301.0, 1368.0, 1322.0, 1310.0, 1370.0, 1318.0, 1350.0, 1303.0, 1299.0];
+    close_tol(ev("STDEV.S", vec![c(&d)]), 27.46391572, 1e-9);
+    close_tol(ev("STDEV", vec![c(&d)]), 27.46391572, 1e-9);
+    close_tol(ev("STDEV.P", vec![c(&d)]), 26.05455814, 1e-9);
+    close_tol(ev("STDEVP", vec![c(&d)]), 26.05455814, 1e-9);
+    close_tol(ev("VAR.S", vec![c(&d)]), 754.2666667, 1e-9);
+    close(ev("VAR.P", vec![c(&d)]), 678.84);
+    close(ev("VARP", vec![c(&d)]), 678.84);
+    is_err(ev("STDEV.S", vec![n(1.0)]), CellError::Div0);
+    close(ev("STDEV.P", vec![n(1.0)]), 0.0);
+    let mixed = arr(vec![vec![nv(2.0), Value::Bool(true), tv("x")]]);
+    close(ev("VARA", vec![rf(mixed.clone())]), 1.0);
+    close(ev("VARPA", vec![rf(mixed.clone())]), 2.0 / 3.0);
+    close(ev("STDEVA", vec![rf(mixed.clone())]), 1.0);
+    close(ev("STDEVPA", vec![rf(mixed)]), (2.0f64 / 3.0).sqrt());
+    let s = [4.0, 5.0, 6.0, 7.0, 5.0, 4.0, 3.0];
+    close(ev("DEVSQ", vec![c(&[4.0, 5.0, 8.0, 7.0, 11.0, 4.0, 3.0])]), 48.0);
+    close_tol(ev("AVEDEV", vec![c(&s)]), 1.020408163, 1e-9);
+    let g = [4.0, 5.0, 8.0, 7.0, 11.0, 4.0, 3.0];
+    close_tol(ev("GEOMEAN", vec![c(&g)]), 5.476986969, 1e-9);
+    close_tol(ev("HARMEAN", vec![c(&g)]), 5.028375962, 1e-9);
+    is_err(ev("GEOMEAN", vec![c(&[1.0, 0.0])]), CellError::Num);
+    close_tol(ev("TRIMMEAN", vec![c(&[4.0, 5.0, 6.0, 7.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0, 3.0]), n(0.2)]), 3.777777778, 1e-9);
+    is_err(ev("TRIMMEAN", vec![c(&[1.0]), n(1.0)]), CellError::Num);
+    let k = [3.0, 4.0, 5.0, 2.0, 3.0, 4.0, 5.0, 6.0, 4.0, 7.0];
+    close_tol(ev("KURT", vec![c(&k)]), -0.151799637, 1e-8);
+    close_tol(ev("SKEW", vec![c(&k)]), 0.359543071, 1e-8);
+    close_tol(ev("SKEW.P", vec![c(&k)]), 0.303193339, 1e-8);
+    is_err(ev("KURT", vec![c(&[1.0, 2.0, 3.0])]), CellError::Div0);
+    close_tol(ev("STANDARDIZE", vec![n(42.0), n(40.0), n(1.5)]), 1.333333333, 1e-9);
+    is_err(ev("STANDARDIZE", vec![n(42.0), n(40.0), n(0.0)]), CellError::Num);
+}
+
+#[test]
+fn min_max_order() {
+    close(ev("MIN", vec![c(&[3.0, -1.0, 2.0]), n(0.0)]), -1.0);
+    close(ev("MAX", vec![c(&[3.0, -1.0, 2.0]), n(10.0)]), 10.0);
+    close(ev("MIN", vec![]), 0.0);
+    close(ev("MAX", vec![rf(arr(vec![vec![tv("a")]]))]), 0.0);
+    close(ev("MAXA", vec![rf(arr(vec![vec![nv(-1.0), Value::Bool(true)]]))]), 1.0);
+    close(ev("MINA", vec![rf(arr(vec![vec![nv(1.0), tv("x")]]))]), 0.0);
+    let d = c(&[3.0, 5.0, 3.0, 5.0, 4.0, 4.0, 2.0, 4.0, 6.0, 7.0]);
+    close(ev("LARGE", vec![d.clone(), n(3.0)]), 5.0);
+    close(ev("SMALL", vec![d.clone(), n(4.0)]), 4.0);
+    is_err(ev("LARGE", vec![d.clone(), n(0.0)]), CellError::Num);
+    is_err(ev("SMALL", vec![d.clone(), n(11.0)]), CellError::Num);
+    assert_eq!(rows_of(&ev("LARGE", vec![d, av(row(&[1.0, 2.0]))])), vec![vec![nv(7.0), nv(6.0)]]);
+    let r = c(&[89.0, 88.0, 92.0, 101.0, 94.0, 97.0, 95.0]);
+    close(ev("RANK.AVG", vec![n(94.0), r.clone()]), 4.0);
+    close(ev("RANK.EQ", vec![n(101.0), r.clone()]), 1.0);
+    is_err(ev("RANK", vec![n(1.0), r]), CellError::NA);
+    let r2 = c(&[7.0, 3.5, 3.5, 1.0, 2.0]);
+    close(ev("RANK.EQ", vec![n(7.0), r2.clone(), n(1.0)]), 5.0);
+    close(ev("RANK.EQ", vec![n(3.5), r2.clone(), n(1.0)]), 3.0);
+    close(ev("RANK.AVG", vec![n(3.5), r2, n(1.0)]), 3.5);
+}
+
+#[test]
+fn percentiles() {
+    close(ev("PERCENTILE.INC", vec![c(&[1.0, 3.0, 2.0, 4.0]), n(0.3)]), 1.9);
+    close(ev("PERCENTILE", vec![c(&[1.0, 3.0, 2.0, 4.0]), n(1.0)]), 4.0);
+    is_err(ev("PERCENTILE.INC", vec![c(&[1.0]), n(1.5)]), CellError::Num);
+    let e9 = c(&[1.0, 2.0, 3.0, 6.0, 6.0, 6.0, 7.0, 8.0, 9.0]);
+    close(ev("PERCENTILE.EXC", vec![e9.clone(), n(0.25)]), 2.5);
+    is_err(ev("PERCENTILE.EXC", vec![e9.clone(), n(0.0)]), CellError::Num);
+    is_err(ev("PERCENTILE.EXC", vec![e9.clone(), n(0.01)]), CellError::Num);
+    close(ev("QUARTILE.INC", vec![c(&[1.0, 2.0, 4.0, 7.0, 8.0, 9.0, 10.0, 12.0]), n(1.0)]), 3.5);
+    close(ev("QUARTILE", vec![c(&[1.0, 2.0, 4.0, 7.0, 8.0, 9.0, 10.0, 12.0]), n(4.0)]), 12.0);
+    let q = c(&[6.0, 7.0, 15.0, 36.0, 39.0, 40.0, 41.0, 42.0, 43.0, 47.0, 49.0]);
+    close(ev("QUARTILE.EXC", vec![q.clone(), n(1.0)]), 15.0);
+    close(ev("QUARTILE.EXC", vec![q.clone(), n(3.0)]), 43.0);
+    is_err(ev("QUARTILE.EXC", vec![q, n(4.0)]), CellError::Num);
+    let p = c(&[13.0, 12.0, 11.0, 8.0, 4.0, 3.0, 2.0, 1.0, 1.0, 1.0]);
+    close(ev("PERCENTRANK.INC", vec![p.clone(), n(2.0)]), 0.333);
+    close(ev("PERCENTRANK.INC", vec![p.clone(), n(4.0)]), 0.555);
+    close(ev("PERCENTRANK.INC", vec![p.clone(), n(8.0)]), 0.666);
+    close(ev("PERCENTRANK", vec![p.clone(), n(5.0)]), 0.583);
+    close(ev("PERCENTRANK.INC", vec![p.clone(), n(5.0), n(1.0)]), 0.5);
+    is_err(ev("PERCENTRANK.INC", vec![p.clone(), n(0.5)]), CellError::NA);
+    is_err(ev("PERCENTRANK.INC", vec![p, n(5.0), n(0.0)]), CellError::Num);
+    close(ev("PERCENTRANK.EXC", vec![e9.clone(), n(7.0)]), 0.7);
+    close(ev("PERCENTRANK.EXC", vec![e9.clone(), n(5.43)]), 0.381);
+    close(ev("PERCENTRANK.EXC", vec![e9, n(5.43), n(1.0)]), 0.3);
+    let t = c(&[1.0, 2.0, 3.0]);
+    close(ev("PERCENTRANK", vec![t.clone(), n(2.0), n(400.0)]), 0.5);
+    close(ev("PERCENTRANK.INC", vec![t.clone(), n(2.0), n(400.0)]), 0.5);
+    close(ev("PERCENTRANK.INC", vec![t.clone(), n(1.0), n(400.0)]), 0.0);
+    close(ev("PERCENTRANK.EXC", vec![t, n(2.0), n(400.0)]), 0.5);
+}
+
+#[test]
+fn pairs_and_regression() {
+    close_tol(ev("CORREL", vec![c(&[3.0, 2.0, 4.0, 5.0, 6.0]), c(&[9.0, 7.0, 12.0, 15.0, 17.0])]), 0.997054486, 1e-9);
+    close_tol(ev("PEARSON", vec![c(&[9.0, 7.0, 5.0, 3.0, 1.0]), c(&[10.0, 6.0, 1.0, 5.0, 3.0])]), 0.699379, D7);
+    is_err(ev("CORREL", vec![c(&[1.0, 2.0]), c(&[1.0, 2.0, 3.0])]), CellError::NA);
+    is_err(ev("CORREL", vec![c(&[1.0, 1.0]), c(&[1.0, 2.0])]), CellError::Div0);
+    let y = c(&[2.0, 3.0, 9.0, 1.0, 8.0, 7.0, 5.0]);
+    let x = c(&[6.0, 5.0, 11.0, 7.0, 5.0, 4.0, 4.0]);
+    close_tol(ev("SLOPE", vec![y.clone(), x.clone()]), 0.305555556, 1e-8);
+    close_tol(ev("RSQ", vec![y.clone(), x.clone()]), 0.057950192, 1e-8);
+    close_tol(ev("STEYX", vec![y.clone(), x.clone()]), 3.305718950, 1e-8);
+    close_tol(ev("INTERCEPT", vec![c(&[2.0, 3.0, 9.0, 1.0, 8.0]), c(&[6.0, 5.0, 11.0, 7.0, 5.0])]), 0.048387097, 1e-8);
+    close_tol(ev("FORECAST", vec![n(30.0), c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 10.607253, D7);
+    close_tol(ev("FORECAST.LINEAR", vec![n(30.0), c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 10.607253, D7);
+    close(ev("COVARIANCE.P", vec![c(&[3.0, 2.0, 4.0, 5.0, 6.0]), c(&[9.0, 7.0, 12.0, 15.0, 17.0])]), 5.2);
+    close(ev("COVAR", vec![c(&[3.0, 2.0, 4.0, 5.0, 6.0]), c(&[9.0, 7.0, 12.0, 15.0, 17.0])]), 5.2);
+    close(ev("COVARIANCE.S", vec![c(&[2.0, 4.0, 8.0]), c(&[5.0, 11.0, 12.0])]), 29.0 / 3.0);
+    // Pairs with text are skipped.
+    let xs = arr(vec![vec![nv(1.0)], vec![tv("x")], vec![nv(3.0)]]);
+    close(ev("SLOPE", vec![c(&[2.0, 100.0, 6.0]), rf(xs)]), 2.0);
+}
+
+#[test]
+fn linest_family() {
+    let r = rows_of(&ev("LINEST", vec![c(&[1.0, 9.0, 5.0, 7.0]), c(&[0.0, 4.0, 2.0, 3.0])]));
+    assert_eq!(r.len(), 1);
+    close(r[0][0].clone(), 2.0);
+    close(r[0][1].clone(), 1.0);
+    // Statistics for a simple fit: y = 1,2,4 on x = 1,2,3.
+    let s = rows_of(&ev("LINEST", vec![c(&[1.0, 2.0, 4.0]), c(&[1.0, 2.0, 3.0]), b(true), b(true)]));
+    assert_eq!((s.len(), s[0].len()), (5, 2));
+    close(s[0][0].clone(), 1.5);
+    close(s[0][1].clone(), -2.0 / 3.0);
+    close(s[2][0].clone(), 0.9642857142857143); // r²
+    close(s[3][1].clone(), 1.0); // df
+    close(s[4][0].clone(), 4.5); // ssreg
+    close(s[4][1].clone(), 1.0 / 6.0); // ssresid
+    close(s[2][1].clone(), (1.0f64 / 6.0).sqrt()); // sey
+    close(s[3][0].clone(), 27.0); // F
+    close(s[1][0].clone(), (1.0f64 / 6.0 / 2.0).sqrt()); // se slope
+    // No constant.
+    let z = rows_of(&ev("LINEST", vec![c(&[2.0, 4.0, 6.0]), c(&[1.0, 2.0, 3.0]), b(false)]));
+    close(z[0][0].clone(), 2.0);
+    close(z[0][1].clone(), 0.0);
+    // Two predictors: y = 1 + 2a + 3b.
+    let xs = arr(vec![vec![nv(1.0), nv(0.0)], vec![nv(0.0), nv(1.0)], vec![nv(1.0), nv(1.0)], vec![nv(2.0), nv(1.0)], vec![nv(3.0), nv(5.0)]]);
+    let ys: Vec<f64> = [(1.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (3.0, 5.0)].iter().map(|(a, b)| 1.0 + 2.0 * a + 3.0 * b).collect();
+    let m = rows_of(&ev("LINEST", vec![c(&ys), av(xs)]));
+    close(m[0][0].clone(), 3.0);
+    close(m[0][1].clone(), 2.0);
+    close(m[0][2].clone(), 1.0);
+    let gy = [33100.0, 47300.0, 69000.0, 102000.0, 150000.0, 220000.0];
+    let gx = [11.0, 12.0, 13.0, 14.0, 15.0, 16.0];
+    let l = rows_of(&ev("LOGEST", vec![c(&gy), c(&gx)]));
+    close_tol(l[0][0].clone(), 1.463275628, 1e-9);
+    close_tol(l[0][1].clone(), 495.3047702, 1e-9);
+    let g = rows_of(&ev("GROWTH", vec![c(&gy), c(&gx), c(&[17.0, 18.0])]));
+    close_tol(g[0][0].clone(), 320196.7184, 1e-9);
+    close_tol(g[1][0].clone(), 468536.0539, 1e-9);
+    let ty = [133890.0, 135000.0, 135790.0, 137300.0, 138130.0, 139100.0, 139900.0, 141120.0, 141890.0, 143230.0, 144000.0, 145290.0];
+    let tx: Vec<f64> = (1..=12).map(f64::from).collect();
+    let t1 = ev("TREND", vec![c(&ty), c(&tx), n(13.0)]);
+    close_tol(Value::Number(rows_of(&t1)[0][0].as_f64().unwrap().round()), 146172.0, 1e-9);
+    let fitted = rows_of(&ev("TREND", vec![c(&[1.0, 9.0, 5.0, 7.0]), c(&[0.0, 4.0, 2.0, 3.0])]));
+    close(fitted[1][0].clone(), 9.0);
+    is_err(ev("LOGEST", vec![c(&[1.0, -2.0])]), CellError::Num);
+    is_err(ev("LINEST", vec![c(&[1.0, 2.0]), c(&[1.0, 2.0, 3.0])]), CellError::Ref);
+}
+
+// #2177: one predictor row of 16,384 columns built three 16,384² matrices (6 GB) and an O(k³)
+// inversion; a wider TOROW aborted the process. It is now refused before allocating.
+#[test]
+fn linest_family_caps_regressor_count() {
+    let wide = |k: usize| av(arr(vec![(0..k).map(|i| nv(i as f64)).collect()]));
+    let tall = |k: usize| av(arr((0..k).map(|i| vec![nv(i as f64), nv(1.0)]).collect()));
+    for f in ["LINEST", "LOGEST", "TREND", "GROWTH"] {
+        // y is one cell, so every column of x is a predictor.
+        is_err(ev(f, vec![n(1.0), wide(16_384)]), CellError::Value);
+        // y is a row, so every row of x is a predictor.
+        is_err(ev(f, vec![av(arr(vec![vec![nv(1.0), nv(2.0)]])), tall(16_384)]), CellError::Value);
+    }
+    is_err(ev("LINEST", vec![n(1.0), wide(MAX_REGRESSORS + 1)]), CellError::Value);
+    // At the cap the fit still runs (one observation: coefficients are zero, not an error).
+    assert_eq!(rows_of(&ev("LINEST", vec![n(1.0), wide(MAX_REGRESSORS)]))[0].len(), MAX_REGRESSORS + 1);
+    // The rows × k² work bound.
+    assert_eq!(check_regression_size(1_000, MAX_REGRESSORS), Ok(()));
+    assert_eq!(check_regression_size(1_000_000, 100), Err(CellError::Num));
+    assert_eq!(check_regression_size(usize::MAX, 2), Err(CellError::Num));
+    assert_eq!(check_regression_size(10_000_000, 1), Ok(()));
+}
+
+#[test]
+fn frequency_prob() {
+    let f = ev("FREQUENCY", vec![c(&[79.0, 85.0, 78.0, 85.0, 50.0, 81.0, 95.0, 88.0, 97.0]), c(&[70.0, 79.0, 89.0])]);
+    assert_eq!(rows_of(&f), vec![vec![nv(1.0)], vec![nv(2.0)], vec![nv(4.0)], vec![nv(2.0)]]);
+    let x = c(&[0.0, 1.0, 2.0, 3.0]);
+    let p = c(&[0.2, 0.3, 0.1, 0.4]);
+    close(ev("PROB", vec![x.clone(), p.clone(), n(2.0)]), 0.1);
+    close(ev("PROB", vec![x.clone(), p, n(1.0), n(3.0)]), 0.8);
+    is_err(ev("PROB", vec![x.clone(), c(&[0.5, 0.5, 0.5, 0.5]), n(1.0)]), CellError::Num);
+    // Excel: any probability <= 0 is #NUM!, even when it sums to one and lies outside the limits.
+    is_err(ev("PROB", vec![x.clone(), c(&[0.5, 0.0, 0.25, 0.25]), n(0.0), n(3.0)]), CellError::Num);
+    is_err(ev("PROB", vec![x, c(&[0.5, 0.0, 0.25, 0.25]), n(2.0), n(3.0)]), CellError::Num);
+}
+
+#[test]
+fn normal() {
+    close_tol(ev("NORM.DIST", vec![n(42.0), n(40.0), n(1.5), b(true)]), 0.9087888, D7);
+    close_tol(ev("NORM.DIST", vec![n(42.0), n(40.0), n(1.5), b(false)]), 0.10934005, D7);
+    close_tol(ev("NORMDIST", vec![n(42.0), n(40.0), n(1.5), b(true)]), 0.9087888, D7);
+    is_err(ev("NORM.DIST", vec![n(42.0), n(40.0), n(0.0), b(true)]), CellError::Num);
+    close_tol(ev("NORM.INV", vec![n(0.908789), n(40.0), n(1.5)]), 42.000002, D7);
+    close_tol(ev("NORMINV", vec![n(0.908789), n(40.0), n(1.5)]), 42.000002, D7);
+    is_err(ev("NORM.INV", vec![n(1.0), n(0.0), n(1.0)]), CellError::Num);
+    close_tol(ev("NORM.S.DIST", vec![n(1.333333), b(true)]), 0.908788726, 1e-8);
+    close_tol(ev("NORM.S.DIST", vec![n(0.0), b(false)]), 0.398942280, 1e-8);
+    close_tol(ev("NORMSDIST", vec![n(1.333333)]), 0.908788726, 1e-8);
+    close_tol(ev("NORM.S.INV", vec![n(0.908789)]), 1.3333347, D7);
+    close_tol(ev("NORMSINV", vec![n(0.975)]), 1.959963985, 1e-9);
+    close_tol(ev("PHI", vec![n(0.75)]), 0.301137432, 1e-8);
+    close_tol(ev("GAUSS", vec![n(2.0)]), 0.477249868, 1e-8);
+    close_tol(ev("FISHER", vec![n(0.75)]), 0.972955075, 1e-8);
+    close_tol(ev("FISHERINV", vec![n(0.972955)]), 0.75, D7);
+    is_err(ev("FISHER", vec![n(1.0)]), CellError::Num);
+    close_tol(ev("CONFIDENCE.NORM", vec![n(0.05), n(2.5), n(50.0)]), 0.692951912, 1e-8);
+    close_tol(ev("CONFIDENCE", vec![n(0.05), n(2.5), n(50.0)]), 0.692951912, 1e-8);
+    close_tol(ev("CONFIDENCE.T", vec![n(0.05), n(1.0), n(50.0)]), 0.284196855, 1e-8);
+    is_err(ev("CONFIDENCE.T", vec![n(0.05), n(1.0), n(1.0)]), CellError::Div0);
+    let z = c(&[3.0, 6.0, 7.0, 8.0, 6.0, 5.0, 4.0, 2.0, 1.0, 9.0]);
+    close_tol(ev("Z.TEST", vec![z.clone(), n(4.0)]), 0.090574, 1e-5);
+    close_tol(ev("ZTEST", vec![z, n(6.0)]), 0.863043, 1e-5);
+    close_tol(ev("LOGNORM.DIST", vec![n(4.0), n(3.5), n(1.2), b(true)]), 0.0390836, D7);
+    close_tol(ev("LOGNORM.DIST", vec![n(4.0), n(3.5), n(1.2), b(false)]), 0.0176176, D7);
+    close_tol(ev("LOGNORMDIST", vec![n(4.0), n(3.5), n(1.2)]), 0.0390836, D7);
+    close_tol(ev("LOGNORM.INV", vec![n(0.039084), n(3.5), n(1.2)]), 4.0000252, D7);
+    close_tol(ev("LOGINV", vec![n(0.039084), n(3.5), n(1.2)]), 4.0000252, D7);
+}
+
+#[test]
+fn t_chi_f() {
+    close_tol(ev("T.DIST", vec![n(60.0), n(1.0), b(true)]), 0.99469533, D7);
+    close_tol(ev("T.DIST", vec![n(8.0), n(3.0), b(false)]), 0.00073691, 1e-5);
+    close_tol(ev("T.DIST.2T", vec![n(1.959999998), n(60.0)]), 0.054644930, D7);
+    close_tol(ev("T.DIST.RT", vec![n(1.959999998), n(60.0)]), 0.027322465, D7);
+    close_tol(ev("TDIST", vec![n(1.959999998), n(60.0), n(2.0)]), 0.054644930, D7);
+    is_err(ev("TDIST", vec![n(-1.0), n(60.0), n(2.0)]), CellError::Num);
+    is_err(ev("T.DIST", vec![n(1.0), n(0.0), b(true)]), CellError::Num);
+    close_tol(ev("T.INV", vec![n(0.75), n(2.0)]), 0.8164966, D7);
+    close_tol(ev("T.INV", vec![n(0.25), n(2.0)]), -0.8164966, D7);
+    close_tol(ev("T.INV.2T", vec![n(0.546449), n(60.0)]), 0.606533, D7);
+    close_tol(ev("T.INV.2T", vec![n(0.05), n(10.0)]), 2.228138852, 1e-9);
+    close_tol(ev("TINV", vec![n(0.05), n(10.0)]), 2.228138852, 1e-9);
+    let a1 = c(&[3.0, 4.0, 5.0, 8.0, 9.0, 1.0, 2.0, 4.0, 5.0]);
+    let a2 = c(&[6.0, 19.0, 3.0, 2.0, 14.0, 4.0, 5.0, 17.0, 1.0]);
+    close_tol(ev("T.TEST", vec![a1.clone(), a2.clone(), n(2.0), n(1.0)]), 0.196016, 1e-5);
+    close_tol(ev("TTEST", vec![a1.clone(), a2.clone(), n(2.0), n(1.0)]), 0.196016, 1e-5);
+    close_tol(ev("T.TEST", vec![a1.clone(), a2.clone(), n(2.0), n(2.0)]), 0.191995887, 1e-6);
+    close_tol(ev("T.TEST", vec![a1.clone(), a2.clone(), n(1.0), n(3.0)]), 0.1012, 1e-3);
+    is_err(ev("T.TEST", vec![a1, a2, n(3.0), n(1.0)]), CellError::Num);
+    close_tol(ev("CHISQ.DIST", vec![n(0.5), n(1.0), b(true)]), 0.52049988, D7);
+    close_tol(ev("CHISQ.DIST", vec![n(2.0), n(3.0), b(false)]), 0.20755375, D7);
+    close_tol(ev("CHISQ.DIST.RT", vec![n(18.307), n(10.0)]), 0.0500006, 1e-5);
+    close_tol(ev("CHIDIST", vec![n(18.307), n(10.0)]), 0.0500006, 1e-5);
+    close_tol(ev("CHISQ.INV", vec![n(0.93), n(1.0)]), 3.283020287, 1e-8);
+    close_tol(ev("CHISQ.INV", vec![n(0.6), n(2.0)]), 1.832581464, 1e-8);
+    close_tol(ev("CHISQ.INV.RT", vec![n(0.050001), n(10.0)]), 18.30697, D7);
+    close_tol(ev("CHIINV", vec![n(0.050001), n(10.0)]), 18.30697, D7);
+    is_err(ev("CHISQ.DIST", vec![n(-1.0), n(1.0), b(true)]), CellError::Num);
+    let act = arr(vec![vec![nv(58.0), nv(35.0)], vec![nv(11.0), nv(25.0)], vec![nv(10.0), nv(23.0)]]);
+    let exp = arr(vec![vec![nv(45.35), nv(47.65)], vec![nv(17.56), nv(18.44)], vec![nv(16.09), nv(16.91)]]);
+    close_tol(ev("CHISQ.TEST", vec![av(act.clone()), av(exp.clone())]), 0.0003082, 1e-3);
+    close_tol(ev("CHITEST", vec![av(act), av(exp)]), 0.0003082, 1e-3);
+    close_tol(ev("F.DIST", vec![n(15.2069), n(6.0), n(4.0), b(true)]), 0.99, 1e-6);
+    close_tol(ev("F.DIST", vec![n(15.2069), n(6.0), n(4.0), b(false)]), 0.0012238, 1e-5);
+    close_tol(ev("F.DIST.RT", vec![n(15.2069), n(6.0), n(4.0)]), 0.01, 1e-6);
+    close_tol(ev("FDIST", vec![n(15.2069), n(6.0), n(4.0)]), 0.01, 1e-6);
+    close_tol(ev("F.INV", vec![n(0.01), n(6.0), n(4.0)]), 0.10930991, D7);
+    close_tol(ev("F.INV.RT", vec![n(0.01), n(6.0), n(4.0)]), 15.20686, D7);
+    close_tol(ev("FINV", vec![n(0.01), n(6.0), n(4.0)]), 15.20686, D7);
+    close_tol(ev("F.TEST", vec![c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 0.64831785, D7);
+    close_tol(ev("FTEST", vec![c(&[6.0, 7.0, 9.0, 15.0, 21.0]), c(&[20.0, 28.0, 31.0, 38.0, 40.0])]), 0.64831785, D7);
+    is_err(ev("F.DIST", vec![n(1.0), n(0.0), n(4.0), b(true)]), CellError::Num);
+}
+
+#[test]
+fn binom_inv_huge_trials_returns() {
+    // Above 2^53 neighbouring f64 values are more than 1 apart; the bisection must still end.
+    let cases: [(&str, f64, f64, f64); 3] = [("BINOM.INV", 1e17, 0.5, 0.5), ("CRITBINOM", 1e300, 1.0, 0.5), ("BINOM.INV", 1e300, 0.5, 0.5)];
+    for (name, trials, p, alpha) in cases {
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            let r = ev(name, vec![n(trials), n(p), n(alpha)]);
+            let _ = tx.send(r);
+        });
+        match rx.recv_timeout(std::time::Duration::from_secs(5)) {
+            Ok(Value::Number(_)) | Ok(Value::Error(CellError::Num)) => {}
+            Ok(other) => panic!("{name}({trials},{p},{alpha}) returned {other:?}"),
+            Err(_) => panic!("{name}({trials},{p},{alpha}) did not return within 5 s"),
+        }
+    }
+}
+
+#[test]
+fn discrete() {
+    close_tol(ev("BINOM.DIST", vec![n(6.0), n(10.0), n(0.5), b(false)]), 0.205078125, 1e-12);
+    close_tol(ev("BINOM.DIST", vec![n(6.0), n(10.0), n(0.5), b(true)]), 0.828125, 1e-12);
+    close_tol(ev("BINOMDIST", vec![n(6.0), n(10.0), n(0.5), b(false)]), 0.205078125, 1e-12);
+    is_err(ev("BINOM.DIST", vec![n(11.0), n(10.0), n(0.5), b(false)]), CellError::Num);
+    close_tol(ev("BINOM.DIST.RANGE", vec![n(60.0), n(0.75), n(48.0)]), 0.083974967, 1e-6);
+    close_tol(ev("BINOM.DIST.RANGE", vec![n(60.0), n(0.75), n(45.0), n(50.0)]), 0.523629793, 1e-6);
+    close(ev("BINOM.INV", vec![n(6.0), n(0.5), n(0.75)]), 4.0);
+    close(ev("CRITBINOM", vec![n(6.0), n(0.5), n(0.75)]), 4.0);
+    close(ev("BINOM.INV", vec![n(1e9), n(0.5), n(0.5)]), 5e8);
+    close_tol(ev("POISSON.DIST", vec![n(2.0), n(5.0), b(true)]), 0.124652, 1e-5);
+    close_tol(ev("POISSON.DIST", vec![n(2.0), n(5.0), b(false)]), 0.084224, 1e-5);
+    close_tol(ev("POISSON", vec![n(2.0), n(5.0), b(false)]), 0.084224, 1e-5);
+    is_err(ev("POISSON.DIST", vec![n(-1.0), n(5.0), b(false)]), CellError::Num);
+    close_tol(ev("HYPGEOM.DIST", vec![n(1.0), n(4.0), n(8.0), n(20.0), b(true)]), 0.4654, 1e-4);
+    close_tol(ev("HYPGEOM.DIST", vec![n(1.0), n(4.0), n(8.0), n(20.0), b(false)]), 0.3633, 1e-4);
+    close_tol(ev("HYPGEOMDIST", vec![n(1.0), n(4.0), n(8.0), n(20.0)]), 0.363261094, 1e-8);
+    is_err(ev("HYPGEOMDIST", vec![n(5.0), n(4.0), n(8.0), n(20.0)]), CellError::Num);
+    close_tol(ev("NEGBINOM.DIST", vec![n(10.0), n(5.0), n(0.25), b(true)]), 0.3135141, D7);
+    close_tol(ev("NEGBINOM.DIST", vec![n(10.0), n(5.0), n(0.25), b(false)]), 0.0550487, D7);
+    close_tol(ev("NEGBINOMDIST", vec![n(10.0), n(5.0), n(0.25)]), 0.0550487, D7);
+}
+
+#[test]
+fn continuous() {
+    close_tol(ev("EXPON.DIST", vec![n(0.2), n(10.0), b(true)]), 0.86466472, D7);
+    close_tol(ev("EXPON.DIST", vec![n(0.2), n(10.0), b(false)]), 1.35335283, D7);
+    close_tol(ev("EXPONDIST", vec![n(0.2), n(10.0), b(true)]), 0.86466472, D7);
+    is_err(ev("EXPON.DIST", vec![n(0.2), n(0.0), b(true)]), CellError::Num);
+    close_tol(ev("GAMMA.DIST", vec![n(10.00001131), n(9.0), n(2.0), b(false)]), 0.032639, 1e-5);
+    close_tol(ev("GAMMA.DIST", vec![n(10.00001131), n(9.0), n(2.0), b(true)]), 0.068094, 1e-5);
+    close_tol(ev("GAMMADIST", vec![n(10.00001131), n(9.0), n(2.0), b(true)]), 0.068094, 1e-5);
+    close_tol(ev("GAMMA.INV", vec![n(0.068094), n(9.0), n(2.0)]), 10.0000112, 1e-6);
+    close_tol(ev("GAMMAINV", vec![n(0.068094), n(9.0), n(2.0)]), 10.0000112, 1e-6);
+    close_tol(ev("GAMMALN", vec![n(4.0)]), 1.791759469, 1e-9);
+    close_tol(ev("GAMMALN.PRECISE", vec![n(4.5)]), 2.453736571, 1e-9);
+    is_err(ev("GAMMALN", vec![n(0.0)]), CellError::Num);
+    close_tol(ev("GAMMA", vec![n(2.5)]), 1.329340388, 1e-9);
+    close_tol(ev("GAMMA", vec![n(-0.75)]), -4.834146544, 1e-8);
+    is_err(ev("GAMMA", vec![n(-1.0)]), CellError::Num);
+    is_err(ev("GAMMA", vec![n(0.0)]), CellError::Num);
+    close_tol(ev("BETA.DIST", vec![n(2.0), n(8.0), n(10.0), b(true), n(1.0), n(3.0)]), 0.6854706, D7);
+    close_tol(ev("BETA.DIST", vec![n(2.0), n(8.0), n(10.0), b(false), n(1.0), n(3.0)]), 1.4837646, D7);
+    close_tol(ev("BETADIST", vec![n(2.0), n(8.0), n(10.0), n(1.0), n(3.0)]), 0.6854706, D7);
+    close_tol(ev("BETA.INV", vec![n(0.685470581), n(8.0), n(10.0), n(1.0), n(3.0)]), 2.0, D7);
+    close_tol(ev("BETAINV", vec![n(0.685470581), n(8.0), n(10.0), n(1.0), n(3.0)]), 2.0, D7);
+    is_err(ev("BETA.DIST", vec![n(4.0), n(8.0), n(10.0), b(true), n(1.0), n(3.0)]), CellError::Num);
+    close_tol(ev("WEIBULL.DIST", vec![n(105.0), n(20.0), n(100.0), b(true)]), 0.929581, 1e-5);
+    close_tol(ev("WEIBULL.DIST", vec![n(105.0), n(20.0), n(100.0), b(false)]), 0.035589, 1e-4);
+    close_tol(ev("WEIBULL", vec![n(105.0), n(20.0), n(100.0), b(true)]), 0.929581, 1e-5);
+    // Lifting over an array of x values.
+    let r = rows_of(&ev("NORM.S.DIST", vec![av(row(&[0.0, 1.0])), b(true)]));
+    close(r[0][0].clone(), 0.5);
+    close_tol(r[0][1].clone(), 0.841344746, 1e-8);
+}
+
+#[test]
+fn aggregate_helper() {
+    let vals = vec![nv(1.0), nv(2.0), tv("x"), Value::Empty, Value::Bool(true), nv(6.0)];
+    close(aggregate_values(1, &vals), 3.0);
+    close(aggregate_values(2, &vals), 3.0);
+    close(aggregate_values(3, &vals), 5.0);
+    close(aggregate_values(4, &vals), 6.0);
+    close(aggregate_values(105, &vals), 1.0);
+    close(aggregate_values(6, &vals), 12.0);
+    close(aggregate_values(9, &vals), 9.0);
+    close(aggregate_values(109, &vals), 9.0);
+    close(aggregate_values(11, &vals), 14.0 / 3.0);
+    close(aggregate_values(10, &vals), 7.0);
+    close(aggregate_values(12, &vals), 2.0);
+    is_err(aggregate_values(13, &vals), CellError::NA);
+    is_err(aggregate_values(14, &vals), CellError::Value);
+    is_err(aggregate_values(99, &vals), CellError::Value);
+    is_err(aggregate_values(9, &[nv(1.0), Value::Error(CellError::Div0)]), CellError::Div0);
+    close(aggregate_values_k(14, &vals, &nv(1.0)), 6.0);
+    close(aggregate_values_k(15, &vals, &nv(2.0)), 2.0);
+    close(aggregate_values_k(16, &vals, &nv(0.5)), 2.0);
+    close(aggregate_values_k(17, &vals, &nv(4.0)), 6.0);
+    close(aggregate_values_k(18, &vals, &nv(0.5)), 2.0);
+    close(aggregate_values_k(19, &vals, &nv(2.0)), 2.0);
+    close(aggregate_values_k(9, &vals, &nv(2.0)), 9.0);
+    is_err(aggregate_values_k(14, &vals, &nv(10.0)), CellError::Num);
+}

From 3ec086c1bdf83b893b34401774904ca4f9a90dae Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:44 +0000
Subject: [PATCH 36/76] refactor(ui-egui): move code_editor tests to
 src/code_editor/tests.rs

---
 crates/ui-egui/src/code_editor.rs       | 375 +-----------------------
 crates/ui-egui/src/code_editor/tests.rs | 372 +++++++++++++++++++++++
 2 files changed, 373 insertions(+), 374 deletions(-)
 create mode 100644 crates/ui-egui/src/code_editor/tests.rs

diff --git a/crates/ui-egui/src/code_editor.rs b/crates/ui-egui/src/code_editor.rs
index e462e46ef..ee65b7ec8 100644
--- a/crates/ui-egui/src/code_editor.rs
+++ b/crates/ui-egui/src/code_editor.rs
@@ -570,377 +570,4 @@ pub fn code_editor(ui: &mut Ui, id: egui::Id, text: &mut String, lang: Lang, max
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use egui::Modifiers;
-
-    fn spans(text: &str, lang: Lang) -> Vec<(&str, Token)> {
-        highlight(text, lang).into_iter().map(|(r, k)| (text.get(r).unwrap_or("?"), k)).collect()
-    }
-
-    #[test]
-    fn python_tokens() {
-        let s = spans("def f(x):\n    return len(x) + 1.5  # done\nxl(\"A1:B2\")", Lang::Python);
-        assert_eq!(
-            s,
-            vec![
-                ("def", Token::Keyword),
-                ("return", Token::Keyword),
-                ("len", Token::Builtin),
-                ("1.5", Token::Number),
-                ("# done", Token::Comment),
-                ("xl", Token::Builtin),
-                ("\"A1:B2\"", Token::String),
-            ]
-        );
-        assert_eq!(spans("s = '''a\n'b'\nc'''", Lang::Python), vec![("'''a\n'b'\nc'''", Token::String)]);
-        assert_eq!(spans("x = 'it\\'s'", Lang::Python), vec![("'it\\'s'", Token::String)]);
-        assert_eq!(spans("hello", Lang::Plain), vec![]);
-    }
-
-    #[test]
-    fn latex_tokens() {
-        let s = spans("\\frac{a^2}{3} % half\n\\{", Lang::Latex);
-        assert_eq!(
-            s,
-            vec![
-                ("\\frac", Token::Keyword),
-                ("^", Token::Builtin),
-                ("2", Token::Number),
-                ("3", Token::Number),
-                ("% half", Token::Comment),
-                ("\\{", Token::Keyword),
-            ]
-        );
-    }
-
-    #[test]
-    fn hostile_input_never_panics_and_spans_stay_on_char_boundaries() {
-        let inputs = [
-            "",
-            "'",
-            "\"",
-            "'''",
-            "\"\"\"x",
-            "#",
-            "\\",
-            "%",
-            "1",
-            ".",
-            "é'ü\\",
-            "θ = 'π' # ∑",
-            "\u{1F600}'\u{1F600}",
-            "'\\",
-            "\\\u{1F600}",
-            "\u{200B}\n\t'''\n",
-            "0x_é",
-            "a.b.c",
-            "____",
-        ];
-        for text in inputs {
-            for lang in [Lang::Python, Lang::Latex, Lang::Plain] {
-                let mut last = 0;
-                for (r, _) in highlight(text, lang) {
-                    assert!(r.start >= last && r.start <= r.end && r.end <= text.len(), "{text:?} {lang:?} {r:?}");
-                    assert!(text.is_char_boundary(r.start) && text.is_char_boundary(r.end), "{text:?} {lang:?} {r:?}");
-                    last = r.end;
-                }
-                let job = layout_job(text, lang, &FontId::default(), egui::Color32::BLACK, &Tokens::light().syntax, f32::INFINITY);
-                assert_eq!(job.text, text, "every character is laid out once");
-            }
-        }
-    }
-
-    #[test]
-    fn enter_keeps_indentation_and_indents_after_a_colon() {
-        let mut s = "    x = 1".to_string();
-        let e = newline(&mut s, (9, 9), Lang::Python);
-        assert_eq!(s, "    x = 1\n    ");
-        assert_eq!(e.caret, 14);
-        let mut s = "if x:".to_string();
-        let e = newline(&mut s, (5, 5), Lang::Python);
-        assert_eq!(s, "if x:\n    ");
-        assert_eq!(e.caret, 10);
-        // Plain text keeps the indentation but adds none after a colon.
-        let mut s = "  a:".to_string();
-        newline(&mut s, (4, 4), Lang::Plain);
-        assert_eq!(s, "  a:\n  ");
-        // A selection is replaced; out-of-range carets are clamped.
-        let mut s = "abcdef".to_string();
-        let e = newline(&mut s, (4, 2), Lang::Plain);
-        assert_eq!((s.as_str(), e.caret), ("ab\nef", 3));
-        let mut s = "é".to_string();
-        let e = newline(&mut s, (99, 99), Lang::Plain);
-        assert_eq!((s.as_str(), e.caret), ("é\n", 2));
-    }
-
-    #[test]
-    /// Shift+Tab removes four leading spaces, while a plain Tab still inserts four spaces at the caret.
-    fn shift_tab_in_the_editor_dedents_rather_than_indents() {
-        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
-            |ui, text: &mut String| {
-                if ui.ctx().cumulative_pass_nr() == 0 {
-                    ui.ctx().set_fonts(theme::pinned_font_definitions());
-                    return;
-                }
-                let id = egui::Id::unique("code");
-                ui.memory_mut(|m| m.request_focus(id));
-                code_editor(ui, id, text, Lang::Python, 5);
-            },
-            "        x".to_string(),
-        );
-        h.run_steps(2);
-        let tab = |modifiers| egui::Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers };
-        h.input_mut().events.push(tab(Modifiers::SHIFT));
-        h.run_steps(1);
-        assert_eq!(h.state(), "    x");
-        // A plain Tab still inserts spaces at the caret (the end).
-        h.input_mut().events.push(tab(Modifiers::NONE));
-        h.run_steps(1);
-        assert_eq!(h.state(), "    x    ");
-    }
-
-    /// Gives the context the deterministic font set, including the editor's monospace family.
-    fn install_mono(ctx: &egui::Context) {
-        ctx.set_fonts(theme::pinned_font_definitions());
-    }
-
-    /// Builds a 400x300 code-editor harness with pinned mono fonts, focus, two passes and an accessibility check.
-    fn editor_harness(text: &str) -> egui_kittest::Harness<'static, String> {
-        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
-            |ui, text: &mut String| {
-                if ui.ctx().cumulative_pass_nr() == 0 {
-                    install_mono(ui.ctx());
-                    return;
-                }
-                let id = egui::Id::unique("code");
-                ui.memory_mut(|m| m.request_focus(id));
-                code_editor(ui, id, text, Lang::Python, 5);
-            },
-            text.to_string(),
-        );
-        h.run_steps(2);
-        h.check_accessibility();
-        h
-    }
-
-    fn key(key: Key, modifiers: Modifiers) -> egui::Event {
-        egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }
-    }
-
-    #[test]
-    fn batched_input_applies_in_order_and_keeps_every_key() {
-        // Events gather between repaints (typing, key repeat). The text typed before an Enter
-        // comes first, and two Enters make two lines.
-        let mut h = editor_harness("");
-        h.input_mut().events.extend([egui::Event::Text("if x:".into()), key(Key::Enter, Modifiers::NONE), key(Key::Enter, Modifiers::NONE)]);
-        h.run_steps(1);
-        assert_eq!(h.state(), "if x:\n    \n    ");
-        // Backspace and Tab in the same frame as the typing around them.
-        h.input_mut().events.extend([
-            egui::Event::Text("y = 1".into()),
-            key(Key::Backspace, Modifiers::NONE),
-            egui::Event::Text("2".into()),
-            key(Key::Tab, Modifiers::NONE),
-        ]);
-        h.run_steps(1);
-        assert_eq!(h.state(), "if x:\n    \n    y = 2    ");
-        // An event the field acts on (an arrow) keeps the order too: the text typed before it
-        // is applied first, the field moves the caret, and the Enter after it waits for the
-        // next pass, where the editor applies it at the moved caret, with the indentation.
-        h.input_mut().events.extend([egui::Event::Text("a".into()), key(Key::ArrowLeft, Modifiers::NONE), key(Key::Enter, Modifiers::NONE)]);
-        h.run_steps(1);
-        assert_eq!(h.state(), "if x:\n    \n    y = 2    a", "the Enter waits for the arrow");
-        h.run_steps(1);
-        assert_eq!(h.state(), "if x:\n    \n    y = 2    \n    a");
-    }
-
-    #[test]
-    fn a_selection_ending_at_a_line_start_leaves_that_line_alone() {
-        // Selecting "a\n" in "a\nb" ends at the start of the second line, which is not selected.
-        let mut s = "a\nb".to_string();
-        indent(&mut s, (0, 2), false);
-        assert_eq!(s, "    a\nb");
-        let mut s = "    a\n    b".to_string();
-        indent(&mut s, (0, 6), true);
-        assert_eq!(s, "a\n    b");
-        // One character into the second line, both lines are touched.
-        let mut s = "a\nb".to_string();
-        indent(&mut s, (0, 3), false);
-        assert_eq!(s, "    a\n    b");
-    }
-
-    #[test]
-    fn typed_text_and_deletions_replace_the_selection() {
-        let mut s = "abcd".to_string();
-        assert_eq!(insert(&mut s, (3, 1), "X"), Edit { anchor: 2, caret: 2 });
-        assert_eq!(s, "aXd");
-        assert_eq!(delete(&mut s, (2, 2), true), Edit { anchor: 1, caret: 1 });
-        assert_eq!(s, "ad");
-        assert_eq!(delete(&mut s, (1, 1), false), Edit { anchor: 1, caret: 1 });
-        assert_eq!(s, "a");
-        assert_eq!(delete(&mut s, (0, 0), true), Edit { anchor: 0, caret: 0 });
-        assert_eq!(delete(&mut s, (9, 9), false), Edit { anchor: 1, caret: 1 });
-        assert_eq!(s, "a");
-        let mut s = "éa".to_string();
-        delete(&mut s, (2, 0), true);
-        assert_eq!(s, "");
-        // The queue keeps what the editor does not handle, and everything after it.
-        let mut events = vec![
-            egui::Event::Text("x".into()),
-            egui::Event::Text("\n".into()),
-            key(Key::ArrowLeft, Modifiers::NONE),
-            key(Key::Enter, Modifiers::NONE),
-        ];
-        let (mut s, mut sel) = (String::new(), (0, 0));
-        let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
-        assert!(out.edited);
-        assert_eq!((s.as_str(), sel), ("x", (1, 1)));
-        assert_eq!(events.len(), 2, "the lone newline and the arrow stay for the field: {events:?}");
-        assert_eq!(out.held, vec![key(Key::Enter, Modifiers::NONE)], "the Enter after the arrow waits for the next pass");
-        let mut events = vec![egui::Event::Key { key: Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }];
-        let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
-        assert!(!out.edited && out.held.is_empty(), "a key release is nothing to apply");
-        assert_eq!(events.len(), 1);
-    }
-
-    #[test]
-    fn select_all_then_tab_in_one_pass_indents_every_line() {
-        // Cmd+A is the field's, Tab the editor's: the Tab waits for the pass after the
-        // selection and indents the selected lines, rather than reaching the field, which would
-        // replace the selection with a tab character.
-        let mut h = editor_harness("a\nb");
-        h.input_mut().events.extend([key(Key::A, Modifiers::COMMAND), key(Key::Tab, Modifiers::NONE)]);
-        h.run_steps(1);
-        assert_eq!(h.state(), "a\nb", "the Tab waits for the selection");
-        h.run_steps(1);
-        assert_eq!(h.state(), "    a\n    b");
-        h.input_mut().events.extend([key(Key::A, Modifiers::COMMAND), key(Key::Tab, Modifiers::SHIFT)]);
-        h.run_steps(2);
-        assert_eq!(h.state(), "a\nb");
-    }
-
-    #[test]
-    fn a_keystroke_sequence_as_the_platform_sends_it_keeps_the_editors_enter() {
-        // egui-winit sends a Key event before each Text event. Those presses are nobody's to
-        // read, so they do not hand the Enter to the field, which knows no indentation.
-        let mut h = editor_harness("");
-        let typed = |k, c: &str, m| [key(k, m), egui::Event::Text(c.into())];
-        let mut events = Vec::new();
-        events.extend(typed(Key::I, "i", Modifiers::NONE));
-        events.extend(typed(Key::F, "f", Modifiers::NONE));
-        events.extend(typed(Key::Space, " ", Modifiers::NONE));
-        events.extend(typed(Key::X, "x", Modifiers::NONE));
-        events.extend(typed(Key::Colon, ":", Modifiers::SHIFT));
-        events.push(key(Key::Enter, Modifiers::NONE));
-        h.input_mut().events.extend(events);
-        h.run_steps(1);
-        assert_eq!(h.state(), "if x:\n    ");
-        // A character typed with Option (macOS) comes as a key under that modifier and its text;
-        // the field reads neither the key nor Option, so the Enter after it is still the editor's.
-        h.input_mut().events.extend([key(Key::E, Modifiers::ALT), egui::Event::Text("\u{e9}".into()), key(Key::Enter, Modifiers::NONE)]);
-        h.run_steps(1);
-        assert_eq!(h.state(), "if x:\n    \u{e9}\n    ");
-    }
-
-    #[test]
-    fn tab_and_enter_under_modifiers_never_reach_the_field() {
-        // The field would make a tab character of Ctrl+Tab (in place of the selection) and a
-        // newline of Shift+Enter; Cmd+Enter is nobody's here and stays for a shortcut.
-        let mut events = vec![key(Key::Tab, Modifiers::CTRL), key(Key::Enter, Modifiers::SHIFT), key(Key::Enter, Modifiers::COMMAND)];
-        let (mut s, mut sel) = ("if x:".to_string(), (5, 5));
-        let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
-        assert_eq!(s, "if x:\n    ");
-        assert_eq!(events, vec![key(Key::Enter, Modifiers::COMMAND)]);
-        assert!(out.held.is_empty());
-    }
-
-    #[test]
-    fn events_after_a_held_key_wait_with_it_and_pointer_events_do_not() {
-        let mut events = vec![
-            key(Key::X, Modifiers::NONE),
-            egui::Event::Text("x".into()),
-            key(Key::A, Modifiers::COMMAND),
-            key(Key::Tab, Modifiers::NONE),
-            egui::Event::PointerMoved(egui::Pos2::ZERO),
-            key(Key::ArrowLeft, Modifiers::NONE),
-            egui::Event::Text("y".into()),
-        ];
-        let (mut s, mut sel) = (String::new(), (0, 0));
-        let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
-        assert_eq!((s.as_str(), sel), ("x", (1, 1)), "the typing before the select-all is applied");
-        assert_eq!(events, vec![key(Key::X, Modifiers::NONE), key(Key::A, Modifiers::COMMAND), egui::Event::PointerMoved(egui::Pos2::ZERO)]);
-        assert_eq!(out.held, vec![key(Key::Tab, Modifiers::NONE), key(Key::ArrowLeft, Modifiers::NONE), egui::Event::Text("y".into())]);
-    }
-
-    #[test]
-    /// Events held by the previous pass are applied once in the next pass; older held events are dropped and cleared.
-    fn held_back_events_land_in_the_next_pass_only() {
-        let mut h = editor_harness("");
-        let id = egui::Id::unique("code");
-        let held = |pass, c: &str| Held { pass, events: vec![egui::Event::Text(c.into())] };
-        // What the pass just completed held back comes in with the next one.
-        let last = h.ctx.cumulative_pass_nr() - 1;
-        h.ctx.data_mut(|d| d.insert_temp(held_id(id), held(last, "a")));
-        h.run_steps(1);
-        assert_eq!(h.state(), "a");
-        // Anything older is dropped rather than typed out of context, and cleared.
-        h.ctx.data_mut(|d| d.insert_temp(held_id(id), held(last, "b")));
-        h.run_steps(1);
-        assert_eq!(h.state(), "a");
-        assert!(h.ctx.data(|d| d.get_temp::<Held>(held_id(id))).is_none());
-    }
-
-    #[test]
-    /// Held keyboard input does not land in the next focused text field once the code editor has lost focus.
-    fn held_back_events_go_nowhere_once_the_editor_lost_the_focus() {
-        // Typed into the editor, they must not land in whatever has the focus next.
-        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
-            |ui, s: &mut (String, String, bool)| {
-                if ui.ctx().cumulative_pass_nr() == 0 {
-                    install_mono(ui.ctx());
-                    return;
-                }
-                let (code, other) = (egui::Id::unique("code"), egui::Id::unique("other"));
-                ui.memory_mut(|m| m.request_focus(if s.2 { code } else { other }));
-                code_editor(ui, code, &mut s.0, Lang::Python, 5);
-                ui.add(TextEdit::singleline(&mut s.1).id(other)).accessible_name("Other field");
-            },
-            (String::new(), String::new(), true),
-        );
-        h.run_steps(2);
-        h.input_mut().events.extend([key(Key::ArrowLeft, Modifiers::NONE), egui::Event::Text("x".into())]);
-        h.run_steps(1);
-        assert_eq!(h.state().0, "", "the x waits for the arrow");
-        h.state_mut().2 = false;
-        h.run_steps(2);
-        assert_eq!((h.state().0.as_str(), h.state().1.as_str()), ("", ""));
-    }
-
-    #[test]
-    /// A discard-triggered repeat pass receives held keys with the selection made by the first pass.
-    fn a_repeat_pass_of_the_frame_counts_as_the_next_pass() {
-        // When a widget asks egui to discard and repeat the pass, the repeat pass gets the
-        // held-back keys, with the selection the field made in the first pass.
-        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
-            |ui, s: &mut (String, bool)| {
-                if ui.ctx().cumulative_pass_nr() == 0 {
-                    install_mono(ui.ctx());
-                    return;
-                }
-                let id = egui::Id::unique("code");
-                ui.memory_mut(|m| m.request_focus(id));
-                code_editor(ui, id, &mut s.0, Lang::Python, 5);
-                if std::mem::take(&mut s.1) {
-                    ui.ctx().request_discard("the test repeats this pass");
-                }
-            },
-            ("a\nb".to_string(), false),
-        );
-        h.run_steps(2);
-        h.state_mut().1 = true;
-        h.input_mut().events.extend([key(Key::A, Modifiers::COMMAND), key(Key::Tab, Modifiers::NONE)]);
-        h.run_steps(1);
-        assert_eq!(h.state().0, "    a\n    b");
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/code_editor/tests.rs b/crates/ui-egui/src/code_editor/tests.rs
new file mode 100644
index 000000000..1bfcab75c
--- /dev/null
+++ b/crates/ui-egui/src/code_editor/tests.rs
@@ -0,0 +1,372 @@
+use super::*;
+use egui::Modifiers;
+
+fn spans(text: &str, lang: Lang) -> Vec<(&str, Token)> {
+    highlight(text, lang).into_iter().map(|(r, k)| (text.get(r).unwrap_or("?"), k)).collect()
+}
+
+#[test]
+fn python_tokens() {
+    let s = spans("def f(x):\n    return len(x) + 1.5  # done\nxl(\"A1:B2\")", Lang::Python);
+    assert_eq!(
+        s,
+        vec![
+            ("def", Token::Keyword),
+            ("return", Token::Keyword),
+            ("len", Token::Builtin),
+            ("1.5", Token::Number),
+            ("# done", Token::Comment),
+            ("xl", Token::Builtin),
+            ("\"A1:B2\"", Token::String),
+        ]
+    );
+    assert_eq!(spans("s = '''a\n'b'\nc'''", Lang::Python), vec![("'''a\n'b'\nc'''", Token::String)]);
+    assert_eq!(spans("x = 'it\\'s'", Lang::Python), vec![("'it\\'s'", Token::String)]);
+    assert_eq!(spans("hello", Lang::Plain), vec![]);
+}
+
+#[test]
+fn latex_tokens() {
+    let s = spans("\\frac{a^2}{3} % half\n\\{", Lang::Latex);
+    assert_eq!(
+        s,
+        vec![
+            ("\\frac", Token::Keyword),
+            ("^", Token::Builtin),
+            ("2", Token::Number),
+            ("3", Token::Number),
+            ("% half", Token::Comment),
+            ("\\{", Token::Keyword),
+        ]
+    );
+}
+
+#[test]
+fn hostile_input_never_panics_and_spans_stay_on_char_boundaries() {
+    let inputs = [
+        "",
+        "'",
+        "\"",
+        "'''",
+        "\"\"\"x",
+        "#",
+        "\\",
+        "%",
+        "1",
+        ".",
+        "é'ü\\",
+        "θ = 'π' # ∑",
+        "\u{1F600}'\u{1F600}",
+        "'\\",
+        "\\\u{1F600}",
+        "\u{200B}\n\t'''\n",
+        "0x_é",
+        "a.b.c",
+        "____",
+    ];
+    for text in inputs {
+        for lang in [Lang::Python, Lang::Latex, Lang::Plain] {
+            let mut last = 0;
+            for (r, _) in highlight(text, lang) {
+                assert!(r.start >= last && r.start <= r.end && r.end <= text.len(), "{text:?} {lang:?} {r:?}");
+                assert!(text.is_char_boundary(r.start) && text.is_char_boundary(r.end), "{text:?} {lang:?} {r:?}");
+                last = r.end;
+            }
+            let job = layout_job(text, lang, &FontId::default(), egui::Color32::BLACK, &Tokens::light().syntax, f32::INFINITY);
+            assert_eq!(job.text, text, "every character is laid out once");
+        }
+    }
+}
+
+#[test]
+fn enter_keeps_indentation_and_indents_after_a_colon() {
+    let mut s = "    x = 1".to_string();
+    let e = newline(&mut s, (9, 9), Lang::Python);
+    assert_eq!(s, "    x = 1\n    ");
+    assert_eq!(e.caret, 14);
+    let mut s = "if x:".to_string();
+    let e = newline(&mut s, (5, 5), Lang::Python);
+    assert_eq!(s, "if x:\n    ");
+    assert_eq!(e.caret, 10);
+    // Plain text keeps the indentation but adds none after a colon.
+    let mut s = "  a:".to_string();
+    newline(&mut s, (4, 4), Lang::Plain);
+    assert_eq!(s, "  a:\n  ");
+    // A selection is replaced; out-of-range carets are clamped.
+    let mut s = "abcdef".to_string();
+    let e = newline(&mut s, (4, 2), Lang::Plain);
+    assert_eq!((s.as_str(), e.caret), ("ab\nef", 3));
+    let mut s = "é".to_string();
+    let e = newline(&mut s, (99, 99), Lang::Plain);
+    assert_eq!((s.as_str(), e.caret), ("é\n", 2));
+}
+
+#[test]
+/// Shift+Tab removes four leading spaces, while a plain Tab still inserts four spaces at the caret.
+fn shift_tab_in_the_editor_dedents_rather_than_indents() {
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
+        |ui, text: &mut String| {
+            if ui.ctx().cumulative_pass_nr() == 0 {
+                ui.ctx().set_fonts(theme::pinned_font_definitions());
+                return;
+            }
+            let id = egui::Id::unique("code");
+            ui.memory_mut(|m| m.request_focus(id));
+            code_editor(ui, id, text, Lang::Python, 5);
+        },
+        "        x".to_string(),
+    );
+    h.run_steps(2);
+    let tab = |modifiers| egui::Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers };
+    h.input_mut().events.push(tab(Modifiers::SHIFT));
+    h.run_steps(1);
+    assert_eq!(h.state(), "    x");
+    // A plain Tab still inserts spaces at the caret (the end).
+    h.input_mut().events.push(tab(Modifiers::NONE));
+    h.run_steps(1);
+    assert_eq!(h.state(), "    x    ");
+}
+
+/// Gives the context the deterministic font set, including the editor's monospace family.
+fn install_mono(ctx: &egui::Context) {
+    ctx.set_fonts(theme::pinned_font_definitions());
+}
+
+/// Builds a 400x300 code-editor harness with pinned mono fonts, focus, two passes and an accessibility check.
+fn editor_harness(text: &str) -> egui_kittest::Harness<'static, String> {
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
+        |ui, text: &mut String| {
+            if ui.ctx().cumulative_pass_nr() == 0 {
+                install_mono(ui.ctx());
+                return;
+            }
+            let id = egui::Id::unique("code");
+            ui.memory_mut(|m| m.request_focus(id));
+            code_editor(ui, id, text, Lang::Python, 5);
+        },
+        text.to_string(),
+    );
+    h.run_steps(2);
+    h.check_accessibility();
+    h
+}
+
+fn key(key: Key, modifiers: Modifiers) -> egui::Event {
+    egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }
+}
+
+#[test]
+fn batched_input_applies_in_order_and_keeps_every_key() {
+    // Events gather between repaints (typing, key repeat). The text typed before an Enter
+    // comes first, and two Enters make two lines.
+    let mut h = editor_harness("");
+    h.input_mut().events.extend([egui::Event::Text("if x:".into()), key(Key::Enter, Modifiers::NONE), key(Key::Enter, Modifiers::NONE)]);
+    h.run_steps(1);
+    assert_eq!(h.state(), "if x:\n    \n    ");
+    // Backspace and Tab in the same frame as the typing around them.
+    h.input_mut().events.extend([
+        egui::Event::Text("y = 1".into()),
+        key(Key::Backspace, Modifiers::NONE),
+        egui::Event::Text("2".into()),
+        key(Key::Tab, Modifiers::NONE),
+    ]);
+    h.run_steps(1);
+    assert_eq!(h.state(), "if x:\n    \n    y = 2    ");
+    // An event the field acts on (an arrow) keeps the order too: the text typed before it
+    // is applied first, the field moves the caret, and the Enter after it waits for the
+    // next pass, where the editor applies it at the moved caret, with the indentation.
+    h.input_mut().events.extend([egui::Event::Text("a".into()), key(Key::ArrowLeft, Modifiers::NONE), key(Key::Enter, Modifiers::NONE)]);
+    h.run_steps(1);
+    assert_eq!(h.state(), "if x:\n    \n    y = 2    a", "the Enter waits for the arrow");
+    h.run_steps(1);
+    assert_eq!(h.state(), "if x:\n    \n    y = 2    \n    a");
+}
+
+#[test]
+fn a_selection_ending_at_a_line_start_leaves_that_line_alone() {
+    // Selecting "a\n" in "a\nb" ends at the start of the second line, which is not selected.
+    let mut s = "a\nb".to_string();
+    indent(&mut s, (0, 2), false);
+    assert_eq!(s, "    a\nb");
+    let mut s = "    a\n    b".to_string();
+    indent(&mut s, (0, 6), true);
+    assert_eq!(s, "a\n    b");
+    // One character into the second line, both lines are touched.
+    let mut s = "a\nb".to_string();
+    indent(&mut s, (0, 3), false);
+    assert_eq!(s, "    a\n    b");
+}
+
+#[test]
+fn typed_text_and_deletions_replace_the_selection() {
+    let mut s = "abcd".to_string();
+    assert_eq!(insert(&mut s, (3, 1), "X"), Edit { anchor: 2, caret: 2 });
+    assert_eq!(s, "aXd");
+    assert_eq!(delete(&mut s, (2, 2), true), Edit { anchor: 1, caret: 1 });
+    assert_eq!(s, "ad");
+    assert_eq!(delete(&mut s, (1, 1), false), Edit { anchor: 1, caret: 1 });
+    assert_eq!(s, "a");
+    assert_eq!(delete(&mut s, (0, 0), true), Edit { anchor: 0, caret: 0 });
+    assert_eq!(delete(&mut s, (9, 9), false), Edit { anchor: 1, caret: 1 });
+    assert_eq!(s, "a");
+    let mut s = "éa".to_string();
+    delete(&mut s, (2, 0), true);
+    assert_eq!(s, "");
+    // The queue keeps what the editor does not handle, and everything after it.
+    let mut events = vec![
+        egui::Event::Text("x".into()),
+        egui::Event::Text("\n".into()),
+        key(Key::ArrowLeft, Modifiers::NONE),
+        key(Key::Enter, Modifiers::NONE),
+    ];
+    let (mut s, mut sel) = (String::new(), (0, 0));
+    let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
+    assert!(out.edited);
+    assert_eq!((s.as_str(), sel), ("x", (1, 1)));
+    assert_eq!(events.len(), 2, "the lone newline and the arrow stay for the field: {events:?}");
+    assert_eq!(out.held, vec![key(Key::Enter, Modifiers::NONE)], "the Enter after the arrow waits for the next pass");
+    let mut events = vec![egui::Event::Key { key: Key::Enter, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }];
+    let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
+    assert!(!out.edited && out.held.is_empty(), "a key release is nothing to apply");
+    assert_eq!(events.len(), 1);
+}
+
+#[test]
+fn select_all_then_tab_in_one_pass_indents_every_line() {
+    // Cmd+A is the field's, Tab the editor's: the Tab waits for the pass after the
+    // selection and indents the selected lines, rather than reaching the field, which would
+    // replace the selection with a tab character.
+    let mut h = editor_harness("a\nb");
+    h.input_mut().events.extend([key(Key::A, Modifiers::COMMAND), key(Key::Tab, Modifiers::NONE)]);
+    h.run_steps(1);
+    assert_eq!(h.state(), "a\nb", "the Tab waits for the selection");
+    h.run_steps(1);
+    assert_eq!(h.state(), "    a\n    b");
+    h.input_mut().events.extend([key(Key::A, Modifiers::COMMAND), key(Key::Tab, Modifiers::SHIFT)]);
+    h.run_steps(2);
+    assert_eq!(h.state(), "a\nb");
+}
+
+#[test]
+fn a_keystroke_sequence_as_the_platform_sends_it_keeps_the_editors_enter() {
+    // egui-winit sends a Key event before each Text event. Those presses are nobody's to
+    // read, so they do not hand the Enter to the field, which knows no indentation.
+    let mut h = editor_harness("");
+    let typed = |k, c: &str, m| [key(k, m), egui::Event::Text(c.into())];
+    let mut events = Vec::new();
+    events.extend(typed(Key::I, "i", Modifiers::NONE));
+    events.extend(typed(Key::F, "f", Modifiers::NONE));
+    events.extend(typed(Key::Space, " ", Modifiers::NONE));
+    events.extend(typed(Key::X, "x", Modifiers::NONE));
+    events.extend(typed(Key::Colon, ":", Modifiers::SHIFT));
+    events.push(key(Key::Enter, Modifiers::NONE));
+    h.input_mut().events.extend(events);
+    h.run_steps(1);
+    assert_eq!(h.state(), "if x:\n    ");
+    // A character typed with Option (macOS) comes as a key under that modifier and its text;
+    // the field reads neither the key nor Option, so the Enter after it is still the editor's.
+    h.input_mut().events.extend([key(Key::E, Modifiers::ALT), egui::Event::Text("\u{e9}".into()), key(Key::Enter, Modifiers::NONE)]);
+    h.run_steps(1);
+    assert_eq!(h.state(), "if x:\n    \u{e9}\n    ");
+}
+
+#[test]
+fn tab_and_enter_under_modifiers_never_reach_the_field() {
+    // The field would make a tab character of Ctrl+Tab (in place of the selection) and a
+    // newline of Shift+Enter; Cmd+Enter is nobody's here and stays for a shortcut.
+    let mut events = vec![key(Key::Tab, Modifiers::CTRL), key(Key::Enter, Modifiers::SHIFT), key(Key::Enter, Modifiers::COMMAND)];
+    let (mut s, mut sel) = ("if x:".to_string(), (5, 5));
+    let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
+    assert_eq!(s, "if x:\n    ");
+    assert_eq!(events, vec![key(Key::Enter, Modifiers::COMMAND)]);
+    assert!(out.held.is_empty());
+}
+
+#[test]
+fn events_after_a_held_key_wait_with_it_and_pointer_events_do_not() {
+    let mut events = vec![
+        key(Key::X, Modifiers::NONE),
+        egui::Event::Text("x".into()),
+        key(Key::A, Modifiers::COMMAND),
+        key(Key::Tab, Modifiers::NONE),
+        egui::Event::PointerMoved(egui::Pos2::ZERO),
+        key(Key::ArrowLeft, Modifiers::NONE),
+        egui::Event::Text("y".into()),
+    ];
+    let (mut s, mut sel) = (String::new(), (0, 0));
+    let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
+    assert_eq!((s.as_str(), sel), ("x", (1, 1)), "the typing before the select-all is applied");
+    assert_eq!(events, vec![key(Key::X, Modifiers::NONE), key(Key::A, Modifiers::COMMAND), egui::Event::PointerMoved(egui::Pos2::ZERO)]);
+    assert_eq!(out.held, vec![key(Key::Tab, Modifiers::NONE), key(Key::ArrowLeft, Modifiers::NONE), egui::Event::Text("y".into())]);
+}
+
+#[test]
+/// Events held by the previous pass are applied once in the next pass; older held events are dropped and cleared.
+fn held_back_events_land_in_the_next_pass_only() {
+    let mut h = editor_harness("");
+    let id = egui::Id::unique("code");
+    let held = |pass, c: &str| Held { pass, events: vec![egui::Event::Text(c.into())] };
+    // What the pass just completed held back comes in with the next one.
+    let last = h.ctx.cumulative_pass_nr() - 1;
+    h.ctx.data_mut(|d| d.insert_temp(held_id(id), held(last, "a")));
+    h.run_steps(1);
+    assert_eq!(h.state(), "a");
+    // Anything older is dropped rather than typed out of context, and cleared.
+    h.ctx.data_mut(|d| d.insert_temp(held_id(id), held(last, "b")));
+    h.run_steps(1);
+    assert_eq!(h.state(), "a");
+    assert!(h.ctx.data(|d| d.get_temp::<Held>(held_id(id))).is_none());
+}
+
+#[test]
+/// Held keyboard input does not land in the next focused text field once the code editor has lost focus.
+fn held_back_events_go_nowhere_once_the_editor_lost_the_focus() {
+    // Typed into the editor, they must not land in whatever has the focus next.
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
+        |ui, s: &mut (String, String, bool)| {
+            if ui.ctx().cumulative_pass_nr() == 0 {
+                install_mono(ui.ctx());
+                return;
+            }
+            let (code, other) = (egui::Id::unique("code"), egui::Id::unique("other"));
+            ui.memory_mut(|m| m.request_focus(if s.2 { code } else { other }));
+            code_editor(ui, code, &mut s.0, Lang::Python, 5);
+            ui.add(TextEdit::singleline(&mut s.1).id(other)).accessible_name("Other field");
+        },
+        (String::new(), String::new(), true),
+    );
+    h.run_steps(2);
+    h.input_mut().events.extend([key(Key::ArrowLeft, Modifiers::NONE), egui::Event::Text("x".into())]);
+    h.run_steps(1);
+    assert_eq!(h.state().0, "", "the x waits for the arrow");
+    h.state_mut().2 = false;
+    h.run_steps(2);
+    assert_eq!((h.state().0.as_str(), h.state().1.as_str()), ("", ""));
+}
+
+#[test]
+/// A discard-triggered repeat pass receives held keys with the selection made by the first pass.
+fn a_repeat_pass_of_the_frame_counts_as_the_next_pass() {
+    // When a widget asks egui to discard and repeat the pass, the repeat pass gets the
+    // held-back keys, with the selection the field made in the first pass.
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(400.0, 300.0)).build_ui_state(
+        |ui, s: &mut (String, bool)| {
+            if ui.ctx().cumulative_pass_nr() == 0 {
+                install_mono(ui.ctx());
+                return;
+            }
+            let id = egui::Id::unique("code");
+            ui.memory_mut(|m| m.request_focus(id));
+            code_editor(ui, id, &mut s.0, Lang::Python, 5);
+            if std::mem::take(&mut s.1) {
+                ui.ctx().request_discard("the test repeats this pass");
+            }
+        },
+        ("a\nb".to_string(), false),
+    );
+    h.run_steps(2);
+    h.state_mut().1 = true;
+    h.input_mut().events.extend([key(Key::A, Modifiers::COMMAND), key(Key::Tab, Modifiers::NONE)]);
+    h.run_steps(1);
+    assert_eq!(h.state().0, "    a\n    b");
+}

From 27a39472edf82bdb609c4ea176d26c096332b677 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:45 +0000
Subject: [PATCH 37/76] refactor(ui-egui): move control tests to
 src/control/tests.rs

---
 crates/ui-egui/src/control.rs       | 990 +---------------------------
 crates/ui-egui/src/control/tests.rs | 987 +++++++++++++++++++++++++++
 2 files changed, 988 insertions(+), 989 deletions(-)
 create mode 100644 crates/ui-egui/src/control/tests.rs

diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index a4c226b81..5e8be4945 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -1411,992 +1411,4 @@ pub fn save_image(image: std::sync::Arc<egui::ColorImage>, path: Option<&str>) -
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn sample() -> Vec<Json> {
-        vec![
-            json!({"id": "home.borders", "label": "Borders", "menu": ["Home", "Font"]}),
-            json!({"id": "home.bold", "label": "Bold", "menu": ["Home", "Font"]}),
-            json!({"id": "ui.ribbonTab", "label": "Ribbon Tab", "enabled": true, "ui": true}),
-        ]
-    }
-
-    fn ids(v: &[Json]) -> Vec<&str> {
-        v.iter().filter_map(|c| c.get("id").and_then(Json::as_str)).collect()
-    }
-
-    #[test]
-    fn search_filters_case_insensitively() {
-        assert_eq!(ids(&filter_commands(sample(), Some("border"))), ["home.borders"]);
-        assert_eq!(filter_commands(sample(), Some("BORDER")), filter_commands(sample(), Some("border")));
-        assert_eq!(ids(&filter_commands(sample(), Some("ribbon"))), ["ui.ribbonTab"]);
-        assert_eq!(ids(&filter_commands(sample(), Some("font"))), ["home.borders", "home.bold"]);
-        assert!(filter_commands(sample(), Some("catalog_no_match_7391")).is_empty());
-        assert_eq!(filter_commands(sample(), None).len(), 3);
-    }
-
-    fn test_app() -> SheetApp {
-        let mut session = gridcraft_engine::Session::new();
-        session.new_workbook();
-        SheetApp::new(session, crate::Services::default())
-    }
-
-    #[test]
-    /// Checks that oversized click/drag counts are refused without changing already queued batches, that queued input counts toward the budget, and that normal gestures still queue fully.
-    fn oversized_pointer_requests_are_refused_and_leave_the_queue_alone() {
-        let mut app = test_app();
-        let p = egui::pos2(20.0, 20.0);
-        let m = egui::Modifiers::NONE;
-        let btn = egui::PointerButton::Primary;
-        assert!(push_click(&mut app, p, btn, 2, m).is_ok());
-        assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), 5);
-        assert!(push_click(&mut app, p, btn, u32::MAX, m).is_err());
-        assert!(push_drag(&mut app, p, p, usize::MAX, m).is_err());
-        assert!(push_drag(&mut app, p, p, MAX_QUEUED_SYNTHETIC_EVENTS, m).is_err());
-        assert_eq!(app.synthetic.len(), 2);
-        assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), 5);
-        // Already queued input counts toward the budget.
-        assert!(push_click(&mut app, p, btn, (MAX_QUEUED_SYNTHETIC_EVENTS / 2) as u32, m).is_err());
-        assert_eq!(app.synthetic.len(), 2);
-        // Normal requests still queue in full.
-        assert!(push_drag(&mut app, p, p + egui::vec2(40.0, 40.0), 3, m).is_ok());
-        assert_eq!(app.synthetic.len(), 8);
-    }
-
-    #[test]
-    fn print_command_discovery_documents_settings_and_submission() {
-        let mut session = gridcraft_engine::Session::new();
-        session.new_workbook();
-        let mut app = SheetApp::new(session, crate::Services::default());
-        let Outcome::Done(reply) = handle(&mut app, &egui::Context::default(), "engine.commands", &json!({"search":"print"})) else {
-            panic!("command discovery must return immediately");
-        };
-        assert_eq!(reply["ok"], true);
-        let commands = reply["result"].as_array().unwrap();
-        for (id, expected_docs) in [
-            ("ui.printSettings", &["copies", "duplex", "refresh", "discovering", "status", "detail"][..]),
-            ("ui.printSubmit", &["file.print", "pagination", "pending", "without opening a dialog"][..]),
-        ] {
-            let command = commands.iter().find(|command| command["id"] == id).unwrap();
-            assert_eq!(command["ui"], true);
-            let docs = command["params"].as_str().unwrap();
-            for expected in expected_docs {
-                assert!(docs.contains(expected), "{id}: missing {expected}");
-            }
-        }
-        assert!(!app.printing.busy(), "discovery must not submit a job");
-        assert!(app.backstage.is_none(), "discovery must not open settings");
-    }
-
-    #[test]
-    fn language_command_docs_list_every_language() {
-        let mut session = gridcraft_engine::Session::new();
-        session.new_workbook();
-        let mut app = SheetApp::new(session, crate::Services::default());
-        let Outcome::Done(reply) = handle(&mut app, &egui::Context::default(), "engine.commands", &json!({"search":"language"})) else {
-            panic!("command discovery must return immediately");
-        };
-        let commands = reply["result"].as_array().unwrap();
-        let docs = commands.iter().find(|c| c["id"] == "app.language.set").unwrap()["params"].as_str().unwrap();
-        for l in crate::i18n::Language::ALL {
-            assert!(docs.contains(&format!("\"{}\"", l.code())), "app.language.set docs miss {:?}: {docs}", l.code());
-        }
-    }
-    /// One headless UI pass. A test has no renderer to apply the font-atlas delta, so dropping
-    /// it is intentional (0.37 panics when a `TexturesDelta` is dropped unapplied).
-    fn ui_pass(ctx: &egui::Context, raw: egui::RawInput, f: impl FnMut(&mut egui::Ui)) -> egui::FullOutput {
-        let mut out = ctx.run_ui(raw, f);
-        out.textures_delta.clear();
-        out
-    }
-
-    /// Returns an egui context initialized by one blank pass at `size` with an 8192-pixel texture limit.
-    fn sized_context(size: egui::Vec2) -> egui::Context {
-        let ctx = egui::Context::default();
-        let raw = egui::RawInput {
-            screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)),
-            max_texture_side: Some(8192),
-            ..Default::default()
-        };
-        let _ = ui_pass(&ctx, raw, |_| {});
-        ctx
-    }
-
-    /// Returns blank raw input with a screen rect at `size` and an 8192-pixel texture limit.
-    fn raw_of(size: egui::Vec2) -> egui::RawInput {
-        egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), max_texture_side: Some(8192), ..Default::default() }
-    }
-
-    /// Extracts cloned `ViewportCommand::Screenshot` callbacks from a `FullOutput` for the context's viewport.
-    fn screenshot_callbacks(out: &egui::FullOutput, ctx: &egui::Context) -> Vec<egui::ScreenshotCallback> {
-        out.viewport_output
-            .get(&ctx.viewport_id())
-            .map(|output| {
-                output
-                    .commands
-                    .iter()
-                    .filter_map(|command| match command {
-                        egui::ViewportCommand::Screenshot(callback) => Some(callback.clone()),
-                        _ => None,
-                    })
-                    .collect::<Vec<_>>()
-            })
-            .unwrap_or_default()
-    }
-
-    /// Run three settled passes with `raw` and return the callbacks issued in them.
-    fn issue_with(ctx: &egui::Context, app: &mut SheetApp, raw: egui::RawInput) -> Vec<egui::ScreenshotCallback> {
-        let mut callbacks = Vec::new();
-        for _ in 0..3 {
-            let out = ui_pass(ctx, raw.clone(), |ui| issue_screenshots(app, ui.ctx()));
-            callbacks.extend(screenshot_callbacks(&out, ctx));
-        }
-        callbacks
-    }
-
-    /// Returns a per-process temporary PNG path after removing any stale file at that path.
-    fn temp_png(name: &str) -> std::path::PathBuf {
-        let path = std::env::temp_dir().join(format!("gridcraft-shot-{name}-{}.png", std::process::id()));
-        let _ = std::fs::remove_file(&path);
-        path
-    }
-
-    #[test]
-    /// Checks rounded physical pixels, expected/retained byte counts, the texture-axis cap, the no-size case and overflow refusal.
-    fn capture_geometry_reports_checked_capped_pixels() {
-        let geometry = CaptureGeometry {
-            viewport_id: egui::ViewportId::ROOT,
-            viewport: Some(egui::vec2(800.0, 600.0)),
-            pixels_per_point: 2.0,
-            zoom: 1.0,
-            max_texture_side: 4096,
-            minimized: None,
-            occluded: None,
-            visible: None,
-        };
-        assert_eq!(geometry.expected_size(), Some([1600, 1200]));
-        assert_eq!(geometry.expected_bytes(), Some(1600 * 1200 * 4));
-        assert_eq!(geometry.retained_bytes(), Some(1601 * 1201 * 4), "one pixel of rounding per axis is reserved too");
-        let capped = CaptureGeometry { max_texture_side: 1024, ..geometry };
-        assert_eq!(capped.expected_size(), Some([1024, 1024]), "the surface limit caps both axes");
-        let empty = CaptureGeometry { viewport: Some(egui::Vec2::ZERO), ..geometry };
-        assert_eq!(empty.expected_size(), None, "a minimized window has no capturable size");
-        assert_eq!(empty.retained_bytes(), None);
-        let huge = CaptureGeometry { viewport: Some(egui::vec2(f32::MAX, f32::MAX)), ..geometry };
-        assert_eq!(huge.expected_size(), None, "overflow is refused, not truncated");
-    }
-
-    #[test]
-    /// Checks that one request beyond `SCREENSHOT_MAX_REQUESTS` is rejected with its token while earlier requests stay queued and do not reply early.
-    fn screenshot_admission_stops_on_the_count_budget_without_evicting() {
-        let ctx = sized_context(egui::vec2(800.0, 600.0));
-        let mut app = test_app();
-        let mut replies = Vec::new();
-        for _ in 0..SCREENSHOT_MAX_REQUESTS {
-            let (tx, rx) = std::sync::mpsc::channel();
-            admit(&mut app, &ctx, None, tx);
-            replies.push(rx);
-        }
-        assert_eq!(app.shots.requests.len(), SCREENSHOT_MAX_REQUESTS);
-        assert!(replies.iter_mut().all(|r| r.try_recv().is_err()), "admitted requests do not reply early");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        let reply = rx.try_recv().expect("the over-count request is rejected");
-        assert_eq!(reply["ok"], false);
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("limit 4")), "{reply}");
-        assert!(reply["request"].as_u64().is_some(), "a rejection carries its request token: {reply}");
-        assert_eq!(app.shots.requests.len(), SCREENSHOT_MAX_REQUESTS, "an earlier request is never evicted");
-    }
-
-    #[test]
-    /// Three roughly 100 MB path captures hit the aggregate byte limit; the third is rejected and only two requests remain.
-    fn screenshot_admission_stops_on_aggregate_bytes_before_the_count() {
-        let ctx = sized_context(egui::vec2(5000.0, 5000.0));
-        let mut app = test_app();
-        let path = temp_png("aggregate").to_string_lossy().into_owned();
-        let mut rejected = None;
-        for _ in 0..3 {
-            let (tx, rx) = std::sync::mpsc::channel();
-            // A path capture (not base64) isolates the retained-image aggregate budget.
-            admit(&mut app, &ctx, Some(path.clone()), tx);
-            if let Ok(reply) = rx.try_recv() {
-                rejected = Some(reply);
-            }
-        }
-        let reply = rejected.expect("three 100 MB captures exceed the 256 MiB aggregate budget");
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("aggregate limit")), "{reply}");
-        assert_eq!(app.shots.requests.len(), 2);
-    }
-
-    #[test]
-    /// An unknown-size request reserves the placeholder, issues nothing while settling, then replies once on timeout and releases the reservation.
-    fn requests_without_a_size_stay_queued_and_time_out() {
-        let ctx = sized_context(egui::Vec2::ZERO);
-        let mut app = test_app();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        assert!(rx.try_recv().is_err(), "an unknown size is queued, not refused with an overflow error");
-        assert_eq!(app.shots.requests[0].bytes, UNKNOWN_CAPTURE_BYTES, "the largest possible image is reserved meanwhile");
-        // Settling passes without a size neither issue nor fail the request.
-        let callbacks = issue_with(&ctx, &mut app, raw_of(egui::Vec2::ZERO));
-        assert!(callbacks.is_empty());
-        assert!(!app.shots.requests[0].issued);
-        assert!(rx.try_recv().is_err());
-        app.shots.requests[0].deadline = 0.0;
-        let _ = ui_pass(&ctx, raw_of(egui::Vec2::ZERO), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the size-less request times out once");
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("capturable size")), "{reply}");
-        assert_eq!(app.shots.reserved(), 0, "the placeholder reservation is released");
-    }
-
-    /// Counts `RequestPaintWhileHidden` commands in a logic output.
-    fn hidden_paints(out: &egui::LogicOutput) -> usize {
-        out.viewport_commands.values().flatten().filter(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)).count()
-    }
-
-    #[test]
-    /// A queued capture requests a hidden paint; once issued, the screenshot command supplies the paint itself.
-    fn a_queued_capture_requests_hidden_paint_until_it_is_issued() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let (tx, _rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        let queued = ctx.run_logic(&raw_of(egui::vec2(64.0, 48.0)), |ctx| app.logic(ctx));
-        assert_eq!(hidden_paints(&queued), 1, "a queued capture needs a real `ui` pass");
-
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        let issued = ctx.run_logic(&raw_of(egui::vec2(64.0, 48.0)), |ctx| app.logic(ctx));
-        assert_eq!(hidden_paints(&issued), 0, "the issued Screenshot command paints the hidden window by itself");
-    }
-
-    #[test]
-    /// A minimized request stays queued without requesting hidden paints, because it cannot issue until restored.
-    fn a_minimized_capture_does_not_force_hidden_frames_while_it_waits() {
-        let ctx = egui::Context::default();
-        let mut app = test_app();
-        let mut raw = raw_of(egui::vec2(800.0, 600.0));
-        if let Some(v) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
-            v.inner_rect = None;
-            v.minimized = Some(true);
-        }
-        app.raw_input_hook(&ctx, &mut raw);
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        assert!(rx.try_recv().is_err());
-        let waited = ctx.run_logic(&raw, |ctx| app.logic(ctx));
-        assert_eq!(hidden_paints(&waited), 0, "a minimized request cannot issue until it is restored");
-        app.shots.cancel_all();
-    }
-
-    #[test]
-    /// The real app harness issues exactly one callback, replies once with the token and dimensions, and releases the reservation.
-    fn one_admitted_capture_issues_one_callback_and_replies_once() {
-        use egui_kittest::kittest::Queryable as _;
-
-        let mut app = test_app();
-        app.use_prepared_fonts();
-        let mut h = egui_kittest::Harness::builder()
-            .with_size(egui::vec2(900.0, 700.0))
-            .with_context_setup(|ctx| {
-                ctx.set_fonts(crate::theme::pinned_font_definitions());
-                crate::theme::apply(ctx, false);
-            })
-            // This test completes the callback itself. Keep the real app/AccessKit tree, but
-            // do not let kittest's automatic screenshot handling initialize a GPU renderer.
-            .renderer(egui_kittest::LazyRenderer::Uninitialized { textures_delta: Default::default(), builder: None })
-            .build_ui_state(
-                |ui, app: &mut SheetApp| {
-                    app.logic(ui.ctx());
-                    app.ui(ui);
-                },
-                app,
-            );
-        h.run_steps(4);
-        assert!(h.query_by_label("Name Box").is_some(), "the capture fixture draws the real app, not an empty tree");
-        h.check_accessibility();
-
-        let ctx = h.ctx.clone();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(h.state_mut(), &ctx, None, tx);
-        let token = h.state().shots.requests[0].token;
-        h.state_mut().shots.requests[0].ready_at = 0.0;
-        let mut callbacks = Vec::new();
-        for _ in 0..3 {
-            h.step();
-            callbacks.extend(screenshot_callbacks(h.output(), &ctx));
-        }
-        assert_eq!(callbacks.len(), 1, "the settled request is issued once");
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([900, 700], egui::Color32::RED)));
-        h.step(); // the real logic drains the callback and the UI repaints
-        h.check_accessibility();
-        assert!(h.query_by_label("Name Box").is_some(), "the app tree survives callback drain and repaint");
-        let reply = rx.try_recv().expect("the drain replies once");
-        assert_eq!(reply["ok"], true, "{reply}");
-        assert_eq!(reply["result"]["width"], 900);
-        assert_eq!(reply["result"]["height"], 700);
-        assert_eq!(reply["request"].as_u64(), Some(token), "the reply names its request");
-        assert!(rx.try_recv().is_err(), "a completed slot is taken exactly once");
-        assert_eq!(h.state().shots.reserved(), 0, "the reservation is released after the reply");
-    }
-
-    #[test]
-    /// Completing callbacks in reverse order replies on each matching token/path and writes each request's own pixels.
-    fn out_of_order_completions_reply_on_their_own_request() {
-        let ctx = sized_context(egui::vec2(8.0, 8.0));
-        let mut app = test_app();
-        let p1 = temp_png("order-1");
-        let p2 = temp_png("order-2");
-        let (tx1, rx1) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(p1.to_string_lossy().into_owned()), tx1);
-        let token1 = app.shots.requests[0].token;
-        let (tx2, rx2) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(p2.to_string_lossy().into_owned()), tx2);
-        let token2 = app.shots.requests[1].token;
-        for request in &mut app.shots.requests {
-            request.ready_at = 0.0;
-        }
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 2, "one callback per admitted request");
-        // Complete the second request first: slots, not callback order, carry the result.
-        callbacks[1].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([8, 8], egui::Color32::BLUE)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let second = rx2.try_recv().expect("the second request gets its own reply");
-        assert_eq!(second["ok"], true, "{second}");
-        assert_eq!(second["request"].as_u64(), Some(token2));
-        assert_eq!(second["result"]["path"].as_str(), Some(p2.to_string_lossy().as_ref()));
-        assert!(!p1.exists(), "the unfinished request has not written anything");
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([8, 8], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let first = rx1.try_recv().expect("the first request gets its own reply");
-        assert_eq!(first["request"].as_u64(), Some(token1));
-        assert_eq!(first["result"]["path"].as_str(), Some(p1.to_string_lossy().as_ref()));
-        assert_ne!(std::fs::read(&p1).unwrap(), std::fs::read(&p2).unwrap(), "each reply carries its own pixels");
-        let _ = std::fs::remove_file(&p1);
-        let _ = std::fs::remove_file(&p2);
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// An expired request replies once with a timeout, writes no file and releases its reservation.
-    fn a_timed_out_capture_replies_once_and_never_writes() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let path = temp_png("timeout");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        app.shots.requests[0].deadline = 0.0;
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the timeout replies");
-        assert_eq!(reply["ok"], false);
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("timeout")), "{reply}");
-        assert!(!path.exists(), "a timed-out capture never writes a file");
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        assert!(rx.try_recv().is_err(), "a timeout is reported once");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// A valid image that completes after its deadline gets one timeout reply and is not written.
-    fn a_capture_completed_after_its_deadline_writes_nothing() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let path = temp_png("late");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        let token = app.shots.requests[0].token;
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        // The deadline passes while the callback is outstanding; the image arrives afterwards.
-        app.shots.requests[0].deadline = 0.0;
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the late completion gets one timeout reply");
-        assert_eq!(reply["ok"], false, "{reply}");
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("timeout")), "{reply}");
-        assert_eq!(reply["request"].as_u64(), Some(token));
-        assert!(!path.exists(), "a capture that completed after its deadline never writes a file");
-        assert!(rx.try_recv().is_err(), "the late image is reported once");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Cancelling a request does not reply; a later callback for it is ignored and writes nothing.
-    fn a_callback_after_the_request_is_removed_is_inert() {
-        let ctx = sized_context(egui::vec2(32.0, 24.0));
-        let mut app = test_app();
-        let path = temp_png("removed");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        app.shots.cancel_all();
-        assert!(rx.try_recv().is_err(), "cancelling a request does not reply");
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        assert!(rx.try_recv().is_err(), "a callback for a removed request is inert");
-        assert!(!path.exists());
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// The first issuance adopts a new geometry, updates the epoch and reservation, spends no retry, and the capture then succeeds.
-    fn a_resize_between_admission_and_issuance_does_not_cost_a_retry() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let admitted_epoch = app.shots.requests[0].epoch;
-        let resized = raw_of(egui::vec2(32.0, 24.0));
-        let callbacks = issue_with(&ctx, &mut app, resized.clone());
-        assert_eq!(callbacks.len(), 1);
-        let request = &app.shots.requests[0];
-        assert_eq!(request.retries, 0, "the first issuance adopts the current geometry instead of spending a retry");
-        assert_eq!(request.geometry.viewport, Some(egui::vec2(32.0, 24.0)));
-        assert_eq!(request.expected, Some([32, 24]));
-        assert_eq!(request.bytes, 33 * 25 * 4);
-        assert!(request.epoch > admitted_epoch, "issuance records the new epoch together with the geometry");
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, resized, |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the once-issued capture replies");
-        assert_eq!(reply["ok"], true, "{reply}");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// The reservation is the largest accepted rounded image (11×9×4 bytes for a 10×8 viewport), and that image is accepted.
-    fn the_retained_reservation_is_the_slot_bound() {
-        let ctx = sized_context(egui::vec2(10.0, 8.0));
-        let mut app = test_app();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        // validate_image accepts one pixel of rounding per axis: an 11x9 image is the largest.
-        assert_eq!(app.shots.requests[0].bytes, 11 * 9 * 4);
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([11, 9], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the rounded image is accepted");
-        assert_eq!(reply["ok"], true, "{reply}");
-        assert_eq!(reply["result"]["width"], 11);
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Oversized images retry within the bounded budget, never write, then report the per-image limit, while the valid peer is written.
-    fn an_image_beyond_the_reservation_is_released_without_writing() {
-        let ctx = sized_context(egui::vec2(10.0, 8.0));
-        let mut app = test_app();
-        let p1 = temp_png("over-1");
-        let p2 = temp_png("over-2");
-        let (tx1, rx1) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(p1.to_string_lossy().into_owned()), tx1);
-        let (tx2, rx2) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(p2.to_string_lossy().into_owned()), tx2);
-        for request in &mut app.shots.requests {
-            request.ready_at = 0.0;
-        }
-        assert_eq!(app.shots.reserved(), 2 * 11 * 9 * 4);
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 2);
-        // The slot refuses an image over the reservation instead of retaining bytes beyond it.
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([12, 9], egui::Color32::RED)));
-        // The other request completes with valid pixels.
-        callbacks[1].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([10, 8], egui::Color32::BLUE)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        // A larger image can be a genuine resize, so it receives the same bounded retries as
-        // a smaller one. Each oversized callback is released and never written while retrying.
-        for attempt in 1..=SCREENSHOT_MAX_RETRIES {
-            assert_eq!(app.shots.requests[0].retries, attempt);
-            assert!(rx1.try_recv().is_err(), "retry {attempt} has not replied early");
-            assert!(!p1.exists(), "oversized pixels are never written on retry {attempt}");
-            let callbacks = issue_with(&ctx, &mut app, raw_of(egui::vec2(10.0, 8.0)));
-            assert_eq!(callbacks.len(), 1, "the other valid request is already complete");
-            callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([12, 9], egui::Color32::RED)));
-            let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        }
-        let refused = rx1.try_recv().expect("the oversized image is reported after bounded retries");
-        assert_eq!(refused["ok"], false, "{refused}");
-        assert!(refused["error"].as_str().is_some_and(|e| e.contains("per-image limit")), "{refused}");
-        assert!(!p1.exists());
-        let accepted = rx2.try_recv().expect("the valid image is written");
-        assert_eq!(accepted["ok"], true, "{accepted}");
-        let _ = std::fs::remove_file(&p2);
-        assert_eq!(app.shots.reserved(), 0, "both reservations are released");
-    }
-
-    #[test]
-    /// Two `ui` calls in one pass count as one settling frame, and a pass that requests a discard is not counted; only its rerun counts.
-    fn settling_counts_one_real_pass_and_skips_a_discarded_one() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let (tx, _rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        // Two `ui` calls in one pass are one settling frame.
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| {
-            issue_screenshots(&mut app, ui.ctx());
-            issue_screenshots(&mut app, ui.ctx());
-        });
-        assert_eq!(app.shots.requests[0].frames, 1);
-        // A pass that already asked to be discarded does not count, even though `run_ui` repeats it.
-        let mut asked = false;
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| {
-            if !asked {
-                asked = true;
-                ui.ctx().request_discard("settling test");
-            }
-            issue_screenshots(&mut app, ui.ctx());
-        });
-        assert_eq!(app.shots.requests[0].frames, 2, "only the rerun (real) pass counted");
-    }
-
-    #[test]
-    /// Issuance survives a discard requested after it, the image is written once, and a duplicate callback completion is inert.
-    fn a_discard_requested_after_issuance_still_issues_and_writes_once() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let path = temp_png("discard-after-issue");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let mut asked = false;
-        let mut callbacks = Vec::new();
-        for _ in 0..3 {
-            let out = ui_pass(&ctx, egui::RawInput::default(), |ui| {
-                issue_screenshots(&mut app, ui.ctx());
-                if !asked && app.shots.requests.first().is_some_and(|r| r.issued) {
-                    asked = true;
-                    ui.ctx().request_discard("discard after screenshot issuance");
-                }
-            });
-            callbacks.extend(screenshot_callbacks(&out, &ctx));
-        }
-        assert!(asked, "the test requested a discard after issuance");
-        assert_eq!(callbacks.len(), 1, "issuance happens exactly once across the discard repeat");
-        let image = std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED));
-        callbacks[0].clone().complete(image.clone());
-        callbacks[0].clone().complete(image);
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the discarded pass still delivers one reply");
-        assert_eq!(reply["ok"], true, "{reply}");
-        assert!(path.exists(), "the image is written exactly once");
-        assert!(rx.try_recv().is_err(), "a second completion of the same callback is inert");
-        let _ = std::fs::remove_file(&path);
-    }
-
-    #[test]
-    /// A grow-resize spends one retry, reissues at the new size and then accepts the new image.
-    fn an_image_larger_than_the_reservation_retries_like_a_smaller_one() {
-        let ctx = sized_context(egui::vec2(10.0, 8.0));
-        let mut app = test_app();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-
-        // The surface grew by two pixels while the image was outstanding. The slot's reservation
-        // refuses the larger image before `validate_image`; drain must retry at the new geometry
-        // instead of failing because the resize went in this direction.
-        let mut grown = raw_of(egui::vec2(20.0, 16.0));
-        app.raw_input_hook(&ctx, &mut grown);
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([12, 9], egui::Color32::RED)));
-        let _ = ctx.run_logic(&grown, |ctx| app.logic(ctx));
-        let request = &app.shots.requests[0];
-        assert_eq!(request.retries, 1, "the slot's per-image refusal spends one retry, not a failure");
-        assert!(!request.issued);
-        assert_eq!(request.geometry.viewport, Some(egui::vec2(20.0, 16.0)));
-        assert!(rx.try_recv().is_err(), "a retried capture does not reply yet");
-
-        let callbacks = issue_with(&ctx, &mut app, raw_of(egui::vec2(20.0, 16.0)));
-        assert_eq!(callbacks.len(), 1);
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([20, 16], egui::Color32::BLUE)));
-        let _ = ui_pass(&ctx, raw_of(egui::vec2(20.0, 16.0)), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the retried capture replies");
-        assert_eq!(reply["ok"], true, "{reply}");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Minimize retries reserve unknown-size bytes; only two fit the aggregate budget and stay queued (the rest are reported), and the survivors write after restore.
-    fn a_minimize_retry_without_a_size_still_checks_the_aggregate_budget() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let mut paths = Vec::new();
-        let mut receivers = Vec::new();
-        for n in 0..SCREENSHOT_MAX_REQUESTS {
-            let path = temp_png(&format!("minimize-retry-{n}"));
-            let (tx, rx) = std::sync::mpsc::channel();
-            // A path capture isolates the retained-image aggregate budget.
-            admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-            paths.push(path);
-            receivers.push(rx);
-        }
-        for request in &mut app.shots.requests {
-            request.ready_at = 0.0;
-        }
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), SCREENSHOT_MAX_REQUESTS, "four path captures fit every budget");
-        assert_eq!(app.shots.reserved(), SCREENSHOT_MAX_REQUESTS * 65 * 49 * 4);
-
-        // The window is minimized with every capture outstanding. The drain retries each one
-        // against the new surface generation, which has no capturable size, so every retry
-        // reserves UNKNOWN_CAPTURE_BYTES. Only two unknown-size reservations fit the aggregate
-        // limit; the rest must be reported instead of inflating `reserved()` over the budget.
-        let mut minimized = raw_of(egui::vec2(64.0, 48.0));
-        if let Some(viewport) = minimized.viewports.get_mut(&egui::ViewportId::ROOT) {
-            viewport.inner_rect = None;
-            viewport.minimized = Some(true);
-        }
-        app.raw_input_hook(&ctx, &mut minimized);
-        let image = std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED));
-        for callback in &callbacks {
-            callback.clone().complete(image.clone());
-        }
-        let _ = ctx.run_logic(&minimized, |ctx| app.logic(ctx));
-
-        assert!(
-            app.shots.reserved() <= SCREENSHOT_MAX_AGGREGATE_BYTES,
-            "size-less retries reserved {} bytes, over the {SCREENSHOT_MAX_AGGREGATE_BYTES}-byte aggregate limit",
-            app.shots.reserved()
-        );
-        let rejected: Vec<Json> = receivers.iter_mut().filter_map(|rx| rx.try_recv().ok()).collect();
-        assert_eq!(rejected.len(), 2, "two unknown-size retries no longer fit the aggregate budget");
-        assert!(rejected.iter().all(|reply| reply["error"].as_str().is_some_and(|e| e.contains("aggregate limit"))), "{rejected:?}");
-        assert_eq!(app.shots.requests.len(), 2, "the two fitting retries stay queued");
-        assert!(app.shots.requests.iter().all(|r| !r.issued && r.expected.is_none() && r.bytes == UNKNOWN_CAPTURE_BYTES));
-        assert!(receivers.iter_mut().all(|rx| rx.try_recv().is_err()), "the surviving retries wait for the restore");
-
-        // Restoring re-issues only the surviving requests at the real size; both fit because the
-        // over-reserved retries were rejected rather than kept.
-        let mut restored = raw_of(egui::vec2(64.0, 48.0));
-        if let Some(viewport) = restored.viewports.get_mut(&egui::ViewportId::ROOT) {
-            viewport.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(64.0, 48.0)));
-            viewport.minimized = Some(false);
-            viewport.occluded = Some(false);
-        }
-        app.raw_input_hook(&ctx, &mut restored);
-        let callbacks = issue_with(&ctx, &mut app, restored.clone());
-        assert_eq!(callbacks.len(), 2, "the surviving requests issue on restore");
-        for callback in &callbacks {
-            callback.clone().complete(image.clone());
-        }
-        let _ = ctx.run_logic(&restored, |ctx| app.logic(ctx));
-
-        let mut delivered = 0;
-        for rx in &mut receivers {
-            if let Ok(reply) = rx.try_recv() {
-                assert_eq!(reply["ok"], true, "{reply}");
-                delivered += 1;
-            }
-        }
-        assert_eq!(delivered, 2, "the two surviving captures reply once each");
-        let written = paths.iter().filter(|path| path.exists()).count();
-        assert_eq!(written, 2, "only the surviving captures write their image");
-        for path in &paths {
-            let _ = std::fs::remove_file(path);
-        }
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Fresh hidden viewport geometry invalidates the old image, spends one retry, and the reissued image succeeds.
-    fn a_hidden_resize_rejects_an_image_issued_before_it_and_reissues() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED)));
-
-        // A hidden tick carries the resize in `RawInput::viewports`; the last UI pass still says
-        // 64x48, so only the fresh viewport info lets the drain see the change.
-        let hidden = || {
-            let mut raw = raw_of(egui::vec2(64.0, 48.0));
-            if let Some(viewport) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
-                viewport.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(32.0, 400.0)));
-                viewport.native_pixels_per_point = Some(1.0);
-            }
-            raw
-        };
-        let _ = ctx.run_logic(&hidden(), |ctx| app.logic(ctx));
-        let request = &app.shots.requests[0];
-        assert!(!request.issued, "the image captured before the hidden resize is not accepted");
-        assert_eq!(request.retries, 1);
-        assert_eq!(request.geometry.viewport, Some(egui::vec2(32.0, 400.0)));
-        assert!(rx.try_recv().is_err(), "a retried capture does not reply yet");
-
-        // The next real pass issues against the new size and its image is accepted.
-        let resized = raw_of(egui::vec2(32.0, 24.0));
-        let callbacks = issue_with(&ctx, &mut app, resized.clone());
-        assert_eq!(callbacks.len(), 1, "the retry is issued once against the current geometry");
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::BLUE)));
-        let _ = ui_pass(&ctx, resized, |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the retried capture replies");
-        assert_eq!(reply["ok"], true, "{reply}");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Draining four completed captures replies to all of them and permits a new admission.
-    fn a_drained_capture_frees_its_slot_for_the_next_admission() {
-        let ctx = sized_context(egui::vec2(8.0, 8.0));
-        let mut app = test_app();
-        let mut receivers = Vec::new();
-        for _ in 0..SCREENSHOT_MAX_REQUESTS {
-            let (tx, rx) = std::sync::mpsc::channel();
-            admit(&mut app, &ctx, None, tx);
-            receivers.push(rx);
-        }
-        for request in &mut app.shots.requests {
-            request.ready_at = 0.0;
-        }
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        for callback in &callbacks {
-            callback.clone().complete(std::sync::Arc::new(egui::ColorImage::filled([8, 8], egui::Color32::GREEN)));
-        }
-        assert_eq!(app.shots.requests.len(), SCREENSHOT_MAX_REQUESTS);
-        // Draining before admitting is what `logic` does: completed requests release first.
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        assert_eq!(app.shots.requests.len(), 0);
-        assert!(receivers.iter_mut().all(|rx| rx.try_recv().is_ok()));
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        assert!(rx.try_recv().is_err(), "a new request is admitted once the drained slots are free");
-        assert_eq!(app.shots.requests.len(), 1);
-    }
-
-    #[test]
-    /// Uses `screen_rect` when `inner_rect` is absent, applies native scale times zoom, and advances the epoch on a hidden resize.
-    fn raw_input_geometry_uses_screen_rect_when_inner_rect_is_absent() {
-        // Wayland always omits `inner_rect`; the fresh `RawInput::screen_rect` is the only size.
-        let ctx = sized_context(egui::vec2(800.0, 600.0));
-        let mut app = test_app();
-        let mut raw = raw_of(egui::vec2(1280.0, 720.0));
-        if let Some(v) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
-            v.inner_rect = None;
-            v.native_pixels_per_point = Some(2.0);
-            v.minimized = Some(false);
-            v.occluded = Some(false);
-        }
-        app.raw_input_hook(&ctx, &mut raw);
-        let geo = app.capture_geometry.expect("the raw frame records its geometry");
-        assert_eq!(geo.viewport, Some(egui::vec2(1280.0, 720.0)));
-        assert_eq!(geo.pixels_per_point, 2.0, "native scale times zoom");
-        assert_eq!(geo.expected_size(), Some([2560, 1440]));
-
-        let epoch = app.capture_epoch;
-        // A hidden resize lands on a logic-only tick: no UI pass ran, but the raw frame is fresh.
-        let mut hidden = raw_of(egui::vec2(640.0, 480.0));
-        if let Some(v) = hidden.viewports.get_mut(&egui::ViewportId::ROOT) {
-            v.inner_rect = None;
-            v.native_pixels_per_point = Some(2.0);
-            v.minimized = Some(false);
-            v.occluded = Some(true);
-        }
-        app.raw_input_hook(&ctx, &mut hidden);
-        let _ = ctx.run_logic(&hidden, |ctx| app.logic(ctx));
-        assert!(app.capture_epoch > epoch, "a hidden resize is a new epoch");
-        assert_eq!(app.capture_geometry.expect("geometry").viewport, Some(egui::vec2(640.0, 480.0)));
-    }
-
-    #[test]
-    /// Minimized geometry has no size and reserves unknown bytes; restoring at the same size still changes the epoch.
-    fn minimized_geometry_has_no_size_and_restore_bumps_the_epoch() {
-        let ctx = egui::Context::default();
-        let mut app = test_app();
-        let mut minimized = raw_of(egui::vec2(800.0, 600.0));
-        if let Some(v) = minimized.viewports.get_mut(&egui::ViewportId::ROOT) {
-            v.inner_rect = None;
-            v.minimized = Some(true);
-        }
-        app.raw_input_hook(&ctx, &mut minimized);
-        let geo = app.capture_geometry.expect("recorded");
-        assert_eq!(geo.viewport, None, "a minimized window has no capturable size");
-        assert_eq!(geo.visible, Some(false));
-
-        // Admission while minimized reserves the unknown-size maximum and waits.
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        assert_eq!(app.shots.requests[0].bytes, UNKNOWN_CAPTURE_BYTES);
-        assert!(rx.try_recv().is_err());
-        let epoch = app.capture_epoch;
-
-        // Restoring at the same logical size is still a new surface generation.
-        let mut restored = raw_of(egui::vec2(800.0, 600.0));
-        if let Some(v) = restored.viewports.get_mut(&egui::ViewportId::ROOT) {
-            v.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0)));
-            v.minimized = Some(false);
-            v.occluded = Some(false);
-        }
-        app.raw_input_hook(&ctx, &mut restored);
-        assert!(app.capture_epoch > epoch, "minimize/restore at the same size changes the epoch");
-        assert_eq!(app.capture_geometry.expect("geometry").viewport, Some(egui::vec2(800.0, 600.0)));
-        app.shots.cancel_all();
-    }
-
-    #[test]
-    /// Switching documents before issuance cancels the request once with a document-changed error and writes nothing.
-    fn a_document_switch_before_issuance_cancels_without_writing() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let path = temp_png("doc-queued");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let admitted = app.shots.requests[0].document;
-        assert!(app.run("file.new", json!({})).is_ok());
-        assert_ne!(app.session.active().map(|d| d.uid), admitted, "the test switched documents");
-
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert!(callbacks.is_empty(), "a capture for another document is never issued");
-        let reply = rx.try_recv().expect("the queued request is cancelled once");
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("document changed")), "{reply}");
-        assert!(!path.exists(), "no pixels for the old document are written to its path");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Switching documents after issuance rejects the completed image once and writes nothing.
-    fn a_document_switch_after_issuance_rejects_the_completed_image() {
-        let ctx = sized_context(egui::vec2(64.0, 48.0));
-        let mut app = test_app();
-        let path = temp_png("doc-issued");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        assert!(app.run("file.new", json!({})).is_ok());
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the switched document is reported once");
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("document changed")), "{reply}");
-        assert!(!path.exists(), "a completion after a document switch never writes");
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// A request bound to another viewport is rejected once with a viewport error and writes nothing.
-    fn a_completion_for_another_viewport_is_rejected() {
-        let ctx = sized_context(egui::vec2(32.0, 24.0));
-        let mut app = test_app();
-        let path = temp_png("viewport");
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
-        app.shots.requests[0].ready_at = 0.0;
-        let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
-        assert_eq!(callbacks.len(), 1);
-        // A slot/request bound to a different viewport must not fill this one.
-        app.shots.requests[0].viewport_id = egui::ViewportId::from_hash_of("other-window");
-        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::RED)));
-        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
-        let reply = rx.try_recv().expect("the viewport mismatch is reported once");
-        assert!(reply["error"].as_str().is_some_and(|e| e.contains("another viewport")), "{reply}");
-        assert!(!path.exists());
-        assert_eq!(app.shots.reserved(), 0);
-    }
-
-    #[test]
-    /// Accepts one-pixel rounding on a single axis, but rejects opposite-axis deviation, aspect distortion and more than one pixel of error.
-    fn validate_image_rejects_distortion_but_allows_one_pixel_rounding() {
-        let image = |w: usize, h: usize| egui::ColorImage::filled([w, h], egui::Color32::RED);
-        assert!(validate_image(&image(100, 100), [100, 100]).is_ok());
-        assert!(validate_image(&image(101, 100), [100, 100]).is_ok(), "one pixel of rounding on one axis is legitimate");
-        assert!(validate_image(&image(100, 101), [100, 100]).is_ok());
-        assert!(validate_image(&image(101, 99), [100, 100]).is_err(), "independent per-axis tolerance must not accept a distorted image");
-        assert!(validate_image(&image(99, 101), [100, 100]).is_err());
-        assert!(validate_image(&image(102, 100), [100, 100]).is_err(), "more than one pixel per axis is a different surface");
-    }
-
-    #[test]
-    /// Checks the encoding working-set threshold, the base64 reply cap, and the retained-plus-encoding peak budget.
-    fn encoding_working_set_is_bounded_for_admitted_captures() {
-        assert!(encoding_working_bytes([8191, 2048], false).expect("checked") <= SCREENSHOT_MAX_ENCODING_BYTES);
-        assert!(encoding_working_bytes([8192, 8192], false).expect("checked") > SCREENSHOT_MAX_ENCODING_BYTES);
-        assert!(encoding_working_bytes([4000, 3000], true).expect("checked") <= SCREENSHOT_MAX_ENCODING_BYTES);
-        assert!(encoding_working_bytes([5000, 4000], true).expect("checked") > SCREENSHOT_MAX_ENCODING_BYTES);
-        // The base64 reply itself is capped too, before the string exists.
-        let png = png_worst_bytes(5000 * 4000 * 4, 4000).expect("checked");
-        assert!(base64_len(png).expect("checked") > SCREENSHOT_MAX_BASE64_BYTES);
-        // Retained requests plus one encoding working set are held to a hard peak.
-        assert!(check_peak_budget(0, [64, 48], false).is_ok());
-        assert!(check_peak_budget(SCREENSHOT_MAX_AGGREGATE_BYTES, [9000, 4096], false).is_err());
-    }
-
-    #[test]
-    /// An oversized base64 capture is refused with nothing reserved, while the same capture as a path is admitted.
-    fn base64_capture_over_the_encoding_budget_is_rejected_before_admission() {
-        let ctx = sized_context(egui::vec2(5000.0, 4000.0));
-        let mut app = test_app();
-        let (tx, rx) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, None, tx);
-        let reply = rx.try_recv().expect("an oversized base64 capture is refused at admission");
-        assert_eq!(reply["ok"], false, "{reply}");
-        assert!(
-            reply["error"].as_str().is_some_and(|e| e.contains("encoding") || e.contains("base64")),
-            "the error names the encoding budget: {reply}"
-        );
-        assert!(app.shots.requests.is_empty(), "a refused request reserves nothing");
-
-        // The same capture as a file is admitted within the per-image and encoding budgets.
-        let path = temp_png("encoding-path");
-        let (tx2, rx2) = std::sync::mpsc::channel();
-        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx2);
-        assert!(rx2.try_recv().is_err(), "the path form is admitted");
-        assert_eq!(app.shots.requests.len(), 1);
-        app.shots.cancel_all();
-    }
-
-    #[test]
-    /// Oversized text, repeated maximum texts, keys and moves are refused without changing the queue, and the byte/event limits are both enforced.
-    fn synthetic_text_key_and_move_producers_honour_the_queue_budget() {
-        let ctx = egui::Context::default();
-        let mut app = test_app();
-        // One oversized text event is refused before it is queued.
-        let huge = "x".repeat(MAX_SYNTHETIC_TEXT_BYTES + 1);
-        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": huge})) else { panic!("ui.text returns immediately") };
-        assert_eq!(reply["ok"], false, "{reply}");
-        assert!(app.synthetic.is_empty());
-
-        // The byte budget stops repeated maximum-size texts; the queue is left unchanged.
-        let max = "x".repeat(MAX_SYNTHETIC_TEXT_BYTES);
-        let mut refused_at = None;
-        for i in 0..64 {
-            let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": max.clone()})) else {
-                panic!("ui.text returns immediately")
-            };
-            if reply["ok"] == false {
-                refused_at = Some((i, app.synthetic.len()));
-                break;
-            }
-        }
-        let (accepted, queued) = refused_at.expect("the synthetic byte budget is enforced");
-        assert!(accepted > 0 && accepted < 64, "{accepted} texts fit");
-        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": max})) else { panic!("ui.text returns immediately") };
-        assert_eq!(reply["ok"], false);
-        assert_eq!(app.synthetic.len(), queued, "a refused text leaves the queue alone");
-
-        // Event count: keys and moves use the same overall budget as pointer gestures.
-        app.synthetic.clear();
-        let pos = egui::pos2(1.0, 1.0);
-        app.synthetic.push_back(vec![egui::Event::PointerMoved(pos); MAX_QUEUED_SYNTHETIC_EVENTS - 1]);
-        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.key", &json!({"key":"enter"})) else { panic!("ui.key returns immediately") };
-        assert_eq!(reply["ok"], false, "two key events do not fit in the last slot: {reply}");
-        assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), MAX_QUEUED_SYNTHETIC_EVENTS - 1);
-
-        app.synthetic.clear();
-        app.synthetic.push_back(vec![egui::Event::PointerMoved(pos); MAX_QUEUED_SYNTHETIC_EVENTS]);
-        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.move", &json!({"x":2.0,"y":2.0})) else { panic!("ui.move returns immediately") };
-        assert_eq!(reply["ok"], false, "{reply}");
-        assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), MAX_QUEUED_SYNTHETIC_EVENTS);
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/control/tests.rs b/crates/ui-egui/src/control/tests.rs
new file mode 100644
index 000000000..1b0ae80e5
--- /dev/null
+++ b/crates/ui-egui/src/control/tests.rs
@@ -0,0 +1,987 @@
+use super::*;
+
+fn sample() -> Vec<Json> {
+    vec![
+        json!({"id": "home.borders", "label": "Borders", "menu": ["Home", "Font"]}),
+        json!({"id": "home.bold", "label": "Bold", "menu": ["Home", "Font"]}),
+        json!({"id": "ui.ribbonTab", "label": "Ribbon Tab", "enabled": true, "ui": true}),
+    ]
+}
+
+fn ids(v: &[Json]) -> Vec<&str> {
+    v.iter().filter_map(|c| c.get("id").and_then(Json::as_str)).collect()
+}
+
+#[test]
+fn search_filters_case_insensitively() {
+    assert_eq!(ids(&filter_commands(sample(), Some("border"))), ["home.borders"]);
+    assert_eq!(filter_commands(sample(), Some("BORDER")), filter_commands(sample(), Some("border")));
+    assert_eq!(ids(&filter_commands(sample(), Some("ribbon"))), ["ui.ribbonTab"]);
+    assert_eq!(ids(&filter_commands(sample(), Some("font"))), ["home.borders", "home.bold"]);
+    assert!(filter_commands(sample(), Some("catalog_no_match_7391")).is_empty());
+    assert_eq!(filter_commands(sample(), None).len(), 3);
+}
+
+fn test_app() -> SheetApp {
+    let mut session = gridcraft_engine::Session::new();
+    session.new_workbook();
+    SheetApp::new(session, crate::Services::default())
+}
+
+#[test]
+/// Checks that oversized click/drag counts are refused without changing already queued batches, that queued input counts toward the budget, and that normal gestures still queue fully.
+fn oversized_pointer_requests_are_refused_and_leave_the_queue_alone() {
+    let mut app = test_app();
+    let p = egui::pos2(20.0, 20.0);
+    let m = egui::Modifiers::NONE;
+    let btn = egui::PointerButton::Primary;
+    assert!(push_click(&mut app, p, btn, 2, m).is_ok());
+    assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), 5);
+    assert!(push_click(&mut app, p, btn, u32::MAX, m).is_err());
+    assert!(push_drag(&mut app, p, p, usize::MAX, m).is_err());
+    assert!(push_drag(&mut app, p, p, MAX_QUEUED_SYNTHETIC_EVENTS, m).is_err());
+    assert_eq!(app.synthetic.len(), 2);
+    assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), 5);
+    // Already queued input counts toward the budget.
+    assert!(push_click(&mut app, p, btn, (MAX_QUEUED_SYNTHETIC_EVENTS / 2) as u32, m).is_err());
+    assert_eq!(app.synthetic.len(), 2);
+    // Normal requests still queue in full.
+    assert!(push_drag(&mut app, p, p + egui::vec2(40.0, 40.0), 3, m).is_ok());
+    assert_eq!(app.synthetic.len(), 8);
+}
+
+#[test]
+fn print_command_discovery_documents_settings_and_submission() {
+    let mut session = gridcraft_engine::Session::new();
+    session.new_workbook();
+    let mut app = SheetApp::new(session, crate::Services::default());
+    let Outcome::Done(reply) = handle(&mut app, &egui::Context::default(), "engine.commands", &json!({"search":"print"})) else {
+        panic!("command discovery must return immediately");
+    };
+    assert_eq!(reply["ok"], true);
+    let commands = reply["result"].as_array().unwrap();
+    for (id, expected_docs) in [
+        ("ui.printSettings", &["copies", "duplex", "refresh", "discovering", "status", "detail"][..]),
+        ("ui.printSubmit", &["file.print", "pagination", "pending", "without opening a dialog"][..]),
+    ] {
+        let command = commands.iter().find(|command| command["id"] == id).unwrap();
+        assert_eq!(command["ui"], true);
+        let docs = command["params"].as_str().unwrap();
+        for expected in expected_docs {
+            assert!(docs.contains(expected), "{id}: missing {expected}");
+        }
+    }
+    assert!(!app.printing.busy(), "discovery must not submit a job");
+    assert!(app.backstage.is_none(), "discovery must not open settings");
+}
+
+#[test]
+fn language_command_docs_list_every_language() {
+    let mut session = gridcraft_engine::Session::new();
+    session.new_workbook();
+    let mut app = SheetApp::new(session, crate::Services::default());
+    let Outcome::Done(reply) = handle(&mut app, &egui::Context::default(), "engine.commands", &json!({"search":"language"})) else {
+        panic!("command discovery must return immediately");
+    };
+    let commands = reply["result"].as_array().unwrap();
+    let docs = commands.iter().find(|c| c["id"] == "app.language.set").unwrap()["params"].as_str().unwrap();
+    for l in crate::i18n::Language::ALL {
+        assert!(docs.contains(&format!("\"{}\"", l.code())), "app.language.set docs miss {:?}: {docs}", l.code());
+    }
+}
+/// One headless UI pass. A test has no renderer to apply the font-atlas delta, so dropping
+/// it is intentional (0.37 panics when a `TexturesDelta` is dropped unapplied).
+fn ui_pass(ctx: &egui::Context, raw: egui::RawInput, f: impl FnMut(&mut egui::Ui)) -> egui::FullOutput {
+    let mut out = ctx.run_ui(raw, f);
+    out.textures_delta.clear();
+    out
+}
+
+/// Returns an egui context initialized by one blank pass at `size` with an 8192-pixel texture limit.
+fn sized_context(size: egui::Vec2) -> egui::Context {
+    let ctx = egui::Context::default();
+    let raw = egui::RawInput {
+        screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)),
+        max_texture_side: Some(8192),
+        ..Default::default()
+    };
+    let _ = ui_pass(&ctx, raw, |_| {});
+    ctx
+}
+
+/// Returns blank raw input with a screen rect at `size` and an 8192-pixel texture limit.
+fn raw_of(size: egui::Vec2) -> egui::RawInput {
+    egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), max_texture_side: Some(8192), ..Default::default() }
+}
+
+/// Extracts cloned `ViewportCommand::Screenshot` callbacks from a `FullOutput` for the context's viewport.
+fn screenshot_callbacks(out: &egui::FullOutput, ctx: &egui::Context) -> Vec<egui::ScreenshotCallback> {
+    out.viewport_output
+        .get(&ctx.viewport_id())
+        .map(|output| {
+            output
+                .commands
+                .iter()
+                .filter_map(|command| match command {
+                    egui::ViewportCommand::Screenshot(callback) => Some(callback.clone()),
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default()
+}
+
+/// Run three settled passes with `raw` and return the callbacks issued in them.
+fn issue_with(ctx: &egui::Context, app: &mut SheetApp, raw: egui::RawInput) -> Vec<egui::ScreenshotCallback> {
+    let mut callbacks = Vec::new();
+    for _ in 0..3 {
+        let out = ui_pass(ctx, raw.clone(), |ui| issue_screenshots(app, ui.ctx()));
+        callbacks.extend(screenshot_callbacks(&out, ctx));
+    }
+    callbacks
+}
+
+/// Returns a per-process temporary PNG path after removing any stale file at that path.
+fn temp_png(name: &str) -> std::path::PathBuf {
+    let path = std::env::temp_dir().join(format!("gridcraft-shot-{name}-{}.png", std::process::id()));
+    let _ = std::fs::remove_file(&path);
+    path
+}
+
+#[test]
+/// Checks rounded physical pixels, expected/retained byte counts, the texture-axis cap, the no-size case and overflow refusal.
+fn capture_geometry_reports_checked_capped_pixels() {
+    let geometry = CaptureGeometry {
+        viewport_id: egui::ViewportId::ROOT,
+        viewport: Some(egui::vec2(800.0, 600.0)),
+        pixels_per_point: 2.0,
+        zoom: 1.0,
+        max_texture_side: 4096,
+        minimized: None,
+        occluded: None,
+        visible: None,
+    };
+    assert_eq!(geometry.expected_size(), Some([1600, 1200]));
+    assert_eq!(geometry.expected_bytes(), Some(1600 * 1200 * 4));
+    assert_eq!(geometry.retained_bytes(), Some(1601 * 1201 * 4), "one pixel of rounding per axis is reserved too");
+    let capped = CaptureGeometry { max_texture_side: 1024, ..geometry };
+    assert_eq!(capped.expected_size(), Some([1024, 1024]), "the surface limit caps both axes");
+    let empty = CaptureGeometry { viewport: Some(egui::Vec2::ZERO), ..geometry };
+    assert_eq!(empty.expected_size(), None, "a minimized window has no capturable size");
+    assert_eq!(empty.retained_bytes(), None);
+    let huge = CaptureGeometry { viewport: Some(egui::vec2(f32::MAX, f32::MAX)), ..geometry };
+    assert_eq!(huge.expected_size(), None, "overflow is refused, not truncated");
+}
+
+#[test]
+/// Checks that one request beyond `SCREENSHOT_MAX_REQUESTS` is rejected with its token while earlier requests stay queued and do not reply early.
+fn screenshot_admission_stops_on_the_count_budget_without_evicting() {
+    let ctx = sized_context(egui::vec2(800.0, 600.0));
+    let mut app = test_app();
+    let mut replies = Vec::new();
+    for _ in 0..SCREENSHOT_MAX_REQUESTS {
+        let (tx, rx) = std::sync::mpsc::channel();
+        admit(&mut app, &ctx, None, tx);
+        replies.push(rx);
+    }
+    assert_eq!(app.shots.requests.len(), SCREENSHOT_MAX_REQUESTS);
+    assert!(replies.iter_mut().all(|r| r.try_recv().is_err()), "admitted requests do not reply early");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    let reply = rx.try_recv().expect("the over-count request is rejected");
+    assert_eq!(reply["ok"], false);
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("limit 4")), "{reply}");
+    assert!(reply["request"].as_u64().is_some(), "a rejection carries its request token: {reply}");
+    assert_eq!(app.shots.requests.len(), SCREENSHOT_MAX_REQUESTS, "an earlier request is never evicted");
+}
+
+#[test]
+/// Three roughly 100 MB path captures hit the aggregate byte limit; the third is rejected and only two requests remain.
+fn screenshot_admission_stops_on_aggregate_bytes_before_the_count() {
+    let ctx = sized_context(egui::vec2(5000.0, 5000.0));
+    let mut app = test_app();
+    let path = temp_png("aggregate").to_string_lossy().into_owned();
+    let mut rejected = None;
+    for _ in 0..3 {
+        let (tx, rx) = std::sync::mpsc::channel();
+        // A path capture (not base64) isolates the retained-image aggregate budget.
+        admit(&mut app, &ctx, Some(path.clone()), tx);
+        if let Ok(reply) = rx.try_recv() {
+            rejected = Some(reply);
+        }
+    }
+    let reply = rejected.expect("three 100 MB captures exceed the 256 MiB aggregate budget");
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("aggregate limit")), "{reply}");
+    assert_eq!(app.shots.requests.len(), 2);
+}
+
+#[test]
+/// An unknown-size request reserves the placeholder, issues nothing while settling, then replies once on timeout and releases the reservation.
+fn requests_without_a_size_stay_queued_and_time_out() {
+    let ctx = sized_context(egui::Vec2::ZERO);
+    let mut app = test_app();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    assert!(rx.try_recv().is_err(), "an unknown size is queued, not refused with an overflow error");
+    assert_eq!(app.shots.requests[0].bytes, UNKNOWN_CAPTURE_BYTES, "the largest possible image is reserved meanwhile");
+    // Settling passes without a size neither issue nor fail the request.
+    let callbacks = issue_with(&ctx, &mut app, raw_of(egui::Vec2::ZERO));
+    assert!(callbacks.is_empty());
+    assert!(!app.shots.requests[0].issued);
+    assert!(rx.try_recv().is_err());
+    app.shots.requests[0].deadline = 0.0;
+    let _ = ui_pass(&ctx, raw_of(egui::Vec2::ZERO), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the size-less request times out once");
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("capturable size")), "{reply}");
+    assert_eq!(app.shots.reserved(), 0, "the placeholder reservation is released");
+}
+
+/// Counts `RequestPaintWhileHidden` commands in a logic output.
+fn hidden_paints(out: &egui::LogicOutput) -> usize {
+    out.viewport_commands.values().flatten().filter(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)).count()
+}
+
+#[test]
+/// A queued capture requests a hidden paint; once issued, the screenshot command supplies the paint itself.
+fn a_queued_capture_requests_hidden_paint_until_it_is_issued() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let (tx, _rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    let queued = ctx.run_logic(&raw_of(egui::vec2(64.0, 48.0)), |ctx| app.logic(ctx));
+    assert_eq!(hidden_paints(&queued), 1, "a queued capture needs a real `ui` pass");
+
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    let issued = ctx.run_logic(&raw_of(egui::vec2(64.0, 48.0)), |ctx| app.logic(ctx));
+    assert_eq!(hidden_paints(&issued), 0, "the issued Screenshot command paints the hidden window by itself");
+}
+
+#[test]
+/// A minimized request stays queued without requesting hidden paints, because it cannot issue until restored.
+fn a_minimized_capture_does_not_force_hidden_frames_while_it_waits() {
+    let ctx = egui::Context::default();
+    let mut app = test_app();
+    let mut raw = raw_of(egui::vec2(800.0, 600.0));
+    if let Some(v) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
+        v.inner_rect = None;
+        v.minimized = Some(true);
+    }
+    app.raw_input_hook(&ctx, &mut raw);
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    assert!(rx.try_recv().is_err());
+    let waited = ctx.run_logic(&raw, |ctx| app.logic(ctx));
+    assert_eq!(hidden_paints(&waited), 0, "a minimized request cannot issue until it is restored");
+    app.shots.cancel_all();
+}
+
+#[test]
+/// The real app harness issues exactly one callback, replies once with the token and dimensions, and releases the reservation.
+fn one_admitted_capture_issues_one_callback_and_replies_once() {
+    use egui_kittest::kittest::Queryable as _;
+
+    let mut app = test_app();
+    app.use_prepared_fonts();
+    let mut h = egui_kittest::Harness::builder()
+        .with_size(egui::vec2(900.0, 700.0))
+        .with_context_setup(|ctx| {
+            ctx.set_fonts(crate::theme::pinned_font_definitions());
+            crate::theme::apply(ctx, false);
+        })
+        // This test completes the callback itself. Keep the real app/AccessKit tree, but
+        // do not let kittest's automatic screenshot handling initialize a GPU renderer.
+        .renderer(egui_kittest::LazyRenderer::Uninitialized { textures_delta: Default::default(), builder: None })
+        .build_ui_state(
+            |ui, app: &mut SheetApp| {
+                app.logic(ui.ctx());
+                app.ui(ui);
+            },
+            app,
+        );
+    h.run_steps(4);
+    assert!(h.query_by_label("Name Box").is_some(), "the capture fixture draws the real app, not an empty tree");
+    h.check_accessibility();
+
+    let ctx = h.ctx.clone();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(h.state_mut(), &ctx, None, tx);
+    let token = h.state().shots.requests[0].token;
+    h.state_mut().shots.requests[0].ready_at = 0.0;
+    let mut callbacks = Vec::new();
+    for _ in 0..3 {
+        h.step();
+        callbacks.extend(screenshot_callbacks(h.output(), &ctx));
+    }
+    assert_eq!(callbacks.len(), 1, "the settled request is issued once");
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([900, 700], egui::Color32::RED)));
+    h.step(); // the real logic drains the callback and the UI repaints
+    h.check_accessibility();
+    assert!(h.query_by_label("Name Box").is_some(), "the app tree survives callback drain and repaint");
+    let reply = rx.try_recv().expect("the drain replies once");
+    assert_eq!(reply["ok"], true, "{reply}");
+    assert_eq!(reply["result"]["width"], 900);
+    assert_eq!(reply["result"]["height"], 700);
+    assert_eq!(reply["request"].as_u64(), Some(token), "the reply names its request");
+    assert!(rx.try_recv().is_err(), "a completed slot is taken exactly once");
+    assert_eq!(h.state().shots.reserved(), 0, "the reservation is released after the reply");
+}
+
+#[test]
+/// Completing callbacks in reverse order replies on each matching token/path and writes each request's own pixels.
+fn out_of_order_completions_reply_on_their_own_request() {
+    let ctx = sized_context(egui::vec2(8.0, 8.0));
+    let mut app = test_app();
+    let p1 = temp_png("order-1");
+    let p2 = temp_png("order-2");
+    let (tx1, rx1) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(p1.to_string_lossy().into_owned()), tx1);
+    let token1 = app.shots.requests[0].token;
+    let (tx2, rx2) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(p2.to_string_lossy().into_owned()), tx2);
+    let token2 = app.shots.requests[1].token;
+    for request in &mut app.shots.requests {
+        request.ready_at = 0.0;
+    }
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 2, "one callback per admitted request");
+    // Complete the second request first: slots, not callback order, carry the result.
+    callbacks[1].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([8, 8], egui::Color32::BLUE)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let second = rx2.try_recv().expect("the second request gets its own reply");
+    assert_eq!(second["ok"], true, "{second}");
+    assert_eq!(second["request"].as_u64(), Some(token2));
+    assert_eq!(second["result"]["path"].as_str(), Some(p2.to_string_lossy().as_ref()));
+    assert!(!p1.exists(), "the unfinished request has not written anything");
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([8, 8], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let first = rx1.try_recv().expect("the first request gets its own reply");
+    assert_eq!(first["request"].as_u64(), Some(token1));
+    assert_eq!(first["result"]["path"].as_str(), Some(p1.to_string_lossy().as_ref()));
+    assert_ne!(std::fs::read(&p1).unwrap(), std::fs::read(&p2).unwrap(), "each reply carries its own pixels");
+    let _ = std::fs::remove_file(&p1);
+    let _ = std::fs::remove_file(&p2);
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// An expired request replies once with a timeout, writes no file and releases its reservation.
+fn a_timed_out_capture_replies_once_and_never_writes() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let path = temp_png("timeout");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    app.shots.requests[0].deadline = 0.0;
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the timeout replies");
+    assert_eq!(reply["ok"], false);
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("timeout")), "{reply}");
+    assert!(!path.exists(), "a timed-out capture never writes a file");
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    assert!(rx.try_recv().is_err(), "a timeout is reported once");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// A valid image that completes after its deadline gets one timeout reply and is not written.
+fn a_capture_completed_after_its_deadline_writes_nothing() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let path = temp_png("late");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    let token = app.shots.requests[0].token;
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    // The deadline passes while the callback is outstanding; the image arrives afterwards.
+    app.shots.requests[0].deadline = 0.0;
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the late completion gets one timeout reply");
+    assert_eq!(reply["ok"], false, "{reply}");
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("timeout")), "{reply}");
+    assert_eq!(reply["request"].as_u64(), Some(token));
+    assert!(!path.exists(), "a capture that completed after its deadline never writes a file");
+    assert!(rx.try_recv().is_err(), "the late image is reported once");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Cancelling a request does not reply; a later callback for it is ignored and writes nothing.
+fn a_callback_after_the_request_is_removed_is_inert() {
+    let ctx = sized_context(egui::vec2(32.0, 24.0));
+    let mut app = test_app();
+    let path = temp_png("removed");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    app.shots.cancel_all();
+    assert!(rx.try_recv().is_err(), "cancelling a request does not reply");
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    assert!(rx.try_recv().is_err(), "a callback for a removed request is inert");
+    assert!(!path.exists());
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// The first issuance adopts a new geometry, updates the epoch and reservation, spends no retry, and the capture then succeeds.
+fn a_resize_between_admission_and_issuance_does_not_cost_a_retry() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let admitted_epoch = app.shots.requests[0].epoch;
+    let resized = raw_of(egui::vec2(32.0, 24.0));
+    let callbacks = issue_with(&ctx, &mut app, resized.clone());
+    assert_eq!(callbacks.len(), 1);
+    let request = &app.shots.requests[0];
+    assert_eq!(request.retries, 0, "the first issuance adopts the current geometry instead of spending a retry");
+    assert_eq!(request.geometry.viewport, Some(egui::vec2(32.0, 24.0)));
+    assert_eq!(request.expected, Some([32, 24]));
+    assert_eq!(request.bytes, 33 * 25 * 4);
+    assert!(request.epoch > admitted_epoch, "issuance records the new epoch together with the geometry");
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, resized, |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the once-issued capture replies");
+    assert_eq!(reply["ok"], true, "{reply}");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// The reservation is the largest accepted rounded image (11×9×4 bytes for a 10×8 viewport), and that image is accepted.
+fn the_retained_reservation_is_the_slot_bound() {
+    let ctx = sized_context(egui::vec2(10.0, 8.0));
+    let mut app = test_app();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    // validate_image accepts one pixel of rounding per axis: an 11x9 image is the largest.
+    assert_eq!(app.shots.requests[0].bytes, 11 * 9 * 4);
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([11, 9], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the rounded image is accepted");
+    assert_eq!(reply["ok"], true, "{reply}");
+    assert_eq!(reply["result"]["width"], 11);
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Oversized images retry within the bounded budget, never write, then report the per-image limit, while the valid peer is written.
+fn an_image_beyond_the_reservation_is_released_without_writing() {
+    let ctx = sized_context(egui::vec2(10.0, 8.0));
+    let mut app = test_app();
+    let p1 = temp_png("over-1");
+    let p2 = temp_png("over-2");
+    let (tx1, rx1) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(p1.to_string_lossy().into_owned()), tx1);
+    let (tx2, rx2) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(p2.to_string_lossy().into_owned()), tx2);
+    for request in &mut app.shots.requests {
+        request.ready_at = 0.0;
+    }
+    assert_eq!(app.shots.reserved(), 2 * 11 * 9 * 4);
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 2);
+    // The slot refuses an image over the reservation instead of retaining bytes beyond it.
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([12, 9], egui::Color32::RED)));
+    // The other request completes with valid pixels.
+    callbacks[1].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([10, 8], egui::Color32::BLUE)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    // A larger image can be a genuine resize, so it receives the same bounded retries as
+    // a smaller one. Each oversized callback is released and never written while retrying.
+    for attempt in 1..=SCREENSHOT_MAX_RETRIES {
+        assert_eq!(app.shots.requests[0].retries, attempt);
+        assert!(rx1.try_recv().is_err(), "retry {attempt} has not replied early");
+        assert!(!p1.exists(), "oversized pixels are never written on retry {attempt}");
+        let callbacks = issue_with(&ctx, &mut app, raw_of(egui::vec2(10.0, 8.0)));
+        assert_eq!(callbacks.len(), 1, "the other valid request is already complete");
+        callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([12, 9], egui::Color32::RED)));
+        let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    }
+    let refused = rx1.try_recv().expect("the oversized image is reported after bounded retries");
+    assert_eq!(refused["ok"], false, "{refused}");
+    assert!(refused["error"].as_str().is_some_and(|e| e.contains("per-image limit")), "{refused}");
+    assert!(!p1.exists());
+    let accepted = rx2.try_recv().expect("the valid image is written");
+    assert_eq!(accepted["ok"], true, "{accepted}");
+    let _ = std::fs::remove_file(&p2);
+    assert_eq!(app.shots.reserved(), 0, "both reservations are released");
+}
+
+#[test]
+/// Two `ui` calls in one pass count as one settling frame, and a pass that requests a discard is not counted; only its rerun counts.
+fn settling_counts_one_real_pass_and_skips_a_discarded_one() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let (tx, _rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    // Two `ui` calls in one pass are one settling frame.
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| {
+        issue_screenshots(&mut app, ui.ctx());
+        issue_screenshots(&mut app, ui.ctx());
+    });
+    assert_eq!(app.shots.requests[0].frames, 1);
+    // A pass that already asked to be discarded does not count, even though `run_ui` repeats it.
+    let mut asked = false;
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| {
+        if !asked {
+            asked = true;
+            ui.ctx().request_discard("settling test");
+        }
+        issue_screenshots(&mut app, ui.ctx());
+    });
+    assert_eq!(app.shots.requests[0].frames, 2, "only the rerun (real) pass counted");
+}
+
+#[test]
+/// Issuance survives a discard requested after it, the image is written once, and a duplicate callback completion is inert.
+fn a_discard_requested_after_issuance_still_issues_and_writes_once() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let path = temp_png("discard-after-issue");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let mut asked = false;
+    let mut callbacks = Vec::new();
+    for _ in 0..3 {
+        let out = ui_pass(&ctx, egui::RawInput::default(), |ui| {
+            issue_screenshots(&mut app, ui.ctx());
+            if !asked && app.shots.requests.first().is_some_and(|r| r.issued) {
+                asked = true;
+                ui.ctx().request_discard("discard after screenshot issuance");
+            }
+        });
+        callbacks.extend(screenshot_callbacks(&out, &ctx));
+    }
+    assert!(asked, "the test requested a discard after issuance");
+    assert_eq!(callbacks.len(), 1, "issuance happens exactly once across the discard repeat");
+    let image = std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED));
+    callbacks[0].clone().complete(image.clone());
+    callbacks[0].clone().complete(image);
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the discarded pass still delivers one reply");
+    assert_eq!(reply["ok"], true, "{reply}");
+    assert!(path.exists(), "the image is written exactly once");
+    assert!(rx.try_recv().is_err(), "a second completion of the same callback is inert");
+    let _ = std::fs::remove_file(&path);
+}
+
+#[test]
+/// A grow-resize spends one retry, reissues at the new size and then accepts the new image.
+fn an_image_larger_than_the_reservation_retries_like_a_smaller_one() {
+    let ctx = sized_context(egui::vec2(10.0, 8.0));
+    let mut app = test_app();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+
+    // The surface grew by two pixels while the image was outstanding. The slot's reservation
+    // refuses the larger image before `validate_image`; drain must retry at the new geometry
+    // instead of failing because the resize went in this direction.
+    let mut grown = raw_of(egui::vec2(20.0, 16.0));
+    app.raw_input_hook(&ctx, &mut grown);
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([12, 9], egui::Color32::RED)));
+    let _ = ctx.run_logic(&grown, |ctx| app.logic(ctx));
+    let request = &app.shots.requests[0];
+    assert_eq!(request.retries, 1, "the slot's per-image refusal spends one retry, not a failure");
+    assert!(!request.issued);
+    assert_eq!(request.geometry.viewport, Some(egui::vec2(20.0, 16.0)));
+    assert!(rx.try_recv().is_err(), "a retried capture does not reply yet");
+
+    let callbacks = issue_with(&ctx, &mut app, raw_of(egui::vec2(20.0, 16.0)));
+    assert_eq!(callbacks.len(), 1);
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([20, 16], egui::Color32::BLUE)));
+    let _ = ui_pass(&ctx, raw_of(egui::vec2(20.0, 16.0)), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the retried capture replies");
+    assert_eq!(reply["ok"], true, "{reply}");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Minimize retries reserve unknown-size bytes; only two fit the aggregate budget and stay queued (the rest are reported), and the survivors write after restore.
+fn a_minimize_retry_without_a_size_still_checks_the_aggregate_budget() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let mut paths = Vec::new();
+    let mut receivers = Vec::new();
+    for n in 0..SCREENSHOT_MAX_REQUESTS {
+        let path = temp_png(&format!("minimize-retry-{n}"));
+        let (tx, rx) = std::sync::mpsc::channel();
+        // A path capture isolates the retained-image aggregate budget.
+        admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+        paths.push(path);
+        receivers.push(rx);
+    }
+    for request in &mut app.shots.requests {
+        request.ready_at = 0.0;
+    }
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), SCREENSHOT_MAX_REQUESTS, "four path captures fit every budget");
+    assert_eq!(app.shots.reserved(), SCREENSHOT_MAX_REQUESTS * 65 * 49 * 4);
+
+    // The window is minimized with every capture outstanding. The drain retries each one
+    // against the new surface generation, which has no capturable size, so every retry
+    // reserves UNKNOWN_CAPTURE_BYTES. Only two unknown-size reservations fit the aggregate
+    // limit; the rest must be reported instead of inflating `reserved()` over the budget.
+    let mut minimized = raw_of(egui::vec2(64.0, 48.0));
+    if let Some(viewport) = minimized.viewports.get_mut(&egui::ViewportId::ROOT) {
+        viewport.inner_rect = None;
+        viewport.minimized = Some(true);
+    }
+    app.raw_input_hook(&ctx, &mut minimized);
+    let image = std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED));
+    for callback in &callbacks {
+        callback.clone().complete(image.clone());
+    }
+    let _ = ctx.run_logic(&minimized, |ctx| app.logic(ctx));
+
+    assert!(
+        app.shots.reserved() <= SCREENSHOT_MAX_AGGREGATE_BYTES,
+        "size-less retries reserved {} bytes, over the {SCREENSHOT_MAX_AGGREGATE_BYTES}-byte aggregate limit",
+        app.shots.reserved()
+    );
+    let rejected: Vec<Json> = receivers.iter_mut().filter_map(|rx| rx.try_recv().ok()).collect();
+    assert_eq!(rejected.len(), 2, "two unknown-size retries no longer fit the aggregate budget");
+    assert!(rejected.iter().all(|reply| reply["error"].as_str().is_some_and(|e| e.contains("aggregate limit"))), "{rejected:?}");
+    assert_eq!(app.shots.requests.len(), 2, "the two fitting retries stay queued");
+    assert!(app.shots.requests.iter().all(|r| !r.issued && r.expected.is_none() && r.bytes == UNKNOWN_CAPTURE_BYTES));
+    assert!(receivers.iter_mut().all(|rx| rx.try_recv().is_err()), "the surviving retries wait for the restore");
+
+    // Restoring re-issues only the surviving requests at the real size; both fit because the
+    // over-reserved retries were rejected rather than kept.
+    let mut restored = raw_of(egui::vec2(64.0, 48.0));
+    if let Some(viewport) = restored.viewports.get_mut(&egui::ViewportId::ROOT) {
+        viewport.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(64.0, 48.0)));
+        viewport.minimized = Some(false);
+        viewport.occluded = Some(false);
+    }
+    app.raw_input_hook(&ctx, &mut restored);
+    let callbacks = issue_with(&ctx, &mut app, restored.clone());
+    assert_eq!(callbacks.len(), 2, "the surviving requests issue on restore");
+    for callback in &callbacks {
+        callback.clone().complete(image.clone());
+    }
+    let _ = ctx.run_logic(&restored, |ctx| app.logic(ctx));
+
+    let mut delivered = 0;
+    for rx in &mut receivers {
+        if let Ok(reply) = rx.try_recv() {
+            assert_eq!(reply["ok"], true, "{reply}");
+            delivered += 1;
+        }
+    }
+    assert_eq!(delivered, 2, "the two surviving captures reply once each");
+    let written = paths.iter().filter(|path| path.exists()).count();
+    assert_eq!(written, 2, "only the surviving captures write their image");
+    for path in &paths {
+        let _ = std::fs::remove_file(path);
+    }
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Fresh hidden viewport geometry invalidates the old image, spends one retry, and the reissued image succeeds.
+fn a_hidden_resize_rejects_an_image_issued_before_it_and_reissues() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED)));
+
+    // A hidden tick carries the resize in `RawInput::viewports`; the last UI pass still says
+    // 64x48, so only the fresh viewport info lets the drain see the change.
+    let hidden = || {
+        let mut raw = raw_of(egui::vec2(64.0, 48.0));
+        if let Some(viewport) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
+            viewport.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(32.0, 400.0)));
+            viewport.native_pixels_per_point = Some(1.0);
+        }
+        raw
+    };
+    let _ = ctx.run_logic(&hidden(), |ctx| app.logic(ctx));
+    let request = &app.shots.requests[0];
+    assert!(!request.issued, "the image captured before the hidden resize is not accepted");
+    assert_eq!(request.retries, 1);
+    assert_eq!(request.geometry.viewport, Some(egui::vec2(32.0, 400.0)));
+    assert!(rx.try_recv().is_err(), "a retried capture does not reply yet");
+
+    // The next real pass issues against the new size and its image is accepted.
+    let resized = raw_of(egui::vec2(32.0, 24.0));
+    let callbacks = issue_with(&ctx, &mut app, resized.clone());
+    assert_eq!(callbacks.len(), 1, "the retry is issued once against the current geometry");
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::BLUE)));
+    let _ = ui_pass(&ctx, resized, |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the retried capture replies");
+    assert_eq!(reply["ok"], true, "{reply}");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Draining four completed captures replies to all of them and permits a new admission.
+fn a_drained_capture_frees_its_slot_for_the_next_admission() {
+    let ctx = sized_context(egui::vec2(8.0, 8.0));
+    let mut app = test_app();
+    let mut receivers = Vec::new();
+    for _ in 0..SCREENSHOT_MAX_REQUESTS {
+        let (tx, rx) = std::sync::mpsc::channel();
+        admit(&mut app, &ctx, None, tx);
+        receivers.push(rx);
+    }
+    for request in &mut app.shots.requests {
+        request.ready_at = 0.0;
+    }
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    for callback in &callbacks {
+        callback.clone().complete(std::sync::Arc::new(egui::ColorImage::filled([8, 8], egui::Color32::GREEN)));
+    }
+    assert_eq!(app.shots.requests.len(), SCREENSHOT_MAX_REQUESTS);
+    // Draining before admitting is what `logic` does: completed requests release first.
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    assert_eq!(app.shots.requests.len(), 0);
+    assert!(receivers.iter_mut().all(|rx| rx.try_recv().is_ok()));
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    assert!(rx.try_recv().is_err(), "a new request is admitted once the drained slots are free");
+    assert_eq!(app.shots.requests.len(), 1);
+}
+
+#[test]
+/// Uses `screen_rect` when `inner_rect` is absent, applies native scale times zoom, and advances the epoch on a hidden resize.
+fn raw_input_geometry_uses_screen_rect_when_inner_rect_is_absent() {
+    // Wayland always omits `inner_rect`; the fresh `RawInput::screen_rect` is the only size.
+    let ctx = sized_context(egui::vec2(800.0, 600.0));
+    let mut app = test_app();
+    let mut raw = raw_of(egui::vec2(1280.0, 720.0));
+    if let Some(v) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
+        v.inner_rect = None;
+        v.native_pixels_per_point = Some(2.0);
+        v.minimized = Some(false);
+        v.occluded = Some(false);
+    }
+    app.raw_input_hook(&ctx, &mut raw);
+    let geo = app.capture_geometry.expect("the raw frame records its geometry");
+    assert_eq!(geo.viewport, Some(egui::vec2(1280.0, 720.0)));
+    assert_eq!(geo.pixels_per_point, 2.0, "native scale times zoom");
+    assert_eq!(geo.expected_size(), Some([2560, 1440]));
+
+    let epoch = app.capture_epoch;
+    // A hidden resize lands on a logic-only tick: no UI pass ran, but the raw frame is fresh.
+    let mut hidden = raw_of(egui::vec2(640.0, 480.0));
+    if let Some(v) = hidden.viewports.get_mut(&egui::ViewportId::ROOT) {
+        v.inner_rect = None;
+        v.native_pixels_per_point = Some(2.0);
+        v.minimized = Some(false);
+        v.occluded = Some(true);
+    }
+    app.raw_input_hook(&ctx, &mut hidden);
+    let _ = ctx.run_logic(&hidden, |ctx| app.logic(ctx));
+    assert!(app.capture_epoch > epoch, "a hidden resize is a new epoch");
+    assert_eq!(app.capture_geometry.expect("geometry").viewport, Some(egui::vec2(640.0, 480.0)));
+}
+
+#[test]
+/// Minimized geometry has no size and reserves unknown bytes; restoring at the same size still changes the epoch.
+fn minimized_geometry_has_no_size_and_restore_bumps_the_epoch() {
+    let ctx = egui::Context::default();
+    let mut app = test_app();
+    let mut minimized = raw_of(egui::vec2(800.0, 600.0));
+    if let Some(v) = minimized.viewports.get_mut(&egui::ViewportId::ROOT) {
+        v.inner_rect = None;
+        v.minimized = Some(true);
+    }
+    app.raw_input_hook(&ctx, &mut minimized);
+    let geo = app.capture_geometry.expect("recorded");
+    assert_eq!(geo.viewport, None, "a minimized window has no capturable size");
+    assert_eq!(geo.visible, Some(false));
+
+    // Admission while minimized reserves the unknown-size maximum and waits.
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    assert_eq!(app.shots.requests[0].bytes, UNKNOWN_CAPTURE_BYTES);
+    assert!(rx.try_recv().is_err());
+    let epoch = app.capture_epoch;
+
+    // Restoring at the same logical size is still a new surface generation.
+    let mut restored = raw_of(egui::vec2(800.0, 600.0));
+    if let Some(v) = restored.viewports.get_mut(&egui::ViewportId::ROOT) {
+        v.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0)));
+        v.minimized = Some(false);
+        v.occluded = Some(false);
+    }
+    app.raw_input_hook(&ctx, &mut restored);
+    assert!(app.capture_epoch > epoch, "minimize/restore at the same size changes the epoch");
+    assert_eq!(app.capture_geometry.expect("geometry").viewport, Some(egui::vec2(800.0, 600.0)));
+    app.shots.cancel_all();
+}
+
+#[test]
+/// Switching documents before issuance cancels the request once with a document-changed error and writes nothing.
+fn a_document_switch_before_issuance_cancels_without_writing() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let path = temp_png("doc-queued");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let admitted = app.shots.requests[0].document;
+    assert!(app.run("file.new", json!({})).is_ok());
+    assert_ne!(app.session.active().map(|d| d.uid), admitted, "the test switched documents");
+
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert!(callbacks.is_empty(), "a capture for another document is never issued");
+    let reply = rx.try_recv().expect("the queued request is cancelled once");
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("document changed")), "{reply}");
+    assert!(!path.exists(), "no pixels for the old document are written to its path");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Switching documents after issuance rejects the completed image once and writes nothing.
+fn a_document_switch_after_issuance_rejects_the_completed_image() {
+    let ctx = sized_context(egui::vec2(64.0, 48.0));
+    let mut app = test_app();
+    let path = temp_png("doc-issued");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    assert!(app.run("file.new", json!({})).is_ok());
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([64, 48], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the switched document is reported once");
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("document changed")), "{reply}");
+    assert!(!path.exists(), "a completion after a document switch never writes");
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// A request bound to another viewport is rejected once with a viewport error and writes nothing.
+fn a_completion_for_another_viewport_is_rejected() {
+    let ctx = sized_context(egui::vec2(32.0, 24.0));
+    let mut app = test_app();
+    let path = temp_png("viewport");
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx);
+    app.shots.requests[0].ready_at = 0.0;
+    let callbacks = issue_with(&ctx, &mut app, egui::RawInput::default());
+    assert_eq!(callbacks.len(), 1);
+    // A slot/request bound to a different viewport must not fill this one.
+    app.shots.requests[0].viewport_id = egui::ViewportId::from_hash_of("other-window");
+    callbacks[0].clone().complete(std::sync::Arc::new(egui::ColorImage::filled([32, 24], egui::Color32::RED)));
+    let _ = ui_pass(&ctx, egui::RawInput::default(), |ui| drain_screenshots(&mut app, ui.ctx()));
+    let reply = rx.try_recv().expect("the viewport mismatch is reported once");
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("another viewport")), "{reply}");
+    assert!(!path.exists());
+    assert_eq!(app.shots.reserved(), 0);
+}
+
+#[test]
+/// Accepts one-pixel rounding on a single axis, but rejects opposite-axis deviation, aspect distortion and more than one pixel of error.
+fn validate_image_rejects_distortion_but_allows_one_pixel_rounding() {
+    let image = |w: usize, h: usize| egui::ColorImage::filled([w, h], egui::Color32::RED);
+    assert!(validate_image(&image(100, 100), [100, 100]).is_ok());
+    assert!(validate_image(&image(101, 100), [100, 100]).is_ok(), "one pixel of rounding on one axis is legitimate");
+    assert!(validate_image(&image(100, 101), [100, 100]).is_ok());
+    assert!(validate_image(&image(101, 99), [100, 100]).is_err(), "independent per-axis tolerance must not accept a distorted image");
+    assert!(validate_image(&image(99, 101), [100, 100]).is_err());
+    assert!(validate_image(&image(102, 100), [100, 100]).is_err(), "more than one pixel per axis is a different surface");
+}
+
+#[test]
+/// Checks the encoding working-set threshold, the base64 reply cap, and the retained-plus-encoding peak budget.
+fn encoding_working_set_is_bounded_for_admitted_captures() {
+    assert!(encoding_working_bytes([8191, 2048], false).expect("checked") <= SCREENSHOT_MAX_ENCODING_BYTES);
+    assert!(encoding_working_bytes([8192, 8192], false).expect("checked") > SCREENSHOT_MAX_ENCODING_BYTES);
+    assert!(encoding_working_bytes([4000, 3000], true).expect("checked") <= SCREENSHOT_MAX_ENCODING_BYTES);
+    assert!(encoding_working_bytes([5000, 4000], true).expect("checked") > SCREENSHOT_MAX_ENCODING_BYTES);
+    // The base64 reply itself is capped too, before the string exists.
+    let png = png_worst_bytes(5000 * 4000 * 4, 4000).expect("checked");
+    assert!(base64_len(png).expect("checked") > SCREENSHOT_MAX_BASE64_BYTES);
+    // Retained requests plus one encoding working set are held to a hard peak.
+    assert!(check_peak_budget(0, [64, 48], false).is_ok());
+    assert!(check_peak_budget(SCREENSHOT_MAX_AGGREGATE_BYTES, [9000, 4096], false).is_err());
+}
+
+#[test]
+/// An oversized base64 capture is refused with nothing reserved, while the same capture as a path is admitted.
+fn base64_capture_over_the_encoding_budget_is_rejected_before_admission() {
+    let ctx = sized_context(egui::vec2(5000.0, 4000.0));
+    let mut app = test_app();
+    let (tx, rx) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, None, tx);
+    let reply = rx.try_recv().expect("an oversized base64 capture is refused at admission");
+    assert_eq!(reply["ok"], false, "{reply}");
+    assert!(
+        reply["error"].as_str().is_some_and(|e| e.contains("encoding") || e.contains("base64")),
+        "the error names the encoding budget: {reply}"
+    );
+    assert!(app.shots.requests.is_empty(), "a refused request reserves nothing");
+
+    // The same capture as a file is admitted within the per-image and encoding budgets.
+    let path = temp_png("encoding-path");
+    let (tx2, rx2) = std::sync::mpsc::channel();
+    admit(&mut app, &ctx, Some(path.to_string_lossy().into_owned()), tx2);
+    assert!(rx2.try_recv().is_err(), "the path form is admitted");
+    assert_eq!(app.shots.requests.len(), 1);
+    app.shots.cancel_all();
+}
+
+#[test]
+/// Oversized text, repeated maximum texts, keys and moves are refused without changing the queue, and the byte/event limits are both enforced.
+fn synthetic_text_key_and_move_producers_honour_the_queue_budget() {
+    let ctx = egui::Context::default();
+    let mut app = test_app();
+    // One oversized text event is refused before it is queued.
+    let huge = "x".repeat(MAX_SYNTHETIC_TEXT_BYTES + 1);
+    let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": huge})) else { panic!("ui.text returns immediately") };
+    assert_eq!(reply["ok"], false, "{reply}");
+    assert!(app.synthetic.is_empty());
+
+    // The byte budget stops repeated maximum-size texts; the queue is left unchanged.
+    let max = "x".repeat(MAX_SYNTHETIC_TEXT_BYTES);
+    let mut refused_at = None;
+    for i in 0..64 {
+        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": max.clone()})) else {
+            panic!("ui.text returns immediately")
+        };
+        if reply["ok"] == false {
+            refused_at = Some((i, app.synthetic.len()));
+            break;
+        }
+    }
+    let (accepted, queued) = refused_at.expect("the synthetic byte budget is enforced");
+    assert!(accepted > 0 && accepted < 64, "{accepted} texts fit");
+    let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": max})) else { panic!("ui.text returns immediately") };
+    assert_eq!(reply["ok"], false);
+    assert_eq!(app.synthetic.len(), queued, "a refused text leaves the queue alone");
+
+    // Event count: keys and moves use the same overall budget as pointer gestures.
+    app.synthetic.clear();
+    let pos = egui::pos2(1.0, 1.0);
+    app.synthetic.push_back(vec![egui::Event::PointerMoved(pos); MAX_QUEUED_SYNTHETIC_EVENTS - 1]);
+    let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.key", &json!({"key":"enter"})) else { panic!("ui.key returns immediately") };
+    assert_eq!(reply["ok"], false, "two key events do not fit in the last slot: {reply}");
+    assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), MAX_QUEUED_SYNTHETIC_EVENTS - 1);
+
+    app.synthetic.clear();
+    app.synthetic.push_back(vec![egui::Event::PointerMoved(pos); MAX_QUEUED_SYNTHETIC_EVENTS]);
+    let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.move", &json!({"x":2.0,"y":2.0})) else { panic!("ui.move returns immediately") };
+    assert_eq!(reply["ok"], false, "{reply}");
+    assert_eq!(app.synthetic.iter().map(Vec::len).sum::<usize>(), MAX_QUEUED_SYNTHETIC_EVENTS);
+}

From 46a406c034db7a07c2d08fa66b6abc5992198b64 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:45 +0000
Subject: [PATCH 38/76] refactor(ui-egui): move grid tests to src/grid/tests.rs

---
 crates/ui-egui/src/grid.rs       | 310 +------------------------------
 crates/ui-egui/src/grid/tests.rs | 306 ++++++++++++++++++++++++++++++
 2 files changed, 307 insertions(+), 309 deletions(-)
 create mode 100644 crates/ui-egui/src/grid/tests.rs

diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index 2f9a1ba6e..970ab61dd 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -4201,315 +4201,7 @@ pub(crate) fn heading_font_size(zoom: f32) -> f32 {
 }
 
 #[cfg(test)]
-mod tests {
-
-    #[test]
-    fn editor_matches_the_cell_while_the_text_fits() {
-        use super::editor_width;
-        assert_eq!(editor_width(10.0, 80.0, 7.0), 80.0);
-        assert_eq!(editor_width(66.0, 80.0, 7.0), 80.0);
-        assert_eq!(editor_width(67.0, 80.0, 7.0), 88.0);
-    }
-
-    #[test]
-    fn editor_slack_fits_one_more_glyph_at_high_zoom() {
-        use super::editor_slack;
-        // A glyph is at most about one em wide; at 400% an em is ~60 px, far over the old fixed 14 px.
-        for size in [14.7_f32, 25.0, 60.0] {
-            assert!(editor_slack(size) - 4.0 >= size, "slack {} too small for a {size} px glyph", editor_slack(size));
-        }
-    }
-
-    #[test]
-    fn explicit_left_and_right_keep_their_side_on_a_right_to_left_sheet() {
-        use super::{HAlign, painted_halign};
-        // Painted before the mirror: swapped, so they land where the user put them.
-        assert_eq!(painted_halign(HAlign::Right, true), HAlign::Left);
-        assert_eq!(painted_halign(HAlign::Left, true), HAlign::Right);
-        // Left-to-right sheets and the other alignments are painted as they are.
-        assert_eq!(painted_halign(HAlign::Right, false), HAlign::Right);
-        assert_eq!(painted_halign(HAlign::Left, false), HAlign::Left);
-        for h in [HAlign::Center, HAlign::Justify, HAlign::Fill] {
-            assert_eq!(painted_halign(h, true), h);
-        }
-    }
-
-    #[test]
-    fn heading_labels_scale_with_the_zoom_without_a_cap() {
-        use super::{DISPLAY_SCALE, heading_font_size};
-        let at = |percent: f32| heading_font_size(percent / 100.0 * DISPLAY_SCALE);
-        assert!((at(400.0) / at(100.0) - 4.0).abs() < 1e-4, "four times as large at 400%");
-        assert!(at(200.0) > at(100.0) && at(400.0) > at(200.0));
-        assert_eq!(at(10.0), 8.5, "never below a readable size");
-    }
-    use super::*;
-
-    #[test]
-    fn list_picker_fits_up_to_eight_rows_then_scrolls() {
-        assert_eq!(list_picker_height(5, 18.0, 3.0), 5.0 * 18.0 + 4.0 * 3.0);
-        assert_eq!(list_picker_height(8, 18.0, 3.0), 8.0 * 18.0 + 7.0 * 3.0);
-        assert_eq!(list_picker_height(30, 18.0, 3.0), list_picker_height(8, 18.0, 3.0));
-        assert_eq!(list_picker_height(0, 18.0, 3.0), 18.0);
-    }
-
-    #[test]
-    fn number_format_colors_resolve_named_and_indexed_rgb() {
-        use gridcraft_engine::numfmt::FormatColor as F;
-        assert_eq!(numfmt_color(F::Green), Color32::from_rgb(0, 255, 0));
-        assert_eq!(numfmt_color(F::Indexed(1)), Color32::BLACK);
-        assert_eq!(numfmt_color(F::Indexed(10)), Color32::from_rgb(0, 128, 0));
-        assert_eq!(numfmt_color(F::Indexed(46)), Color32::from_rgb(255, 102, 0));
-        assert_eq!(numfmt_color(F::Indexed(56)), Color32::from_rgb(51, 51, 51));
-        for index in [0, 57, 255] {
-            assert_eq!(numfmt_color(F::Indexed(index)), Color32::BLACK);
-        }
-    }
-
-    #[test]
-    fn wheel_zoom_steps_along_the_ladder_and_stops_at_100() {
-        for (from, zoom_in, to) in [
-            (100, true, 120),
-            (120, false, 100),
-            (100, false, 85),
-            // Between steps, the next one each way (Excel: 112% goes to 115% or 100%).
-            (112, true, 120),
-            (112, false, 100),
-            // A step less than 5% away is skipped…
-            (121, false, 100),
-            (86, false, 70),
-            (139, true, 170),
-            // …but never 100% or a limit.
-            (99, true, 100),
-            (101, false, 100),
-            (96, true, 100),
-            (385, true, 400),
-            (11, false, 10),
-            (400, true, 400),
-            (10, false, 10),
-            // Out-of-range zooms (from a file) come into range first.
-            (5, true, 12),
-            (1000, false, 340),
-            (0, false, 10),
-            (u16::MAX, true, 400),
-        ] {
-            assert_eq!(wheel_zoom_step(from, zoom_in), to, "{from}% {}", if zoom_in { "in" } else { "out" });
-        }
-        // Every step on the ladder is 15–25% from the next, and a notch in then out returns.
-        // (The glide between steps is `zoom_glide_moves_by_ratio_and_always_arrives`.)
-        for w in WHEEL_ZOOM_LADDER.windows(2) {
-            let ratio = f32::from(w[1]) / f32::from(w[0]);
-            assert!((1.15..=1.25).contains(&ratio), "{w:?}");
-            assert_eq!(wheel_zoom_step(w[0], true), w[1]);
-            assert_eq!(wheel_zoom_step(w[1], false), w[0]);
-        }
-    }
-
-    #[test]
-    fn zoom_glide_moves_by_ratio_and_always_arrives() {
-        // A third of the way per frame, as at 60 frames a second.
-        for (from, to) in [(100, 120), (120, 100), (10, 12), (340, 400), (400, 10), (85, 100)] {
-            let (mut z, mut frames) = (from, 0);
-            while z != to {
-                let next = zoom_glide_step(z, to, 0.32);
-                assert!(next != z && next.abs_diff(to) < z.abs_diff(to), "{from} → {to}: {z} then {next}");
-                z = next;
-                frames += 1;
-                assert!(frames < 40, "{from} → {to} arrives");
-            }
-            assert!(frames >= 2, "{from} → {to} glides over more than one frame ({frames})");
-        }
-        assert_eq!(zoom_glide_step(100, 120, 0.32), 106, "a third of the way by ratio");
-        assert_eq!(zoom_glide_step(120, 100, 0.32), 113);
-        // No progress asked or nonsense: still a percent closer, or straight there.
-        assert_eq!(zoom_glide_step(100, 120, 0.0), 101);
-        assert_eq!(zoom_glide_step(120, 100, f32::NAN), 100);
-        assert_eq!(zoom_glide_step(100, 120, 5.0), 120);
-        assert_eq!(zoom_glide_step(120, 120, 0.5), 120);
-        assert_eq!(zoom_glide_step(0, 10, 0.5), 3);
-    }
-
-    #[test]
-    fn center_across_run_stops_at_first_non_continuing_column() {
-        assert_eq!(center_across_end(0, 20, |c| c <= 2), 2);
-        assert_eq!(center_across_end(0, 20, |_| false), 0);
-        assert_eq!(center_across_end(0, 1, |_| true), 1);
-    }
-
-    #[test]
-    fn conditional_number_format_reaches_the_cell_text() {
-        // #1163: a rule's number format replaces the cell's own; unmatched cells keep theirs.
-        let mut session = gridcraft_engine::Session::new();
-        session.new_workbook();
-        session.execute("range.setValues", json!({"range": "A1", "values": [[1], [3], [4]]})).unwrap();
-        session.execute("home.numberFormat", json!({"range": "A3", "code": "0.0"})).unwrap();
-        let rule = json!({"type": "cellIs", "operator": "greater", "value": "2", "style": {"num_fmt": "0.00"}});
-        session.execute("home.conditionalFormat", json!({"range": "A1:A3", "rule": rule})).unwrap();
-        let wb = session.active().unwrap().wb.clone();
-        let sh = wb.sheet(0).unwrap();
-        let mut cf = CfCache::new();
-        let text = |row: u32, cf: &mut CfCache| {
-            let c = CellRef::new(row, 0);
-            let (lk, _) = look(&wb, 0, sh, c, cf);
-            display_text(&wb, sh, c, &sh.value(c), &lk.style, 200.0, 7.0).0
-        };
-        assert_eq!(text(0, &mut cf), "1");
-        assert_eq!(text(1, &mut cf), "3.00");
-        assert_eq!(text(2, &mut cf), "4.00");
-    }
-
-    #[test]
-    fn filter_menu_uses_the_table_whose_header_was_clicked() {
-        use gridcraft_engine::model::Table;
-        let table = |id: u32, r0: u32, r1: u32| Table {
-            id,
-            name: format!("T{id}"),
-            range: RangeRef::new(CellRef::new(r0, 0), CellRef::new(r1, 0)),
-            header_row: true,
-            totals_row: false,
-            columns: vec![],
-            style: String::new(),
-            banded_rows: true,
-            banded_cols: false,
-            first_col: false,
-            last_col: false,
-            filter_button: true,
-            filter: vec![],
-            table_type: None,
-            connection_id: None,
-        };
-        let mut sh = Sheet::new("S");
-        sh.tables.push(table(1, 0, 2));
-        sh.tables.push(table(2, 4, 7));
-        assert_eq!(filter_table_range(&sh, 0, 4), Some(sh.tables[1].range));
-        assert_eq!(filter_table_range(&sh, 0, 0), Some(sh.tables[0].range));
-        assert_eq!(filter_table_range(&sh, 1, 4), None);
-    }
-
-    #[test]
-    fn cell_text_y_moves_monotonically_in_standard_and_tall_rows() {
-        let rect_std = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 20.0));
-        let gh = 18.5;
-        let z = 1.0;
-
-        let y_top_std = cell_text_y(VAlign::Top, rect_std, gh, z);
-        let y_center_std = cell_text_y(VAlign::Center, rect_std, gh, z);
-        let y_bottom_std = cell_text_y(VAlign::Bottom, rect_std, gh, z);
-
-        assert!(y_top_std < y_center_std, "Top ({y_top_std}) must be higher than Center ({y_center_std})");
-        assert!(y_center_std < y_bottom_std, "Center ({y_center_std}) must be higher than Bottom ({y_bottom_std})");
-
-        // Verify tall row (e.g. 40px)
-        let rect_tall = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 40.0));
-        let y_top_tall = cell_text_y(VAlign::Top, rect_tall, gh, z);
-        let y_center_tall = cell_text_y(VAlign::Center, rect_tall, gh, z);
-        let y_bottom_tall = cell_text_y(VAlign::Bottom, rect_tall, gh, z);
-
-        assert!(y_top_tall < y_center_tall, "Top ({y_top_tall}) must be higher than Center ({y_center_tall})");
-        assert!(y_center_tall < y_bottom_tall, "Center ({y_center_tall}) must be higher than Bottom ({y_bottom_tall})");
-    }
-
-    #[test]
-    fn wrapped_cell_text_y_positions_correctly_and_safeguards_overflow() {
-        let rect = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 40.0));
-        let gh = 30.0;
-        let z = 1.0;
-
-        let y_top = wrapped_cell_text_y(VAlign::Top, rect, gh, z);
-        let y_center = wrapped_cell_text_y(VAlign::Center, rect, gh, z);
-        let y_bottom = wrapped_cell_text_y(VAlign::Bottom, rect, gh, z);
-
-        assert!(y_top < y_center);
-        assert!(y_center < y_bottom);
-
-        // Overflow case: gh exceeds rect height; Top still starts inside the cell.
-        let gh_overflow = 60.0;
-        let y_top_ovf = wrapped_cell_text_y(VAlign::Top, rect, gh_overflow, z);
-        assert!(y_top_ovf >= rect.top());
-    }
-
-    #[test]
-    fn wrapped_cell_text_y_keeps_vertical_alignment_when_text_is_taller_than_the_row() {
-        // A default-height row holding three wrapped lines.
-        let rect = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 20.0));
-        let (gh, z) = (60.0, 1.0);
-        let y_top = wrapped_cell_text_y(VAlign::Top, rect, gh, z);
-        let y_center = wrapped_cell_text_y(VAlign::Center, rect, gh, z);
-        let y_bottom = wrapped_cell_text_y(VAlign::Bottom, rect, gh, z);
-        // Taller text overflows upward for Bottom and both ways for Center (the cell clips it).
-        assert!((y_top - 1.5).abs() < 0.01, "Top starts at the top edge, got {y_top}");
-        assert!((y_center + gh / 2.0 - rect.center().y).abs() < 0.01, "Center is centred, got {y_center}");
-        assert!((y_bottom + gh - (rect.bottom() - 1.5)).abs() < 0.01, "Bottom ends at the bottom edge, got {y_bottom}");
-    }
-
-    /// The screen box of a galley of `size` drawn at `pos` turned by `angle` about `pos`, as egui
-    /// draws a rotated `TextShape`.
-    fn rotated_box(pos: Pos2, size: egui::Vec2, angle: f32) -> Rect {
-        let rot = egui::emath::Rot2::from_angle(angle);
-        let pts = [vec2(0.0, 0.0), vec2(size.x, 0.0), vec2(0.0, size.y), size].map(|v| pos + rot * v);
-        Rect::from_points(&pts)
-    }
-
-    #[test]
-    fn rotated_text_box_follows_the_cell_alignment() {
-        // A tall, narrow merged block (one 3-character column over four 60pt rows).
-        let rect = Rect::from_min_max(pos2(10.0, 20.0), pos2(40.0, 340.0));
-        let size = vec2(90.0, 15.0);
-        let pad = 2.5;
-        let near = |a: f32, b: f32| (a - b).abs() < 0.01;
-        for deg in [90i16, -90, 45, -45] {
-            let angle = -(deg as f32).to_radians();
-            for v in [VAlign::Top, VAlign::Center, VAlign::Bottom] {
-                for h in [HAlign::Left, HAlign::Center, HAlign::Right] {
-                    let bb = rotated_box(rotated_text_pos(rect, size, angle, h, v, pad, 0.0), size, angle);
-                    let what = format!("{deg}° {h:?}/{v:?}: {bb:?} in {rect:?}");
-                    assert!(near(bb.height(), rotated_box(Pos2::ZERO, size, angle).height()), "{what}");
-                    assert!(bb.top() >= rect.top() && bb.bottom() <= rect.bottom(), "{what}");
-                    // A narrow column can't hold a 45° line across: only check where it fits.
-                    let fits_x = bb.width() <= rect.width() - 2.0 * pad;
-                    match h {
-                        HAlign::Left => assert!(near(bb.left(), rect.left() + pad), "{what}"),
-                        HAlign::Right => assert!(near(bb.right(), rect.right() - pad), "{what}"),
-                        _ => assert!(near(bb.center().x, rect.center().x), "{what}"),
-                    }
-                    if fits_x {
-                        assert!(bb.left() >= rect.left() && bb.right() <= rect.right(), "{what}");
-                    }
-                    match v {
-                        VAlign::Top => assert!(near(bb.top(), rect.top() + pad), "{what}"),
-                        VAlign::Center => assert!(near(bb.center().y, rect.center().y), "{what}"),
-                        // Bottom is the default: downward text keeps starting at the top, as before.
-                        _ if deg < 0 => assert!(near(bb.top(), rect.top() + pad), "{what}"),
-                        _ => assert!(near(bb.bottom(), rect.bottom() - pad), "{what}"),
-                    }
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn upright_text_with_default_alignment_keeps_its_place() {
-        let rect = Rect::from_min_max(pos2(10.0, 20.0), pos2(40.0, 340.0));
-        let size = vec2(90.0, 15.0);
-        let pad = 2.5;
-        let near = |a: Pos2, b: Pos2| (a - b).length() < 0.01;
-        // Upward text starts at the bottom-left corner, downward text one block-height in from the top-left.
-        let up = rotated_text_pos(rect, size, -std::f32::consts::FRAC_PI_2, HAlign::General, VAlign::Bottom, pad, 0.0);
-        assert!(near(up, pos2(rect.left() + pad, rect.bottom() - pad)), "{up:?}");
-        let down = rotated_text_pos(rect, size, std::f32::consts::FRAC_PI_2, HAlign::General, VAlign::Bottom, pad, 0.0);
-        assert!(near(down, pos2(rect.left() + pad + size.y, rect.top() + pad)), "{down:?}");
-    }
-
-    #[test]
-    fn upward_text_with_middle_align_is_centred_in_a_merged_block() {
-        // Issue #435: "Licht Strom (?)" turned up in A1:A4 with Middle Align was drawn at the bottom.
-        let rect = Rect::from_min_max(pos2(10.0, 20.0), pos2(40.0, 340.0));
-        let size = vec2(90.0, 15.0);
-        let angle = -std::f32::consts::FRAC_PI_2;
-        let bb = rotated_box(rotated_text_pos(rect, size, angle, HAlign::Center, VAlign::Center, 2.5, 0.0), size, angle);
-        assert!((bb.center().y - rect.center().y).abs() < 0.01, "{bb:?} not centred in {rect:?}");
-        assert!((bb.center().x - rect.center().x).abs() < 0.01, "{bb:?} not centred in {rect:?}");
-    }
-}
+mod tests;
 
 #[cfg(test)]
 mod pane_tests {
diff --git a/crates/ui-egui/src/grid/tests.rs b/crates/ui-egui/src/grid/tests.rs
new file mode 100644
index 000000000..74abfc861
--- /dev/null
+++ b/crates/ui-egui/src/grid/tests.rs
@@ -0,0 +1,306 @@
+#[test]
+fn editor_matches_the_cell_while_the_text_fits() {
+    use super::editor_width;
+    assert_eq!(editor_width(10.0, 80.0, 7.0), 80.0);
+    assert_eq!(editor_width(66.0, 80.0, 7.0), 80.0);
+    assert_eq!(editor_width(67.0, 80.0, 7.0), 88.0);
+}
+
+#[test]
+fn editor_slack_fits_one_more_glyph_at_high_zoom() {
+    use super::editor_slack;
+    // A glyph is at most about one em wide; at 400% an em is ~60 px, far over the old fixed 14 px.
+    for size in [14.7_f32, 25.0, 60.0] {
+        assert!(editor_slack(size) - 4.0 >= size, "slack {} too small for a {size} px glyph", editor_slack(size));
+    }
+}
+
+#[test]
+fn explicit_left_and_right_keep_their_side_on_a_right_to_left_sheet() {
+    use super::{HAlign, painted_halign};
+    // Painted before the mirror: swapped, so they land where the user put them.
+    assert_eq!(painted_halign(HAlign::Right, true), HAlign::Left);
+    assert_eq!(painted_halign(HAlign::Left, true), HAlign::Right);
+    // Left-to-right sheets and the other alignments are painted as they are.
+    assert_eq!(painted_halign(HAlign::Right, false), HAlign::Right);
+    assert_eq!(painted_halign(HAlign::Left, false), HAlign::Left);
+    for h in [HAlign::Center, HAlign::Justify, HAlign::Fill] {
+        assert_eq!(painted_halign(h, true), h);
+    }
+}
+
+#[test]
+fn heading_labels_scale_with_the_zoom_without_a_cap() {
+    use super::{DISPLAY_SCALE, heading_font_size};
+    let at = |percent: f32| heading_font_size(percent / 100.0 * DISPLAY_SCALE);
+    assert!((at(400.0) / at(100.0) - 4.0).abs() < 1e-4, "four times as large at 400%");
+    assert!(at(200.0) > at(100.0) && at(400.0) > at(200.0));
+    assert_eq!(at(10.0), 8.5, "never below a readable size");
+}
+use super::*;
+
+#[test]
+fn list_picker_fits_up_to_eight_rows_then_scrolls() {
+    assert_eq!(list_picker_height(5, 18.0, 3.0), 5.0 * 18.0 + 4.0 * 3.0);
+    assert_eq!(list_picker_height(8, 18.0, 3.0), 8.0 * 18.0 + 7.0 * 3.0);
+    assert_eq!(list_picker_height(30, 18.0, 3.0), list_picker_height(8, 18.0, 3.0));
+    assert_eq!(list_picker_height(0, 18.0, 3.0), 18.0);
+}
+
+#[test]
+fn number_format_colors_resolve_named_and_indexed_rgb() {
+    use gridcraft_engine::numfmt::FormatColor as F;
+    assert_eq!(numfmt_color(F::Green), Color32::from_rgb(0, 255, 0));
+    assert_eq!(numfmt_color(F::Indexed(1)), Color32::BLACK);
+    assert_eq!(numfmt_color(F::Indexed(10)), Color32::from_rgb(0, 128, 0));
+    assert_eq!(numfmt_color(F::Indexed(46)), Color32::from_rgb(255, 102, 0));
+    assert_eq!(numfmt_color(F::Indexed(56)), Color32::from_rgb(51, 51, 51));
+    for index in [0, 57, 255] {
+        assert_eq!(numfmt_color(F::Indexed(index)), Color32::BLACK);
+    }
+}
+
+#[test]
+fn wheel_zoom_steps_along_the_ladder_and_stops_at_100() {
+    for (from, zoom_in, to) in [
+        (100, true, 120),
+        (120, false, 100),
+        (100, false, 85),
+        // Between steps, the next one each way (Excel: 112% goes to 115% or 100%).
+        (112, true, 120),
+        (112, false, 100),
+        // A step less than 5% away is skipped…
+        (121, false, 100),
+        (86, false, 70),
+        (139, true, 170),
+        // …but never 100% or a limit.
+        (99, true, 100),
+        (101, false, 100),
+        (96, true, 100),
+        (385, true, 400),
+        (11, false, 10),
+        (400, true, 400),
+        (10, false, 10),
+        // Out-of-range zooms (from a file) come into range first.
+        (5, true, 12),
+        (1000, false, 340),
+        (0, false, 10),
+        (u16::MAX, true, 400),
+    ] {
+        assert_eq!(wheel_zoom_step(from, zoom_in), to, "{from}% {}", if zoom_in { "in" } else { "out" });
+    }
+    // Every step on the ladder is 15–25% from the next, and a notch in then out returns.
+    // (The glide between steps is `zoom_glide_moves_by_ratio_and_always_arrives`.)
+    for w in WHEEL_ZOOM_LADDER.windows(2) {
+        let ratio = f32::from(w[1]) / f32::from(w[0]);
+        assert!((1.15..=1.25).contains(&ratio), "{w:?}");
+        assert_eq!(wheel_zoom_step(w[0], true), w[1]);
+        assert_eq!(wheel_zoom_step(w[1], false), w[0]);
+    }
+}
+
+#[test]
+fn zoom_glide_moves_by_ratio_and_always_arrives() {
+    // A third of the way per frame, as at 60 frames a second.
+    for (from, to) in [(100, 120), (120, 100), (10, 12), (340, 400), (400, 10), (85, 100)] {
+        let (mut z, mut frames) = (from, 0);
+        while z != to {
+            let next = zoom_glide_step(z, to, 0.32);
+            assert!(next != z && next.abs_diff(to) < z.abs_diff(to), "{from} → {to}: {z} then {next}");
+            z = next;
+            frames += 1;
+            assert!(frames < 40, "{from} → {to} arrives");
+        }
+        assert!(frames >= 2, "{from} → {to} glides over more than one frame ({frames})");
+    }
+    assert_eq!(zoom_glide_step(100, 120, 0.32), 106, "a third of the way by ratio");
+    assert_eq!(zoom_glide_step(120, 100, 0.32), 113);
+    // No progress asked or nonsense: still a percent closer, or straight there.
+    assert_eq!(zoom_glide_step(100, 120, 0.0), 101);
+    assert_eq!(zoom_glide_step(120, 100, f32::NAN), 100);
+    assert_eq!(zoom_glide_step(100, 120, 5.0), 120);
+    assert_eq!(zoom_glide_step(120, 120, 0.5), 120);
+    assert_eq!(zoom_glide_step(0, 10, 0.5), 3);
+}
+
+#[test]
+fn center_across_run_stops_at_first_non_continuing_column() {
+    assert_eq!(center_across_end(0, 20, |c| c <= 2), 2);
+    assert_eq!(center_across_end(0, 20, |_| false), 0);
+    assert_eq!(center_across_end(0, 1, |_| true), 1);
+}
+
+#[test]
+fn conditional_number_format_reaches_the_cell_text() {
+    // #1163: a rule's number format replaces the cell's own; unmatched cells keep theirs.
+    let mut session = gridcraft_engine::Session::new();
+    session.new_workbook();
+    session.execute("range.setValues", json!({"range": "A1", "values": [[1], [3], [4]]})).unwrap();
+    session.execute("home.numberFormat", json!({"range": "A3", "code": "0.0"})).unwrap();
+    let rule = json!({"type": "cellIs", "operator": "greater", "value": "2", "style": {"num_fmt": "0.00"}});
+    session.execute("home.conditionalFormat", json!({"range": "A1:A3", "rule": rule})).unwrap();
+    let wb = session.active().unwrap().wb.clone();
+    let sh = wb.sheet(0).unwrap();
+    let mut cf = CfCache::new();
+    let text = |row: u32, cf: &mut CfCache| {
+        let c = CellRef::new(row, 0);
+        let (lk, _) = look(&wb, 0, sh, c, cf);
+        display_text(&wb, sh, c, &sh.value(c), &lk.style, 200.0, 7.0).0
+    };
+    assert_eq!(text(0, &mut cf), "1");
+    assert_eq!(text(1, &mut cf), "3.00");
+    assert_eq!(text(2, &mut cf), "4.00");
+}
+
+#[test]
+fn filter_menu_uses_the_table_whose_header_was_clicked() {
+    use gridcraft_engine::model::Table;
+    let table = |id: u32, r0: u32, r1: u32| Table {
+        id,
+        name: format!("T{id}"),
+        range: RangeRef::new(CellRef::new(r0, 0), CellRef::new(r1, 0)),
+        header_row: true,
+        totals_row: false,
+        columns: vec![],
+        style: String::new(),
+        banded_rows: true,
+        banded_cols: false,
+        first_col: false,
+        last_col: false,
+        filter_button: true,
+        filter: vec![],
+        table_type: None,
+        connection_id: None,
+    };
+    let mut sh = Sheet::new("S");
+    sh.tables.push(table(1, 0, 2));
+    sh.tables.push(table(2, 4, 7));
+    assert_eq!(filter_table_range(&sh, 0, 4), Some(sh.tables[1].range));
+    assert_eq!(filter_table_range(&sh, 0, 0), Some(sh.tables[0].range));
+    assert_eq!(filter_table_range(&sh, 1, 4), None);
+}
+
+#[test]
+fn cell_text_y_moves_monotonically_in_standard_and_tall_rows() {
+    let rect_std = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 20.0));
+    let gh = 18.5;
+    let z = 1.0;
+
+    let y_top_std = cell_text_y(VAlign::Top, rect_std, gh, z);
+    let y_center_std = cell_text_y(VAlign::Center, rect_std, gh, z);
+    let y_bottom_std = cell_text_y(VAlign::Bottom, rect_std, gh, z);
+
+    assert!(y_top_std < y_center_std, "Top ({y_top_std}) must be higher than Center ({y_center_std})");
+    assert!(y_center_std < y_bottom_std, "Center ({y_center_std}) must be higher than Bottom ({y_bottom_std})");
+
+    // Verify tall row (e.g. 40px)
+    let rect_tall = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 40.0));
+    let y_top_tall = cell_text_y(VAlign::Top, rect_tall, gh, z);
+    let y_center_tall = cell_text_y(VAlign::Center, rect_tall, gh, z);
+    let y_bottom_tall = cell_text_y(VAlign::Bottom, rect_tall, gh, z);
+
+    assert!(y_top_tall < y_center_tall, "Top ({y_top_tall}) must be higher than Center ({y_center_tall})");
+    assert!(y_center_tall < y_bottom_tall, "Center ({y_center_tall}) must be higher than Bottom ({y_bottom_tall})");
+}
+
+#[test]
+fn wrapped_cell_text_y_positions_correctly_and_safeguards_overflow() {
+    let rect = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 40.0));
+    let gh = 30.0;
+    let z = 1.0;
+
+    let y_top = wrapped_cell_text_y(VAlign::Top, rect, gh, z);
+    let y_center = wrapped_cell_text_y(VAlign::Center, rect, gh, z);
+    let y_bottom = wrapped_cell_text_y(VAlign::Bottom, rect, gh, z);
+
+    assert!(y_top < y_center);
+    assert!(y_center < y_bottom);
+
+    // Overflow case: gh exceeds rect height; Top still starts inside the cell.
+    let gh_overflow = 60.0;
+    let y_top_ovf = wrapped_cell_text_y(VAlign::Top, rect, gh_overflow, z);
+    assert!(y_top_ovf >= rect.top());
+}
+
+#[test]
+fn wrapped_cell_text_y_keeps_vertical_alignment_when_text_is_taller_than_the_row() {
+    // A default-height row holding three wrapped lines.
+    let rect = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 20.0));
+    let (gh, z) = (60.0, 1.0);
+    let y_top = wrapped_cell_text_y(VAlign::Top, rect, gh, z);
+    let y_center = wrapped_cell_text_y(VAlign::Center, rect, gh, z);
+    let y_bottom = wrapped_cell_text_y(VAlign::Bottom, rect, gh, z);
+    // Taller text overflows upward for Bottom and both ways for Center (the cell clips it).
+    assert!((y_top - 1.5).abs() < 0.01, "Top starts at the top edge, got {y_top}");
+    assert!((y_center + gh / 2.0 - rect.center().y).abs() < 0.01, "Center is centred, got {y_center}");
+    assert!((y_bottom + gh - (rect.bottom() - 1.5)).abs() < 0.01, "Bottom ends at the bottom edge, got {y_bottom}");
+}
+
+/// The screen box of a galley of `size` drawn at `pos` turned by `angle` about `pos`, as egui
+/// draws a rotated `TextShape`.
+fn rotated_box(pos: Pos2, size: egui::Vec2, angle: f32) -> Rect {
+    let rot = egui::emath::Rot2::from_angle(angle);
+    let pts = [vec2(0.0, 0.0), vec2(size.x, 0.0), vec2(0.0, size.y), size].map(|v| pos + rot * v);
+    Rect::from_points(&pts)
+}
+
+#[test]
+fn rotated_text_box_follows_the_cell_alignment() {
+    // A tall, narrow merged block (one 3-character column over four 60pt rows).
+    let rect = Rect::from_min_max(pos2(10.0, 20.0), pos2(40.0, 340.0));
+    let size = vec2(90.0, 15.0);
+    let pad = 2.5;
+    let near = |a: f32, b: f32| (a - b).abs() < 0.01;
+    for deg in [90i16, -90, 45, -45] {
+        let angle = -(deg as f32).to_radians();
+        for v in [VAlign::Top, VAlign::Center, VAlign::Bottom] {
+            for h in [HAlign::Left, HAlign::Center, HAlign::Right] {
+                let bb = rotated_box(rotated_text_pos(rect, size, angle, h, v, pad, 0.0), size, angle);
+                let what = format!("{deg}° {h:?}/{v:?}: {bb:?} in {rect:?}");
+                assert!(near(bb.height(), rotated_box(Pos2::ZERO, size, angle).height()), "{what}");
+                assert!(bb.top() >= rect.top() && bb.bottom() <= rect.bottom(), "{what}");
+                // A narrow column can't hold a 45° line across: only check where it fits.
+                let fits_x = bb.width() <= rect.width() - 2.0 * pad;
+                match h {
+                    HAlign::Left => assert!(near(bb.left(), rect.left() + pad), "{what}"),
+                    HAlign::Right => assert!(near(bb.right(), rect.right() - pad), "{what}"),
+                    _ => assert!(near(bb.center().x, rect.center().x), "{what}"),
+                }
+                if fits_x {
+                    assert!(bb.left() >= rect.left() && bb.right() <= rect.right(), "{what}");
+                }
+                match v {
+                    VAlign::Top => assert!(near(bb.top(), rect.top() + pad), "{what}"),
+                    VAlign::Center => assert!(near(bb.center().y, rect.center().y), "{what}"),
+                    // Bottom is the default: downward text keeps starting at the top, as before.
+                    _ if deg < 0 => assert!(near(bb.top(), rect.top() + pad), "{what}"),
+                    _ => assert!(near(bb.bottom(), rect.bottom() - pad), "{what}"),
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn upright_text_with_default_alignment_keeps_its_place() {
+    let rect = Rect::from_min_max(pos2(10.0, 20.0), pos2(40.0, 340.0));
+    let size = vec2(90.0, 15.0);
+    let pad = 2.5;
+    let near = |a: Pos2, b: Pos2| (a - b).length() < 0.01;
+    // Upward text starts at the bottom-left corner, downward text one block-height in from the top-left.
+    let up = rotated_text_pos(rect, size, -std::f32::consts::FRAC_PI_2, HAlign::General, VAlign::Bottom, pad, 0.0);
+    assert!(near(up, pos2(rect.left() + pad, rect.bottom() - pad)), "{up:?}");
+    let down = rotated_text_pos(rect, size, std::f32::consts::FRAC_PI_2, HAlign::General, VAlign::Bottom, pad, 0.0);
+    assert!(near(down, pos2(rect.left() + pad + size.y, rect.top() + pad)), "{down:?}");
+}
+
+#[test]
+fn upward_text_with_middle_align_is_centred_in_a_merged_block() {
+    // Issue #435: "Licht Strom (?)" turned up in A1:A4 with Middle Align was drawn at the bottom.
+    let rect = Rect::from_min_max(pos2(10.0, 20.0), pos2(40.0, 340.0));
+    let size = vec2(90.0, 15.0);
+    let angle = -std::f32::consts::FRAC_PI_2;
+    let bb = rotated_box(rotated_text_pos(rect, size, angle, HAlign::Center, VAlign::Center, 2.5, 0.0), size, angle);
+    assert!((bb.center().y - rect.center().y).abs() < 0.01, "{bb:?} not centred in {rect:?}");
+    assert!((bb.center().x - rect.center().x).abs() < 0.01, "{bb:?} not centred in {rect:?}");
+}

From cb661c00517b032cee6be71edfe7992960f18bfd Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:46 +0000
Subject: [PATCH 39/76] refactor(ui-egui): move theme tests to
 src/theme/tests.rs

---
 crates/ui-egui/src/theme.rs       | 361 +-----------------------------
 crates/ui-egui/src/theme/tests.rs | 358 +++++++++++++++++++++++++++++
 2 files changed, 359 insertions(+), 360 deletions(-)
 create mode 100644 crates/ui-egui/src/theme/tests.rs

diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index 478b8b86b..28dc465e2 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -1267,363 +1267,4 @@ mod contrast_tests {
 }
 
 #[cfg(all(test, not(target_arch = "wasm32")))]
-mod tests {
-    use super::*;
-    use crate::i18n::Language;
-
-    #[test]
-    /// Loaded script-fallback faces end each role chain just before the craft fonts, in the language's order.
-    fn fallback_faces_are_appended_to_every_family() {
-        // Structural: whatever loaded, the non-Latin fallback keys must sit at the end of each chain
-        // (after the Latin/default fonts) so Latin still wins for Latin text, in the language's order.
-        for han in [HanOrder::Chinese, HanOrder::Japanese] {
-            let language = if han == HanOrder::Japanese { Language::Ja } else { Language::Zh };
-            let fonts = font_definitions_for_language(language);
-            let fb_keys: Vec<String> =
-                fallback_faces(han).into_iter().map(|(k, _)| k.to_string()).filter(|k| fonts.font_data.contains_key(k)).collect();
-            if fb_keys.is_empty() {
-                return; // no fallback face on this machine (minimal Linux)
-            }
-            for role in [UI, UI_BOLD, CELL, CELL_BOLD, CELL_ITALIC, CELL_BOLD_ITALIC, SERIF, MONO] {
-                let chain = fonts.families.get(&FontFamily::Name(role.into())).map(Vec::as_slice).unwrap_or_default();
-                // The optional craft-fonts faces follow the system fallbacks at the very end.
-                let end = chain.iter().rposition(|k| !k.starts_with("craft-")).map_or(0, |i| i + 1);
-                assert!(end >= fb_keys.len(), "{role} chain too short for its fallback");
-                assert_eq!(&chain[end - fb_keys.len()..end], fb_keys.as_slice(), "{role} must end its non-craft chain with the fallback faces");
-            }
-        }
-    }
-
-    #[test]
-    /// Every font family ends with exactly the permitted craft faces in manifest order.
-    fn craft_fonts_are_the_last_fallback_in_every_family() {
-        // Ordering: app/bundled faces, Hack/emoji, system script fallbacks, permitted craft faces.
-        // A craft face must never displace a system face that already covers a glyph.
-        let fonts = font_definitions_for_language(Language::En);
-        let expected: Vec<String> = craft_font_faces().into_iter().map(|(key, _)| key).collect();
-        if expected.is_empty() {
-            return; // optional input absent
-        }
-        for (family, chain) in &fonts.families {
-            let first = chain.iter().position(|k| k.starts_with("craft-")).unwrap_or(chain.len());
-            assert_eq!(&chain[first..], expected.as_slice(), "{family:?} must end with exactly the permitted craft faces in manifest order");
-        }
-    }
-
-    #[test]
-    /// Skips on wasm or when required mode is off; a required native build must embed LXGW with `Hani`/`Hans`.
-    fn a_required_native_build_embeds_the_chinese_face() {
-        if cfg!(target_arch = "wasm32") || !craft_fonts_required() {
-            return;
-        }
-        assert!(
-            chinese_font_loaded(),
-            "CRAFT_FONTS_REQUIRED=1 native builds must embed the LXGW Chinese face from fonts/simplified-chinese-manifest.txt"
-        );
-        let face = craft_font_scripts().find(|(f, s, _)| *f == "LXGW WenKai Lite" && *s == "Regular");
-        assert_eq!(face.map(|(_, _, scripts)| scripts), Some(["Hani", "Hans"].as_slice()), "the Chinese manifest's script tags are asserted");
-    }
-
-    #[test]
-    /// No embedded craft face belongs to the barred Noto CJK, Adobe or Source families.
-    fn barred_faces_never_enter_the_font_set() {
-        for (family, _, _) in craft_font_scripts() {
-            assert!(!family.contains("CJK"), "the barred Noto CJK collection must never be embedded: {family}");
-            assert!(!family.starts_with("Source ") && !family.starts_with("Adobe "), "a barred Adobe/Source face was embedded: {family}");
-        }
-    }
-
-    #[test]
-    /// Skips when craft fonts are absent unless required mode is set; otherwise the required faces and their exact script tags are embedded.
-    fn the_required_craft_faces_keep_their_exact_scripts() {
-        if !craft_fonts_loaded() {
-            assert!(!craft_fonts_required(), "CRAFT_FONTS_REQUIRED=1 but no craft-fonts faces were embedded");
-            return;
-        }
-        let faces: Vec<_> = craft_font_scripts().collect();
-        for (family, style, scripts) in [
-            ("BIZ UDPGothic", "Regular", ["Jpan", "Latn"].as_slice()),
-            ("BIZ UDPGothic", "Bold", ["Jpan", "Latn"].as_slice()),
-            ("NanumGothic", "Regular", ["Hang", "Kore"].as_slice()),
-            ("Noto Sans Symbols", "Regular", ["Zsym"].as_slice()),
-            ("Noto Sans Symbols 2", "Regular", ["Zsym"].as_slice()),
-        ] {
-            assert!(
-                faces.iter().any(|(f, s, declared)| *f == family && *s == style && *declared == scripts),
-                "{family} {style} with {scripts:?} must be embedded; got {faces:?}"
-            );
-        }
-    }
-
-    #[test]
-    /// Interface text maps unbundled `⌃`, `✓` and `✕` to readable chrome fallbacks; document text is not rewritten.
-    fn available_text_maps_unbundled_chrome_symbols() {
-        // No bundled face has ⌃ ✓ ✕; chrome text must show ^ ✔ × instead of tofu. Document text is
-        // never rewritten: this helper is only used for interface tooltips.
-        let ctx = egui::Context::default();
-        ctx.set_fonts(FontDefinitions::default());
-        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
-            assert_eq!(available_text(ui, "Show Formulas (⌃`) ✓ ✕"), "Show Formulas (^`) ✔ ×");
-        });
-        out.textures_delta.clear();
-    }
-
-    #[test]
-    fn interface_families_fall_back_to_the_cell_font() {
-        // Structural (#349): the formula bar, name box and dialogs draw every script the cells can,
-        // so each interface chain carries the cell face, ahead of the script fallback faces.
-        let fonts = font_definitions_for_language(Language::En);
-        let cell = format!("sys-{CELL}");
-        if !fonts.font_data.contains_key(&cell) {
-            return; // no system cell font on this machine
-        }
-        let fb: Vec<String> = fallback_faces(HanOrder::Chinese).into_iter().map(|(k, _)| k.to_string()).collect();
-        for family in [FontFamily::Proportional, FontFamily::Name(UI.into()), FontFamily::Name(UI_BOLD.into()), FontFamily::Name(MONO.into())] {
-            let chain = fonts.families.get(&family).cloned().unwrap_or_default();
-            let at = chain.iter().position(|k| *k == cell);
-            assert!(at.is_some(), "{family:?} lacks the cell face: {chain:?}");
-            let first_fb = chain.iter().position(|k| fb.contains(k)).unwrap_or(chain.len());
-            assert!(at.unwrap_or(usize::MAX) < first_fb, "{family:?}: cell face must precede the script faces");
-        }
-    }
-
-    #[test]
-    fn language_reorders_only_the_han_faces() {
-        let keys = |han| fallback_faces(han).into_iter().map(|(k, _)| k).collect::<Vec<_>>();
-        assert_eq!(
-            keys(HanOrder::Japanese),
-            ["sys-cjk-han-ja", "sys-cjk-han-zh", "sys-cjk-hangul", "sys-thai", "sys-lao", "sys-hebrew", "sys-symbols", "sys-symbols-2"]
-        );
-        assert_eq!(
-            keys(HanOrder::Chinese),
-            ["sys-cjk-han-zh", "sys-cjk-han-ja", "sys-cjk-hangul", "sys-thai", "sys-lao", "sys-hebrew", "sys-symbols", "sys-symbols-2"]
-        );
-        assert_eq!(HanOrder::of(Language::Ja), HanOrder::Japanese);
-        for l in [Language::En, Language::Zh, Language::Ko, Language::Ru, Language::PtBr, Language::De, Language::Cs, Language::Fr, Language::Tr] {
-            assert_eq!(HanOrder::of(l), HanOrder::Chinese, "{l:?} shares the default order (no font rebuild)");
-        }
-    }
-
-    #[test]
-    fn cjk_fallback_probes_flatpak_fonts_with_the_correct_locale_faces() {
-        // Exercise the candidates the fallback loader actually consumes, not just the directory
-        // constant. This must work on CI without an installed CJK font or a Flatpak runtime.
-        for (candidates, face) in [(cjk_han_japanese(), 0), (cjk_han_simplified(), 2), (cjk_hangul(), 1)] {
-            for directory in [
-                "/run/host/fonts/opentype/noto",
-                "/run/host/fonts/google-noto-cjk",
-                "/run/host/fonts/noto-cjk",
-                "/run/host/fonts/truetype/noto",
-                "/run/host/fonts/noto",
-                "/run/host/fonts/truetype",
-                "/run/host/fonts/TTF",
-                "/run/host/fonts",
-                "/run/host/local-fonts",
-                "/run/host/local-fonts/noto-cjk",
-                "/run/host/user-fonts",
-            ] {
-                let path = format!("{directory}/NotoSansCJK-Regular.ttc");
-                assert!(candidates.contains(&(path.clone(), face)), "missing Flatpak CJK candidate {path}, face {face}");
-            }
-        }
-        let chinese = cjk_han_simplified();
-        assert!(chinese.contains(&("/run/host/fonts/truetype/wqy/wqy-microhei.ttc".into(), 0)));
-        assert!(chinese.contains(&("/run/host/fonts/wenquanyi/wqy-microhei.ttc".into(), 0)));
-    }
-
-    #[test]
-    /// A font file shared by several fallback scripts is loaded once, with one shared font blob rather than a copy per script.
-    fn fallback_faces_load_each_file_once() {
-        // The region-merged Noto Sans CJK .ttc serves Japanese, Chinese and Hangul; it must be loaded
-        // once, not once per script (tens of MB each).
-        for language in [Language::En, Language::Ja] {
-            let fonts = font_definitions_for_language(language);
-            let present: Vec<&Arc<FontData>> =
-                fallback_faces(HanOrder::of(language)).into_iter().filter_map(|(k, _)| fonts.font_data.get(k)).collect();
-            for (i, a) in present.iter().enumerate() {
-                for b in present.iter().skip(i + 1) {
-                    assert!(!std::sync::Arc::ptr_eq(&a.font, &b.font), "the same font file is loaded for two fallback scripts");
-                }
-            }
-        }
-    }
-
-    #[test]
-    /// Checks that the proportional and cell families have glyphs for every present script sample; samples with no system or craft face are printed as skipped.
-    fn fallback_covers_its_script() {
-        // Real glyph check, per script: the proportional family (what cells and the UI use) must
-        // have a glyph for every non-space character in the sample. A script runs when a system
-        // face or the optional craft-fonts input provides one; the printed skip is a recorded
-        // gate, and a present face that is not wired in fails.
-        let cases: [(&str, Vec<(String, u32)>, &str); 10] = [
-            ("sys-cjk-han-ja", cjk_han_japanese(), "カテゴリ"),
-            // Chinese uses a system Han face or the native-only permitted LXGW craft face; the
-            // barred Noto CJK collection never supplies it.
-            ("sys-cjk-han-zh", cjk_han_simplified(), "页面布局 客户端配置"),
-            ("sys-cjk-hangul", cjk_hangul(), "한글"),
-            ("sys-thai", thai(), "ทดสอบ"),
-            ("sys-lao", lao(), "ພາສາລາວ"),
-            ("sys-hebrew", hebrew(), "עברית"),
-            ("craft-noto-sans-arabic", Vec::new(), "مرحبا"),
-            ("craft-noto-sans-georgian", Vec::new(), "ქართული"),
-            ("ui", candidates(UI), "Русский"),
-            // Czech interface labels: every Czech accented letter, in both cases.
-            ("ui", candidates(UI), "Příliš žluťoučký kůň úpěl ďábelské ódy ŘŠČŽÝÁÍÉÚŮĚŤĎŇÓ"),
-        ];
-        for language in [Language::En, Language::Ja] {
-            let ctx = egui::Context::default();
-            ctx.set_fonts(font_definitions_for_language(language));
-            let mut out = ctx.run_ui(egui::RawInput::default(), |_ui| {});
-            out.textures_delta.clear(); // nothing consumes the atlas in a headless test
-            for family in [FontFamily::Proportional, FontFamily::Name(CELL.into())] {
-                let font = FontId::new(14.0, family.clone());
-                for (key, cands, sample) in &cases {
-                    // A script runs when a system face or the optional craft-fonts input provides
-                    // one. The skip is printed: a missing fixture is a recorded gate, not a pass.
-                    let system = cands.iter().any(|(p, _)| std::path::Path::new(p).exists());
-                    if !system && !craft_fonts_cover(sample) {
-                        eprintln!("skipped {key}: no system face and no craft-fonts face for {sample:?}");
-                        continue;
-                    }
-                    let missing: String =
-                        sample.chars().filter(|c| !c.is_whitespace()).filter(|&c| !ctx.fonts_mut(|f| f.has_glyph(&font, c))).collect();
-                    assert!(missing.is_empty(), "{key} is present but {sample:?} has no glyph for {missing:?} ({language:?}, {family:?})");
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn chromeos_font_layout_is_probed() {
-        // #1762: Crostini mounts the host's fonts under /usr/share/fonts/chromeos, one folder per
-        // family set; a script whose list misses it renders as tofu with the font installed.
-        let probes = |cands: Vec<(String, u32)>, path: &str| cands.iter().any(|(p, _)| p == path);
-        let cros = "/usr/share/fonts/chromeos";
-        assert!(probes(thai(), &format!("{cros}/noto/NotoSansThai-Regular.ttf")));
-        assert!(probes(hebrew(), &format!("{cros}/noto/NotoSansHebrew-Regular.ttf")));
-        assert!(probes(cjk_han_japanese(), &format!("{cros}/notocjk/NotoSansCJK-Regular.ttc")));
-        assert!(probes(cjk_han_simplified(), &format!("{cros}/notocjk/NotoSansCJK-Regular.ttc")));
-        assert!(probes(cjk_hangul(), &format!("{cros}/notocjk/NotoSansCJK-Regular.ttc")));
-        assert!(probes(symbols_more(), &format!("{cros}/noto/NotoSansSymbols2-Regular.ttf")));
-        assert!(probes(candidates(UI), &format!("{cros}/noto/NotoSans-Regular.ttf")));
-        assert!(probes(candidates(CELL), &format!("{cros}/crosextra/Carlito-Regular.ttf")));
-    }
-
-    #[test]
-    /// Empty, garbage, truncated and bad-index fonts are refused; a bad face is dropped from the definitions and `set_fonts` does not panic.
-    fn unparseable_font_files_are_rejected_not_fatal() {
-        // #226: epaint panics in `set_fonts` on a face it can't parse ("An offset was out of
-        // bounds"). Garbage, a truncated real font and a bad collection index must all be refused.
-        let real = FontDefinitions::default().font_data.values().next().map(|fd| fd.bytes().to_vec()).unwrap_or_default();
-        assert!(font_parses(&real, 0), "egui's own font must parse");
-        assert!(!font_parses(b"", 0));
-        assert!(!font_parses(&[0xAB; 64], 0));
-        assert!(!font_parses(real.get(..20).unwrap_or_default(), 0), "a truncated font must be refused");
-        assert!(!font_parses(&real, 3), "a single-face file has no face 3");
-
-        // A bad face that slipped into the definitions is dropped (key and family entries), and the
-        // context builds its fonts without panicking.
-        let mut fonts = font_definitions();
-        fonts.font_data.insert("sys-hebrew".into(), Arc::new(FontData::from_owned(vec![0, 1, 0, 0, 0, 0xFF, 0, 0])));
-        for chain in fonts.families.values_mut() {
-            chain.push("sys-hebrew".into());
-        }
-        drop_unparseable_fonts(&mut fonts);
-        assert!(!fonts.font_data.contains_key("sys-hebrew"));
-        assert!(fonts.families.values().all(|c| !c.iter().any(|k| k == "sys-hebrew")));
-        let ctx = egui::Context::default();
-        ctx.set_fonts(fonts);
-        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
-            ui.label("Hebrew עברית");
-        });
-        out.textures_delta.clear(); // nothing consumes the atlas in a headless test
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    /// A broken existing font candidate is skipped in favor of a later readable candidate.
-    fn try_load_skips_a_broken_candidate() {
-        // A candidate that exists but is not a readable font must not win over a good one behind it.
-        let dir = std::env::temp_dir().join(format!("gridcraft-font-test-{}", std::process::id()));
-        let _ = std::fs::create_dir_all(&dir);
-        let bad = dir.join("broken.ttf");
-        let good = dir.join("good.ttf");
-        let real = FontDefinitions::default().font_data.values().next().map(|fd| fd.bytes().to_vec()).unwrap_or_default();
-        let _ = std::fs::write(&bad, real.get(..40).unwrap_or_default());
-        let _ = std::fs::write(&good, &real);
-        let (bad_s, good_s) = (bad.to_string_lossy().into_owned(), good.to_string_lossy().into_owned());
-        assert!(try_load(&[(bad_s.as_str(), 0)]).is_none());
-        let loaded = try_load(&[(bad_s.as_str(), 0), (good_s.as_str(), 0)]);
-        assert_eq!(loaded.map(|fd| fd.bytes().len()), Some(real.len()));
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    /// Repeated loads reuse one shared font blob, while a face the kept file does not contain is still refused.
-    fn interface_fonts_are_read_once_and_shared_with_egui() {
-        // egui copies owned font bytes into its text engine and keeps the original too; borrowed
-        // bytes it shares. A rebuild of the font set reuses the file read the first time.
-        let path = std::env::temp_dir().join(format!("gridcraft-font-shared-{}.ttf", std::process::id()));
-        std::fs::write(&path, epaint_default_fonts::UBUNTU_LIGHT).unwrap();
-        let p = path.to_string_lossy().into_owned();
-        let first = try_load(&[(p.as_str(), 0)]).unwrap();
-        std::fs::remove_file(&path).unwrap();
-        let second = try_load(&[(p.as_str(), 0)]).expect("kept from the first read");
-        assert!(
-            std::sync::Arc::ptr_eq(&first.font, &second.font),
-            "interface font bytes must be one shared blob, so egui shares them instead of copying"
-        );
-        assert_eq!(first.bytes(), epaint_default_fonts::UBUNTU_LIGHT);
-        assert!(try_load(&[(p.as_str(), 3)]).is_none(), "a face the kept file doesn't have is still refused");
-    }
-
-    #[test]
-    fn macos_bold_interface_face_is_drawn_unhinted() {
-        // #1184: Helvetica Neue Bold's own TrueType hints close Cyrillic е into ө at 13 pt on a
-        // Retina screen. Core Text never runs them, so on macOS the face goes unhinted like every
-        // other app draws it; the regular face and the other platforms keep egui's default.
-        let fonts = font_definitions_for_language(Language::En);
-        let hinting = |key: &str| fonts.font_data.get(key).map(|fd| fd.tweak.hinting);
-        if let Some(bold) = hinting(&format!("sys-{UI_BOLD}")) {
-            assert_eq!(bold, if cfg!(target_os = "macos") { Some(false) } else { None });
-        }
-        if let Some(regular) = hinting(&format!("sys-{UI}")) {
-            assert_eq!(regular, None, "only the bold face is affected");
-        }
-    }
-
-    #[test]
-    fn fedora_package_folders_are_searched_after_the_other_linux_layouts() {
-        // #1694: Fedora keeps each font family in its own package folder, so without these entries
-        // no cell face is found there and bold and italic cells draw as regular text. Each comes
-        // after the existing Linux folders for the same font, so wherever one of those matched,
-        // nothing changes.
-        let paths = |cands: Vec<(String, u32)>| cands.into_iter().map(|(p, _)| p).collect::<Vec<_>>();
-        let cases: [(&str, Vec<String>, &str, &str); 9] = [
-            (CELL, paths(candidates(CELL)), "google-carlito-fonts/Carlito-Regular.ttf", "/carlito/Carlito-Regular.ttf"),
-            (CELL_BOLD, paths(candidates(CELL_BOLD)), "google-carlito-fonts/Carlito-Bold.ttf", "/carlito/Carlito-Bold.ttf"),
-            (CELL_ITALIC, paths(candidates(CELL_ITALIC)), "google-carlito-fonts/Carlito-Italic.ttf", "/carlito/Carlito-Italic.ttf"),
-            (CELL_BOLD_ITALIC, paths(candidates(CELL_BOLD_ITALIC)), "google-carlito-fonts/Carlito-BoldItalic.ttf", "/carlito/Carlito-BoldItalic.ttf"),
-            (CELL_BOLD, paths(candidates(CELL_BOLD)), "liberation-sans-fonts/LiberationSans-Bold.ttf", "/liberation/LiberationSans-Bold.ttf"),
-            (SERIF, paths(candidates(SERIF)), "liberation-serif-fonts/LiberationSerif-Regular.ttf", "/liberation/LiberationSerif-Regular.ttf"),
-            (MONO, paths(candidates(MONO)), "liberation-mono-fonts/LiberationMono-Regular.ttf", "/dejavu/DejaVuSansMono.ttf"),
-            ("thai", paths(thai()), "google-noto-vf/NotoSansThai[wght].ttf", "/NotoSansThai-Regular.ttf"),
-            ("hebrew", paths(hebrew()), "google-noto-vf/NotoSansHebrew[wght].ttf", "/NotoSansHebrew-Regular.ttf"),
-        ];
-        for (role, list, fedora_file, earlier) in &cases {
-            let at = list.iter().position(|p| *p == format!("/usr/share/fonts/{fedora_file}"));
-            let last_earlier = list.iter().rposition(|p| p.ends_with(earlier));
-            assert!(at.is_some(), "{role}: Fedora's {fedora_file} is not a candidate");
-            assert!(last_earlier.is_some(), "{role}: no existing {earlier} candidate to compare with");
-            assert!(at > last_earlier, "{role}: {fedora_file} must come after every existing {earlier}");
-        }
-        // Liberation Mono only stands in for DejaVu Sans Mono, wherever that is installed.
-        let mono = paths(candidates(MONO));
-        let first_liberation = mono.iter().position(|p| p.ends_with("LiberationMono-Regular.ttf"));
-        let last_dejavu = mono.iter().rposition(|p| p.ends_with("DejaVuSansMono.ttf"));
-        assert!(first_liberation.is_some() && first_liberation > last_dejavu, "Liberation Mono must follow DejaVu Sans Mono: {mono:?}");
-        let noto = mono.iter().position(|p| p == "/usr/share/fonts/google-noto-vf/NotoSansMono[wght].ttf");
-        assert!(noto.is_some() && noto.unwrap_or(0) + 1 == mono.len(), "Fedora's default Noto Sans Mono must be the last resort: {mono:?}");
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/theme/tests.rs b/crates/ui-egui/src/theme/tests.rs
new file mode 100644
index 000000000..15ee29090
--- /dev/null
+++ b/crates/ui-egui/src/theme/tests.rs
@@ -0,0 +1,358 @@
+use super::*;
+use crate::i18n::Language;
+
+#[test]
+/// Loaded script-fallback faces end each role chain just before the craft fonts, in the language's order.
+fn fallback_faces_are_appended_to_every_family() {
+    // Structural: whatever loaded, the non-Latin fallback keys must sit at the end of each chain
+    // (after the Latin/default fonts) so Latin still wins for Latin text, in the language's order.
+    for han in [HanOrder::Chinese, HanOrder::Japanese] {
+        let language = if han == HanOrder::Japanese { Language::Ja } else { Language::Zh };
+        let fonts = font_definitions_for_language(language);
+        let fb_keys: Vec<String> =
+            fallback_faces(han).into_iter().map(|(k, _)| k.to_string()).filter(|k| fonts.font_data.contains_key(k)).collect();
+        if fb_keys.is_empty() {
+            return; // no fallback face on this machine (minimal Linux)
+        }
+        for role in [UI, UI_BOLD, CELL, CELL_BOLD, CELL_ITALIC, CELL_BOLD_ITALIC, SERIF, MONO] {
+            let chain = fonts.families.get(&FontFamily::Name(role.into())).map(Vec::as_slice).unwrap_or_default();
+            // The optional craft-fonts faces follow the system fallbacks at the very end.
+            let end = chain.iter().rposition(|k| !k.starts_with("craft-")).map_or(0, |i| i + 1);
+            assert!(end >= fb_keys.len(), "{role} chain too short for its fallback");
+            assert_eq!(&chain[end - fb_keys.len()..end], fb_keys.as_slice(), "{role} must end its non-craft chain with the fallback faces");
+        }
+    }
+}
+
+#[test]
+/// Every font family ends with exactly the permitted craft faces in manifest order.
+fn craft_fonts_are_the_last_fallback_in_every_family() {
+    // Ordering: app/bundled faces, Hack/emoji, system script fallbacks, permitted craft faces.
+    // A craft face must never displace a system face that already covers a glyph.
+    let fonts = font_definitions_for_language(Language::En);
+    let expected: Vec<String> = craft_font_faces().into_iter().map(|(key, _)| key).collect();
+    if expected.is_empty() {
+        return; // optional input absent
+    }
+    for (family, chain) in &fonts.families {
+        let first = chain.iter().position(|k| k.starts_with("craft-")).unwrap_or(chain.len());
+        assert_eq!(&chain[first..], expected.as_slice(), "{family:?} must end with exactly the permitted craft faces in manifest order");
+    }
+}
+
+#[test]
+/// Skips on wasm or when required mode is off; a required native build must embed LXGW with `Hani`/`Hans`.
+fn a_required_native_build_embeds_the_chinese_face() {
+    if cfg!(target_arch = "wasm32") || !craft_fonts_required() {
+        return;
+    }
+    assert!(
+        chinese_font_loaded(),
+        "CRAFT_FONTS_REQUIRED=1 native builds must embed the LXGW Chinese face from fonts/simplified-chinese-manifest.txt"
+    );
+    let face = craft_font_scripts().find(|(f, s, _)| *f == "LXGW WenKai Lite" && *s == "Regular");
+    assert_eq!(face.map(|(_, _, scripts)| scripts), Some(["Hani", "Hans"].as_slice()), "the Chinese manifest's script tags are asserted");
+}
+
+#[test]
+/// No embedded craft face belongs to the barred Noto CJK, Adobe or Source families.
+fn barred_faces_never_enter_the_font_set() {
+    for (family, _, _) in craft_font_scripts() {
+        assert!(!family.contains("CJK"), "the barred Noto CJK collection must never be embedded: {family}");
+        assert!(!family.starts_with("Source ") && !family.starts_with("Adobe "), "a barred Adobe/Source face was embedded: {family}");
+    }
+}
+
+#[test]
+/// Skips when craft fonts are absent unless required mode is set; otherwise the required faces and their exact script tags are embedded.
+fn the_required_craft_faces_keep_their_exact_scripts() {
+    if !craft_fonts_loaded() {
+        assert!(!craft_fonts_required(), "CRAFT_FONTS_REQUIRED=1 but no craft-fonts faces were embedded");
+        return;
+    }
+    let faces: Vec<_> = craft_font_scripts().collect();
+    for (family, style, scripts) in [
+        ("BIZ UDPGothic", "Regular", ["Jpan", "Latn"].as_slice()),
+        ("BIZ UDPGothic", "Bold", ["Jpan", "Latn"].as_slice()),
+        ("NanumGothic", "Regular", ["Hang", "Kore"].as_slice()),
+        ("Noto Sans Symbols", "Regular", ["Zsym"].as_slice()),
+        ("Noto Sans Symbols 2", "Regular", ["Zsym"].as_slice()),
+    ] {
+        assert!(
+            faces.iter().any(|(f, s, declared)| *f == family && *s == style && *declared == scripts),
+            "{family} {style} with {scripts:?} must be embedded; got {faces:?}"
+        );
+    }
+}
+
+#[test]
+/// Interface text maps unbundled `⌃`, `✓` and `✕` to readable chrome fallbacks; document text is not rewritten.
+fn available_text_maps_unbundled_chrome_symbols() {
+    // No bundled face has ⌃ ✓ ✕; chrome text must show ^ ✔ × instead of tofu. Document text is
+    // never rewritten: this helper is only used for interface tooltips.
+    let ctx = egui::Context::default();
+    ctx.set_fonts(FontDefinitions::default());
+    let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
+        assert_eq!(available_text(ui, "Show Formulas (⌃`) ✓ ✕"), "Show Formulas (^`) ✔ ×");
+    });
+    out.textures_delta.clear();
+}
+
+#[test]
+fn interface_families_fall_back_to_the_cell_font() {
+    // Structural (#349): the formula bar, name box and dialogs draw every script the cells can,
+    // so each interface chain carries the cell face, ahead of the script fallback faces.
+    let fonts = font_definitions_for_language(Language::En);
+    let cell = format!("sys-{CELL}");
+    if !fonts.font_data.contains_key(&cell) {
+        return; // no system cell font on this machine
+    }
+    let fb: Vec<String> = fallback_faces(HanOrder::Chinese).into_iter().map(|(k, _)| k.to_string()).collect();
+    for family in [FontFamily::Proportional, FontFamily::Name(UI.into()), FontFamily::Name(UI_BOLD.into()), FontFamily::Name(MONO.into())] {
+        let chain = fonts.families.get(&family).cloned().unwrap_or_default();
+        let at = chain.iter().position(|k| *k == cell);
+        assert!(at.is_some(), "{family:?} lacks the cell face: {chain:?}");
+        let first_fb = chain.iter().position(|k| fb.contains(k)).unwrap_or(chain.len());
+        assert!(at.unwrap_or(usize::MAX) < first_fb, "{family:?}: cell face must precede the script faces");
+    }
+}
+
+#[test]
+fn language_reorders_only_the_han_faces() {
+    let keys = |han| fallback_faces(han).into_iter().map(|(k, _)| k).collect::<Vec<_>>();
+    assert_eq!(
+        keys(HanOrder::Japanese),
+        ["sys-cjk-han-ja", "sys-cjk-han-zh", "sys-cjk-hangul", "sys-thai", "sys-lao", "sys-hebrew", "sys-symbols", "sys-symbols-2"]
+    );
+    assert_eq!(
+        keys(HanOrder::Chinese),
+        ["sys-cjk-han-zh", "sys-cjk-han-ja", "sys-cjk-hangul", "sys-thai", "sys-lao", "sys-hebrew", "sys-symbols", "sys-symbols-2"]
+    );
+    assert_eq!(HanOrder::of(Language::Ja), HanOrder::Japanese);
+    for l in [Language::En, Language::Zh, Language::Ko, Language::Ru, Language::PtBr, Language::De, Language::Cs, Language::Fr, Language::Tr] {
+        assert_eq!(HanOrder::of(l), HanOrder::Chinese, "{l:?} shares the default order (no font rebuild)");
+    }
+}
+
+#[test]
+fn cjk_fallback_probes_flatpak_fonts_with_the_correct_locale_faces() {
+    // Exercise the candidates the fallback loader actually consumes, not just the directory
+    // constant. This must work on CI without an installed CJK font or a Flatpak runtime.
+    for (candidates, face) in [(cjk_han_japanese(), 0), (cjk_han_simplified(), 2), (cjk_hangul(), 1)] {
+        for directory in [
+            "/run/host/fonts/opentype/noto",
+            "/run/host/fonts/google-noto-cjk",
+            "/run/host/fonts/noto-cjk",
+            "/run/host/fonts/truetype/noto",
+            "/run/host/fonts/noto",
+            "/run/host/fonts/truetype",
+            "/run/host/fonts/TTF",
+            "/run/host/fonts",
+            "/run/host/local-fonts",
+            "/run/host/local-fonts/noto-cjk",
+            "/run/host/user-fonts",
+        ] {
+            let path = format!("{directory}/NotoSansCJK-Regular.ttc");
+            assert!(candidates.contains(&(path.clone(), face)), "missing Flatpak CJK candidate {path}, face {face}");
+        }
+    }
+    let chinese = cjk_han_simplified();
+    assert!(chinese.contains(&("/run/host/fonts/truetype/wqy/wqy-microhei.ttc".into(), 0)));
+    assert!(chinese.contains(&("/run/host/fonts/wenquanyi/wqy-microhei.ttc".into(), 0)));
+}
+
+#[test]
+/// A font file shared by several fallback scripts is loaded once, with one shared font blob rather than a copy per script.
+fn fallback_faces_load_each_file_once() {
+    // The region-merged Noto Sans CJK .ttc serves Japanese, Chinese and Hangul; it must be loaded
+    // once, not once per script (tens of MB each).
+    for language in [Language::En, Language::Ja] {
+        let fonts = font_definitions_for_language(language);
+        let present: Vec<&Arc<FontData>> =
+            fallback_faces(HanOrder::of(language)).into_iter().filter_map(|(k, _)| fonts.font_data.get(k)).collect();
+        for (i, a) in present.iter().enumerate() {
+            for b in present.iter().skip(i + 1) {
+                assert!(!std::sync::Arc::ptr_eq(&a.font, &b.font), "the same font file is loaded for two fallback scripts");
+            }
+        }
+    }
+}
+
+#[test]
+/// Checks that the proportional and cell families have glyphs for every present script sample; samples with no system or craft face are printed as skipped.
+fn fallback_covers_its_script() {
+    // Real glyph check, per script: the proportional family (what cells and the UI use) must
+    // have a glyph for every non-space character in the sample. A script runs when a system
+    // face or the optional craft-fonts input provides one; the printed skip is a recorded
+    // gate, and a present face that is not wired in fails.
+    let cases: [(&str, Vec<(String, u32)>, &str); 10] = [
+        ("sys-cjk-han-ja", cjk_han_japanese(), "カテゴリ"),
+        // Chinese uses a system Han face or the native-only permitted LXGW craft face; the
+        // barred Noto CJK collection never supplies it.
+        ("sys-cjk-han-zh", cjk_han_simplified(), "页面布局 客户端配置"),
+        ("sys-cjk-hangul", cjk_hangul(), "한글"),
+        ("sys-thai", thai(), "ทดสอบ"),
+        ("sys-lao", lao(), "ພາສາລາວ"),
+        ("sys-hebrew", hebrew(), "עברית"),
+        ("craft-noto-sans-arabic", Vec::new(), "مرحبا"),
+        ("craft-noto-sans-georgian", Vec::new(), "ქართული"),
+        ("ui", candidates(UI), "Русский"),
+        // Czech interface labels: every Czech accented letter, in both cases.
+        ("ui", candidates(UI), "Příliš žluťoučký kůň úpěl ďábelské ódy ŘŠČŽÝÁÍÉÚŮĚŤĎŇÓ"),
+    ];
+    for language in [Language::En, Language::Ja] {
+        let ctx = egui::Context::default();
+        ctx.set_fonts(font_definitions_for_language(language));
+        let mut out = ctx.run_ui(egui::RawInput::default(), |_ui| {});
+        out.textures_delta.clear(); // nothing consumes the atlas in a headless test
+        for family in [FontFamily::Proportional, FontFamily::Name(CELL.into())] {
+            let font = FontId::new(14.0, family.clone());
+            for (key, cands, sample) in &cases {
+                // A script runs when a system face or the optional craft-fonts input provides
+                // one. The skip is printed: a missing fixture is a recorded gate, not a pass.
+                let system = cands.iter().any(|(p, _)| std::path::Path::new(p).exists());
+                if !system && !craft_fonts_cover(sample) {
+                    eprintln!("skipped {key}: no system face and no craft-fonts face for {sample:?}");
+                    continue;
+                }
+                let missing: String =
+                    sample.chars().filter(|c| !c.is_whitespace()).filter(|&c| !ctx.fonts_mut(|f| f.has_glyph(&font, c))).collect();
+                assert!(missing.is_empty(), "{key} is present but {sample:?} has no glyph for {missing:?} ({language:?}, {family:?})");
+            }
+        }
+    }
+}
+
+#[test]
+fn chromeos_font_layout_is_probed() {
+    // #1762: Crostini mounts the host's fonts under /usr/share/fonts/chromeos, one folder per
+    // family set; a script whose list misses it renders as tofu with the font installed.
+    let probes = |cands: Vec<(String, u32)>, path: &str| cands.iter().any(|(p, _)| p == path);
+    let cros = "/usr/share/fonts/chromeos";
+    assert!(probes(thai(), &format!("{cros}/noto/NotoSansThai-Regular.ttf")));
+    assert!(probes(hebrew(), &format!("{cros}/noto/NotoSansHebrew-Regular.ttf")));
+    assert!(probes(cjk_han_japanese(), &format!("{cros}/notocjk/NotoSansCJK-Regular.ttc")));
+    assert!(probes(cjk_han_simplified(), &format!("{cros}/notocjk/NotoSansCJK-Regular.ttc")));
+    assert!(probes(cjk_hangul(), &format!("{cros}/notocjk/NotoSansCJK-Regular.ttc")));
+    assert!(probes(symbols_more(), &format!("{cros}/noto/NotoSansSymbols2-Regular.ttf")));
+    assert!(probes(candidates(UI), &format!("{cros}/noto/NotoSans-Regular.ttf")));
+    assert!(probes(candidates(CELL), &format!("{cros}/crosextra/Carlito-Regular.ttf")));
+}
+
+#[test]
+/// Empty, garbage, truncated and bad-index fonts are refused; a bad face is dropped from the definitions and `set_fonts` does not panic.
+fn unparseable_font_files_are_rejected_not_fatal() {
+    // #226: epaint panics in `set_fonts` on a face it can't parse ("An offset was out of
+    // bounds"). Garbage, a truncated real font and a bad collection index must all be refused.
+    let real = FontDefinitions::default().font_data.values().next().map(|fd| fd.bytes().to_vec()).unwrap_or_default();
+    assert!(font_parses(&real, 0), "egui's own font must parse");
+    assert!(!font_parses(b"", 0));
+    assert!(!font_parses(&[0xAB; 64], 0));
+    assert!(!font_parses(real.get(..20).unwrap_or_default(), 0), "a truncated font must be refused");
+    assert!(!font_parses(&real, 3), "a single-face file has no face 3");
+
+    // A bad face that slipped into the definitions is dropped (key and family entries), and the
+    // context builds its fonts without panicking.
+    let mut fonts = font_definitions();
+    fonts.font_data.insert("sys-hebrew".into(), Arc::new(FontData::from_owned(vec![0, 1, 0, 0, 0, 0xFF, 0, 0])));
+    for chain in fonts.families.values_mut() {
+        chain.push("sys-hebrew".into());
+    }
+    drop_unparseable_fonts(&mut fonts);
+    assert!(!fonts.font_data.contains_key("sys-hebrew"));
+    assert!(fonts.families.values().all(|c| !c.iter().any(|k| k == "sys-hebrew")));
+    let ctx = egui::Context::default();
+    ctx.set_fonts(fonts);
+    let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
+        ui.label("Hebrew עברית");
+    });
+    out.textures_delta.clear(); // nothing consumes the atlas in a headless test
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+/// A broken existing font candidate is skipped in favor of a later readable candidate.
+fn try_load_skips_a_broken_candidate() {
+    // A candidate that exists but is not a readable font must not win over a good one behind it.
+    let dir = std::env::temp_dir().join(format!("gridcraft-font-test-{}", std::process::id()));
+    let _ = std::fs::create_dir_all(&dir);
+    let bad = dir.join("broken.ttf");
+    let good = dir.join("good.ttf");
+    let real = FontDefinitions::default().font_data.values().next().map(|fd| fd.bytes().to_vec()).unwrap_or_default();
+    let _ = std::fs::write(&bad, real.get(..40).unwrap_or_default());
+    let _ = std::fs::write(&good, &real);
+    let (bad_s, good_s) = (bad.to_string_lossy().into_owned(), good.to_string_lossy().into_owned());
+    assert!(try_load(&[(bad_s.as_str(), 0)]).is_none());
+    let loaded = try_load(&[(bad_s.as_str(), 0), (good_s.as_str(), 0)]);
+    assert_eq!(loaded.map(|fd| fd.bytes().len()), Some(real.len()));
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+/// Repeated loads reuse one shared font blob, while a face the kept file does not contain is still refused.
+fn interface_fonts_are_read_once_and_shared_with_egui() {
+    // egui copies owned font bytes into its text engine and keeps the original too; borrowed
+    // bytes it shares. A rebuild of the font set reuses the file read the first time.
+    let path = std::env::temp_dir().join(format!("gridcraft-font-shared-{}.ttf", std::process::id()));
+    std::fs::write(&path, epaint_default_fonts::UBUNTU_LIGHT).unwrap();
+    let p = path.to_string_lossy().into_owned();
+    let first = try_load(&[(p.as_str(), 0)]).unwrap();
+    std::fs::remove_file(&path).unwrap();
+    let second = try_load(&[(p.as_str(), 0)]).expect("kept from the first read");
+    assert!(
+        std::sync::Arc::ptr_eq(&first.font, &second.font),
+        "interface font bytes must be one shared blob, so egui shares them instead of copying"
+    );
+    assert_eq!(first.bytes(), epaint_default_fonts::UBUNTU_LIGHT);
+    assert!(try_load(&[(p.as_str(), 3)]).is_none(), "a face the kept file doesn't have is still refused");
+}
+
+#[test]
+fn macos_bold_interface_face_is_drawn_unhinted() {
+    // #1184: Helvetica Neue Bold's own TrueType hints close Cyrillic е into ө at 13 pt on a
+    // Retina screen. Core Text never runs them, so on macOS the face goes unhinted like every
+    // other app draws it; the regular face and the other platforms keep egui's default.
+    let fonts = font_definitions_for_language(Language::En);
+    let hinting = |key: &str| fonts.font_data.get(key).map(|fd| fd.tweak.hinting);
+    if let Some(bold) = hinting(&format!("sys-{UI_BOLD}")) {
+        assert_eq!(bold, if cfg!(target_os = "macos") { Some(false) } else { None });
+    }
+    if let Some(regular) = hinting(&format!("sys-{UI}")) {
+        assert_eq!(regular, None, "only the bold face is affected");
+    }
+}
+
+#[test]
+fn fedora_package_folders_are_searched_after_the_other_linux_layouts() {
+    // #1694: Fedora keeps each font family in its own package folder, so without these entries
+    // no cell face is found there and bold and italic cells draw as regular text. Each comes
+    // after the existing Linux folders for the same font, so wherever one of those matched,
+    // nothing changes.
+    let paths = |cands: Vec<(String, u32)>| cands.into_iter().map(|(p, _)| p).collect::<Vec<_>>();
+    let cases: [(&str, Vec<String>, &str, &str); 9] = [
+        (CELL, paths(candidates(CELL)), "google-carlito-fonts/Carlito-Regular.ttf", "/carlito/Carlito-Regular.ttf"),
+        (CELL_BOLD, paths(candidates(CELL_BOLD)), "google-carlito-fonts/Carlito-Bold.ttf", "/carlito/Carlito-Bold.ttf"),
+        (CELL_ITALIC, paths(candidates(CELL_ITALIC)), "google-carlito-fonts/Carlito-Italic.ttf", "/carlito/Carlito-Italic.ttf"),
+        (CELL_BOLD_ITALIC, paths(candidates(CELL_BOLD_ITALIC)), "google-carlito-fonts/Carlito-BoldItalic.ttf", "/carlito/Carlito-BoldItalic.ttf"),
+        (CELL_BOLD, paths(candidates(CELL_BOLD)), "liberation-sans-fonts/LiberationSans-Bold.ttf", "/liberation/LiberationSans-Bold.ttf"),
+        (SERIF, paths(candidates(SERIF)), "liberation-serif-fonts/LiberationSerif-Regular.ttf", "/liberation/LiberationSerif-Regular.ttf"),
+        (MONO, paths(candidates(MONO)), "liberation-mono-fonts/LiberationMono-Regular.ttf", "/dejavu/DejaVuSansMono.ttf"),
+        ("thai", paths(thai()), "google-noto-vf/NotoSansThai[wght].ttf", "/NotoSansThai-Regular.ttf"),
+        ("hebrew", paths(hebrew()), "google-noto-vf/NotoSansHebrew[wght].ttf", "/NotoSansHebrew-Regular.ttf"),
+    ];
+    for (role, list, fedora_file, earlier) in &cases {
+        let at = list.iter().position(|p| *p == format!("/usr/share/fonts/{fedora_file}"));
+        let last_earlier = list.iter().rposition(|p| p.ends_with(earlier));
+        assert!(at.is_some(), "{role}: Fedora's {fedora_file} is not a candidate");
+        assert!(last_earlier.is_some(), "{role}: no existing {earlier} candidate to compare with");
+        assert!(at > last_earlier, "{role}: {fedora_file} must come after every existing {earlier}");
+    }
+    // Liberation Mono only stands in for DejaVu Sans Mono, wherever that is installed.
+    let mono = paths(candidates(MONO));
+    let first_liberation = mono.iter().position(|p| p.ends_with("LiberationMono-Regular.ttf"));
+    let last_dejavu = mono.iter().rposition(|p| p.ends_with("DejaVuSansMono.ttf"));
+    assert!(first_liberation.is_some() && first_liberation > last_dejavu, "Liberation Mono must follow DejaVu Sans Mono: {mono:?}");
+    let noto = mono.iter().position(|p| p == "/usr/share/fonts/google-noto-vf/NotoSansMono[wght].ttf");
+    assert!(noto.is_some() && noto.unwrap_or(0) + 1 == mono.len(), "Fedora's default Noto Sans Mono must be the last resort: {mono:?}");
+}

From a8db625e6b955e47d1b24a56d71f6c039f34789f Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:15:59 +0000
Subject: [PATCH 40/76] style: cargo fmt on the moved test files

---
 apps/gridcraft-cli/src/check/tests.rs   |  9 ++++-----
 crates/engine/src/cmd/data/tests.rs     |  5 ++---
 crates/engine/src/cmd/pivot/tests.rs    |  9 +++------
 crates/engine/src/cmd/print/tests.rs    |  7 ++-----
 crates/engine/src/cmd/solver/tests.rs   | 21 +++++++--------------
 crates/engine/src/io/tests.rs           |  9 ++-------
 crates/functions/src/financial/tests.rs |  5 +----
 crates/ui-egui/src/code_editor/tests.rs |  8 ++------
 crates/ui-egui/src/control/tests.rs     | 16 ++++------------
 crates/ui-egui/src/theme/tests.rs       |  9 +++------
 10 files changed, 30 insertions(+), 68 deletions(-)

diff --git a/apps/gridcraft-cli/src/check/tests.rs b/apps/gridcraft-cli/src/check/tests.rs
index f1df04670..68c6f8fb5 100644
--- a/apps/gridcraft-cli/src/check/tests.rs
+++ b/apps/gridcraft-cli/src/check/tests.rs
@@ -223,8 +223,7 @@ fn diff_detects_changed_cond_format_rule() {
         wb.sheet_mut(0).unwrap().cond_formats.push(cf);
         wb
     };
-    let diffs =
-        |a: &Workbook, b: &Workbook| diff_workbooks(a, b, &Options::default()).into_iter().find(|c| c.name == "condFormats").unwrap().diffs;
+    let diffs = |a: &Workbook, b: &Workbook| diff_workbooks(a, b, &Options::default()).into_iter().find(|c| c.name == "condFormats").unwrap().diffs;
     assert_eq!(diffs(&with(bar(false, 1)), &with(bar(true, 1))), 1);
     assert_eq!(diffs(&with(bar(true, 1)), &with(bar(true, 1))), 0);
     assert_eq!(diffs(&with(bar(true, 1)), &with(bar(true, 5))), 0);
@@ -315,7 +314,8 @@ fn plain() -> Vec<u8> {
 fn package_reports_relationship_kinds_the_output_lost() {
     // A kind GridCraft doesn't know is dropped on save; a calculation chain is never written
     // (Excel rebuilds it), so its absence isn't a loss.
-    let calc_chain = r#"<Relationship Id="rId91" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain" Target="calcChain.xml"/>"#;
+    let calc_chain =
+        r#"<Relationship Id="rId91" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain" Target="calcChain.xml"/>"#;
     let source = with_rels(&plain(), &[(WB_RELS, &format!("{MADE_UP}{calc_chain}"))], &[MADE_UP_PART, ("xl/calcChain.xml", "<calcChain/>")]);
     assert_eq!(package_of(&source), ["lost relationship madeUp"]);
     assert!(check_bytes("t.xlsx", &plain(), &Options::default()).round_trip.is_clean());
@@ -347,8 +347,7 @@ fn comments_without_a_comment_are_not_a_loss() {
 #[test]
 fn empty_drawings_and_person_lists_are_not_a_loss() {
     let drawing = r#"<Relationship Id="rId8" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing1.xml"/>"#;
-    let person =
-        r#"<Relationship Id="rId92" Type="http://schemas.microsoft.com/office/2017/10/relationships/person" Target="persons/person.xml"/>"#;
+    let person = r#"<Relationship Id="rId92" Type="http://schemas.microsoft.com/office/2017/10/relationships/person" Target="persons/person.xml"/>"#;
     let source = with_rels(
         &plain(),
         &[(WB_RELS, &format!("{MADE_UP}{person}")), (SHEET_RELS, drawing)],
diff --git a/crates/engine/src/cmd/data/tests.rs b/crates/engine/src/cmd/data/tests.rs
index 8708fbf75..5b848e5c0 100644
--- a/crates/engine/src/cmd/data/tests.rs
+++ b/crates/engine/src/cmd/data/tests.rs
@@ -128,9 +128,8 @@ fn partial_validation_edits_keep_the_rest_of_the_old_rule() {
     let mut s = Session::new();
     s.new_workbook();
     let rule = |range: &str, lo: &str, hi: &str| json!({"range": range, "type": "whole", "operator": "between", "formula1": lo, "formula2": hi});
-    let ok = |s: &mut Session, cell: &str, input: &str| {
-        s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == json!(true)
-    };
+    let ok =
+        |s: &mut Session, cell: &str, input: &str| s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == json!(true);
     s.execute("data.validation", rule("B1:B3", "1", "10")).unwrap();
     s.execute("data.validation", json!({"range": "B2", "clear": true})).unwrap();
     assert!(ok(&mut s, "B2", "999"));
diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs
index 49aca34d8..639f9b63d 100644
--- a/crates/engine/src/cmd/pivot/tests.rs
+++ b/crates/engine/src/cmd/pivot/tests.rs
@@ -569,12 +569,10 @@ fn replace_protection() {
     s.execute("pivot.addField", json!({"field": "Region", "area": "rows", "replace": true})).unwrap();
     assert_eq!(text(&s, "H5"), "North");
     // A second pivot can't overlap the first.
-    let e =
-        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H6", "replace": true})).unwrap_err().to_string();
+    let e = s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H6", "replace": true})).unwrap_err().to_string();
     assert!(e.contains("overlap"), "{e}");
     // Nor its own source data.
-    let e =
-        s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!B2", "replace": true})).unwrap_err().to_string();
+    let e = s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!B2", "replace": true})).unwrap_err().to_string();
     assert!(e.contains("source data"), "{e}");
     // Delete clears the report.
     s.execute("pivot.delete", json!({})).unwrap();
@@ -761,8 +759,7 @@ fn collapsed_column_items_count_as_one_column_group() {
 #[test]
 fn inserting_or_deleting_lines_moves_the_pivot_with_its_cells() {
     let mut s = sales();
-    s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H10", "rows": ["Region"], "values": ["Sales"]}))
-        .unwrap();
+    s.execute("insert.pivotTable", json!({"source": "Sheet1!A1:E13", "destination": "Sheet1!H10", "rows": ["Region"], "values": ["Sales"]})).unwrap();
     assert_eq!(pt(&s).last_range.unwrap().a1(), "H10:I14");
     // Rows above the report (and below the source) move the report only.
     s.execute("home.insertRows", json!({"rows": "16:17"})).unwrap();
diff --git a/crates/engine/src/cmd/print/tests.rs b/crates/engine/src/cmd/print/tests.rs
index 89b7b62a7..21b13338f 100644
--- a/crates/engine/src/cmd/print/tests.rs
+++ b/crates/engine/src/cmd/print/tests.rs
@@ -223,11 +223,8 @@ fn pdf_contains_text_and_header_codes_expand() {
     let mut s = s();
     s.execute("range.setValues", json!({"range": "A1", "values": [["Quarterly Report", null], ["Total", 1234.5]]})).unwrap();
     s.execute("home.bold", json!({"range": "A1"})).unwrap();
-    s.execute(
-        "pageLayout.pageSetup",
-        json!({"header": "&LLeft &A&CMiddle&RPage &P of &N", "footer": "&C&F", "gridlines": true, "headings": true}),
-    )
-    .unwrap();
+    s.execute("pageLayout.pageSetup", json!({"header": "&LLeft &A&CMiddle&RPage &P of &N", "footer": "&C&F", "gridlines": true, "headings": true}))
+        .unwrap();
     let (pdf, pages) = pdf_of(&mut s, json!({}));
     assert_eq!(pages, 1);
     assert!(contains(&pdf, "(Quarterly Report) Tj"));
diff --git a/crates/engine/src/cmd/solver/tests.rs b/crates/engine/src/cmd/solver/tests.rs
index bac1328b7..3f570fc6e 100644
--- a/crates/engine/src/cmd/solver/tests.rs
+++ b/crates/engine/src/cmd/solver/tests.rs
@@ -103,8 +103,7 @@ fn evolutionary_finds_the_global_minimum_of_non_smooth_and_multimodal_models() {
     let mut s = s();
     // |x − 3| + |y + 2| has a kink at its minimum (3, −2).
     set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=ABS(A1-3)+ABS(A2+2)")]);
-    let p =
-        json!({"objective": "B1", "goal": "min", "variables": "A1:A2", "constraints": ["A1:A2 >= -10", "A1:A2 <= 10"], "method": "evolutionary"});
+    let p = json!({"objective": "B1", "goal": "min", "variables": "A1:A2", "constraints": ["A1:A2 >= -10", "A1:A2 <= 10"], "method": "evolutionary"});
     let r = s.execute("data.solver", p.clone()).unwrap();
     assert!(r["status"] == "converged" || r["status"] == "cannotImprove", "{r}");
     assert!((n(&s, "A1") - 3.0).abs() < 1e-6 && (n(&s, "A2") + 2.0).abs() < 1e-6, "{r}");
@@ -247,8 +246,7 @@ fn answer_and_limits_reports_describe_the_wyndor_glass_solution() {
     assert_eq!(row(r), [2.0, 0.0, 30.0, 2.0, 36.0]);
     assert_eq!(row(r + 1), [6.0, 0.0, 6.0, 6.0, 36.0]);
     // data.solverReport writes reports from the saved model and a given solution.
-    let out =
-        s.execute("data.solverReport", json!({"reports": ["answer"], "values": {"B2": 2, "C2": 6}, "original": {"B2": 1, "C2": 1}})).unwrap();
+    let out = s.execute("data.solverReport", json!({"reports": ["answer"], "values": {"B2": 2, "C2": 6}, "original": {"B2": 1, "C2": 1}})).unwrap();
     assert_eq!(out["sheets"], json!(["Answer Report 2"]));
     let r = row_of(&s, "Answer Report 2", "$D$6") + 1;
     assert_eq!(at(&s, "Answer Report 2", &format!("D{r}")), Value::number(8.0));
@@ -289,11 +287,8 @@ fn refused_solver_reports_preserve_the_document_and_history() {
         for (keep, save) in [(true, true), (false, true), (true, false), (false, false)] {
             let mut s = s();
             set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
-            s.execute(
-                "data.solver",
-                json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 2"], "method": "simplex", "keep": false}),
-            )
-            .unwrap();
+            s.execute("data.solver", json!({"objective": "B1", "variables": "A1", "constraints": ["A1 <= 2"], "method": "simplex", "keep": false}))
+                .unwrap();
             set(&mut s, &[("C1", "redo")]);
             s.execute("edit.undo", json!({})).unwrap();
             let d = s.doc_mut().unwrap();
@@ -411,8 +406,7 @@ fn limits_report_of_a_nonlinear_model() {
     // width ranges over 0..5, the area over 0..25.
     let mut s = s();
     set(&mut s, &[("A1", "1"), ("A2", "1"), ("B1", "=A1*A2"), ("B2", "=2*A1+2*A2")]);
-    let r =
-        s.execute("data.solver", json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 20"], "reports": ["limits"]})).unwrap();
+    let r = s.execute("data.solver", json!({"objective": "B1", "variables": "A1:A2", "constraints": ["B2 <= 20"], "reports": ["limits"]})).unwrap();
     assert_eq!(r["reports"], json!(["Limits Report 1"]), "{r}");
     let l = "Limits Report 1";
     let r = row_of(&s, l, "$A$1") + 1;
@@ -427,9 +421,8 @@ fn infeasible_unbounded_and_nonlinear_models_are_reported() {
     let mut s = s();
     set(&mut s, &[("A1", "1"), ("B1", "=2*A1")]);
     for method in ["simplex", "grg"] {
-        let r = s
-            .execute("data.solver", json!({"objective": "B1", "variables": "A1", "constraints": ["A1 >= 5", "B1 <= 6"], "method": method}))
-            .unwrap();
+        let r =
+            s.execute("data.solver", json!({"objective": "B1", "variables": "A1", "constraints": ["A1 >= 5", "B1 <= 6"], "method": method})).unwrap();
         assert_eq!(r["status"], "infeasible", "{method}: {r}");
         assert_eq!(r["changed"], false);
         assert_eq!(n(&s, "A1"), 1.0, "an infeasible model leaves the cells alone");
diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs
index 36e5cad89..48c8e130e 100644
--- a/crates/engine/src/io/tests.rs
+++ b/crates/engine/src/io/tests.rs
@@ -176,10 +176,7 @@ fn html_export_marks_right_to_left_sheets() {
     let html = to_html(&wb, 0).unwrap();
     assert!(html.contains("<body><table dir=\"rtl\">"), "{html}");
     assert!(html.contains("<td style=\"\" dir=\"auto\">Hello!</td>"), "Latin text keeps its own direction: {html}");
-    assert!(
-        html.contains("<td style=\"text-align:left;\" dir=\"ltr\">-5</td>"),
-        "numbers mirror to the left and keep their sign in front: {html}"
-    );
+    assert!(html.contains("<td style=\"text-align:left;\" dir=\"ltr\">-5</td>"), "numbers mirror to the left and keep their sign in front: {html}");
     let clip = copied(&wb, "A1:B1");
     assert!(clip.starts_with("<table dir=\"rtl\" style="), "{clip}");
     assert_eq!(clip.matches("dir=\"auto\"").count(), 1, "{clip}");
@@ -496,9 +493,7 @@ fn template_extension_saves_template_content_type() {
     let mut types = String::new();
     std::io::Read::read_to_string(&mut zip.by_name("[Content_Types].xml").unwrap(), &mut types).unwrap();
     assert!(
-        types.contains(
-            r#"PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml""#
-        ),
+        types.contains(r#"PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml""#),
         "{types}"
     );
 }
diff --git a/crates/functions/src/financial/tests.rs b/crates/functions/src/financial/tests.rs
index 17f416412..2788da94a 100644
--- a/crates/functions/src/financial/tests.rs
+++ b/crates/functions/src/financial/tests.rs
@@ -227,10 +227,7 @@ fn odd_periods() {
     is_err(ev("ODDFPRICE", first(0.0785, &[0.0625, 100.0, 2.0, 5.0])), CellError::Num);
     is_err(ev("ODDFPRICE", first(0.0785, &[-0.01, 100.0, 2.0, 1.0])), CellError::Num);
     is_err(ev("ODDFYIELD", first(0.0575, &[0.0, 100.0, 2.0, 0.0])), CellError::Num);
-    is_err(
-        ev("ODDFPRICE", vec![d(2009, 4, 1), d(2021, 3, 1), d(2008, 10, 15), d(2009, 3, 1), n(0.07), n(0.06), n(100.0), n(2.0)]),
-        CellError::Num,
-    );
+    is_err(ev("ODDFPRICE", vec![d(2009, 4, 1), d(2021, 3, 1), d(2008, 10, 15), d(2009, 3, 1), n(0.07), n(0.06), n(100.0), n(2.0)]), CellError::Num);
     is_err(ev("ODDLPRICE", vec![d(2007, 10, 1), d(2008, 6, 15), d(2007, 10, 15), n(0.0375), n(0.0405), n(100.0), n(2.0)]), CellError::Num);
     is_err(ev("ODDLYIELD", vec![d(2008, 4, 20), d(2008, 6, 15), d(2007, 12, 24), n(0.0375), n(-1.0), n(100.0), n(2.0)]), CellError::Num);
     is_err(
diff --git a/crates/ui-egui/src/code_editor/tests.rs b/crates/ui-egui/src/code_editor/tests.rs
index 1bfcab75c..ba3c08efa 100644
--- a/crates/ui-egui/src/code_editor/tests.rs
+++ b/crates/ui-egui/src/code_editor/tests.rs
@@ -213,12 +213,8 @@ fn typed_text_and_deletions_replace_the_selection() {
     delete(&mut s, (2, 0), true);
     assert_eq!(s, "");
     // The queue keeps what the editor does not handle, and everything after it.
-    let mut events = vec![
-        egui::Event::Text("x".into()),
-        egui::Event::Text("\n".into()),
-        key(Key::ArrowLeft, Modifiers::NONE),
-        key(Key::Enter, Modifiers::NONE),
-    ];
+    let mut events =
+        vec![egui::Event::Text("x".into()), egui::Event::Text("\n".into()), key(Key::ArrowLeft, Modifiers::NONE), key(Key::Enter, Modifiers::NONE)];
     let (mut s, mut sel) = (String::new(), (0, 0));
     let out = apply_in_order(&mut events, &mut s, &mut sel, Lang::Python);
     assert!(out.edited);
diff --git a/crates/ui-egui/src/control/tests.rs b/crates/ui-egui/src/control/tests.rs
index 1b0ae80e5..a680279e5 100644
--- a/crates/ui-egui/src/control/tests.rs
+++ b/crates/ui-egui/src/control/tests.rs
@@ -100,11 +100,8 @@ fn ui_pass(ctx: &egui::Context, raw: egui::RawInput, f: impl FnMut(&mut egui::Ui
 /// Returns an egui context initialized by one blank pass at `size` with an 8192-pixel texture limit.
 fn sized_context(size: egui::Vec2) -> egui::Context {
     let ctx = egui::Context::default();
-    let raw = egui::RawInput {
-        screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)),
-        max_texture_side: Some(8192),
-        ..Default::default()
-    };
+    let raw =
+        egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), max_texture_side: Some(8192), ..Default::default() };
     let _ = ui_pass(&ctx, raw, |_| {});
     ctx
 }
@@ -927,10 +924,7 @@ fn base64_capture_over_the_encoding_budget_is_rejected_before_admission() {
     admit(&mut app, &ctx, None, tx);
     let reply = rx.try_recv().expect("an oversized base64 capture is refused at admission");
     assert_eq!(reply["ok"], false, "{reply}");
-    assert!(
-        reply["error"].as_str().is_some_and(|e| e.contains("encoding") || e.contains("base64")),
-        "the error names the encoding budget: {reply}"
-    );
+    assert!(reply["error"].as_str().is_some_and(|e| e.contains("encoding") || e.contains("base64")), "the error names the encoding budget: {reply}");
     assert!(app.shots.requests.is_empty(), "a refused request reserves nothing");
 
     // The same capture as a file is admitted within the per-image and encoding budgets.
@@ -957,9 +951,7 @@ fn synthetic_text_key_and_move_producers_honour_the_queue_budget() {
     let max = "x".repeat(MAX_SYNTHETIC_TEXT_BYTES);
     let mut refused_at = None;
     for i in 0..64 {
-        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": max.clone()})) else {
-            panic!("ui.text returns immediately")
-        };
+        let Outcome::Done(reply) = handle(&mut app, &ctx, "ui.text", &json!({"text": max.clone()})) else { panic!("ui.text returns immediately") };
         if reply["ok"] == false {
             refused_at = Some((i, app.synthetic.len()));
             break;
diff --git a/crates/ui-egui/src/theme/tests.rs b/crates/ui-egui/src/theme/tests.rs
index 15ee29090..b8ad4416e 100644
--- a/crates/ui-egui/src/theme/tests.rs
+++ b/crates/ui-egui/src/theme/tests.rs
@@ -9,8 +9,7 @@ fn fallback_faces_are_appended_to_every_family() {
     for han in [HanOrder::Chinese, HanOrder::Japanese] {
         let language = if han == HanOrder::Japanese { Language::Ja } else { Language::Zh };
         let fonts = font_definitions_for_language(language);
-        let fb_keys: Vec<String> =
-            fallback_faces(han).into_iter().map(|(k, _)| k.to_string()).filter(|k| fonts.font_data.contains_key(k)).collect();
+        let fb_keys: Vec<String> = fallback_faces(han).into_iter().map(|(k, _)| k.to_string()).filter(|k| fonts.font_data.contains_key(k)).collect();
         if fb_keys.is_empty() {
             return; // no fallback face on this machine (minimal Linux)
         }
@@ -168,8 +167,7 @@ fn fallback_faces_load_each_file_once() {
     // once, not once per script (tens of MB each).
     for language in [Language::En, Language::Ja] {
         let fonts = font_definitions_for_language(language);
-        let present: Vec<&Arc<FontData>> =
-            fallback_faces(HanOrder::of(language)).into_iter().filter_map(|(k, _)| fonts.font_data.get(k)).collect();
+        let present: Vec<&Arc<FontData>> = fallback_faces(HanOrder::of(language)).into_iter().filter_map(|(k, _)| fonts.font_data.get(k)).collect();
         for (i, a) in present.iter().enumerate() {
             for b in present.iter().skip(i + 1) {
                 assert!(!std::sync::Arc::ptr_eq(&a.font, &b.font), "the same font file is loaded for two fallback scripts");
@@ -215,8 +213,7 @@ fn fallback_covers_its_script() {
                     eprintln!("skipped {key}: no system face and no craft-fonts face for {sample:?}");
                     continue;
                 }
-                let missing: String =
-                    sample.chars().filter(|c| !c.is_whitespace()).filter(|&c| !ctx.fonts_mut(|f| f.has_glyph(&font, c))).collect();
+                let missing: String = sample.chars().filter(|c| !c.is_whitespace()).filter(|&c| !ctx.fonts_mut(|f| f.has_glyph(&font, c))).collect();
                 assert!(missing.is_empty(), "{key} is present but {sample:?} has no glyph for {missing:?} ({language:?}, {family:?})");
             }
         }

From 58465af95adebd22bdbc6c01b215c3f7e81c7f9a Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:50:33 +0000
Subject: [PATCH 41/76] refactor(engine): move cmd/solver.rs items to
 cmd/solver/

---
 crates/engine/src/cmd/solver.rs              | 1863 +-----------------
 crates/engine/src/cmd/solver/evolutionary.rs |  255 +++
 crates/engine/src/cmd/solver/lp.rs           |  447 +++++
 crates/engine/src/cmd/solver/model.rs        |  459 +++++
 crates/engine/src/cmd/solver/nlp.rs          |  197 ++
 crates/engine/src/cmd/solver/problem.rs      |  144 ++
 crates/engine/src/cmd/solver/reports.rs      |  373 ++++
 7 files changed, 1890 insertions(+), 1848 deletions(-)
 create mode 100644 crates/engine/src/cmd/solver/evolutionary.rs
 create mode 100644 crates/engine/src/cmd/solver/lp.rs
 create mode 100644 crates/engine/src/cmd/solver/model.rs
 create mode 100644 crates/engine/src/cmd/solver/nlp.rs
 create mode 100644 crates/engine/src/cmd/solver/problem.rs
 create mode 100644 crates/engine/src/cmd/solver/reports.rs

diff --git a/crates/engine/src/cmd/solver.rs b/crates/engine/src/cmd/solver.rs
index 191493841..d42b75961 100644
--- a/crates/engine/src/cmd/solver.rs
+++ b/crates/engine/src/cmd/solver.rs
@@ -33,6 +33,21 @@ use super::whatif::Trial;
 use super::{CommandSpec, Ctx, DocState, EngineError, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, str_param};
 use gridcraft_core::split_sheet;
 
+mod evolutionary;
+mod lp;
+mod model;
+mod nlp;
+mod problem;
+mod reports;
+
+use evolutionary::{EvoEnd, evolutionary};
+use lp::{Outcome, Sense, branch_and_bound, linearize, solve_lp};
+pub use model::saved_model;
+use model::{Goal, Method, Model, model_params, parse_model, save_model};
+use nlp::{nlp, project};
+use problem::{Evaluator, as_num, build_problem};
+use reports::{ReportInput, insert_report_selections, prepare_reports, report, report_kinds, write_reports};
+
 const CMD: &str = "data.solver";
 const REPORT_CMD: &str = "data.solverReport";
 /// Excel's limit on decision variables.
@@ -75,1485 +90,6 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-// ---------------------------------------------------------------- model
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum Rel {
-    Le,
-    Eq,
-    Ge,
-    Int,
-    Bin,
-}
-
-impl Rel {
-    fn parse(s: &str) -> Option<Rel> {
-        match s.trim().to_ascii_lowercase().as_str() {
-            "<=" | "≤" | "=<" | "le" => Some(Rel::Le),
-            ">=" | "≥" | "=>" | "ge" => Some(Rel::Ge),
-            "=" | "==" | "eq" => Some(Rel::Eq),
-            "int" | "integer" => Some(Rel::Int),
-            "bin" | "binary" => Some(Rel::Bin),
-            _ => None,
-        }
-    }
-    fn text(self) -> &'static str {
-        match self {
-            Rel::Le => "<=",
-            Rel::Eq => "=",
-            Rel::Ge => ">=",
-            Rel::Int => "int",
-            Rel::Bin => "bin",
-        }
-    }
-    /// The relation code of the saved model (`solver_relN`), as in Solver's VBA `SolverAdd`.
-    fn code(self) -> u8 {
-        match self {
-            Rel::Le => 1,
-            Rel::Eq => 2,
-            Rel::Ge => 3,
-            Rel::Int => 4,
-            Rel::Bin => 5,
-        }
-    }
-    fn from_code(c: &str) -> Option<Rel> {
-        match c.trim() {
-            "1" => Some(Rel::Le),
-            "2" => Some(Rel::Eq),
-            "3" => Some(Rel::Ge),
-            "4" => Some(Rel::Int),
-            "5" => Some(Rel::Bin),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-enum Rhs {
-    None,
-    Const(f64),
-    Cells(Vec<CellRef>),
-}
-
-#[derive(Clone, Debug)]
-struct Constraint {
-    lhs: Vec<CellRef>,
-    lhs_text: String,
-    rel: Rel,
-    rhs: Rhs,
-    rhs_text: String,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum Goal {
-    Max,
-    Min,
-    Value(f64),
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum Method {
-    Simplex,
-    Grg,
-    Evolutionary,
-}
-
-/// The Evolutionary method's options (Solver Options › Evolutionary). The search keeps no
-/// clock, so the time without improvement is counted in generations.
-#[derive(Clone, Copy, Debug, PartialEq)]
-struct EvoOptions {
-    population: usize,
-    mutation: f64,
-    seed: u64,
-    convergence: f64,
-    stall: u64,
-    require_bounds: bool,
-}
-
-impl Default for EvoOptions {
-    fn default() -> EvoOptions {
-        EvoOptions { population: 100, mutation: 0.075, seed: 0, convergence: 1e-4, stall: 50, require_bounds: true }
-    }
-}
-
-fn evo_options(p: &Json) -> EvoOptions {
-    let d = EvoOptions::default();
-    let num = |k: &str| p.get(k).and_then(Json::as_f64).or_else(|| str_param(p, k).and_then(num_text)).filter(|v| v.is_finite());
-    EvoOptions {
-        population: num("populationSize").map_or(d.population, |v| v.clamp(MIN_POPULATION as f64, MAX_POPULATION as f64) as usize),
-        mutation: num("mutationRate").map_or(d.mutation, |v| v.clamp(0.0, 1.0)),
-        seed: num("randomSeed").map_or(d.seed, |v| v.clamp(0.0, f64::from(u32::MAX)) as u64),
-        convergence: num("convergence").map_or(d.convergence, |v| v.clamp(0.0, 1.0)),
-        stall: num("generationsWithoutImprovement").map_or(d.stall, |v| v.clamp(1.0, 100_000.0) as u64),
-        require_bounds: bool_param(p, "requireBounds").unwrap_or(d.require_bounds),
-    }
-}
-
-#[derive(Clone, Debug)]
-struct Model {
-    sheet: usize,
-    objective: CellRef,
-    goal: Goal,
-    vars: Vec<CellRef>,
-    vars_text: String,
-    cons: Vec<Constraint>,
-    non_negative: bool,
-    method: Method,
-    evo: EvoOptions,
-}
-
-/// Cells of `"B2:B4,D1"` on one sheet (row-major per area, in order), at most `cap`.
-fn cells_of(wb: &Workbook, t: &str, default_sheet: usize, cap: usize) -> Result<(usize, Vec<CellRef>)> {
-    let mut sheet = None;
-    let mut out = Vec::new();
-    for part in t.split(',').map(str::trim).filter(|x| !x.is_empty()) {
-        let (sh, body) = split_sheet(part);
-        let si = match sh {
-            Some(n) => wb.sheet_index(&n).ok_or_else(|| bad(CMD, format!("no sheet named `{n}`")))?,
-            None => default_sheet,
-        };
-        if *sheet.get_or_insert(si) != si {
-            return Err(bad(CMD, "all cells of a reference must be on one sheet"));
-        }
-        let r = RangeRef::parse(body.trim()).ok_or_else(|| bad(CMD, format!("not a reference: `{part}`")))?;
-        if r.count() > cap as u64 || out.len() + r.count() as usize > cap {
-            return Err(bad(CMD, format!("too many cells (at most {cap})")));
-        }
-        out.extend(r.iter());
-    }
-    if out.is_empty() {
-        return Err(bad(CMD, format!("not a reference: `{t}`")));
-    }
-    Ok((sheet.unwrap_or(default_sheet), out))
-}
-
-fn num_text(t: &str) -> Option<f64> {
-    gridcraft_core::parse::parse_number_text(t.trim()).filter(|v| v.is_finite())
-}
-
-/// Splits `"B5 <= 10"` / `"B2 int"` into (lhs, relation, rhs).
-fn split_constraint(t: &str) -> Option<(String, Rel, String)> {
-    for op in ["<=", ">=", "=<", "=>", "≤", "≥", "=="] {
-        if let Some((a, b)) = t.split_once(op) {
-            return Some((a.trim().into(), Rel::parse(op)?, b.trim().into()));
-        }
-    }
-    if let Some((a, b)) = t.split_once('=') {
-        return Some((a.trim().into(), Rel::Eq, b.trim().into()));
-    }
-    let lower = t.trim().to_ascii_lowercase();
-    for (suffix, rel) in [("integer", Rel::Int), ("binary", Rel::Bin), ("int", Rel::Int), ("bin", Rel::Bin)] {
-        if let Some(a) = lower.strip_suffix(suffix) {
-            let a = a.trim();
-            return Some((t.trim().get(..a.len())?.trim().to_string(), rel, String::new()));
-        }
-    }
-    None
-}
-
-fn parse_constraint(wb: &Workbook, sheet: usize, c: &Json) -> Result<Constraint> {
-    let (lhs_text, rel, rhs_json) = match c {
-        Json::String(t) => {
-            let (l, r, rhs) = split_constraint(t).ok_or_else(|| bad(CMD, format!("not a constraint: `{t}`")))?;
-            (l, r, Json::String(rhs))
-        }
-        Json::Object(_) => {
-            let lhs = str_param(c, "lhs").or_else(|| str_param(c, "cell")).or_else(|| str_param(c, "range")).unwrap_or("").to_string();
-            let op = str_param(c, "op").or_else(|| str_param(c, "relation")).unwrap_or("");
-            let rel = Rel::parse(op).ok_or_else(|| bad(CMD, format!("unknown constraint relation `{op}`")))?;
-            (lhs, rel, c.get("rhs").or_else(|| c.get("value")).cloned().unwrap_or(Json::Null))
-        }
-        _ => return Err(bad(CMD, "a constraint is a string like \"B5 <= 10\" or {lhs, op, rhs}")),
-    };
-    let (lsi, lhs) = cells_of(wb, &lhs_text, sheet, MAX_CONSTRAINTS)?;
-    if lsi != sheet {
-        return Err(EngineError::Other("Constraint cells must be on the objective cell's sheet.".into()));
-    }
-    let (rhs, rhs_text) = match rel {
-        Rel::Int | Rel::Bin => (Rhs::None, String::new()),
-        _ => match &rhs_json {
-            Json::Number(n) => {
-                let v = n.as_f64().filter(|v| v.is_finite()).ok_or_else(|| bad(CMD, "the constraint's right side must be a number"))?;
-                (Rhs::Const(v), v.to_string())
-            }
-            Json::String(t) => {
-                let t = t.trim().trim_start_matches('=').trim();
-                if let Some(v) = num_text(t) {
-                    (Rhs::Const(v), t.to_string())
-                } else {
-                    let (rsi, cells) = cells_of(wb, t, sheet, MAX_CONSTRAINTS)?;
-                    if rsi != sheet {
-                        return Err(EngineError::Other("Constraint cells must be on the objective cell's sheet.".into()));
-                    }
-                    if cells.len() != 1 && cells.len() != lhs.len() {
-                        return Err(EngineError::Other("The constraint's two sides must be the same size (or the right side one cell).".into()));
-                    }
-                    (Rhs::Cells(cells), t.to_string())
-                }
-            }
-            _ => return Err(bad(CMD, "missing the constraint's right side")),
-        },
-    };
-    Ok(Constraint { lhs, lhs_text, rel, rhs, rhs_text })
-}
-
-fn parse_model(s: &Session, p: &Json) -> Result<Model> {
-    let d = s.doc()?;
-    let wb = &d.wb;
-    let obj_text = str_param(p, "objective").or_else(|| str_param(p, "setObjective")).or_else(|| str_param(p, "set")).unwrap_or("");
-    let (sheet, obj) = cells_of(wb, obj_text, wb.active_sheet(), 1).map_err(|_| EngineError::Other("The objective must be a single cell.".into()))?;
-    let objective = *obj.first().ok_or_else(|| EngineError::Other("The objective must be a single cell.".into()))?;
-    let sh = wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    if sh.cell(objective).is_none_or(|c| c.formula.is_none()) {
-        return Err(EngineError::Other("The objective cell must contain a formula.".into()));
-    }
-    let goal = match str_param(p, "goal").or_else(|| str_param(p, "to")).unwrap_or("max").to_ascii_lowercase().as_str() {
-        "max" | "maximize" | "maximum" => Goal::Max,
-        "min" | "minimize" | "minimum" => Goal::Min,
-        "value" | "valueof" | "value of" => {
-            let v = f64_param(p, "value")
-                .or_else(|| str_param(p, "value").and_then(num_text))
-                .filter(|v| v.is_finite())
-                .ok_or_else(|| bad(CMD, "goal `value` needs a number in `value`"))?;
-            Goal::Value(v)
-        }
-        g => return Err(bad(CMD, format!("unknown goal `{g}` (max, min or value)"))),
-    };
-    let vars_text = str_param(p, "variables").or_else(|| str_param(p, "changing")).or_else(|| str_param(p, "byChanging")).unwrap_or("").to_string();
-    let (vsi, mut vars) = cells_of(wb, &vars_text, sheet, MAX_VARS).map_err(|e| match e {
-        EngineError::BadParams { msg, .. } if msg.starts_with("too many") => {
-            EngineError::Other(format!("Too many variable cells (at most {MAX_VARS})."))
-        }
-        _ => EngineError::Other("The variable cells must be a reference like B2:B4.".into()),
-    })?;
-    if vsi != sheet {
-        return Err(EngineError::Other("The variable cells must be on the objective cell's sheet.".into()));
-    }
-    let mut seen = std::collections::HashSet::new();
-    vars.retain(|c| seen.insert(*c));
-    if vars.iter().any(|c| sh.cell(*c).is_some_and(|c| c.formula.is_some())) {
-        return Err(EngineError::Other("Variable cells must hold constants, not formulas.".into()));
-    }
-    let mut cons = Vec::new();
-    let mut scalar = 0usize;
-    if let Some(list) = p.get("constraints") {
-        let list = list.as_array().ok_or_else(|| bad(CMD, "`constraints` must be an array"))?;
-        if list.len() > MAX_CONSTRAINTS {
-            return Err(EngineError::Other(format!("Too many constraints (at most {MAX_CONSTRAINTS}).")));
-        }
-        for c in list {
-            let c = parse_constraint(wb, sheet, c)?;
-            scalar = scalar.saturating_add(c.lhs.len());
-            if scalar > MAX_CONSTRAINTS {
-                return Err(EngineError::Other(format!("Too many constraints (at most {MAX_CONSTRAINTS} cells).")));
-            }
-            if matches!(c.rel, Rel::Int | Rel::Bin) && c.lhs.iter().any(|x| !vars.contains(x)) {
-                return Err(EngineError::Other("Integer and binary constraints must be on variable cells.".into()));
-            }
-            cons.push(c);
-        }
-    }
-    let non_negative = bool_param(p, "nonNegative").unwrap_or(true);
-    let method = match str_param(p, "method").unwrap_or("grg").to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
-        "grg" | "grgnonlinear" | "nonlinear" => Method::Grg,
-        "simplex" | "simplexlp" | "lp" | "linear" => Method::Simplex,
-        "evolutionary" | "evo" | "genetic" => Method::Evolutionary,
-        m => return Err(bad(CMD, format!("unknown method `{m}` (grg, simplex or evolutionary)"))),
-    };
-    Ok(Model { sheet, objective, goal, vars, vars_text, cons, non_negative, method, evo: evo_options(p) })
-}
-
-// ---------------------------------------------------------------- saved model
-
-fn ref_text(sheet_name: &str, cells: &str) -> String {
-    let q = crate::pivot::quote_sheet(sheet_name);
-    cells
-        .split(',')
-        .map(str::trim)
-        .filter(|x| !x.is_empty())
-        .filter_map(|part| {
-            let r = RangeRef::parse(split_sheet(part).1.trim())?;
-            let abs = |c: CellRef| format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row as u64 + 1);
-            Some(if r.is_single() { format!("{q}!{}", abs(r.start)) } else { format!("{q}!{}:{}", abs(r.start), abs(r.end)) })
-        })
-        .collect::<Vec<_>>()
-        .join(",")
-}
-
-/// The model as hidden names scoped to its sheet (replacing any saved before).
-fn save_model(wb: &mut Workbook, m: &Model) {
-    let Some(sheet_name) = wb.sheet(m.sheet).map(|s| s.name.clone()) else { return };
-    wb.names.retain(|n| !(n.scope == Some(m.sheet) && n.name.to_ascii_lowercase().starts_with("solver_")));
-    let mut put = |name: String, formula: String| {
-        wb.names.push(DefinedName { name, scope: Some(m.sheet), formula, comment: String::new(), hidden: true });
-    };
-    put("solver_opt".into(), ref_text(&sheet_name, &m.objective.a1()));
-    let (typ, val) = match m.goal {
-        Goal::Max => (1, 0.0),
-        Goal::Min => (2, 0.0),
-        Goal::Value(v) => (3, v),
-    };
-    put("solver_typ".into(), typ.to_string());
-    put("solver_val".into(), val.to_string());
-    put("solver_adj".into(), ref_text(&sheet_name, &m.vars_text));
-    for (i, c) in m.cons.iter().enumerate() {
-        let k = i + 1;
-        put(format!("solver_lhs{k}"), ref_text(&sheet_name, &c.lhs_text));
-        put(format!("solver_rel{k}"), c.rel.code().to_string());
-        let rhs = match &c.rhs {
-            Rhs::None => {
-                if c.rel == Rel::Bin {
-                    "\"binary\"".to_string()
-                } else {
-                    "\"integer\"".to_string()
-                }
-            }
-            Rhs::Const(v) => v.to_string(),
-            Rhs::Cells(_) => ref_text(&sheet_name, &c.rhs_text),
-        };
-        put(format!("solver_rhs{k}"), rhs);
-    }
-    put("solver_num".into(), m.cons.len().to_string());
-    put("solver_neg".into(), if m.non_negative { "1" } else { "2" }.into());
-    let eng = match m.method {
-        Method::Grg => "1",
-        Method::Simplex => "2",
-        Method::Evolutionary => "3",
-    };
-    put("solver_eng".into(), eng.into());
-    if m.method == Method::Evolutionary {
-        put("solver_ssz".into(), m.evo.population.to_string());
-        put("solver_mrt".into(), m.evo.mutation.to_string());
-        put("solver_rsd".into(), m.evo.seed.to_string());
-        put("solver_rbv".into(), if m.evo.require_bounds { "1" } else { "2" }.into());
-    }
-    put("solver_ver".into(), "3".into());
-}
-
-/// The saved model of a sheet as `data.solver` params, if any.
-pub fn saved_model(wb: &Workbook, sheet: usize) -> Option<Json> {
-    let get = |n: &str| {
-        wb.names
-            .iter()
-            .find(|d| d.name.eq_ignore_ascii_case(n) && (d.scope == Some(sheet) || d.scope.is_none()))
-            .map(|d| d.formula.trim().trim_start_matches('=').to_string())
-    };
-    let local = |t: String| -> String { t.split(',').map(|p| split_sheet(p.trim()).1.replace('$', "")).collect::<Vec<_>>().join(",") };
-    let objective = local(get("solver_opt")?);
-    if objective.is_empty() {
-        return None;
-    }
-    let goal = match get("solver_typ").as_deref().map(str::trim) {
-        Some("2") => "min",
-        Some("3") => "value",
-        _ => "max",
-    };
-    let value = get("solver_val").and_then(|v| num_text(&v)).unwrap_or(0.0);
-    let count = get("solver_num").and_then(|v| num_text(&v)).unwrap_or(0.0).clamp(0.0, MAX_CONSTRAINTS as f64) as usize;
-    let mut constraints = Vec::new();
-    for k in 1..=count {
-        let (Some(lhs), Some(rel)) = (get(&format!("solver_lhs{k}")), get(&format!("solver_rel{k}")).and_then(|r| Rel::from_code(&r))) else {
-            continue;
-        };
-        let lhs = local(lhs);
-        constraints.push(match rel {
-            Rel::Int | Rel::Bin => json!(format!("{lhs} {}", rel.text())),
-            _ => {
-                let rhs = get(&format!("solver_rhs{k}")).unwrap_or_default();
-                let rhs = if num_text(&rhs).is_some() { rhs } else { local(rhs) };
-                json!(format!("{lhs} {} {rhs}", rel.text()))
-            }
-        });
-    }
-    let method = match get("solver_eng").as_deref().map(str::trim) {
-        Some("2") => "simplex",
-        Some("3") => "evolutionary",
-        _ => "grg",
-    };
-    let mut model = json!({
-        "objective": objective,
-        "goal": goal,
-        "value": value,
-        "variables": get("solver_adj").map(local).unwrap_or_default(),
-        "constraints": constraints,
-        "nonNegative": get("solver_neg").as_deref().map(str::trim) != Some("2"),
-        "method": method,
-    });
-    for (name, key) in [("solver_ssz", "populationSize"), ("solver_mrt", "mutationRate"), ("solver_rsd", "randomSeed")] {
-        if let Some(v) = get(name).and_then(|v| num_text(&v)) {
-            model[key] = json!(v);
-        }
-    }
-    if let Some(v) = get("solver_rbv") {
-        model["requireBounds"] = json!(v.trim() != "2");
-    }
-    Some(model)
-}
-
-/// The model as `data.solver` params, in the form [`saved_model`] returns (the objective
-/// qualified by its sheet).
-fn model_params(wb: &Workbook, m: &Model) -> Json {
-    let sheet = wb.sheet(m.sheet).map(|s| crate::pivot::quote_sheet(&s.name)).unwrap_or_default();
-    let (goal, value) = match m.goal {
-        Goal::Max => ("max", 0.0),
-        Goal::Min => ("min", 0.0),
-        Goal::Value(v) => ("value", v),
-    };
-    let constraints: Vec<Json> = m
-        .cons
-        .iter()
-        .map(|c| match c.rel {
-            Rel::Int | Rel::Bin => json!(format!("{} {}", c.lhs_text, c.rel.text())),
-            _ => json!(format!("{} {} {}", c.lhs_text, c.rel.text(), c.rhs_text)),
-        })
-        .collect();
-    let method = match m.method {
-        Method::Simplex => "simplex",
-        Method::Grg => "grg",
-        Method::Evolutionary => "evolutionary",
-    };
-    let mut out = json!({
-        "objective": format!("{sheet}!{}", m.objective.a1()),
-        "goal": goal,
-        "value": value,
-        "variables": m.vars_text,
-        "constraints": constraints,
-        "nonNegative": m.non_negative,
-        "method": method,
-    });
-    if m.method == Method::Evolutionary {
-        let e = &m.evo;
-        out["populationSize"] = json!(e.population);
-        out["mutationRate"] = json!(e.mutation);
-        out["randomSeed"] = json!(e.seed);
-        out["convergence"] = json!(e.convergence);
-        out["generationsWithoutImprovement"] = json!(e.stall);
-        out["requireBounds"] = json!(e.require_bounds);
-    }
-    out
-}
-
-// ---------------------------------------------------------------- evaluation
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum Sense {
-    Le,
-    Ge,
-    Eq,
-}
-
-/// A scalar constraint `lhs (sense) rhs`.
-#[derive(Clone, Debug)]
-struct Row {
-    lhs: CellRef,
-    sense: Sense,
-    rhs: Option<CellRef>,
-    rhs_const: f64,
-}
-
-/// The values the solvers see at a point: the objective and `lhs − rhs` per row.
-#[derive(Clone, Debug)]
-struct Point {
-    f: f64,
-    g: Vec<f64>,
-}
-
-struct Evaluator {
-    trial: Trial,
-    sheet: usize,
-    vars: Vec<CellRef>,
-    objective: CellRef,
-    rows: Vec<Row>,
-    evals: u64,
-    budget: u64,
-    /// The Limits report: the objective is this variable itself.
-    target: Option<usize>,
-}
-
-fn as_num(v: &Value) -> f64 {
-    match v {
-        Value::Number(n) => *n,
-        Value::Empty => 0.0,
-        Value::Bool(b) => f64::from(u8::from(*b)),
-        _ => f64::NAN,
-    }
-}
-
-impl Evaluator {
-    fn exhausted(&self) -> bool {
-        self.evals >= self.budget
-    }
-
-    /// Evaluates the model at `x`; `None` once the budget is spent.
-    fn eval(&mut self, x: &[f64]) -> Option<Point> {
-        if self.exhausted() {
-            return None;
-        }
-        self.evals += 1;
-        let sets: Vec<(usize, CellRef, Value)> = self.vars.iter().zip(x).map(|(c, v)| (self.sheet, *c, Value::number(*v))).collect();
-        let mut reads = Vec::with_capacity(1 + 2 * self.rows.len());
-        reads.push((self.sheet, self.objective));
-        for r in &self.rows {
-            reads.push((self.sheet, r.lhs));
-            if let Some(c) = r.rhs {
-                reads.push((self.sheet, c));
-            }
-        }
-        let vals = self.trial.run(&sets, &reads);
-        let mut it = vals.iter().map(as_num);
-        let f = it.next().unwrap_or(f64::NAN);
-        let f = match self.target {
-            Some(j) => x.get(j).copied().unwrap_or(f64::NAN),
-            None => f,
-        };
-        let mut g = Vec::with_capacity(self.rows.len());
-        for r in &self.rows {
-            let l = it.next().unwrap_or(f64::NAN);
-            let rv = if r.rhs.is_some() { it.next().unwrap_or(f64::NAN) } else { r.rhs_const };
-            g.push(l - rv);
-        }
-        Some(Point { f, g })
-    }
-}
-
-// ---------------------------------------------------------------- problem
-
-struct Problem {
-    lo: Vec<f64>,
-    hi: Vec<f64>,
-    integer: Vec<bool>,
-    rows: Vec<Row>,
-}
-
-/// Splits the constraints into variable bounds and general rows.
-fn build_problem(m: &Model) -> Problem {
-    let n = m.vars.len();
-    let mut lo = vec![f64::NEG_INFINITY; n];
-    let mut hi = vec![f64::INFINITY; n];
-    let mut has_lower = vec![false; n];
-    let mut integer = vec![false; n];
-    let mut rows = Vec::new();
-    let var_index = |c: &CellRef| m.vars.iter().position(|v| v == c);
-    for c in &m.cons {
-        for (k, cell) in c.lhs.iter().enumerate() {
-            let j = var_index(cell);
-            match c.rel {
-                Rel::Int | Rel::Bin => {
-                    if let Some(j) = j {
-                        if let Some(b) = integer.get_mut(j) {
-                            *b = true;
-                        }
-                        if c.rel == Rel::Bin
-                            && let (Some(l), Some(h), Some(hl)) = (lo.get_mut(j), hi.get_mut(j), has_lower.get_mut(j))
-                        {
-                            *l = l.max(0.0);
-                            *h = h.min(1.0);
-                            *hl = true;
-                        }
-                    }
-                }
-                rel => {
-                    let sense = match rel {
-                        Rel::Le => Sense::Le,
-                        Rel::Ge => Sense::Ge,
-                        _ => Sense::Eq,
-                    };
-                    let (rhs, rhs_const) = match &c.rhs {
-                        Rhs::Const(v) => (None, *v),
-                        Rhs::Cells(cells) => (cells.get(k).or_else(|| cells.first()).copied(), 0.0),
-                        Rhs::None => (None, 0.0),
-                    };
-                    match (j, rhs) {
-                        // A constant bound on a variable cell is a box bound.
-                        (Some(j), None) => {
-                            if let (Some(l), Some(h), Some(hl)) = (lo.get_mut(j), hi.get_mut(j), has_lower.get_mut(j)) {
-                                if sense != Sense::Ge {
-                                    *h = h.min(rhs_const);
-                                }
-                                if sense != Sense::Le {
-                                    *l = l.max(rhs_const);
-                                    *hl = true;
-                                }
-                            }
-                        }
-                        _ => rows.push(Row { lhs: *cell, sense, rhs, rhs_const }),
-                    }
-                }
-            }
-        }
-    }
-    if m.non_negative {
-        for (l, hl) in lo.iter_mut().zip(&has_lower) {
-            if !hl {
-                *l = l.max(0.0);
-            }
-        }
-    }
-    Problem { lo, hi, integer, rows }
-}
-
-/// What a relaxation (or the whole solve) ended with.
-#[derive(Clone, Debug)]
-enum Outcome {
-    /// x, objective to minimise, and whether the solver converged (vs. ran out of budget).
-    Solved(Vec<f64>, f64, bool),
-    Infeasible,
-    Unbounded,
-    Limit,
-}
-
-/// Depth-first branch and bound over a relaxation solver; returns the best integer point.
-fn branch_and_bound(
-    lo: &[f64],
-    hi: &[f64],
-    integer: &[bool],
-    max_nodes: usize,
-    gap: f64,
-    relax: &mut dyn FnMut(&[f64], &[f64]) -> Outcome,
-) -> (Outcome, usize) {
-    let mut stack: Vec<(Vec<f64>, Vec<f64>)> = vec![(lo.to_vec(), hi.to_vec())];
-    let mut best: Option<(Vec<f64>, f64)> = None;
-    let mut nodes = 0usize;
-    let mut limited = false;
-    let mut root = true;
-    while let Some((l, h)) = stack.pop() {
-        if nodes >= max_nodes {
-            limited = true;
-            break;
-        }
-        nodes += 1;
-        let out = relax(&l, &h);
-        let was_root = std::mem::replace(&mut root, false);
-        let (x, obj, converged) = match out {
-            Outcome::Solved(x, obj, c) => (x, obj, c),
-            Outcome::Unbounded if was_root => return (Outcome::Unbounded, nodes),
-            Outcome::Limit => {
-                limited = true;
-                break;
-            }
-            _ => continue,
-        };
-        if !converged {
-            limited = true;
-        }
-        if let Some((_, b)) = &best
-            && obj >= b - gap * b.abs().max(1e-12) - 1e-9 * (1.0 + b.abs())
-        {
-            continue;
-        }
-        // The most fractional integer variable.
-        let frac = x
-            .iter()
-            .zip(integer)
-            .enumerate()
-            .filter(|(_, (_, int))| **int)
-            .map(|(j, (v, _))| (j, (v - v.round()).abs()))
-            .filter(|(_, f)| *f > 1e-6)
-            .max_by(|a, b| a.1.total_cmp(&b.1));
-        match frac {
-            None => {
-                let snapped: Vec<f64> = x.iter().zip(integer).map(|(v, int)| if *int { v.round() } else { *v }).collect();
-                best = Some((snapped, obj));
-            }
-            Some((j, _)) => {
-                let v = x.get(j).copied().unwrap_or(0.0);
-                let (mut down_h, mut up_l) = (h.clone(), l.clone());
-                if let Some(e) = down_h.get_mut(j) {
-                    *e = e.min(v.floor());
-                }
-                if let Some(e) = up_l.get_mut(j) {
-                    *e = e.max(v.ceil());
-                }
-                // Explore the nearer side first (pushed last).
-                if v - v.floor() < 0.5 {
-                    stack.push((up_l, h));
-                    stack.push((l, down_h));
-                } else {
-                    stack.push((l, down_h));
-                    stack.push((up_l, h));
-                }
-            }
-        }
-    }
-    match best {
-        Some((x, obj)) => (Outcome::Solved(x, obj, !limited), nodes),
-        None if limited => (Outcome::Limit, nodes),
-        None => (Outcome::Infeasible, nodes),
-    }
-}
-
-// ---------------------------------------------------------------- simplex
-
-/// Pivots the tableau on (r, j), updating the objective row.
-fn pivot(t: &mut [Vec<f64>], obj: &mut [f64], r: usize, j: usize) {
-    let Some(prow) = t.get_mut(r) else { return };
-    let pv = prow.get(j).copied().unwrap_or(0.0);
-    if pv == 0.0 {
-        return;
-    }
-    for v in prow.iter_mut() {
-        *v /= pv;
-    }
-    let prow = prow.clone();
-    for (i, row) in t.iter_mut().enumerate() {
-        if i == r {
-            continue;
-        }
-        let f = row.get(j).copied().unwrap_or(0.0);
-        if f != 0.0 {
-            for (v, p) in row.iter_mut().zip(&prow) {
-                *v -= f * p;
-            }
-        }
-    }
-    let f = obj.get(j).copied().unwrap_or(0.0);
-    if f != 0.0 {
-        for (v, p) in obj.iter_mut().zip(&prow) {
-            *v -= f * p;
-        }
-    }
-}
-
-enum Step {
-    Optimal,
-    Unbounded,
-    Limit,
-}
-
-/// Minimises with the reduced costs in `obj` (last entry: −objective). Columns not `allowed`
-/// never enter.
-fn simplex(t: &mut [Vec<f64>], basis: &mut [usize], obj: &mut [f64], allowed: &[bool], budget: &mut u64) -> Step {
-    let n = obj.len().saturating_sub(1);
-    let cost = (t.len() as u64 + 1).saturating_mul(n as u64 + 1).max(1);
-    let mut stalled = 0u32;
-    loop {
-        if *budget < cost {
-            return Step::Limit;
-        }
-        *budget -= cost;
-        let bland = stalled > 50;
-        let mut enter = None;
-        let mut best = -EPS;
-        for (j, d) in obj.iter().take(n).enumerate() {
-            if !allowed.get(j).copied().unwrap_or(false) || *d >= -EPS {
-                continue;
-            }
-            if bland {
-                enter = Some(j);
-                break;
-            }
-            if *d < best {
-                best = *d;
-                enter = Some(j);
-            }
-        }
-        let Some(j) = enter else { return Step::Optimal };
-        let mut leave: Option<(usize, f64)> = None;
-        for (i, row) in t.iter().enumerate() {
-            let a = row.get(j).copied().unwrap_or(0.0);
-            if a <= EPS {
-                continue;
-            }
-            let ratio = row.get(n).copied().unwrap_or(0.0) / a;
-            let better = match leave {
-                None => true,
-                Some((li, lr)) => ratio < lr - 1e-12 || (ratio <= lr + 1e-12 && basis.get(i) < basis.get(li)),
-            };
-            if better {
-                leave = Some((i, ratio));
-            }
-        }
-        let Some((r, ratio)) = leave else { return Step::Unbounded };
-        stalled = if ratio <= EPS { stalled + 1 } else { 0 };
-        pivot(t, obj, r, j);
-        if let Some(b) = basis.get_mut(r) {
-            *b = j;
-        }
-    }
-}
-
-/// Minimises `c·x` subject to `rows` (coefficients, sense, rhs) and `lo ≤ x ≤ hi`.
-fn solve_lp(c: &[f64], rows: &[(Vec<f64>, Sense, f64)], lo: &[f64], hi: &[f64], budget: &mut u64) -> Outcome {
-    let n = c.len();
-    if lo.iter().zip(hi).any(|(l, h)| l > h) {
-        return Outcome::Infeasible;
-    }
-    // x_j = offset + Σ sign·y_k with y ≥ 0.
-    struct Map {
-        var: usize,
-        sign: f64,
-    }
-    let mut cols: Vec<Map> = Vec::new();
-    let mut offset = vec![0.0; n];
-    let mut extra: Vec<(Vec<(usize, f64)>, Sense, f64)> = Vec::new();
-    for j in 0..n {
-        let (l, h) = (lo.get(j).copied().unwrap_or(f64::NEG_INFINITY), hi.get(j).copied().unwrap_or(f64::INFINITY));
-        if l.is_finite() {
-            if let Some(o) = offset.get_mut(j) {
-                *o = l;
-            }
-            cols.push(Map { var: j, sign: 1.0 });
-            if h.is_finite() {
-                extra.push((vec![(cols.len() - 1, 1.0)], Sense::Le, h - l));
-            }
-        } else if h.is_finite() {
-            if let Some(o) = offset.get_mut(j) {
-                *o = h;
-            }
-            cols.push(Map { var: j, sign: -1.0 });
-        } else {
-            cols.push(Map { var: j, sign: 1.0 });
-            cols.push(Map { var: j, sign: -1.0 });
-        }
-    }
-    let ny = cols.len();
-    // Rows over y: (coefficients, sense, rhs).
-    let mut yrows: Vec<(Vec<f64>, Sense, f64)> = Vec::with_capacity(rows.len() + extra.len());
-    for (a, sense, b) in rows {
-        let mut coef = vec![0.0; ny];
-        for (k, m) in cols.iter().enumerate() {
-            if let Some(v) = coef.get_mut(k) {
-                *v = a.get(m.var).copied().unwrap_or(0.0) * m.sign;
-            }
-        }
-        let shift: f64 = a.iter().zip(&offset).map(|(x, o)| x * o).sum();
-        yrows.push((coef, *sense, b - shift));
-    }
-    for (entries, sense, b) in extra {
-        let mut coef = vec![0.0; ny];
-        for (k, v) in entries {
-            if let Some(e) = coef.get_mut(k) {
-                *e = v;
-            }
-        }
-        yrows.push((coef, sense, b));
-    }
-    let m = yrows.len();
-    let n_slack = yrows.iter().filter(|r| r.1 != Sense::Eq).count();
-    // Rows with b < 0 are negated so every right side is ≥ 0.
-    let normalized: Vec<(Vec<f64>, Sense, f64)> = yrows
-        .into_iter()
-        .map(|(a, s, b)| {
-            if b < 0.0 {
-                let s = match s {
-                    Sense::Le => Sense::Ge,
-                    Sense::Ge => Sense::Le,
-                    Sense::Eq => Sense::Eq,
-                };
-                (a.iter().map(|v| -v).collect(), s, -b)
-            } else {
-                (a, s, b)
-            }
-        })
-        .collect();
-    let n_art = normalized.iter().filter(|r| r.1 != Sense::Le).count();
-    let width = ny + n_slack + n_art;
-    let mut t: Vec<Vec<f64>> = Vec::with_capacity(m);
-    let mut basis = vec![0usize; m];
-    let (mut si, mut ai) = (ny, ny + n_slack);
-    for (i, (a, s, b)) in normalized.iter().enumerate() {
-        let mut row = vec![0.0; width + 1];
-        for (v, x) in row.iter_mut().zip(a) {
-            *v = *x;
-        }
-        match s {
-            Sense::Le => {
-                if let Some(v) = row.get_mut(si) {
-                    *v = 1.0;
-                }
-                if let Some(bi) = basis.get_mut(i) {
-                    *bi = si;
-                }
-                si += 1;
-            }
-            Sense::Ge => {
-                if let Some(v) = row.get_mut(si) {
-                    *v = -1.0;
-                }
-                si += 1;
-                if let Some(v) = row.get_mut(ai) {
-                    *v = 1.0;
-                }
-                if let Some(bi) = basis.get_mut(i) {
-                    *bi = ai;
-                }
-                ai += 1;
-            }
-            Sense::Eq => {
-                if let Some(v) = row.get_mut(ai) {
-                    *v = 1.0;
-                }
-                if let Some(bi) = basis.get_mut(i) {
-                    *bi = ai;
-                }
-                ai += 1;
-            }
-        }
-        if let Some(v) = row.get_mut(width) {
-            *v = *b;
-        }
-        t.push(row);
-    }
-    let is_art = |j: usize| j >= ny + n_slack && j < width;
-    // Phase 1: minimise the sum of the artificials.
-    let mut obj = vec![0.0; width + 1];
-    for j in (ny + n_slack)..width {
-        if let Some(v) = obj.get_mut(j) {
-            *v = 1.0;
-        }
-    }
-    for (i, row) in t.iter().enumerate() {
-        if basis.get(i).is_some_and(|b| is_art(*b)) {
-            for (v, x) in obj.iter_mut().zip(row) {
-                *v -= x;
-            }
-        }
-    }
-    let all: Vec<bool> = vec![true; width];
-    if n_art > 0 {
-        match simplex(&mut t, &mut basis, &mut obj, &all, budget) {
-            Step::Limit => return Outcome::Limit,
-            Step::Unbounded | Step::Optimal => {}
-        }
-        let scale = normalized.iter().map(|r| r.2.abs()).fold(1.0f64, f64::max);
-        if -obj.get(width).copied().unwrap_or(0.0) > 1e-7 * scale {
-            return Outcome::Infeasible;
-        }
-        // Drive zero-valued artificials out of the basis where possible.
-        for i in 0..m {
-            if !basis.get(i).is_some_and(|b| is_art(*b)) {
-                continue;
-            }
-            let j = t.get(i).and_then(|row| (0..ny + n_slack).find(|&j| row.get(j).is_some_and(|v| v.abs() > EPS)));
-            if let Some(j) = j {
-                pivot(&mut t, &mut obj, i, j);
-                if let Some(b) = basis.get_mut(i) {
-                    *b = j;
-                }
-            }
-        }
-    }
-    // Phase 2: the real costs; artificials may not re-enter.
-    let mut cost = vec![0.0; width + 1];
-    for (k, mp) in cols.iter().enumerate() {
-        if let Some(v) = cost.get_mut(k) {
-            *v = c.get(mp.var).copied().unwrap_or(0.0) * mp.sign;
-        }
-    }
-    let mut obj = cost.clone();
-    for (i, row) in t.iter().enumerate() {
-        let cb = basis.get(i).and_then(|b| cost.get(*b)).copied().unwrap_or(0.0);
-        if cb != 0.0 {
-            for (v, x) in obj.iter_mut().zip(row) {
-                *v -= cb * x;
-            }
-        }
-    }
-    let allowed: Vec<bool> = (0..width).map(|j| !is_art(j)).collect();
-    match simplex(&mut t, &mut basis, &mut obj, &allowed, budget) {
-        Step::Limit => return Outcome::Limit,
-        Step::Unbounded => return Outcome::Unbounded,
-        Step::Optimal => {}
-    }
-    let mut y = vec![0.0; width];
-    for (i, row) in t.iter().enumerate() {
-        if let (Some(b), Some(v)) = (basis.get(i), row.get(width))
-            && let Some(e) = y.get_mut(*b)
-        {
-            *e = *v;
-        }
-    }
-    let mut x = offset;
-    for (k, mp) in cols.iter().enumerate() {
-        if let Some(e) = x.get_mut(mp.var) {
-            *e += mp.sign * y.get(k).copied().unwrap_or(0.0);
-        }
-    }
-    let val: f64 = c.iter().zip(&x).map(|(a, b)| a * b).sum();
-    Outcome::Solved(x, val, true)
-}
-
-/// Linearises the model at `x0` (n + 1 evaluations) and checks it at one more point. Returns the
-/// objective gradient and constant, and per row the gradient and constant of `lhs − rhs`.
-#[allow(clippy::type_complexity)]
-fn linearize(ev: &mut Evaluator, x0: &[f64]) -> std::result::Result<((Vec<f64>, f64), Vec<(Vec<f64>, f64)>), &'static str> {
-    let n = x0.len();
-    let p0 = ev.eval(x0).ok_or("budget")?;
-    if !p0.f.is_finite() || p0.g.iter().any(|v| !v.is_finite()) {
-        return Err("error");
-    }
-    let mut cf = vec![0.0; n];
-    let mut ga = vec![vec![0.0; n]; p0.g.len()];
-    for j in 0..n {
-        let mut x = x0.to_vec();
-        if let Some(v) = x.get_mut(j) {
-            *v += 1.0;
-        }
-        let p = ev.eval(&x).ok_or("budget")?;
-        if let Some(v) = cf.get_mut(j) {
-            *v = p.f - p0.f;
-        }
-        for (row, (gi, g0)) in ga.iter_mut().zip(p.g.iter().zip(&p0.g)) {
-            if let Some(v) = row.get_mut(j) {
-                *v = gi - g0;
-            }
-        }
-    }
-    let dot = |a: &[f64], x: &[f64]| a.iter().zip(x).map(|(p, q)| p * q).sum::<f64>();
-    let f_const = p0.f - dot(&cf, x0);
-    let rows: Vec<(Vec<f64>, f64)> = ga.into_iter().zip(&p0.g).map(|(a, g0)| (a.clone(), g0 - dot(&a, x0))).collect();
-    // Linearity check at a spread-out point.
-    let xt: Vec<f64> =
-        x0.iter().enumerate().map(|(j, v)| v + if j % 2 == 0 { 1.7 + 0.3 * (j % 5) as f64 } else { -0.6 - 0.2 * (j % 3) as f64 }).collect();
-    let pt = ev.eval(&xt).ok_or("budget")?;
-    let close = |actual: f64, pred: f64, terms: f64| actual.is_finite() && (actual - pred).abs() <= 1e-6 * (1.0 + actual.abs() + terms);
-    let terms = |a: &[f64]| a.iter().zip(&xt).map(|(p, q)| (p * q).abs()).sum::<f64>();
-    if !close(pt.f, f_const + dot(&cf, &xt), terms(&cf)) {
-        return Err("nonlinear");
-    }
-    for ((a, k), g) in rows.iter().zip(&pt.g) {
-        if !close(*g, k + dot(a, &xt), terms(a)) {
-            return Err("nonlinear");
-        }
-    }
-    Ok(((cf, f_const), rows))
-}
-
-// ---------------------------------------------------------------- nonlinear
-
-/// Augmented-Lagrangian value of a point: objective `phi` plus the constraint terms.
-fn aug(phi: f64, cons: &[f64], senses: &[Sense], lam: &[f64], mu: f64) -> f64 {
-    let mut v = phi;
-    for ((c, s), l) in cons.iter().zip(senses).zip(lam) {
-        v += match s {
-            Sense::Eq => l * c + 0.5 * mu * c * c,
-            _ => {
-                let t = (l + mu * c).max(0.0);
-                (t * t - l * l) / (2.0 * mu)
-            }
-        };
-    }
-    v
-}
-
-/// Constraint values in the `≤ 0` / `= 0` form, and the objective to minimise.
-fn shape(p: &Point, rows: &[Row], goal: Goal) -> (f64, Vec<f64>) {
-    let phi = match goal {
-        Goal::Max => -p.f,
-        Goal::Min => p.f,
-        Goal::Value(v) => (p.f - v) * (p.f - v),
-    };
-    let cons = p.g.iter().zip(rows).map(|(g, r)| if r.sense == Sense::Ge { -g } else { *g }).collect();
-    (phi, cons)
-}
-
-fn violation(cons: &[f64], senses: &[Sense]) -> f64 {
-    cons.iter().zip(senses).map(|(c, s)| if *s == Sense::Eq { c.abs() } else { c.max(0.0) }).fold(0.0, f64::max)
-}
-
-fn project(x: &mut [f64], lo: &[f64], hi: &[f64]) {
-    for ((v, l), h) in x.iter_mut().zip(lo).zip(hi) {
-        if *v < *l {
-            *v = *l;
-        }
-        if *v > *h {
-            *v = *h;
-        }
-    }
-}
-
-/// Local minimisation of the model within bounds `lo..hi` from `x0`.
-fn nlp(ev: &mut Evaluator, x0: &[f64], lo: &[f64], hi: &[f64], goal: Goal) -> Outcome {
-    let n = x0.len();
-    let rows = ev.rows.clone();
-    let senses: Vec<Sense> = rows.iter().map(|r| r.sense).collect();
-    let mut x = x0.to_vec();
-    project(&mut x, lo, hi);
-    let mut lam = vec![0.0; rows.len()];
-    let mut mu = 10.0;
-    let Some(p) = ev.eval(&x) else { return Outcome::Limit };
-    let (mut phi, mut cons) = shape(&p, &rows, goal);
-    if !phi.is_finite() {
-        return Outcome::Infeasible;
-    }
-    let phi0 = phi;
-    let mut prev_viol = violation(&cons, &senses);
-    let mut converged = false;
-    let mut out_of_budget = false;
-    let mut carried: Option<f64> = None;
-    for _outer in 0..40 {
-        // Inner: projected gradient on the augmented Lagrangian.
-        let lval = |phi: f64, cons: &[f64], lam: &[f64], mu: f64| aug(phi, cons, &senses, lam, mu);
-        let grad = |ev: &mut Evaluator, x: &[f64], lam: &[f64], mu: f64| -> Option<Vec<f64>> {
-            let mut gr = vec![0.0; n];
-            for j in 0..n {
-                let xj = x.get(j).copied().unwrap_or(0.0);
-                let h = 1e-6 * xj.abs().max(1.0);
-                let (l, u) = (lo.get(j).copied().unwrap_or(f64::NEG_INFINITY), hi.get(j).copied().unwrap_or(f64::INFINITY));
-                let (a, b) = (if xj - h >= l { xj - h } else { xj }, if xj + h <= u { xj + h } else { xj });
-                if b <= a {
-                    continue;
-                }
-                let mut xa = x.to_vec();
-                let mut xb = x.to_vec();
-                if let Some(v) = xa.get_mut(j) {
-                    *v = a;
-                }
-                if let Some(v) = xb.get_mut(j) {
-                    *v = b;
-                }
-                let (pa, ca) = shape(&ev.eval(&xa)?, &rows, goal);
-                let (pb, cb) = shape(&ev.eval(&xb)?, &rows, goal);
-                let d = (lval(pb, &cb, lam, mu) - lval(pa, &ca, lam, mu)) / (b - a);
-                if let Some(v) = gr.get_mut(j) {
-                    *v = if d.is_finite() { d } else { 0.0 };
-                }
-            }
-            Some(gr)
-        };
-        let mut l_cur = lval(phi, &cons, &lam, mu);
-        let Some(mut g) = grad(ev, &x, &lam, mu) else {
-            out_of_budget = true;
-            break;
-        };
-        // The step length carries over between outer iterations once known.
-        let gnorm = g.iter().map(|v| v.abs()).fold(0.0, f64::max);
-        let mut alpha = carried.unwrap_or(if gnorm > 0.0 { 1.0 / gnorm } else { 1.0 });
-        let mut inner_done = false;
-        let mut quiet = 0;
-        for _inner in 0..500 {
-            let mut accepted = None;
-            let mut a = alpha;
-            for _ in 0..40 {
-                let mut xn: Vec<f64> = x.iter().zip(&g).map(|(v, d)| v - a * d).collect();
-                project(&mut xn, lo, hi);
-                let Some(pn) = ev.eval(&xn) else { break };
-                let (phn, cn) = shape(&pn, &rows, goal);
-                let ln = lval(phn, &cn, &lam, mu);
-                let decrease: f64 = g.iter().zip(x.iter().zip(&xn)).map(|(d, (u, v))| d * (u - v)).sum();
-                if ln.is_finite() && ln <= l_cur - 1e-4 * decrease {
-                    accepted = Some((xn, phn, cn, ln));
-                    break;
-                }
-                a *= 0.25;
-            }
-            if ev.exhausted() {
-                out_of_budget = true;
-            }
-            let Some((xn, phn, cn, ln)) = accepted else {
-                inner_done = true;
-                break;
-            };
-            // Variables or objective running off towards infinity: unbounded.
-            if phn.abs() > 1e15 * (1.0 + phi0.abs()) || xn.iter().zip(x0).any(|(v, s)| v.abs() > 1e15 * (1.0 + s.abs())) {
-                return Outcome::Unbounded;
-            }
-            let s: Vec<f64> = xn.iter().zip(&x).map(|(a, b)| a - b).collect();
-            let step = s.iter().map(|v| v.abs()).fold(0.0, f64::max);
-            let xmax = xn.iter().map(|v| v.abs()).fold(1.0, f64::max);
-            let small = step <= 1e-10 * xmax || (l_cur - ln).abs() <= 1e-13 * (1.0 + l_cur.abs());
-            quiet = if small { quiet + 1 } else { 0 };
-            x = xn;
-            phi = phn;
-            cons = cn;
-            l_cur = ln;
-            if quiet >= 3 {
-                inner_done = true;
-                break;
-            }
-            let Some(gn) = grad(ev, &x, &lam, mu) else {
-                out_of_budget = true;
-                break;
-            };
-            // Barzilai–Borwein step.
-            let yv: Vec<f64> = gn.iter().zip(&g).map(|(a, b)| a - b).collect();
-            let sy: f64 = s.iter().zip(&yv).map(|(a, b)| a * b).sum();
-            let ss: f64 = s.iter().map(|v| v * v).sum();
-            alpha = if sy > 0.0 { (ss / sy).clamp(1e-12, 1e12) } else { (a * 4.0).min(1e12) };
-            g = gn;
-            if g.iter().all(|v| *v == 0.0) {
-                inner_done = true;
-                break;
-            }
-        }
-        carried = Some(alpha);
-        if out_of_budget {
-            break;
-        }
-        let viol = violation(&cons, &senses);
-        let scale = rows.iter().map(|r| r.rhs_const.abs()).fold(1.0, f64::max);
-        if viol <= PRECISION * scale && inner_done {
-            converged = true;
-            if rows.is_empty() {
-                break;
-            }
-        }
-        // Multiplier and penalty updates.
-        for ((l, c), s) in lam.iter_mut().zip(&cons).zip(&senses) {
-            *l = match s {
-                Sense::Eq => *l + mu * c,
-                _ => (*l + mu * c).max(0.0),
-            };
-        }
-        if viol > 0.25 * prev_viol {
-            mu = (mu * 10.0).min(1e10);
-        }
-        if converged && viol <= PRECISION * scale * 1e-2 {
-            break;
-        }
-        prev_viol = viol;
-        converged = false;
-    }
-    let viol = violation(&cons, &senses);
-    let scale = rows.iter().map(|r| r.rhs_const.abs()).fold(1.0, f64::max);
-    if viol > PRECISION * scale * 10.0 {
-        return if out_of_budget { Outcome::Limit } else { Outcome::Infeasible };
-    }
-    Outcome::Solved(x, phi, (converged || viol <= PRECISION * scale) && !out_of_budget)
-}
-
-// ---------------------------------------------------------------- evolutionary
-
-/// A small deterministic generator (SplitMix64), so a seed reproduces a run on every platform.
-struct Rng(u64);
-
-impl Rng {
-    fn new(seed: u64) -> Rng {
-        Rng(seed ^ 0x2545_F491_4F6C_DD1D)
-    }
-    fn next(&mut self) -> u64 {
-        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
-        let mut z = self.0;
-        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
-        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
-        z ^ (z >> 31)
-    }
-    /// Uniform in [0, 1).
-    fn uniform(&mut self) -> f64 {
-        (self.next() >> 11) as f64 / (1u64 << 53) as f64
-    }
-    fn between(&mut self, a: f64, b: f64) -> f64 {
-        a + (b - a) * self.uniform()
-    }
-    fn below(&mut self, n: usize) -> usize {
-        if n == 0 { 0 } else { usize::try_from(self.next() % n as u64).unwrap_or(0) }
-    }
-    /// Standard normal (Box–Muller).
-    fn normal(&mut self) -> f64 {
-        let u = self.uniform().max(f64::MIN_POSITIVE);
-        (-2.0 * u.ln()).sqrt() * (std::f64::consts::TAU * self.uniform()).cos()
-    }
-}
-
-/// A candidate: its point, the objective to minimise and its constraint violation.
-#[derive(Clone, Debug)]
-struct Member {
-    x: Vec<f64>,
-    phi: f64,
-    viol: f64,
-}
-
-impl Member {
-    /// Feasible beats infeasible; then the lower objective, or the smaller violation.
-    fn better(&self, o: &Member, tol: f64) -> bool {
-        match (self.viol <= tol, o.viol <= tol) {
-            (true, false) => true,
-            (false, true) => false,
-            (true, true) => self.phi < o.phi,
-            (false, false) => self.viol < o.viol,
-        }
-    }
-}
-
-/// Why the Evolutionary search stopped.
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum EvoEnd {
-    /// Almost all of the population is within Convergence of the best member.
-    Converged,
-    /// The best member didn't improve for the set number of generations.
-    Stalled,
-    /// The evaluation budget ran out.
-    Budget,
-}
-
-/// The search box, integer flags and scoring shared by the genetic and pattern phases.
-struct EvoSearch<'a> {
-    ev: &'a mut Evaluator,
-    rows: Vec<Row>,
-    senses: Vec<Sense>,
-    goal: Goal,
-    lo: Vec<f64>,
-    hi: Vec<f64>,
-    integer: &'a [bool],
-    tol: f64,
-}
-
-impl EvoSearch<'_> {
-    /// Clamps into the box and rounds integer variables.
-    fn repair(&self, x: &mut [f64]) {
-        for (j, v) in x.iter_mut().enumerate() {
-            let (l, h) = (self.lo.get(j).copied().unwrap_or(0.0), self.hi.get(j).copied().unwrap_or(0.0));
-            *v = if v.is_finite() { v.clamp(l, h) } else { l };
-            if self.integer.get(j).copied().unwrap_or(false) {
-                *v = v.round().clamp(l.ceil(), h.floor());
-            }
-        }
-    }
-
-    /// Scores `x`; `None` once the budget is spent.
-    fn score(&mut self, x: Vec<f64>) -> Option<Member> {
-        let p = self.ev.eval(&x)?;
-        let (phi, cons) = shape(&p, &self.rows, self.goal);
-        let viol = violation(&cons, &self.senses);
-        let phi = if phi.is_finite() { phi } else { f64::INFINITY };
-        let viol = if viol.is_finite() && cons.iter().all(|c| c.is_finite()) { viol } else { f64::INFINITY };
-        Some(Member { x, phi, viol })
-    }
-}
-
-/// The Evolutionary method within `lo..hi` from `x0`.
-fn evolutionary(ev: &mut Evaluator, x0: &[f64], lo: &[f64], hi: &[f64], integer: &[bool], goal: Goal, o: &EvoOptions) -> (Outcome, EvoEnd) {
-    let rows = ev.rows.clone();
-    let senses: Vec<Sense> = rows.iter().map(|r| r.sense).collect();
-    let scale = rows.iter().map(|r| r.rhs_const.abs()).fold(1.0, f64::max);
-    let mut start = x0.to_vec();
-    project(&mut start, lo, hi);
-    // Without a bound, search within 100 of the start.
-    let blo: Vec<f64> = lo.iter().zip(&start).map(|(l, s)| if l.is_finite() { *l } else { s - 100.0 }).collect();
-    let bhi: Vec<f64> = hi.iter().zip(&start).map(|(h, s)| if h.is_finite() { *h } else { s + 100.0 }).collect();
-    let no_integer = blo.iter().zip(&bhi).zip(integer).any(|((l, h), int)| *int && l.ceil() > h.floor());
-    if blo.iter().zip(&bhi).any(|(l, h)| l > h) || no_integer {
-        return (Outcome::Infeasible, EvoEnd::Converged);
-    }
-    let span: Vec<f64> = blo.iter().zip(&bhi).map(|(l, h)| (h - l).max(1e-9)).collect();
-    let mut se = EvoSearch { ev, rows, senses, goal, lo: blo, hi: bhi, integer, tol: PRECISION * scale };
-    let mut rng = Rng::new(o.seed);
-    let size = o.population.clamp(MIN_POPULATION, MAX_POPULATION);
-    let tol = se.tol;
-    let mut end = EvoEnd::Budget;
-    // The first generation: the start and random points in the box.
-    let mut pop: Vec<Member> = Vec::with_capacity(size);
-    se.repair(&mut start);
-    let mut next_x = Some(start);
-    while pop.len() < size {
-        let x = next_x.take().unwrap_or_else(|| {
-            let mut x: Vec<f64> = se.lo.iter().zip(&se.hi).map(|(l, h)| rng.between(*l, *h)).collect();
-            se.repair(&mut x);
-            x
-        });
-        match se.score(x) {
-            Some(m) => pop.push(m),
-            None => break,
-        }
-    }
-    let mut best: Option<Member> = None;
-    for m in &pop {
-        if best.as_ref().is_none_or(|b| m.better(b, tol)) {
-            best = Some(m.clone());
-        }
-    }
-    let mut last_improved = 0u64;
-    let mut generation = 0u64;
-    'search: while pop.len() == size {
-        let Some(b) = best.clone() else { break };
-        // Converged: 99% of the population is feasible and within Convergence of the best.
-        let close = pop.iter().filter(|m| m.viol <= tol && (m.phi - b.phi).abs() <= o.convergence * b.phi.abs().max(1.0)).count();
-        if b.viol <= tol && generation >= 5 && close * 100 >= size * 99 {
-            end = EvoEnd::Converged;
-            break;
-        }
-        if generation.saturating_sub(last_improved) >= o.stall {
-            end = EvoEnd::Stalled;
-            break;
-        }
-        // The next generation: the best survives, the rest are children of two tournaments.
-        let mut next = Vec::with_capacity(size);
-        next.push(b.clone());
-        while next.len() < size {
-            let mut parent = || {
-                let (i, k) = (rng.below(size), rng.below(size));
-                match (pop.get(i), pop.get(k)) {
-                    (Some(p), Some(q)) => Some(if q.better(p, tol) { q.x.clone() } else { p.x.clone() }),
-                    _ => None,
-                }
-            };
-            let (Some(pa), Some(pb)) = (parent(), parent()) else { break 'search };
-            let mut x: Vec<f64> = pa
-                .iter()
-                .zip(&pb)
-                .zip(&span)
-                .map(|((a, c), w)| {
-                    let mut v = a + rng.between(-0.25, 1.25) * (c - a);
-                    if rng.uniform() < o.mutation {
-                        v += 0.1 * w * rng.normal();
-                    }
-                    v
-                })
-                .collect();
-            se.repair(&mut x);
-            match se.score(x) {
-                Some(m) => next.push(m),
-                None => break 'search,
-            }
-        }
-        generation += 1;
-        for m in &next {
-            let Some(cur) = &best else { continue };
-            if m.better(cur, tol) {
-                let improved = cur.viol > tol || cur.phi - m.phi > 1e-9 * cur.phi.abs().max(1.0);
-                best = Some(m.clone());
-                if improved {
-                    last_improved = generation;
-                }
-            }
-        }
-        pop = next;
-    }
-    // Polish: a compass search on the continuous variables around the best member.
-    if let Some(mut b) = best.clone() {
-        let mut step: Vec<f64> = span.iter().map(|w| 0.01 * w).collect();
-        let n = b.x.len();
-        'polish: for _ in 0..10_000 {
-            if step.iter().zip(&span).zip(integer).all(|((s, w), int)| *int || *s <= 1e-9 * w.max(1.0)) {
-                break;
-            }
-            let mut moved = false;
-            for j in 0..n {
-                if integer.get(j).copied().unwrap_or(false) {
-                    continue;
-                }
-                for dir in [1.0, -1.0] {
-                    let mut x = b.x.clone();
-                    if let (Some(v), Some(s)) = (x.get_mut(j), step.get(j)) {
-                        *v += dir * s;
-                    }
-                    se.repair(&mut x);
-                    if x == b.x {
-                        continue;
-                    }
-                    let Some(m) = se.score(x) else { break 'polish };
-                    if m.better(&b, tol) {
-                        b = m;
-                        moved = true;
-                        break;
-                    }
-                }
-            }
-            if !moved {
-                for s in &mut step {
-                    *s *= 0.5;
-                }
-            }
-        }
-        best = Some(b);
-    }
-    match best {
-        Some(b) if b.viol <= tol => (Outcome::Solved(b.x, b.phi, end != EvoEnd::Budget), end),
-        _ if end == EvoEnd::Budget => (Outcome::Limit, end),
-        _ => (Outcome::Infeasible, end),
-    }
-}
-
 /// What a solve ended with, and why Simplex LP or Evolutionary stopped.
 struct Solve {
     outcome: Outcome,
@@ -1615,375 +151,6 @@ fn optimise(ev: &mut Evaluator, m: &Model, goal: Goal, x0: &[f64], lo: &[f64], h
     Solve { outcome, not_linear, evo_end }
 }
 
-// ---------------------------------------------------------------- reports
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum ReportKind {
-    Answer,
-    Limits,
-}
-
-impl ReportKind {
-    fn title(self) -> &'static str {
-        match self {
-            ReportKind::Answer => "Answer",
-            ReportKind::Limits => "Limits",
-        }
-    }
-}
-
-/// The `reports` list (`None` when absent).
-fn report_kinds(cmd: &'static str, p: &Json) -> Result<Option<Vec<ReportKind>>> {
-    let Some(list) = p.get("reports") else { return Ok(None) };
-    let list = list.as_array().ok_or_else(|| bad(cmd, "`reports` must be an array of answer and limits"))?;
-    let mut kinds = Vec::new();
-    for k in list {
-        let kind = match k.as_str().map(|t| t.trim().to_ascii_lowercase()).as_deref() {
-            Some("answer") => ReportKind::Answer,
-            Some("limits") => ReportKind::Limits,
-            _ => return Err(bad(cmd, format!("unknown report {k} (answer or limits)"))),
-        };
-        if !kinds.contains(&kind) {
-            kinds.push(kind);
-        }
-    }
-    Ok(Some(kinds))
-}
-
-/// A report's cells: (row, column, value, bold).
-type Lines = Vec<(u32, u32, Value, bool)>;
-
-fn abs_ref(c: CellRef) -> String {
-    format!("${}${}", gridcraft_core::col_to_letters(c.col), u64::from(c.row) + 1)
-}
-
-/// A cell's name in the reports: the nearest text to its left and the nearest text above it.
-fn cell_name(sh: &Sheet, c: CellRef) -> String {
-    let text = |c: CellRef| match sh.value(c) {
-        Value::Text(t) if !t.trim().is_empty() => Some(t.to_string()),
-        _ => None,
-    };
-    let left = (0..c.col).rev().find_map(|col| text(CellRef::new(c.row, col)));
-    let top = (0..c.row).rev().find_map(|row| text(CellRef::new(row, c.col)));
-    [left, top].into_iter().flatten().collect::<Vec<_>>().join(" ")
-}
-
-fn method_name(m: Method) -> &'static str {
-    match m {
-        Method::Simplex => "Simplex LP",
-        Method::Grg => "GRG Nonlinear",
-        Method::Evolutionary => "Evolutionary",
-    }
-}
-
-/// Header labels in bold from column 1, then the rows below them; returns the next free row.
-fn table(out: &mut Lines, row: u32, headers: &[&str], rows: Vec<Vec<Value>>) -> u32 {
-    for (k, h) in headers.iter().enumerate() {
-        out.push((row, 1 + k as u32, Value::text(*h), true));
-    }
-    let mut r = row;
-    for cells in rows {
-        r = r.saturating_add(1);
-        for (k, v) in cells.into_iter().enumerate() {
-            out.push((r, 1 + k as u32, v, false));
-        }
-    }
-    r.saturating_add(2)
-}
-
-/// Everything a report describes: the model, its starting and final values, and the result.
-struct ReportInput<'a> {
-    model: &'a Model,
-    prob: &'a Problem,
-    original: Vec<f64>,
-    solution: Vec<f64>,
-    message: String,
-    budget: u64,
-}
-
-fn title(out: &mut Lines, kind: ReportKind, sheet: &str) -> u32 {
-    out.push((0, 0, Value::text(format!("GridCraft {} Report", kind.title())), true));
-    out.push((1, 0, Value::text(format!("Worksheet: {sheet}")), false));
-    3
-}
-
-fn format_constraint_row(sh: &Sheet, c: &Constraint, cell: CellRef, v: f64, rhs: &[f64], k: usize) -> Vec<Value> {
-    let (formula, status, slack) = match (c.rel, &c.rhs) {
-        (Rel::Int, _) => (format!("{}=Integer", abs_ref(cell)), "Binding", 0.0),
-        (Rel::Bin, _) => (format!("{}=Binary", abs_ref(cell)), "Binding", 0.0),
-        (rel, rhs_cells) => {
-            let b = rhs.get(k).or_else(|| rhs.first()).copied().unwrap_or(f64::NAN);
-            let rhs_text = match rhs_cells {
-                Rhs::Cells(cells) => cells.get(k).or_else(|| cells.first()).map(|c| abs_ref(*c)).unwrap_or_default(),
-                _ => gridcraft_core::number_to_text(b),
-            };
-            let slack = (v - b).abs();
-            let binding = rel == Rel::Eq || slack <= PRECISION * (1.0 + b.abs());
-            let slack = if binding { 0.0 } else { slack };
-            (format!("{}{}{rhs_text}", abs_ref(cell), rel.text()), if binding { "Binding" } else { "Not Binding" }, slack)
-        }
-    };
-    let num = |v: f64| if v.is_finite() { Value::number(v) } else { Value::Error(gridcraft_core::CellError::Value) };
-    vec![Value::text(abs_ref(cell)), Value::text(cell_name(sh, cell)), num(v), Value::text(formula), Value::text(status), num(slack)]
-}
-
-fn answer_report(d: &DocState, sh: &Sheet, inp: &ReportInput) -> Lines {
-    let m = inp.model;
-    let mut trial = Trial::new(d);
-    let read = |trial: &mut Trial, x: &[f64], cells: &[CellRef]| -> Vec<f64> {
-        let sets: Vec<(usize, CellRef, Value)> = m.vars.iter().zip(x).map(|(c, v)| (m.sheet, *c, Value::number(*v))).collect();
-        let reads: Vec<(usize, CellRef)> = cells.iter().map(|c| (m.sheet, *c)).collect();
-        trial.run(&sets, &reads).iter().map(as_num).collect()
-    };
-    let f0 = read(&mut trial, &inp.original, &[m.objective]).first().copied().unwrap_or(f64::NAN);
-    // Every cell the constraints read, at the solution.
-    let mut cells = vec![m.objective];
-    for c in &m.cons {
-        cells.extend(&c.lhs);
-        if let Rhs::Cells(r) = &c.rhs {
-            cells.extend(r);
-        }
-    }
-    let vals = read(&mut trial, &inp.solution, &cells);
-    let mut at = vals.iter().copied();
-    let f1 = at.next().unwrap_or(f64::NAN);
-    let num = |v: f64| if v.is_finite() { Value::number(v) } else { Value::Error(gridcraft_core::CellError::Value) };
-    let mut out = Lines::new();
-    let mut r = title(&mut out, ReportKind::Answer, &sh.name);
-    out.push((r, 0, Value::text(format!("Result: {}", inp.message)), false));
-    out.push((r + 1, 0, Value::text(format!("Engine: {}", method_name(m.method))), false));
-    r += 3;
-    let goal = match m.goal {
-        Goal::Max => "Max".to_string(),
-        Goal::Min => "Min".to_string(),
-        Goal::Value(v) => format!("Value Of {v}"),
-    };
-    out.push((r, 0, Value::text(format!("Objective Cell ({goal})")), true));
-    let obj = vec![vec![Value::text(abs_ref(m.objective)), Value::text(cell_name(sh, m.objective)), num(f0), num(f1)]];
-    r = table(&mut out, r + 1, &["Cell", "Name", "Original Value", "Final Value"], obj);
-    out.push((r, 0, Value::text("Variable Cells"), true));
-    let kind = |j: usize| {
-        let bin = m.cons.iter().any(|c| c.rel == Rel::Bin && m.vars.get(j).is_some_and(|v| c.lhs.contains(v)));
-        match (bin, inp.prob.integer.get(j).copied().unwrap_or(false)) {
-            (true, _) => "Binary",
-            (false, true) => "Integer",
-            _ => "Contin",
-        }
-    };
-    let vars = m
-        .vars
-        .iter()
-        .enumerate()
-        .map(|(j, c)| {
-            let (a, b) = (inp.original.get(j).copied().unwrap_or(f64::NAN), inp.solution.get(j).copied().unwrap_or(f64::NAN));
-            vec![Value::text(abs_ref(*c)), Value::text(cell_name(sh, *c)), num(a), num(b), Value::text(kind(j))]
-        })
-        .collect();
-    r = table(&mut out, r + 1, &["Cell", "Name", "Original Value", "Final Value", "Integer"], vars);
-    out.push((r, 0, Value::text("Constraints"), true));
-    let mut rows = Vec::new();
-    for c in &m.cons {
-        let lhs: Vec<f64> = c.lhs.iter().map(|_| at.next().unwrap_or(f64::NAN)).collect();
-        let rhs: Vec<f64> = match &c.rhs {
-            Rhs::Cells(cells) => cells.iter().map(|_| at.next().unwrap_or(f64::NAN)).collect(),
-            Rhs::Const(v) => vec![*v],
-            Rhs::None => vec![],
-        };
-        for (k, (cell, v)) in c.lhs.iter().zip(&lhs).enumerate() {
-            rows.push(format_constraint_row(sh, c, *cell, *v, &rhs, k));
-        }
-    }
-    table(&mut out, r + 1, &["Cell", "Name", "Cell Value", "Formula", "Status", "Slack"], rows);
-    out
-}
-
-fn limits_report(d: &DocState, sh: &Sheet, inp: &ReportInput) -> Result<Lines> {
-    let m = inp.model;
-    if inp.prob.integer.iter().any(|b| *b) {
-        return Err(EngineError::Other("The Limits report doesn't apply to models with integer or binary constraints.".into()));
-    }
-    if m.method == Method::Evolutionary {
-        return Err(EngineError::Other("The Limits report is available for Simplex LP and GRG Nonlinear.".into()));
-    }
-    let n = m.vars.len();
-    let x = &inp.solution;
-    // Each variable is minimised and maximised with the others held at the solution.
-    let per = (inp.budget / (2 * n as u64).max(1)).max(n as u64 + 3);
-    let mut ev = Evaluator {
-        trial: Trial::new(d),
-        sheet: m.sheet,
-        vars: m.vars.clone(),
-        objective: m.objective,
-        rows: inp.prob.rows.clone(),
-        evals: 0,
-        budget: 0,
-        target: None,
-    };
-    let objective_at = |ev: &mut Evaluator, x: &[f64]| {
-        ev.target = None;
-        ev.budget = ev.evals.saturating_add(1);
-        ev.eval(x).map(|p| p.f).unwrap_or(f64::NAN)
-    };
-    let num = |v: f64| if v.is_finite() { Value::number(v) } else { Value::Error(gridcraft_core::CellError::Value) };
-    let f = objective_at(&mut ev, x);
-    let mut rows = Vec::new();
-    for (j, c) in m.vars.iter().enumerate() {
-        let (mut lo, mut hi) = (x.clone(), x.clone());
-        if let (Some(l), Some(h), Some(pl), Some(ph)) = (lo.get_mut(j), hi.get_mut(j), inp.prob.lo.get(j), inp.prob.hi.get(j)) {
-            *l = *pl;
-            *h = *ph;
-        }
-        let mut ends = Vec::new();
-        for goal in [Goal::Min, Goal::Max] {
-            ev.target = Some(j);
-            ev.evals = 0;
-            ev.budget = per;
-            let solve = optimise(&mut ev, m, goal, x, &lo, &hi, &inp.prob.integer, 0.0);
-            ends.push(match solve.outcome {
-                Outcome::Solved(p, _, _) => {
-                    let v = p.get(j).copied().unwrap_or(f64::NAN);
-                    (num(v), num(objective_at(&mut ev, &p)))
-                }
-                Outcome::Unbounded => (Value::text("Unbounded"), Value::Empty),
-                _ => (Value::Error(gridcraft_core::CellError::NA), Value::Empty),
-            });
-        }
-        let mut row = vec![Value::text(abs_ref(*c)), Value::text(cell_name(sh, *c)), num(x.get(j).copied().unwrap_or(f64::NAN))];
-        for (v, o) in ends {
-            row.push(v);
-            row.push(o);
-        }
-        rows.push(row);
-    }
-    let mut out = Lines::new();
-    let r = title(&mut out, ReportKind::Limits, &sh.name);
-    let obj = vec![vec![Value::text(abs_ref(m.objective)), Value::text(cell_name(sh, m.objective)), num(f)]];
-    let r = table(&mut out, r, &["Objective Cell", "Name", "Value"], obj);
-    table(&mut out, r, &["Variable Cell", "Name", "Value", "Lower Limit", "Objective Result", "Upper Limit", "Objective Result"], rows);
-    Ok(out)
-}
-
-/// Builds every report before the solution or saved model can change.
-fn prepare_reports(d: &DocState, kinds: &[ReportKind], inp: &ReportInput) -> Result<Vec<(String, Lines)>> {
-    if kinds.is_empty() {
-        return Ok(Vec::new());
-    }
-    if d.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    let sh = d.wb.sheet(inp.model.sheet).ok_or(EngineError::NoDocument)?;
-    let mut built = Vec::new();
-    for k in kinds {
-        let lines = match k {
-            ReportKind::Answer => answer_report(d, sh, inp),
-            ReportKind::Limits => limits_report(d, sh, inp)?,
-        };
-        let name = (1..=10_000u32)
-            .map(|i| format!("{} Report {i}", k.title()))
-            .find(|n| d.wb.sheet_index(n).is_none() && !built.iter().any(|(b, _): &(String, Lines)| b == n))
-            .ok_or_else(|| EngineError::Other("Too many report sheets.".into()))?;
-        built.push((name, lines));
-    }
-    Ok(built)
-}
-
-/// Inserts prepared reports before the model's sheet, which stays active.
-fn write_reports(cx: &mut Ctx, at: usize, built: Vec<(String, Lines)>) -> Vec<String> {
-    let names: Vec<String> = built.iter().map(|(n, _)| n.clone()).collect();
-    let count = built.len();
-    if count == 0 {
-        return names;
-    }
-    let bold = cx.wb.styles.derive(gridcraft_model::StyleId::DEFAULT, |st| st.font.bold = true);
-    for (i, (name, lines)) in built.into_iter().enumerate() {
-        let mut sheet = Sheet::new(name);
-        for (r, c, v, b) in lines {
-            let style = if b { bold } else { gridcraft_model::StyleId::DEFAULT };
-            sheet.set_cell(CellRef::new(r, c), Cell { value: v, formula: None, style });
-        }
-        for (c, w) in [(0u32, 14.0f32), (1, 110.0), (2, 140.0), (3, 120.0), (4, 120.0), (5, 120.0), (6, 120.0), (7, 120.0)] {
-            sheet.cols.insert(c, gridcraft_model::LineInfo { size: Some(w), ..Default::default() });
-        }
-        cx.wb.sheets.insert(at + i, std::sync::Arc::new(sheet));
-    }
-    for nm in cx.wb.names.iter_mut() {
-        if let Some(sc) = nm.scope.as_mut()
-            && *sc >= at
-        {
-            *sc += count;
-        }
-    }
-    if cx.wb.active_sheet() >= at {
-        cx.wb.set_active_sheet(cx.wb.active_sheet().saturating_add(count));
-    }
-    cx.structural = true;
-    names
-}
-
-fn insert_report_selections(s: &mut Session, at: usize, count: usize) {
-    if let Ok(d) = s.doc_mut() {
-        for i in 0..count {
-            d.sheet_selections.insert((at + i).min(d.sheet_selections.len()), crate::Selection::default());
-        }
-    }
-}
-
-/// `data.solverReport`: reports for a solution of the sheet's saved model.
-fn report(s: &mut Session, p: &Json) -> Result<Json> {
-    let kinds = report_kinds(REPORT_CMD, p)?.ok_or_else(|| bad(REPORT_CMD, "missing `reports` (answer, limits)"))?;
-    if kinds.is_empty() {
-        return Err(bad(REPORT_CMD, "`reports` is empty (answer, limits)"));
-    }
-    let d = s.doc()?;
-    // The given model as is, else the saved model with any params given here over it.
-    let params = match p.get("model") {
-        Some(m @ Json::Object(_)) => m.clone(),
-        Some(Json::Null) | None => {
-            let mut params = saved_model(&d.wb, d.wb.active_sheet()).unwrap_or_else(|| json!({}));
-            if let (Some(base), Some(over)) = (params.as_object_mut(), p.as_object()) {
-                for (k, v) in over {
-                    base.insert(k.clone(), v.clone());
-                }
-            }
-            params
-        }
-        Some(_) => return Err(bad(REPORT_CMD, "`model` must be data.solver params")),
-    };
-    let model = parse_model(s, &params)?;
-    let prob = build_problem(&model);
-    let d = s.doc()?;
-    let sh = d.wb.sheet(model.sheet).ok_or(EngineError::NoDocument)?;
-    let current: Vec<f64> = model.vars.iter().map(|c| as_num(&sh.value(*c))).collect();
-    // `{cell: number}` maps; cells they leave out keep their current values.
-    let point = |key: &str| -> Result<Vec<f64>> {
-        let mut x = current.clone();
-        let Some(map) = p.get(key) else { return Ok(x) };
-        let map = map.as_object().ok_or_else(|| bad(REPORT_CMD, format!("`{key}` must map cells to numbers")))?;
-        for (cell, v) in map {
-            let c = CellRef::parse(&cell.replace('$', "")).ok_or_else(|| bad(REPORT_CMD, format!("not a cell: `{cell}`")))?;
-            let j = model.vars.iter().position(|v| *v == c).ok_or_else(|| bad(REPORT_CMD, format!("`{cell}` is not a variable cell")))?;
-            let v = v.as_f64().filter(|v| v.is_finite()).ok_or_else(|| bad(REPORT_CMD, format!("`{key}.{cell}` must be a number")))?;
-            if let Some(e) = x.get_mut(j) {
-                *e = v;
-            }
-        }
-        Ok(x)
-    };
-    let solution = point("values")?;
-    let original = if p.get("original").is_some() { point("original")? } else { solution.clone() };
-    let budget = params
-        .get("maxEvaluations")
-        .and_then(Json::as_f64)
-        .filter(|v| v.is_finite() && *v >= 1.0)
-        .map_or(DEFAULT_EVALS, |v| (v as u64).min(MAX_EVALS));
-    let message = str_param(p, "message").unwrap_or("").chars().take(500).collect();
-    let inp = ReportInput { model: &model, prob: &prob, original, solution, message, budget };
-    let built = prepare_reports(s.doc()?, &kinds, &inp)?;
-    let sheets = edit(s, |cx| Ok(write_reports(cx, model.sheet, built)))?;
-    insert_report_selections(s, model.sheet, sheets.len());
-    Ok(json!({"sheets": sheets}))
-}
-
 // ---------------------------------------------------------------- command
 
 fn run(s: &mut Session, p: &Json) -> Result<Json> {
diff --git a/crates/engine/src/cmd/solver/evolutionary.rs b/crates/engine/src/cmd/solver/evolutionary.rs
new file mode 100644
index 000000000..391d4e8ed
--- /dev/null
+++ b/crates/engine/src/cmd/solver/evolutionary.rs
@@ -0,0 +1,255 @@
+use super::lp::{Outcome, Row, Sense};
+use super::model::{EvoOptions, Goal};
+use super::nlp::{project, shape, violation};
+use super::problem::Evaluator;
+use super::*;
+
+// ---------------------------------------------------------------- evolutionary
+
+/// A small deterministic generator (SplitMix64), so a seed reproduces a run on every platform.
+struct Rng(u64);
+
+impl Rng {
+    fn new(seed: u64) -> Rng {
+        Rng(seed ^ 0x2545_F491_4F6C_DD1D)
+    }
+    fn next(&mut self) -> u64 {
+        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
+        let mut z = self.0;
+        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+        z ^ (z >> 31)
+    }
+    /// Uniform in [0, 1).
+    fn uniform(&mut self) -> f64 {
+        (self.next() >> 11) as f64 / (1u64 << 53) as f64
+    }
+    fn between(&mut self, a: f64, b: f64) -> f64 {
+        a + (b - a) * self.uniform()
+    }
+    fn below(&mut self, n: usize) -> usize {
+        if n == 0 { 0 } else { usize::try_from(self.next() % n as u64).unwrap_or(0) }
+    }
+    /// Standard normal (Box–Muller).
+    fn normal(&mut self) -> f64 {
+        let u = self.uniform().max(f64::MIN_POSITIVE);
+        (-2.0 * u.ln()).sqrt() * (std::f64::consts::TAU * self.uniform()).cos()
+    }
+}
+
+/// A candidate: its point, the objective to minimise and its constraint violation.
+#[derive(Clone, Debug)]
+struct Member {
+    x: Vec<f64>,
+    phi: f64,
+    viol: f64,
+}
+
+impl Member {
+    /// Feasible beats infeasible; then the lower objective, or the smaller violation.
+    fn better(&self, o: &Member, tol: f64) -> bool {
+        match (self.viol <= tol, o.viol <= tol) {
+            (true, false) => true,
+            (false, true) => false,
+            (true, true) => self.phi < o.phi,
+            (false, false) => self.viol < o.viol,
+        }
+    }
+}
+
+/// Why the Evolutionary search stopped.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum EvoEnd {
+    /// Almost all of the population is within Convergence of the best member.
+    Converged,
+    /// The best member didn't improve for the set number of generations.
+    Stalled,
+    /// The evaluation budget ran out.
+    Budget,
+}
+
+/// The search box, integer flags and scoring shared by the genetic and pattern phases.
+struct EvoSearch<'a> {
+    ev: &'a mut Evaluator,
+    rows: Vec<Row>,
+    senses: Vec<Sense>,
+    goal: Goal,
+    lo: Vec<f64>,
+    hi: Vec<f64>,
+    integer: &'a [bool],
+    tol: f64,
+}
+
+impl EvoSearch<'_> {
+    /// Clamps into the box and rounds integer variables.
+    fn repair(&self, x: &mut [f64]) {
+        for (j, v) in x.iter_mut().enumerate() {
+            let (l, h) = (self.lo.get(j).copied().unwrap_or(0.0), self.hi.get(j).copied().unwrap_or(0.0));
+            *v = if v.is_finite() { v.clamp(l, h) } else { l };
+            if self.integer.get(j).copied().unwrap_or(false) {
+                *v = v.round().clamp(l.ceil(), h.floor());
+            }
+        }
+    }
+
+    /// Scores `x`; `None` once the budget is spent.
+    fn score(&mut self, x: Vec<f64>) -> Option<Member> {
+        let p = self.ev.eval(&x)?;
+        let (phi, cons) = shape(&p, &self.rows, self.goal);
+        let viol = violation(&cons, &self.senses);
+        let phi = if phi.is_finite() { phi } else { f64::INFINITY };
+        let viol = if viol.is_finite() && cons.iter().all(|c| c.is_finite()) { viol } else { f64::INFINITY };
+        Some(Member { x, phi, viol })
+    }
+}
+
+/// The Evolutionary method within `lo..hi` from `x0`.
+pub(super) fn evolutionary(
+    ev: &mut Evaluator,
+    x0: &[f64],
+    lo: &[f64],
+    hi: &[f64],
+    integer: &[bool],
+    goal: Goal,
+    o: &EvoOptions,
+) -> (Outcome, EvoEnd) {
+    let rows = ev.rows.clone();
+    let senses: Vec<Sense> = rows.iter().map(|r| r.sense).collect();
+    let scale = rows.iter().map(|r| r.rhs_const.abs()).fold(1.0, f64::max);
+    let mut start = x0.to_vec();
+    project(&mut start, lo, hi);
+    // Without a bound, search within 100 of the start.
+    let blo: Vec<f64> = lo.iter().zip(&start).map(|(l, s)| if l.is_finite() { *l } else { s - 100.0 }).collect();
+    let bhi: Vec<f64> = hi.iter().zip(&start).map(|(h, s)| if h.is_finite() { *h } else { s + 100.0 }).collect();
+    let no_integer = blo.iter().zip(&bhi).zip(integer).any(|((l, h), int)| *int && l.ceil() > h.floor());
+    if blo.iter().zip(&bhi).any(|(l, h)| l > h) || no_integer {
+        return (Outcome::Infeasible, EvoEnd::Converged);
+    }
+    let span: Vec<f64> = blo.iter().zip(&bhi).map(|(l, h)| (h - l).max(1e-9)).collect();
+    let mut se = EvoSearch { ev, rows, senses, goal, lo: blo, hi: bhi, integer, tol: PRECISION * scale };
+    let mut rng = Rng::new(o.seed);
+    let size = o.population.clamp(MIN_POPULATION, MAX_POPULATION);
+    let tol = se.tol;
+    let mut end = EvoEnd::Budget;
+    // The first generation: the start and random points in the box.
+    let mut pop: Vec<Member> = Vec::with_capacity(size);
+    se.repair(&mut start);
+    let mut next_x = Some(start);
+    while pop.len() < size {
+        let x = next_x.take().unwrap_or_else(|| {
+            let mut x: Vec<f64> = se.lo.iter().zip(&se.hi).map(|(l, h)| rng.between(*l, *h)).collect();
+            se.repair(&mut x);
+            x
+        });
+        match se.score(x) {
+            Some(m) => pop.push(m),
+            None => break,
+        }
+    }
+    let mut best: Option<Member> = None;
+    for m in &pop {
+        if best.as_ref().is_none_or(|b| m.better(b, tol)) {
+            best = Some(m.clone());
+        }
+    }
+    let mut last_improved = 0u64;
+    let mut generation = 0u64;
+    'search: while pop.len() == size {
+        let Some(b) = best.clone() else { break };
+        // Converged: 99% of the population is feasible and within Convergence of the best.
+        let close = pop.iter().filter(|m| m.viol <= tol && (m.phi - b.phi).abs() <= o.convergence * b.phi.abs().max(1.0)).count();
+        if b.viol <= tol && generation >= 5 && close * 100 >= size * 99 {
+            end = EvoEnd::Converged;
+            break;
+        }
+        if generation.saturating_sub(last_improved) >= o.stall {
+            end = EvoEnd::Stalled;
+            break;
+        }
+        // The next generation: the best survives, the rest are children of two tournaments.
+        let mut next = Vec::with_capacity(size);
+        next.push(b.clone());
+        while next.len() < size {
+            let mut parent = || {
+                let (i, k) = (rng.below(size), rng.below(size));
+                match (pop.get(i), pop.get(k)) {
+                    (Some(p), Some(q)) => Some(if q.better(p, tol) { q.x.clone() } else { p.x.clone() }),
+                    _ => None,
+                }
+            };
+            let (Some(pa), Some(pb)) = (parent(), parent()) else { break 'search };
+            let mut x: Vec<f64> = pa
+                .iter()
+                .zip(&pb)
+                .zip(&span)
+                .map(|((a, c), w)| {
+                    let mut v = a + rng.between(-0.25, 1.25) * (c - a);
+                    if rng.uniform() < o.mutation {
+                        v += 0.1 * w * rng.normal();
+                    }
+                    v
+                })
+                .collect();
+            se.repair(&mut x);
+            match se.score(x) {
+                Some(m) => next.push(m),
+                None => break 'search,
+            }
+        }
+        generation += 1;
+        for m in &next {
+            let Some(cur) = &best else { continue };
+            if m.better(cur, tol) {
+                let improved = cur.viol > tol || cur.phi - m.phi > 1e-9 * cur.phi.abs().max(1.0);
+                best = Some(m.clone());
+                if improved {
+                    last_improved = generation;
+                }
+            }
+        }
+        pop = next;
+    }
+    // Polish: a compass search on the continuous variables around the best member.
+    if let Some(mut b) = best.clone() {
+        let mut step: Vec<f64> = span.iter().map(|w| 0.01 * w).collect();
+        let n = b.x.len();
+        'polish: for _ in 0..10_000 {
+            if step.iter().zip(&span).zip(integer).all(|((s, w), int)| *int || *s <= 1e-9 * w.max(1.0)) {
+                break;
+            }
+            let mut moved = false;
+            for j in 0..n {
+                if integer.get(j).copied().unwrap_or(false) {
+                    continue;
+                }
+                for dir in [1.0, -1.0] {
+                    let mut x = b.x.clone();
+                    if let (Some(v), Some(s)) = (x.get_mut(j), step.get(j)) {
+                        *v += dir * s;
+                    }
+                    se.repair(&mut x);
+                    if x == b.x {
+                        continue;
+                    }
+                    let Some(m) = se.score(x) else { break 'polish };
+                    if m.better(&b, tol) {
+                        b = m;
+                        moved = true;
+                        break;
+                    }
+                }
+            }
+            if !moved {
+                for s in &mut step {
+                    *s *= 0.5;
+                }
+            }
+        }
+        best = Some(b);
+    }
+    match best {
+        Some(b) if b.viol <= tol => (Outcome::Solved(b.x, b.phi, end != EvoEnd::Budget), end),
+        _ if end == EvoEnd::Budget => (Outcome::Limit, end),
+        _ => (Outcome::Infeasible, end),
+    }
+}
diff --git a/crates/engine/src/cmd/solver/lp.rs b/crates/engine/src/cmd/solver/lp.rs
new file mode 100644
index 000000000..29dad10db
--- /dev/null
+++ b/crates/engine/src/cmd/solver/lp.rs
@@ -0,0 +1,447 @@
+use super::problem::Evaluator;
+use super::*;
+
+// ---------------------------------------------------------------- evaluation
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Sense {
+    Le,
+    Ge,
+    Eq,
+}
+
+/// A scalar constraint `lhs (sense) rhs`.
+#[derive(Clone, Debug)]
+pub(super) struct Row {
+    pub(super) lhs: CellRef,
+    pub(super) sense: Sense,
+    pub(super) rhs: Option<CellRef>,
+    pub(super) rhs_const: f64,
+}
+
+/// What a relaxation (or the whole solve) ended with.
+#[derive(Clone, Debug)]
+pub(super) enum Outcome {
+    /// x, objective to minimise, and whether the solver converged (vs. ran out of budget).
+    Solved(Vec<f64>, f64, bool),
+    Infeasible,
+    Unbounded,
+    Limit,
+}
+
+/// Depth-first branch and bound over a relaxation solver; returns the best integer point.
+pub(super) fn branch_and_bound(
+    lo: &[f64],
+    hi: &[f64],
+    integer: &[bool],
+    max_nodes: usize,
+    gap: f64,
+    relax: &mut dyn FnMut(&[f64], &[f64]) -> Outcome,
+) -> (Outcome, usize) {
+    let mut stack: Vec<(Vec<f64>, Vec<f64>)> = vec![(lo.to_vec(), hi.to_vec())];
+    let mut best: Option<(Vec<f64>, f64)> = None;
+    let mut nodes = 0usize;
+    let mut limited = false;
+    let mut root = true;
+    while let Some((l, h)) = stack.pop() {
+        if nodes >= max_nodes {
+            limited = true;
+            break;
+        }
+        nodes += 1;
+        let out = relax(&l, &h);
+        let was_root = std::mem::replace(&mut root, false);
+        let (x, obj, converged) = match out {
+            Outcome::Solved(x, obj, c) => (x, obj, c),
+            Outcome::Unbounded if was_root => return (Outcome::Unbounded, nodes),
+            Outcome::Limit => {
+                limited = true;
+                break;
+            }
+            _ => continue,
+        };
+        if !converged {
+            limited = true;
+        }
+        if let Some((_, b)) = &best
+            && obj >= b - gap * b.abs().max(1e-12) - 1e-9 * (1.0 + b.abs())
+        {
+            continue;
+        }
+        // The most fractional integer variable.
+        let frac = x
+            .iter()
+            .zip(integer)
+            .enumerate()
+            .filter(|(_, (_, int))| **int)
+            .map(|(j, (v, _))| (j, (v - v.round()).abs()))
+            .filter(|(_, f)| *f > 1e-6)
+            .max_by(|a, b| a.1.total_cmp(&b.1));
+        match frac {
+            None => {
+                let snapped: Vec<f64> = x.iter().zip(integer).map(|(v, int)| if *int { v.round() } else { *v }).collect();
+                best = Some((snapped, obj));
+            }
+            Some((j, _)) => {
+                let v = x.get(j).copied().unwrap_or(0.0);
+                let (mut down_h, mut up_l) = (h.clone(), l.clone());
+                if let Some(e) = down_h.get_mut(j) {
+                    *e = e.min(v.floor());
+                }
+                if let Some(e) = up_l.get_mut(j) {
+                    *e = e.max(v.ceil());
+                }
+                // Explore the nearer side first (pushed last).
+                if v - v.floor() < 0.5 {
+                    stack.push((up_l, h));
+                    stack.push((l, down_h));
+                } else {
+                    stack.push((l, down_h));
+                    stack.push((up_l, h));
+                }
+            }
+        }
+    }
+    match best {
+        Some((x, obj)) => (Outcome::Solved(x, obj, !limited), nodes),
+        None if limited => (Outcome::Limit, nodes),
+        None => (Outcome::Infeasible, nodes),
+    }
+}
+
+// ---------------------------------------------------------------- simplex
+
+/// Pivots the tableau on (r, j), updating the objective row.
+fn pivot(t: &mut [Vec<f64>], obj: &mut [f64], r: usize, j: usize) {
+    let Some(prow) = t.get_mut(r) else { return };
+    let pv = prow.get(j).copied().unwrap_or(0.0);
+    if pv == 0.0 {
+        return;
+    }
+    for v in prow.iter_mut() {
+        *v /= pv;
+    }
+    let prow = prow.clone();
+    for (i, row) in t.iter_mut().enumerate() {
+        if i == r {
+            continue;
+        }
+        let f = row.get(j).copied().unwrap_or(0.0);
+        if f != 0.0 {
+            for (v, p) in row.iter_mut().zip(&prow) {
+                *v -= f * p;
+            }
+        }
+    }
+    let f = obj.get(j).copied().unwrap_or(0.0);
+    if f != 0.0 {
+        for (v, p) in obj.iter_mut().zip(&prow) {
+            *v -= f * p;
+        }
+    }
+}
+
+enum Step {
+    Optimal,
+    Unbounded,
+    Limit,
+}
+
+/// Minimises with the reduced costs in `obj` (last entry: −objective). Columns not `allowed`
+/// never enter.
+fn simplex(t: &mut [Vec<f64>], basis: &mut [usize], obj: &mut [f64], allowed: &[bool], budget: &mut u64) -> Step {
+    let n = obj.len().saturating_sub(1);
+    let cost = (t.len() as u64 + 1).saturating_mul(n as u64 + 1).max(1);
+    let mut stalled = 0u32;
+    loop {
+        if *budget < cost {
+            return Step::Limit;
+        }
+        *budget -= cost;
+        let bland = stalled > 50;
+        let mut enter = None;
+        let mut best = -EPS;
+        for (j, d) in obj.iter().take(n).enumerate() {
+            if !allowed.get(j).copied().unwrap_or(false) || *d >= -EPS {
+                continue;
+            }
+            if bland {
+                enter = Some(j);
+                break;
+            }
+            if *d < best {
+                best = *d;
+                enter = Some(j);
+            }
+        }
+        let Some(j) = enter else { return Step::Optimal };
+        let mut leave: Option<(usize, f64)> = None;
+        for (i, row) in t.iter().enumerate() {
+            let a = row.get(j).copied().unwrap_or(0.0);
+            if a <= EPS {
+                continue;
+            }
+            let ratio = row.get(n).copied().unwrap_or(0.0) / a;
+            let better = match leave {
+                None => true,
+                Some((li, lr)) => ratio < lr - 1e-12 || (ratio <= lr + 1e-12 && basis.get(i) < basis.get(li)),
+            };
+            if better {
+                leave = Some((i, ratio));
+            }
+        }
+        let Some((r, ratio)) = leave else { return Step::Unbounded };
+        stalled = if ratio <= EPS { stalled + 1 } else { 0 };
+        pivot(t, obj, r, j);
+        if let Some(b) = basis.get_mut(r) {
+            *b = j;
+        }
+    }
+}
+
+/// Minimises `c·x` subject to `rows` (coefficients, sense, rhs) and `lo ≤ x ≤ hi`.
+pub(super) fn solve_lp(c: &[f64], rows: &[(Vec<f64>, Sense, f64)], lo: &[f64], hi: &[f64], budget: &mut u64) -> Outcome {
+    let n = c.len();
+    if lo.iter().zip(hi).any(|(l, h)| l > h) {
+        return Outcome::Infeasible;
+    }
+    // x_j = offset + Σ sign·y_k with y ≥ 0.
+    struct Map {
+        var: usize,
+        sign: f64,
+    }
+    let mut cols: Vec<Map> = Vec::new();
+    let mut offset = vec![0.0; n];
+    let mut extra: Vec<(Vec<(usize, f64)>, Sense, f64)> = Vec::new();
+    for j in 0..n {
+        let (l, h) = (lo.get(j).copied().unwrap_or(f64::NEG_INFINITY), hi.get(j).copied().unwrap_or(f64::INFINITY));
+        if l.is_finite() {
+            if let Some(o) = offset.get_mut(j) {
+                *o = l;
+            }
+            cols.push(Map { var: j, sign: 1.0 });
+            if h.is_finite() {
+                extra.push((vec![(cols.len() - 1, 1.0)], Sense::Le, h - l));
+            }
+        } else if h.is_finite() {
+            if let Some(o) = offset.get_mut(j) {
+                *o = h;
+            }
+            cols.push(Map { var: j, sign: -1.0 });
+        } else {
+            cols.push(Map { var: j, sign: 1.0 });
+            cols.push(Map { var: j, sign: -1.0 });
+        }
+    }
+    let ny = cols.len();
+    // Rows over y: (coefficients, sense, rhs).
+    let mut yrows: Vec<(Vec<f64>, Sense, f64)> = Vec::with_capacity(rows.len() + extra.len());
+    for (a, sense, b) in rows {
+        let mut coef = vec![0.0; ny];
+        for (k, m) in cols.iter().enumerate() {
+            if let Some(v) = coef.get_mut(k) {
+                *v = a.get(m.var).copied().unwrap_or(0.0) * m.sign;
+            }
+        }
+        let shift: f64 = a.iter().zip(&offset).map(|(x, o)| x * o).sum();
+        yrows.push((coef, *sense, b - shift));
+    }
+    for (entries, sense, b) in extra {
+        let mut coef = vec![0.0; ny];
+        for (k, v) in entries {
+            if let Some(e) = coef.get_mut(k) {
+                *e = v;
+            }
+        }
+        yrows.push((coef, sense, b));
+    }
+    let m = yrows.len();
+    let n_slack = yrows.iter().filter(|r| r.1 != Sense::Eq).count();
+    // Rows with b < 0 are negated so every right side is ≥ 0.
+    let normalized: Vec<(Vec<f64>, Sense, f64)> = yrows
+        .into_iter()
+        .map(|(a, s, b)| {
+            if b < 0.0 {
+                let s = match s {
+                    Sense::Le => Sense::Ge,
+                    Sense::Ge => Sense::Le,
+                    Sense::Eq => Sense::Eq,
+                };
+                (a.iter().map(|v| -v).collect(), s, -b)
+            } else {
+                (a, s, b)
+            }
+        })
+        .collect();
+    let n_art = normalized.iter().filter(|r| r.1 != Sense::Le).count();
+    let width = ny + n_slack + n_art;
+    let mut t: Vec<Vec<f64>> = Vec::with_capacity(m);
+    let mut basis = vec![0usize; m];
+    let (mut si, mut ai) = (ny, ny + n_slack);
+    for (i, (a, s, b)) in normalized.iter().enumerate() {
+        let mut row = vec![0.0; width + 1];
+        for (v, x) in row.iter_mut().zip(a) {
+            *v = *x;
+        }
+        match s {
+            Sense::Le => {
+                if let Some(v) = row.get_mut(si) {
+                    *v = 1.0;
+                }
+                if let Some(bi) = basis.get_mut(i) {
+                    *bi = si;
+                }
+                si += 1;
+            }
+            Sense::Ge => {
+                if let Some(v) = row.get_mut(si) {
+                    *v = -1.0;
+                }
+                si += 1;
+                if let Some(v) = row.get_mut(ai) {
+                    *v = 1.0;
+                }
+                if let Some(bi) = basis.get_mut(i) {
+                    *bi = ai;
+                }
+                ai += 1;
+            }
+            Sense::Eq => {
+                if let Some(v) = row.get_mut(ai) {
+                    *v = 1.0;
+                }
+                if let Some(bi) = basis.get_mut(i) {
+                    *bi = ai;
+                }
+                ai += 1;
+            }
+        }
+        if let Some(v) = row.get_mut(width) {
+            *v = *b;
+        }
+        t.push(row);
+    }
+    let is_art = |j: usize| j >= ny + n_slack && j < width;
+    // Phase 1: minimise the sum of the artificials.
+    let mut obj = vec![0.0; width + 1];
+    for j in (ny + n_slack)..width {
+        if let Some(v) = obj.get_mut(j) {
+            *v = 1.0;
+        }
+    }
+    for (i, row) in t.iter().enumerate() {
+        if basis.get(i).is_some_and(|b| is_art(*b)) {
+            for (v, x) in obj.iter_mut().zip(row) {
+                *v -= x;
+            }
+        }
+    }
+    let all: Vec<bool> = vec![true; width];
+    if n_art > 0 {
+        match simplex(&mut t, &mut basis, &mut obj, &all, budget) {
+            Step::Limit => return Outcome::Limit,
+            Step::Unbounded | Step::Optimal => {}
+        }
+        let scale = normalized.iter().map(|r| r.2.abs()).fold(1.0f64, f64::max);
+        if -obj.get(width).copied().unwrap_or(0.0) > 1e-7 * scale {
+            return Outcome::Infeasible;
+        }
+        // Drive zero-valued artificials out of the basis where possible.
+        for i in 0..m {
+            if !basis.get(i).is_some_and(|b| is_art(*b)) {
+                continue;
+            }
+            let j = t.get(i).and_then(|row| (0..ny + n_slack).find(|&j| row.get(j).is_some_and(|v| v.abs() > EPS)));
+            if let Some(j) = j {
+                pivot(&mut t, &mut obj, i, j);
+                if let Some(b) = basis.get_mut(i) {
+                    *b = j;
+                }
+            }
+        }
+    }
+    // Phase 2: the real costs; artificials may not re-enter.
+    let mut cost = vec![0.0; width + 1];
+    for (k, mp) in cols.iter().enumerate() {
+        if let Some(v) = cost.get_mut(k) {
+            *v = c.get(mp.var).copied().unwrap_or(0.0) * mp.sign;
+        }
+    }
+    let mut obj = cost.clone();
+    for (i, row) in t.iter().enumerate() {
+        let cb = basis.get(i).and_then(|b| cost.get(*b)).copied().unwrap_or(0.0);
+        if cb != 0.0 {
+            for (v, x) in obj.iter_mut().zip(row) {
+                *v -= cb * x;
+            }
+        }
+    }
+    let allowed: Vec<bool> = (0..width).map(|j| !is_art(j)).collect();
+    match simplex(&mut t, &mut basis, &mut obj, &allowed, budget) {
+        Step::Limit => return Outcome::Limit,
+        Step::Unbounded => return Outcome::Unbounded,
+        Step::Optimal => {}
+    }
+    let mut y = vec![0.0; width];
+    for (i, row) in t.iter().enumerate() {
+        if let (Some(b), Some(v)) = (basis.get(i), row.get(width))
+            && let Some(e) = y.get_mut(*b)
+        {
+            *e = *v;
+        }
+    }
+    let mut x = offset;
+    for (k, mp) in cols.iter().enumerate() {
+        if let Some(e) = x.get_mut(mp.var) {
+            *e += mp.sign * y.get(k).copied().unwrap_or(0.0);
+        }
+    }
+    let val: f64 = c.iter().zip(&x).map(|(a, b)| a * b).sum();
+    Outcome::Solved(x, val, true)
+}
+
+/// Linearises the model at `x0` (n + 1 evaluations) and checks it at one more point. Returns the
+/// objective gradient and constant, and per row the gradient and constant of `lhs − rhs`.
+#[allow(clippy::type_complexity)]
+pub(super) fn linearize(ev: &mut Evaluator, x0: &[f64]) -> std::result::Result<((Vec<f64>, f64), Vec<(Vec<f64>, f64)>), &'static str> {
+    let n = x0.len();
+    let p0 = ev.eval(x0).ok_or("budget")?;
+    if !p0.f.is_finite() || p0.g.iter().any(|v| !v.is_finite()) {
+        return Err("error");
+    }
+    let mut cf = vec![0.0; n];
+    let mut ga = vec![vec![0.0; n]; p0.g.len()];
+    for j in 0..n {
+        let mut x = x0.to_vec();
+        if let Some(v) = x.get_mut(j) {
+            *v += 1.0;
+        }
+        let p = ev.eval(&x).ok_or("budget")?;
+        if let Some(v) = cf.get_mut(j) {
+            *v = p.f - p0.f;
+        }
+        for (row, (gi, g0)) in ga.iter_mut().zip(p.g.iter().zip(&p0.g)) {
+            if let Some(v) = row.get_mut(j) {
+                *v = gi - g0;
+            }
+        }
+    }
+    let dot = |a: &[f64], x: &[f64]| a.iter().zip(x).map(|(p, q)| p * q).sum::<f64>();
+    let f_const = p0.f - dot(&cf, x0);
+    let rows: Vec<(Vec<f64>, f64)> = ga.into_iter().zip(&p0.g).map(|(a, g0)| (a.clone(), g0 - dot(&a, x0))).collect();
+    // Linearity check at a spread-out point.
+    let xt: Vec<f64> =
+        x0.iter().enumerate().map(|(j, v)| v + if j % 2 == 0 { 1.7 + 0.3 * (j % 5) as f64 } else { -0.6 - 0.2 * (j % 3) as f64 }).collect();
+    let pt = ev.eval(&xt).ok_or("budget")?;
+    let close = |actual: f64, pred: f64, terms: f64| actual.is_finite() && (actual - pred).abs() <= 1e-6 * (1.0 + actual.abs() + terms);
+    let terms = |a: &[f64]| a.iter().zip(&xt).map(|(p, q)| (p * q).abs()).sum::<f64>();
+    if !close(pt.f, f_const + dot(&cf, &xt), terms(&cf)) {
+        return Err("nonlinear");
+    }
+    for ((a, k), g) in rows.iter().zip(&pt.g) {
+        if !close(*g, k + dot(a, &xt), terms(a)) {
+            return Err("nonlinear");
+        }
+    }
+    Ok(((cf, f_const), rows))
+}
diff --git a/crates/engine/src/cmd/solver/model.rs b/crates/engine/src/cmd/solver/model.rs
new file mode 100644
index 000000000..b97eccd78
--- /dev/null
+++ b/crates/engine/src/cmd/solver/model.rs
@@ -0,0 +1,459 @@
+use super::*;
+
+// ---------------------------------------------------------------- model
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Rel {
+    Le,
+    Eq,
+    Ge,
+    Int,
+    Bin,
+}
+
+impl Rel {
+    fn parse(s: &str) -> Option<Rel> {
+        match s.trim().to_ascii_lowercase().as_str() {
+            "<=" | "≤" | "=<" | "le" => Some(Rel::Le),
+            ">=" | "≥" | "=>" | "ge" => Some(Rel::Ge),
+            "=" | "==" | "eq" => Some(Rel::Eq),
+            "int" | "integer" => Some(Rel::Int),
+            "bin" | "binary" => Some(Rel::Bin),
+            _ => None,
+        }
+    }
+    pub(super) fn text(self) -> &'static str {
+        match self {
+            Rel::Le => "<=",
+            Rel::Eq => "=",
+            Rel::Ge => ">=",
+            Rel::Int => "int",
+            Rel::Bin => "bin",
+        }
+    }
+    /// The relation code of the saved model (`solver_relN`), as in Solver's VBA `SolverAdd`.
+    fn code(self) -> u8 {
+        match self {
+            Rel::Le => 1,
+            Rel::Eq => 2,
+            Rel::Ge => 3,
+            Rel::Int => 4,
+            Rel::Bin => 5,
+        }
+    }
+    fn from_code(c: &str) -> Option<Rel> {
+        match c.trim() {
+            "1" => Some(Rel::Le),
+            "2" => Some(Rel::Eq),
+            "3" => Some(Rel::Ge),
+            "4" => Some(Rel::Int),
+            "5" => Some(Rel::Bin),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) enum Rhs {
+    None,
+    Const(f64),
+    Cells(Vec<CellRef>),
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct Constraint {
+    pub(super) lhs: Vec<CellRef>,
+    lhs_text: String,
+    pub(super) rel: Rel,
+    pub(super) rhs: Rhs,
+    rhs_text: String,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Goal {
+    Max,
+    Min,
+    Value(f64),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Method {
+    Simplex,
+    Grg,
+    Evolutionary,
+}
+
+/// The Evolutionary method's options (Solver Options › Evolutionary). The search keeps no
+/// clock, so the time without improvement is counted in generations.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct EvoOptions {
+    pub(super) population: usize,
+    pub(super) mutation: f64,
+    pub(super) seed: u64,
+    pub(super) convergence: f64,
+    pub(super) stall: u64,
+    pub(super) require_bounds: bool,
+}
+
+impl Default for EvoOptions {
+    fn default() -> EvoOptions {
+        EvoOptions { population: 100, mutation: 0.075, seed: 0, convergence: 1e-4, stall: 50, require_bounds: true }
+    }
+}
+
+fn evo_options(p: &Json) -> EvoOptions {
+    let d = EvoOptions::default();
+    let num = |k: &str| p.get(k).and_then(Json::as_f64).or_else(|| str_param(p, k).and_then(num_text)).filter(|v| v.is_finite());
+    EvoOptions {
+        population: num("populationSize").map_or(d.population, |v| v.clamp(MIN_POPULATION as f64, MAX_POPULATION as f64) as usize),
+        mutation: num("mutationRate").map_or(d.mutation, |v| v.clamp(0.0, 1.0)),
+        seed: num("randomSeed").map_or(d.seed, |v| v.clamp(0.0, f64::from(u32::MAX)) as u64),
+        convergence: num("convergence").map_or(d.convergence, |v| v.clamp(0.0, 1.0)),
+        stall: num("generationsWithoutImprovement").map_or(d.stall, |v| v.clamp(1.0, 100_000.0) as u64),
+        require_bounds: bool_param(p, "requireBounds").unwrap_or(d.require_bounds),
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct Model {
+    pub(super) sheet: usize,
+    pub(super) objective: CellRef,
+    pub(super) goal: Goal,
+    pub(super) vars: Vec<CellRef>,
+    vars_text: String,
+    pub(super) cons: Vec<Constraint>,
+    pub(super) non_negative: bool,
+    pub(super) method: Method,
+    pub(super) evo: EvoOptions,
+}
+
+/// Cells of `"B2:B4,D1"` on one sheet (row-major per area, in order), at most `cap`.
+fn cells_of(wb: &Workbook, t: &str, default_sheet: usize, cap: usize) -> Result<(usize, Vec<CellRef>)> {
+    let mut sheet = None;
+    let mut out = Vec::new();
+    for part in t.split(',').map(str::trim).filter(|x| !x.is_empty()) {
+        let (sh, body) = split_sheet(part);
+        let si = match sh {
+            Some(n) => wb.sheet_index(&n).ok_or_else(|| bad(CMD, format!("no sheet named `{n}`")))?,
+            None => default_sheet,
+        };
+        if *sheet.get_or_insert(si) != si {
+            return Err(bad(CMD, "all cells of a reference must be on one sheet"));
+        }
+        let r = RangeRef::parse(body.trim()).ok_or_else(|| bad(CMD, format!("not a reference: `{part}`")))?;
+        if r.count() > cap as u64 || out.len() + r.count() as usize > cap {
+            return Err(bad(CMD, format!("too many cells (at most {cap})")));
+        }
+        out.extend(r.iter());
+    }
+    if out.is_empty() {
+        return Err(bad(CMD, format!("not a reference: `{t}`")));
+    }
+    Ok((sheet.unwrap_or(default_sheet), out))
+}
+
+fn num_text(t: &str) -> Option<f64> {
+    gridcraft_core::parse::parse_number_text(t.trim()).filter(|v| v.is_finite())
+}
+
+/// Splits `"B5 <= 10"` / `"B2 int"` into (lhs, relation, rhs).
+fn split_constraint(t: &str) -> Option<(String, Rel, String)> {
+    for op in ["<=", ">=", "=<", "=>", "≤", "≥", "=="] {
+        if let Some((a, b)) = t.split_once(op) {
+            return Some((a.trim().into(), Rel::parse(op)?, b.trim().into()));
+        }
+    }
+    if let Some((a, b)) = t.split_once('=') {
+        return Some((a.trim().into(), Rel::Eq, b.trim().into()));
+    }
+    let lower = t.trim().to_ascii_lowercase();
+    for (suffix, rel) in [("integer", Rel::Int), ("binary", Rel::Bin), ("int", Rel::Int), ("bin", Rel::Bin)] {
+        if let Some(a) = lower.strip_suffix(suffix) {
+            let a = a.trim();
+            return Some((t.trim().get(..a.len())?.trim().to_string(), rel, String::new()));
+        }
+    }
+    None
+}
+
+fn parse_constraint(wb: &Workbook, sheet: usize, c: &Json) -> Result<Constraint> {
+    let (lhs_text, rel, rhs_json) = match c {
+        Json::String(t) => {
+            let (l, r, rhs) = split_constraint(t).ok_or_else(|| bad(CMD, format!("not a constraint: `{t}`")))?;
+            (l, r, Json::String(rhs))
+        }
+        Json::Object(_) => {
+            let lhs = str_param(c, "lhs").or_else(|| str_param(c, "cell")).or_else(|| str_param(c, "range")).unwrap_or("").to_string();
+            let op = str_param(c, "op").or_else(|| str_param(c, "relation")).unwrap_or("");
+            let rel = Rel::parse(op).ok_or_else(|| bad(CMD, format!("unknown constraint relation `{op}`")))?;
+            (lhs, rel, c.get("rhs").or_else(|| c.get("value")).cloned().unwrap_or(Json::Null))
+        }
+        _ => return Err(bad(CMD, "a constraint is a string like \"B5 <= 10\" or {lhs, op, rhs}")),
+    };
+    let (lsi, lhs) = cells_of(wb, &lhs_text, sheet, MAX_CONSTRAINTS)?;
+    if lsi != sheet {
+        return Err(EngineError::Other("Constraint cells must be on the objective cell's sheet.".into()));
+    }
+    let (rhs, rhs_text) = match rel {
+        Rel::Int | Rel::Bin => (Rhs::None, String::new()),
+        _ => match &rhs_json {
+            Json::Number(n) => {
+                let v = n.as_f64().filter(|v| v.is_finite()).ok_or_else(|| bad(CMD, "the constraint's right side must be a number"))?;
+                (Rhs::Const(v), v.to_string())
+            }
+            Json::String(t) => {
+                let t = t.trim().trim_start_matches('=').trim();
+                if let Some(v) = num_text(t) {
+                    (Rhs::Const(v), t.to_string())
+                } else {
+                    let (rsi, cells) = cells_of(wb, t, sheet, MAX_CONSTRAINTS)?;
+                    if rsi != sheet {
+                        return Err(EngineError::Other("Constraint cells must be on the objective cell's sheet.".into()));
+                    }
+                    if cells.len() != 1 && cells.len() != lhs.len() {
+                        return Err(EngineError::Other("The constraint's two sides must be the same size (or the right side one cell).".into()));
+                    }
+                    (Rhs::Cells(cells), t.to_string())
+                }
+            }
+            _ => return Err(bad(CMD, "missing the constraint's right side")),
+        },
+    };
+    Ok(Constraint { lhs, lhs_text, rel, rhs, rhs_text })
+}
+
+pub(super) fn parse_model(s: &Session, p: &Json) -> Result<Model> {
+    let d = s.doc()?;
+    let wb = &d.wb;
+    let obj_text = str_param(p, "objective").or_else(|| str_param(p, "setObjective")).or_else(|| str_param(p, "set")).unwrap_or("");
+    let (sheet, obj) = cells_of(wb, obj_text, wb.active_sheet(), 1).map_err(|_| EngineError::Other("The objective must be a single cell.".into()))?;
+    let objective = *obj.first().ok_or_else(|| EngineError::Other("The objective must be a single cell.".into()))?;
+    let sh = wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    if sh.cell(objective).is_none_or(|c| c.formula.is_none()) {
+        return Err(EngineError::Other("The objective cell must contain a formula.".into()));
+    }
+    let goal = match str_param(p, "goal").or_else(|| str_param(p, "to")).unwrap_or("max").to_ascii_lowercase().as_str() {
+        "max" | "maximize" | "maximum" => Goal::Max,
+        "min" | "minimize" | "minimum" => Goal::Min,
+        "value" | "valueof" | "value of" => {
+            let v = f64_param(p, "value")
+                .or_else(|| str_param(p, "value").and_then(num_text))
+                .filter(|v| v.is_finite())
+                .ok_or_else(|| bad(CMD, "goal `value` needs a number in `value`"))?;
+            Goal::Value(v)
+        }
+        g => return Err(bad(CMD, format!("unknown goal `{g}` (max, min or value)"))),
+    };
+    let vars_text = str_param(p, "variables").or_else(|| str_param(p, "changing")).or_else(|| str_param(p, "byChanging")).unwrap_or("").to_string();
+    let (vsi, mut vars) = cells_of(wb, &vars_text, sheet, MAX_VARS).map_err(|e| match e {
+        EngineError::BadParams { msg, .. } if msg.starts_with("too many") => {
+            EngineError::Other(format!("Too many variable cells (at most {MAX_VARS})."))
+        }
+        _ => EngineError::Other("The variable cells must be a reference like B2:B4.".into()),
+    })?;
+    if vsi != sheet {
+        return Err(EngineError::Other("The variable cells must be on the objective cell's sheet.".into()));
+    }
+    let mut seen = std::collections::HashSet::new();
+    vars.retain(|c| seen.insert(*c));
+    if vars.iter().any(|c| sh.cell(*c).is_some_and(|c| c.formula.is_some())) {
+        return Err(EngineError::Other("Variable cells must hold constants, not formulas.".into()));
+    }
+    let mut cons = Vec::new();
+    let mut scalar = 0usize;
+    if let Some(list) = p.get("constraints") {
+        let list = list.as_array().ok_or_else(|| bad(CMD, "`constraints` must be an array"))?;
+        if list.len() > MAX_CONSTRAINTS {
+            return Err(EngineError::Other(format!("Too many constraints (at most {MAX_CONSTRAINTS}).")));
+        }
+        for c in list {
+            let c = parse_constraint(wb, sheet, c)?;
+            scalar = scalar.saturating_add(c.lhs.len());
+            if scalar > MAX_CONSTRAINTS {
+                return Err(EngineError::Other(format!("Too many constraints (at most {MAX_CONSTRAINTS} cells).")));
+            }
+            if matches!(c.rel, Rel::Int | Rel::Bin) && c.lhs.iter().any(|x| !vars.contains(x)) {
+                return Err(EngineError::Other("Integer and binary constraints must be on variable cells.".into()));
+            }
+            cons.push(c);
+        }
+    }
+    let non_negative = bool_param(p, "nonNegative").unwrap_or(true);
+    let method = match str_param(p, "method").unwrap_or("grg").to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
+        "grg" | "grgnonlinear" | "nonlinear" => Method::Grg,
+        "simplex" | "simplexlp" | "lp" | "linear" => Method::Simplex,
+        "evolutionary" | "evo" | "genetic" => Method::Evolutionary,
+        m => return Err(bad(CMD, format!("unknown method `{m}` (grg, simplex or evolutionary)"))),
+    };
+    Ok(Model { sheet, objective, goal, vars, vars_text, cons, non_negative, method, evo: evo_options(p) })
+}
+
+// ---------------------------------------------------------------- saved model
+
+fn ref_text(sheet_name: &str, cells: &str) -> String {
+    let q = crate::pivot::quote_sheet(sheet_name);
+    cells
+        .split(',')
+        .map(str::trim)
+        .filter(|x| !x.is_empty())
+        .filter_map(|part| {
+            let r = RangeRef::parse(split_sheet(part).1.trim())?;
+            let abs = |c: CellRef| format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row as u64 + 1);
+            Some(if r.is_single() { format!("{q}!{}", abs(r.start)) } else { format!("{q}!{}:{}", abs(r.start), abs(r.end)) })
+        })
+        .collect::<Vec<_>>()
+        .join(",")
+}
+
+/// The model as hidden names scoped to its sheet (replacing any saved before).
+pub(super) fn save_model(wb: &mut Workbook, m: &Model) {
+    let Some(sheet_name) = wb.sheet(m.sheet).map(|s| s.name.clone()) else { return };
+    wb.names.retain(|n| !(n.scope == Some(m.sheet) && n.name.to_ascii_lowercase().starts_with("solver_")));
+    let mut put = |name: String, formula: String| {
+        wb.names.push(DefinedName { name, scope: Some(m.sheet), formula, comment: String::new(), hidden: true });
+    };
+    put("solver_opt".into(), ref_text(&sheet_name, &m.objective.a1()));
+    let (typ, val) = match m.goal {
+        Goal::Max => (1, 0.0),
+        Goal::Min => (2, 0.0),
+        Goal::Value(v) => (3, v),
+    };
+    put("solver_typ".into(), typ.to_string());
+    put("solver_val".into(), val.to_string());
+    put("solver_adj".into(), ref_text(&sheet_name, &m.vars_text));
+    for (i, c) in m.cons.iter().enumerate() {
+        let k = i + 1;
+        put(format!("solver_lhs{k}"), ref_text(&sheet_name, &c.lhs_text));
+        put(format!("solver_rel{k}"), c.rel.code().to_string());
+        let rhs = match &c.rhs {
+            Rhs::None => {
+                if c.rel == Rel::Bin {
+                    "\"binary\"".to_string()
+                } else {
+                    "\"integer\"".to_string()
+                }
+            }
+            Rhs::Const(v) => v.to_string(),
+            Rhs::Cells(_) => ref_text(&sheet_name, &c.rhs_text),
+        };
+        put(format!("solver_rhs{k}"), rhs);
+    }
+    put("solver_num".into(), m.cons.len().to_string());
+    put("solver_neg".into(), if m.non_negative { "1" } else { "2" }.into());
+    let eng = match m.method {
+        Method::Grg => "1",
+        Method::Simplex => "2",
+        Method::Evolutionary => "3",
+    };
+    put("solver_eng".into(), eng.into());
+    if m.method == Method::Evolutionary {
+        put("solver_ssz".into(), m.evo.population.to_string());
+        put("solver_mrt".into(), m.evo.mutation.to_string());
+        put("solver_rsd".into(), m.evo.seed.to_string());
+        put("solver_rbv".into(), if m.evo.require_bounds { "1" } else { "2" }.into());
+    }
+    put("solver_ver".into(), "3".into());
+}
+
+/// The saved model of a sheet as `data.solver` params, if any.
+pub fn saved_model(wb: &Workbook, sheet: usize) -> Option<Json> {
+    let get = |n: &str| {
+        wb.names
+            .iter()
+            .find(|d| d.name.eq_ignore_ascii_case(n) && (d.scope == Some(sheet) || d.scope.is_none()))
+            .map(|d| d.formula.trim().trim_start_matches('=').to_string())
+    };
+    let local = |t: String| -> String { t.split(',').map(|p| split_sheet(p.trim()).1.replace('$', "")).collect::<Vec<_>>().join(",") };
+    let objective = local(get("solver_opt")?);
+    if objective.is_empty() {
+        return None;
+    }
+    let goal = match get("solver_typ").as_deref().map(str::trim) {
+        Some("2") => "min",
+        Some("3") => "value",
+        _ => "max",
+    };
+    let value = get("solver_val").and_then(|v| num_text(&v)).unwrap_or(0.0);
+    let count = get("solver_num").and_then(|v| num_text(&v)).unwrap_or(0.0).clamp(0.0, MAX_CONSTRAINTS as f64) as usize;
+    let mut constraints = Vec::new();
+    for k in 1..=count {
+        let (Some(lhs), Some(rel)) = (get(&format!("solver_lhs{k}")), get(&format!("solver_rel{k}")).and_then(|r| Rel::from_code(&r))) else {
+            continue;
+        };
+        let lhs = local(lhs);
+        constraints.push(match rel {
+            Rel::Int | Rel::Bin => json!(format!("{lhs} {}", rel.text())),
+            _ => {
+                let rhs = get(&format!("solver_rhs{k}")).unwrap_or_default();
+                let rhs = if num_text(&rhs).is_some() { rhs } else { local(rhs) };
+                json!(format!("{lhs} {} {rhs}", rel.text()))
+            }
+        });
+    }
+    let method = match get("solver_eng").as_deref().map(str::trim) {
+        Some("2") => "simplex",
+        Some("3") => "evolutionary",
+        _ => "grg",
+    };
+    let mut model = json!({
+        "objective": objective,
+        "goal": goal,
+        "value": value,
+        "variables": get("solver_adj").map(local).unwrap_or_default(),
+        "constraints": constraints,
+        "nonNegative": get("solver_neg").as_deref().map(str::trim) != Some("2"),
+        "method": method,
+    });
+    for (name, key) in [("solver_ssz", "populationSize"), ("solver_mrt", "mutationRate"), ("solver_rsd", "randomSeed")] {
+        if let Some(v) = get(name).and_then(|v| num_text(&v)) {
+            model[key] = json!(v);
+        }
+    }
+    if let Some(v) = get("solver_rbv") {
+        model["requireBounds"] = json!(v.trim() != "2");
+    }
+    Some(model)
+}
+
+/// The model as `data.solver` params, in the form [`saved_model`] returns (the objective
+/// qualified by its sheet).
+pub(super) fn model_params(wb: &Workbook, m: &Model) -> Json {
+    let sheet = wb.sheet(m.sheet).map(|s| crate::pivot::quote_sheet(&s.name)).unwrap_or_default();
+    let (goal, value) = match m.goal {
+        Goal::Max => ("max", 0.0),
+        Goal::Min => ("min", 0.0),
+        Goal::Value(v) => ("value", v),
+    };
+    let constraints: Vec<Json> = m
+        .cons
+        .iter()
+        .map(|c| match c.rel {
+            Rel::Int | Rel::Bin => json!(format!("{} {}", c.lhs_text, c.rel.text())),
+            _ => json!(format!("{} {} {}", c.lhs_text, c.rel.text(), c.rhs_text)),
+        })
+        .collect();
+    let method = match m.method {
+        Method::Simplex => "simplex",
+        Method::Grg => "grg",
+        Method::Evolutionary => "evolutionary",
+    };
+    let mut out = json!({
+        "objective": format!("{sheet}!{}", m.objective.a1()),
+        "goal": goal,
+        "value": value,
+        "variables": m.vars_text,
+        "constraints": constraints,
+        "nonNegative": m.non_negative,
+        "method": method,
+    });
+    if m.method == Method::Evolutionary {
+        let e = &m.evo;
+        out["populationSize"] = json!(e.population);
+        out["mutationRate"] = json!(e.mutation);
+        out["randomSeed"] = json!(e.seed);
+        out["convergence"] = json!(e.convergence);
+        out["generationsWithoutImprovement"] = json!(e.stall);
+        out["requireBounds"] = json!(e.require_bounds);
+    }
+    out
+}
diff --git a/crates/engine/src/cmd/solver/nlp.rs b/crates/engine/src/cmd/solver/nlp.rs
new file mode 100644
index 000000000..6219e9b23
--- /dev/null
+++ b/crates/engine/src/cmd/solver/nlp.rs
@@ -0,0 +1,197 @@
+use super::lp::{Outcome, Row, Sense};
+use super::model::Goal;
+use super::problem::{Evaluator, Point};
+use super::*;
+
+// ---------------------------------------------------------------- nonlinear
+
+/// Augmented-Lagrangian value of a point: objective `phi` plus the constraint terms.
+fn aug(phi: f64, cons: &[f64], senses: &[Sense], lam: &[f64], mu: f64) -> f64 {
+    let mut v = phi;
+    for ((c, s), l) in cons.iter().zip(senses).zip(lam) {
+        v += match s {
+            Sense::Eq => l * c + 0.5 * mu * c * c,
+            _ => {
+                let t = (l + mu * c).max(0.0);
+                (t * t - l * l) / (2.0 * mu)
+            }
+        };
+    }
+    v
+}
+
+/// Constraint values in the `≤ 0` / `= 0` form, and the objective to minimise.
+pub(super) fn shape(p: &Point, rows: &[Row], goal: Goal) -> (f64, Vec<f64>) {
+    let phi = match goal {
+        Goal::Max => -p.f,
+        Goal::Min => p.f,
+        Goal::Value(v) => (p.f - v) * (p.f - v),
+    };
+    let cons = p.g.iter().zip(rows).map(|(g, r)| if r.sense == Sense::Ge { -g } else { *g }).collect();
+    (phi, cons)
+}
+
+pub(super) fn violation(cons: &[f64], senses: &[Sense]) -> f64 {
+    cons.iter().zip(senses).map(|(c, s)| if *s == Sense::Eq { c.abs() } else { c.max(0.0) }).fold(0.0, f64::max)
+}
+
+pub(super) fn project(x: &mut [f64], lo: &[f64], hi: &[f64]) {
+    for ((v, l), h) in x.iter_mut().zip(lo).zip(hi) {
+        if *v < *l {
+            *v = *l;
+        }
+        if *v > *h {
+            *v = *h;
+        }
+    }
+}
+
+/// Local minimisation of the model within bounds `lo..hi` from `x0`.
+pub(super) fn nlp(ev: &mut Evaluator, x0: &[f64], lo: &[f64], hi: &[f64], goal: Goal) -> Outcome {
+    let n = x0.len();
+    let rows = ev.rows.clone();
+    let senses: Vec<Sense> = rows.iter().map(|r| r.sense).collect();
+    let mut x = x0.to_vec();
+    project(&mut x, lo, hi);
+    let mut lam = vec![0.0; rows.len()];
+    let mut mu = 10.0;
+    let Some(p) = ev.eval(&x) else { return Outcome::Limit };
+    let (mut phi, mut cons) = shape(&p, &rows, goal);
+    if !phi.is_finite() {
+        return Outcome::Infeasible;
+    }
+    let phi0 = phi;
+    let mut prev_viol = violation(&cons, &senses);
+    let mut converged = false;
+    let mut out_of_budget = false;
+    let mut carried: Option<f64> = None;
+    for _outer in 0..40 {
+        // Inner: projected gradient on the augmented Lagrangian.
+        let lval = |phi: f64, cons: &[f64], lam: &[f64], mu: f64| aug(phi, cons, &senses, lam, mu);
+        let grad = |ev: &mut Evaluator, x: &[f64], lam: &[f64], mu: f64| -> Option<Vec<f64>> {
+            let mut gr = vec![0.0; n];
+            for j in 0..n {
+                let xj = x.get(j).copied().unwrap_or(0.0);
+                let h = 1e-6 * xj.abs().max(1.0);
+                let (l, u) = (lo.get(j).copied().unwrap_or(f64::NEG_INFINITY), hi.get(j).copied().unwrap_or(f64::INFINITY));
+                let (a, b) = (if xj - h >= l { xj - h } else { xj }, if xj + h <= u { xj + h } else { xj });
+                if b <= a {
+                    continue;
+                }
+                let mut xa = x.to_vec();
+                let mut xb = x.to_vec();
+                if let Some(v) = xa.get_mut(j) {
+                    *v = a;
+                }
+                if let Some(v) = xb.get_mut(j) {
+                    *v = b;
+                }
+                let (pa, ca) = shape(&ev.eval(&xa)?, &rows, goal);
+                let (pb, cb) = shape(&ev.eval(&xb)?, &rows, goal);
+                let d = (lval(pb, &cb, lam, mu) - lval(pa, &ca, lam, mu)) / (b - a);
+                if let Some(v) = gr.get_mut(j) {
+                    *v = if d.is_finite() { d } else { 0.0 };
+                }
+            }
+            Some(gr)
+        };
+        let mut l_cur = lval(phi, &cons, &lam, mu);
+        let Some(mut g) = grad(ev, &x, &lam, mu) else {
+            out_of_budget = true;
+            break;
+        };
+        // The step length carries over between outer iterations once known.
+        let gnorm = g.iter().map(|v| v.abs()).fold(0.0, f64::max);
+        let mut alpha = carried.unwrap_or(if gnorm > 0.0 { 1.0 / gnorm } else { 1.0 });
+        let mut inner_done = false;
+        let mut quiet = 0;
+        for _inner in 0..500 {
+            let mut accepted = None;
+            let mut a = alpha;
+            for _ in 0..40 {
+                let mut xn: Vec<f64> = x.iter().zip(&g).map(|(v, d)| v - a * d).collect();
+                project(&mut xn, lo, hi);
+                let Some(pn) = ev.eval(&xn) else { break };
+                let (phn, cn) = shape(&pn, &rows, goal);
+                let ln = lval(phn, &cn, &lam, mu);
+                let decrease: f64 = g.iter().zip(x.iter().zip(&xn)).map(|(d, (u, v))| d * (u - v)).sum();
+                if ln.is_finite() && ln <= l_cur - 1e-4 * decrease {
+                    accepted = Some((xn, phn, cn, ln));
+                    break;
+                }
+                a *= 0.25;
+            }
+            if ev.exhausted() {
+                out_of_budget = true;
+            }
+            let Some((xn, phn, cn, ln)) = accepted else {
+                inner_done = true;
+                break;
+            };
+            // Variables or objective running off towards infinity: unbounded.
+            if phn.abs() > 1e15 * (1.0 + phi0.abs()) || xn.iter().zip(x0).any(|(v, s)| v.abs() > 1e15 * (1.0 + s.abs())) {
+                return Outcome::Unbounded;
+            }
+            let s: Vec<f64> = xn.iter().zip(&x).map(|(a, b)| a - b).collect();
+            let step = s.iter().map(|v| v.abs()).fold(0.0, f64::max);
+            let xmax = xn.iter().map(|v| v.abs()).fold(1.0, f64::max);
+            let small = step <= 1e-10 * xmax || (l_cur - ln).abs() <= 1e-13 * (1.0 + l_cur.abs());
+            quiet = if small { quiet + 1 } else { 0 };
+            x = xn;
+            phi = phn;
+            cons = cn;
+            l_cur = ln;
+            if quiet >= 3 {
+                inner_done = true;
+                break;
+            }
+            let Some(gn) = grad(ev, &x, &lam, mu) else {
+                out_of_budget = true;
+                break;
+            };
+            // Barzilai–Borwein step.
+            let yv: Vec<f64> = gn.iter().zip(&g).map(|(a, b)| a - b).collect();
+            let sy: f64 = s.iter().zip(&yv).map(|(a, b)| a * b).sum();
+            let ss: f64 = s.iter().map(|v| v * v).sum();
+            alpha = if sy > 0.0 { (ss / sy).clamp(1e-12, 1e12) } else { (a * 4.0).min(1e12) };
+            g = gn;
+            if g.iter().all(|v| *v == 0.0) {
+                inner_done = true;
+                break;
+            }
+        }
+        carried = Some(alpha);
+        if out_of_budget {
+            break;
+        }
+        let viol = violation(&cons, &senses);
+        let scale = rows.iter().map(|r| r.rhs_const.abs()).fold(1.0, f64::max);
+        if viol <= PRECISION * scale && inner_done {
+            converged = true;
+            if rows.is_empty() {
+                break;
+            }
+        }
+        // Multiplier and penalty updates.
+        for ((l, c), s) in lam.iter_mut().zip(&cons).zip(&senses) {
+            *l = match s {
+                Sense::Eq => *l + mu * c,
+                _ => (*l + mu * c).max(0.0),
+            };
+        }
+        if viol > 0.25 * prev_viol {
+            mu = (mu * 10.0).min(1e10);
+        }
+        if converged && viol <= PRECISION * scale * 1e-2 {
+            break;
+        }
+        prev_viol = viol;
+        converged = false;
+    }
+    let viol = violation(&cons, &senses);
+    let scale = rows.iter().map(|r| r.rhs_const.abs()).fold(1.0, f64::max);
+    if viol > PRECISION * scale * 10.0 {
+        return if out_of_budget { Outcome::Limit } else { Outcome::Infeasible };
+    }
+    Outcome::Solved(x, phi, (converged || viol <= PRECISION * scale) && !out_of_budget)
+}
diff --git a/crates/engine/src/cmd/solver/problem.rs b/crates/engine/src/cmd/solver/problem.rs
new file mode 100644
index 000000000..be74a81af
--- /dev/null
+++ b/crates/engine/src/cmd/solver/problem.rs
@@ -0,0 +1,144 @@
+use super::lp::{Row, Sense};
+use super::model::{Model, Rel, Rhs};
+use super::*;
+
+/// The values the solvers see at a point: the objective and `lhs − rhs` per row.
+#[derive(Clone, Debug)]
+pub(super) struct Point {
+    pub(super) f: f64,
+    pub(super) g: Vec<f64>,
+}
+
+pub(super) struct Evaluator {
+    pub(super) trial: Trial,
+    pub(super) sheet: usize,
+    pub(super) vars: Vec<CellRef>,
+    pub(super) objective: CellRef,
+    pub(super) rows: Vec<Row>,
+    pub(super) evals: u64,
+    pub(super) budget: u64,
+    /// The Limits report: the objective is this variable itself.
+    pub(super) target: Option<usize>,
+}
+
+pub(super) fn as_num(v: &Value) -> f64 {
+    match v {
+        Value::Number(n) => *n,
+        Value::Empty => 0.0,
+        Value::Bool(b) => f64::from(u8::from(*b)),
+        _ => f64::NAN,
+    }
+}
+
+impl Evaluator {
+    pub(super) fn exhausted(&self) -> bool {
+        self.evals >= self.budget
+    }
+
+    /// Evaluates the model at `x`; `None` once the budget is spent.
+    pub(super) fn eval(&mut self, x: &[f64]) -> Option<Point> {
+        if self.exhausted() {
+            return None;
+        }
+        self.evals += 1;
+        let sets: Vec<(usize, CellRef, Value)> = self.vars.iter().zip(x).map(|(c, v)| (self.sheet, *c, Value::number(*v))).collect();
+        let mut reads = Vec::with_capacity(1 + 2 * self.rows.len());
+        reads.push((self.sheet, self.objective));
+        for r in &self.rows {
+            reads.push((self.sheet, r.lhs));
+            if let Some(c) = r.rhs {
+                reads.push((self.sheet, c));
+            }
+        }
+        let vals = self.trial.run(&sets, &reads);
+        let mut it = vals.iter().map(as_num);
+        let f = it.next().unwrap_or(f64::NAN);
+        let f = match self.target {
+            Some(j) => x.get(j).copied().unwrap_or(f64::NAN),
+            None => f,
+        };
+        let mut g = Vec::with_capacity(self.rows.len());
+        for r in &self.rows {
+            let l = it.next().unwrap_or(f64::NAN);
+            let rv = if r.rhs.is_some() { it.next().unwrap_or(f64::NAN) } else { r.rhs_const };
+            g.push(l - rv);
+        }
+        Some(Point { f, g })
+    }
+}
+
+// ---------------------------------------------------------------- problem
+
+pub(super) struct Problem {
+    pub(super) lo: Vec<f64>,
+    pub(super) hi: Vec<f64>,
+    pub(super) integer: Vec<bool>,
+    pub(super) rows: Vec<Row>,
+}
+
+/// Splits the constraints into variable bounds and general rows.
+pub(super) fn build_problem(m: &Model) -> Problem {
+    let n = m.vars.len();
+    let mut lo = vec![f64::NEG_INFINITY; n];
+    let mut hi = vec![f64::INFINITY; n];
+    let mut has_lower = vec![false; n];
+    let mut integer = vec![false; n];
+    let mut rows = Vec::new();
+    let var_index = |c: &CellRef| m.vars.iter().position(|v| v == c);
+    for c in &m.cons {
+        for (k, cell) in c.lhs.iter().enumerate() {
+            let j = var_index(cell);
+            match c.rel {
+                Rel::Int | Rel::Bin => {
+                    if let Some(j) = j {
+                        if let Some(b) = integer.get_mut(j) {
+                            *b = true;
+                        }
+                        if c.rel == Rel::Bin
+                            && let (Some(l), Some(h), Some(hl)) = (lo.get_mut(j), hi.get_mut(j), has_lower.get_mut(j))
+                        {
+                            *l = l.max(0.0);
+                            *h = h.min(1.0);
+                            *hl = true;
+                        }
+                    }
+                }
+                rel => {
+                    let sense = match rel {
+                        Rel::Le => Sense::Le,
+                        Rel::Ge => Sense::Ge,
+                        _ => Sense::Eq,
+                    };
+                    let (rhs, rhs_const) = match &c.rhs {
+                        Rhs::Const(v) => (None, *v),
+                        Rhs::Cells(cells) => (cells.get(k).or_else(|| cells.first()).copied(), 0.0),
+                        Rhs::None => (None, 0.0),
+                    };
+                    match (j, rhs) {
+                        // A constant bound on a variable cell is a box bound.
+                        (Some(j), None) => {
+                            if let (Some(l), Some(h), Some(hl)) = (lo.get_mut(j), hi.get_mut(j), has_lower.get_mut(j)) {
+                                if sense != Sense::Ge {
+                                    *h = h.min(rhs_const);
+                                }
+                                if sense != Sense::Le {
+                                    *l = l.max(rhs_const);
+                                    *hl = true;
+                                }
+                            }
+                        }
+                        _ => rows.push(Row { lhs: *cell, sense, rhs, rhs_const }),
+                    }
+                }
+            }
+        }
+    }
+    if m.non_negative {
+        for (l, hl) in lo.iter_mut().zip(&has_lower) {
+            if !hl {
+                *l = l.max(0.0);
+            }
+        }
+    }
+    Problem { lo, hi, integer, rows }
+}
diff --git a/crates/engine/src/cmd/solver/reports.rs b/crates/engine/src/cmd/solver/reports.rs
new file mode 100644
index 000000000..9f3b82866
--- /dev/null
+++ b/crates/engine/src/cmd/solver/reports.rs
@@ -0,0 +1,373 @@
+use super::lp::Outcome;
+use super::model::{Constraint, Goal, Method, Model, Rel, Rhs, parse_model, saved_model};
+use super::problem::{Evaluator, Problem, as_num, build_problem};
+use super::*;
+
+// ---------------------------------------------------------------- reports
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum ReportKind {
+    Answer,
+    Limits,
+}
+
+impl ReportKind {
+    fn title(self) -> &'static str {
+        match self {
+            ReportKind::Answer => "Answer",
+            ReportKind::Limits => "Limits",
+        }
+    }
+}
+
+/// The `reports` list (`None` when absent).
+pub(super) fn report_kinds(cmd: &'static str, p: &Json) -> Result<Option<Vec<ReportKind>>> {
+    let Some(list) = p.get("reports") else { return Ok(None) };
+    let list = list.as_array().ok_or_else(|| bad(cmd, "`reports` must be an array of answer and limits"))?;
+    let mut kinds = Vec::new();
+    for k in list {
+        let kind = match k.as_str().map(|t| t.trim().to_ascii_lowercase()).as_deref() {
+            Some("answer") => ReportKind::Answer,
+            Some("limits") => ReportKind::Limits,
+            _ => return Err(bad(cmd, format!("unknown report {k} (answer or limits)"))),
+        };
+        if !kinds.contains(&kind) {
+            kinds.push(kind);
+        }
+    }
+    Ok(Some(kinds))
+}
+
+/// A report's cells: (row, column, value, bold).
+type Lines = Vec<(u32, u32, Value, bool)>;
+
+fn abs_ref(c: CellRef) -> String {
+    format!("${}${}", gridcraft_core::col_to_letters(c.col), u64::from(c.row) + 1)
+}
+
+/// A cell's name in the reports: the nearest text to its left and the nearest text above it.
+fn cell_name(sh: &Sheet, c: CellRef) -> String {
+    let text = |c: CellRef| match sh.value(c) {
+        Value::Text(t) if !t.trim().is_empty() => Some(t.to_string()),
+        _ => None,
+    };
+    let left = (0..c.col).rev().find_map(|col| text(CellRef::new(c.row, col)));
+    let top = (0..c.row).rev().find_map(|row| text(CellRef::new(row, c.col)));
+    [left, top].into_iter().flatten().collect::<Vec<_>>().join(" ")
+}
+
+fn method_name(m: Method) -> &'static str {
+    match m {
+        Method::Simplex => "Simplex LP",
+        Method::Grg => "GRG Nonlinear",
+        Method::Evolutionary => "Evolutionary",
+    }
+}
+
+/// Header labels in bold from column 1, then the rows below them; returns the next free row.
+fn table(out: &mut Lines, row: u32, headers: &[&str], rows: Vec<Vec<Value>>) -> u32 {
+    for (k, h) in headers.iter().enumerate() {
+        out.push((row, 1 + k as u32, Value::text(*h), true));
+    }
+    let mut r = row;
+    for cells in rows {
+        r = r.saturating_add(1);
+        for (k, v) in cells.into_iter().enumerate() {
+            out.push((r, 1 + k as u32, v, false));
+        }
+    }
+    r.saturating_add(2)
+}
+
+/// Everything a report describes: the model, its starting and final values, and the result.
+pub(super) struct ReportInput<'a> {
+    pub(super) model: &'a Model,
+    pub(super) prob: &'a Problem,
+    pub(super) original: Vec<f64>,
+    pub(super) solution: Vec<f64>,
+    pub(super) message: String,
+    pub(super) budget: u64,
+}
+
+fn title(out: &mut Lines, kind: ReportKind, sheet: &str) -> u32 {
+    out.push((0, 0, Value::text(format!("GridCraft {} Report", kind.title())), true));
+    out.push((1, 0, Value::text(format!("Worksheet: {sheet}")), false));
+    3
+}
+
+fn format_constraint_row(sh: &Sheet, c: &Constraint, cell: CellRef, v: f64, rhs: &[f64], k: usize) -> Vec<Value> {
+    let (formula, status, slack) = match (c.rel, &c.rhs) {
+        (Rel::Int, _) => (format!("{}=Integer", abs_ref(cell)), "Binding", 0.0),
+        (Rel::Bin, _) => (format!("{}=Binary", abs_ref(cell)), "Binding", 0.0),
+        (rel, rhs_cells) => {
+            let b = rhs.get(k).or_else(|| rhs.first()).copied().unwrap_or(f64::NAN);
+            let rhs_text = match rhs_cells {
+                Rhs::Cells(cells) => cells.get(k).or_else(|| cells.first()).map(|c| abs_ref(*c)).unwrap_or_default(),
+                _ => gridcraft_core::number_to_text(b),
+            };
+            let slack = (v - b).abs();
+            let binding = rel == Rel::Eq || slack <= PRECISION * (1.0 + b.abs());
+            let slack = if binding { 0.0 } else { slack };
+            (format!("{}{}{rhs_text}", abs_ref(cell), rel.text()), if binding { "Binding" } else { "Not Binding" }, slack)
+        }
+    };
+    let num = |v: f64| if v.is_finite() { Value::number(v) } else { Value::Error(gridcraft_core::CellError::Value) };
+    vec![Value::text(abs_ref(cell)), Value::text(cell_name(sh, cell)), num(v), Value::text(formula), Value::text(status), num(slack)]
+}
+
+fn answer_report(d: &DocState, sh: &Sheet, inp: &ReportInput) -> Lines {
+    let m = inp.model;
+    let mut trial = Trial::new(d);
+    let read = |trial: &mut Trial, x: &[f64], cells: &[CellRef]| -> Vec<f64> {
+        let sets: Vec<(usize, CellRef, Value)> = m.vars.iter().zip(x).map(|(c, v)| (m.sheet, *c, Value::number(*v))).collect();
+        let reads: Vec<(usize, CellRef)> = cells.iter().map(|c| (m.sheet, *c)).collect();
+        trial.run(&sets, &reads).iter().map(as_num).collect()
+    };
+    let f0 = read(&mut trial, &inp.original, &[m.objective]).first().copied().unwrap_or(f64::NAN);
+    // Every cell the constraints read, at the solution.
+    let mut cells = vec![m.objective];
+    for c in &m.cons {
+        cells.extend(&c.lhs);
+        if let Rhs::Cells(r) = &c.rhs {
+            cells.extend(r);
+        }
+    }
+    let vals = read(&mut trial, &inp.solution, &cells);
+    let mut at = vals.iter().copied();
+    let f1 = at.next().unwrap_or(f64::NAN);
+    let num = |v: f64| if v.is_finite() { Value::number(v) } else { Value::Error(gridcraft_core::CellError::Value) };
+    let mut out = Lines::new();
+    let mut r = title(&mut out, ReportKind::Answer, &sh.name);
+    out.push((r, 0, Value::text(format!("Result: {}", inp.message)), false));
+    out.push((r + 1, 0, Value::text(format!("Engine: {}", method_name(m.method))), false));
+    r += 3;
+    let goal = match m.goal {
+        Goal::Max => "Max".to_string(),
+        Goal::Min => "Min".to_string(),
+        Goal::Value(v) => format!("Value Of {v}"),
+    };
+    out.push((r, 0, Value::text(format!("Objective Cell ({goal})")), true));
+    let obj = vec![vec![Value::text(abs_ref(m.objective)), Value::text(cell_name(sh, m.objective)), num(f0), num(f1)]];
+    r = table(&mut out, r + 1, &["Cell", "Name", "Original Value", "Final Value"], obj);
+    out.push((r, 0, Value::text("Variable Cells"), true));
+    let kind = |j: usize| {
+        let bin = m.cons.iter().any(|c| c.rel == Rel::Bin && m.vars.get(j).is_some_and(|v| c.lhs.contains(v)));
+        match (bin, inp.prob.integer.get(j).copied().unwrap_or(false)) {
+            (true, _) => "Binary",
+            (false, true) => "Integer",
+            _ => "Contin",
+        }
+    };
+    let vars = m
+        .vars
+        .iter()
+        .enumerate()
+        .map(|(j, c)| {
+            let (a, b) = (inp.original.get(j).copied().unwrap_or(f64::NAN), inp.solution.get(j).copied().unwrap_or(f64::NAN));
+            vec![Value::text(abs_ref(*c)), Value::text(cell_name(sh, *c)), num(a), num(b), Value::text(kind(j))]
+        })
+        .collect();
+    r = table(&mut out, r + 1, &["Cell", "Name", "Original Value", "Final Value", "Integer"], vars);
+    out.push((r, 0, Value::text("Constraints"), true));
+    let mut rows = Vec::new();
+    for c in &m.cons {
+        let lhs: Vec<f64> = c.lhs.iter().map(|_| at.next().unwrap_or(f64::NAN)).collect();
+        let rhs: Vec<f64> = match &c.rhs {
+            Rhs::Cells(cells) => cells.iter().map(|_| at.next().unwrap_or(f64::NAN)).collect(),
+            Rhs::Const(v) => vec![*v],
+            Rhs::None => vec![],
+        };
+        for (k, (cell, v)) in c.lhs.iter().zip(&lhs).enumerate() {
+            rows.push(format_constraint_row(sh, c, *cell, *v, &rhs, k));
+        }
+    }
+    table(&mut out, r + 1, &["Cell", "Name", "Cell Value", "Formula", "Status", "Slack"], rows);
+    out
+}
+
+fn limits_report(d: &DocState, sh: &Sheet, inp: &ReportInput) -> Result<Lines> {
+    let m = inp.model;
+    if inp.prob.integer.iter().any(|b| *b) {
+        return Err(EngineError::Other("The Limits report doesn't apply to models with integer or binary constraints.".into()));
+    }
+    if m.method == Method::Evolutionary {
+        return Err(EngineError::Other("The Limits report is available for Simplex LP and GRG Nonlinear.".into()));
+    }
+    let n = m.vars.len();
+    let x = &inp.solution;
+    // Each variable is minimised and maximised with the others held at the solution.
+    let per = (inp.budget / (2 * n as u64).max(1)).max(n as u64 + 3);
+    let mut ev = Evaluator {
+        trial: Trial::new(d),
+        sheet: m.sheet,
+        vars: m.vars.clone(),
+        objective: m.objective,
+        rows: inp.prob.rows.clone(),
+        evals: 0,
+        budget: 0,
+        target: None,
+    };
+    let objective_at = |ev: &mut Evaluator, x: &[f64]| {
+        ev.target = None;
+        ev.budget = ev.evals.saturating_add(1);
+        ev.eval(x).map(|p| p.f).unwrap_or(f64::NAN)
+    };
+    let num = |v: f64| if v.is_finite() { Value::number(v) } else { Value::Error(gridcraft_core::CellError::Value) };
+    let f = objective_at(&mut ev, x);
+    let mut rows = Vec::new();
+    for (j, c) in m.vars.iter().enumerate() {
+        let (mut lo, mut hi) = (x.clone(), x.clone());
+        if let (Some(l), Some(h), Some(pl), Some(ph)) = (lo.get_mut(j), hi.get_mut(j), inp.prob.lo.get(j), inp.prob.hi.get(j)) {
+            *l = *pl;
+            *h = *ph;
+        }
+        let mut ends = Vec::new();
+        for goal in [Goal::Min, Goal::Max] {
+            ev.target = Some(j);
+            ev.evals = 0;
+            ev.budget = per;
+            let solve = optimise(&mut ev, m, goal, x, &lo, &hi, &inp.prob.integer, 0.0);
+            ends.push(match solve.outcome {
+                Outcome::Solved(p, _, _) => {
+                    let v = p.get(j).copied().unwrap_or(f64::NAN);
+                    (num(v), num(objective_at(&mut ev, &p)))
+                }
+                Outcome::Unbounded => (Value::text("Unbounded"), Value::Empty),
+                _ => (Value::Error(gridcraft_core::CellError::NA), Value::Empty),
+            });
+        }
+        let mut row = vec![Value::text(abs_ref(*c)), Value::text(cell_name(sh, *c)), num(x.get(j).copied().unwrap_or(f64::NAN))];
+        for (v, o) in ends {
+            row.push(v);
+            row.push(o);
+        }
+        rows.push(row);
+    }
+    let mut out = Lines::new();
+    let r = title(&mut out, ReportKind::Limits, &sh.name);
+    let obj = vec![vec![Value::text(abs_ref(m.objective)), Value::text(cell_name(sh, m.objective)), num(f)]];
+    let r = table(&mut out, r, &["Objective Cell", "Name", "Value"], obj);
+    table(&mut out, r, &["Variable Cell", "Name", "Value", "Lower Limit", "Objective Result", "Upper Limit", "Objective Result"], rows);
+    Ok(out)
+}
+
+/// Builds every report before the solution or saved model can change.
+pub(super) fn prepare_reports(d: &DocState, kinds: &[ReportKind], inp: &ReportInput) -> Result<Vec<(String, Lines)>> {
+    if kinds.is_empty() {
+        return Ok(Vec::new());
+    }
+    if d.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    let sh = d.wb.sheet(inp.model.sheet).ok_or(EngineError::NoDocument)?;
+    let mut built = Vec::new();
+    for k in kinds {
+        let lines = match k {
+            ReportKind::Answer => answer_report(d, sh, inp),
+            ReportKind::Limits => limits_report(d, sh, inp)?,
+        };
+        let name = (1..=10_000u32)
+            .map(|i| format!("{} Report {i}", k.title()))
+            .find(|n| d.wb.sheet_index(n).is_none() && !built.iter().any(|(b, _): &(String, Lines)| b == n))
+            .ok_or_else(|| EngineError::Other("Too many report sheets.".into()))?;
+        built.push((name, lines));
+    }
+    Ok(built)
+}
+
+/// Inserts prepared reports before the model's sheet, which stays active.
+pub(super) fn write_reports(cx: &mut Ctx, at: usize, built: Vec<(String, Lines)>) -> Vec<String> {
+    let names: Vec<String> = built.iter().map(|(n, _)| n.clone()).collect();
+    let count = built.len();
+    if count == 0 {
+        return names;
+    }
+    let bold = cx.wb.styles.derive(gridcraft_model::StyleId::DEFAULT, |st| st.font.bold = true);
+    for (i, (name, lines)) in built.into_iter().enumerate() {
+        let mut sheet = Sheet::new(name);
+        for (r, c, v, b) in lines {
+            let style = if b { bold } else { gridcraft_model::StyleId::DEFAULT };
+            sheet.set_cell(CellRef::new(r, c), Cell { value: v, formula: None, style });
+        }
+        for (c, w) in [(0u32, 14.0f32), (1, 110.0), (2, 140.0), (3, 120.0), (4, 120.0), (5, 120.0), (6, 120.0), (7, 120.0)] {
+            sheet.cols.insert(c, gridcraft_model::LineInfo { size: Some(w), ..Default::default() });
+        }
+        cx.wb.sheets.insert(at + i, std::sync::Arc::new(sheet));
+    }
+    for nm in cx.wb.names.iter_mut() {
+        if let Some(sc) = nm.scope.as_mut()
+            && *sc >= at
+        {
+            *sc += count;
+        }
+    }
+    if cx.wb.active_sheet() >= at {
+        cx.wb.set_active_sheet(cx.wb.active_sheet().saturating_add(count));
+    }
+    cx.structural = true;
+    names
+}
+
+pub(super) fn insert_report_selections(s: &mut Session, at: usize, count: usize) {
+    if let Ok(d) = s.doc_mut() {
+        for i in 0..count {
+            d.sheet_selections.insert((at + i).min(d.sheet_selections.len()), crate::Selection::default());
+        }
+    }
+}
+
+/// `data.solverReport`: reports for a solution of the sheet's saved model.
+pub(super) fn report(s: &mut Session, p: &Json) -> Result<Json> {
+    let kinds = report_kinds(REPORT_CMD, p)?.ok_or_else(|| bad(REPORT_CMD, "missing `reports` (answer, limits)"))?;
+    if kinds.is_empty() {
+        return Err(bad(REPORT_CMD, "`reports` is empty (answer, limits)"));
+    }
+    let d = s.doc()?;
+    // The given model as is, else the saved model with any params given here over it.
+    let params = match p.get("model") {
+        Some(m @ Json::Object(_)) => m.clone(),
+        Some(Json::Null) | None => {
+            let mut params = saved_model(&d.wb, d.wb.active_sheet()).unwrap_or_else(|| json!({}));
+            if let (Some(base), Some(over)) = (params.as_object_mut(), p.as_object()) {
+                for (k, v) in over {
+                    base.insert(k.clone(), v.clone());
+                }
+            }
+            params
+        }
+        Some(_) => return Err(bad(REPORT_CMD, "`model` must be data.solver params")),
+    };
+    let model = parse_model(s, &params)?;
+    let prob = build_problem(&model);
+    let d = s.doc()?;
+    let sh = d.wb.sheet(model.sheet).ok_or(EngineError::NoDocument)?;
+    let current: Vec<f64> = model.vars.iter().map(|c| as_num(&sh.value(*c))).collect();
+    // `{cell: number}` maps; cells they leave out keep their current values.
+    let point = |key: &str| -> Result<Vec<f64>> {
+        let mut x = current.clone();
+        let Some(map) = p.get(key) else { return Ok(x) };
+        let map = map.as_object().ok_or_else(|| bad(REPORT_CMD, format!("`{key}` must map cells to numbers")))?;
+        for (cell, v) in map {
+            let c = CellRef::parse(&cell.replace('$', "")).ok_or_else(|| bad(REPORT_CMD, format!("not a cell: `{cell}`")))?;
+            let j = model.vars.iter().position(|v| *v == c).ok_or_else(|| bad(REPORT_CMD, format!("`{cell}` is not a variable cell")))?;
+            let v = v.as_f64().filter(|v| v.is_finite()).ok_or_else(|| bad(REPORT_CMD, format!("`{key}.{cell}` must be a number")))?;
+            if let Some(e) = x.get_mut(j) {
+                *e = v;
+            }
+        }
+        Ok(x)
+    };
+    let solution = point("values")?;
+    let original = if p.get("original").is_some() { point("original")? } else { solution.clone() };
+    let budget = params
+        .get("maxEvaluations")
+        .and_then(Json::as_f64)
+        .filter(|v| v.is_finite() && *v >= 1.0)
+        .map_or(DEFAULT_EVALS, |v| (v as u64).min(MAX_EVALS));
+    let message = str_param(p, "message").unwrap_or("").chars().take(500).collect();
+    let inp = ReportInput { model: &model, prob: &prob, original, solution, message, budget };
+    let built = prepare_reports(s.doc()?, &kinds, &inp)?;
+    let sheets = edit(s, |cx| Ok(write_reports(cx, model.sheet, built)))?;
+    insert_report_selections(s, model.sheet, sheets.len());
+    Ok(json!({"sheets": sheets}))
+}

From 5a7d2f259e0b993acb864537addc94b17cb67331 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:04:00 +0000
Subject: [PATCH 42/76] refactor(engine): move cmd/insert.rs items to
 cmd/insert/

---
 crates/engine/src/cmd/insert.rs             | 1516 +------------------
 crates/engine/src/cmd/insert/chart.rs       |  420 +++++
 crates/engine/src/cmd/insert/cond_format.rs |  339 +++++
 crates/engine/src/cmd/insert/links.rs       |  157 ++
 crates/engine/src/cmd/insert/objects.rs     |  264 ++++
 crates/engine/src/cmd/insert/table.rs       |  331 ++++
 6 files changed, 1524 insertions(+), 1503 deletions(-)
 create mode 100644 crates/engine/src/cmd/insert/chart.rs
 create mode 100644 crates/engine/src/cmd/insert/cond_format.rs
 create mode 100644 crates/engine/src/cmd/insert/links.rs
 create mode 100644 crates/engine/src/cmd/insert/objects.rs
 create mode 100644 crates/engine/src/cmd/insert/table.rs

diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs
index 8274dfeed..6dc2de5fe 100644
--- a/crates/engine/src/cmd/insert.rs
+++ b/crates/engine/src/cmd/insert.rs
@@ -10,6 +10,19 @@ use super::sheet::{rewrite, shift_cell_features};
 use super::*;
 use crate::selection::current_region;
 
+mod chart;
+mod cond_format;
+mod links;
+mod objects;
+mod table;
+
+pub use chart::{build_chart, chart_kind, recommend_charts, scatter_x_from_first, series_from_range};
+use chart::{chart_delete, chart_set, chart_switch, insert_chart};
+use cond_format::{add_cf, clear_cf, insert_icon, manage_cf};
+use links::{comment, delete_comment, insert_link, open_link, reply_comment, resolve_comment, show_note};
+use objects::{delete_object, insert_picture, insert_shape, insert_sparkline, move_object, set_anchor_mode, shape_set_text};
+use table::{format_as_table, insert_table, table_convert, table_flag, table_rename, table_style, table_total_fn};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -226,1171 +239,6 @@ fn block(s: &Session, p: &Json) -> Result<RangeRef> {
     Ok(current_region(sh, d.selection.active))
 }
 
-fn chart_areas(s: &Session, p: &Json) -> Result<Vec<RangeRef>> {
-    if p.get("range").is_some() {
-        return target_ranges(s, p);
-    }
-    let d = s.doc()?;
-    if d.selection.ranges.len() > 1 {
-        return Ok(d.selection.ranges.clone());
-    }
-    Ok(vec![block(s, p)?])
-}
-
-// ---------------------------------------------------------------- tables
-
-fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
-    let r = block(s, p)?;
-    let sheet = target_sheet(s, p)?;
-    let d = s.doc()?;
-    if d.wb.sheet(sheet).is_some_and(|sh| sh.tables.iter().any(|t| t.range.intersects(&r))) {
-        return Err(EngineError::Other("A table can't overlap another table.".into()));
-    }
-    let arrays = |sh: &gridcraft_model::Sheet| {
-        sh.cells.iter().any(|(_, x)| x.formula.as_ref().and_then(|f| f.array).is_some_and(|a| !a.is_single() && a.intersects(&r)))
-    };
-    if d.wb.sheet(sheet).is_some_and(arrays) {
-        return Err(EngineError::Other("Multi-cell array formulas aren't allowed in tables.".into()));
-    }
-    if r.count() > 50_000_000 {
-        return Err(bad("insert.table", "range too large"));
-    }
-    let header = bool_param(p, "header").unwrap_or_else(|| {
-        let sh = d.wb.sheet(sheet);
-        sh.is_some_and(|sh| (r.start.col..=r.end.col).all(|c| sh.value(CellRef::new(r.start.row, c)).is_text()) && r.height() > 1)
-    });
-    let name = str_param(p, "name")
-        .map(str::to_string)
-        .unwrap_or_else(|| (1..).map(|n| format!("Table{n}")).find(|n| d.wb.table(n).is_none()).unwrap_or_else(|| "Table".into()));
-    if !valid_table_name(&name) {
-        return Err(EngineError::Other("The name that you entered is not valid.".into()));
-    }
-    if d.wb.table(&name).is_some() || d.wb.names.iter().any(|n| n.name.eq_ignore_ascii_case(&name)) {
-        return Err(EngineError::Other("The name entered already exists. Enter a unique name.".into()));
-    }
-    // Without a header row, the data moves down a row to make room for one: never a table with it.
-    let moves_a_table = |sh: &gridcraft_model::Sheet| {
-        sh.tables.iter().any(|t| t.range.end.row >= r.start.row && t.range.start.col <= r.end.col && t.range.end.col >= r.start.col)
-    };
-    if !header && d.wb.sheet(sheet).is_some_and(moves_a_table) {
-        return Err(EngineError::Other("This operation isn't allowed: it would shift cells in a table on your worksheet.".into()));
-    }
-    let style = str_param(p, "style").unwrap_or("TableStyleMedium2").to_string();
-    let id = d.wb.next_object_id();
-    edit(s, |cx| {
-        // Without a header row, insert one with generic names.
-        let r = if header {
-            r
-        } else {
-            let sh = cx.sheet_mut(sheet)?;
-            // The header row pushes the data down one row: never off the end of the sheet.
-            let last = RangeRef::new(CellRef::new(MAX_ROWS - 1, r.start.col), CellRef::new(MAX_ROWS - 1, r.end.col));
-            if sh.cells.iter_range(last).any(|(_, x)| x.formula.is_some() || !x.value.is_empty()) {
-                return Err(EngineError::Other("To prevent possible loss of data, cells can't be pushed off the end of the worksheet.".into()));
-            }
-            sh.cells.shift_rows_in_cols(r.start.col, r.end.col, r.start.row, 1);
-            // Like Insert Cells > Shift down: move merges, conditional formats, notes, links and pictures, and re-point every formula
-            // reference (on any sheet) at the cells that moved.
-            let e = Edit::InsertCells { axis: Axis::Rows, range: RangeRef::new(r.start, CellRef::new(r.start.row, r.end.col)) };
-            shift_cell_features(sh, &e);
-            let name = sh.name.clone();
-            rewrite(&mut cx.wb, &name, &e);
-            let sh = cx.sheet_mut(sheet)?;
-            for (i, c) in (r.start.col..=r.end.col).enumerate() {
-                sh.set_value(CellRef::new(r.start.row, c), gridcraft_core::Value::text(format!("Column{}", i + 1)));
-            }
-            cx.structural = true;
-            RangeRef::new(r.start, CellRef::new((r.end.row + 1).min(MAX_ROWS - 1), r.end.col))
-        };
-        let sh = cx.sheet_mut(sheet)?;
-        let mut names: Vec<String> = Vec::new();
-        // Lower-case names taken, and the next suffix for each header, so that thousands of equal
-        // headers don't take cubic time.
-        let mut taken = std::collections::HashSet::new();
-        let mut next_suffix = std::collections::HashMap::new();
-        for c in r.start.col..=r.end.col {
-            let mut n = sh.value(CellRef::new(r.start.row, c)).display();
-            if n.is_empty() {
-                n = format!("Column{}", c - r.start.col + 1);
-            }
-            let base = n.clone();
-            let key = base.to_ascii_lowercase();
-            let mut k = next_suffix.get(&key).copied().unwrap_or(2);
-            while taken.contains(&n.to_ascii_lowercase()) {
-                n = format!("{base}{k}");
-                k += 1;
-            }
-            next_suffix.insert(key, k);
-            taken.insert(n.to_ascii_lowercase());
-            // Headers are text.
-            sh.set_value(CellRef::new(r.start.row, c), gridcraft_core::Value::text(n.as_str()));
-            names.push(n);
-        }
-        sh.tables.push(Table {
-            id,
-            name: name.clone(),
-            range: r,
-            header_row: true,
-            totals_row: false,
-            columns: names
-                .into_iter()
-                .map(|n| TableColumn { name: n, totals: TotalsFn::None, totals_label: None, formula: None, unique_name: None, xml: None })
-                .collect(),
-            style,
-            banded_rows: true,
-            banded_cols: false,
-            first_col: false,
-            last_col: false,
-            filter_button: true,
-            filter: vec![],
-            table_type: None,
-            connection_id: None,
-        });
-        cx.structural = true;
-        Ok(json!({"table": name, "range": r.a1()}))
-    })
-}
-
-/// Format as Table inside a table restyles that table, as in Excel; elsewhere it makes a new one.
-fn format_as_table(s: &mut Session, p: &Json) -> Result<Json> {
-    // Without a range, the active area decides (as in insert_table), not the first one.
-    let r = if p.get("range").is_some() { target_range(s, p)? } else { s.doc()?.selection.current() };
-    let sheet = target_sheet(s, p)?;
-    let inside = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.tables.iter().find(|t| t.range.contains_range(&r))).map(|t| (t.name.clone(), t.range));
-    match inside {
-        Some((table, range)) => {
-            table_style(s, &with(p, "table", json!(table)))?;
-            Ok(json!({"table": table, "range": range.a1()}))
-        }
-        None => insert_table(s, p),
-    }
-}
-
-fn find_table(s: &Session, p: &Json) -> Result<(usize, usize)> {
-    let d = s.doc()?;
-    if let Some(n) = str_param(p, "table") {
-        return d.wb.table(n).ok_or_else(|| bad("table", format!("no table named `{n}`")));
-    }
-    let sheet = d.wb.active_sheet();
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let ti = sh
-        .tables
-        .iter()
-        .position(|t| t.range.contains(d.selection.active))
-        .ok_or_else(|| EngineError::Disabled("table".into(), "select a cell in a table".into()))?;
-    Ok((sheet, ti))
-}
-
-fn table_flag(s: &mut Session, p: &Json, which: &str) -> Result<Json> {
-    let (si, ti) = find_table(s, p)?;
-    let on = bool_param(p, "on");
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        let Some(t) = sh.tables.get_mut(ti) else { return Ok(Json::Null) };
-        match which {
-            "totals" => {
-                let v = on.unwrap_or(!t.totals_row);
-                if v != t.totals_row {
-                    if v && t.range.end.row.saturating_add(1) >= MAX_ROWS {
-                        return Err(EngineError::Other("There's no room below the table for the total row.".into()));
-                    }
-                    t.totals_row = v;
-                    if v {
-                        t.range.end.row += 1;
-                        if let Some(first) = t.columns.first_mut() {
-                            first.totals_label = Some("Total".into());
-                        }
-                        if t.columns.len() > 1
-                            && let Some(last) = t.columns.last_mut()
-                            && last.totals == TotalsFn::None
-                        {
-                            last.totals = TotalsFn::Sum;
-                        }
-                    } else {
-                        let row = t.range.end.row;
-                        t.range.end.row = t.range.end.row.saturating_sub(1);
-                        let (c0, c1) = (t.range.start.col, t.range.end.col);
-                        for c in c0..=c1 {
-                            sh.remove_cell(CellRef::new(row, c));
-                        }
-                    }
-                    write_totals(sh, ti);
-                    cx.structural = true;
-                }
-            }
-            "bandedRows" => t.banded_rows = on.unwrap_or(!t.banded_rows),
-            "bandedCols" => t.banded_cols = on.unwrap_or(!t.banded_cols),
-            "firstCol" => t.first_col = on.unwrap_or(!t.first_col),
-            "lastCol" => t.last_col = on.unwrap_or(!t.last_col),
-            "header" => {
-                t.filter_button = on.unwrap_or(!t.filter_button);
-                if !t.filter_button {
-                    t.filter.clear();
-                }
-            }
-            _ => {}
-        }
-        Ok(Json::Null)
-    })
-}
-
-/// Writes the totals row cells (labels and SUBTOTAL formulas).
-fn write_totals(sh: &mut Sheet, ti: usize) {
-    let Some(t) = sh.tables.get(ti).cloned() else { return };
-    if !t.totals_row {
-        return;
-    }
-    let row = t.range.end.row;
-    for (i, col) in t.columns.iter().enumerate() {
-        let c = CellRef::new(row, t.range.start.col + i as u32);
-        if let Some(code) = col.totals.subtotal_code() {
-            let f = format!("=SUBTOTAL({code},{}[{}])", t.name, col.name);
-            sh.set_cell(c, Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c) });
-        } else if let Some(l) = &col.totals_label {
-            sh.set_value(c, gridcraft_core::Value::text(l.as_str()));
-        } else {
-            sh.remove_cell(c);
-        }
-    }
-}
-
-fn table_total_fn(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ti) = find_table(s, p)?;
-    let col = str_param(p, "column").ok_or_else(|| bad("table.totalFunction", "missing `column`"))?.to_string();
-    let f = match str_param(p, "function").unwrap_or("sum") {
-        "average" => TotalsFn::Average,
-        "count" => TotalsFn::Count,
-        "countNums" => TotalsFn::CountNums,
-        "max" => TotalsFn::Max,
-        "min" => TotalsFn::Min,
-        "stdDev" => TotalsFn::StdDev,
-        "var" => TotalsFn::Var,
-        "none" => TotalsFn::None,
-        _ => TotalsFn::Sum,
-    };
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        if let Some(t) = sh.tables.get_mut(ti)
-            && let Some(i) = t.column_index(&col)
-            && let Some(c) = t.columns.get_mut(i)
-        {
-            c.totals = f;
-        }
-        write_totals(sh, ti);
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-fn table_style(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ti) = find_table(s, p)?;
-    let style = str_param(p, "style").unwrap_or("TableStyleMedium2").to_string();
-    edit(s, |cx| {
-        if let Some(t) = cx.sheet_mut(si)?.tables.get_mut(ti) {
-            t.style = style.clone();
-        }
-        Ok(Json::Null)
-    })
-}
-
-/// Table names follow the Microsoft name rules, as the xlsx writer does: letters, digits, `_` and `.`,
-/// starting with a letter, `_` or `\`, and at most 255 characters. Anything else (a hyphen, say) would
-/// read as an operator inside a structured reference, and the writer would rename the table on save.
-fn valid_table_name(name: &str) -> bool {
-    name.chars().count() <= 255
-        && name.starts_with(|c: char| c.is_alphabetic() || c == '_' || c == '\\')
-        && CellRef::parse(name).is_none()
-        && !super::formulas::is_r1c1(name)
-        && name.chars().enumerate().all(|(i, c)| c.is_alphanumeric() || c == '_' || c == '.' || (i == 0 && c == '\\'))
-}
-
-fn table_rename(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ti) = find_table(s, p)?;
-    let name = str_param(p, "name").ok_or_else(|| bad("table.rename", "missing `name`"))?.to_string();
-    if !valid_table_name(&name) {
-        return Err(EngineError::Other("The name that you entered is not valid.".into()));
-    }
-    let wb = &s.doc()?.wb;
-    if wb.table(&name).is_some_and(|x| x != (si, ti)) || wb.names.iter().any(|n| n.name.eq_ignore_ascii_case(&name)) {
-        return Err(EngineError::Other("The name entered already exists. Enter a unique name.".into()));
-    }
-    edit(s, |cx| {
-        let old = cx.wb.sheet(si).and_then(|sh| sh.tables.get(ti)).map(|t| t.name.clone()).unwrap_or_default();
-        if let Some(t) = cx.sheet_mut(si)?.tables.get_mut(ti) {
-            t.name = name.clone();
-        }
-        // Structured references follow the rename.
-        for i in 0..cx.wb.sheets.len() {
-            let keys: Vec<(CellRef, std::sync::Arc<Formula>)> =
-                cx.wb.sheets.get(i).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
-            // A bare name that is also a defined name resolves to the defined name, so it is not the table.
-            let shadowed = cx.wb.name(&old, i).is_some();
-            let Some(sh) = cx.wb.sheet_mut(i) else { continue };
-            for (c, f) in keys {
-                let Some(e) = f.expr() else { continue };
-                let ne = e.map(&mut |x| match x {
-                    gridcraft_formula::Expr::Struct(mut st) if st.table.eq_ignore_ascii_case(&old) => {
-                        st.table = name.clone();
-                        gridcraft_formula::Expr::Struct(st)
-                    }
-                    gridcraft_formula::Expr::Name(n) if !shadowed && n.eq_ignore_ascii_case(&old) => gridcraft_formula::Expr::Name(name.clone()),
-                    o => o,
-                });
-                if let Some(cell) = sh.cells.get_mut(c) {
-                    cell.formula = Some(std::sync::Arc::new(Formula::from_expr(ne)));
-                }
-            }
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-fn table_convert(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ti) = find_table(s, p)?;
-    edit(s, |cx| {
-        // Apply the table look as plain formatting, then drop the table.
-        let wb = &mut cx.wb;
-        let Some(t) = wb.sheet(si).and_then(|sh| sh.tables.get(ti)).cloned() else { return Ok(Json::Null) };
-        let looks: Vec<(CellRef, Style)> = t.range.iter().map(|c| (c, crate::tables::table_cell_style(wb, si, &t, c))).collect();
-        for (c, st) in looks {
-            let id = wb.styles.intern(st);
-            if let Some(sh) = wb.sheet_mut(si) {
-                sh.set_style(c, id);
-            }
-        }
-        if let Some(sh) = wb.sheet_mut(si) {
-            sh.tables.remove(ti);
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-// ---------------------------------------------------------------- charts
-
-pub fn chart_kind(t: &str, sub: &str) -> ChartKind {
-    match (t, sub) {
-        ("column", "stacked") => ChartKind::ColumnStacked,
-        ("column", "stacked100") => ChartKind::ColumnStacked100,
-        ("bar", "stacked") => ChartKind::BarStacked,
-        ("bar", "stacked100") => ChartKind::BarStacked100,
-        ("bar", _) => ChartKind::BarClustered,
-        ("line", "markers") => ChartKind::LineMarkers,
-        ("line", "stacked") => ChartKind::LineStacked,
-        ("line", _) => ChartKind::Line,
-        ("pie", _) => ChartKind::Pie,
-        ("doughnut", _) => ChartKind::Doughnut,
-        ("area", "stacked") => ChartKind::AreaStacked,
-        ("area", "stacked100") => ChartKind::AreaStacked100,
-        ("area", _) => ChartKind::Area,
-        ("scatter", "lines") => ChartKind::ScatterLines,
-        ("scatter", _) => ChartKind::Scatter,
-        ("bubble", _) => ChartKind::Bubble,
-        ("radar", _) => ChartKind::Radar,
-        ("histogram", _) => ChartKind::Histogram,
-        ("waterfall", _) => ChartKind::Waterfall,
-        ("funnel", _) => ChartKind::Funnel,
-        ("treemap", _) => ChartKind::Treemap,
-        ("sunburst", _) => ChartKind::Sunburst,
-        ("boxWhisker", _) => ChartKind::BoxWhisker,
-        ("stock", _) => ChartKind::Stock,
-        ("combo", _) => ChartKind::Combo,
-        _ => ChartKind::ColumnClustered,
-    }
-}
-
-/// Builds series from a block: first row/column as names/categories when they're text.
-pub fn series_from_range(sh: &Sheet, r: RangeRef, by_rows: bool) -> Vec<Series> {
-    let q = gridcraft_formula::quote_sheet(&sh.name);
-    let abs = |r: RangeRef| {
-        format!(
-            "{q}!${}${}:${}${}",
-            gridcraft_core::col_to_letters(r.start.col),
-            r.start.row + 1,
-            gridcraft_core::col_to_letters(r.end.col),
-            r.end.row + 1
-        )
-    };
-    let abs1 = |c: CellRef| format!("{q}!${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1);
-    let is_text = |c: CellRef| sh.value(c).is_text() || sh.value(c).is_empty();
-    let header_row = r.height() > 1
-        && (r.start.col..=r.end.col).any(|c| sh.value(CellRef::new(r.start.row, c)).is_text())
-        && (r.start.col..=r.end.col).filter(|c| *c != r.start.col).all(|c| is_text(CellRef::new(r.start.row, c)));
-    // A blank top-left cell above a header row marks the first column as the category labels even
-    // when it holds numbers (years, X values), the usual spreadsheet convention, so it isn't
-    // plotted as a series of its own (#287).
-    let blank_corner = header_row && sh.value(r.start).is_empty();
-    let label_col =
-        r.width() > 1 && (blank_corner || (r.start.row + header_row as u32..=r.end.row).all(|row| is_text(CellRef::new(row, r.start.col))));
-    let data = RangeRef::new(CellRef::new(r.start.row + header_row as u32, r.start.col + label_col as u32), r.end);
-    let mut out = Vec::new();
-    if !by_rows {
-        for c in data.start.col..=data.end.col {
-            out.push(Series {
-                name: header_row.then(|| abs1(CellRef::new(r.start.row, c))),
-                categories: label_col.then(|| abs(RangeRef::new(CellRef::new(data.start.row, r.start.col), CellRef::new(data.end.row, r.start.col)))),
-                values: abs(RangeRef::new(CellRef::new(data.start.row, c), CellRef::new(data.end.row, c))),
-                bubble_sizes: None,
-                color: None,
-                secondary: false,
-                kind: None,
-                quartiles: Default::default(),
-                smooth: false,
-                trendlines: Vec::new(),
-            });
-        }
-    } else {
-        for row in data.start.row..=data.end.row {
-            out.push(Series {
-                name: label_col.then(|| abs1(CellRef::new(row, r.start.col))),
-                categories: header_row
-                    .then(|| abs(RangeRef::new(CellRef::new(r.start.row, data.start.col), CellRef::new(r.start.row, data.end.col)))),
-                values: abs(RangeRef::new(CellRef::new(row, data.start.col), CellRef::new(row, data.end.col))),
-                bubble_sizes: None,
-                color: None,
-                secondary: false,
-                kind: None,
-                quartiles: Default::default(),
-                smooth: false,
-                trendlines: Vec::new(),
-            });
-        }
-    }
-    out
-}
-
-fn series_from_areas(sh: &Sheet, areas: &[RangeRef]) -> Result<(RangeRef, bool, Vec<Series>)> {
-    let Some(first) = areas.first().copied() else { return Err(EngineError::Other("Select data for the chart first.".into())) };
-    let bounds = areas.iter().skip(1).fold(first, |r, area| r.union(area));
-    if areas.len() == 1 {
-        let by_rows = first.width() > first.height() + 1;
-        return Ok((bounds, by_rows, series_from_range(sh, first, by_rows)));
-    }
-    let valid_shape = first.width() == 1
-        && first.height() > 1
-        && areas.iter().skip(1).all(|area| area.width() == 1 && area.height() == first.height())
-        && first.iter().all(|cell| sh.value(cell).is_text() || sh.value(cell).is_empty());
-    if !valid_shape {
-        return Err(bad("insert.chart", "multi-area charts require a text category column followed by equal-height series columns"));
-    }
-    let category = series_from_range(sh, first, false).into_iter().next().map(|series| series.values);
-    let mut series = Vec::with_capacity(areas.len() - 1);
-    for area in &areas[1..] {
-        let mut area_series = series_from_range(sh, *area, false);
-        let Some(mut item) = area_series.pop() else {
-            return Err(EngineError::Other("Select data for the chart first.".into()));
-        };
-        if item.name.is_none() {
-            return Err(bad("insert.chart", "multi-area series columns require headers"));
-        }
-        item.categories = category.clone();
-        series.push(item);
-    }
-    Ok((bounds, false, series))
-}
-
-/// A scatter plot of a block without category labels takes its first column (or row) as the X
-/// values of the others, as Excel does: two plain columns make one series of points, not two (#428).
-pub fn scatter_x_from_first(kind: ChartKind, series: &mut Vec<Series>) {
-    if matches!(kind, ChartKind::Scatter | ChartKind::ScatterLines) && series.len() > 1 && series[0].categories.is_none() {
-        let x = series.remove(0).values;
-        for se in series.iter_mut() {
-            se.categories = Some(x.clone());
-        }
-    }
-}
-
-/// Most cells a chart's source block may span (bounds the series it builds).
-const MAX_CHART_CELLS: u64 = 1_000_000;
-
-/// Chart types that suit the shape of the data, best first, as `(type, subtype, label)` for
-/// `insert.chart`. Our own heuristic from the shape of the block (series count, points per
-/// series, text categories, negative values), not a copy of Excel's ranking: two numeric columns
-/// without labels → scatter; one short series → column, pie, bar; long series → line; several
-/// series → clustered and stacked columns and bars, line.
-pub fn recommend_charts(s: &Session, p: &Json) -> Result<Vec<(&'static str, &'static str, &'static str)>> {
-    let areas = chart_areas(s, p)?;
-    if areas.iter().fold(0_u64, |count, area| count.saturating_add(area.count())) > MAX_CHART_CELLS {
-        return Err(bad("insert.chart", "range too large for a chart"));
-    }
-    let sheet = target_sheet(s, p)?;
-    let d = s.doc()?;
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let (_, by_rows, series) = series_from_areas(sh, &areas)?;
-    let ranges: Vec<RangeRef> = series
-        .iter()
-        .filter_map(|x| match gridcraft_formula::parse(&x.values) {
-            Ok(gridcraft_formula::Expr::Ref(rf)) => Some(rf.range()),
-            _ => None,
-        })
-        .collect();
-    let points = ranges.first().map_or(0, RangeRef::count);
-    let (mut any_number, mut non_negative) = (false, true);
-    for n in ranges.iter().flat_map(|rr| rr.iter()).filter_map(|c| sh.value(c).as_f64()) {
-        any_number = true;
-        non_negative &= n >= 0.0;
-    }
-    if series.is_empty() || !any_number {
-        return Err(EngineError::Other("Select data for the chart first.".into()));
-    }
-    let labelled = series.first().is_some_and(|x| x.categories.is_some());
-    const COLUMN: (&str, &str, &str) = ("column", "", "Clustered Column");
-    const BAR: (&str, &str, &str) = ("bar", "", "Clustered Bar");
-    const LINE: (&str, &str, &str) = ("line", "", "Line");
-    const LINE_MARKERS: (&str, &str, &str) = ("line", "markers", "Line with Markers");
-    const PIE: (&str, &str, &str) = ("pie", "", "Pie");
-    const DOUGHNUT: (&str, &str, &str) = ("doughnut", "", "Doughnut");
-    const AREA: (&str, &str, &str) = ("area", "", "Area");
-    const SCATTER: (&str, &str, &str) = ("scatter", "", "Scatter");
-    const STACKED_COLUMN: (&str, &str, &str) = ("column", "stacked", "Stacked Column");
-    const STACKED_BAR: (&str, &str, &str) = ("bar", "stacked", "Stacked Bar");
-    let mut out = Vec::new();
-    if series.len() == 2 && !labelled && !by_rows {
-        out.extend([SCATTER, LINE_MARKERS, COLUMN]);
-    } else if series.len() == 1 {
-        if points > 12 {
-            out.extend([LINE, COLUMN, AREA]);
-        } else {
-            out.extend([COLUMN, BAR]);
-            if non_negative && points >= 2 {
-                out.extend([PIE, DOUGHNUT]);
-            }
-            out.push(LINE_MARKERS);
-        }
-    } else if points > 12 {
-        out.extend([LINE, COLUMN, AREA, STACKED_COLUMN]);
-    } else {
-        out.extend([COLUMN, BAR, STACKED_COLUMN, LINE_MARKERS, STACKED_BAR]);
-    }
-    Ok(out)
-}
-
-/// The chart `insert.chart` would insert for these params, without inserting it: the sheet it
-/// goes on and the chart (previews in the Recommended Charts dialog).
-pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> {
-    let areas = chart_areas(s, p)?;
-    if areas.iter().fold(0_u64, |count, area| count.saturating_add(area.count())) > MAX_CHART_CELLS {
-        return Err(bad("insert.chart", "range too large for a chart"));
-    }
-    let mut t = str_param(p, "type").unwrap_or("column").to_string();
-    let mut sub = str_param(p, "subtype").unwrap_or("").to_string();
-    if t == "auto" {
-        let first = recommend_charts(s, p)?.into_iter().next().unwrap_or(("column", "", ""));
-        t = first.0.into();
-        sub = first.1.into();
-    }
-    let sheet = target_sheet(s, p)?;
-    let d = s.doc()?;
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let kind = chart_kind(&t, &sub);
-    let (bounds, by_rows, mut series) = series_from_areas(sh, &areas)?;
-    if series.is_empty() {
-        return Err(EngineError::Other("Select data for the chart first.".into()));
-    }
-    scatter_x_from_first(kind, &mut series);
-    let id = d.wb.next_object_id();
-    let at = cell_param_on(s, p, "at", sheet)?.unwrap_or_else(|| CellRef::new(bounds.start.row, bounds.end.col + 2));
-    let title = str_param(p, "title").map(str::to_string).or_else(|| {
-        if series.len() == 1 {
-            series[0].name.as_ref().map(|n| gridcraft_calc::evaluate(&d.wb, sheet, at, n).display())
-        } else {
-            Some("Chart Title".into())
-        }
-    });
-    let chart = Chart {
-        id,
-        kind,
-        anchor: Anchor {
-            cell: at,
-            dx: 0.0,
-            dy: 0.0,
-            width: f64_param(p, "width").unwrap_or(480.0) as f32,
-            height: f64_param(p, "height").unwrap_or(288.0) as f32,
-            mode: anchor_mode_param(p).unwrap_or_default(),
-        },
-        title,
-        series,
-        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
-        data_labels: false,
-        gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
-        style: 1,
-        x_title: None,
-        y_title: None,
-        source: (areas.len() == 1).then(|| format!("{}!{}", gridcraft_formula::quote_sheet(&sh.name), bounds.a1())),
-        by_rows,
-        pivot: None,
-    };
-    Ok((sheet, chart))
-}
-
-fn insert_chart(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, chart) = build_chart(s, p)?;
-    let id = chart.id;
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.charts.push(chart);
-        Ok(json!({"chart": id}))
-    })
-}
-
-fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
-    let d = s.doc()?;
-    let sheet = d.wb.active_sheet();
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let idx = match u32_param(p, "chart") {
-        Some(id) => sh.charts.iter().position(|c| c.id == id),
-        None => sh.charts.len().checked_sub(1),
-    };
-    idx.map(|i| (sheet, i)).ok_or_else(|| bad("chart", "no such chart"))
-}
-
-fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ci) = find_chart(s, p)?;
-    let at = cell_param_on(s, p, "at", si)?;
-    let quartiles = p
-        .get("quartiles")
-        .map(|v| match v.as_str() {
-            Some("exclusive") => Ok(gridcraft_model::QuartileMethod::Exclusive),
-            Some("inclusive") => Ok(gridcraft_model::QuartileMethod::Inclusive),
-            _ => Err(bad("quartiles", "expected exclusive or inclusive")),
-        })
-        .transpose()?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        let Some(c) = sh.charts.get_mut(ci) else { return Ok(Json::Null) };
-        if let Some(t) = str_param(p, "type") {
-            c.kind = chart_kind(t, str_param(p, "subtype").unwrap_or(""));
-        }
-        if let Some(method) = quartiles {
-            for series in &mut c.series {
-                series.quartiles = method;
-            }
-        }
-        if let Some(t) = p.get("title") {
-            c.title = t.as_str().map(str::to_string);
-        }
-        if let Some(l) = str_param(p, "legend") {
-            c.legend = match l {
-                "none" => LegendPos::None,
-                "top" => LegendPos::Top,
-                "left" => LegendPos::Left,
-                "right" => LegendPos::Right,
-                _ => LegendPos::Bottom,
-            };
-        }
-        if let Some(v) = bool_param(p, "dataLabels") {
-            c.data_labels = v;
-        }
-        if let Some(v) = bool_param(p, "gridlines") {
-            c.gridlines = v;
-        }
-        if let Some(v) = u32_param(p, "style") {
-            c.style = v.clamp(1, 16);
-        }
-        if let Some(t) = p.get("xTitle") {
-            c.x_title = t.as_str().map(str::to_string);
-        }
-        if let Some(t) = p.get("yTitle") {
-            c.y_title = t.as_str().map(str::to_string);
-        }
-        if let Some(at) = at {
-            c.anchor.cell = at;
-        }
-        if let Some(w) = f64_param(p, "width") {
-            c.anchor.width = w.clamp(20.0, 10000.0) as f32;
-        }
-        if let Some(h) = f64_param(p, "height") {
-            c.anchor.height = h.clamp(20.0, 10000.0) as f32;
-        }
-        if let Some(v) = f64_param(p, "dx") {
-            c.anchor.dx = v as f32;
-        }
-        if let Some(v) = f64_param(p, "dy") {
-            c.anchor.dy = v as f32;
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn chart_switch(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ci) = find_chart(s, p)?;
-    edit(s, |cx| {
-        let Some(sh) = cx.wb.sheet(si) else { return Ok(Json::Null) };
-        let Some(c) = sh.charts.get(ci) else { return Ok(Json::Null) };
-        // Charts read from a file have no source range: take the block their series span.
-        let Some((src, by_rows)) = c.source.clone().map(|s| (s, c.by_rows)).or_else(|| series_block(&c.series)) else { return Ok(Json::Null) };
-        let (sheet_name, body) = split_sheet(&src);
-        let src_sheet = sheet_name.and_then(|n| cx.wb.sheet_index(&n)).unwrap_or(si);
-        let Some(mut r) = RangeRef::parse(body) else { return Ok(Json::Null) };
-        let Some(ssh) = cx.wb.sheet(src_sheet) else { return Ok(Json::Null) };
-        // Whole-column/row references (common in files) span a million cells: clip the block's
-        // far edges to the cells in use, then refuse anything still too large to chart.
-        if let Some(used) = ssh.used_range() {
-            r.end.row = r.end.row.min(used.end.row).max(r.start.row);
-            r.end.col = r.end.col.min(used.end.col).max(r.start.col);
-        }
-        if r.count() > MAX_CHART_CELLS {
-            return Err(bad("chart.switchRowColumn", "range too large for a chart"));
-        }
-        let by_rows = !by_rows;
-        let series = series_from_range(ssh, r, by_rows);
-        if let Some(c) = cx.sheet_mut(si)?.charts.get_mut(ci) {
-            c.source.get_or_insert(src);
-            c.by_rows = by_rows;
-            c.series = series;
-            scatter_x_from_first(c.kind, &mut c.series);
-        }
-        Ok(Json::Null)
-    })
-}
-
-/// The block a chart's series come from, and whether each series is a row of it: the bounding
-/// range of the series names, categories and values, when they're all references to one sheet.
-fn series_block(series: &[Series]) -> Option<(String, bool)> {
-    let mut sheet: Option<String> = None;
-    let mut bounds: Option<RangeRef> = None;
-    let mut rows = 0;
-    for s in series {
-        for (i, f) in [Some(&s.values), s.categories.as_ref(), s.name.as_ref()].into_iter().flatten().enumerate() {
-            let Ok(gridcraft_formula::Expr::Ref(r)) = gridcraft_formula::parse(f) else { return None };
-            let gridcraft_formula::SheetSel::Named(n) = &r.sheet else { return None };
-            if !sheet.get_or_insert_with(|| n.clone()).eq_ignore_ascii_case(n) {
-                return None;
-            }
-            let range = r.range();
-            if i == 0 && range.height() == 1 && range.width() > 1 {
-                rows += 1;
-            }
-            bounds = Some(bounds.map_or(range, |b| b.union(&range)));
-        }
-    }
-    Some((format!("{}!{}", gridcraft_formula::quote_sheet(&sheet?), bounds?.a1()), rows > 0 && rows == series.len()))
-}
-
-fn chart_delete(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ci) = find_chart(s, p)?;
-    edit(s, |cx| {
-        cx.sheet_mut(si)?.charts.remove(ci);
-        Ok(Json::Null)
-    })
-}
-
-fn insert_sparkline(s: &mut Session, p: &Json) -> Result<Json> {
-    let src = str_param(p, "range").ok_or_else(|| bad("insert.sparkline", "missing `range`"))?.to_string();
-    let loc = cell_param(s, p, "location")?.ok_or_else(|| bad("insert.sparkline", "missing `location`"))?;
-    let kind = match str_param(p, "type") {
-        Some("column") => SparklineKind::Column,
-        Some("winLoss") => SparklineKind::WinLoss,
-        _ => SparklineKind::Line,
-    };
-    let markers = bool_param(p, "markers").unwrap_or(false);
-    let sheet = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        sh.sparklines.retain(|x| x.cell != loc);
-        sh.sparklines.push(Sparkline { cell: loc, source: src.clone(), kind, color: Color::Theme(4, 0), markers });
-        Ok(Json::Null)
-    })
-}
-
-fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
-    let placement = str_param(p, "placement").unwrap_or("overCells");
-    if !matches!(placement, "cell" | "overCells") {
-        return Err(bad("insert.picture", "placement must be cell or overCells"));
-    }
-    let data = if let Some(b) = str_param(p, "base64") {
-        crate::io::base64_decode(b).ok_or_else(|| bad("insert.picture", "invalid base64"))?
-    } else if let Some(path) = str_param(p, "path") {
-        crate::io::read_file(path)?
-    } else {
-        s.ui_requests.push(crate::UiRequest::Dialog("insertPicture".into(), json!({"placement": placement})));
-        return ok();
-    };
-    if placement == "cell" {
-        let mime = validate_cell_picture(&data)?;
-        let d = s.doc()?;
-        let sheet = d.wb.active_sheet();
-        let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-        let at = match str_param(p, "at") {
-            Some(a) => CellRef::parse(a).ok_or_else(|| bad("insert.picture", "invalid cell address"))?,
-            None => d.selection.active,
-        };
-        let at = sh.merge_at(at).map(|r| r.start).unwrap_or(at);
-        let style = sh.style_id(at);
-        if sh.is_protected() && d.wb.styles.get(style).protection.locked && locked_cell_error(sh, at, &d.unlocked_ranges).is_some() {
-            return Err(EngineError::Other("The cell you're trying to change is on a protected sheet.".into()));
-        }
-        let picture = CellPicture { data, mime: mime.into(), alt: str_param(p, "alt").unwrap_or("").into() };
-        return edit(s, |cx| {
-            cx.sheet_mut(sheet)?.set_picture(at, std::sync::Arc::new(picture));
-            cx.touch(sheet, at);
-            Ok(json!({"cell": at.a1(), "placement": "cell"}))
-        });
-    }
-    if data.len() > 64 * 1024 * 1024 {
-        return Err(bad("insert.picture", "image larger than 64 MB"));
-    }
-    let mime = str_param(p, "mime")
-        .map(str::to_string)
-        .unwrap_or_else(|| if data.starts_with(&[0x89, b'P', b'N', b'G']) { "image/png".into() } else { "image/jpeg".into() });
-    let (w, h) = crate::io::image_size(&data).unwrap_or((320, 240));
-    let d = s.doc()?;
-    let id = d.wb.next_object_id();
-    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
-    let scale = (640.0 / w.max(1) as f32).min(1.0);
-    let img = Image {
-        id,
-        anchor: Anchor {
-            cell: at,
-            dx: 0.0,
-            dy: 0.0,
-            width: f64_param(p, "width").map(|v| v as f32).unwrap_or(w as f32 * scale),
-            height: f64_param(p, "height").map(|v| v as f32).unwrap_or(h as f32 * scale),
-            // Excel inserts pictures as "Move but don't size with cells" (`editAs="oneCell"`).
-            mode: anchor_mode_param(p).unwrap_or(gridcraft_model::AnchorMode::MoveOnly),
-        },
-        data: data.into(),
-        mime,
-        alt: str_param(p, "alt").unwrap_or("").into(),
-    };
-    let sheet = d.wb.active_sheet();
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.images.push(img);
-        Ok(json!({"image": id}))
-    })
-}
-
-/// Validate before mutating the workbook; header dimensions alone do not prove the pixels decode.
-fn validate_cell_picture(data: &[u8]) -> Result<&'static str> {
-    if data.len() > 16 * 1024 * 1024 {
-        return Err(bad("insert.picture", "cell pictures must be at most 16 MiB"));
-    }
-    let format = image::guess_format(data).map_err(|_| bad("insert.picture", "choose a valid PNG or JPEG picture"))?;
-    let mime = match format {
-        image::ImageFormat::Png => "image/png",
-        image::ImageFormat::Jpeg => "image/jpeg",
-        _ => return Err(bad("insert.picture", "cell pictures support PNG and JPEG")),
-    };
-    let (width, height) = image::ImageReader::with_format(std::io::Cursor::new(data), format)
-        .into_dimensions()
-        .map_err(|_| bad("insert.picture", "invalid image dimensions"))?;
-    if width == 0 || height == 0 || width > 8192 || height > 8192 || u64::from(width) * u64::from(height) > 16_000_000 {
-        return Err(bad("insert.picture", "cell pictures are limited to 8192 pixels per side and 16 million pixels"));
-    }
-    let mut reader = image::ImageReader::with_format(std::io::Cursor::new(data), format);
-    let mut limits = image::Limits::default();
-    limits.max_image_width = Some(8192);
-    limits.max_image_height = Some(8192);
-    limits.max_alloc = Some(64 * 1024 * 1024);
-    reader.limits(limits);
-    reader.decode().map_err(|_| bad("insert.picture", "picture cannot be decoded within the 64 MiB limit"))?;
-    Ok(mime)
-}
-
-fn insert_shape(s: &mut Session, p: &Json) -> Result<Json> {
-    let kind = match str_param(p, "kind").unwrap_or("rectangle") {
-        "roundedRectangle" => ShapeKind::RoundedRectangle,
-        "ellipse" | "oval" => ShapeKind::Ellipse,
-        "triangle" => ShapeKind::Triangle,
-        "line" => ShapeKind::Line,
-        "arrow" => ShapeKind::Arrow,
-        "textBox" => ShapeKind::TextBox,
-        _ => ShapeKind::Rectangle,
-    };
-    let d = s.doc()?;
-    let id = d.wb.next_object_id();
-    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
-    let fill =
-        super::format::color_param(p.get("fill")).unwrap_or(if kind == ShapeKind::TextBox { Color::rgb(255, 255, 255) } else { Color::Theme(4, 0) });
-    let line = super::format::color_param(p.get("line")).unwrap_or(if kind == ShapeKind::TextBox {
-        Color::rgb(0x80, 0x80, 0x80)
-    } else {
-        Color::Theme(4, -250)
-    });
-    let shape = Shape {
-        id,
-        kind,
-        anchor: Anchor {
-            cell: at,
-            dx: 0.0,
-            dy: 0.0,
-            width: f64_param(p, "width").unwrap_or(144.0) as f32,
-            height: f64_param(p, "height").unwrap_or(if kind == ShapeKind::Line { 0.0 } else { 96.0 }) as f32,
-            mode: anchor_mode_param(p).unwrap_or_default(),
-        },
-        fill,
-        line,
-        text: str_param(p, "text").unwrap_or("").into(),
-        format: Default::default(),
-    };
-    let sheet = d.wb.active_sheet();
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.shapes.push(shape);
-        Ok(json!({"shape": id}))
-    })
-}
-
-/// A text box holds at most as many characters as a cell.
-const SHAPE_TEXT_MAX_CHARS: usize = 32_767;
-
-fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
-    let id =
-        p.get("id").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok()).ok_or_else(|| bad("shape.setText", "`id` must be a text box id"))?;
-    let text = str_param(p, "text").ok_or_else(|| bad("shape.setText", "`text` must be a string"))?;
-    if text.chars().nth(SHAPE_TEXT_MAX_CHARS).is_some() {
-        return Err(bad("shape.setText", "`text` is longer than 32,767 characters"));
-    }
-    let d = s.doc()?;
-    let sheet = d.wb.active_sheet();
-    let sh = d.wb.active().ok_or_else(|| bad("shape.setText", "no such text box"))?;
-    let shape = sh.shapes.iter().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
-    if shape.kind != ShapeKind::TextBox {
-        return Err(bad("shape.setText", "the shape is not a text box"));
-    }
-    // Sheet protection locks drawing objects (there is no "edit objects" allowance yet).
-    if sh.is_protected() {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
-    if shape.text == text {
-        return ok();
-    }
-    edit(s, |cx| {
-        let shape = cx.sheet_mut(sheet)?.shapes.iter_mut().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
-        shape.text = text.into();
-        Ok(Json::Null)
-    })
-}
-
-fn delete_object(s: &mut Session, p: &Json) -> Result<Json> {
-    let id = u32_param(p, "id").ok_or_else(|| bad("object.delete", "missing `id`"))?;
-    let kind = str_param(p, "kind").unwrap_or("").to_string();
-    let sheet = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        match kind.as_str() {
-            "chart" => sh.charts.retain(|c| c.id != id),
-            "image" => sh.images.retain(|c| c.id != id),
-            "slicer" => sh.slicers.retain(|c| c.id != id),
-            _ => sh.shapes.retain(|c| c.id != id),
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
-    let id = u32_param(p, "id").ok_or_else(|| bad("object.move", "missing `id`"))?;
-    let kind = str_param(p, "kind").unwrap_or("").to_string();
-    let sheet = s.doc()?.wb.active_sheet();
-    let at = cell_param(s, p, "at")?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        let anchor = match kind.as_str() {
-            "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-            "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-            "slicer" => sh.slicers.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-            "shape" => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-            _ => None,
-        };
-        let Some(a) = anchor else { return Err(bad("object.move", "no such object")) };
-        if let Some(at) = at {
-            a.cell = at;
-        }
-        if let Some(v) = f64_param(p, "dx") {
-            a.dx = v as f32;
-        }
-        if let Some(v) = f64_param(p, "dy") {
-            a.dy = v as f32;
-        }
-        if let Some(v) = f64_param(p, "width") {
-            a.width = v.clamp(1.0, 10000.0) as f32;
-        }
-        if let Some(v) = f64_param(p, "height") {
-            a.height = v.clamp(0.0, 10000.0) as f32;
-        }
-        Ok(Json::Null)
-    })
-}
-
-/// Sets an object's anchor mode (Excel's "Move and size with cells" / "Move but don't size with
-/// cells" / "Don't move or size with cells"), so it follows — or ignores — its rows and columns
-/// when the sheet is sorted or edited structurally.
-fn set_anchor_mode(s: &mut Session, p: &Json) -> Result<Json> {
-    let id = u32_param(p, "id").ok_or_else(|| bad("object.setAnchorMode", "missing `id`"))?;
-    let kind = str_param(p, "kind").unwrap_or("").to_string();
-    if !matches!(kind.as_str(), "chart" | "image" | "shape") {
-        return Err(bad("object.setAnchorMode", "kind must be chart, image or shape"));
-    }
-    let mode = anchor_mode_param(p).ok_or_else(|| bad("object.setAnchorMode", "mode must be moveAndSize, moveOnly or absolute"))?;
-    let sheet = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        let anchor = match kind.as_str() {
-            "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-            "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-            _ => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
-        };
-        let Some(a) = anchor else { return Err(bad("object.setAnchorMode", "no such object")) };
-        a.mode = mode;
-        Ok(json!({"mode": anchor_mode_name(mode)}))
-    })
-}
-
-// ---------------------------------------------------------------- links & comments
-
-fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
-    if bool_param(p, "remove").unwrap_or(false) {
-        return edit(s, |cx| {
-            cx.sheet_mut(sheet)?.hyperlinks.remove(&at);
-            Ok(Json::Null)
-        });
-    }
-    let Some(target) = str_param(p, "target").map(str::to_string) else {
-        s.ui_requests.push(crate::UiRequest::Dialog("insertLink".into(), json!({})));
-        return ok();
-    };
-    let text = str_param(p, "text").map(str::to_string);
-    let tooltip = str_param(p, "tooltip").map(str::to_string);
-    let external = links_outside(&s.doc()?.wb, sheet, &target);
-    edit(s, |cx| {
-        let link_style = cx.wb.styles.derive(cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(), |st| {
-            st.font.color = Color::Theme(10, 0);
-            st.font.underline = Underline::Single;
-        });
-        let sh = cx.sheet_mut(sheet)?;
-        if let Some(t) = text.clone().or_else(|| sh.value(at).is_empty().then(|| target.clone())) {
-            sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style });
-        } else {
-            sh.set_style(at, link_style);
-        }
-        sh.hyperlinks.insert(at, Hyperlink { target: target.clone(), tooltip: tooltip.clone(), external });
-        cx.touch(sheet, at);
-        Ok(Json::Null)
-    })
-}
-
-/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the
-/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no
-/// dialog; the interactive click asks for confirmation first, in the UI.
-fn open_link(s: &mut Session, p: &Json) -> Result<Json> {
-    let target = match str_param(p, "url").or_else(|| str_param(p, "target")) {
-        Some(t) => t.to_string(),
-        None => {
-            let sheet = target_sheet(s, p)?;
-            let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
-            let Some(h) = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.hyperlinks.get(&at)) else {
-                return Err(EngineError::Other("There's no hyperlink in this cell.".into()));
-            };
-            h.target.clone()
-        }
-    };
-    match crate::links::classify(&target) {
-        crate::links::LinkKind::Internal(r) => super::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})),
-        crate::links::LinkKind::External(u) => {
-            s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone()));
-            Ok(json!({"opened": u}))
-        }
-        crate::links::LinkKind::Refused(why) => Err(EngineError::Other(why)),
-    }
-}
-
-/// Sorts a link target as the two pages of Excel's Insert Hyperlink dialog do: "Place in This
-/// Document" is a sheet reference, a defined name or `#…`; anything else ("Existing File or Web
-/// Page") is outside the workbook and saved as a relationship.
-fn links_outside(wb: &Workbook, sheet: usize, target: &str) -> bool {
-    let t = target.trim();
-    if t.starts_with('#') || wb.name(t, sheet).is_some() || wb.table(t).is_some() {
-        return false;
-    }
-    let (on, body) = split_sheet(t);
-    // Sheet names can't hold `: \ / ? * [ ]`, so `https://…!A1` or `C:\…!A1` is no sheet reference,
-    // and `Book.xlsx#Sheet1!A1` is a place in another file unless a sheet has that name.
-    let on_sheet = on.is_none_or(|name| {
-        wb.sheets.iter().any(|s| s.name.eq_ignore_ascii_case(&name))
-            || (!name.is_empty() && !name.contains([':', '\\', '/', '?', '*', '[', ']', '#']))
-    });
-    !(on_sheet && RangeRef::parse(body).is_some())
-}
-
-fn comment(s: &mut Session, p: &Json, threaded: bool) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
-    let text = str_param(p, "text").unwrap_or("").to_string();
-    let named = str_param(p, "author").map(str::to_string);
-    let author = named.clone().unwrap_or_else(|| s.prefs.user_name.clone());
-    edit(s, |cx| {
-        let comments = &mut cx.sheet_mut(sheet)?.comments;
-        // Writing a note on a cell that has one edits it, as Excel's Edit Note does: the box, the
-        // replies, the dates and who wrote it stay. A note replaces a comment and vice versa.
-        if let Some(c) = comments.get_mut(&at).filter(|c| c.threaded == threaded) {
-            c.text = text.clone();
-            if let Some(author) = named.clone() {
-                c.author = author;
-            }
-            return Ok(json!({"cell": at.a1()}));
-        }
-        comments.insert(
-            at,
-            Comment {
-                author: author.clone(),
-                text: text.clone(),
-                replies: vec![],
-                threaded,
-                resolved: false,
-                visible: false,
-                dates: vec![],
-                note_box: None,
-            },
-        );
-        Ok(json!({"cell": at.a1()}))
-    })
-}
-
-fn reply_comment(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
-    let text = str_param(p, "text").unwrap_or("").to_string();
-    let author = str_param(p, "author").map(str::to_string).unwrap_or_else(|| s.prefs.user_name.clone());
-    edit(s, |cx| {
-        let c = cx.sheet_mut(sheet)?.comments.get_mut(&at).ok_or_else(|| EngineError::Other("There's no comment in this cell.".into()))?;
-        c.replies.push((author.clone(), text.clone()));
-        Ok(Json::Null)
-    })
-}
-
-fn resolve_comment(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
-    let v = bool_param(p, "resolved").unwrap_or(true);
-    edit(s, |cx| {
-        if let Some(c) = cx.sheet_mut(sheet)?.comments.get_mut(&at) {
-            c.resolved = v;
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn delete_comment(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let ranges = target_ranges(s, p)?;
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.comments.retain(|c, _| !ranges.iter().any(|r| r.contains(*c)));
-        Ok(Json::Null)
-    })
-}
-
-fn show_note(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
-    edit(s, |cx| {
-        if let Some(c) = cx.sheet_mut(sheet)?.comments.get_mut(&at) {
-            c.visible = !c.visible;
-        }
-        Ok(Json::Null)
-    })
-}
-
 fn insert_symbol(s: &mut Session, p: &Json) -> Result<Json> {
     let ch = str_param(p, "char").unwrap_or("").to_string();
     let d = s.doc()?;
@@ -1399,344 +247,6 @@ fn insert_symbol(s: &mut Session, p: &Json) -> Result<Json> {
     s.execute("cell.set", json!({"cell": at.a1(), "input": format!("{cur}{ch}")}))
 }
 
-// ---------------------------------------------------------------- conditional formatting
-
-fn preset_style(name: &str) -> Style {
-    let mut s = Style::default();
-    match name {
-        "redText" => s.font.color = Color::rgb(0x9C, 0x00, 0x06),
-        "yellowFill" | "yellowFillDarkYellowText" => {
-            s.fill = Fill::solid(Color::rgb(0xFF, 0xEB, 0x9C));
-            s.font.color = Color::rgb(0x9C, 0x57, 0x00);
-        }
-        "greenFill" | "greenFillDarkGreenText" => {
-            s.fill = Fill::solid(Color::rgb(0xC6, 0xEF, 0xCE));
-            s.font.color = Color::rgb(0x00, 0x61, 0x00);
-        }
-        "lightRedFill" => s.fill = Fill::solid(Color::rgb(0xFF, 0xC7, 0xCE)),
-        "redBorder" => {
-            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0xC0, 0x00, 0x00) };
-            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
-        }
-        _ => {
-            s.fill = Fill::solid(Color::rgb(0xFF, 0xC7, 0xCE));
-            s.font.color = Color::rgb(0x9C, 0x00, 0x06);
-        }
-    }
-    s
-}
-
-/// Whether `v` is one formula string literal: `"…"` with every inner quote doubled.
-fn is_string_literal(v: &str) -> bool {
-    v.len() >= 2 && v.starts_with('"') && v.ends_with('"') && v.get(1..v.len() - 1).is_some_and(|inner| !inner.replace("\"\"", "").contains('"'))
-}
-
-/// A conditional format's `style` as the model's `Style` JSON (`font`, `fill`, `borders`, `align`,
-/// `num_fmt`, `protection`, merged over the default by the caller), where a colour may also be
-/// written as `format_range` takes it (`"#RRGGBB"`, `{theme, tint}`, `"auto"`) and `fill` may be a
-/// colour alone (a solid fill) or `"none"` (no fill). An unknown key is an error rather than
-/// dropped: dropped, it left a rule with an empty format that matches and shows nothing.
-fn cf_style_json(st: &Json) -> Result<Json> {
-    const KEYS: [&str; 6] = ["font", "fill", "borders", "align", "num_fmt", "protection"];
-    let err = |m: String| bad("home.conditionalFormat", m);
-    let Some(obj) = st.as_object() else { return Err(err("`style` must be an object, e.g. {\"fill\": \"#FFC7CE\"}".into())) };
-    let mut st = obj.clone();
-    if let Some(k) = st.keys().find(|k| !KEYS.contains(&k.as_str())) {
-        let hint = if k == "preset" { "; a preset goes in `rule.preset`" } else { "" };
-        return Err(err(format!("unknown key `{k}` in `style` (known: {}){hint}", KEYS.join(", "))));
-    }
-    // A colour written the way the other formatting commands take it, as the model stores it.
-    let color = |v: &mut Json, what: &str| -> Result<()> {
-        if v.is_string() || v.get("theme").is_some() {
-            let c = super::format::color_param(Some(v)).ok_or_else(|| err(format!("invalid colour {v} for `{what}`")))?;
-            *v = serde_json::to_value(c).map_err(|e| EngineError::Other(e.to_string()))?;
-        }
-        Ok(())
-    };
-    if let Some(f) = st.get_mut("font").and_then(Json::as_object_mut)
-        && let Some(c) = f.get_mut("color")
-    {
-        color(c, "font.color")?;
-    }
-    if let Some(fill) = st.get_mut("fill") {
-        // `"none"` (or `"auto"`) is no fill, as `home.fillColor` reads it, not a solid automatic one.
-        if fill.is_string() && super::format::color_param(Some(fill)) == Some(Color::Auto) {
-            *fill = serde_json::to_value(Fill::default()).map_err(|e| EngineError::Other(e.to_string()))?;
-        } else if fill.is_string() || fill.get("theme").is_some() {
-            *fill = json!({"pattern": "Solid", "fg": fill.clone()});
-        }
-        if let Some(f) = fill.as_object_mut() {
-            for k in ["fg", "bg"] {
-                if let Some(c) = f.get_mut(k) {
-                    color(c, &format!("fill.{k}"))?;
-                }
-            }
-            // A colour with no pattern is a solid fill, not an invisible one.
-            if f.contains_key("fg") && !f.contains_key("pattern") {
-                f.insert("pattern".into(), json!("Solid"));
-            }
-        }
-    }
-    if let Some(b) = st.get_mut("borders").and_then(Json::as_object_mut) {
-        for (side, line) in b.iter_mut() {
-            if let Some(c) = line.get_mut("color") {
-                color(c, &format!("borders.{side}.color"))?;
-            }
-        }
-    }
-    Ok(Json::Object(st))
-}
-
-/// #1999: a formula that doesn't parse must never reach the workbook — Excel refuses to open
-/// files carrying it, even in repair mode. Validated here so the API and the New Rule dialog
-/// (which dispatches this command) share one gate, the way Excel's object model refuses.
-fn check_cf_formula(cmd: &str, what: &str, formula: &str) -> Result<()> {
-    // Strip exactly one leading '=', the way the XLSX writer does: a value like '===A1'
-    // only parses after several strips and would still be saved unparseable. (#1999 review)
-    if gridcraft_formula::parse(formula.strip_prefix('=').unwrap_or(formula)).is_err() {
-        return Err(bad(cmd, format!("invalid {what} formula `{formula}` — it does not parse; Excel would reject the saved file")));
-    }
-    Ok(())
-}
-
-fn check_cf_value(what: &str, v: &gridcraft_model::features::CfValueKind) -> Result<()> {
-    if let gridcraft_model::features::CfValueKind::Formula(f) = v {
-        check_cf_formula("home.conditionalFormat", what, f)?;
-    }
-    Ok(())
-}
-
-fn check_cf_rule(rule: &CfRule) -> Result<()> {
-    const CMD: &str = "home.conditionalFormat";
-    match rule {
-        CfRule::CellIs { a, b, .. } => {
-            check_cf_formula(CMD, "comparison value", a)?;
-            if let Some(b) = b {
-                check_cf_formula(CMD, "second comparison value", b)?;
-            }
-        }
-        CfRule::Expression { formula, .. } => check_cf_formula(CMD, "rule", formula)?,
-        CfRule::DataBar { min, max, .. } => {
-            check_cf_value("data bar minimum", min)?;
-            check_cf_value("data bar maximum", max)?;
-        }
-        CfRule::ColorScale { stops } => {
-            for (kind, _) in stops {
-                check_cf_value("color scale threshold", kind)?;
-            }
-        }
-        _ => {}
-    }
-    Ok(())
-}
-
-fn add_cf(s: &mut Session, p: &Json) -> Result<Json> {
-    let ranges = target_ranges(s, p)?;
-    let sheet = target_sheet(s, p)?;
-    let Some(rule) = p.get("rule") else {
-        s.ui_requests.push(crate::UiRequest::Dialog("newFormattingRule".into(), json!({})));
-        return ok();
-    };
-    let g = |k: &str| rule.get(k).and_then(Json::as_str).map(str::to_string);
-    let style = Box::new(match rule.get("style") {
-        Some(st) if !st.is_null() => {
-            let st = cf_style_json(st)?;
-            let base = serde_json::to_value(Style::default()).map_err(|e| EngineError::Other(e.to_string()))?;
-            serde_json::from_value(super::format::merge_json(base, &st)).map_err(|e| bad("home.conditionalFormat", e.to_string()))?
-        }
-        _ => preset_style(g("preset").as_deref().unwrap_or("lightRedFillDarkRedText")),
-    });
-    let kind = g("type").unwrap_or_else(|| "cellIs".into());
-    let value_kind = |v: Option<&Json>, default: CfValueKind| -> CfValueKind {
-        match v {
-            Some(Json::Object(o)) => {
-                let t = o.get("type").and_then(Json::as_str).unwrap_or("num");
-                let val = o.get("value").and_then(Json::as_f64).unwrap_or(0.0);
-                match t {
-                    "min" => CfValueKind::Min,
-                    "max" => CfValueKind::Max,
-                    "percent" => CfValueKind::Percent(val),
-                    "percentile" => CfValueKind::Percentile(val),
-                    "formula" => CfValueKind::Formula(o.get("value").and_then(Json::as_str).unwrap_or("").into()),
-                    _ => CfValueKind::Number(val),
-                }
-            }
-            _ => default,
-        }
-    };
-    let rule = match kind.as_str() {
-        "cellIs" => {
-            // Excel's file and VBA names (`lessThan`, …) are accepted too.
-            let op = match g("operator").as_deref().unwrap_or("greater") {
-                "between" => CfOperator::Between,
-                "notBetween" => CfOperator::NotBetween,
-                "equal" => CfOperator::Equal,
-                "notEqual" => CfOperator::NotEqual,
-                "less" | "lessThan" => CfOperator::Less,
-                "greaterOrEqual" | "greaterThanOrEqual" => CfOperator::GreaterOrEqual,
-                "lessOrEqual" | "lessThanOrEqual" => CfOperator::LessOrEqual,
-                "greater" | "greaterThan" => CfOperator::Greater,
-                other => return Err(bad("home.conditionalFormat", format!("unknown operator `{other}`"))),
-            };
-            let a = rule.get("value").map(super::edit::json_to_input).unwrap_or_default();
-            let b = rule.get("value2").map(super::edit::json_to_input);
-            let quote = |v: String| {
-                // A number, a formula, or text already written as a string literal (`"Closed"`, as
-                // in the file and in openpyxl's `CellIsRule`) is kept; other text is quoted.
-                if gridcraft_core::parse::parse_number_text(&v).is_some() || v.starts_with('=') {
-                    v.trim_start_matches('=').to_string()
-                } else if is_string_literal(&v) {
-                    v
-                } else {
-                    format!("\"{}\"", v.replace('"', "\"\""))
-                }
-            };
-            CfRule::CellIs { op, a: quote(a), b: b.map(quote), style }
-        }
-        "expression" => CfRule::Expression { formula: g("formula").unwrap_or_default().trim_start_matches('=').to_string(), style },
-        "containsText" => CfRule::ContainsText { text: g("text").unwrap_or_default(), style },
-        "notContainsText" => CfRule::NotContainsText { text: g("text").unwrap_or_default(), style },
-        "beginsWith" => CfRule::BeginsWith { text: g("text").unwrap_or_default(), style },
-        "endsWith" => CfRule::EndsWith { text: g("text").unwrap_or_default(), style },
-        "blanks" => CfRule::Blanks { style },
-        "noBlanks" => CfRule::NoBlanks { style },
-        "errors" => CfRule::Errors { style },
-        "noErrors" => CfRule::NoErrors { style },
-        "duplicate" => CfRule::Duplicate { style },
-        "unique" => CfRule::Unique { style },
-        "top10" => CfRule::Top10 {
-            bottom: rule.get("bottom").and_then(Json::as_bool).unwrap_or(false),
-            percent: rule.get("percent").and_then(Json::as_bool).unwrap_or(false),
-            rank: rule.get("rank").and_then(Json::as_u64).unwrap_or(10) as u32,
-            style,
-        },
-        "aboveAverage" => CfRule::AboveAverage { below: rule.get("below").and_then(Json::as_bool).unwrap_or(false), equal: false, std_dev: 0, style },
-        "timePeriod" => CfRule::TimePeriod { period: g("period").unwrap_or_else(|| "today".into()), style },
-        "colorScale" => {
-            let cols: Vec<Color> = rule
-                .get("colors")
-                .and_then(Json::as_array)
-                .map(|a| a.iter().filter_map(|c| super::format::color_param(Some(c))).collect())
-                .unwrap_or_else(|| vec![Color::rgb(0xF8, 0x69, 0x6B), Color::rgb(0xFF, 0xEB, 0x84), Color::rgb(0x63, 0xBE, 0x7B)]);
-            let stops = match cols.len() {
-                2 => vec![(CfValueKind::Min, cols[0]), (CfValueKind::Max, cols[1])],
-                _ => vec![
-                    (CfValueKind::Min, cols.first().copied().unwrap_or_default()),
-                    (CfValueKind::Percentile(50.0), cols.get(1).copied().unwrap_or_default()),
-                    (CfValueKind::Max, cols.get(2).copied().unwrap_or_default()),
-                ],
-            };
-            CfRule::ColorScale { stops }
-        }
-        "dataBar" => CfRule::DataBar {
-            min: value_kind(rule.get("min"), CfValueKind::Min),
-            max: value_kind(rule.get("max"), CfValueKind::Max),
-            color: super::format::color_param(rule.get("color")).unwrap_or(Color::rgb(0x63, 0x8E, 0xC6)),
-            gradient: rule.get("gradient").and_then(Json::as_bool).unwrap_or(true),
-            show_value: true,
-        },
-        "iconSet" => CfRule::IconSet {
-            set: g("set").unwrap_or_else(|| "3TrafficLights1".into()),
-            thresholds: vec![],
-            reverse: rule.get("reverse").and_then(Json::as_bool).unwrap_or(false),
-            show_value: true,
-        },
-        other => return Err(bad("home.conditionalFormat", format!("unknown rule type `{other}`"))),
-    };
-    check_cf_rule(&rule)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        let priority = sh.cond_formats.iter().map(|c| c.priority).max().unwrap_or(0) + 1;
-        // New rules take precedence over older ones.
-        for cf in sh.cond_formats.iter_mut() {
-            cf.priority += 1;
-        }
-        sh.cond_formats.insert(0, CondFormat { ranges: ranges.clone(), rule, priority: 1, stop_if_true: false });
-        let _ = priority;
-        Ok(json!({"rules": sh.cond_formats.len()}))
-    })
-}
-
-fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let whole = bool_param(p, "sheet").unwrap_or(false);
-    let ranges = target_ranges(s, p)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        if whole {
-            sh.cond_formats.clear();
-        } else {
-            for cf in sh.cond_formats.iter_mut() {
-                cf.ranges.retain(|r| !ranges.iter().any(|x| x.intersects(r)));
-            }
-            sh.cond_formats.retain(|c| !c.ranges.is_empty());
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn manage_cf(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    if p.get("delete").is_none() && p.get("moveUp").is_none() && p.get("moveDown").is_none() {
-        let list: Vec<Json> = s
-            .doc()?
-            .wb
-            .sheet(sheet)
-            .map(|sh| {
-                sh.cond_formats.iter().map(|c| json!({"ranges": c.ranges.iter().map(|r| r.a1()).collect::<Vec<_>>(), "rule": c.rule})).collect()
-            })
-            .unwrap_or_default();
-        return Ok(json!({"rules": list}));
-    }
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        // The count is taken again after each step: a delete shortens the list.
-        if let Some(i) = u32_param(p, "delete").map(|v| v as usize)
-            && i < sh.cond_formats.len()
-        {
-            sh.cond_formats.remove(i);
-        }
-        if let Some(i) = u32_param(p, "moveUp").map(|v| v as usize)
-            && i > 0
-            && i < sh.cond_formats.len()
-        {
-            sh.cond_formats.swap(i, i - 1);
-        }
-        if let Some(i) = u32_param(p, "moveDown").map(|v| v as usize)
-            && i + 1 < sh.cond_formats.len()
-        {
-            sh.cond_formats.swap(i, i + 1);
-        }
-        for (k, cf) in sh.cond_formats.iter_mut().enumerate() {
-            cf.priority = k as u32 + 1;
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn insert_icon(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").unwrap_or("check").to_string();
-    let size = f64_param(p, "size").unwrap_or(48.0).clamp(8.0, 1000.0) as f32;
-    let d = s.doc()?;
-    let id = d.wb.next_object_id();
-    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
-    let color = super::format::color_param(p.get("color")).unwrap_or(Color::Theme(1, 0));
-    let shape = Shape {
-        id,
-        kind: ShapeKind::Icon,
-        anchor: Anchor { cell: at, dx: 4.0, dy: 4.0, width: size, height: size, mode: anchor_mode_param(p).unwrap_or_default() },
-        fill: color,
-        line: Color::Auto,
-        text: name,
-        format: Default::default(),
-    };
-    let sheet = d.wb.active_sheet();
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.shapes.push(shape);
-        Ok(json!({"shape": id}))
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/engine/src/cmd/insert/chart.rs b/crates/engine/src/cmd/insert/chart.rs
new file mode 100644
index 000000000..4817e41ec
--- /dev/null
+++ b/crates/engine/src/cmd/insert/chart.rs
@@ -0,0 +1,420 @@
+use super::*;
+
+fn chart_areas(s: &Session, p: &Json) -> Result<Vec<RangeRef>> {
+    if p.get("range").is_some() {
+        return target_ranges(s, p);
+    }
+    let d = s.doc()?;
+    if d.selection.ranges.len() > 1 {
+        return Ok(d.selection.ranges.clone());
+    }
+    Ok(vec![block(s, p)?])
+}
+
+// ---------------------------------------------------------------- charts
+
+pub fn chart_kind(t: &str, sub: &str) -> ChartKind {
+    match (t, sub) {
+        ("column", "stacked") => ChartKind::ColumnStacked,
+        ("column", "stacked100") => ChartKind::ColumnStacked100,
+        ("bar", "stacked") => ChartKind::BarStacked,
+        ("bar", "stacked100") => ChartKind::BarStacked100,
+        ("bar", _) => ChartKind::BarClustered,
+        ("line", "markers") => ChartKind::LineMarkers,
+        ("line", "stacked") => ChartKind::LineStacked,
+        ("line", _) => ChartKind::Line,
+        ("pie", _) => ChartKind::Pie,
+        ("doughnut", _) => ChartKind::Doughnut,
+        ("area", "stacked") => ChartKind::AreaStacked,
+        ("area", "stacked100") => ChartKind::AreaStacked100,
+        ("area", _) => ChartKind::Area,
+        ("scatter", "lines") => ChartKind::ScatterLines,
+        ("scatter", _) => ChartKind::Scatter,
+        ("bubble", _) => ChartKind::Bubble,
+        ("radar", _) => ChartKind::Radar,
+        ("histogram", _) => ChartKind::Histogram,
+        ("waterfall", _) => ChartKind::Waterfall,
+        ("funnel", _) => ChartKind::Funnel,
+        ("treemap", _) => ChartKind::Treemap,
+        ("sunburst", _) => ChartKind::Sunburst,
+        ("boxWhisker", _) => ChartKind::BoxWhisker,
+        ("stock", _) => ChartKind::Stock,
+        ("combo", _) => ChartKind::Combo,
+        _ => ChartKind::ColumnClustered,
+    }
+}
+
+/// Builds series from a block: first row/column as names/categories when they're text.
+pub fn series_from_range(sh: &Sheet, r: RangeRef, by_rows: bool) -> Vec<Series> {
+    let q = gridcraft_formula::quote_sheet(&sh.name);
+    let abs = |r: RangeRef| {
+        format!(
+            "{q}!${}${}:${}${}",
+            gridcraft_core::col_to_letters(r.start.col),
+            r.start.row + 1,
+            gridcraft_core::col_to_letters(r.end.col),
+            r.end.row + 1
+        )
+    };
+    let abs1 = |c: CellRef| format!("{q}!${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1);
+    let is_text = |c: CellRef| sh.value(c).is_text() || sh.value(c).is_empty();
+    let header_row = r.height() > 1
+        && (r.start.col..=r.end.col).any(|c| sh.value(CellRef::new(r.start.row, c)).is_text())
+        && (r.start.col..=r.end.col).filter(|c| *c != r.start.col).all(|c| is_text(CellRef::new(r.start.row, c)));
+    // A blank top-left cell above a header row marks the first column as the category labels even
+    // when it holds numbers (years, X values), the usual spreadsheet convention, so it isn't
+    // plotted as a series of its own (#287).
+    let blank_corner = header_row && sh.value(r.start).is_empty();
+    let label_col =
+        r.width() > 1 && (blank_corner || (r.start.row + header_row as u32..=r.end.row).all(|row| is_text(CellRef::new(row, r.start.col))));
+    let data = RangeRef::new(CellRef::new(r.start.row + header_row as u32, r.start.col + label_col as u32), r.end);
+    let mut out = Vec::new();
+    if !by_rows {
+        for c in data.start.col..=data.end.col {
+            out.push(Series {
+                name: header_row.then(|| abs1(CellRef::new(r.start.row, c))),
+                categories: label_col.then(|| abs(RangeRef::new(CellRef::new(data.start.row, r.start.col), CellRef::new(data.end.row, r.start.col)))),
+                values: abs(RangeRef::new(CellRef::new(data.start.row, c), CellRef::new(data.end.row, c))),
+                bubble_sizes: None,
+                color: None,
+                secondary: false,
+                kind: None,
+                quartiles: Default::default(),
+                smooth: false,
+                trendlines: Vec::new(),
+            });
+        }
+    } else {
+        for row in data.start.row..=data.end.row {
+            out.push(Series {
+                name: label_col.then(|| abs1(CellRef::new(row, r.start.col))),
+                categories: header_row
+                    .then(|| abs(RangeRef::new(CellRef::new(r.start.row, data.start.col), CellRef::new(r.start.row, data.end.col)))),
+                values: abs(RangeRef::new(CellRef::new(row, data.start.col), CellRef::new(row, data.end.col))),
+                bubble_sizes: None,
+                color: None,
+                secondary: false,
+                kind: None,
+                quartiles: Default::default(),
+                smooth: false,
+                trendlines: Vec::new(),
+            });
+        }
+    }
+    out
+}
+
+fn series_from_areas(sh: &Sheet, areas: &[RangeRef]) -> Result<(RangeRef, bool, Vec<Series>)> {
+    let Some(first) = areas.first().copied() else { return Err(EngineError::Other("Select data for the chart first.".into())) };
+    let bounds = areas.iter().skip(1).fold(first, |r, area| r.union(area));
+    if areas.len() == 1 {
+        let by_rows = first.width() > first.height() + 1;
+        return Ok((bounds, by_rows, series_from_range(sh, first, by_rows)));
+    }
+    let valid_shape = first.width() == 1
+        && first.height() > 1
+        && areas.iter().skip(1).all(|area| area.width() == 1 && area.height() == first.height())
+        && first.iter().all(|cell| sh.value(cell).is_text() || sh.value(cell).is_empty());
+    if !valid_shape {
+        return Err(bad("insert.chart", "multi-area charts require a text category column followed by equal-height series columns"));
+    }
+    let category = series_from_range(sh, first, false).into_iter().next().map(|series| series.values);
+    let mut series = Vec::with_capacity(areas.len() - 1);
+    for area in &areas[1..] {
+        let mut area_series = series_from_range(sh, *area, false);
+        let Some(mut item) = area_series.pop() else {
+            return Err(EngineError::Other("Select data for the chart first.".into()));
+        };
+        if item.name.is_none() {
+            return Err(bad("insert.chart", "multi-area series columns require headers"));
+        }
+        item.categories = category.clone();
+        series.push(item);
+    }
+    Ok((bounds, false, series))
+}
+
+/// A scatter plot of a block without category labels takes its first column (or row) as the X
+/// values of the others, as Excel does: two plain columns make one series of points, not two (#428).
+pub fn scatter_x_from_first(kind: ChartKind, series: &mut Vec<Series>) {
+    if matches!(kind, ChartKind::Scatter | ChartKind::ScatterLines) && series.len() > 1 && series[0].categories.is_none() {
+        let x = series.remove(0).values;
+        for se in series.iter_mut() {
+            se.categories = Some(x.clone());
+        }
+    }
+}
+
+/// Most cells a chart's source block may span (bounds the series it builds).
+const MAX_CHART_CELLS: u64 = 1_000_000;
+
+/// Chart types that suit the shape of the data, best first, as `(type, subtype, label)` for
+/// `insert.chart`. Our own heuristic from the shape of the block (series count, points per
+/// series, text categories, negative values), not a copy of Excel's ranking: two numeric columns
+/// without labels → scatter; one short series → column, pie, bar; long series → line; several
+/// series → clustered and stacked columns and bars, line.
+pub fn recommend_charts(s: &Session, p: &Json) -> Result<Vec<(&'static str, &'static str, &'static str)>> {
+    let areas = chart_areas(s, p)?;
+    if areas.iter().fold(0_u64, |count, area| count.saturating_add(area.count())) > MAX_CHART_CELLS {
+        return Err(bad("insert.chart", "range too large for a chart"));
+    }
+    let sheet = target_sheet(s, p)?;
+    let d = s.doc()?;
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let (_, by_rows, series) = series_from_areas(sh, &areas)?;
+    let ranges: Vec<RangeRef> = series
+        .iter()
+        .filter_map(|x| match gridcraft_formula::parse(&x.values) {
+            Ok(gridcraft_formula::Expr::Ref(rf)) => Some(rf.range()),
+            _ => None,
+        })
+        .collect();
+    let points = ranges.first().map_or(0, RangeRef::count);
+    let (mut any_number, mut non_negative) = (false, true);
+    for n in ranges.iter().flat_map(|rr| rr.iter()).filter_map(|c| sh.value(c).as_f64()) {
+        any_number = true;
+        non_negative &= n >= 0.0;
+    }
+    if series.is_empty() || !any_number {
+        return Err(EngineError::Other("Select data for the chart first.".into()));
+    }
+    let labelled = series.first().is_some_and(|x| x.categories.is_some());
+    const COLUMN: (&str, &str, &str) = ("column", "", "Clustered Column");
+    const BAR: (&str, &str, &str) = ("bar", "", "Clustered Bar");
+    const LINE: (&str, &str, &str) = ("line", "", "Line");
+    const LINE_MARKERS: (&str, &str, &str) = ("line", "markers", "Line with Markers");
+    const PIE: (&str, &str, &str) = ("pie", "", "Pie");
+    const DOUGHNUT: (&str, &str, &str) = ("doughnut", "", "Doughnut");
+    const AREA: (&str, &str, &str) = ("area", "", "Area");
+    const SCATTER: (&str, &str, &str) = ("scatter", "", "Scatter");
+    const STACKED_COLUMN: (&str, &str, &str) = ("column", "stacked", "Stacked Column");
+    const STACKED_BAR: (&str, &str, &str) = ("bar", "stacked", "Stacked Bar");
+    let mut out = Vec::new();
+    if series.len() == 2 && !labelled && !by_rows {
+        out.extend([SCATTER, LINE_MARKERS, COLUMN]);
+    } else if series.len() == 1 {
+        if points > 12 {
+            out.extend([LINE, COLUMN, AREA]);
+        } else {
+            out.extend([COLUMN, BAR]);
+            if non_negative && points >= 2 {
+                out.extend([PIE, DOUGHNUT]);
+            }
+            out.push(LINE_MARKERS);
+        }
+    } else if points > 12 {
+        out.extend([LINE, COLUMN, AREA, STACKED_COLUMN]);
+    } else {
+        out.extend([COLUMN, BAR, STACKED_COLUMN, LINE_MARKERS, STACKED_BAR]);
+    }
+    Ok(out)
+}
+
+/// The chart `insert.chart` would insert for these params, without inserting it: the sheet it
+/// goes on and the chart (previews in the Recommended Charts dialog).
+pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> {
+    let areas = chart_areas(s, p)?;
+    if areas.iter().fold(0_u64, |count, area| count.saturating_add(area.count())) > MAX_CHART_CELLS {
+        return Err(bad("insert.chart", "range too large for a chart"));
+    }
+    let mut t = str_param(p, "type").unwrap_or("column").to_string();
+    let mut sub = str_param(p, "subtype").unwrap_or("").to_string();
+    if t == "auto" {
+        let first = recommend_charts(s, p)?.into_iter().next().unwrap_or(("column", "", ""));
+        t = first.0.into();
+        sub = first.1.into();
+    }
+    let sheet = target_sheet(s, p)?;
+    let d = s.doc()?;
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let kind = chart_kind(&t, &sub);
+    let (bounds, by_rows, mut series) = series_from_areas(sh, &areas)?;
+    if series.is_empty() {
+        return Err(EngineError::Other("Select data for the chart first.".into()));
+    }
+    scatter_x_from_first(kind, &mut series);
+    let id = d.wb.next_object_id();
+    let at = cell_param_on(s, p, "at", sheet)?.unwrap_or_else(|| CellRef::new(bounds.start.row, bounds.end.col + 2));
+    let title = str_param(p, "title").map(str::to_string).or_else(|| {
+        if series.len() == 1 {
+            series[0].name.as_ref().map(|n| gridcraft_calc::evaluate(&d.wb, sheet, at, n).display())
+        } else {
+            Some("Chart Title".into())
+        }
+    });
+    let chart = Chart {
+        id,
+        kind,
+        anchor: Anchor {
+            cell: at,
+            dx: 0.0,
+            dy: 0.0,
+            width: f64_param(p, "width").unwrap_or(480.0) as f32,
+            height: f64_param(p, "height").unwrap_or(288.0) as f32,
+            mode: anchor_mode_param(p).unwrap_or_default(),
+        },
+        title,
+        series,
+        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
+        data_labels: false,
+        gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
+        style: 1,
+        x_title: None,
+        y_title: None,
+        source: (areas.len() == 1).then(|| format!("{}!{}", gridcraft_formula::quote_sheet(&sh.name), bounds.a1())),
+        by_rows,
+        pivot: None,
+    };
+    Ok((sheet, chart))
+}
+
+pub(super) fn insert_chart(s: &mut Session, p: &Json) -> Result<Json> {
+    let (sheet, chart) = build_chart(s, p)?;
+    let id = chart.id;
+    edit(s, |cx| {
+        cx.sheet_mut(sheet)?.charts.push(chart);
+        Ok(json!({"chart": id}))
+    })
+}
+
+fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
+    let d = s.doc()?;
+    let sheet = d.wb.active_sheet();
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let idx = match u32_param(p, "chart") {
+        Some(id) => sh.charts.iter().position(|c| c.id == id),
+        None => sh.charts.len().checked_sub(1),
+    };
+    idx.map(|i| (sheet, i)).ok_or_else(|| bad("chart", "no such chart"))
+}
+
+pub(super) fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ci) = find_chart(s, p)?;
+    let at = cell_param_on(s, p, "at", si)?;
+    let quartiles = p
+        .get("quartiles")
+        .map(|v| match v.as_str() {
+            Some("exclusive") => Ok(gridcraft_model::QuartileMethod::Exclusive),
+            Some("inclusive") => Ok(gridcraft_model::QuartileMethod::Inclusive),
+            _ => Err(bad("quartiles", "expected exclusive or inclusive")),
+        })
+        .transpose()?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        let Some(c) = sh.charts.get_mut(ci) else { return Ok(Json::Null) };
+        if let Some(t) = str_param(p, "type") {
+            c.kind = chart_kind(t, str_param(p, "subtype").unwrap_or(""));
+        }
+        if let Some(method) = quartiles {
+            for series in &mut c.series {
+                series.quartiles = method;
+            }
+        }
+        if let Some(t) = p.get("title") {
+            c.title = t.as_str().map(str::to_string);
+        }
+        if let Some(l) = str_param(p, "legend") {
+            c.legend = match l {
+                "none" => LegendPos::None,
+                "top" => LegendPos::Top,
+                "left" => LegendPos::Left,
+                "right" => LegendPos::Right,
+                _ => LegendPos::Bottom,
+            };
+        }
+        if let Some(v) = bool_param(p, "dataLabels") {
+            c.data_labels = v;
+        }
+        if let Some(v) = bool_param(p, "gridlines") {
+            c.gridlines = v;
+        }
+        if let Some(v) = u32_param(p, "style") {
+            c.style = v.clamp(1, 16);
+        }
+        if let Some(t) = p.get("xTitle") {
+            c.x_title = t.as_str().map(str::to_string);
+        }
+        if let Some(t) = p.get("yTitle") {
+            c.y_title = t.as_str().map(str::to_string);
+        }
+        if let Some(at) = at {
+            c.anchor.cell = at;
+        }
+        if let Some(w) = f64_param(p, "width") {
+            c.anchor.width = w.clamp(20.0, 10000.0) as f32;
+        }
+        if let Some(h) = f64_param(p, "height") {
+            c.anchor.height = h.clamp(20.0, 10000.0) as f32;
+        }
+        if let Some(v) = f64_param(p, "dx") {
+            c.anchor.dx = v as f32;
+        }
+        if let Some(v) = f64_param(p, "dy") {
+            c.anchor.dy = v as f32;
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn chart_switch(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ci) = find_chart(s, p)?;
+    edit(s, |cx| {
+        let Some(sh) = cx.wb.sheet(si) else { return Ok(Json::Null) };
+        let Some(c) = sh.charts.get(ci) else { return Ok(Json::Null) };
+        // Charts read from a file have no source range: take the block their series span.
+        let Some((src, by_rows)) = c.source.clone().map(|s| (s, c.by_rows)).or_else(|| series_block(&c.series)) else { return Ok(Json::Null) };
+        let (sheet_name, body) = split_sheet(&src);
+        let src_sheet = sheet_name.and_then(|n| cx.wb.sheet_index(&n)).unwrap_or(si);
+        let Some(mut r) = RangeRef::parse(body) else { return Ok(Json::Null) };
+        let Some(ssh) = cx.wb.sheet(src_sheet) else { return Ok(Json::Null) };
+        // Whole-column/row references (common in files) span a million cells: clip the block's
+        // far edges to the cells in use, then refuse anything still too large to chart.
+        if let Some(used) = ssh.used_range() {
+            r.end.row = r.end.row.min(used.end.row).max(r.start.row);
+            r.end.col = r.end.col.min(used.end.col).max(r.start.col);
+        }
+        if r.count() > MAX_CHART_CELLS {
+            return Err(bad("chart.switchRowColumn", "range too large for a chart"));
+        }
+        let by_rows = !by_rows;
+        let series = series_from_range(ssh, r, by_rows);
+        if let Some(c) = cx.sheet_mut(si)?.charts.get_mut(ci) {
+            c.source.get_or_insert(src);
+            c.by_rows = by_rows;
+            c.series = series;
+            scatter_x_from_first(c.kind, &mut c.series);
+        }
+        Ok(Json::Null)
+    })
+}
+
+/// The block a chart's series come from, and whether each series is a row of it: the bounding
+/// range of the series names, categories and values, when they're all references to one sheet.
+fn series_block(series: &[Series]) -> Option<(String, bool)> {
+    let mut sheet: Option<String> = None;
+    let mut bounds: Option<RangeRef> = None;
+    let mut rows = 0;
+    for s in series {
+        for (i, f) in [Some(&s.values), s.categories.as_ref(), s.name.as_ref()].into_iter().flatten().enumerate() {
+            let Ok(gridcraft_formula::Expr::Ref(r)) = gridcraft_formula::parse(f) else { return None };
+            let gridcraft_formula::SheetSel::Named(n) = &r.sheet else { return None };
+            if !sheet.get_or_insert_with(|| n.clone()).eq_ignore_ascii_case(n) {
+                return None;
+            }
+            let range = r.range();
+            if i == 0 && range.height() == 1 && range.width() > 1 {
+                rows += 1;
+            }
+            bounds = Some(bounds.map_or(range, |b| b.union(&range)));
+        }
+    }
+    Some((format!("{}!{}", gridcraft_formula::quote_sheet(&sheet?), bounds?.a1()), rows > 0 && rows == series.len()))
+}
+
+pub(super) fn chart_delete(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ci) = find_chart(s, p)?;
+    edit(s, |cx| {
+        cx.sheet_mut(si)?.charts.remove(ci);
+        Ok(Json::Null)
+    })
+}
diff --git a/crates/engine/src/cmd/insert/cond_format.rs b/crates/engine/src/cmd/insert/cond_format.rs
new file mode 100644
index 000000000..aeeb9db55
--- /dev/null
+++ b/crates/engine/src/cmd/insert/cond_format.rs
@@ -0,0 +1,339 @@
+use super::*;
+
+// ---------------------------------------------------------------- conditional formatting
+
+fn preset_style(name: &str) -> Style {
+    let mut s = Style::default();
+    match name {
+        "redText" => s.font.color = Color::rgb(0x9C, 0x00, 0x06),
+        "yellowFill" | "yellowFillDarkYellowText" => {
+            s.fill = Fill::solid(Color::rgb(0xFF, 0xEB, 0x9C));
+            s.font.color = Color::rgb(0x9C, 0x57, 0x00);
+        }
+        "greenFill" | "greenFillDarkGreenText" => {
+            s.fill = Fill::solid(Color::rgb(0xC6, 0xEF, 0xCE));
+            s.font.color = Color::rgb(0x00, 0x61, 0x00);
+        }
+        "lightRedFill" => s.fill = Fill::solid(Color::rgb(0xFF, 0xC7, 0xCE)),
+        "redBorder" => {
+            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0xC0, 0x00, 0x00) };
+            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
+        }
+        _ => {
+            s.fill = Fill::solid(Color::rgb(0xFF, 0xC7, 0xCE));
+            s.font.color = Color::rgb(0x9C, 0x00, 0x06);
+        }
+    }
+    s
+}
+
+/// Whether `v` is one formula string literal: `"…"` with every inner quote doubled.
+fn is_string_literal(v: &str) -> bool {
+    v.len() >= 2 && v.starts_with('"') && v.ends_with('"') && v.get(1..v.len() - 1).is_some_and(|inner| !inner.replace("\"\"", "").contains('"'))
+}
+
+/// A conditional format's `style` as the model's `Style` JSON (`font`, `fill`, `borders`, `align`,
+/// `num_fmt`, `protection`, merged over the default by the caller), where a colour may also be
+/// written as `format_range` takes it (`"#RRGGBB"`, `{theme, tint}`, `"auto"`) and `fill` may be a
+/// colour alone (a solid fill) or `"none"` (no fill). An unknown key is an error rather than
+/// dropped: dropped, it left a rule with an empty format that matches and shows nothing.
+fn cf_style_json(st: &Json) -> Result<Json> {
+    const KEYS: [&str; 6] = ["font", "fill", "borders", "align", "num_fmt", "protection"];
+    let err = |m: String| bad("home.conditionalFormat", m);
+    let Some(obj) = st.as_object() else { return Err(err("`style` must be an object, e.g. {\"fill\": \"#FFC7CE\"}".into())) };
+    let mut st = obj.clone();
+    if let Some(k) = st.keys().find(|k| !KEYS.contains(&k.as_str())) {
+        let hint = if k == "preset" { "; a preset goes in `rule.preset`" } else { "" };
+        return Err(err(format!("unknown key `{k}` in `style` (known: {}){hint}", KEYS.join(", "))));
+    }
+    // A colour written the way the other formatting commands take it, as the model stores it.
+    let color = |v: &mut Json, what: &str| -> Result<()> {
+        if v.is_string() || v.get("theme").is_some() {
+            let c = crate::cmd::format::color_param(Some(v)).ok_or_else(|| err(format!("invalid colour {v} for `{what}`")))?;
+            *v = serde_json::to_value(c).map_err(|e| EngineError::Other(e.to_string()))?;
+        }
+        Ok(())
+    };
+    if let Some(f) = st.get_mut("font").and_then(Json::as_object_mut)
+        && let Some(c) = f.get_mut("color")
+    {
+        color(c, "font.color")?;
+    }
+    if let Some(fill) = st.get_mut("fill") {
+        // `"none"` (or `"auto"`) is no fill, as `home.fillColor` reads it, not a solid automatic one.
+        if fill.is_string() && crate::cmd::format::color_param(Some(fill)) == Some(Color::Auto) {
+            *fill = serde_json::to_value(Fill::default()).map_err(|e| EngineError::Other(e.to_string()))?;
+        } else if fill.is_string() || fill.get("theme").is_some() {
+            *fill = json!({"pattern": "Solid", "fg": fill.clone()});
+        }
+        if let Some(f) = fill.as_object_mut() {
+            for k in ["fg", "bg"] {
+                if let Some(c) = f.get_mut(k) {
+                    color(c, &format!("fill.{k}"))?;
+                }
+            }
+            // A colour with no pattern is a solid fill, not an invisible one.
+            if f.contains_key("fg") && !f.contains_key("pattern") {
+                f.insert("pattern".into(), json!("Solid"));
+            }
+        }
+    }
+    if let Some(b) = st.get_mut("borders").and_then(Json::as_object_mut) {
+        for (side, line) in b.iter_mut() {
+            if let Some(c) = line.get_mut("color") {
+                color(c, &format!("borders.{side}.color"))?;
+            }
+        }
+    }
+    Ok(Json::Object(st))
+}
+
+/// #1999: a formula that doesn't parse must never reach the workbook — Excel refuses to open
+/// files carrying it, even in repair mode. Validated here so the API and the New Rule dialog
+/// (which dispatches this command) share one gate, the way Excel's object model refuses.
+fn check_cf_formula(cmd: &str, what: &str, formula: &str) -> Result<()> {
+    // Strip exactly one leading '=', the way the XLSX writer does: a value like '===A1'
+    // only parses after several strips and would still be saved unparseable. (#1999 review)
+    if gridcraft_formula::parse(formula.strip_prefix('=').unwrap_or(formula)).is_err() {
+        return Err(bad(cmd, format!("invalid {what} formula `{formula}` — it does not parse; Excel would reject the saved file")));
+    }
+    Ok(())
+}
+
+fn check_cf_value(what: &str, v: &gridcraft_model::features::CfValueKind) -> Result<()> {
+    if let gridcraft_model::features::CfValueKind::Formula(f) = v {
+        check_cf_formula("home.conditionalFormat", what, f)?;
+    }
+    Ok(())
+}
+
+fn check_cf_rule(rule: &CfRule) -> Result<()> {
+    const CMD: &str = "home.conditionalFormat";
+    match rule {
+        CfRule::CellIs { a, b, .. } => {
+            check_cf_formula(CMD, "comparison value", a)?;
+            if let Some(b) = b {
+                check_cf_formula(CMD, "second comparison value", b)?;
+            }
+        }
+        CfRule::Expression { formula, .. } => check_cf_formula(CMD, "rule", formula)?,
+        CfRule::DataBar { min, max, .. } => {
+            check_cf_value("data bar minimum", min)?;
+            check_cf_value("data bar maximum", max)?;
+        }
+        CfRule::ColorScale { stops } => {
+            for (kind, _) in stops {
+                check_cf_value("color scale threshold", kind)?;
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+pub(super) fn add_cf(s: &mut Session, p: &Json) -> Result<Json> {
+    let ranges = target_ranges(s, p)?;
+    let sheet = target_sheet(s, p)?;
+    let Some(rule) = p.get("rule") else {
+        s.ui_requests.push(crate::UiRequest::Dialog("newFormattingRule".into(), json!({})));
+        return ok();
+    };
+    let g = |k: &str| rule.get(k).and_then(Json::as_str).map(str::to_string);
+    let style = Box::new(match rule.get("style") {
+        Some(st) if !st.is_null() => {
+            let st = cf_style_json(st)?;
+            let base = serde_json::to_value(Style::default()).map_err(|e| EngineError::Other(e.to_string()))?;
+            serde_json::from_value(crate::cmd::format::merge_json(base, &st)).map_err(|e| bad("home.conditionalFormat", e.to_string()))?
+        }
+        _ => preset_style(g("preset").as_deref().unwrap_or("lightRedFillDarkRedText")),
+    });
+    let kind = g("type").unwrap_or_else(|| "cellIs".into());
+    let value_kind = |v: Option<&Json>, default: CfValueKind| -> CfValueKind {
+        match v {
+            Some(Json::Object(o)) => {
+                let t = o.get("type").and_then(Json::as_str).unwrap_or("num");
+                let val = o.get("value").and_then(Json::as_f64).unwrap_or(0.0);
+                match t {
+                    "min" => CfValueKind::Min,
+                    "max" => CfValueKind::Max,
+                    "percent" => CfValueKind::Percent(val),
+                    "percentile" => CfValueKind::Percentile(val),
+                    "formula" => CfValueKind::Formula(o.get("value").and_then(Json::as_str).unwrap_or("").into()),
+                    _ => CfValueKind::Number(val),
+                }
+            }
+            _ => default,
+        }
+    };
+    let rule = match kind.as_str() {
+        "cellIs" => {
+            // Excel's file and VBA names (`lessThan`, …) are accepted too.
+            let op = match g("operator").as_deref().unwrap_or("greater") {
+                "between" => CfOperator::Between,
+                "notBetween" => CfOperator::NotBetween,
+                "equal" => CfOperator::Equal,
+                "notEqual" => CfOperator::NotEqual,
+                "less" | "lessThan" => CfOperator::Less,
+                "greaterOrEqual" | "greaterThanOrEqual" => CfOperator::GreaterOrEqual,
+                "lessOrEqual" | "lessThanOrEqual" => CfOperator::LessOrEqual,
+                "greater" | "greaterThan" => CfOperator::Greater,
+                other => return Err(bad("home.conditionalFormat", format!("unknown operator `{other}`"))),
+            };
+            let a = rule.get("value").map(crate::cmd::edit::json_to_input).unwrap_or_default();
+            let b = rule.get("value2").map(crate::cmd::edit::json_to_input);
+            let quote = |v: String| {
+                // A number, a formula, or text already written as a string literal (`"Closed"`, as
+                // in the file and in openpyxl's `CellIsRule`) is kept; other text is quoted.
+                if gridcraft_core::parse::parse_number_text(&v).is_some() || v.starts_with('=') {
+                    v.trim_start_matches('=').to_string()
+                } else if is_string_literal(&v) {
+                    v
+                } else {
+                    format!("\"{}\"", v.replace('"', "\"\""))
+                }
+            };
+            CfRule::CellIs { op, a: quote(a), b: b.map(quote), style }
+        }
+        "expression" => CfRule::Expression { formula: g("formula").unwrap_or_default().trim_start_matches('=').to_string(), style },
+        "containsText" => CfRule::ContainsText { text: g("text").unwrap_or_default(), style },
+        "notContainsText" => CfRule::NotContainsText { text: g("text").unwrap_or_default(), style },
+        "beginsWith" => CfRule::BeginsWith { text: g("text").unwrap_or_default(), style },
+        "endsWith" => CfRule::EndsWith { text: g("text").unwrap_or_default(), style },
+        "blanks" => CfRule::Blanks { style },
+        "noBlanks" => CfRule::NoBlanks { style },
+        "errors" => CfRule::Errors { style },
+        "noErrors" => CfRule::NoErrors { style },
+        "duplicate" => CfRule::Duplicate { style },
+        "unique" => CfRule::Unique { style },
+        "top10" => CfRule::Top10 {
+            bottom: rule.get("bottom").and_then(Json::as_bool).unwrap_or(false),
+            percent: rule.get("percent").and_then(Json::as_bool).unwrap_or(false),
+            rank: rule.get("rank").and_then(Json::as_u64).unwrap_or(10) as u32,
+            style,
+        },
+        "aboveAverage" => CfRule::AboveAverage { below: rule.get("below").and_then(Json::as_bool).unwrap_or(false), equal: false, std_dev: 0, style },
+        "timePeriod" => CfRule::TimePeriod { period: g("period").unwrap_or_else(|| "today".into()), style },
+        "colorScale" => {
+            let cols: Vec<Color> = rule
+                .get("colors")
+                .and_then(Json::as_array)
+                .map(|a| a.iter().filter_map(|c| crate::cmd::format::color_param(Some(c))).collect())
+                .unwrap_or_else(|| vec![Color::rgb(0xF8, 0x69, 0x6B), Color::rgb(0xFF, 0xEB, 0x84), Color::rgb(0x63, 0xBE, 0x7B)]);
+            let stops = match cols.len() {
+                2 => vec![(CfValueKind::Min, cols[0]), (CfValueKind::Max, cols[1])],
+                _ => vec![
+                    (CfValueKind::Min, cols.first().copied().unwrap_or_default()),
+                    (CfValueKind::Percentile(50.0), cols.get(1).copied().unwrap_or_default()),
+                    (CfValueKind::Max, cols.get(2).copied().unwrap_or_default()),
+                ],
+            };
+            CfRule::ColorScale { stops }
+        }
+        "dataBar" => CfRule::DataBar {
+            min: value_kind(rule.get("min"), CfValueKind::Min),
+            max: value_kind(rule.get("max"), CfValueKind::Max),
+            color: crate::cmd::format::color_param(rule.get("color")).unwrap_or(Color::rgb(0x63, 0x8E, 0xC6)),
+            gradient: rule.get("gradient").and_then(Json::as_bool).unwrap_or(true),
+            show_value: true,
+        },
+        "iconSet" => CfRule::IconSet {
+            set: g("set").unwrap_or_else(|| "3TrafficLights1".into()),
+            thresholds: vec![],
+            reverse: rule.get("reverse").and_then(Json::as_bool).unwrap_or(false),
+            show_value: true,
+        },
+        other => return Err(bad("home.conditionalFormat", format!("unknown rule type `{other}`"))),
+    };
+    check_cf_rule(&rule)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        let priority = sh.cond_formats.iter().map(|c| c.priority).max().unwrap_or(0) + 1;
+        // New rules take precedence over older ones.
+        for cf in sh.cond_formats.iter_mut() {
+            cf.priority += 1;
+        }
+        sh.cond_formats.insert(0, CondFormat { ranges: ranges.clone(), rule, priority: 1, stop_if_true: false });
+        let _ = priority;
+        Ok(json!({"rules": sh.cond_formats.len()}))
+    })
+}
+
+pub(super) fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let whole = bool_param(p, "sheet").unwrap_or(false);
+    let ranges = target_ranges(s, p)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        if whole {
+            sh.cond_formats.clear();
+        } else {
+            for cf in sh.cond_formats.iter_mut() {
+                cf.ranges.retain(|r| !ranges.iter().any(|x| x.intersects(r)));
+            }
+            sh.cond_formats.retain(|c| !c.ranges.is_empty());
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn manage_cf(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    if p.get("delete").is_none() && p.get("moveUp").is_none() && p.get("moveDown").is_none() {
+        let list: Vec<Json> = s
+            .doc()?
+            .wb
+            .sheet(sheet)
+            .map(|sh| {
+                sh.cond_formats.iter().map(|c| json!({"ranges": c.ranges.iter().map(|r| r.a1()).collect::<Vec<_>>(), "rule": c.rule})).collect()
+            })
+            .unwrap_or_default();
+        return Ok(json!({"rules": list}));
+    }
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        // The count is taken again after each step: a delete shortens the list.
+        if let Some(i) = u32_param(p, "delete").map(|v| v as usize)
+            && i < sh.cond_formats.len()
+        {
+            sh.cond_formats.remove(i);
+        }
+        if let Some(i) = u32_param(p, "moveUp").map(|v| v as usize)
+            && i > 0
+            && i < sh.cond_formats.len()
+        {
+            sh.cond_formats.swap(i, i - 1);
+        }
+        if let Some(i) = u32_param(p, "moveDown").map(|v| v as usize)
+            && i + 1 < sh.cond_formats.len()
+        {
+            sh.cond_formats.swap(i, i + 1);
+        }
+        for (k, cf) in sh.cond_formats.iter_mut().enumerate() {
+            cf.priority = k as u32 + 1;
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn insert_icon(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").unwrap_or("check").to_string();
+    let size = f64_param(p, "size").unwrap_or(48.0).clamp(8.0, 1000.0) as f32;
+    let d = s.doc()?;
+    let id = d.wb.next_object_id();
+    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
+    let color = crate::cmd::format::color_param(p.get("color")).unwrap_or(Color::Theme(1, 0));
+    let shape = Shape {
+        id,
+        kind: ShapeKind::Icon,
+        anchor: Anchor { cell: at, dx: 4.0, dy: 4.0, width: size, height: size, mode: anchor_mode_param(p).unwrap_or_default() },
+        fill: color,
+        line: Color::Auto,
+        text: name,
+        format: Default::default(),
+    };
+    let sheet = d.wb.active_sheet();
+    edit(s, |cx| {
+        cx.sheet_mut(sheet)?.shapes.push(shape);
+        Ok(json!({"shape": id}))
+    })
+}
diff --git a/crates/engine/src/cmd/insert/links.rs b/crates/engine/src/cmd/insert/links.rs
new file mode 100644
index 000000000..a024350fd
--- /dev/null
+++ b/crates/engine/src/cmd/insert/links.rs
@@ -0,0 +1,157 @@
+use super::*;
+
+// ---------------------------------------------------------------- links & comments
+
+pub(super) fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
+    if bool_param(p, "remove").unwrap_or(false) {
+        return edit(s, |cx| {
+            cx.sheet_mut(sheet)?.hyperlinks.remove(&at);
+            Ok(Json::Null)
+        });
+    }
+    let Some(target) = str_param(p, "target").map(str::to_string) else {
+        s.ui_requests.push(crate::UiRequest::Dialog("insertLink".into(), json!({})));
+        return ok();
+    };
+    let text = str_param(p, "text").map(str::to_string);
+    let tooltip = str_param(p, "tooltip").map(str::to_string);
+    let external = links_outside(&s.doc()?.wb, sheet, &target);
+    edit(s, |cx| {
+        let link_style = cx.wb.styles.derive(cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(), |st| {
+            st.font.color = Color::Theme(10, 0);
+            st.font.underline = Underline::Single;
+        });
+        let sh = cx.sheet_mut(sheet)?;
+        if let Some(t) = text.clone().or_else(|| sh.value(at).is_empty().then(|| target.clone())) {
+            sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style });
+        } else {
+            sh.set_style(at, link_style);
+        }
+        sh.hyperlinks.insert(at, Hyperlink { target: target.clone(), tooltip: tooltip.clone(), external });
+        cx.touch(sheet, at);
+        Ok(Json::Null)
+    })
+}
+
+/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the
+/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no
+/// dialog; the interactive click asks for confirmation first, in the UI.
+pub(super) fn open_link(s: &mut Session, p: &Json) -> Result<Json> {
+    let target = match str_param(p, "url").or_else(|| str_param(p, "target")) {
+        Some(t) => t.to_string(),
+        None => {
+            let sheet = target_sheet(s, p)?;
+            let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
+            let Some(h) = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.hyperlinks.get(&at)) else {
+                return Err(EngineError::Other("There's no hyperlink in this cell.".into()));
+            };
+            h.target.clone()
+        }
+    };
+    match crate::links::classify(&target) {
+        crate::links::LinkKind::Internal(r) => crate::cmd::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})),
+        crate::links::LinkKind::External(u) => {
+            s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone()));
+            Ok(json!({"opened": u}))
+        }
+        crate::links::LinkKind::Refused(why) => Err(EngineError::Other(why)),
+    }
+}
+
+/// Sorts a link target as the two pages of Excel's Insert Hyperlink dialog do: "Place in This
+/// Document" is a sheet reference, a defined name or `#…`; anything else ("Existing File or Web
+/// Page") is outside the workbook and saved as a relationship.
+fn links_outside(wb: &Workbook, sheet: usize, target: &str) -> bool {
+    let t = target.trim();
+    if t.starts_with('#') || wb.name(t, sheet).is_some() || wb.table(t).is_some() {
+        return false;
+    }
+    let (on, body) = split_sheet(t);
+    // Sheet names can't hold `: \ / ? * [ ]`, so `https://…!A1` or `C:\…!A1` is no sheet reference,
+    // and `Book.xlsx#Sheet1!A1` is a place in another file unless a sheet has that name.
+    let on_sheet = on.is_none_or(|name| {
+        wb.sheets.iter().any(|s| s.name.eq_ignore_ascii_case(&name))
+            || (!name.is_empty() && !name.contains([':', '\\', '/', '?', '*', '[', ']', '#']))
+    });
+    !(on_sheet && RangeRef::parse(body).is_some())
+}
+
+pub(super) fn comment(s: &mut Session, p: &Json, threaded: bool) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
+    let text = str_param(p, "text").unwrap_or("").to_string();
+    let named = str_param(p, "author").map(str::to_string);
+    let author = named.clone().unwrap_or_else(|| s.prefs.user_name.clone());
+    edit(s, |cx| {
+        let comments = &mut cx.sheet_mut(sheet)?.comments;
+        // Writing a note on a cell that has one edits it, as Excel's Edit Note does: the box, the
+        // replies, the dates and who wrote it stay. A note replaces a comment and vice versa.
+        if let Some(c) = comments.get_mut(&at).filter(|c| c.threaded == threaded) {
+            c.text = text.clone();
+            if let Some(author) = named.clone() {
+                c.author = author;
+            }
+            return Ok(json!({"cell": at.a1()}));
+        }
+        comments.insert(
+            at,
+            Comment {
+                author: author.clone(),
+                text: text.clone(),
+                replies: vec![],
+                threaded,
+                resolved: false,
+                visible: false,
+                dates: vec![],
+                note_box: None,
+            },
+        );
+        Ok(json!({"cell": at.a1()}))
+    })
+}
+
+pub(super) fn reply_comment(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
+    let text = str_param(p, "text").unwrap_or("").to_string();
+    let author = str_param(p, "author").map(str::to_string).unwrap_or_else(|| s.prefs.user_name.clone());
+    edit(s, |cx| {
+        let c = cx.sheet_mut(sheet)?.comments.get_mut(&at).ok_or_else(|| EngineError::Other("There's no comment in this cell.".into()))?;
+        c.replies.push((author.clone(), text.clone()));
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn resolve_comment(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
+    let v = bool_param(p, "resolved").unwrap_or(true);
+    edit(s, |cx| {
+        if let Some(c) = cx.sheet_mut(sheet)?.comments.get_mut(&at) {
+            c.resolved = v;
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn delete_comment(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let ranges = target_ranges(s, p)?;
+    edit(s, |cx| {
+        cx.sheet_mut(sheet)?.comments.retain(|c, _| !ranges.iter().any(|r| r.contains(*c)));
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn show_note(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = cell_param_on(s, p, "cell", sheet)?.unwrap_or(s.doc()?.selection.active);
+    edit(s, |cx| {
+        if let Some(c) = cx.sheet_mut(sheet)?.comments.get_mut(&at) {
+            c.visible = !c.visible;
+        }
+        Ok(Json::Null)
+    })
+}
diff --git a/crates/engine/src/cmd/insert/objects.rs b/crates/engine/src/cmd/insert/objects.rs
new file mode 100644
index 000000000..e4486b7e4
--- /dev/null
+++ b/crates/engine/src/cmd/insert/objects.rs
@@ -0,0 +1,264 @@
+use super::*;
+
+pub(super) fn insert_sparkline(s: &mut Session, p: &Json) -> Result<Json> {
+    let src = str_param(p, "range").ok_or_else(|| bad("insert.sparkline", "missing `range`"))?.to_string();
+    let loc = cell_param(s, p, "location")?.ok_or_else(|| bad("insert.sparkline", "missing `location`"))?;
+    let kind = match str_param(p, "type") {
+        Some("column") => SparklineKind::Column,
+        Some("winLoss") => SparklineKind::WinLoss,
+        _ => SparklineKind::Line,
+    };
+    let markers = bool_param(p, "markers").unwrap_or(false);
+    let sheet = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        sh.sparklines.retain(|x| x.cell != loc);
+        sh.sparklines.push(Sparkline { cell: loc, source: src.clone(), kind, color: Color::Theme(4, 0), markers });
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
+    let placement = str_param(p, "placement").unwrap_or("overCells");
+    if !matches!(placement, "cell" | "overCells") {
+        return Err(bad("insert.picture", "placement must be cell or overCells"));
+    }
+    let data = if let Some(b) = str_param(p, "base64") {
+        crate::io::base64_decode(b).ok_or_else(|| bad("insert.picture", "invalid base64"))?
+    } else if let Some(path) = str_param(p, "path") {
+        crate::io::read_file(path)?
+    } else {
+        s.ui_requests.push(crate::UiRequest::Dialog("insertPicture".into(), json!({"placement": placement})));
+        return ok();
+    };
+    if placement == "cell" {
+        let mime = validate_cell_picture(&data)?;
+        let d = s.doc()?;
+        let sheet = d.wb.active_sheet();
+        let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+        let at = match str_param(p, "at") {
+            Some(a) => CellRef::parse(a).ok_or_else(|| bad("insert.picture", "invalid cell address"))?,
+            None => d.selection.active,
+        };
+        let at = sh.merge_at(at).map(|r| r.start).unwrap_or(at);
+        let style = sh.style_id(at);
+        if sh.is_protected() && d.wb.styles.get(style).protection.locked && locked_cell_error(sh, at, &d.unlocked_ranges).is_some() {
+            return Err(EngineError::Other("The cell you're trying to change is on a protected sheet.".into()));
+        }
+        let picture = CellPicture { data, mime: mime.into(), alt: str_param(p, "alt").unwrap_or("").into() };
+        return edit(s, |cx| {
+            cx.sheet_mut(sheet)?.set_picture(at, std::sync::Arc::new(picture));
+            cx.touch(sheet, at);
+            Ok(json!({"cell": at.a1(), "placement": "cell"}))
+        });
+    }
+    if data.len() > 64 * 1024 * 1024 {
+        return Err(bad("insert.picture", "image larger than 64 MB"));
+    }
+    let mime = str_param(p, "mime")
+        .map(str::to_string)
+        .unwrap_or_else(|| if data.starts_with(&[0x89, b'P', b'N', b'G']) { "image/png".into() } else { "image/jpeg".into() });
+    let (w, h) = crate::io::image_size(&data).unwrap_or((320, 240));
+    let d = s.doc()?;
+    let id = d.wb.next_object_id();
+    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
+    let scale = (640.0 / w.max(1) as f32).min(1.0);
+    let img = Image {
+        id,
+        anchor: Anchor {
+            cell: at,
+            dx: 0.0,
+            dy: 0.0,
+            width: f64_param(p, "width").map(|v| v as f32).unwrap_or(w as f32 * scale),
+            height: f64_param(p, "height").map(|v| v as f32).unwrap_or(h as f32 * scale),
+            // Excel inserts pictures as "Move but don't size with cells" (`editAs="oneCell"`).
+            mode: anchor_mode_param(p).unwrap_or(gridcraft_model::AnchorMode::MoveOnly),
+        },
+        data: data.into(),
+        mime,
+        alt: str_param(p, "alt").unwrap_or("").into(),
+    };
+    let sheet = d.wb.active_sheet();
+    edit(s, |cx| {
+        cx.sheet_mut(sheet)?.images.push(img);
+        Ok(json!({"image": id}))
+    })
+}
+
+/// Validate before mutating the workbook; header dimensions alone do not prove the pixels decode.
+fn validate_cell_picture(data: &[u8]) -> Result<&'static str> {
+    if data.len() > 16 * 1024 * 1024 {
+        return Err(bad("insert.picture", "cell pictures must be at most 16 MiB"));
+    }
+    let format = image::guess_format(data).map_err(|_| bad("insert.picture", "choose a valid PNG or JPEG picture"))?;
+    let mime = match format {
+        image::ImageFormat::Png => "image/png",
+        image::ImageFormat::Jpeg => "image/jpeg",
+        _ => return Err(bad("insert.picture", "cell pictures support PNG and JPEG")),
+    };
+    let (width, height) = image::ImageReader::with_format(std::io::Cursor::new(data), format)
+        .into_dimensions()
+        .map_err(|_| bad("insert.picture", "invalid image dimensions"))?;
+    if width == 0 || height == 0 || width > 8192 || height > 8192 || u64::from(width) * u64::from(height) > 16_000_000 {
+        return Err(bad("insert.picture", "cell pictures are limited to 8192 pixels per side and 16 million pixels"));
+    }
+    let mut reader = image::ImageReader::with_format(std::io::Cursor::new(data), format);
+    let mut limits = image::Limits::default();
+    limits.max_image_width = Some(8192);
+    limits.max_image_height = Some(8192);
+    limits.max_alloc = Some(64 * 1024 * 1024);
+    reader.limits(limits);
+    reader.decode().map_err(|_| bad("insert.picture", "picture cannot be decoded within the 64 MiB limit"))?;
+    Ok(mime)
+}
+
+pub(super) fn insert_shape(s: &mut Session, p: &Json) -> Result<Json> {
+    let kind = match str_param(p, "kind").unwrap_or("rectangle") {
+        "roundedRectangle" => ShapeKind::RoundedRectangle,
+        "ellipse" | "oval" => ShapeKind::Ellipse,
+        "triangle" => ShapeKind::Triangle,
+        "line" => ShapeKind::Line,
+        "arrow" => ShapeKind::Arrow,
+        "textBox" => ShapeKind::TextBox,
+        _ => ShapeKind::Rectangle,
+    };
+    let d = s.doc()?;
+    let id = d.wb.next_object_id();
+    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
+    let fill = crate::cmd::format::color_param(p.get("fill")).unwrap_or(if kind == ShapeKind::TextBox {
+        Color::rgb(255, 255, 255)
+    } else {
+        Color::Theme(4, 0)
+    });
+    let line = crate::cmd::format::color_param(p.get("line")).unwrap_or(if kind == ShapeKind::TextBox {
+        Color::rgb(0x80, 0x80, 0x80)
+    } else {
+        Color::Theme(4, -250)
+    });
+    let shape = Shape {
+        id,
+        kind,
+        anchor: Anchor {
+            cell: at,
+            dx: 0.0,
+            dy: 0.0,
+            width: f64_param(p, "width").unwrap_or(144.0) as f32,
+            height: f64_param(p, "height").unwrap_or(if kind == ShapeKind::Line { 0.0 } else { 96.0 }) as f32,
+            mode: anchor_mode_param(p).unwrap_or_default(),
+        },
+        fill,
+        line,
+        text: str_param(p, "text").unwrap_or("").into(),
+        format: Default::default(),
+    };
+    let sheet = d.wb.active_sheet();
+    edit(s, |cx| {
+        cx.sheet_mut(sheet)?.shapes.push(shape);
+        Ok(json!({"shape": id}))
+    })
+}
+
+/// A text box holds at most as many characters as a cell.
+const SHAPE_TEXT_MAX_CHARS: usize = 32_767;
+
+pub(super) fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
+    let id =
+        p.get("id").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok()).ok_or_else(|| bad("shape.setText", "`id` must be a text box id"))?;
+    let text = str_param(p, "text").ok_or_else(|| bad("shape.setText", "`text` must be a string"))?;
+    if text.chars().nth(SHAPE_TEXT_MAX_CHARS).is_some() {
+        return Err(bad("shape.setText", "`text` is longer than 32,767 characters"));
+    }
+    let d = s.doc()?;
+    let sheet = d.wb.active_sheet();
+    let sh = d.wb.active().ok_or_else(|| bad("shape.setText", "no such text box"))?;
+    let shape = sh.shapes.iter().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
+    if shape.kind != ShapeKind::TextBox {
+        return Err(bad("shape.setText", "the shape is not a text box"));
+    }
+    // Sheet protection locks drawing objects (there is no "edit objects" allowance yet).
+    if sh.is_protected() {
+        return Err(EngineError::Other(PROTECTED.into()));
+    }
+    if shape.text == text {
+        return ok();
+    }
+    edit(s, |cx| {
+        let shape = cx.sheet_mut(sheet)?.shapes.iter_mut().find(|shape| shape.id == id).ok_or_else(|| bad("shape.setText", "no such text box"))?;
+        shape.text = text.into();
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn delete_object(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = u32_param(p, "id").ok_or_else(|| bad("object.delete", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("").to_string();
+    let sheet = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        match kind.as_str() {
+            "chart" => sh.charts.retain(|c| c.id != id),
+            "image" => sh.images.retain(|c| c.id != id),
+            "slicer" => sh.slicers.retain(|c| c.id != id),
+            _ => sh.shapes.retain(|c| c.id != id),
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = u32_param(p, "id").ok_or_else(|| bad("object.move", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("").to_string();
+    let sheet = s.doc()?.wb.active_sheet();
+    let at = cell_param(s, p, "at")?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        let anchor = match kind.as_str() {
+            "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "slicer" => sh.slicers.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "shape" => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            _ => None,
+        };
+        let Some(a) = anchor else { return Err(bad("object.move", "no such object")) };
+        if let Some(at) = at {
+            a.cell = at;
+        }
+        if let Some(v) = f64_param(p, "dx") {
+            a.dx = v as f32;
+        }
+        if let Some(v) = f64_param(p, "dy") {
+            a.dy = v as f32;
+        }
+        if let Some(v) = f64_param(p, "width") {
+            a.width = v.clamp(1.0, 10000.0) as f32;
+        }
+        if let Some(v) = f64_param(p, "height") {
+            a.height = v.clamp(0.0, 10000.0) as f32;
+        }
+        Ok(Json::Null)
+    })
+}
+
+/// Sets an object's anchor mode (Excel's "Move and size with cells" / "Move but don't size with
+/// cells" / "Don't move or size with cells"), so it follows — or ignores — its rows and columns
+/// when the sheet is sorted or edited structurally.
+pub(super) fn set_anchor_mode(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = u32_param(p, "id").ok_or_else(|| bad("object.setAnchorMode", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("").to_string();
+    if !matches!(kind.as_str(), "chart" | "image" | "shape") {
+        return Err(bad("object.setAnchorMode", "kind must be chart, image or shape"));
+    }
+    let mode = anchor_mode_param(p).ok_or_else(|| bad("object.setAnchorMode", "mode must be moveAndSize, moveOnly or absolute"))?;
+    let sheet = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        let anchor = match kind.as_str() {
+            "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            _ => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+        };
+        let Some(a) = anchor else { return Err(bad("object.setAnchorMode", "no such object")) };
+        a.mode = mode;
+        Ok(json!({"mode": anchor_mode_name(mode)}))
+    })
+}
diff --git a/crates/engine/src/cmd/insert/table.rs b/crates/engine/src/cmd/insert/table.rs
new file mode 100644
index 000000000..461af7861
--- /dev/null
+++ b/crates/engine/src/cmd/insert/table.rs
@@ -0,0 +1,331 @@
+use super::*;
+
+// ---------------------------------------------------------------- tables
+
+pub(super) fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
+    let r = block(s, p)?;
+    let sheet = target_sheet(s, p)?;
+    let d = s.doc()?;
+    if d.wb.sheet(sheet).is_some_and(|sh| sh.tables.iter().any(|t| t.range.intersects(&r))) {
+        return Err(EngineError::Other("A table can't overlap another table.".into()));
+    }
+    let arrays = |sh: &gridcraft_model::Sheet| {
+        sh.cells.iter().any(|(_, x)| x.formula.as_ref().and_then(|f| f.array).is_some_and(|a| !a.is_single() && a.intersects(&r)))
+    };
+    if d.wb.sheet(sheet).is_some_and(arrays) {
+        return Err(EngineError::Other("Multi-cell array formulas aren't allowed in tables.".into()));
+    }
+    if r.count() > 50_000_000 {
+        return Err(bad("insert.table", "range too large"));
+    }
+    let header = bool_param(p, "header").unwrap_or_else(|| {
+        let sh = d.wb.sheet(sheet);
+        sh.is_some_and(|sh| (r.start.col..=r.end.col).all(|c| sh.value(CellRef::new(r.start.row, c)).is_text()) && r.height() > 1)
+    });
+    let name = str_param(p, "name")
+        .map(str::to_string)
+        .unwrap_or_else(|| (1..).map(|n| format!("Table{n}")).find(|n| d.wb.table(n).is_none()).unwrap_or_else(|| "Table".into()));
+    if !valid_table_name(&name) {
+        return Err(EngineError::Other("The name that you entered is not valid.".into()));
+    }
+    if d.wb.table(&name).is_some() || d.wb.names.iter().any(|n| n.name.eq_ignore_ascii_case(&name)) {
+        return Err(EngineError::Other("The name entered already exists. Enter a unique name.".into()));
+    }
+    // Without a header row, the data moves down a row to make room for one: never a table with it.
+    let moves_a_table = |sh: &gridcraft_model::Sheet| {
+        sh.tables.iter().any(|t| t.range.end.row >= r.start.row && t.range.start.col <= r.end.col && t.range.end.col >= r.start.col)
+    };
+    if !header && d.wb.sheet(sheet).is_some_and(moves_a_table) {
+        return Err(EngineError::Other("This operation isn't allowed: it would shift cells in a table on your worksheet.".into()));
+    }
+    let style = str_param(p, "style").unwrap_or("TableStyleMedium2").to_string();
+    let id = d.wb.next_object_id();
+    edit(s, |cx| {
+        // Without a header row, insert one with generic names.
+        let r = if header {
+            r
+        } else {
+            let sh = cx.sheet_mut(sheet)?;
+            // The header row pushes the data down one row: never off the end of the sheet.
+            let last = RangeRef::new(CellRef::new(MAX_ROWS - 1, r.start.col), CellRef::new(MAX_ROWS - 1, r.end.col));
+            if sh.cells.iter_range(last).any(|(_, x)| x.formula.is_some() || !x.value.is_empty()) {
+                return Err(EngineError::Other("To prevent possible loss of data, cells can't be pushed off the end of the worksheet.".into()));
+            }
+            sh.cells.shift_rows_in_cols(r.start.col, r.end.col, r.start.row, 1);
+            // Like Insert Cells > Shift down: move merges, conditional formats, notes, links and pictures, and re-point every formula
+            // reference (on any sheet) at the cells that moved.
+            let e = Edit::InsertCells { axis: Axis::Rows, range: RangeRef::new(r.start, CellRef::new(r.start.row, r.end.col)) };
+            shift_cell_features(sh, &e);
+            let name = sh.name.clone();
+            rewrite(&mut cx.wb, &name, &e);
+            let sh = cx.sheet_mut(sheet)?;
+            for (i, c) in (r.start.col..=r.end.col).enumerate() {
+                sh.set_value(CellRef::new(r.start.row, c), gridcraft_core::Value::text(format!("Column{}", i + 1)));
+            }
+            cx.structural = true;
+            RangeRef::new(r.start, CellRef::new((r.end.row + 1).min(MAX_ROWS - 1), r.end.col))
+        };
+        let sh = cx.sheet_mut(sheet)?;
+        let mut names: Vec<String> = Vec::new();
+        // Lower-case names taken, and the next suffix for each header, so that thousands of equal
+        // headers don't take cubic time.
+        let mut taken = std::collections::HashSet::new();
+        let mut next_suffix = std::collections::HashMap::new();
+        for c in r.start.col..=r.end.col {
+            let mut n = sh.value(CellRef::new(r.start.row, c)).display();
+            if n.is_empty() {
+                n = format!("Column{}", c - r.start.col + 1);
+            }
+            let base = n.clone();
+            let key = base.to_ascii_lowercase();
+            let mut k = next_suffix.get(&key).copied().unwrap_or(2);
+            while taken.contains(&n.to_ascii_lowercase()) {
+                n = format!("{base}{k}");
+                k += 1;
+            }
+            next_suffix.insert(key, k);
+            taken.insert(n.to_ascii_lowercase());
+            // Headers are text.
+            sh.set_value(CellRef::new(r.start.row, c), gridcraft_core::Value::text(n.as_str()));
+            names.push(n);
+        }
+        sh.tables.push(Table {
+            id,
+            name: name.clone(),
+            range: r,
+            header_row: true,
+            totals_row: false,
+            columns: names
+                .into_iter()
+                .map(|n| TableColumn { name: n, totals: TotalsFn::None, totals_label: None, formula: None, unique_name: None, xml: None })
+                .collect(),
+            style,
+            banded_rows: true,
+            banded_cols: false,
+            first_col: false,
+            last_col: false,
+            filter_button: true,
+            filter: vec![],
+            table_type: None,
+            connection_id: None,
+        });
+        cx.structural = true;
+        Ok(json!({"table": name, "range": r.a1()}))
+    })
+}
+
+/// Format as Table inside a table restyles that table, as in Excel; elsewhere it makes a new one.
+pub(super) fn format_as_table(s: &mut Session, p: &Json) -> Result<Json> {
+    // Without a range, the active area decides (as in insert_table), not the first one.
+    let r = if p.get("range").is_some() { target_range(s, p)? } else { s.doc()?.selection.current() };
+    let sheet = target_sheet(s, p)?;
+    let inside = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.tables.iter().find(|t| t.range.contains_range(&r))).map(|t| (t.name.clone(), t.range));
+    match inside {
+        Some((table, range)) => {
+            table_style(s, &with(p, "table", json!(table)))?;
+            Ok(json!({"table": table, "range": range.a1()}))
+        }
+        None => insert_table(s, p),
+    }
+}
+
+fn find_table(s: &Session, p: &Json) -> Result<(usize, usize)> {
+    let d = s.doc()?;
+    if let Some(n) = str_param(p, "table") {
+        return d.wb.table(n).ok_or_else(|| bad("table", format!("no table named `{n}`")));
+    }
+    let sheet = d.wb.active_sheet();
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let ti = sh
+        .tables
+        .iter()
+        .position(|t| t.range.contains(d.selection.active))
+        .ok_or_else(|| EngineError::Disabled("table".into(), "select a cell in a table".into()))?;
+    Ok((sheet, ti))
+}
+
+pub(super) fn table_flag(s: &mut Session, p: &Json, which: &str) -> Result<Json> {
+    let (si, ti) = find_table(s, p)?;
+    let on = bool_param(p, "on");
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        let Some(t) = sh.tables.get_mut(ti) else { return Ok(Json::Null) };
+        match which {
+            "totals" => {
+                let v = on.unwrap_or(!t.totals_row);
+                if v != t.totals_row {
+                    if v && t.range.end.row.saturating_add(1) >= MAX_ROWS {
+                        return Err(EngineError::Other("There's no room below the table for the total row.".into()));
+                    }
+                    t.totals_row = v;
+                    if v {
+                        t.range.end.row += 1;
+                        if let Some(first) = t.columns.first_mut() {
+                            first.totals_label = Some("Total".into());
+                        }
+                        if t.columns.len() > 1
+                            && let Some(last) = t.columns.last_mut()
+                            && last.totals == TotalsFn::None
+                        {
+                            last.totals = TotalsFn::Sum;
+                        }
+                    } else {
+                        let row = t.range.end.row;
+                        t.range.end.row = t.range.end.row.saturating_sub(1);
+                        let (c0, c1) = (t.range.start.col, t.range.end.col);
+                        for c in c0..=c1 {
+                            sh.remove_cell(CellRef::new(row, c));
+                        }
+                    }
+                    write_totals(sh, ti);
+                    cx.structural = true;
+                }
+            }
+            "bandedRows" => t.banded_rows = on.unwrap_or(!t.banded_rows),
+            "bandedCols" => t.banded_cols = on.unwrap_or(!t.banded_cols),
+            "firstCol" => t.first_col = on.unwrap_or(!t.first_col),
+            "lastCol" => t.last_col = on.unwrap_or(!t.last_col),
+            "header" => {
+                t.filter_button = on.unwrap_or(!t.filter_button);
+                if !t.filter_button {
+                    t.filter.clear();
+                }
+            }
+            _ => {}
+        }
+        Ok(Json::Null)
+    })
+}
+
+/// Writes the totals row cells (labels and SUBTOTAL formulas).
+fn write_totals(sh: &mut Sheet, ti: usize) {
+    let Some(t) = sh.tables.get(ti).cloned() else { return };
+    if !t.totals_row {
+        return;
+    }
+    let row = t.range.end.row;
+    for (i, col) in t.columns.iter().enumerate() {
+        let c = CellRef::new(row, t.range.start.col + i as u32);
+        if let Some(code) = col.totals.subtotal_code() {
+            let f = format!("=SUBTOTAL({code},{}[{}])", t.name, col.name);
+            sh.set_cell(c, Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c) });
+        } else if let Some(l) = &col.totals_label {
+            sh.set_value(c, gridcraft_core::Value::text(l.as_str()));
+        } else {
+            sh.remove_cell(c);
+        }
+    }
+}
+
+pub(super) fn table_total_fn(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ti) = find_table(s, p)?;
+    let col = str_param(p, "column").ok_or_else(|| bad("table.totalFunction", "missing `column`"))?.to_string();
+    let f = match str_param(p, "function").unwrap_or("sum") {
+        "average" => TotalsFn::Average,
+        "count" => TotalsFn::Count,
+        "countNums" => TotalsFn::CountNums,
+        "max" => TotalsFn::Max,
+        "min" => TotalsFn::Min,
+        "stdDev" => TotalsFn::StdDev,
+        "var" => TotalsFn::Var,
+        "none" => TotalsFn::None,
+        _ => TotalsFn::Sum,
+    };
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        if let Some(t) = sh.tables.get_mut(ti)
+            && let Some(i) = t.column_index(&col)
+            && let Some(c) = t.columns.get_mut(i)
+        {
+            c.totals = f;
+        }
+        write_totals(sh, ti);
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn table_style(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ti) = find_table(s, p)?;
+    let style = str_param(p, "style").unwrap_or("TableStyleMedium2").to_string();
+    edit(s, |cx| {
+        if let Some(t) = cx.sheet_mut(si)?.tables.get_mut(ti) {
+            t.style = style.clone();
+        }
+        Ok(Json::Null)
+    })
+}
+
+/// Table names follow the Microsoft name rules, as the xlsx writer does: letters, digits, `_` and `.`,
+/// starting with a letter, `_` or `\`, and at most 255 characters. Anything else (a hyphen, say) would
+/// read as an operator inside a structured reference, and the writer would rename the table on save.
+fn valid_table_name(name: &str) -> bool {
+    name.chars().count() <= 255
+        && name.starts_with(|c: char| c.is_alphabetic() || c == '_' || c == '\\')
+        && CellRef::parse(name).is_none()
+        && !crate::cmd::formulas::is_r1c1(name)
+        && name.chars().enumerate().all(|(i, c)| c.is_alphanumeric() || c == '_' || c == '.' || (i == 0 && c == '\\'))
+}
+
+pub(super) fn table_rename(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ti) = find_table(s, p)?;
+    let name = str_param(p, "name").ok_or_else(|| bad("table.rename", "missing `name`"))?.to_string();
+    if !valid_table_name(&name) {
+        return Err(EngineError::Other("The name that you entered is not valid.".into()));
+    }
+    let wb = &s.doc()?.wb;
+    if wb.table(&name).is_some_and(|x| x != (si, ti)) || wb.names.iter().any(|n| n.name.eq_ignore_ascii_case(&name)) {
+        return Err(EngineError::Other("The name entered already exists. Enter a unique name.".into()));
+    }
+    edit(s, |cx| {
+        let old = cx.wb.sheet(si).and_then(|sh| sh.tables.get(ti)).map(|t| t.name.clone()).unwrap_or_default();
+        if let Some(t) = cx.sheet_mut(si)?.tables.get_mut(ti) {
+            t.name = name.clone();
+        }
+        // Structured references follow the rename.
+        for i in 0..cx.wb.sheets.len() {
+            let keys: Vec<(CellRef, std::sync::Arc<Formula>)> =
+                cx.wb.sheets.get(i).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
+            // A bare name that is also a defined name resolves to the defined name, so it is not the table.
+            let shadowed = cx.wb.name(&old, i).is_some();
+            let Some(sh) = cx.wb.sheet_mut(i) else { continue };
+            for (c, f) in keys {
+                let Some(e) = f.expr() else { continue };
+                let ne = e.map(&mut |x| match x {
+                    gridcraft_formula::Expr::Struct(mut st) if st.table.eq_ignore_ascii_case(&old) => {
+                        st.table = name.clone();
+                        gridcraft_formula::Expr::Struct(st)
+                    }
+                    gridcraft_formula::Expr::Name(n) if !shadowed && n.eq_ignore_ascii_case(&old) => gridcraft_formula::Expr::Name(name.clone()),
+                    o => o,
+                });
+                if let Some(cell) = sh.cells.get_mut(c) {
+                    cell.formula = Some(std::sync::Arc::new(Formula::from_expr(ne)));
+                }
+            }
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn table_convert(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ti) = find_table(s, p)?;
+    edit(s, |cx| {
+        // Apply the table look as plain formatting, then drop the table.
+        let wb = &mut cx.wb;
+        let Some(t) = wb.sheet(si).and_then(|sh| sh.tables.get(ti)).cloned() else { return Ok(Json::Null) };
+        let looks: Vec<(CellRef, Style)> = t.range.iter().map(|c| (c, crate::tables::table_cell_style(wb, si, &t, c))).collect();
+        for (c, st) in looks {
+            let id = wb.styles.intern(st);
+            if let Some(sh) = wb.sheet_mut(si) {
+                sh.set_style(c, id);
+            }
+        }
+        if let Some(sh) = wb.sheet_mut(si) {
+            sh.tables.remove(ti);
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}

From b0818bccc35991e014bdeee38878c92b0ee5bf7e Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:44:09 +0000
Subject: [PATCH 43/76] refactor(calc): move eval.rs items to eval/

---
 crates/calc/src/eval.rs               | 1445 +------------------------
 crates/calc/src/eval/array.rs         |  180 +++
 crates/calc/src/eval/call.rs          |  424 ++++++++
 crates/calc/src/eval/format.rs        |   74 ++
 crates/calc/src/eval/lambda.rs        |  198 ++++
 crates/calc/src/eval/reference_fns.rs |  407 +++++++
 crates/calc/src/eval/special.rs       |  167 +++
 7 files changed, 1462 insertions(+), 1433 deletions(-)
 create mode 100644 crates/calc/src/eval/array.rs
 create mode 100644 crates/calc/src/eval/call.rs
 create mode 100644 crates/calc/src/eval/format.rs
 create mode 100644 crates/calc/src/eval/lambda.rs
 create mode 100644 crates/calc/src/eval/reference_fns.rs
 create mode 100644 crates/calc/src/eval/special.rs

diff --git a/crates/calc/src/eval.rs b/crates/calc/src/eval.rs
index 4bdb3a30d..45d81ccca 100644
--- a/crates/calc/src/eval.rs
+++ b/crates/calc/src/eval.rs
@@ -11,6 +11,18 @@ use gridcraft_formula::{BinOp, Expr, RefKind, Reference, SheetSel, StructItem, S
 use gridcraft_functions::{Arg, Ctx};
 use gridcraft_model::Workbook;
 
+mod array;
+mod call;
+mod format;
+mod lambda;
+mod reference_fns;
+mod special;
+
+use array::map_unary;
+pub use array::{binary_values, zip2};
+pub use format::r1c1_to_a1;
+pub use special::{SPECIAL_FUNCTIONS, is_known_function, precedents, resized_sum_range};
+
 /// Largest array a reference may expand to.
 pub const MAX_CELLS: u64 = 16_000_000;
 /// References up to this many cells (one whole row) are always read at their full size.
@@ -615,1021 +627,6 @@ impl<'h> Evaluator<'h> {
             }
         }
     }
-
-    fn call(&mut self, name: &str, args: &[Expr]) -> Ev {
-        match name {
-            "IF" => {
-                if args.is_empty() || args.len() > 3 {
-                    return err(CellError::Value);
-                }
-                let c = self.arg_val(args, 0).unwrap_or_default();
-                if let Value::Array(arr) = &c {
-                    // Array condition: element-wise.
-                    let t = self.arg_val(args, 1).unwrap_or(Value::Bool(true));
-                    let f = if args.len() > 2 { self.arg_val(args, 2).unwrap_or(Value::Bool(false)) } else { Value::Bool(false) };
-                    return Ev::V(zip3(arr, &t, &f, |c, t, f| match c.to_bool() {
-                        Ok(true) => t.clone(),
-                        Ok(false) => f.clone(),
-                        Err(e) => Value::Error(e),
-                    }));
-                }
-                match c.to_bool() {
-                    Ok(true) => match args.get(1) {
-                        Some(Expr::Missing) => Ev::V(Value::Number(0.0)),
-                        Some(e) => self.eval(e),
-                        None => Ev::V(Value::Bool(true)),
-                    },
-                    Ok(false) => match args.get(2) {
-                        Some(Expr::Missing) => Ev::V(Value::Number(0.0)),
-                        Some(e) => self.eval(e),
-                        None => Ev::V(Value::Bool(false)),
-                    },
-                    Err(e) => err(e),
-                }
-            }
-            "IFS" => {
-                if args.len() < 2 || !args.len().is_multiple_of(2) {
-                    return err(CellError::Value);
-                }
-                for pair in args.chunks(2) {
-                    let [c, v] = pair else { break };
-                    let cv = self.value(c);
-                    match cv.scalar().to_bool() {
-                        Ok(true) => return self.eval(v),
-                        Ok(false) => {}
-                        Err(e) => return err(e),
-                    }
-                }
-                err(CellError::NA)
-            }
-            "IFERROR" | "IFNA" => {
-                if args.len() != 2 {
-                    return err(CellError::Value);
-                }
-                let v = self.arg_ev(args, 0).unwrap_or(Ev::V(Value::Empty));
-                let na_only = name == "IFNA";
-                let catch = |e: CellError| if na_only { e == CellError::NA } else { true };
-                match &v {
-                    Ev::V(Value::Error(e)) if catch(*e) => self.eval(&args[1]),
-                    Ev::V(Value::Array(a)) if a.data.iter().any(|x| x.as_error().is_some_and(catch)) => {
-                        let alt = self.arg_val(args, 1).unwrap_or_default();
-                        let data = a.data.iter().map(|x| if x.as_error().is_some_and(catch) { alt.scalar() } else { x.clone() }).collect();
-                        Ev::V(Array::new(a.rows, a.cols, data).map(Value::from).unwrap_or(Value::Error(CellError::Value)))
-                    }
-                    Ev::R(_) => {
-                        let val = self.deref(v.clone());
-                        match val {
-                            Value::Error(e) if catch(e) => self.eval(&args[1]),
-                            Value::Array(ref a) if a.data.iter().any(|x| x.as_error().is_some_and(catch)) => {
-                                let alt = self.arg_val(args, 1).unwrap_or_default();
-                                let data = a.data.iter().map(|x| if x.as_error().is_some_and(catch) { alt.scalar() } else { x.clone() }).collect();
-                                Ev::V(Array::new(a.rows, a.cols, data).map(Value::from).unwrap_or(Value::Error(CellError::Value)))
-                            }
-                            _ => v,
-                        }
-                    }
-                    _ => v,
-                }
-            }
-            "CHOOSE" => {
-                if args.len() < 2 {
-                    return err(CellError::Value);
-                }
-                let index = self.value(&args[0]);
-                if let Value::Array(_) = index {
-                    // An array of indexes picks element by element: `CHOOSE({1,2},A1:A3,B1:B3)`
-                    // is a two-column array. The library CHOOSE lifts over its arguments.
-                    let Some(spec) = gridcraft_functions::lookup(name) else { return err(CellError::Name) };
-                    let mut evaluated = vec![Arg { value: index, from_ref: false }];
-                    for a in &args[1..] {
-                        let value = self.value(a);
-                        evaluated.push(Arg { value, from_ref: false });
-                    }
-                    let mut ctx = FnCtx { ev: self, criteria: None, lambda: None };
-                    return gridcraft_functions::call(spec, &evaluated, &mut ctx).pipe(Ev::V);
-                }
-                let i = match index.to_number() {
-                    Ok(n) => n.trunc() as i64,
-                    Err(e) => return err(e),
-                };
-                if i < 1 || i as usize >= args.len() {
-                    return err(CellError::Value);
-                }
-                self.eval(&args[i as usize])
-            }
-            "SWITCH" => {
-                if args.len() < 3 {
-                    return err(CellError::Value);
-                }
-                let v = self.arg_val(args, 0).unwrap_or_default().scalar();
-                if let Value::Error(e) = v {
-                    return err(e);
-                }
-                let rest = &args[1..];
-                let mut i = 0;
-                while i + 1 < rest.len() {
-                    let cand = self.value(&rest[i]).scalar();
-                    if !cand.is_error() && compare(&v, &cand) == std::cmp::Ordering::Equal && same_kind(&v, &cand) {
-                        return self.eval(&rest[i + 1]);
-                    }
-                    i += 2;
-                }
-                if rest.len() % 2 == 1 { rest.last().map_or(err(CellError::NA), |d| self.eval(d)) } else { err(CellError::NA) }
-            }
-            "ROW" | "COLUMN" => {
-                let is_row = name == "ROW";
-                if args.is_empty() || matches!(args.first(), Some(Expr::Missing)) {
-                    return Ev::V(Value::number(if is_row { self.at.row + 1 } else { self.at.col + 1 } as f64));
-                }
-                match self.eval(&args[0]) {
-                    Ev::R(a) => {
-                        let Some(a) = a.first() else { return err(CellError::Ref) };
-                        let r = self.trim_lines(a);
-                        if is_row {
-                            let rows: Vec<Value> = (r.start.row..=r.end.row).map(|x| Value::number(x as f64 + 1.0)).collect();
-                            if rows.len() == 1 { Ev::V(rows.into_iter().next().unwrap_or_default()) } else { Ev::V(Array::column(rows).into()) }
-                        } else {
-                            let cols: Vec<Value> = (r.start.col..=r.end.col).map(|x| Value::number(x as f64 + 1.0)).collect();
-                            if cols.len() == 1 { Ev::V(cols.into_iter().next().unwrap_or_default()) } else { Ev::V(Array::row(cols).into()) }
-                        }
-                    }
-                    Ev::V(Value::Error(e)) => err(e),
-                    _ => err(CellError::Value),
-                }
-            }
-            "ROWS" | "COLUMNS" => {
-                if args.len() != 1 {
-                    return err(CellError::Value);
-                }
-                let is_rows = name == "ROWS";
-                match self.eval(&args[0]) {
-                    Ev::R(a) => match a.as_slice() {
-                        [a] => Ev::V(Value::number(if is_rows { a.range.height() } else { a.range.width() } as f64)),
-                        _ => err(CellError::Ref),
-                    },
-                    Ev::V(Value::Array(arr)) => Ev::V(Value::number(if is_rows { arr.rows } else { arr.cols } as f64)),
-                    Ev::V(Value::Error(e)) => err(e),
-                    Ev::V(_) => Ev::V(Value::Number(1.0)),
-                    Ev::L(_) => err(CellError::Value),
-                }
-            }
-            "AREAS" => match args.first().map(|a| self.eval(a)) {
-                Some(Ev::R(a)) => Ev::V(Value::number(a.len() as f64)),
-                Some(Ev::V(Value::Error(e))) => err(e),
-                _ => err(CellError::Value),
-            },
-            "ISREF" => Ev::V(Value::Bool(matches!(args.first().map(|a| self.eval(a)), Some(Ev::R(_))))),
-            "ISFORMULA" | "FORMULATEXT" => {
-                let Some(Ev::R(a)) = args.first().map(|a| self.eval(a)) else { return err(CellError::NA) };
-                let Some(a) = a.first() else { return err(CellError::NA) };
-                let f = self.host.workbook().sheet(a.sheet).and_then(|s| s.cell(a.range.start)).and_then(|c| c.formula.clone());
-                if name == "ISFORMULA" {
-                    Ev::V(Value::Bool(f.is_some()))
-                } else {
-                    match f {
-                        Some(f) => Ev::V(Value::text(format!("={}", f.text))),
-                        None => err(CellError::NA),
-                    }
-                }
-            }
-            "SHEET" | "SHEETS" => {
-                let wb = self.host.workbook();
-                if args.is_empty() {
-                    return Ev::V(Value::number(if name == "SHEET" { self.sheet + 1 } else { wb.sheets.len() } as f64));
-                }
-                match self.eval(&args[0]) {
-                    Ev::R(a) => {
-                        if name == "SHEET" {
-                            a.first().map_or(err(CellError::Ref), |a| Ev::V(Value::number(a.sheet as f64 + 1.0)))
-                        } else {
-                            let mut s: Vec<usize> = a.iter().map(|x| x.sheet).collect();
-                            s.dedup();
-                            Ev::V(Value::number(s.len() as f64))
-                        }
-                    }
-                    Ev::V(Value::Text(t)) if name == "SHEET" => {
-                        let wb = self.host.workbook();
-                        wb.sheet_index(&t).map_or(err(CellError::NA), |i| Ev::V(Value::number(i as f64 + 1.0)))
-                    }
-                    _ => err(CellError::NA),
-                }
-            }
-            "OFFSET" => self.offset(args),
-            "INDIRECT" => self.indirect(args),
-            "INDEX" => self.index(args),
-            "XLOOKUP" => self.xlookup(args),
-            "CELL" => self.cell_info(args),
-            "TRIMRANGE" => self.trimrange(args),
-            "SUBTOTAL" | "AGGREGATE" => self.subtotal(name, args),
-            "TEXT" => {
-                if args.len() != 2 {
-                    return err(CellError::Value);
-                }
-                let v = self.arg_val(args, 0).unwrap_or_default();
-                let f = self.arg_val(args, 1).unwrap_or_default();
-                let sys = self.host.workbook().date_system;
-                let one = |v: &Value, f: &Value| -> Value {
-                    if let Value::Error(e) = v {
-                        return Value::Error(*e);
-                    }
-                    let code = match f.to_text() {
-                        Ok(c) => c,
-                        Err(e) => return Value::Error(e),
-                    };
-                    match gridcraft_numfmt::text_function(v, &code, sys) {
-                        Ok(s) => Value::text(s),
-                        Err(e) => Value::Error(e),
-                    }
-                };
-                Ev::V(zip2(&v, &f, one))
-            }
-            "LET" => self.let_(args),
-            "LAMBDA" => {
-                if args.is_empty() {
-                    return err(CellError::Value);
-                }
-                let mut params = Vec::new();
-                for p in &args[..args.len() - 1] {
-                    match p {
-                        Expr::Name(n) => params.push(n.trim_start_matches('[').trim_end_matches(']').to_string()),
-                        _ => return err(CellError::Value),
-                    }
-                }
-                let Some(body) = args.last() else { return err(CellError::Value) };
-                Ev::L(Arc::new(Lambda { params, body: body.clone(), env: self.env.clone() }))
-            }
-            "ISOMITTED" => {
-                let r = matches!(args.first(), Some(Expr::Name(n)) if self.env.iter().rev().find(|(k, _)| gridcraft_formula::same_name(k, n)).is_some_and(|(_, v)| matches!(v, Ev::V(Value::Empty))));
-                Ev::V(Value::Bool(r))
-            }
-            "MAP" | "REDUCE" | "SCAN" | "BYROW" | "BYCOL" | "MAKEARRAY" => self.higher_order(name, args),
-            "GROUPBY" | "PIVOTBY" => {
-                // The aggregation may be a function given by name (`SUM`): pass it as its name.
-                let i = if name == "GROUPBY" { 2 } else { 3 };
-                match args.get(i).and_then(|a| self.function_by_name(a)) {
-                    Some(f) => {
-                        let mut args = args.to_vec();
-                        if let Some(a) = args.get_mut(i) {
-                            *a = Expr::Text(f.into());
-                        }
-                        self.builtin(name, &args)
-                    }
-                    None => self.builtin(name, args),
-                }
-            }
-            "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" => {
-                self.host.note_volatile();
-                self.builtin(name, args)
-            }
-            _ => self.builtin(name, args),
-        }
-    }
-
-    fn builtin(&mut self, name: &str, args: &[Expr]) -> Ev {
-        let Some(spec) = gridcraft_functions::lookup(name) else {
-            // A defined name holding a LAMBDA, or a LET-bound lambda.
-            return match self.name(name) {
-                Ev::L(l) => self.apply_lambda(&l, args),
-                Ev::V(Value::Error(x)) => err(x),
-                _ => err(CellError::Name),
-            };
-        };
-        if args.len() < spec.min_args || args.len() > spec.max_args {
-            return err(CellError::Value);
-        }
-        if let Some(kind) = Agg::of(spec.name) {
-            return self.aggregate(kind, args);
-        }
-        let mut evaluated = Vec::with_capacity(args.len());
-        // SUMIF/AVERAGEIF: the size of the criteria range (argument 1), which the sum range takes.
-        let mut criteria_shape = None;
-        // Database functions: the criteria range (argument 2), whose formulas are computed criteria.
-        let mut criteria = None;
-        // GROUPBY/PIVOTBY: the LAMBDA given as their function.
-        let mut lambda = None;
-        let lambda_at = match name {
-            "GROUPBY" => Some(2),
-            "PIVOTBY" => Some(3),
-            _ => None,
-        };
-        for (i, a) in args.iter().enumerate() {
-            let mut ev = self.eval(a);
-            if lambda_at == Some(i)
-                && let Ev::L(l) = &ev
-            {
-                lambda = Some(l.clone());
-                ev = Ev::V(Value::Empty);
-            }
-            if spec.category == gridcraft_functions::Category::Database
-                && i == 2
-                && let Ev::R(areas) = &ev
-                && let [area] = areas.as_slice()
-            {
-                criteria = Some(*area);
-            }
-            if resizes_sum_range(name, args.len()) {
-                if i == 0 {
-                    criteria_shape = ev_shape(&ev);
-                } else if i == 2
-                    && let (Some((h, w)), Ev::R(areas)) = (criteria_shape, &ev)
-                    && let [area] = areas.as_slice()
-                {
-                    ev = Ev::R(vec![Area { sheet: area.sheet, range: resized_sum_range(area.range, h, w) }]);
-                }
-            }
-            let from_ref = matches!(ev, Ev::R(_));
-            let value = match ev {
-                Ev::R(areas) if areas.len() > 1 => {
-                    // Multi-area references (unions): flatten into one row for aggregates.
-                    let mut vals = Vec::new();
-                    for ar in &areas {
-                        match self.area_value(ar) {
-                            Value::Array(a) => vals.extend(a.data.iter().cloned()),
-                            v => vals.push(v),
-                        }
-                    }
-                    Value::from(Array::row(vals))
-                }
-                ev => self.deref(ev),
-            };
-            evaluated.push(Arg { value, from_ref });
-        }
-        let mut ctx = FnCtx { ev: self, criteria, lambda };
-        gridcraft_functions::call(spec, &evaluated, &mut ctx).pipe(Ev::V)
-    }
-
-    /// Performs aggregation operations without copying its ranges: blocks are folded over the stored
-    /// cells, so no array is built and there is no `MAX_CELLS` limit. Arguments are evaluated and read one
-    /// after another, as the array path does, so volatile formulas (like `RAND`) see the same order.
-    /// Only `SUM`, `COUNT` and `AVG` are supported currently.
-    fn aggregate(&mut self, kind: Agg, args: &[Expr]) -> Ev {
-        let mut acc = Acc::default();
-        let mut first_error = None;
-        for a in args {
-            let ev = self.eval(a);
-            let steps = match ev {
-                Ev::R(areas) => areas.iter().map(|area| self.aggregate_area(kind, area, &mut acc)).collect(),
-                ev => {
-                    let value = self.deref(ev);
-                    vec![self.aggregate_value(kind, value, false, &mut acc)]
-                }
-            };
-            if first_error.is_none() {
-                first_error = steps.into_iter().find_map(Result::err);
-            }
-        }
-        first_error.unwrap_or_else(|| Ev::V(acc.finish(kind)))
-    }
-
-    /// Adds one area to `acc`; `Err` is the result the function ends with.
-    fn aggregate_area(&mut self, kind: Agg, a: &Area, acc: &mut Acc) -> Result<(), Ev> {
-        if !a.range.is_single() {
-            let mut error = None;
-            let walked = self.host.visit_range(a.sheet, a.range, &mut |v| match acc.add_cell(kind, v) {
-                Ok(()) => true,
-                Err(e) => {
-                    error = Some(e);
-                    false
-                }
-            });
-            if walked {
-                return error.map_or(Ok(()), |e| Err(err(e)));
-            }
-        }
-        let value = self.area_value(a);
-        self.aggregate_value(kind, value, true, acc)
-    }
-
-    /// Adds one argument's value by calling `SUM` and `COUNT` on it, so coercion and error rules
-    /// stay in one place (`AVERAGE` of an argument is its `SUM` over its `COUNT`).
-    fn aggregate_value(&mut self, kind: Agg, value: Value, from_ref: bool, acc: &mut Acc) -> Result<(), Ev> {
-        let (Some(sum), Some(count)) = (gridcraft_functions::lookup("SUM"), gridcraft_functions::lookup("COUNT")) else {
-            return Err(err(CellError::Name));
-        };
-        let args = [Arg { value, from_ref }];
-        if kind != Agg::Count {
-            match gridcraft_functions::call(sum, &args, &mut FnCtx { ev: self, criteria: None, lambda: None }) {
-                Value::Number(n) => acc.sum += n,
-                other => return Err(Ev::V(other)),
-            }
-        }
-        if kind != Agg::Sum {
-            match gridcraft_functions::call(count, &args, &mut FnCtx { ev: self, criteria: None, lambda: None }) {
-                Value::Number(n) => acc.count = acc.count.saturating_add(n as u64),
-                other => return Err(Ev::V(other)),
-            }
-        }
-        Ok(())
-    }
-
-    pub fn apply_lambda(&mut self, l: &Lambda, args: &[Expr]) -> Ev {
-        // Too many or too few argument positions is #VALUE!. An explicitly empty position, as in
-        // `(1,)`, is `Expr::Missing` and still counts as a position (it binds as omitted). `f()`
-        // parses to no arguments, which for a one-parameter lambda can also be read as one empty
-        // position, so that call still binds the parameter as omitted.
-        let positions_ok = args.len() == l.params.len() || (args.is_empty() && l.params.len() == 1);
-        if !positions_ok {
-            return err(CellError::Value);
-        }
-        let mut bound = Vec::with_capacity(l.params.len());
-        for (i, p) in l.params.iter().enumerate() {
-            let v = match args.get(i) {
-                Some(Expr::Missing) | None => Ev::V(Value::Empty),
-                Some(e) => self.eval(e),
-            };
-            bound.push((p.clone(), v));
-        }
-        self.call_lambda_values(l, bound)
-    }
-
-    fn call_lambda_values(&mut self, l: &Lambda, bound: Vec<(String, Ev)>) -> Ev {
-        if self.calls >= MAX_LAMBDA_CALLS {
-            return err(CellError::Num);
-        }
-        // #2382: one charge per invocation, so a cell's total work stays bounded however the
-        // lambdas nest. Foregrounding the charge here means every path into a body (direct
-        // `(2,3)` application, `MAP`/`REDUCE`/`BYROW` helpers, D-function criteria) meters.
-        self.fuel = match self.fuel.checked_sub(1) {
-            Some(f) => f,
-            None => return err(CellError::Calc),
-        };
-        self.calls += 1;
-        let saved = std::mem::replace(&mut self.env, l.env.clone());
-        self.env.extend(bound);
-        let r = self.eval(&l.body);
-        self.env = saved;
-        self.calls -= 1;
-        r
-    }
-
-    fn let_(&mut self, args: &[Expr]) -> Ev {
-        if args.len() < 3 || args.len().is_multiple_of(2) {
-            return err(CellError::Value);
-        }
-        let base = self.env.len();
-        for pair in args[..args.len() - 1].chunks(2) {
-            let [Expr::Name(n), v] = pair else {
-                self.env.truncate(base);
-                return err(CellError::Value);
-            };
-            let val = self.eval(v);
-            self.env.push((n.clone(), val));
-        }
-        let r = match args.last() {
-            Some(body) => self.eval(body),
-            None => err(CellError::Value),
-        };
-        self.env.truncate(base);
-        r
-    }
-
-    /// A worksheet function given by name where a function is expected (`BYROW(A1:C3,SUM)`,
-    /// `GROUPBY(A2:A9,B2:B9,SUM)`): its name, unless a LET/LAMBDA variable or a defined name has
-    /// that name.
-    fn function_by_name(&self, e: &Expr) -> Option<String> {
-        let Expr::Name(n) = e else { return None };
-        if self.env.iter().any(|(k, _)| gridcraft_formula::same_name(k, n)) || self.host.workbook().name(n, self.sheet).is_some() {
-            return None;
-        }
-        let u = n.to_ascii_uppercase();
-        gridcraft_functions::lookup(&u).map(|_| u)
-    }
-
-    /// The function argument of a LAMBDA helper; a function given by name takes `arity`
-    /// arguments.
-    fn lambda_arg(&mut self, e: Option<&Expr>, arity: usize) -> Option<Arc<Lambda>> {
-        if let Some(f) = e.and_then(|x| self.function_by_name(x)) {
-            let params: Vec<String> = (0..arity).map(|i| format!("_xleta.{i}")).collect();
-            let body = Expr::Call(f, params.iter().map(|p| Expr::Name(p.clone())).collect());
-            return Some(Arc::new(Lambda { params, body, env: Vec::new() }));
-        }
-        match e.map(|x| self.eval(x)) {
-            Some(Ev::L(l)) => Some(l),
-            _ => None,
-        }
-    }
-
-    fn higher_order(&mut self, name: &str, args: &[Expr]) -> Ev {
-        let as_array = |v: Value| -> Arc<Array> {
-            match v {
-                Value::Array(a) => a,
-                other => Arc::new(Array::scalar(other)),
-            }
-        };
-        match name {
-            "MAP" => {
-                if args.len() < 2 {
-                    return err(CellError::Value);
-                }
-                let Some(l) = self.lambda_arg(args.last(), args.len() - 1) else { return err(CellError::Value) };
-                let arrays: Vec<Arc<Array>> = args[..args.len() - 1].iter().map(|a| as_array(self.value(a))).collect();
-                let rows = arrays.iter().map(|a| a.rows).max().unwrap_or(1);
-                let cols = arrays.iter().map(|a| a.cols).max().unwrap_or(1);
-                let Some(n) = broadcast_len(rows, cols) else { return err(CellError::Num) };
-                // The LAMBDA takes one parameter per array.
-                if l.params.len() != arrays.len() {
-                    return err(CellError::Value);
-                }
-                let mut out = Vec::with_capacity(n);
-                for r in 0..rows {
-                    for c in 0..cols {
-                        let bound = l.params.iter().zip(arrays.iter()).map(|(p, a)| (p.clone(), Ev::V(a.get_broadcast(r, c)))).collect();
-                        let v = self.call_lambda_values(&l, bound);
-                        let Some(one) = single(self.deref(v)) else { return err(CellError::Calc) };
-                        out.push(one);
-                    }
-                }
-                Ev::V(Array::new(rows, cols, out).map(Value::from).unwrap_or(Value::Error(CellError::Calc)))
-            }
-            "REDUCE" | "SCAN" => {
-                if args.len() != 3 {
-                    return err(CellError::Value);
-                }
-                let mut acc = self.value(&args[0]);
-                let arr = as_array(self.value(&args[1]));
-                let Some(l) = self.lambda_arg(args.get(2), 2) else { return err(CellError::Value) };
-                if l.params.len() != 2 {
-                    return err(CellError::Value);
-                }
-                let mut scan = Vec::with_capacity(arr.data.len());
-                for v in arr.data.iter() {
-                    let bound = vec![(l.params[0].clone(), Ev::V(acc.clone())), (l.params[1].clone(), Ev::V(v.clone()))];
-                    let r = self.call_lambda_values(&l, bound);
-                    acc = self.deref(r);
-                    if name == "SCAN" {
-                        let Some(one) = single(acc.clone()) else { return err(CellError::Calc) };
-                        scan.push(one);
-                    }
-                }
-                if name == "SCAN" {
-                    Ev::V(Array::new(arr.rows, arr.cols, scan).map(Value::from).unwrap_or(Value::Error(CellError::Calc)))
-                } else {
-                    Ev::V(acc)
-                }
-            }
-            "BYROW" | "BYCOL" => {
-                if args.len() != 2 {
-                    return err(CellError::Value);
-                }
-                let arr = as_array(self.value(&args[0]));
-                let Some(l) = self.lambda_arg(args.get(1), 1) else { return err(CellError::Value) };
-                let Some(p) = l.params.first().cloned() else { return err(CellError::Value) };
-                if l.params.len() != 1 {
-                    return err(CellError::Value);
-                }
-                let by_row = name == "BYROW";
-                let n = if by_row { arr.rows } else { arr.cols };
-                let mut out = Vec::with_capacity(n);
-                for i in 0..n {
-                    let slice: Vec<Value> = if by_row {
-                        (0..arr.cols).map(|c| arr.get(i, c).cloned().unwrap_or_default()).collect()
-                    } else {
-                        (0..arr.rows).map(|r| arr.get(r, i).cloned().unwrap_or_default()).collect()
-                    };
-                    let a = if by_row { Array::row(slice) } else { Array::column(slice) };
-                    let r = self.call_lambda_values(&l, vec![(p.clone(), Ev::V(a.into()))]);
-                    let Some(one) = single(self.deref(r)) else { return err(CellError::Calc) };
-                    out.push(one);
-                }
-                let a = if by_row { Array::column(out) } else { Array::row(out) };
-                Ev::V(a.into())
-            }
-            "MAKEARRAY" => {
-                if args.len() != 3 {
-                    return err(CellError::Value);
-                }
-                let (rows, cols) = match (self.arg_num(args, 0, 0.0), self.arg_num(args, 1, 0.0)) {
-                    (Ok(r), Ok(c)) => (r.trunc(), c.trunc()),
-                    (Err(e), _) | (_, Err(e)) => return err(e),
-                };
-                if rows < 1.0 || cols < 1.0 || rows * cols > MAX_CELLS as f64 {
-                    return err(CellError::Value);
-                }
-                let Some(l) = self.lambda_arg(args.get(2), 2) else { return err(CellError::Value) };
-                if l.params.len() != 2 {
-                    return err(CellError::Value);
-                }
-                let (rows, cols) = (rows as usize, cols as usize);
-                let mut out = Vec::with_capacity(rows * cols);
-                for r in 0..rows {
-                    for c in 0..cols {
-                        let bound = vec![
-                            (l.params[0].clone(), Ev::V(Value::number(r as f64 + 1.0))),
-                            (l.params[1].clone(), Ev::V(Value::number(c as f64 + 1.0))),
-                        ];
-                        let v = self.call_lambda_values(&l, bound);
-                        let Some(one) = single(self.deref(v)) else { return err(CellError::Calc) };
-                        out.push(one);
-                    }
-                }
-                Ev::V(Array::new(rows, cols, out).map(Value::from).unwrap_or(Value::Error(CellError::Calc)))
-            }
-            _ => err(CellError::Name),
-        }
-    }
-
-    /// Whole rows/columns trimmed for ROW()/COLUMN() arrays.
-    fn trim_lines(&mut self, a: &Area) -> RangeRef {
-        if a.range.is_full_cols() || a.range.is_full_rows() { self.trim(a) } else { a.range }
-    }
-
-    fn offset(&mut self, args: &[Expr]) -> Ev {
-        self.host.note_volatile();
-        if args.len() < 3 || args.len() > 5 {
-            return err(CellError::Value);
-        }
-        let base = match self.eval(&args[0]) {
-            Ev::R(a) if a.len() == 1 => a[0],
-            Ev::V(Value::Error(e)) => return err(e),
-            _ => return err(CellError::Value),
-        };
-        let rows = match self.arg_num(args, 1, 0.0) {
-            Ok(n) => n.trunc() as i64,
-            Err(e) => return err(e),
-        };
-        let cols = match self.arg_num(args, 2, 0.0) {
-            Ok(n) => n.trunc() as i64,
-            Err(e) => return err(e),
-        };
-        let h = match self.arg_num(args, 3, base.range.height() as f64) {
-            Ok(n) => n.trunc() as i64,
-            Err(e) => return err(e),
-        };
-        let w = match self.arg_num(args, 4, base.range.width() as f64) {
-            Ok(n) => n.trunc() as i64,
-            Err(e) => return err(e),
-        };
-        if h == 0 || w == 0 {
-            return err(CellError::Ref);
-        }
-        let r0 = (base.range.start.row as i64).saturating_add(rows);
-        let c0 = (base.range.start.col as i64).saturating_add(cols);
-        let (r0, r1) = if h > 0 { (r0, r0.saturating_add(h - 1)) } else { (r0.saturating_add(h + 1), r0) };
-        let (c0, c1) = if w > 0 { (c0, c0.saturating_add(w - 1)) } else { (c0.saturating_add(w + 1), c0) };
-        if r0 < 0 || c0 < 0 || r1 >= MAX_ROWS as i64 || c1 >= MAX_COLS as i64 {
-            return err(CellError::Ref);
-        }
-        Ev::R(vec![Area { sheet: base.sheet, range: RangeRef::new(CellRef::new(r0 as u32, c0 as u32), CellRef::new(r1 as u32, c1 as u32)) }])
-    }
-
-    fn indirect(&mut self, args: &[Expr]) -> Ev {
-        self.host.note_volatile();
-        if args.is_empty() || args.len() > 2 {
-            return err(CellError::Value);
-        }
-        let text = match self.arg_val(args, 0).map(|v| v.scalar().to_text()) {
-            Some(Ok(t)) => t,
-            Some(Err(e)) => return err(e),
-            None => return err(CellError::Value),
-        };
-        let a1 = match args.get(1) {
-            None | Some(Expr::Missing) => true,
-            Some(e) => {
-                let v = self.value(e);
-                v.scalar().to_bool().unwrap_or(true)
-            }
-        };
-        // With a1 = FALSE, text that isn't R1C1 can still be a name, but never an A1 reference.
-        let (text, a1_ok) = if a1 {
-            (text, true)
-        } else {
-            match r1c1_to_a1(&text, self.at) {
-                Ok(Some(a1_text)) => (a1_text, true),
-                Ok(None) => (text, false),
-                Err(e) => return err(e),
-            }
-        };
-        match gridcraft_formula::parse(&text) {
-            Ok(Expr::Ref(_)) if !a1_ok => err(CellError::Ref),
-            Ok(e @ (Expr::Ref(_) | Expr::Name(_) | Expr::Struct(_))) => match self.eval(&e) {
-                r @ Ev::R(_) => r,
-                _ => err(CellError::Ref),
-            },
-            _ => err(CellError::Ref),
-        }
-    }
-
-    fn index(&mut self, args: &[Expr]) -> Ev {
-        if args.is_empty() || args.len() > 4 {
-            return err(CellError::Value);
-        }
-        let src = self.eval(&args[0]);
-        let mut arg = |i: usize| match args.get(i) {
-            None | Some(Expr::Missing) => None,
-            Some(e) => Some(self.value(e)),
-        };
-        let (rows, cols) = (arg(1), arg(2));
-        let area_n = match self.arg_num(args, 3, 1.0) {
-            Ok(n) => n.trunc() as i64,
-            Err(e) => return err(e),
-        };
-        let two = args.len() == 2;
-        let num = |v: &Option<Value>| v.as_ref().map_or(Ok(0.0), |v| v.to_number()).map(|n| n.trunc() as i64);
-        // Arrays of positions pick a value for each: INDEX(A1:C10,{1;2},{1,3}) is 2×2.
-        if let (Some(Value::Array(_)), _) | (_, Some(Value::Array(_))) = (&rows, &cols) {
-            let as_array = |v: &Option<Value>| match v {
-                Some(Value::Array(a)) => Arc::clone(a),
-                Some(v) => Arc::new(Array::scalar(v.clone())),
-                None => Arc::new(Array::scalar(Value::Number(0.0))),
-            };
-            let (ra, ca) = (as_array(&rows), as_array(&cols));
-            let (h, w) = (ra.rows.max(ca.rows), ra.cols.max(ca.cols));
-            if (h as u64).saturating_mul(w as u64) > MAX_CELLS {
-                return err(CellError::Num);
-            }
-            let mut out = Vec::with_capacity(h * w);
-            for r in 0..h {
-                for c in 0..w {
-                    let pos = (num(&Some(ra.get_broadcast(r, c))), num(&Some(ca.get_broadcast(r, c))));
-                    let v = match pos {
-                        (Ok(row), Ok(col)) => {
-                            let one = self.index_one(src.clone(), row, col, area_n, two);
-                            match self.deref(one) {
-                                Value::Array(a) if a.rows * a.cols > 1 => Value::Error(CellError::Calc),
-                                v => v.scalar(),
-                            }
-                        }
-                        (Err(e), _) | (_, Err(e)) => Value::Error(e),
-                    };
-                    out.push(v);
-                }
-            }
-            return Ev::V(Array::new(h, w, out).map(Value::from).unwrap_or(Value::Error(CellError::Value)));
-        }
-        let (row, col) = match (num(&rows), num(&cols)) {
-            (Ok(r), Ok(c)) => (r, c),
-            (Err(e), _) | (_, Err(e)) => return err(e),
-        };
-        self.index_one(src, row, col, area_n, two)
-    }
-
-    /// INDEX for one row and column position (0 = the whole column or row).
-    fn index_one(&mut self, src: Ev, row: i64, col: i64, area_n: i64, two_args: bool) -> Ev {
-        if row < 0 || col < 0 {
-            return err(CellError::Value);
-        }
-        match src {
-            Ev::R(areas) => {
-                let area = usize::try_from((area_n as u64).saturating_sub(1)).ok();
-                let Some(a) = area.and_then(|i| areas.get(i)).copied() else { return err(CellError::Ref) };
-                let r = a.range;
-                // A single row or column with one index picks along it. An area with several rows
-                // and columns needs both: `INDEX(A1:C3,2)` is #REF! in Excel (an empty third
-                // argument, `INDEX(A1:C3,2,)`, still means the whole row). Arrays differ:
-                // `INDEX({1,2;3,4},2)` is the row.
-                if two_args && r.height() > 1 && r.width() > 1 {
-                    return err(CellError::Ref);
-                }
-                let (row, col) = if two_args && r.height() == 1 { (1, row) } else { (row, col) };
-                if row as u64 > r.height() as u64 || col as u64 > r.width() as u64 {
-                    return err(CellError::Ref);
-                }
-                let (r0, r1) = if row == 0 { (r.start.row, r.end.row) } else { (r.start.row + row as u32 - 1, r.start.row + row as u32 - 1) };
-                let (c0, c1) = if col == 0 { (r.start.col, r.end.col) } else { (r.start.col + col as u32 - 1, r.start.col + col as u32 - 1) };
-                Ev::R(vec![Area { sheet: a.sheet, range: RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1)) }])
-            }
-            Ev::V(Value::Array(arr)) => {
-                let (row, col) = if two_args && arr.rows == 1 { (1, row) } else { (row, col) };
-                if row as usize > arr.rows || col as usize > arr.cols {
-                    return err(CellError::Ref);
-                }
-                match (row, col) {
-                    (0, 0) => Ev::V(Value::Array(arr)),
-                    (0, c) => Ev::V(Array::column((0..arr.rows).map(|r| arr.get(r, c as usize - 1).cloned().unwrap_or_default()).collect()).into()),
-                    (r, 0) => Ev::V(Array::row((0..arr.cols).map(|c| arr.get(r as usize - 1, c).cloned().unwrap_or_default()).collect()).into()),
-                    (r, c) => Ev::V(arr.get(r as usize - 1, c as usize - 1).cloned().unwrap_or(Value::Error(CellError::Ref))),
-                }
-            }
-            Ev::V(Value::Error(e)) => err(e),
-            Ev::V(v) => {
-                if row <= 1 && col <= 1 {
-                    Ev::V(v)
-                } else {
-                    err(CellError::Ref)
-                }
-            }
-            Ev::L(_) => err(CellError::Value),
-        }
-    }
-
-    /// XLOOKUP whose result range is a reference returns a reference, as in Excel, so that it can
-    /// end a range (`SUM(XLOOKUP(a,…):XLOOKUP(b,…))`) or feed CELL. Everything else (arrays of
-    /// lookup values, array arguments, errors) goes to the library function.
-    fn xlookup(&mut self, args: &[Expr]) -> Ev {
-        if (3..=6).contains(&args.len())
-            && let (Ev::R(look), Ev::R(ret)) = (self.eval(&args[1]), self.eval(&args[2]))
-            && let ([l], [r]) = (look.as_slice(), ret.as_slice())
-            && let Some(spec) = gridcraft_functions::lookup("XMATCH")
-        {
-            let key = self.value(&args[0]);
-            let (l, r) = (*l, *r);
-            let vertical = l.range.width() == 1 && l.range.height() > 1;
-            let horizontal = l.range.height() == 1 && l.range.width() > 1;
-            let same_len = if vertical { r.range.height() == l.range.height() } else { r.range.width() == l.range.width() };
-            if !matches!(key, Value::Array(_)) && (vertical || horizontal) && same_len {
-                let mut xargs = vec![Arg { value: key, from_ref: false }, Arg { value: self.area_value(&l), from_ref: true }];
-                // An empty match_mode before a given search_mode is the default (0), not the end.
-                let given = |i: usize| args.get(i).is_some_and(|e| !matches!(e, Expr::Missing));
-                let last = if given(5) {
-                    5
-                } else if given(4) {
-                    4
-                } else {
-                    3
-                };
-                for i in 4..=last {
-                    match args.get(i) {
-                        Some(Expr::Missing) | None => xargs.push(Arg { value: Value::Number(0.0), from_ref: false }),
-                        Some(e) => {
-                            let value = self.value(e);
-                            xargs.push(Arg { value, from_ref: false });
-                        }
-                    }
-                }
-                let mut ctx = FnCtx { ev: self, criteria: None, lambda: None };
-                return match gridcraft_functions::call(spec, &xargs, &mut ctx) {
-                    Value::Number(p) if p >= 1.0 => {
-                        let k = p as u32 - 1;
-                        let range = if vertical {
-                            RangeRef::new(
-                                CellRef::new(r.range.start.row + k, r.range.start.col),
-                                CellRef::new(r.range.start.row + k, r.range.end.col),
-                            )
-                        } else {
-                            RangeRef::new(
-                                CellRef::new(r.range.start.row, r.range.start.col + k),
-                                CellRef::new(r.range.end.row, r.range.start.col + k),
-                            )
-                        };
-                        Ev::R(vec![Area { sheet: r.sheet, range }])
-                    }
-                    Value::Error(CellError::NA) if args.get(3).is_some_and(|e| !matches!(e, Expr::Missing)) => self.eval(&args[3]),
-                    Value::Error(e) => err(e),
-                    _ => err(CellError::Value),
-                };
-            }
-        }
-        self.builtin("XLOOKUP", args)
-    }
-
-    fn cell_info(&mut self, args: &[Expr]) -> Ev {
-        let kind = match self.arg_val(args, 0).map(|v| v.scalar().to_text()) {
-            Some(Ok(t)) => t.to_ascii_lowercase(),
-            Some(Err(e)) => return err(e),
-            None => return err(CellError::Value),
-        };
-        let area = match args.get(1).map(|a| self.eval(a)) {
-            Some(Ev::R(a)) => a.first().copied(),
-            None => Some(Area { sheet: self.sheet, range: RangeRef::cell(self.at) }),
-            _ => return err(CellError::Value),
-        };
-        let Some(a) = area else { return err(CellError::Ref) };
-        let c = a.range.start;
-        let wb = self.host.workbook();
-        let sheet = wb.sheet(a.sheet);
-        match kind.as_str() {
-            "address" => Ev::V(Value::text(format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1))),
-            "row" => Ev::V(Value::number(c.row as f64 + 1.0)),
-            "col" => Ev::V(Value::number(c.col as f64 + 1.0)),
-            "contents" => Ev::V(self.host.cell_value(a.sheet, c)),
-            "type" => {
-                let v = self.host.cell_value(a.sheet, c);
-                Ev::V(Value::text(match v {
-                    Value::Empty => "b",
-                    Value::Text(_) => "l",
-                    _ => "v",
-                }))
-            }
-            "width" => Ev::V(Value::number(sheet.map_or(8.43, |s| gridcraft_model::points_to_chars(s.col_width(c.col) as f64)).round())),
-            // Excel's `<folder>/[<file>]<sheet>`, which the classic sheet-name formula splits on
-            // the `]`. Empty until the workbook has a file of its own, as in Excel (#1489).
-            "filename" => Ev::V(Value::text(match &wb.source_path {
-                Some(file) => {
-                    let name = file.file_name().unwrap_or_default().to_string_lossy();
-                    let on = sheet.map_or("", |s| s.name.as_str());
-                    file.parent().unwrap_or(std::path::Path::new("")).join(format!("[{name}]{on}")).to_string_lossy().into_owned()
-                }
-                None => String::new(),
-            })),
-            "sheetname" => Ev::V(Value::text(sheet.map(|s| s.name.clone()).unwrap_or_default())),
-            "protect" => Ev::V(Value::number(if sheet.is_some_and(|s| wb.styles.get(s.style_id(c)).protection.locked) { 1.0 } else { 0.0 })),
-            "format" => {
-                let code = sheet.map(|s| wb.styles.get(s.style_id(c)).num_fmt.as_str().to_string()).unwrap_or_default();
-                Ev::V(Value::text(cell_format_code(&code)))
-            }
-            "color" | "parentheses" => Ev::V(Value::Number(0.0)),
-            "prefix" => Ev::V(Value::text("")),
-            _ => err(CellError::Value),
-        }
-    }
-
-    fn subtotal(&mut self, name: &str, args: &[Expr]) -> Ev {
-        // SUBTOTAL needs function_num and ref1; AGGREGATE needs function_num, options and ref1.
-        let min_args = if name == "AGGREGATE" { 3 } else { 2 };
-        if args.len() < min_args {
-            return err(CellError::Value);
-        }
-        let code = match self.arg_num(args, 0, 0.0) {
-            Ok(n) => n.trunc() as u32,
-            Err(e) => return err(e),
-        };
-        let (func, options, rest) = if name == "AGGREGATE" {
-            let opt = match self.arg_num(args, 1, 0.0) {
-                Ok(n) => n.trunc() as u32,
-                Err(e) => return err(e),
-            };
-            (code, opt, &args[2..])
-        } else {
-            let (f, ignore_hidden) = if code > 100 { (code - 100, true) } else { (code, false) };
-            (f, if ignore_hidden { 5 } else { 0 }, &args[1..])
-        };
-        if !(1..=19).contains(&func) || (name == "SUBTOTAL" && func > 11) {
-            return err(CellError::Value);
-        }
-        let skip_hidden = matches!(options, 1 | 3 | 5 | 7);
-        // SUBTOTAL leaves out rows a filter hides whatever the function number (Microsoft's
-        // SUBTOTAL documentation); 101-111 also leave out rows hidden by hand.
-        let skip_filtered = name == "SUBTOTAL";
-        let skip_errors = matches!(options, 2 | 3 | 6 | 7);
-        // SUBTOTAL always leaves out nested SUBTOTAL/AGGREGATE cells (101-111 too); AGGREGATE does so for options 0-3.
-        let skip_nested = name == "SUBTOTAL" || options <= 3;
-        let mut values = Vec::new();
-        let mut k = None;
-        let refs = if name == "AGGREGATE" && func >= 14 { &rest[..1.min(rest.len())] } else { rest };
-        if name == "AGGREGATE" && func >= 14 {
-            k = rest.get(1).map(|e| self.value(e));
-        }
-        // Every cell visited (even one skipped as hidden, nested or an error) and every value
-        // counts against one budget for the whole call. All arguments are evaluated (references
-        // stay lazy) and charged before any cell is read: a value stored in XFD1048576 makes
-        // `A:XFD` trim to the whole sheet, ~17 billion cells (#2175).
-        enum Input {
-            Cells(usize, RangeRef),
-            Values(Value),
-        }
-        let mut inputs = Vec::new();
-        let mut budget = MAX_CELLS;
-        for e in refs {
-            match self.eval(e) {
-                Ev::R(areas) => {
-                    for a in areas {
-                        let range = self.trim(&a);
-                        budget = match budget.checked_sub(range.count()) {
-                            Some(left) => left,
-                            None => return err(CellError::Num),
-                        };
-                        inputs.push(Input::Cells(a.sheet, range));
-                    }
-                }
-                Ev::V(v) => {
-                    let n = match &v {
-                        Value::Array(a) => u64::try_from(a.data.len()).unwrap_or(u64::MAX),
-                        _ => 1,
-                    };
-                    budget = match budget.checked_sub(n) {
-                        Some(left) => left,
-                        None => return err(CellError::Num),
-                    };
-                    inputs.push(Input::Values(v));
-                }
-                Ev::L(_) => return err(CellError::Value),
-            }
-        }
-        for input in inputs {
-            match input {
-                Input::Cells(sheet, range) => {
-                    for c in range.iter() {
-                        let (hidden, nested) = {
-                            let wb = self.host.workbook();
-                            let s = wb.sheet(sheet);
-                            let hidden =
-                                s.is_some_and(|s| if skip_hidden { s.is_row_hidden(c.row) } else { skip_filtered && s.is_row_filtered(c.row) });
-                            let nested = skip_nested
-                                && s.and_then(|s| s.cell(c)).and_then(|cell| cell.formula.as_ref()).is_some_and(|f| {
-                                    let u = f.text.to_ascii_uppercase();
-                                    u.contains("SUBTOTAL(") || u.contains("AGGREGATE(")
-                                });
-                            (hidden, nested)
-                        };
-                        if hidden || nested {
-                            continue;
-                        }
-                        let v = self.host.cell_value(sheet, c);
-                        if skip_errors && v.is_error() {
-                            continue;
-                        }
-                        values.push(v);
-                    }
-                }
-                Input::Values(Value::Array(a)) => values.extend(a.data.iter().filter(|v| !(skip_errors && v.is_error())).cloned()),
-                Input::Values(v) => values.push(v),
-            }
-        }
-        if let Some(k) = k {
-            return Ev::V(gridcraft_functions::aggregate_values_k(func, &values, &k));
-        }
-        Ev::V(gridcraft_functions::aggregate_values(func, &values))
-    }
 }
 
 trait Pipe: Sized {
@@ -1639,424 +636,6 @@ trait Pipe: Sized {
 }
 impl<T> Pipe for T {}
 
-/// CELL("format") code for a number format.
-fn cell_format_code(code: &str) -> String {
-    let c = code.to_ascii_lowercase();
-    if c == "general" {
-        return "G".into();
-    }
-    if c.contains('%') {
-        return format!("P{}", decimals(&c));
-    }
-    if c.contains('e') && c.contains('0') {
-        return format!("S{}", decimals(&c));
-    }
-    if c.contains('$') {
-        return format!("C{}", decimals(&c));
-    }
-    if c.contains('y') || c.contains('d') {
-        return "D1".into();
-    }
-    if c.contains('h') {
-        return "D9".into();
-    }
-    if c.contains(',') {
-        return format!(",{}", decimals(&c));
-    }
-    format!("F{}", decimals(&c))
-}
-
-fn decimals(c: &str) -> usize {
-    c.split_once('.').map_or(0, |(_, d)| d.chars().take_while(|ch| *ch == '0').count())
-}
-
-fn same_kind(a: &Value, b: &Value) -> bool {
-    std::mem::discriminant(a) == std::mem::discriminant(b) || (a.is_empty() || b.is_empty())
-}
-
-/// Converts an R1C1 reference text to A1 (for INDIRECT(…, FALSE)). `Ok(None)` means the text is
-/// not R1C1; `Err` means it is R1C1 but points past the sheet.
-pub fn r1c1_to_a1(s: &str, at: CellRef) -> Result<Option<String>, CellError> {
-    let (sheet, body) = match s.rsplit_once('!') {
-        Some((sh, b)) => (format!("{sh}!"), b),
-        None => (String::new(), s),
-    };
-    let conv = |part: &str| -> Result<Option<String>, CellError> {
-        let u = part.to_ascii_uppercase();
-        let Some((rpart, cpart)) = u.strip_prefix('R').and_then(|rest| rest.split_once('C')) else { return Ok(None) };
-        // `None`: not R1C1. `Some(None)`: R1C1, but past the sheet.
-        let num = |p: &str, base: u32, max: u32| -> Option<Option<(u32, bool)>> {
-            let (v, absolute) = if p.is_empty() {
-                (Some(i64::from(base)), false)
-            } else if let Some(inner) = p.strip_prefix('[').and_then(|x| x.strip_suffix(']')) {
-                (i64::from(base).checked_add(inner.parse().ok()?), false)
-            } else {
-                (p.parse::<u32>().ok()?.checked_sub(1).map(i64::from), true)
-            };
-            Some(v.filter(|v| (0..i64::from(max)).contains(v)).map(|v| (v as u32, absolute)))
-        };
-        let (Some(r), Some(c)) = (num(rpart, at.row, MAX_ROWS), num(cpart, at.col, MAX_COLS)) else { return Ok(None) };
-        let (Some((r, ra)), Some((c, ca))) = (r, c) else { return Err(CellError::Ref) };
-        Ok(Some(format!("{}{}{}{}", if ca { "$" } else { "" }, gridcraft_core::col_to_letters(c), if ra { "$" } else { "" }, r + 1)))
-    };
-    let out = match body.split_once(':') {
-        Some((a, b)) => match (conv(a)?, conv(b)?) {
-            (Some(a), Some(b)) => format!("{a}:{b}"),
-            _ => return Ok(None),
-        },
-        None => match conv(body)? {
-            Some(x) => x,
-            None => return Ok(None),
-        },
-    };
-    Ok(Some(format!("{sheet}{out}")))
-}
-
-/// The aggregates that can fold a reference without building an array.
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Agg {
-    Sum,
-    Count,
-    Average,
-}
-
-impl Agg {
-    fn of(name: &str) -> Option<Agg> {
-        match name {
-            "SUM" => Some(Agg::Sum),
-            "COUNT" => Some(Agg::Count),
-            "AVERAGE" => Some(Agg::Average),
-            _ => None,
-        }
-    }
-}
-
-/// What a folded aggregate carries from one value to the next.
-#[derive(Default)]
-struct Acc {
-    sum: f64,
-    count: u64,
-}
-
-impl Acc {
-    /// Takes a value found inside a reference: only numbers count. `Err` is an error value that
-    /// ends `SUM` and `AVERAGE`; `COUNT` skips errors.
-    fn add_cell(&mut self, kind: Agg, v: &Value) -> Result<(), CellError> {
-        match v {
-            Value::Number(n) => {
-                self.sum += n;
-                self.count = self.count.saturating_add(1);
-                Ok(())
-            }
-            Value::Error(e) if kind != Agg::Count => Err(*e),
-            _ => Ok(()),
-        }
-    }
-
-    fn finish(&self, kind: Agg) -> Value {
-        match kind {
-            Agg::Sum => Value::number(self.sum),
-            Agg::Count => Value::number(self.count as f64),
-            Agg::Average if self.count == 0 => Value::Error(CellError::Div0),
-            Agg::Average => Value::number(self.sum / self.count as f64),
-        }
-    }
-}
-
-// ---------------------------------------------------------------- operators
-
-fn map_unary(v: &Value, f: &dyn Fn(f64) -> Value, plus: bool, sys: gridcraft_core::DateSystem) -> Value {
-    match v {
-        Value::Array(a) => Value::from(Array { rows: a.rows, cols: a.cols, data: a.data.iter().map(|x| map_unary(x, f, plus, sys)).collect() }),
-        Value::Error(e) => Value::Error(*e),
-        Value::Text(_) if plus => v.clone(),
-        other => match other.to_number_in(sys) {
-            Ok(n) => f(n),
-            Err(e) => Value::Error(e),
-        },
-    }
-}
-
-/// Element-wise combination with Excel's broadcasting.
-pub fn zip2(a: &Value, b: &Value, f: impl Fn(&Value, &Value) -> Value) -> Value {
-    match (a, b) {
-        (Value::Array(x), Value::Array(y)) => {
-            let rows = broadcast_dim(x.rows, y.rows);
-            let cols = broadcast_dim(x.cols, y.cols);
-            let Some(n) = broadcast_len(rows, cols) else { return Value::Error(CellError::Num) };
-            let mut data = Vec::with_capacity(n);
-            for r in 0..rows {
-                for c in 0..cols {
-                    data.push(f(&x.get_broadcast(r, c), &y.get_broadcast(r, c)));
-                }
-            }
-            Value::from(Array { rows, cols, data })
-        }
-        (Value::Array(x), s) => Value::from(Array { rows: x.rows, cols: x.cols, data: x.data.iter().map(|v| f(v, s)).collect() }),
-        (s, Value::Array(y)) => Value::from(Array { rows: y.rows, cols: y.cols, data: y.data.iter().map(|v| f(s, v)).collect() }),
-        (x, y) => f(x, y),
-    }
-}
-
-/// Cell count of a `rows`×`cols` broadcast result, or `None` when it would exceed [`MAX_CELLS`].
-/// Each operand passes its own size cap, but their broadcast product can be far larger
-/// (`SEQUENCE(1048576)*SEQUENCE(1,16384)` is 17 billion cells), so it is checked before allocating.
-fn broadcast_len(rows: usize, cols: usize) -> Option<usize> {
-    rows.checked_mul(cols).filter(|&n| n as u64 <= MAX_CELLS)
-}
-
-fn broadcast_dim(a: usize, b: usize) -> usize {
-    if a == 1 {
-        b
-    } else if b == 1 {
-        a
-    } else {
-        a.max(b)
-    }
-}
-
-fn zip3(c: &Array, t: &Value, f: &Value, g: impl Fn(&Value, &Value, &Value) -> Value) -> Value {
-    let dims = |v: &Value| if let Value::Array(a) = v { (a.rows, a.cols) } else { (1, 1) };
-    let (tr, tc) = dims(t);
-    let (fr, fc) = dims(f);
-    let rows = broadcast_dim(broadcast_dim(c.rows, tr), fr);
-    let cols = broadcast_dim(broadcast_dim(c.cols, tc), fc);
-    let Some(n) = broadcast_len(rows, cols) else { return Value::Error(CellError::Num) };
-    let get = |v: &Value, r: usize, col: usize| if let Value::Array(a) = v { a.get_broadcast(r, col) } else { v.clone() };
-    let mut data = Vec::with_capacity(n);
-    for r in 0..rows {
-        for col in 0..cols {
-            data.push(g(&c.get_broadcast(r, col), &get(t, r, col), &get(f, r, col)));
-        }
-    }
-    Value::from(Array { rows, cols, data })
-}
-
-/// One cell of a LAMBDA helper's result, or `None` for an array of more than one value: arrays
-/// can't nest, so the whole helper gives `#CALC!`, as in Excel.
-fn single(v: Value) -> Option<Value> {
-    match v {
-        Value::Array(a) if a.rows * a.cols > 1 => None,
-        v => Some(v.scalar()),
-    }
-}
-
-pub fn binary_values(op: BinOp, x: &Value, y: &Value, sys: gridcraft_core::DateSystem) -> Value {
-    zip2(x, y, |a, b| binary_scalar(op, a, b, sys))
-}
-
-fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSystem) -> Value {
-    if let Value::Error(e) = a {
-        return Value::Error(*e);
-    }
-    if let Value::Error(e) = b {
-        return Value::Error(*e);
-    }
-    let num = |f: fn(f64, f64) -> Value| match (a.to_number_in(sys), b.to_number_in(sys)) {
-        (Ok(x), Ok(y)) => f(x, y),
-        (Err(e), _) | (_, Err(e)) => Value::Error(e),
-    };
-    use std::cmp::Ordering::*;
-    match op {
-        BinOp::Add => num(|x, y| Value::number(x + y)),
-        BinOp::Sub => num(|x, y| Value::number(x - y)),
-        BinOp::Mul => num(|x, y| Value::number(x * y)),
-        BinOp::Div => num(|x, y| if y == 0.0 { Value::Error(CellError::Div0) } else { Value::number(x / y) }),
-        BinOp::Pow => num(|x, y| {
-            if x == 0.0 && y == 0.0 {
-                Value::Error(CellError::Num)
-            } else if x == 0.0 && y < 0.0 {
-                Value::Error(CellError::Div0)
-            } else {
-                Value::number(x.powf(y))
-            }
-        }),
-        BinOp::Concat => match (a.to_text(), b.to_text()) {
-            (Ok(x), Ok(y)) => {
-                if x.len() + y.len() > 32767 * 4 {
-                    Value::Error(CellError::Value)
-                } else {
-                    Value::text(x + &y)
-                }
-            }
-            (Err(e), _) | (_, Err(e)) => Value::Error(e),
-        },
-        BinOp::Eq => Value::Bool(compare(a, b) == Equal),
-        BinOp::Ne => Value::Bool(compare(a, b) != Equal),
-        BinOp::Lt => Value::Bool(compare(a, b) == Less),
-        BinOp::Gt => Value::Bool(compare(a, b) == Greater),
-        BinOp::Le => Value::Bool(compare(a, b) != Greater),
-        BinOp::Ge => Value::Bool(compare(a, b) != Less),
-        BinOp::Range | BinOp::Union | BinOp::Intersect => Value::Error(CellError::Value),
-    }
-}
-
-/// SUMIF and AVERAGEIF with a sum range: Excel sizes the sum range like the criteria range.
-fn resizes_sum_range(name: &str, args: usize) -> bool {
-    args == 3 && matches!(name, "SUMIF" | "AVERAGEIF")
-}
-
-/// Height and width of a single-area reference or an array argument.
-fn ev_shape(ev: &Ev) -> Option<(u32, u32)> {
-    match ev {
-        Ev::R(areas) => match areas.as_slice() {
-            [a] => Some((a.range.height(), a.range.width())),
-            _ => None,
-        },
-        Ev::V(Value::Array(a)) => Some((u32::try_from(a.rows).unwrap_or(u32::MAX), u32::try_from(a.cols).unwrap_or(u32::MAX))),
-        Ev::V(_) => Some((1, 1)),
-        Ev::L(_) => None,
-    }
-}
-
-/// The range SUMIF/AVERAGEIF add up: from the sum range's top-left cell, as many rows and columns
-/// as the criteria range (`height` × `width`), cut off at the sheet's edge.
-pub fn resized_sum_range(sum: RangeRef, height: u32, width: u32) -> RangeRef {
-    let row = sum.start.row.saturating_add(height.saturating_sub(1)).min(MAX_ROWS - 1);
-    let col = sum.start.col.saturating_add(width.saturating_sub(1)).min(MAX_COLS - 1);
-    RangeRef::new(sum.start, CellRef::new(row, col))
-}
-
-/// Collects the static references of an expression with their sheets resolved; `dynamic` is
-/// set when the formula uses INDIRECT/OFFSET/names/tables whose targets can change.
-pub fn precedents(wb: &Workbook, sheet: usize, e: &Expr) -> (Vec<Area>, bool) {
-    let mut out = Vec::new();
-    let mut dynamic = false;
-    let push = |out: &mut Vec<Area>, r: &Reference, range: RangeRef| match &r.sheet {
-        SheetSel::Current => out.push(Area { sheet, range }),
-        SheetSel::Named(n) => {
-            if let Some(i) = wb.sheet_index(n) {
-                out.push(Area { sheet: i, range });
-            }
-        }
-        SheetSel::Span(a, b) => {
-            if let (Some(i), Some(j)) = (wb.sheet_index(a), wb.sheet_index(b)) {
-                for s in i.min(j)..=i.max(j) {
-                    out.push(Area { sheet: s, range });
-                }
-            }
-        }
-    };
-    e.walk(&mut |x| match x {
-        Expr::Ref(r) => push(&mut out, r, r.range()),
-        // The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
-        // the criteria range's size isn't known statically, recalculate the formula every time.
-        Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
-            (Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
-                let (crit, sum) = (c.range(), s.range());
-                push(&mut out, s, resized_sum_range(sum, crit.height(), crit.width()));
-            }
-            (_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
-            _ => dynamic = true,
-        },
-        Expr::Call(n, _)
-            if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
-        {
-            dynamic = true
-        }
-        Expr::Name(_) | Expr::Struct(_) => dynamic = true,
-        Expr::Call(n, _) if gridcraft_functions::lookup(n).is_none() && !is_special(n) => dynamic = true,
-        // A range ending in a function's result (`A1:INDEX(B1:B9,n)`) covers the cells between
-        // the references inside it, not only those references.
-        Expr::Binary(BinOp::Range, a, b) if !matches!((&**a, &**b), (Expr::Ref(_), Expr::Ref(_))) => {
-            let mut inner = precedents(wb, sheet, a).0;
-            inner.extend(precedents(wb, sheet, b).0);
-            let mut boxes: Vec<Area> = Vec::new();
-            for area in inner {
-                match boxes.iter_mut().find(|x| x.sheet == area.sheet) {
-                    Some(x) => x.range = x.range.union(&area.range),
-                    None => boxes.push(area),
-                }
-            }
-            out.extend(boxes);
-        }
-        _ => {}
-    });
-    (out, dynamic)
-}
-
-fn is_special(n: &str) -> bool {
-    matches!(
-        n,
-        "IF" | "IFS"
-            | "IFERROR"
-            | "IFNA"
-            | "CHOOSE"
-            | "SWITCH"
-            | "ROW"
-            | "COLUMN"
-            | "ROWS"
-            | "COLUMNS"
-            | "AREAS"
-            | "ISREF"
-            | "ISFORMULA"
-            | "FORMULATEXT"
-            | "SHEET"
-            | "SHEETS"
-            | "OFFSET"
-            | "INDIRECT"
-            | "INDEX"
-            | "CELL"
-            | "TRIMRANGE"
-            | "SUBTOTAL"
-            | "AGGREGATE"
-            | "TEXT"
-            | "LET"
-            | "LAMBDA"
-            | "ISOMITTED"
-            | "MAP"
-            | "REDUCE"
-            | "SCAN"
-            | "BYROW"
-            | "BYCOL"
-            | "MAKEARRAY"
-    )
-}
-
-/// Names of functions the evaluator implements itself (merged into the function list for UI).
-pub const SPECIAL_FUNCTIONS: &[&str] = &[
-    "IF",
-    "IFS",
-    "IFERROR",
-    "IFNA",
-    "CHOOSE",
-    "SWITCH",
-    "ROW",
-    "COLUMN",
-    "ROWS",
-    "COLUMNS",
-    "AREAS",
-    "ISREF",
-    "ISFORMULA",
-    "FORMULATEXT",
-    "SHEET",
-    "SHEETS",
-    "OFFSET",
-    "INDIRECT",
-    "INDEX",
-    "CELL",
-    "TRIMRANGE",
-    "SUBTOTAL",
-    "AGGREGATE",
-    "TEXT",
-    "LET",
-    "LAMBDA",
-    "ISOMITTED",
-    "MAP",
-    "REDUCE",
-    "SCAN",
-    "BYROW",
-    "BYCOL",
-    "MAKEARRAY",
-];
-
-pub fn is_known_function(n: &str) -> bool {
-    is_special(&n.to_ascii_uppercase()) || gridcraft_functions::lookup(n).is_some()
-}
-
-#[allow(dead_code)]
-fn unused(_: RefKind) {}
-
 #[cfg(test)]
 mod fuel_tests {
     use super::*;
diff --git a/crates/calc/src/eval/array.rs b/crates/calc/src/eval/array.rs
new file mode 100644
index 000000000..b17a8c70f
--- /dev/null
+++ b/crates/calc/src/eval/array.rs
@@ -0,0 +1,180 @@
+use super::*;
+
+/// The aggregates that can fold a reference without building an array.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum Agg {
+    Sum,
+    Count,
+    Average,
+}
+
+impl Agg {
+    pub(super) fn of(name: &str) -> Option<Agg> {
+        match name {
+            "SUM" => Some(Agg::Sum),
+            "COUNT" => Some(Agg::Count),
+            "AVERAGE" => Some(Agg::Average),
+            _ => None,
+        }
+    }
+}
+
+/// What a folded aggregate carries from one value to the next.
+#[derive(Default)]
+pub(super) struct Acc {
+    pub(super) sum: f64,
+    pub(super) count: u64,
+}
+
+impl Acc {
+    /// Takes a value found inside a reference: only numbers count. `Err` is an error value that
+    /// ends `SUM` and `AVERAGE`; `COUNT` skips errors.
+    pub(super) fn add_cell(&mut self, kind: Agg, v: &Value) -> Result<(), CellError> {
+        match v {
+            Value::Number(n) => {
+                self.sum += n;
+                self.count = self.count.saturating_add(1);
+                Ok(())
+            }
+            Value::Error(e) if kind != Agg::Count => Err(*e),
+            _ => Ok(()),
+        }
+    }
+
+    pub(super) fn finish(&self, kind: Agg) -> Value {
+        match kind {
+            Agg::Sum => Value::number(self.sum),
+            Agg::Count => Value::number(self.count as f64),
+            Agg::Average if self.count == 0 => Value::Error(CellError::Div0),
+            Agg::Average => Value::number(self.sum / self.count as f64),
+        }
+    }
+}
+
+// ---------------------------------------------------------------- operators
+
+pub(super) fn map_unary(v: &Value, f: &dyn Fn(f64) -> Value, plus: bool, sys: gridcraft_core::DateSystem) -> Value {
+    match v {
+        Value::Array(a) => Value::from(Array { rows: a.rows, cols: a.cols, data: a.data.iter().map(|x| map_unary(x, f, plus, sys)).collect() }),
+        Value::Error(e) => Value::Error(*e),
+        Value::Text(_) if plus => v.clone(),
+        other => match other.to_number_in(sys) {
+            Ok(n) => f(n),
+            Err(e) => Value::Error(e),
+        },
+    }
+}
+
+/// Element-wise combination with Excel's broadcasting.
+pub fn zip2(a: &Value, b: &Value, f: impl Fn(&Value, &Value) -> Value) -> Value {
+    match (a, b) {
+        (Value::Array(x), Value::Array(y)) => {
+            let rows = broadcast_dim(x.rows, y.rows);
+            let cols = broadcast_dim(x.cols, y.cols);
+            let Some(n) = broadcast_len(rows, cols) else { return Value::Error(CellError::Num) };
+            let mut data = Vec::with_capacity(n);
+            for r in 0..rows {
+                for c in 0..cols {
+                    data.push(f(&x.get_broadcast(r, c), &y.get_broadcast(r, c)));
+                }
+            }
+            Value::from(Array { rows, cols, data })
+        }
+        (Value::Array(x), s) => Value::from(Array { rows: x.rows, cols: x.cols, data: x.data.iter().map(|v| f(v, s)).collect() }),
+        (s, Value::Array(y)) => Value::from(Array { rows: y.rows, cols: y.cols, data: y.data.iter().map(|v| f(s, v)).collect() }),
+        (x, y) => f(x, y),
+    }
+}
+
+/// Cell count of a `rows`×`cols` broadcast result, or `None` when it would exceed [`MAX_CELLS`].
+/// Each operand passes its own size cap, but their broadcast product can be far larger
+/// (`SEQUENCE(1048576)*SEQUENCE(1,16384)` is 17 billion cells), so it is checked before allocating.
+pub(super) fn broadcast_len(rows: usize, cols: usize) -> Option<usize> {
+    rows.checked_mul(cols).filter(|&n| n as u64 <= MAX_CELLS)
+}
+
+fn broadcast_dim(a: usize, b: usize) -> usize {
+    if a == 1 {
+        b
+    } else if b == 1 {
+        a
+    } else {
+        a.max(b)
+    }
+}
+
+pub(super) fn zip3(c: &Array, t: &Value, f: &Value, g: impl Fn(&Value, &Value, &Value) -> Value) -> Value {
+    let dims = |v: &Value| if let Value::Array(a) = v { (a.rows, a.cols) } else { (1, 1) };
+    let (tr, tc) = dims(t);
+    let (fr, fc) = dims(f);
+    let rows = broadcast_dim(broadcast_dim(c.rows, tr), fr);
+    let cols = broadcast_dim(broadcast_dim(c.cols, tc), fc);
+    let Some(n) = broadcast_len(rows, cols) else { return Value::Error(CellError::Num) };
+    let get = |v: &Value, r: usize, col: usize| if let Value::Array(a) = v { a.get_broadcast(r, col) } else { v.clone() };
+    let mut data = Vec::with_capacity(n);
+    for r in 0..rows {
+        for col in 0..cols {
+            data.push(g(&c.get_broadcast(r, col), &get(t, r, col), &get(f, r, col)));
+        }
+    }
+    Value::from(Array { rows, cols, data })
+}
+
+/// One cell of a LAMBDA helper's result, or `None` for an array of more than one value: arrays
+/// can't nest, so the whole helper gives `#CALC!`, as in Excel.
+pub(super) fn single(v: Value) -> Option<Value> {
+    match v {
+        Value::Array(a) if a.rows * a.cols > 1 => None,
+        v => Some(v.scalar()),
+    }
+}
+
+pub fn binary_values(op: BinOp, x: &Value, y: &Value, sys: gridcraft_core::DateSystem) -> Value {
+    zip2(x, y, |a, b| binary_scalar(op, a, b, sys))
+}
+
+fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSystem) -> Value {
+    if let Value::Error(e) = a {
+        return Value::Error(*e);
+    }
+    if let Value::Error(e) = b {
+        return Value::Error(*e);
+    }
+    let num = |f: fn(f64, f64) -> Value| match (a.to_number_in(sys), b.to_number_in(sys)) {
+        (Ok(x), Ok(y)) => f(x, y),
+        (Err(e), _) | (_, Err(e)) => Value::Error(e),
+    };
+    use std::cmp::Ordering::*;
+    match op {
+        BinOp::Add => num(|x, y| Value::number(x + y)),
+        BinOp::Sub => num(|x, y| Value::number(x - y)),
+        BinOp::Mul => num(|x, y| Value::number(x * y)),
+        BinOp::Div => num(|x, y| if y == 0.0 { Value::Error(CellError::Div0) } else { Value::number(x / y) }),
+        BinOp::Pow => num(|x, y| {
+            if x == 0.0 && y == 0.0 {
+                Value::Error(CellError::Num)
+            } else if x == 0.0 && y < 0.0 {
+                Value::Error(CellError::Div0)
+            } else {
+                Value::number(x.powf(y))
+            }
+        }),
+        BinOp::Concat => match (a.to_text(), b.to_text()) {
+            (Ok(x), Ok(y)) => {
+                if x.len() + y.len() > 32767 * 4 {
+                    Value::Error(CellError::Value)
+                } else {
+                    Value::text(x + &y)
+                }
+            }
+            (Err(e), _) | (_, Err(e)) => Value::Error(e),
+        },
+        BinOp::Eq => Value::Bool(compare(a, b) == Equal),
+        BinOp::Ne => Value::Bool(compare(a, b) != Equal),
+        BinOp::Lt => Value::Bool(compare(a, b) == Less),
+        BinOp::Gt => Value::Bool(compare(a, b) == Greater),
+        BinOp::Le => Value::Bool(compare(a, b) != Greater),
+        BinOp::Ge => Value::Bool(compare(a, b) != Less),
+        BinOp::Range | BinOp::Union | BinOp::Intersect => Value::Error(CellError::Value),
+    }
+}
diff --git a/crates/calc/src/eval/call.rs b/crates/calc/src/eval/call.rs
new file mode 100644
index 000000000..9013ca882
--- /dev/null
+++ b/crates/calc/src/eval/call.rs
@@ -0,0 +1,424 @@
+use super::array::{Acc, Agg, zip2, zip3};
+use super::format::same_kind;
+use super::special::{ev_shape, resized_sum_range, resizes_sum_range};
+use super::*;
+
+impl<'h> Evaluator<'h> {
+    pub(super) fn call(&mut self, name: &str, args: &[Expr]) -> Ev {
+        match name {
+            "IF" => {
+                if args.is_empty() || args.len() > 3 {
+                    return err(CellError::Value);
+                }
+                let c = self.arg_val(args, 0).unwrap_or_default();
+                if let Value::Array(arr) = &c {
+                    // Array condition: element-wise.
+                    let t = self.arg_val(args, 1).unwrap_or(Value::Bool(true));
+                    let f = if args.len() > 2 { self.arg_val(args, 2).unwrap_or(Value::Bool(false)) } else { Value::Bool(false) };
+                    return Ev::V(zip3(arr, &t, &f, |c, t, f| match c.to_bool() {
+                        Ok(true) => t.clone(),
+                        Ok(false) => f.clone(),
+                        Err(e) => Value::Error(e),
+                    }));
+                }
+                match c.to_bool() {
+                    Ok(true) => match args.get(1) {
+                        Some(Expr::Missing) => Ev::V(Value::Number(0.0)),
+                        Some(e) => self.eval(e),
+                        None => Ev::V(Value::Bool(true)),
+                    },
+                    Ok(false) => match args.get(2) {
+                        Some(Expr::Missing) => Ev::V(Value::Number(0.0)),
+                        Some(e) => self.eval(e),
+                        None => Ev::V(Value::Bool(false)),
+                    },
+                    Err(e) => err(e),
+                }
+            }
+            "IFS" => {
+                if args.len() < 2 || !args.len().is_multiple_of(2) {
+                    return err(CellError::Value);
+                }
+                for pair in args.chunks(2) {
+                    let [c, v] = pair else { break };
+                    let cv = self.value(c);
+                    match cv.scalar().to_bool() {
+                        Ok(true) => return self.eval(v),
+                        Ok(false) => {}
+                        Err(e) => return err(e),
+                    }
+                }
+                err(CellError::NA)
+            }
+            "IFERROR" | "IFNA" => {
+                if args.len() != 2 {
+                    return err(CellError::Value);
+                }
+                let v = self.arg_ev(args, 0).unwrap_or(Ev::V(Value::Empty));
+                let na_only = name == "IFNA";
+                let catch = |e: CellError| if na_only { e == CellError::NA } else { true };
+                match &v {
+                    Ev::V(Value::Error(e)) if catch(*e) => self.eval(&args[1]),
+                    Ev::V(Value::Array(a)) if a.data.iter().any(|x| x.as_error().is_some_and(catch)) => {
+                        let alt = self.arg_val(args, 1).unwrap_or_default();
+                        let data = a.data.iter().map(|x| if x.as_error().is_some_and(catch) { alt.scalar() } else { x.clone() }).collect();
+                        Ev::V(Array::new(a.rows, a.cols, data).map(Value::from).unwrap_or(Value::Error(CellError::Value)))
+                    }
+                    Ev::R(_) => {
+                        let val = self.deref(v.clone());
+                        match val {
+                            Value::Error(e) if catch(e) => self.eval(&args[1]),
+                            Value::Array(ref a) if a.data.iter().any(|x| x.as_error().is_some_and(catch)) => {
+                                let alt = self.arg_val(args, 1).unwrap_or_default();
+                                let data = a.data.iter().map(|x| if x.as_error().is_some_and(catch) { alt.scalar() } else { x.clone() }).collect();
+                                Ev::V(Array::new(a.rows, a.cols, data).map(Value::from).unwrap_or(Value::Error(CellError::Value)))
+                            }
+                            _ => v,
+                        }
+                    }
+                    _ => v,
+                }
+            }
+            "CHOOSE" => {
+                if args.len() < 2 {
+                    return err(CellError::Value);
+                }
+                let index = self.value(&args[0]);
+                if let Value::Array(_) = index {
+                    // An array of indexes picks element by element: `CHOOSE({1,2},A1:A3,B1:B3)`
+                    // is a two-column array. The library CHOOSE lifts over its arguments.
+                    let Some(spec) = gridcraft_functions::lookup(name) else { return err(CellError::Name) };
+                    let mut evaluated = vec![Arg { value: index, from_ref: false }];
+                    for a in &args[1..] {
+                        let value = self.value(a);
+                        evaluated.push(Arg { value, from_ref: false });
+                    }
+                    let mut ctx = FnCtx { ev: self, criteria: None, lambda: None };
+                    return gridcraft_functions::call(spec, &evaluated, &mut ctx).pipe(Ev::V);
+                }
+                let i = match index.to_number() {
+                    Ok(n) => n.trunc() as i64,
+                    Err(e) => return err(e),
+                };
+                if i < 1 || i as usize >= args.len() {
+                    return err(CellError::Value);
+                }
+                self.eval(&args[i as usize])
+            }
+            "SWITCH" => {
+                if args.len() < 3 {
+                    return err(CellError::Value);
+                }
+                let v = self.arg_val(args, 0).unwrap_or_default().scalar();
+                if let Value::Error(e) = v {
+                    return err(e);
+                }
+                let rest = &args[1..];
+                let mut i = 0;
+                while i + 1 < rest.len() {
+                    let cand = self.value(&rest[i]).scalar();
+                    if !cand.is_error() && compare(&v, &cand) == std::cmp::Ordering::Equal && same_kind(&v, &cand) {
+                        return self.eval(&rest[i + 1]);
+                    }
+                    i += 2;
+                }
+                if rest.len() % 2 == 1 { rest.last().map_or(err(CellError::NA), |d| self.eval(d)) } else { err(CellError::NA) }
+            }
+            "ROW" | "COLUMN" => {
+                let is_row = name == "ROW";
+                if args.is_empty() || matches!(args.first(), Some(Expr::Missing)) {
+                    return Ev::V(Value::number(if is_row { self.at.row + 1 } else { self.at.col + 1 } as f64));
+                }
+                match self.eval(&args[0]) {
+                    Ev::R(a) => {
+                        let Some(a) = a.first() else { return err(CellError::Ref) };
+                        let r = self.trim_lines(a);
+                        if is_row {
+                            let rows: Vec<Value> = (r.start.row..=r.end.row).map(|x| Value::number(x as f64 + 1.0)).collect();
+                            if rows.len() == 1 { Ev::V(rows.into_iter().next().unwrap_or_default()) } else { Ev::V(Array::column(rows).into()) }
+                        } else {
+                            let cols: Vec<Value> = (r.start.col..=r.end.col).map(|x| Value::number(x as f64 + 1.0)).collect();
+                            if cols.len() == 1 { Ev::V(cols.into_iter().next().unwrap_or_default()) } else { Ev::V(Array::row(cols).into()) }
+                        }
+                    }
+                    Ev::V(Value::Error(e)) => err(e),
+                    _ => err(CellError::Value),
+                }
+            }
+            "ROWS" | "COLUMNS" => {
+                if args.len() != 1 {
+                    return err(CellError::Value);
+                }
+                let is_rows = name == "ROWS";
+                match self.eval(&args[0]) {
+                    Ev::R(a) => match a.as_slice() {
+                        [a] => Ev::V(Value::number(if is_rows { a.range.height() } else { a.range.width() } as f64)),
+                        _ => err(CellError::Ref),
+                    },
+                    Ev::V(Value::Array(arr)) => Ev::V(Value::number(if is_rows { arr.rows } else { arr.cols } as f64)),
+                    Ev::V(Value::Error(e)) => err(e),
+                    Ev::V(_) => Ev::V(Value::Number(1.0)),
+                    Ev::L(_) => err(CellError::Value),
+                }
+            }
+            "AREAS" => match args.first().map(|a| self.eval(a)) {
+                Some(Ev::R(a)) => Ev::V(Value::number(a.len() as f64)),
+                Some(Ev::V(Value::Error(e))) => err(e),
+                _ => err(CellError::Value),
+            },
+            "ISREF" => Ev::V(Value::Bool(matches!(args.first().map(|a| self.eval(a)), Some(Ev::R(_))))),
+            "ISFORMULA" | "FORMULATEXT" => {
+                let Some(Ev::R(a)) = args.first().map(|a| self.eval(a)) else { return err(CellError::NA) };
+                let Some(a) = a.first() else { return err(CellError::NA) };
+                let f = self.host.workbook().sheet(a.sheet).and_then(|s| s.cell(a.range.start)).and_then(|c| c.formula.clone());
+                if name == "ISFORMULA" {
+                    Ev::V(Value::Bool(f.is_some()))
+                } else {
+                    match f {
+                        Some(f) => Ev::V(Value::text(format!("={}", f.text))),
+                        None => err(CellError::NA),
+                    }
+                }
+            }
+            "SHEET" | "SHEETS" => {
+                let wb = self.host.workbook();
+                if args.is_empty() {
+                    return Ev::V(Value::number(if name == "SHEET" { self.sheet + 1 } else { wb.sheets.len() } as f64));
+                }
+                match self.eval(&args[0]) {
+                    Ev::R(a) => {
+                        if name == "SHEET" {
+                            a.first().map_or(err(CellError::Ref), |a| Ev::V(Value::number(a.sheet as f64 + 1.0)))
+                        } else {
+                            let mut s: Vec<usize> = a.iter().map(|x| x.sheet).collect();
+                            s.dedup();
+                            Ev::V(Value::number(s.len() as f64))
+                        }
+                    }
+                    Ev::V(Value::Text(t)) if name == "SHEET" => {
+                        let wb = self.host.workbook();
+                        wb.sheet_index(&t).map_or(err(CellError::NA), |i| Ev::V(Value::number(i as f64 + 1.0)))
+                    }
+                    _ => err(CellError::NA),
+                }
+            }
+            "OFFSET" => self.offset(args),
+            "INDIRECT" => self.indirect(args),
+            "INDEX" => self.index(args),
+            "XLOOKUP" => self.xlookup(args),
+            "CELL" => self.cell_info(args),
+            "TRIMRANGE" => self.trimrange(args),
+            "SUBTOTAL" | "AGGREGATE" => self.subtotal(name, args),
+            "TEXT" => {
+                if args.len() != 2 {
+                    return err(CellError::Value);
+                }
+                let v = self.arg_val(args, 0).unwrap_or_default();
+                let f = self.arg_val(args, 1).unwrap_or_default();
+                let sys = self.host.workbook().date_system;
+                let one = |v: &Value, f: &Value| -> Value {
+                    if let Value::Error(e) = v {
+                        return Value::Error(*e);
+                    }
+                    let code = match f.to_text() {
+                        Ok(c) => c,
+                        Err(e) => return Value::Error(e),
+                    };
+                    match gridcraft_numfmt::text_function(v, &code, sys) {
+                        Ok(s) => Value::text(s),
+                        Err(e) => Value::Error(e),
+                    }
+                };
+                Ev::V(zip2(&v, &f, one))
+            }
+            "LET" => self.let_(args),
+            "LAMBDA" => {
+                if args.is_empty() {
+                    return err(CellError::Value);
+                }
+                let mut params = Vec::new();
+                for p in &args[..args.len() - 1] {
+                    match p {
+                        Expr::Name(n) => params.push(n.trim_start_matches('[').trim_end_matches(']').to_string()),
+                        _ => return err(CellError::Value),
+                    }
+                }
+                let Some(body) = args.last() else { return err(CellError::Value) };
+                Ev::L(Arc::new(Lambda { params, body: body.clone(), env: self.env.clone() }))
+            }
+            "ISOMITTED" => {
+                let r = matches!(args.first(), Some(Expr::Name(n)) if self.env.iter().rev().find(|(k, _)| gridcraft_formula::same_name(k, n)).is_some_and(|(_, v)| matches!(v, Ev::V(Value::Empty))));
+                Ev::V(Value::Bool(r))
+            }
+            "MAP" | "REDUCE" | "SCAN" | "BYROW" | "BYCOL" | "MAKEARRAY" => self.higher_order(name, args),
+            "GROUPBY" | "PIVOTBY" => {
+                // The aggregation may be a function given by name (`SUM`): pass it as its name.
+                let i = if name == "GROUPBY" { 2 } else { 3 };
+                match args.get(i).and_then(|a| self.function_by_name(a)) {
+                    Some(f) => {
+                        let mut args = args.to_vec();
+                        if let Some(a) = args.get_mut(i) {
+                            *a = Expr::Text(f.into());
+                        }
+                        self.builtin(name, &args)
+                    }
+                    None => self.builtin(name, args),
+                }
+            }
+            "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" => {
+                self.host.note_volatile();
+                self.builtin(name, args)
+            }
+            _ => self.builtin(name, args),
+        }
+    }
+
+    pub(super) fn builtin(&mut self, name: &str, args: &[Expr]) -> Ev {
+        let Some(spec) = gridcraft_functions::lookup(name) else {
+            // A defined name holding a LAMBDA, or a LET-bound lambda.
+            return match self.name(name) {
+                Ev::L(l) => self.apply_lambda(&l, args),
+                Ev::V(Value::Error(x)) => err(x),
+                _ => err(CellError::Name),
+            };
+        };
+        if args.len() < spec.min_args || args.len() > spec.max_args {
+            return err(CellError::Value);
+        }
+        if let Some(kind) = Agg::of(spec.name) {
+            return self.aggregate(kind, args);
+        }
+        let mut evaluated = Vec::with_capacity(args.len());
+        // SUMIF/AVERAGEIF: the size of the criteria range (argument 1), which the sum range takes.
+        let mut criteria_shape = None;
+        // Database functions: the criteria range (argument 2), whose formulas are computed criteria.
+        let mut criteria = None;
+        // GROUPBY/PIVOTBY: the LAMBDA given as their function.
+        let mut lambda = None;
+        let lambda_at = match name {
+            "GROUPBY" => Some(2),
+            "PIVOTBY" => Some(3),
+            _ => None,
+        };
+        for (i, a) in args.iter().enumerate() {
+            let mut ev = self.eval(a);
+            if lambda_at == Some(i)
+                && let Ev::L(l) = &ev
+            {
+                lambda = Some(l.clone());
+                ev = Ev::V(Value::Empty);
+            }
+            if spec.category == gridcraft_functions::Category::Database
+                && i == 2
+                && let Ev::R(areas) = &ev
+                && let [area] = areas.as_slice()
+            {
+                criteria = Some(*area);
+            }
+            if resizes_sum_range(name, args.len()) {
+                if i == 0 {
+                    criteria_shape = ev_shape(&ev);
+                } else if i == 2
+                    && let (Some((h, w)), Ev::R(areas)) = (criteria_shape, &ev)
+                    && let [area] = areas.as_slice()
+                {
+                    ev = Ev::R(vec![Area { sheet: area.sheet, range: resized_sum_range(area.range, h, w) }]);
+                }
+            }
+            let from_ref = matches!(ev, Ev::R(_));
+            let value = match ev {
+                Ev::R(areas) if areas.len() > 1 => {
+                    // Multi-area references (unions): flatten into one row for aggregates.
+                    let mut vals = Vec::new();
+                    for ar in &areas {
+                        match self.area_value(ar) {
+                            Value::Array(a) => vals.extend(a.data.iter().cloned()),
+                            v => vals.push(v),
+                        }
+                    }
+                    Value::from(Array::row(vals))
+                }
+                ev => self.deref(ev),
+            };
+            evaluated.push(Arg { value, from_ref });
+        }
+        let mut ctx = FnCtx { ev: self, criteria, lambda };
+        gridcraft_functions::call(spec, &evaluated, &mut ctx).pipe(Ev::V)
+    }
+
+    /// Performs aggregation operations without copying its ranges: blocks are folded over the stored
+    /// cells, so no array is built and there is no `MAX_CELLS` limit. Arguments are evaluated and read one
+    /// after another, as the array path does, so volatile formulas (like `RAND`) see the same order.
+    /// Only `SUM`, `COUNT` and `AVG` are supported currently.
+    fn aggregate(&mut self, kind: Agg, args: &[Expr]) -> Ev {
+        let mut acc = Acc::default();
+        let mut first_error = None;
+        for a in args {
+            let ev = self.eval(a);
+            let steps = match ev {
+                Ev::R(areas) => areas.iter().map(|area| self.aggregate_area(kind, area, &mut acc)).collect(),
+                ev => {
+                    let value = self.deref(ev);
+                    vec![self.aggregate_value(kind, value, false, &mut acc)]
+                }
+            };
+            if first_error.is_none() {
+                first_error = steps.into_iter().find_map(Result::err);
+            }
+        }
+        first_error.unwrap_or_else(|| Ev::V(acc.finish(kind)))
+    }
+
+    /// Adds one area to `acc`; `Err` is the result the function ends with.
+    fn aggregate_area(&mut self, kind: Agg, a: &Area, acc: &mut Acc) -> Result<(), Ev> {
+        if !a.range.is_single() {
+            let mut error = None;
+            let walked = self.host.visit_range(a.sheet, a.range, &mut |v| match acc.add_cell(kind, v) {
+                Ok(()) => true,
+                Err(e) => {
+                    error = Some(e);
+                    false
+                }
+            });
+            if walked {
+                return error.map_or(Ok(()), |e| Err(err(e)));
+            }
+        }
+        let value = self.area_value(a);
+        self.aggregate_value(kind, value, true, acc)
+    }
+
+    /// Adds one argument's value by calling `SUM` and `COUNT` on it, so coercion and error rules
+    /// stay in one place (`AVERAGE` of an argument is its `SUM` over its `COUNT`).
+    fn aggregate_value(&mut self, kind: Agg, value: Value, from_ref: bool, acc: &mut Acc) -> Result<(), Ev> {
+        let (Some(sum), Some(count)) = (gridcraft_functions::lookup("SUM"), gridcraft_functions::lookup("COUNT")) else {
+            return Err(err(CellError::Name));
+        };
+        let args = [Arg { value, from_ref }];
+        if kind != Agg::Count {
+            match gridcraft_functions::call(sum, &args, &mut FnCtx { ev: self, criteria: None, lambda: None }) {
+                Value::Number(n) => acc.sum += n,
+                other => return Err(Ev::V(other)),
+            }
+        }
+        if kind != Agg::Sum {
+            match gridcraft_functions::call(count, &args, &mut FnCtx { ev: self, criteria: None, lambda: None }) {
+                Value::Number(n) => acc.count = acc.count.saturating_add(n as u64),
+                other => return Err(Ev::V(other)),
+            }
+        }
+        Ok(())
+    }
+
+    /// A worksheet function given by name where a function is expected (`BYROW(A1:C3,SUM)`,
+    /// `GROUPBY(A2:A9,B2:B9,SUM)`): its name, unless a LET/LAMBDA variable or a defined name has
+    /// that name.
+    pub(super) fn function_by_name(&self, e: &Expr) -> Option<String> {
+        let Expr::Name(n) = e else { return None };
+        if self.env.iter().any(|(k, _)| gridcraft_formula::same_name(k, n)) || self.host.workbook().name(n, self.sheet).is_some() {
+            return None;
+        }
+        let u = n.to_ascii_uppercase();
+        gridcraft_functions::lookup(&u).map(|_| u)
+    }
+}
diff --git a/crates/calc/src/eval/format.rs b/crates/calc/src/eval/format.rs
new file mode 100644
index 000000000..a4c52b492
--- /dev/null
+++ b/crates/calc/src/eval/format.rs
@@ -0,0 +1,74 @@
+use super::*;
+
+/// CELL("format") code for a number format.
+pub(super) fn cell_format_code(code: &str) -> String {
+    let c = code.to_ascii_lowercase();
+    if c == "general" {
+        return "G".into();
+    }
+    if c.contains('%') {
+        return format!("P{}", decimals(&c));
+    }
+    if c.contains('e') && c.contains('0') {
+        return format!("S{}", decimals(&c));
+    }
+    if c.contains('$') {
+        return format!("C{}", decimals(&c));
+    }
+    if c.contains('y') || c.contains('d') {
+        return "D1".into();
+    }
+    if c.contains('h') {
+        return "D9".into();
+    }
+    if c.contains(',') {
+        return format!(",{}", decimals(&c));
+    }
+    format!("F{}", decimals(&c))
+}
+
+fn decimals(c: &str) -> usize {
+    c.split_once('.').map_or(0, |(_, d)| d.chars().take_while(|ch| *ch == '0').count())
+}
+
+pub(super) fn same_kind(a: &Value, b: &Value) -> bool {
+    std::mem::discriminant(a) == std::mem::discriminant(b) || (a.is_empty() || b.is_empty())
+}
+
+/// Converts an R1C1 reference text to A1 (for INDIRECT(…, FALSE)). `Ok(None)` means the text is
+/// not R1C1; `Err` means it is R1C1 but points past the sheet.
+pub fn r1c1_to_a1(s: &str, at: CellRef) -> Result<Option<String>, CellError> {
+    let (sheet, body) = match s.rsplit_once('!') {
+        Some((sh, b)) => (format!("{sh}!"), b),
+        None => (String::new(), s),
+    };
+    let conv = |part: &str| -> Result<Option<String>, CellError> {
+        let u = part.to_ascii_uppercase();
+        let Some((rpart, cpart)) = u.strip_prefix('R').and_then(|rest| rest.split_once('C')) else { return Ok(None) };
+        // `None`: not R1C1. `Some(None)`: R1C1, but past the sheet.
+        let num = |p: &str, base: u32, max: u32| -> Option<Option<(u32, bool)>> {
+            let (v, absolute) = if p.is_empty() {
+                (Some(i64::from(base)), false)
+            } else if let Some(inner) = p.strip_prefix('[').and_then(|x| x.strip_suffix(']')) {
+                (i64::from(base).checked_add(inner.parse().ok()?), false)
+            } else {
+                (p.parse::<u32>().ok()?.checked_sub(1).map(i64::from), true)
+            };
+            Some(v.filter(|v| (0..i64::from(max)).contains(v)).map(|v| (v as u32, absolute)))
+        };
+        let (Some(r), Some(c)) = (num(rpart, at.row, MAX_ROWS), num(cpart, at.col, MAX_COLS)) else { return Ok(None) };
+        let (Some((r, ra)), Some((c, ca))) = (r, c) else { return Err(CellError::Ref) };
+        Ok(Some(format!("{}{}{}{}", if ca { "$" } else { "" }, gridcraft_core::col_to_letters(c), if ra { "$" } else { "" }, r + 1)))
+    };
+    let out = match body.split_once(':') {
+        Some((a, b)) => match (conv(a)?, conv(b)?) {
+            (Some(a), Some(b)) => format!("{a}:{b}"),
+            _ => return Ok(None),
+        },
+        None => match conv(body)? {
+            Some(x) => x,
+            None => return Ok(None),
+        },
+    };
+    Ok(Some(format!("{sheet}{out}")))
+}
diff --git a/crates/calc/src/eval/lambda.rs b/crates/calc/src/eval/lambda.rs
new file mode 100644
index 000000000..45f99b488
--- /dev/null
+++ b/crates/calc/src/eval/lambda.rs
@@ -0,0 +1,198 @@
+use super::array::{broadcast_len, single};
+use super::*;
+
+impl<'h> Evaluator<'h> {
+    pub fn apply_lambda(&mut self, l: &Lambda, args: &[Expr]) -> Ev {
+        // Too many or too few argument positions is #VALUE!. An explicitly empty position, as in
+        // `(1,)`, is `Expr::Missing` and still counts as a position (it binds as omitted). `f()`
+        // parses to no arguments, which for a one-parameter lambda can also be read as one empty
+        // position, so that call still binds the parameter as omitted.
+        let positions_ok = args.len() == l.params.len() || (args.is_empty() && l.params.len() == 1);
+        if !positions_ok {
+            return err(CellError::Value);
+        }
+        let mut bound = Vec::with_capacity(l.params.len());
+        for (i, p) in l.params.iter().enumerate() {
+            let v = match args.get(i) {
+                Some(Expr::Missing) | None => Ev::V(Value::Empty),
+                Some(e) => self.eval(e),
+            };
+            bound.push((p.clone(), v));
+        }
+        self.call_lambda_values(l, bound)
+    }
+
+    pub(super) fn call_lambda_values(&mut self, l: &Lambda, bound: Vec<(String, Ev)>) -> Ev {
+        if self.calls >= MAX_LAMBDA_CALLS {
+            return err(CellError::Num);
+        }
+        // #2382: one charge per invocation, so a cell's total work stays bounded however the
+        // lambdas nest. Foregrounding the charge here means every path into a body (direct
+        // `(2,3)` application, `MAP`/`REDUCE`/`BYROW` helpers, D-function criteria) meters.
+        self.fuel = match self.fuel.checked_sub(1) {
+            Some(f) => f,
+            None => return err(CellError::Calc),
+        };
+        self.calls += 1;
+        let saved = std::mem::replace(&mut self.env, l.env.clone());
+        self.env.extend(bound);
+        let r = self.eval(&l.body);
+        self.env = saved;
+        self.calls -= 1;
+        r
+    }
+
+    pub(super) fn let_(&mut self, args: &[Expr]) -> Ev {
+        if args.len() < 3 || args.len().is_multiple_of(2) {
+            return err(CellError::Value);
+        }
+        let base = self.env.len();
+        for pair in args[..args.len() - 1].chunks(2) {
+            let [Expr::Name(n), v] = pair else {
+                self.env.truncate(base);
+                return err(CellError::Value);
+            };
+            let val = self.eval(v);
+            self.env.push((n.clone(), val));
+        }
+        let r = match args.last() {
+            Some(body) => self.eval(body),
+            None => err(CellError::Value),
+        };
+        self.env.truncate(base);
+        r
+    }
+
+    /// The function argument of a LAMBDA helper; a function given by name takes `arity`
+    /// arguments.
+    fn lambda_arg(&mut self, e: Option<&Expr>, arity: usize) -> Option<Arc<Lambda>> {
+        if let Some(f) = e.and_then(|x| self.function_by_name(x)) {
+            let params: Vec<String> = (0..arity).map(|i| format!("_xleta.{i}")).collect();
+            let body = Expr::Call(f, params.iter().map(|p| Expr::Name(p.clone())).collect());
+            return Some(Arc::new(Lambda { params, body, env: Vec::new() }));
+        }
+        match e.map(|x| self.eval(x)) {
+            Some(Ev::L(l)) => Some(l),
+            _ => None,
+        }
+    }
+
+    pub(super) fn higher_order(&mut self, name: &str, args: &[Expr]) -> Ev {
+        let as_array = |v: Value| -> Arc<Array> {
+            match v {
+                Value::Array(a) => a,
+                other => Arc::new(Array::scalar(other)),
+            }
+        };
+        match name {
+            "MAP" => {
+                if args.len() < 2 {
+                    return err(CellError::Value);
+                }
+                let Some(l) = self.lambda_arg(args.last(), args.len() - 1) else { return err(CellError::Value) };
+                let arrays: Vec<Arc<Array>> = args[..args.len() - 1].iter().map(|a| as_array(self.value(a))).collect();
+                let rows = arrays.iter().map(|a| a.rows).max().unwrap_or(1);
+                let cols = arrays.iter().map(|a| a.cols).max().unwrap_or(1);
+                let Some(n) = broadcast_len(rows, cols) else { return err(CellError::Num) };
+                // The LAMBDA takes one parameter per array.
+                if l.params.len() != arrays.len() {
+                    return err(CellError::Value);
+                }
+                let mut out = Vec::with_capacity(n);
+                for r in 0..rows {
+                    for c in 0..cols {
+                        let bound = l.params.iter().zip(arrays.iter()).map(|(p, a)| (p.clone(), Ev::V(a.get_broadcast(r, c)))).collect();
+                        let v = self.call_lambda_values(&l, bound);
+                        let Some(one) = single(self.deref(v)) else { return err(CellError::Calc) };
+                        out.push(one);
+                    }
+                }
+                Ev::V(Array::new(rows, cols, out).map(Value::from).unwrap_or(Value::Error(CellError::Calc)))
+            }
+            "REDUCE" | "SCAN" => {
+                if args.len() != 3 {
+                    return err(CellError::Value);
+                }
+                let mut acc = self.value(&args[0]);
+                let arr = as_array(self.value(&args[1]));
+                let Some(l) = self.lambda_arg(args.get(2), 2) else { return err(CellError::Value) };
+                if l.params.len() != 2 {
+                    return err(CellError::Value);
+                }
+                let mut scan = Vec::with_capacity(arr.data.len());
+                for v in arr.data.iter() {
+                    let bound = vec![(l.params[0].clone(), Ev::V(acc.clone())), (l.params[1].clone(), Ev::V(v.clone()))];
+                    let r = self.call_lambda_values(&l, bound);
+                    acc = self.deref(r);
+                    if name == "SCAN" {
+                        let Some(one) = single(acc.clone()) else { return err(CellError::Calc) };
+                        scan.push(one);
+                    }
+                }
+                if name == "SCAN" {
+                    Ev::V(Array::new(arr.rows, arr.cols, scan).map(Value::from).unwrap_or(Value::Error(CellError::Calc)))
+                } else {
+                    Ev::V(acc)
+                }
+            }
+            "BYROW" | "BYCOL" => {
+                if args.len() != 2 {
+                    return err(CellError::Value);
+                }
+                let arr = as_array(self.value(&args[0]));
+                let Some(l) = self.lambda_arg(args.get(1), 1) else { return err(CellError::Value) };
+                let Some(p) = l.params.first().cloned() else { return err(CellError::Value) };
+                if l.params.len() != 1 {
+                    return err(CellError::Value);
+                }
+                let by_row = name == "BYROW";
+                let n = if by_row { arr.rows } else { arr.cols };
+                let mut out = Vec::with_capacity(n);
+                for i in 0..n {
+                    let slice: Vec<Value> = if by_row {
+                        (0..arr.cols).map(|c| arr.get(i, c).cloned().unwrap_or_default()).collect()
+                    } else {
+                        (0..arr.rows).map(|r| arr.get(r, i).cloned().unwrap_or_default()).collect()
+                    };
+                    let a = if by_row { Array::row(slice) } else { Array::column(slice) };
+                    let r = self.call_lambda_values(&l, vec![(p.clone(), Ev::V(a.into()))]);
+                    let Some(one) = single(self.deref(r)) else { return err(CellError::Calc) };
+                    out.push(one);
+                }
+                let a = if by_row { Array::column(out) } else { Array::row(out) };
+                Ev::V(a.into())
+            }
+            "MAKEARRAY" => {
+                if args.len() != 3 {
+                    return err(CellError::Value);
+                }
+                let (rows, cols) = match (self.arg_num(args, 0, 0.0), self.arg_num(args, 1, 0.0)) {
+                    (Ok(r), Ok(c)) => (r.trunc(), c.trunc()),
+                    (Err(e), _) | (_, Err(e)) => return err(e),
+                };
+                if rows < 1.0 || cols < 1.0 || rows * cols > MAX_CELLS as f64 {
+                    return err(CellError::Value);
+                }
+                let Some(l) = self.lambda_arg(args.get(2), 2) else { return err(CellError::Value) };
+                if l.params.len() != 2 {
+                    return err(CellError::Value);
+                }
+                let (rows, cols) = (rows as usize, cols as usize);
+                let mut out = Vec::with_capacity(rows * cols);
+                for r in 0..rows {
+                    for c in 0..cols {
+                        let bound = vec![
+                            (l.params[0].clone(), Ev::V(Value::number(r as f64 + 1.0))),
+                            (l.params[1].clone(), Ev::V(Value::number(c as f64 + 1.0))),
+                        ];
+                        let v = self.call_lambda_values(&l, bound);
+                        let Some(one) = single(self.deref(v)) else { return err(CellError::Calc) };
+                        out.push(one);
+                    }
+                }
+                Ev::V(Array::new(rows, cols, out).map(Value::from).unwrap_or(Value::Error(CellError::Calc)))
+            }
+            _ => err(CellError::Name),
+        }
+    }
+}
diff --git a/crates/calc/src/eval/reference_fns.rs b/crates/calc/src/eval/reference_fns.rs
new file mode 100644
index 000000000..a21797c23
--- /dev/null
+++ b/crates/calc/src/eval/reference_fns.rs
@@ -0,0 +1,407 @@
+use super::format::{cell_format_code, r1c1_to_a1};
+use super::*;
+
+impl<'h> Evaluator<'h> {
+    /// Whole rows/columns trimmed for ROW()/COLUMN() arrays.
+    pub(super) fn trim_lines(&mut self, a: &Area) -> RangeRef {
+        if a.range.is_full_cols() || a.range.is_full_rows() { self.trim(a) } else { a.range }
+    }
+
+    pub(super) fn offset(&mut self, args: &[Expr]) -> Ev {
+        self.host.note_volatile();
+        if args.len() < 3 || args.len() > 5 {
+            return err(CellError::Value);
+        }
+        let base = match self.eval(&args[0]) {
+            Ev::R(a) if a.len() == 1 => a[0],
+            Ev::V(Value::Error(e)) => return err(e),
+            _ => return err(CellError::Value),
+        };
+        let rows = match self.arg_num(args, 1, 0.0) {
+            Ok(n) => n.trunc() as i64,
+            Err(e) => return err(e),
+        };
+        let cols = match self.arg_num(args, 2, 0.0) {
+            Ok(n) => n.trunc() as i64,
+            Err(e) => return err(e),
+        };
+        let h = match self.arg_num(args, 3, base.range.height() as f64) {
+            Ok(n) => n.trunc() as i64,
+            Err(e) => return err(e),
+        };
+        let w = match self.arg_num(args, 4, base.range.width() as f64) {
+            Ok(n) => n.trunc() as i64,
+            Err(e) => return err(e),
+        };
+        if h == 0 || w == 0 {
+            return err(CellError::Ref);
+        }
+        let r0 = (base.range.start.row as i64).saturating_add(rows);
+        let c0 = (base.range.start.col as i64).saturating_add(cols);
+        let (r0, r1) = if h > 0 { (r0, r0.saturating_add(h - 1)) } else { (r0.saturating_add(h + 1), r0) };
+        let (c0, c1) = if w > 0 { (c0, c0.saturating_add(w - 1)) } else { (c0.saturating_add(w + 1), c0) };
+        if r0 < 0 || c0 < 0 || r1 >= MAX_ROWS as i64 || c1 >= MAX_COLS as i64 {
+            return err(CellError::Ref);
+        }
+        Ev::R(vec![Area { sheet: base.sheet, range: RangeRef::new(CellRef::new(r0 as u32, c0 as u32), CellRef::new(r1 as u32, c1 as u32)) }])
+    }
+
+    pub(super) fn indirect(&mut self, args: &[Expr]) -> Ev {
+        self.host.note_volatile();
+        if args.is_empty() || args.len() > 2 {
+            return err(CellError::Value);
+        }
+        let text = match self.arg_val(args, 0).map(|v| v.scalar().to_text()) {
+            Some(Ok(t)) => t,
+            Some(Err(e)) => return err(e),
+            None => return err(CellError::Value),
+        };
+        let a1 = match args.get(1) {
+            None | Some(Expr::Missing) => true,
+            Some(e) => {
+                let v = self.value(e);
+                v.scalar().to_bool().unwrap_or(true)
+            }
+        };
+        // With a1 = FALSE, text that isn't R1C1 can still be a name, but never an A1 reference.
+        let (text, a1_ok) = if a1 {
+            (text, true)
+        } else {
+            match r1c1_to_a1(&text, self.at) {
+                Ok(Some(a1_text)) => (a1_text, true),
+                Ok(None) => (text, false),
+                Err(e) => return err(e),
+            }
+        };
+        match gridcraft_formula::parse(&text) {
+            Ok(Expr::Ref(_)) if !a1_ok => err(CellError::Ref),
+            Ok(e @ (Expr::Ref(_) | Expr::Name(_) | Expr::Struct(_))) => match self.eval(&e) {
+                r @ Ev::R(_) => r,
+                _ => err(CellError::Ref),
+            },
+            _ => err(CellError::Ref),
+        }
+    }
+
+    pub(super) fn index(&mut self, args: &[Expr]) -> Ev {
+        if args.is_empty() || args.len() > 4 {
+            return err(CellError::Value);
+        }
+        let src = self.eval(&args[0]);
+        let mut arg = |i: usize| match args.get(i) {
+            None | Some(Expr::Missing) => None,
+            Some(e) => Some(self.value(e)),
+        };
+        let (rows, cols) = (arg(1), arg(2));
+        let area_n = match self.arg_num(args, 3, 1.0) {
+            Ok(n) => n.trunc() as i64,
+            Err(e) => return err(e),
+        };
+        let two = args.len() == 2;
+        let num = |v: &Option<Value>| v.as_ref().map_or(Ok(0.0), |v| v.to_number()).map(|n| n.trunc() as i64);
+        // Arrays of positions pick a value for each: INDEX(A1:C10,{1;2},{1,3}) is 2×2.
+        if let (Some(Value::Array(_)), _) | (_, Some(Value::Array(_))) = (&rows, &cols) {
+            let as_array = |v: &Option<Value>| match v {
+                Some(Value::Array(a)) => Arc::clone(a),
+                Some(v) => Arc::new(Array::scalar(v.clone())),
+                None => Arc::new(Array::scalar(Value::Number(0.0))),
+            };
+            let (ra, ca) = (as_array(&rows), as_array(&cols));
+            let (h, w) = (ra.rows.max(ca.rows), ra.cols.max(ca.cols));
+            if (h as u64).saturating_mul(w as u64) > MAX_CELLS {
+                return err(CellError::Num);
+            }
+            let mut out = Vec::with_capacity(h * w);
+            for r in 0..h {
+                for c in 0..w {
+                    let pos = (num(&Some(ra.get_broadcast(r, c))), num(&Some(ca.get_broadcast(r, c))));
+                    let v = match pos {
+                        (Ok(row), Ok(col)) => {
+                            let one = self.index_one(src.clone(), row, col, area_n, two);
+                            match self.deref(one) {
+                                Value::Array(a) if a.rows * a.cols > 1 => Value::Error(CellError::Calc),
+                                v => v.scalar(),
+                            }
+                        }
+                        (Err(e), _) | (_, Err(e)) => Value::Error(e),
+                    };
+                    out.push(v);
+                }
+            }
+            return Ev::V(Array::new(h, w, out).map(Value::from).unwrap_or(Value::Error(CellError::Value)));
+        }
+        let (row, col) = match (num(&rows), num(&cols)) {
+            (Ok(r), Ok(c)) => (r, c),
+            (Err(e), _) | (_, Err(e)) => return err(e),
+        };
+        self.index_one(src, row, col, area_n, two)
+    }
+
+    /// INDEX for one row and column position (0 = the whole column or row).
+    fn index_one(&mut self, src: Ev, row: i64, col: i64, area_n: i64, two_args: bool) -> Ev {
+        if row < 0 || col < 0 {
+            return err(CellError::Value);
+        }
+        match src {
+            Ev::R(areas) => {
+                let area = usize::try_from((area_n as u64).saturating_sub(1)).ok();
+                let Some(a) = area.and_then(|i| areas.get(i)).copied() else { return err(CellError::Ref) };
+                let r = a.range;
+                // A single row or column with one index picks along it. An area with several rows
+                // and columns needs both: `INDEX(A1:C3,2)` is #REF! in Excel (an empty third
+                // argument, `INDEX(A1:C3,2,)`, still means the whole row). Arrays differ:
+                // `INDEX({1,2;3,4},2)` is the row.
+                if two_args && r.height() > 1 && r.width() > 1 {
+                    return err(CellError::Ref);
+                }
+                let (row, col) = if two_args && r.height() == 1 { (1, row) } else { (row, col) };
+                if row as u64 > r.height() as u64 || col as u64 > r.width() as u64 {
+                    return err(CellError::Ref);
+                }
+                let (r0, r1) = if row == 0 { (r.start.row, r.end.row) } else { (r.start.row + row as u32 - 1, r.start.row + row as u32 - 1) };
+                let (c0, c1) = if col == 0 { (r.start.col, r.end.col) } else { (r.start.col + col as u32 - 1, r.start.col + col as u32 - 1) };
+                Ev::R(vec![Area { sheet: a.sheet, range: RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1)) }])
+            }
+            Ev::V(Value::Array(arr)) => {
+                let (row, col) = if two_args && arr.rows == 1 { (1, row) } else { (row, col) };
+                if row as usize > arr.rows || col as usize > arr.cols {
+                    return err(CellError::Ref);
+                }
+                match (row, col) {
+                    (0, 0) => Ev::V(Value::Array(arr)),
+                    (0, c) => Ev::V(Array::column((0..arr.rows).map(|r| arr.get(r, c as usize - 1).cloned().unwrap_or_default()).collect()).into()),
+                    (r, 0) => Ev::V(Array::row((0..arr.cols).map(|c| arr.get(r as usize - 1, c).cloned().unwrap_or_default()).collect()).into()),
+                    (r, c) => Ev::V(arr.get(r as usize - 1, c as usize - 1).cloned().unwrap_or(Value::Error(CellError::Ref))),
+                }
+            }
+            Ev::V(Value::Error(e)) => err(e),
+            Ev::V(v) => {
+                if row <= 1 && col <= 1 {
+                    Ev::V(v)
+                } else {
+                    err(CellError::Ref)
+                }
+            }
+            Ev::L(_) => err(CellError::Value),
+        }
+    }
+
+    /// XLOOKUP whose result range is a reference returns a reference, as in Excel, so that it can
+    /// end a range (`SUM(XLOOKUP(a,…):XLOOKUP(b,…))`) or feed CELL. Everything else (arrays of
+    /// lookup values, array arguments, errors) goes to the library function.
+    pub(super) fn xlookup(&mut self, args: &[Expr]) -> Ev {
+        if (3..=6).contains(&args.len())
+            && let (Ev::R(look), Ev::R(ret)) = (self.eval(&args[1]), self.eval(&args[2]))
+            && let ([l], [r]) = (look.as_slice(), ret.as_slice())
+            && let Some(spec) = gridcraft_functions::lookup("XMATCH")
+        {
+            let key = self.value(&args[0]);
+            let (l, r) = (*l, *r);
+            let vertical = l.range.width() == 1 && l.range.height() > 1;
+            let horizontal = l.range.height() == 1 && l.range.width() > 1;
+            let same_len = if vertical { r.range.height() == l.range.height() } else { r.range.width() == l.range.width() };
+            if !matches!(key, Value::Array(_)) && (vertical || horizontal) && same_len {
+                let mut xargs = vec![Arg { value: key, from_ref: false }, Arg { value: self.area_value(&l), from_ref: true }];
+                // An empty match_mode before a given search_mode is the default (0), not the end.
+                let given = |i: usize| args.get(i).is_some_and(|e| !matches!(e, Expr::Missing));
+                let last = if given(5) {
+                    5
+                } else if given(4) {
+                    4
+                } else {
+                    3
+                };
+                for i in 4..=last {
+                    match args.get(i) {
+                        Some(Expr::Missing) | None => xargs.push(Arg { value: Value::Number(0.0), from_ref: false }),
+                        Some(e) => {
+                            let value = self.value(e);
+                            xargs.push(Arg { value, from_ref: false });
+                        }
+                    }
+                }
+                let mut ctx = FnCtx { ev: self, criteria: None, lambda: None };
+                return match gridcraft_functions::call(spec, &xargs, &mut ctx) {
+                    Value::Number(p) if p >= 1.0 => {
+                        let k = p as u32 - 1;
+                        let range = if vertical {
+                            RangeRef::new(
+                                CellRef::new(r.range.start.row + k, r.range.start.col),
+                                CellRef::new(r.range.start.row + k, r.range.end.col),
+                            )
+                        } else {
+                            RangeRef::new(
+                                CellRef::new(r.range.start.row, r.range.start.col + k),
+                                CellRef::new(r.range.end.row, r.range.start.col + k),
+                            )
+                        };
+                        Ev::R(vec![Area { sheet: r.sheet, range }])
+                    }
+                    Value::Error(CellError::NA) if args.get(3).is_some_and(|e| !matches!(e, Expr::Missing)) => self.eval(&args[3]),
+                    Value::Error(e) => err(e),
+                    _ => err(CellError::Value),
+                };
+            }
+        }
+        self.builtin("XLOOKUP", args)
+    }
+
+    pub(super) fn cell_info(&mut self, args: &[Expr]) -> Ev {
+        let kind = match self.arg_val(args, 0).map(|v| v.scalar().to_text()) {
+            Some(Ok(t)) => t.to_ascii_lowercase(),
+            Some(Err(e)) => return err(e),
+            None => return err(CellError::Value),
+        };
+        let area = match args.get(1).map(|a| self.eval(a)) {
+            Some(Ev::R(a)) => a.first().copied(),
+            None => Some(Area { sheet: self.sheet, range: RangeRef::cell(self.at) }),
+            _ => return err(CellError::Value),
+        };
+        let Some(a) = area else { return err(CellError::Ref) };
+        let c = a.range.start;
+        let wb = self.host.workbook();
+        let sheet = wb.sheet(a.sheet);
+        match kind.as_str() {
+            "address" => Ev::V(Value::text(format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1))),
+            "row" => Ev::V(Value::number(c.row as f64 + 1.0)),
+            "col" => Ev::V(Value::number(c.col as f64 + 1.0)),
+            "contents" => Ev::V(self.host.cell_value(a.sheet, c)),
+            "type" => {
+                let v = self.host.cell_value(a.sheet, c);
+                Ev::V(Value::text(match v {
+                    Value::Empty => "b",
+                    Value::Text(_) => "l",
+                    _ => "v",
+                }))
+            }
+            "width" => Ev::V(Value::number(sheet.map_or(8.43, |s| gridcraft_model::points_to_chars(s.col_width(c.col) as f64)).round())),
+            // Excel's `<folder>/[<file>]<sheet>`, which the classic sheet-name formula splits on
+            // the `]`. Empty until the workbook has a file of its own, as in Excel (#1489).
+            "filename" => Ev::V(Value::text(match &wb.source_path {
+                Some(file) => {
+                    let name = file.file_name().unwrap_or_default().to_string_lossy();
+                    let on = sheet.map_or("", |s| s.name.as_str());
+                    file.parent().unwrap_or(std::path::Path::new("")).join(format!("[{name}]{on}")).to_string_lossy().into_owned()
+                }
+                None => String::new(),
+            })),
+            "sheetname" => Ev::V(Value::text(sheet.map(|s| s.name.clone()).unwrap_or_default())),
+            "protect" => Ev::V(Value::number(if sheet.is_some_and(|s| wb.styles.get(s.style_id(c)).protection.locked) { 1.0 } else { 0.0 })),
+            "format" => {
+                let code = sheet.map(|s| wb.styles.get(s.style_id(c)).num_fmt.as_str().to_string()).unwrap_or_default();
+                Ev::V(Value::text(cell_format_code(&code)))
+            }
+            "color" | "parentheses" => Ev::V(Value::Number(0.0)),
+            "prefix" => Ev::V(Value::text("")),
+            _ => err(CellError::Value),
+        }
+    }
+
+    pub(super) fn subtotal(&mut self, name: &str, args: &[Expr]) -> Ev {
+        // SUBTOTAL needs function_num and ref1; AGGREGATE needs function_num, options and ref1.
+        let min_args = if name == "AGGREGATE" { 3 } else { 2 };
+        if args.len() < min_args {
+            return err(CellError::Value);
+        }
+        let code = match self.arg_num(args, 0, 0.0) {
+            Ok(n) => n.trunc() as u32,
+            Err(e) => return err(e),
+        };
+        let (func, options, rest) = if name == "AGGREGATE" {
+            let opt = match self.arg_num(args, 1, 0.0) {
+                Ok(n) => n.trunc() as u32,
+                Err(e) => return err(e),
+            };
+            (code, opt, &args[2..])
+        } else {
+            let (f, ignore_hidden) = if code > 100 { (code - 100, true) } else { (code, false) };
+            (f, if ignore_hidden { 5 } else { 0 }, &args[1..])
+        };
+        if !(1..=19).contains(&func) || (name == "SUBTOTAL" && func > 11) {
+            return err(CellError::Value);
+        }
+        let skip_hidden = matches!(options, 1 | 3 | 5 | 7);
+        // SUBTOTAL leaves out rows a filter hides whatever the function number (Microsoft's
+        // SUBTOTAL documentation); 101-111 also leave out rows hidden by hand.
+        let skip_filtered = name == "SUBTOTAL";
+        let skip_errors = matches!(options, 2 | 3 | 6 | 7);
+        // SUBTOTAL always leaves out nested SUBTOTAL/AGGREGATE cells (101-111 too); AGGREGATE does so for options 0-3.
+        let skip_nested = name == "SUBTOTAL" || options <= 3;
+        let mut values = Vec::new();
+        let mut k = None;
+        let refs = if name == "AGGREGATE" && func >= 14 { &rest[..1.min(rest.len())] } else { rest };
+        if name == "AGGREGATE" && func >= 14 {
+            k = rest.get(1).map(|e| self.value(e));
+        }
+        // Every cell visited (even one skipped as hidden, nested or an error) and every value
+        // counts against one budget for the whole call. All arguments are evaluated (references
+        // stay lazy) and charged before any cell is read: a value stored in XFD1048576 makes
+        // `A:XFD` trim to the whole sheet, ~17 billion cells (#2175).
+        enum Input {
+            Cells(usize, RangeRef),
+            Values(Value),
+        }
+        let mut inputs = Vec::new();
+        let mut budget = MAX_CELLS;
+        for e in refs {
+            match self.eval(e) {
+                Ev::R(areas) => {
+                    for a in areas {
+                        let range = self.trim(&a);
+                        budget = match budget.checked_sub(range.count()) {
+                            Some(left) => left,
+                            None => return err(CellError::Num),
+                        };
+                        inputs.push(Input::Cells(a.sheet, range));
+                    }
+                }
+                Ev::V(v) => {
+                    let n = match &v {
+                        Value::Array(a) => u64::try_from(a.data.len()).unwrap_or(u64::MAX),
+                        _ => 1,
+                    };
+                    budget = match budget.checked_sub(n) {
+                        Some(left) => left,
+                        None => return err(CellError::Num),
+                    };
+                    inputs.push(Input::Values(v));
+                }
+                Ev::L(_) => return err(CellError::Value),
+            }
+        }
+        for input in inputs {
+            match input {
+                Input::Cells(sheet, range) => {
+                    for c in range.iter() {
+                        let (hidden, nested) = {
+                            let wb = self.host.workbook();
+                            let s = wb.sheet(sheet);
+                            let hidden =
+                                s.is_some_and(|s| if skip_hidden { s.is_row_hidden(c.row) } else { skip_filtered && s.is_row_filtered(c.row) });
+                            let nested = skip_nested
+                                && s.and_then(|s| s.cell(c)).and_then(|cell| cell.formula.as_ref()).is_some_and(|f| {
+                                    let u = f.text.to_ascii_uppercase();
+                                    u.contains("SUBTOTAL(") || u.contains("AGGREGATE(")
+                                });
+                            (hidden, nested)
+                        };
+                        if hidden || nested {
+                            continue;
+                        }
+                        let v = self.host.cell_value(sheet, c);
+                        if skip_errors && v.is_error() {
+                            continue;
+                        }
+                        values.push(v);
+                    }
+                }
+                Input::Values(Value::Array(a)) => values.extend(a.data.iter().filter(|v| !(skip_errors && v.is_error())).cloned()),
+                Input::Values(v) => values.push(v),
+            }
+        }
+        if let Some(k) = k {
+            return Ev::V(gridcraft_functions::aggregate_values_k(func, &values, &k));
+        }
+        Ev::V(gridcraft_functions::aggregate_values(func, &values))
+    }
+}
diff --git a/crates/calc/src/eval/special.rs b/crates/calc/src/eval/special.rs
new file mode 100644
index 000000000..f68badbfc
--- /dev/null
+++ b/crates/calc/src/eval/special.rs
@@ -0,0 +1,167 @@
+use super::*;
+
+/// SUMIF and AVERAGEIF with a sum range: Excel sizes the sum range like the criteria range.
+pub(super) fn resizes_sum_range(name: &str, args: usize) -> bool {
+    args == 3 && matches!(name, "SUMIF" | "AVERAGEIF")
+}
+
+/// Height and width of a single-area reference or an array argument.
+pub(super) fn ev_shape(ev: &Ev) -> Option<(u32, u32)> {
+    match ev {
+        Ev::R(areas) => match areas.as_slice() {
+            [a] => Some((a.range.height(), a.range.width())),
+            _ => None,
+        },
+        Ev::V(Value::Array(a)) => Some((u32::try_from(a.rows).unwrap_or(u32::MAX), u32::try_from(a.cols).unwrap_or(u32::MAX))),
+        Ev::V(_) => Some((1, 1)),
+        Ev::L(_) => None,
+    }
+}
+
+/// The range SUMIF/AVERAGEIF add up: from the sum range's top-left cell, as many rows and columns
+/// as the criteria range (`height` × `width`), cut off at the sheet's edge.
+pub fn resized_sum_range(sum: RangeRef, height: u32, width: u32) -> RangeRef {
+    let row = sum.start.row.saturating_add(height.saturating_sub(1)).min(MAX_ROWS - 1);
+    let col = sum.start.col.saturating_add(width.saturating_sub(1)).min(MAX_COLS - 1);
+    RangeRef::new(sum.start, CellRef::new(row, col))
+}
+
+/// Collects the static references of an expression with their sheets resolved; `dynamic` is
+/// set when the formula uses INDIRECT/OFFSET/names/tables whose targets can change.
+pub fn precedents(wb: &Workbook, sheet: usize, e: &Expr) -> (Vec<Area>, bool) {
+    let mut out = Vec::new();
+    let mut dynamic = false;
+    let push = |out: &mut Vec<Area>, r: &Reference, range: RangeRef| match &r.sheet {
+        SheetSel::Current => out.push(Area { sheet, range }),
+        SheetSel::Named(n) => {
+            if let Some(i) = wb.sheet_index(n) {
+                out.push(Area { sheet: i, range });
+            }
+        }
+        SheetSel::Span(a, b) => {
+            if let (Some(i), Some(j)) = (wb.sheet_index(a), wb.sheet_index(b)) {
+                for s in i.min(j)..=i.max(j) {
+                    out.push(Area { sheet: s, range });
+                }
+            }
+        }
+    };
+    e.walk(&mut |x| match x {
+        Expr::Ref(r) => push(&mut out, r, r.range()),
+        // The cells SUMIF/AVERAGEIF really read from the sum range (see `resized_sum_range`); when
+        // the criteria range's size isn't known statically, recalculate the formula every time.
+        Expr::Call(n, args) if resizes_sum_range(n, args.len()) => match (args.first(), args.get(2)) {
+            (Some(Expr::Ref(c)), Some(Expr::Ref(s))) => {
+                let (crit, sum) = (c.range(), s.range());
+                push(&mut out, s, resized_sum_range(sum, crit.height(), crit.width()));
+            }
+            (_, Some(Expr::Number(_) | Expr::Text(_) | Expr::Bool(_) | Expr::Error(_) | Expr::Array(_) | Expr::Missing)) => {}
+            _ => dynamic = true,
+        },
+        Expr::Call(n, _)
+            if matches!(n.as_str(), "INDIRECT" | "OFFSET" | "NOW" | "TODAY" | "RAND" | "RANDBETWEEN" | "RANDARRAY" | "CELL" | "INFO") =>
+        {
+            dynamic = true
+        }
+        Expr::Name(_) | Expr::Struct(_) => dynamic = true,
+        Expr::Call(n, _) if gridcraft_functions::lookup(n).is_none() && !is_special(n) => dynamic = true,
+        // A range ending in a function's result (`A1:INDEX(B1:B9,n)`) covers the cells between
+        // the references inside it, not only those references.
+        Expr::Binary(BinOp::Range, a, b) if !matches!((&**a, &**b), (Expr::Ref(_), Expr::Ref(_))) => {
+            let mut inner = precedents(wb, sheet, a).0;
+            inner.extend(precedents(wb, sheet, b).0);
+            let mut boxes: Vec<Area> = Vec::new();
+            for area in inner {
+                match boxes.iter_mut().find(|x| x.sheet == area.sheet) {
+                    Some(x) => x.range = x.range.union(&area.range),
+                    None => boxes.push(area),
+                }
+            }
+            out.extend(boxes);
+        }
+        _ => {}
+    });
+    (out, dynamic)
+}
+
+fn is_special(n: &str) -> bool {
+    matches!(
+        n,
+        "IF" | "IFS"
+            | "IFERROR"
+            | "IFNA"
+            | "CHOOSE"
+            | "SWITCH"
+            | "ROW"
+            | "COLUMN"
+            | "ROWS"
+            | "COLUMNS"
+            | "AREAS"
+            | "ISREF"
+            | "ISFORMULA"
+            | "FORMULATEXT"
+            | "SHEET"
+            | "SHEETS"
+            | "OFFSET"
+            | "INDIRECT"
+            | "INDEX"
+            | "CELL"
+            | "TRIMRANGE"
+            | "SUBTOTAL"
+            | "AGGREGATE"
+            | "TEXT"
+            | "LET"
+            | "LAMBDA"
+            | "ISOMITTED"
+            | "MAP"
+            | "REDUCE"
+            | "SCAN"
+            | "BYROW"
+            | "BYCOL"
+            | "MAKEARRAY"
+    )
+}
+
+/// Names of functions the evaluator implements itself (merged into the function list for UI).
+pub const SPECIAL_FUNCTIONS: &[&str] = &[
+    "IF",
+    "IFS",
+    "IFERROR",
+    "IFNA",
+    "CHOOSE",
+    "SWITCH",
+    "ROW",
+    "COLUMN",
+    "ROWS",
+    "COLUMNS",
+    "AREAS",
+    "ISREF",
+    "ISFORMULA",
+    "FORMULATEXT",
+    "SHEET",
+    "SHEETS",
+    "OFFSET",
+    "INDIRECT",
+    "INDEX",
+    "CELL",
+    "TRIMRANGE",
+    "SUBTOTAL",
+    "AGGREGATE",
+    "TEXT",
+    "LET",
+    "LAMBDA",
+    "ISOMITTED",
+    "MAP",
+    "REDUCE",
+    "SCAN",
+    "BYROW",
+    "BYCOL",
+    "MAKEARRAY",
+];
+
+pub fn is_known_function(n: &str) -> bool {
+    is_special(&n.to_ascii_uppercase()) || gridcraft_functions::lookup(n).is_some()
+}
+
+#[allow(dead_code)]
+fn unused(_: RefKind) {}

From c5098a07651c0ec4469ba3de29a6ce1d54336485 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:54:38 +0000
Subject: [PATCH 44/76] refactor(calc): move recalc.rs items to recalc/

---
 crates/calc/src/recalc.rs           | 895 +---------------------------
 crates/calc/src/recalc/graph.rs     | 340 +++++++++++
 crates/calc/src/recalc/pass_host.rs | 554 +++++++++++++++++
 3 files changed, 901 insertions(+), 888 deletions(-)
 create mode 100644 crates/calc/src/recalc/graph.rs
 create mode 100644 crates/calc/src/recalc/pass_host.rs

diff --git a/crates/calc/src/recalc.rs b/crates/calc/src/recalc.rs
index 17a0e6649..b7f403131 100644
--- a/crates/calc/src/recalc.rs
+++ b/crates/calc/src/recalc.rs
@@ -13,359 +13,20 @@
 use std::collections::{BTreeSet, VecDeque};
 use std::hash::{BuildHasherDefault, Hasher};
 
-/// A fast, non-cryptographic hasher for cell keys (FxHash-style multiply-rotate).
-#[derive(Default, Clone, Copy)]
-pub struct FxHasher(u64);
-
-impl Hasher for FxHasher {
-    fn finish(&self) -> u64 {
-        self.0
-    }
-    fn write(&mut self, bytes: &[u8]) {
-        for b in bytes {
-            self.write_u64(*b as u64);
-        }
-    }
-    fn write_u64(&mut self, i: u64) {
-        self.0 = (self.0.rotate_left(5) ^ i).wrapping_mul(0x51_7c_c1_b7_27_22_0a_95);
-    }
-    fn write_u32(&mut self, i: u32) {
-        self.write_u64(i as u64);
-    }
-    fn write_usize(&mut self, i: usize) {
-        self.write_u64(i as u64);
-    }
-}
-
-type HashMap<K, V> = std::collections::HashMap<K, V, BuildHasherDefault<FxHasher>>;
-type HashSet<K> = std::collections::HashSet<K, BuildHasherDefault<FxHasher>>;
-
 use gridcraft_core::{Array, CellError, CellRef, RangeRef, Value};
 use gridcraft_formula::Expr;
 use gridcraft_model::{CalcMode, Workbook};
 
 use crate::eval::{Area, Evaluator, Host, precedents, stack_position};
 
-pub type Key = (usize, CellRef);
+mod graph;
+mod pass_host;
 
-#[derive(Clone, Debug, Default)]
-struct Node {
-    areas: Vec<Area>,
-    dynamic: bool,
-}
-
-/// Ranges wider than this many columns go to the per-sheet wide index instead of per-column ones.
-const WIDE: u32 = 64;
-
-/// Insertions an [`Intervals`] keeps aside (scanned by every query) before merging them in.
-const PENDING: usize = 32;
-
-/// Formulas a formula may calculate on demand one inside the other (each needing one another's
-/// value before it is done). Each level takes stack, so a chain deeper than this is suspended and
-/// calculated from the top instead (see [`PassHost::calculate`]): long dependency chains calculate
-/// whatever order they come in, with bounded stack.
-const MAX_NESTED: usize = 64;
-
-/// Formula evaluations iterative calculation may spend on one recalculation (passes × formulas
-/// evaluated again), however high Maximum Iterations is.
-const MAX_ITERATION_WORK: usize = 10_000_000;
-
-/// Row intervals `[r0, r1]`, each with a payload, answering "which intervals overlap rows
-/// `a..=b`?" in O(log n + k).
-///
-/// The intervals are sorted by start with an implicit segment tree of their largest end, so a query
-/// only descends into subtrees that hold a match. Removals mark entries dead (re-inserting one
-/// revives it); insertions wait in a small sorted set. [`Intervals::settle`] merges them and drops
-/// dead entries once either grows, so mutations cost O(log n) amortised.
-#[derive(Clone, Debug)]
-struct Intervals<T> {
-    /// Sorted, without duplicates.
-    items: Vec<(u32, u32, T)>,
-    dead: Vec<bool>,
-    dead_count: usize,
-    /// Segment tree over `items`: node `i` has children `2i` and `2i + 1`, leaves start at
-    /// `max_end.len() / 2`. Each node holds the largest end below it (dead entries included).
-    max_end: Vec<u32>,
-    /// Inserted since the last merge.
-    pending: BTreeSet<(u32, u32, T)>,
-}
-
-impl<T> Default for Intervals<T> {
-    fn default() -> Self {
-        Intervals { items: Vec::new(), dead: Vec::new(), dead_count: 0, max_end: Vec::new(), pending: BTreeSet::new() }
-    }
-}
-
-impl<T: Copy + Ord> Intervals<T> {
-    fn is_empty(&self) -> bool {
-        self.items.len() == self.dead_count && self.pending.is_empty()
-    }
-
-    fn insert(&mut self, r0: u32, r1: u32, t: T) {
-        let it = (r0, r1, t);
-        if let Ok(i) = self.items.binary_search(&it) {
-            if let Some(d) = self.dead.get_mut(i)
-                && *d
-            {
-                *d = false;
-                self.dead_count -= 1;
-            }
-            return;
-        }
-        self.pending.insert(it);
-    }
-
-    fn remove(&mut self, r0: u32, r1: u32, t: T) {
-        let it = (r0, r1, t);
-        if let Ok(i) = self.items.binary_search(&it) {
-            if let Some(d) = self.dead.get_mut(i)
-                && !*d
-            {
-                *d = true;
-                self.dead_count += 1;
-            }
-            return;
-        }
-        self.pending.remove(&it);
-    }
-
-    /// Merges pending insertions and drops dead entries when there are enough of them.
-    fn settle(&mut self) {
-        if self.pending.len() <= PENDING && self.dead_count <= (self.items.len() / 2).max(PENDING) {
-            return;
-        }
-        let mut all: Vec<(u32, u32, T)> = Vec::with_capacity(self.items.len() - self.dead_count + self.pending.len());
-        all.extend(self.items.iter().zip(&self.dead).filter(|(_, d)| !**d).map(|(it, _)| *it));
-        all.extend(std::mem::take(&mut self.pending));
-        // Two sorted runs: the stable sort merges them in linear time.
-        all.sort();
-        all.dedup();
-        let size = all.len().next_power_of_two();
-        let mut max_end = vec![0; 2 * size];
-        if let Some(leaves) = max_end.get_mut(size..) {
-            for (slot, it) in leaves.iter_mut().zip(&all) {
-                *slot = it.1;
-            }
-        }
-        for i in (1..size).rev() {
-            let m = max_end.get(2 * i).copied().unwrap_or(0).max(max_end.get(2 * i + 1).copied().unwrap_or(0));
-            if let Some(slot) = max_end.get_mut(i) {
-                *slot = m;
-            }
-        }
-        self.dead = vec![false; all.len()];
-        self.dead_count = 0;
-        self.items = all;
-        self.max_end = max_end;
-    }
-
-    /// Calls `f` for every interval overlapping rows `a..=b` (`r0 <= b && r1 >= a`). Returns the
-    /// number of tree nodes visited.
-    fn query(&self, a: u32, b: u32, f: &mut dyn FnMut(&T)) -> usize {
-        for it in &self.pending {
-            if it.0 <= b && it.1 >= a {
-                f(&it.2);
-            }
-        }
-        // Entries before `p` start at or before row `b`.
-        let p = self.items.partition_point(|it| it.0 <= b);
-        if p == 0 {
-            return 0;
-        }
-        self.walk(1, 0, self.max_end.len() / 2, p, a, f)
-    }
-
-    fn walk(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, f: &mut dyn FnMut(&T)) -> usize {
-        if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) {
-            return 1;
-        }
-        if hi - lo <= 1 {
-            if let (Some(it), Some(false)) = (self.items.get(lo), self.dead.get(lo))
-                && it.1 >= a
-            {
-                f(&it.2);
-            }
-            return 1;
-        }
-        let mid = lo + (hi - lo) / 2;
-        1 + self.walk(2 * node, lo, mid, p, a, f) + self.walk(2 * node + 1, mid, hi, p, a, f)
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct Graph {
-    nodes: HashMap<Key, Node>,
-    /// single cell → dependents
-    cell_deps: HashMap<Key, HashSet<Key>>,
-    /// (sheet, col) → row intervals of the ranges (up to `WIDE` columns) that cover the column
-    col_deps: HashMap<(usize, u32), Intervals<Key>>,
-    /// sheet → row intervals of wider ranges, with their columns: (first, last, dependent)
-    wide_deps: HashMap<usize, Intervals<(u32, u32, Key)>>,
-    dynamic: HashSet<Key>,
-    /// Range indexes changed since the last [`Graph::settle`].
-    unsettled_cols: HashSet<(usize, u32)>,
-    unsettled_wide: HashSet<usize>,
-}
-
-impl Graph {
-    pub fn len(&self) -> usize {
-        self.nodes.len()
-    }
-    pub fn is_empty(&self) -> bool {
-        self.nodes.is_empty()
-    }
-
-    /// Index entries of a formula's precedents, without duplicates: single cells, column
-    /// intervals and wide ranges.
-    fn entries(areas: &[Area]) -> (Vec<Key>, Vec<(usize, u32, u32, u32)>, Vec<(usize, RangeRef)>) {
-        let (mut cells, mut cols, mut wide) = (Vec::new(), Vec::new(), Vec::new());
-        for a in areas {
-            if a.range.is_single() {
-                cells.push((a.sheet, a.range.start));
-            } else if a.range.width() > WIDE {
-                wide.push((a.sheet, a.range));
-            } else {
-                for c in a.range.start.col..=a.range.end.col {
-                    cols.push((a.sheet, c, a.range.start.row, a.range.end.row));
-                }
-            }
-        }
-        cells.sort_unstable();
-        cells.dedup();
-        cols.sort_unstable();
-        cols.dedup();
-        wide.sort_unstable_by_key(|(s, r)| (*s, r.start, r.end));
-        wide.dedup();
-        (cells, cols, wide)
-    }
-
-    fn insert(&mut self, k: Key, node: Node) {
-        self.remove(k);
-        let (cells, cols, wide) = Self::entries(&node.areas);
-        for c in cells {
-            self.cell_deps.entry(c).or_default().insert(k);
-        }
-        for (s, c, r0, r1) in cols {
-            self.col_deps.entry((s, c)).or_default().insert(r0, r1, k);
-            self.unsettled_cols.insert((s, c));
-        }
-        for (s, r) in wide {
-            self.wide_deps.entry(s).or_default().insert(r.start.row, r.end.row, (r.start.col, r.end.col, k));
-            self.unsettled_wide.insert(s);
-        }
-        if node.dynamic {
-            self.dynamic.insert(k);
-        }
-        self.nodes.insert(k, node);
-    }
-
-    fn remove(&mut self, k: Key) {
-        let Some(old) = self.nodes.remove(&k) else { return };
-        let (cells, cols, wide) = Self::entries(&old.areas);
-        for c in cells {
-            if let Some(v) = self.cell_deps.get_mut(&c) {
-                v.remove(&k);
-                if v.is_empty() {
-                    self.cell_deps.remove(&c);
-                }
-            }
-        }
-        for (s, c, r0, r1) in cols {
-            if let Some(v) = self.col_deps.get_mut(&(s, c)) {
-                v.remove(r0, r1, k);
-                self.unsettled_cols.insert((s, c));
-            }
-        }
-        for (s, r) in wide {
-            if let Some(v) = self.wide_deps.get_mut(&s) {
-                v.remove(r.start.row, r.end.row, (r.start.col, r.end.col, k));
-                self.unsettled_wide.insert(s);
-            }
-        }
-        self.dynamic.remove(&k);
-    }
-
-    /// Tidies the range indexes changed by `insert`/`remove` (queries stay correct without it,
-    /// just slower).
-    fn settle(&mut self) {
-        for key in std::mem::take(&mut self.unsettled_cols) {
-            if let Some(v) = self.col_deps.get_mut(&key) {
-                v.settle();
-                if v.is_empty() {
-                    self.col_deps.remove(&key);
-                }
-            }
-        }
-        for key in std::mem::take(&mut self.unsettled_wide) {
-            if let Some(v) = self.wide_deps.get_mut(&key) {
-                v.settle();
-                if v.is_empty() {
-                    self.wide_deps.remove(&key);
-                }
-            }
-        }
-    }
-
-    /// Formulas that read cell `c` of `sheet`.
-    pub fn dependents(&self, sheet: usize, c: CellRef, out: &mut Vec<Key>) {
-        if let Some(v) = self.cell_deps.get(&(sheet, c)) {
-            out.extend(v.iter().copied());
-        }
-        if let Some(v) = self.col_deps.get(&(sheet, c.col)) {
-            v.query(c.row, c.row, &mut |k| out.push(*k));
-        }
-        if let Some(v) = self.wide_deps.get(&sheet) {
-            v.query(c.row, c.row, &mut |(c0, c1, k)| {
-                if *c0 <= c.col && c.col <= *c1 {
-                    out.push(*k);
-                }
-            });
-        }
-    }
-
-    /// Formulas that read any cell of `range` (a formula can be listed more than once).
-    pub fn dependents_of_range(&self, sheet: usize, range: RangeRef, out: &mut Vec<Key>) {
-        if range.count() <= 4096 {
-            for c in range.iter() {
-                if let Some(v) = self.cell_deps.get(&(sheet, c)) {
-                    out.extend(v.iter().copied());
-                }
-            }
-        } else {
-            for ((s, c), v) in &self.cell_deps {
-                if *s == sheet && range.contains(*c) {
-                    out.extend(v.iter().copied());
-                }
-            }
-        }
-        let (r0, r1) = (range.start.row, range.end.row);
-        if (range.width() as usize) <= self.col_deps.len() {
-            for col in range.start.col..=range.end.col {
-                if let Some(v) = self.col_deps.get(&(sheet, col)) {
-                    v.query(r0, r1, &mut |k| out.push(*k));
-                }
-            }
-        } else {
-            for ((s, col), v) in &self.col_deps {
-                if *s == sheet && range.start.col <= *col && *col <= range.end.col {
-                    v.query(r0, r1, &mut |k| out.push(*k));
-                }
-            }
-        }
-        if let Some(v) = self.wide_deps.get(&sheet) {
-            v.query(r0, r1, &mut |(c0, c1, k)| {
-                if *c0 <= range.end.col && range.start.col <= *c1 {
-                    out.push(*k);
-                }
-            });
-        }
-    }
-
-    /// Precedent areas of a formula cell (for Trace Precedents).
-    pub fn precedents_of(&self, k: Key) -> Vec<Area> {
-        self.nodes.get(&k).map(|n| n.areas.clone()).unwrap_or_default()
-    }
-}
+#[cfg(test)]
+use graph::Intervals;
+pub use graph::{FxHasher, Graph, Key};
+use graph::{HashMap, HashSet, Node};
+use pass_host::{PassHost, spills_as_before};
 
 /// Calculation state kept beside a workbook.
 #[derive(Clone, Debug)]
@@ -385,548 +46,6 @@ impl Default for Calc {
     }
 }
 
-struct PassHost<'a> {
-    wb: &'a Workbook,
-    exprs: &'a HashMap<Key, std::sync::Arc<Expr>>,
-    results: HashMap<Key, Value>,
-    pending: HashSet<Key>,
-    in_progress: HashSet<Key>,
-    /// New spills found during the pass: anchor → array.
-    spills: HashMap<Key, std::sync::Arc<Array>>,
-    /// Used range per sheet: the workbook doesn't change during a pass, and working it out walks
-    /// every row, so once per sheet rather than once per range read.
-    used: HashMap<usize, Option<RangeRef>>,
-    rng: &'a mut u64,
-    now: f64,
-    cycle: bool,
-    cycles: Vec<Key>,
-    depth: usize,
-    /// A formula needed at [`MAX_NESTED`] levels deep: the evaluations in progress are abandoned
-    /// and it is calculated first.
-    suspend: Option<Key>,
-    /// Formulas whose evaluation was abandoned for another one, to be calculated again after it.
-    /// They all need it, so reading one of them while it is calculated is a circular reference,
-    /// as reading a formula in progress is.
-    waiting: HashSet<Key>,
-    /// The formulas abandoned since the last suspension.
-    abandoned: Vec<Key>,
-    /// Other formulas read at [`MAX_NESTED`] levels deep by the evaluations being abandoned. They
-    /// are calculated along with the suspended one, rather than one per restart (a wide range
-    /// read at the limit would restart the abandoned evaluations once per cell in it).
-    also: Vec<Key>,
-    /// Suspensions so far (tests check that a wide read at the limit needs one, not one per cell).
-    #[cfg(test)]
-    suspensions: usize,
-    /// The formulas in `cycles`.
-    cycle_seen: HashSet<Key>,
-    /// Iterative calculation: a circular reference reads the cell's previous value instead of
-    /// giving `#CIRC!`.
-    iterate: bool,
-    /// Values from the previous iteration; cells not in it read their stored value.
-    prev: HashMap<Key, Value>,
-    /// Formulas being evaluated, innermost last (kept only when iterating).
-    stack: Vec<Key>,
-    /// Formulas found on a circular reference (when iterating).
-    members: HashSet<Key>,
-    /// Results that read a previous value, directly or through other formulas.
-    tainted: HashSet<Key>,
-    /// Whether the formula being evaluated has read a previous value.
-    taint: bool,
-    /// `stack_position()` where the outermost formula being calculated started.
-    stack_top: usize,
-    /// Whether an evaluation ran past the stack budget since the innermost formula started.
-    out_of_stack: bool,
-}
-
-impl<'a> PassHost<'a> {
-    fn new(wb: &'a Workbook, exprs: &'a HashMap<Key, std::sync::Arc<Expr>>, rng: &'a mut u64, now: f64) -> Self {
-        PassHost {
-            wb,
-            exprs,
-            results: HashMap::with_capacity_and_hasher(exprs.len(), Default::default()),
-            pending: exprs.keys().copied().collect(),
-            in_progress: HashSet::default(),
-            spills: HashMap::default(),
-            used: HashMap::default(),
-            rng,
-            now,
-            cycle: false,
-            cycles: vec![],
-            depth: 0,
-            suspend: None,
-            waiting: HashSet::default(),
-            abandoned: Vec::new(),
-            also: Vec::new(),
-            #[cfg(test)]
-            suspensions: 0,
-            cycle_seen: HashSet::default(),
-            iterate: false,
-            prev: HashMap::default(),
-            stack: Vec::new(),
-            members: HashSet::default(),
-            tainted: HashSet::default(),
-            taint: false,
-            stack_top: 0,
-            out_of_stack: false,
-        }
-    }
-}
-
-/// Whether an array result at `k` can't spill: it is in a table, or its area runs off the sheet,
-/// overlaps merged cells, holds other cells, or another formula's spill (unless that formula is
-/// recalculated in this pass, and so may spill elsewhere now).
-fn spill_blocked(host: &PassHost<'_>, (sheet, anchor): Key, a: &Array) -> bool {
-    let Some(sh) = host.wb.sheet(sheet) else { return false };
-    let end =
-        CellRef::new(anchor.row.saturating_add((a.rows as u32).saturating_sub(1)), anchor.col.saturating_add((a.cols as u32).saturating_sub(1)));
-    let range = RangeRef::new(anchor, end);
-    let own = sh.spill_ranges.get(&anchor);
-    let spilled_over = |c: CellRef| {
-        !own.is_some_and(|o| o.contains(c))
-            && sh.spill_ranges.iter().any(|(o, r)| *o != anchor && r.contains(c) && !host.exprs.contains_key(&(sheet, *o)))
-    };
-    end.row >= gridcraft_core::MAX_ROWS
-        || end.col >= gridcraft_core::MAX_COLS
-        || sh.merges.iter().any(|m| m.intersects(&range))
-        || sh.tables.iter().any(|t| t.range.contains(anchor))
-        || sh.cells.iter_range(range).any(|(c, cell)| c != anchor && (!cell.value.is_empty() || cell.formula.is_some()))
-        || sh.spill.range(range.start..=range.end).any(|(c, _)| range.contains(*c) && spilled_over(*c))
-}
-
-/// Whether `arr`, anchored at `anchor`, would spill exactly what the sheet already holds over
-/// `range`: the same area, nothing new in the way, and the same values.
-fn spills_as_before(sheet: &gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, arr: &Array) -> bool {
-    let end =
-        CellRef::new(anchor.row.saturating_add((arr.rows as u32).saturating_sub(1)), anchor.col.saturating_add((arr.cols as u32).saturating_sub(1)));
-    RangeRef::new(anchor, end) == range
-        && !sheet.merges.iter().any(|m| m.intersects(&range))
-        && !sheet.tables.iter().any(|t| t.range.contains(anchor))
-        && range
-            .iter()
-            .enumerate()
-            .all(|(i, c)| c == anchor || (!sheet.cells.has(c) && sheet.spill.get(&c) == Some(arr.data.get(i).unwrap_or(&Value::Empty))))
-}
-
-impl PassHost<'_> {
-    /// Calculates `k` (and the formulas it reads) with bounded stack: when [`Self::compute`] would
-    /// go deeper than [`MAX_NESTED`], it suspends what is in progress, the formula it needed is
-    /// calculated from here, then the suspended ones again (reading the results kept so far).
-    fn calculate(&mut self, k: Key) {
-        // Formulas to calculate, innermost last, each with the ones abandoned to calculate the
-        // next.
-        let mut work: Vec<(Key, Vec<Key>)> = vec![(k, Vec::new())];
-        while let Some(&(top, _)) = work.last() {
-            self.compute(top);
-            match self.suspend.take() {
-                Some(next) => {
-                    #[cfg(test)]
-                    {
-                        self.suspensions += 1;
-                    }
-                    let held = std::mem::take(&mut self.abandoned);
-                    self.waiting.extend(held.iter().copied());
-                    if let Some(entry) = work.last_mut() {
-                        entry.1 = held;
-                    }
-                    // The other formulas read at the limit are calculated after `next`, before the
-                    // held evaluations restart. Each has nothing held of its own, so the held ones
-                    // are released only when the last of them is done.
-                    let mut seen: HashSet<Key> = HashSet::default();
-                    seen.insert(next);
-                    for s in std::mem::take(&mut self.also) {
-                        if seen.insert(s) {
-                            work.push((s, Vec::new()));
-                        }
-                    }
-                    work.push((next, Vec::new()));
-                }
-                None => {
-                    work.pop();
-                    if let Some(entry) = work.last_mut() {
-                        for a in entry.1.drain(..) {
-                            self.waiting.remove(&a);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn compute(&mut self, k: Key) -> Value {
-        if let Some(v) = self.results.get(&k) {
-            let v = v.clone();
-            if self.iterate && self.tainted.contains(&k) {
-                self.taint = true;
-            }
-            return v;
-        }
-        let Some(expr) = self.exprs.get(&k) else {
-            return self.wb.sheet(k.0).map(|s| s.value(k.1)).unwrap_or_default();
-        };
-        if self.suspend.is_some() {
-            // Unwinding to `calculate`: the value is thrown away. A formula read at the limit is
-            // calculated with the suspended one, so the evaluations are not restarted for each.
-            if self.depth >= MAX_NESTED && !self.in_progress.contains(&k) && !self.waiting.contains(&k) {
-                self.also.push(k);
-            }
-            return Value::Error(CellError::Calc);
-        }
-        if self.in_progress.contains(&k) || self.waiting.contains(&k) {
-            self.cycle = true;
-            if self.iterate {
-                return self.circular_read(k);
-            }
-            // Once each, though a suspended evaluation meets it again.
-            if self.cycle_seen.insert(k) {
-                self.cycles.push(k);
-            }
-            return Value::Error(CellError::Circ);
-        }
-        if self.depth >= MAX_NESTED {
-            self.suspend = Some(k);
-            return Value::Error(CellError::Calc);
-        }
-        if self.depth == 0 {
-            self.stack_top = stack_position();
-        }
-        self.in_progress.insert(k);
-        self.depth += 1;
-        let outer_taint = std::mem::replace(&mut self.taint, false);
-        if self.iterate {
-            self.stack.push(k);
-        }
-        let expr = std::sync::Arc::clone(expr);
-        let outer_out_of_stack = std::mem::replace(&mut self.out_of_stack, false);
-        let v = {
-            let mut ev = Evaluator::new(self, k.0, k.1);
-            ev.value(&expr)
-        };
-        let out_of_stack = std::mem::replace(&mut self.out_of_stack, outer_out_of_stack);
-        if out_of_stack && self.depth > 1 && self.suspend.is_none() {
-            // It ran out of the stack left below the formulas that read it: it is calculated
-            // from the top instead, as a formula needed at `MAX_NESTED` levels deep is.
-            self.suspend = Some(k);
-            self.depth -= 1;
-            self.in_progress.remove(&k);
-            if self.iterate {
-                self.stack.pop();
-            }
-            self.taint = outer_taint;
-            return Value::Error(CellError::Calc);
-        }
-        if self.suspend.is_some() {
-            // Abandoned: `calculate` evaluates this formula again once the one it needs is done.
-            self.depth -= 1;
-            self.in_progress.remove(&k);
-            self.abandoned.push(k);
-            if self.iterate {
-                self.stack.pop();
-            }
-            self.taint = outer_taint;
-            return Value::Error(CellError::Calc);
-        }
-        // A legacy array formula fills the range it was entered in.
-        let legacy = self.wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.as_ref()).and_then(|f| f.array);
-        let v = match legacy {
-            Some(range) => fit_to_range(v, range),
-            None => v,
-        };
-        self.depth -= 1;
-        self.in_progress.remove(&k);
-        self.pending.remove(&k);
-        if self.iterate {
-            self.stack.pop();
-            if self.taint {
-                self.tainted.insert(k);
-            } else {
-                self.tainted.remove(&k);
-            }
-        }
-        self.taint |= outer_taint;
-        // A blank cell shows as 0 in a formula's result, inside an array as well (`=A1:A3`,
-        // FILTER or SORT of a range with blanks). GROUPBY and PIVOTBY lay out blank cells
-        // of their own, which stay blank.
-        let keep_blanks = matches!(&*expr, Expr::Call(n, _) if matches!(n.as_str(), "GROUPBY" | "PIVOTBY"));
-        let v = match v {
-            Value::Array(a) => {
-                let a = if keep_blanks || !a.data.iter().any(|x| matches!(x, Value::Empty)) {
-                    a
-                } else {
-                    let data = a.data.iter().map(|x| if matches!(x, Value::Empty) { Value::Number(0.0) } else { x.clone() }).collect();
-                    Array::new(a.rows, a.cols, data).map(std::sync::Arc::new).unwrap_or(a)
-                };
-                // A dynamic-array formula anchors a spill range even while its result is one
-                // value -- a FILTER matching one row, a SORT or UNIQUE over one item -- so `C1#`
-                // is the 1 x 1 range and `ROWS(C1#)` is 1, as in Excel (#1491). A formula that
-                // returns a scalar never reaches this arm, so it does not become an anchor.
-                self.spills.insert(k, a.clone());
-                a.data.first().cloned().unwrap_or_default()
-            }
-            Value::Empty => Value::Number(0.0),
-            v => v,
-        };
-        // An array that can't spill is #SPILL! for the formulas evaluated after it in this pass too.
-        let v = match self.spills.get(&k) {
-            Some(a) if spill_blocked(self, k, a) => {
-                self.spills.remove(&k);
-                Value::Error(CellError::Spill)
-            }
-            _ => v,
-        };
-        self.results.insert(k, v.clone());
-        v
-    }
-
-    /// A formula's previous value for iterative calculation: from the last iteration, else the
-    /// value it shows. Blank, and the `#CIRC!` of a loop calculated with iteration off, are 0.
-    fn previous(&self, k: Key) -> Value {
-        let v = match self.prev.get(&k) {
-            Some(v) => v.clone(),
-            None => self.wb.sheet(k.0).map(|s| s.value(k.1)).unwrap_or_default(),
-        };
-        if matches!(v, Value::Empty | Value::Error(CellError::Circ)) { Value::Number(0.0) } else { v }
-    }
-
-    /// Reading `k` while it is being evaluated, with iterative calculation on: its previous value.
-    /// The formulas around the loop are the ones whose changes decide when iteration stops.
-    fn circular_read(&mut self, k: Key) -> Value {
-        self.taint = true;
-        match self.stack.iter().rposition(|s| *s == k) {
-            Some(i) => self.members.extend(self.stack.get(i..).unwrap_or_default().iter().copied()),
-            // Too deep to follow: the formula itself is watched.
-            None => {
-                self.members.insert(k);
-            }
-        }
-        self.previous(k)
-    }
-
-    /// Iterative calculation, after a first pass over `order` that met circular references. The
-    /// formulas that read a previous value (the loops and what depends on them) are evaluated
-    /// again in the same order, each pass starting from the last one's values and reading what it
-    /// has already produced (Gauss-Seidel), until no formula on a loop changes by `max_change` or
-    /// more, or after `max_iterations` passes in all. Returns the number of passes.
-    fn iterate_loops(&mut self, order: &[Key], max_iterations: u32, max_change: f64) -> u32 {
-        let again: Vec<Key> = order.iter().copied().filter(|k| self.tainted.contains(k)).collect();
-        let set: HashSet<Key> = again.iter().copied().collect();
-        // Bounds the work whatever Maximum Iterations says.
-        let max_passes = u32::try_from(MAX_ITERATION_WORK / again.len().max(1)).unwrap_or(u32::MAX).max(1);
-        let mut passes = 1u32;
-        while passes < max_iterations.min(max_passes) && !self.converged(max_change) {
-            self.prev = again.iter().filter_map(|k| self.results.remove(k).map(|v| (*k, v))).collect();
-            self.pending = set.clone();
-            self.spills.retain(|a, _| !set.contains(a));
-            for k in &again {
-                self.calculate(*k);
-            }
-            passes += 1;
-        }
-        passes
-    }
-
-    /// Whether every formula on a loop changed by less than `max_change` in the last pass (text,
-    /// logical and error values: not at all).
-    fn converged(&self, max_change: f64) -> bool {
-        self.members.iter().all(|k| {
-            let Some(new) = self.results.get(k) else { return true };
-            match (new, &self.previous(*k)) {
-                (Value::Number(a), Value::Number(b)) => {
-                    let d = (a - b).abs();
-                    d < max_change || d == 0.0
-                }
-                (new, old) => new == old,
-            }
-        })
-    }
-}
-
-/// A legacy (Ctrl+Shift+Enter) array formula's result fitted to the range it was entered in, as
-/// Excel does: a single row or column repeats across the range, a single value fills it, cells
-/// past the result show `#N/A`, and a result larger than the range is cut off.
-fn fit_to_range(v: Value, range: RangeRef) -> Value {
-    if range.count() > crate::eval::MAX_CELLS {
-        return Value::Error(CellError::Num);
-    }
-    let (h, w) = (range.height() as usize, range.width() as usize);
-    let Value::Array(a) = v else {
-        return if h * w == 1 { v } else { Array::new(h, w, vec![v; h * w]).map(Value::from).unwrap_or(Value::Error(CellError::Value)) };
-    };
-    if h * w == 1 {
-        return a.data.first().cloned().unwrap_or_default();
-    }
-    let mut data = Vec::with_capacity(h * w);
-    for r in 0..h {
-        for c in 0..w {
-            let (r, c) = (if a.rows == 1 { 0 } else { r }, if a.cols == 1 { 0 } else { c });
-            data.push(a.get(r, c).cloned().unwrap_or(Value::Error(CellError::NA)));
-        }
-    }
-    Array::new(h, w, data).map(Value::from).unwrap_or(Value::Error(CellError::Value))
-}
-
-impl Host for PassHost<'_> {
-    fn workbook(&self) -> &Workbook {
-        self.wb
-    }
-    fn stack_top(&self) -> Option<usize> {
-        (self.depth > 1).then_some(self.stack_top)
-    }
-    fn stack_exhausted(&mut self) {
-        self.out_of_stack = true;
-    }
-    fn spill_range(&mut self, sheet: usize, anchor: CellRef) -> Option<RangeRef> {
-        let k = (sheet, anchor);
-        if !(self.pending.contains(&k) || self.results.contains_key(&k)) {
-            return self.wb.sheet(sheet)?.spill_ranges.get(&anchor).copied();
-        }
-        // Recalculated in this pass: its new array, unless something blocks it (#SPILL!).
-        self.compute(k);
-        let arr = self.spills.get(&k)?;
-        let end = CellRef::new(
-            anchor.row.saturating_add((arr.rows as u32).saturating_sub(1)),
-            anchor.col.saturating_add((arr.cols as u32).saturating_sub(1)),
-        );
-        let range = RangeRef::new(anchor, end);
-        let sh = self.wb.sheet(sheet)?;
-        let blocked = end.row >= gridcraft_core::MAX_ROWS
-            || end.col >= gridcraft_core::MAX_COLS
-            || sh.cells.iter_range(range).any(|(c, cell)| c != anchor && (cell.formula.is_some() || !cell.value.is_empty()))
-            || sh.merges.iter().any(|m| m.intersects(&range));
-        (!blocked).then_some(range)
-    }
-    fn cell_value(&mut self, sheet: usize, c: CellRef) -> Value {
-        let k = (sheet, c);
-        if self.pending.contains(&k) || self.results.contains_key(&k) {
-            return self.compute(k);
-        }
-        // A cell covered by a spill computed in this pass.
-        for (anchor, arr) in &self.spills {
-            if anchor.0 == sheet && c.row >= anchor.1.row && c.col >= anchor.1.col {
-                let (dr, dc) = ((c.row - anchor.1.row) as usize, (c.col - anchor.1.col) as usize);
-                if dr < arr.rows && dc < arr.cols {
-                    if self.iterate && self.tainted.contains(anchor) {
-                        self.taint = true;
-                    }
-                    return arr.get(dr, dc).cloned().unwrap_or_default();
-                }
-            }
-        }
-        self.wb.sheet(sheet).map(|s| s.value(c)).unwrap_or_default()
-    }
-    fn range_values(&mut self, sheet: usize, range: RangeRef) -> Vec<Value> {
-        let (h, w) = (range.height() as usize, range.width() as usize);
-        let mut out = vec![Value::Empty; h * w];
-        let Some(sh) = self.wb.sheet(sheet) else { return out };
-        // Sparse walk: only stored cells; formula cells that are (or were) dirty go through
-        // `compute`, constants are copied straight from the store.
-        let mut formulas: Vec<(usize, CellRef)> = Vec::new();
-        for (c, cell) in sh.cells.iter_range(range) {
-            let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
-            if cell.formula.is_some() {
-                formulas.push((i, c));
-            } else if let Some(slot) = out.get_mut(i) {
-                *slot = cell.value.clone();
-            }
-        }
-        for (c, v) in sh.spill.range(range.start..=range.end) {
-            if range.contains(*c) {
-                let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
-                if let Some(slot) = out.get_mut(i)
-                    && slot.is_empty()
-                {
-                    *slot = v.clone();
-                }
-            }
-        }
-        for (i, c) in formulas {
-            let v = self.cell_value(sheet, c);
-            if let Some(slot) = out.get_mut(i) {
-                *slot = v;
-            }
-        }
-        if !self.spills.is_empty() {
-            let new: Vec<(usize, Value)> = self
-                .spills
-                .iter()
-                .filter(|(a, _)| a.0 == sheet)
-                .flat_map(|(a, arr)| {
-                    let mut v = Vec::new();
-                    for r in 0..arr.rows {
-                        for cc in 0..arr.cols {
-                            let c = CellRef::new(a.1.row.saturating_add(r as u32), a.1.col.saturating_add(cc as u32));
-                            if c != a.1 && range.contains(c) {
-                                v.push((
-                                    (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize,
-                                    arr.get(r, cc).cloned().unwrap_or_default(),
-                                ));
-                            }
-                        }
-                    }
-                    v
-                })
-                .collect();
-            // Iterating: an array spilled by a formula that read a previous value.
-            if self.iterate
-                && self.spills.iter().any(|(a, arr)| {
-                    let end = CellRef::new(
-                        a.1.row.saturating_add((arr.rows as u32).saturating_sub(1)),
-                        a.1.col.saturating_add((arr.cols as u32).saturating_sub(1)),
-                    );
-                    a.0 == sheet && self.tainted.contains(a) && RangeRef::new(a.1, end).intersects(&range)
-                })
-            {
-                self.taint = true;
-            }
-            for (i, v) in new {
-                if let Some(slot) = out.get_mut(i) {
-                    *slot = v;
-                }
-            }
-        }
-        out
-    }
-    fn visit_range(&mut self, sheet: usize, range: RangeRef, f: &mut dyn FnMut(&Value) -> bool) -> bool {
-        let wb = self.wb;
-        let Some(sh) = wb.sheet(sheet) else { return false };
-        // Formula cells first, in row-major order like `range_values`: reading one calculates it
-        // and the pass remembers the value, so the walk below gets the same value again without
-        // this method holding any.
-        for (c, cell) in sh.cells.iter_range(range) {
-            if cell.formula.is_some() {
-                let _ = self.cell_value(sheet, c);
-            }
-        }
-        // Spilled values sit between the stored cells (and the formulas just calculated may have
-        // produced some): leave such blocks to `range_values`.
-        if self.spills.keys().any(|a| a.0 == sheet) || sh.spill.range(range.start..=range.end).any(|(c, _)| range.contains(*c)) {
-            return false;
-        }
-        for (c, cell) in sh.cells.iter_range(range) {
-            let go = if cell.formula.is_some() { f(&self.cell_value(sheet, c)) } else { f(&cell.value) };
-            if !go {
-                break;
-            }
-        }
-        true
-    }
-    fn used_range(&mut self, sheet: usize) -> Option<RangeRef> {
-        let wb = self.wb;
-        *self.used.entry(sheet).or_insert_with(|| wb.sheet(sheet).and_then(|s| s.used_range()))
-    }
-    fn now_serial(&self) -> f64 {
-        self.now
-    }
-    fn random(&mut self) -> f64 {
-        // xorshift64*
-        let mut x = *self.rng;
-        x ^= x >> 12;
-        x ^= x << 25;
-        x ^= x >> 27;
-        *self.rng = x;
-        (x.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 11) as f64 / (1u64 << 53) as f64
-    }
-}
-
 /// Pops one finished component off Tarjan's stack, labelling its nodes with `comp_index`. The
 /// component is everything up to and including `root`.
 fn pop_component(stack: &mut Vec<usize>, on_stack: &mut [bool], comp: &mut [usize], comp_index: usize, root: usize) {
diff --git a/crates/calc/src/recalc/graph.rs b/crates/calc/src/recalc/graph.rs
new file mode 100644
index 000000000..aee4b46d5
--- /dev/null
+++ b/crates/calc/src/recalc/graph.rs
@@ -0,0 +1,340 @@
+use super::*;
+
+/// A fast, non-cryptographic hasher for cell keys (FxHash-style multiply-rotate).
+#[derive(Default, Clone, Copy)]
+pub struct FxHasher(u64);
+
+impl Hasher for FxHasher {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+    fn write(&mut self, bytes: &[u8]) {
+        for b in bytes {
+            self.write_u64(*b as u64);
+        }
+    }
+    fn write_u64(&mut self, i: u64) {
+        self.0 = (self.0.rotate_left(5) ^ i).wrapping_mul(0x51_7c_c1_b7_27_22_0a_95);
+    }
+    fn write_u32(&mut self, i: u32) {
+        self.write_u64(i as u64);
+    }
+    fn write_usize(&mut self, i: usize) {
+        self.write_u64(i as u64);
+    }
+}
+
+pub(super) type HashMap<K, V> = std::collections::HashMap<K, V, BuildHasherDefault<FxHasher>>;
+
+pub(super) type HashSet<K> = std::collections::HashSet<K, BuildHasherDefault<FxHasher>>;
+
+pub type Key = (usize, CellRef);
+
+#[derive(Clone, Debug, Default)]
+pub(super) struct Node {
+    pub(super) areas: Vec<Area>,
+    pub(super) dynamic: bool,
+}
+
+/// Ranges wider than this many columns go to the per-sheet wide index instead of per-column ones.
+const WIDE: u32 = 64;
+
+/// Insertions an [`Intervals`] keeps aside (scanned by every query) before merging them in.
+const PENDING: usize = 32;
+
+/// Row intervals `[r0, r1]`, each with a payload, answering "which intervals overlap rows
+/// `a..=b`?" in O(log n + k).
+///
+/// The intervals are sorted by start with an implicit segment tree of their largest end, so a query
+/// only descends into subtrees that hold a match. Removals mark entries dead (re-inserting one
+/// revives it); insertions wait in a small sorted set. [`Intervals::settle`] merges them and drops
+/// dead entries once either grows, so mutations cost O(log n) amortised.
+#[derive(Clone, Debug)]
+pub(super) struct Intervals<T> {
+    /// Sorted, without duplicates.
+    items: Vec<(u32, u32, T)>,
+    dead: Vec<bool>,
+    dead_count: usize,
+    /// Segment tree over `items`: node `i` has children `2i` and `2i + 1`, leaves start at
+    /// `max_end.len() / 2`. Each node holds the largest end below it (dead entries included).
+    max_end: Vec<u32>,
+    /// Inserted since the last merge.
+    pending: BTreeSet<(u32, u32, T)>,
+}
+
+impl<T> Default for Intervals<T> {
+    fn default() -> Self {
+        Intervals { items: Vec::new(), dead: Vec::new(), dead_count: 0, max_end: Vec::new(), pending: BTreeSet::new() }
+    }
+}
+
+impl<T: Copy + Ord> Intervals<T> {
+    pub(super) fn is_empty(&self) -> bool {
+        self.items.len() == self.dead_count && self.pending.is_empty()
+    }
+
+    pub(super) fn insert(&mut self, r0: u32, r1: u32, t: T) {
+        let it = (r0, r1, t);
+        if let Ok(i) = self.items.binary_search(&it) {
+            if let Some(d) = self.dead.get_mut(i)
+                && *d
+            {
+                *d = false;
+                self.dead_count -= 1;
+            }
+            return;
+        }
+        self.pending.insert(it);
+    }
+
+    pub(super) fn remove(&mut self, r0: u32, r1: u32, t: T) {
+        let it = (r0, r1, t);
+        if let Ok(i) = self.items.binary_search(&it) {
+            if let Some(d) = self.dead.get_mut(i)
+                && !*d
+            {
+                *d = true;
+                self.dead_count += 1;
+            }
+            return;
+        }
+        self.pending.remove(&it);
+    }
+
+    /// Merges pending insertions and drops dead entries when there are enough of them.
+    pub(super) fn settle(&mut self) {
+        if self.pending.len() <= PENDING && self.dead_count <= (self.items.len() / 2).max(PENDING) {
+            return;
+        }
+        let mut all: Vec<(u32, u32, T)> = Vec::with_capacity(self.items.len() - self.dead_count + self.pending.len());
+        all.extend(self.items.iter().zip(&self.dead).filter(|(_, d)| !**d).map(|(it, _)| *it));
+        all.extend(std::mem::take(&mut self.pending));
+        // Two sorted runs: the stable sort merges them in linear time.
+        all.sort();
+        all.dedup();
+        let size = all.len().next_power_of_two();
+        let mut max_end = vec![0; 2 * size];
+        if let Some(leaves) = max_end.get_mut(size..) {
+            for (slot, it) in leaves.iter_mut().zip(&all) {
+                *slot = it.1;
+            }
+        }
+        for i in (1..size).rev() {
+            let m = max_end.get(2 * i).copied().unwrap_or(0).max(max_end.get(2 * i + 1).copied().unwrap_or(0));
+            if let Some(slot) = max_end.get_mut(i) {
+                *slot = m;
+            }
+        }
+        self.dead = vec![false; all.len()];
+        self.dead_count = 0;
+        self.items = all;
+        self.max_end = max_end;
+    }
+
+    /// Calls `f` for every interval overlapping rows `a..=b` (`r0 <= b && r1 >= a`). Returns the
+    /// number of tree nodes visited.
+    pub(super) fn query(&self, a: u32, b: u32, f: &mut dyn FnMut(&T)) -> usize {
+        for it in &self.pending {
+            if it.0 <= b && it.1 >= a {
+                f(&it.2);
+            }
+        }
+        // Entries before `p` start at or before row `b`.
+        let p = self.items.partition_point(|it| it.0 <= b);
+        if p == 0 {
+            return 0;
+        }
+        self.walk(1, 0, self.max_end.len() / 2, p, a, f)
+    }
+
+    fn walk(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, f: &mut dyn FnMut(&T)) -> usize {
+        if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) {
+            return 1;
+        }
+        if hi - lo <= 1 {
+            if let (Some(it), Some(false)) = (self.items.get(lo), self.dead.get(lo))
+                && it.1 >= a
+            {
+                f(&it.2);
+            }
+            return 1;
+        }
+        let mid = lo + (hi - lo) / 2;
+        1 + self.walk(2 * node, lo, mid, p, a, f) + self.walk(2 * node + 1, mid, hi, p, a, f)
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct Graph {
+    pub(super) nodes: HashMap<Key, Node>,
+    /// single cell → dependents
+    cell_deps: HashMap<Key, HashSet<Key>>,
+    /// (sheet, col) → row intervals of the ranges (up to `WIDE` columns) that cover the column
+    col_deps: HashMap<(usize, u32), Intervals<Key>>,
+    /// sheet → row intervals of wider ranges, with their columns: (first, last, dependent)
+    wide_deps: HashMap<usize, Intervals<(u32, u32, Key)>>,
+    pub(super) dynamic: HashSet<Key>,
+    /// Range indexes changed since the last [`Graph::settle`].
+    unsettled_cols: HashSet<(usize, u32)>,
+    unsettled_wide: HashSet<usize>,
+}
+
+impl Graph {
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.nodes.is_empty()
+    }
+
+    /// Index entries of a formula's precedents, without duplicates: single cells, column
+    /// intervals and wide ranges.
+    fn entries(areas: &[Area]) -> (Vec<Key>, Vec<(usize, u32, u32, u32)>, Vec<(usize, RangeRef)>) {
+        let (mut cells, mut cols, mut wide) = (Vec::new(), Vec::new(), Vec::new());
+        for a in areas {
+            if a.range.is_single() {
+                cells.push((a.sheet, a.range.start));
+            } else if a.range.width() > WIDE {
+                wide.push((a.sheet, a.range));
+            } else {
+                for c in a.range.start.col..=a.range.end.col {
+                    cols.push((a.sheet, c, a.range.start.row, a.range.end.row));
+                }
+            }
+        }
+        cells.sort_unstable();
+        cells.dedup();
+        cols.sort_unstable();
+        cols.dedup();
+        wide.sort_unstable_by_key(|(s, r)| (*s, r.start, r.end));
+        wide.dedup();
+        (cells, cols, wide)
+    }
+
+    pub(super) fn insert(&mut self, k: Key, node: Node) {
+        self.remove(k);
+        let (cells, cols, wide) = Self::entries(&node.areas);
+        for c in cells {
+            self.cell_deps.entry(c).or_default().insert(k);
+        }
+        for (s, c, r0, r1) in cols {
+            self.col_deps.entry((s, c)).or_default().insert(r0, r1, k);
+            self.unsettled_cols.insert((s, c));
+        }
+        for (s, r) in wide {
+            self.wide_deps.entry(s).or_default().insert(r.start.row, r.end.row, (r.start.col, r.end.col, k));
+            self.unsettled_wide.insert(s);
+        }
+        if node.dynamic {
+            self.dynamic.insert(k);
+        }
+        self.nodes.insert(k, node);
+    }
+
+    pub(super) fn remove(&mut self, k: Key) {
+        let Some(old) = self.nodes.remove(&k) else { return };
+        let (cells, cols, wide) = Self::entries(&old.areas);
+        for c in cells {
+            if let Some(v) = self.cell_deps.get_mut(&c) {
+                v.remove(&k);
+                if v.is_empty() {
+                    self.cell_deps.remove(&c);
+                }
+            }
+        }
+        for (s, c, r0, r1) in cols {
+            if let Some(v) = self.col_deps.get_mut(&(s, c)) {
+                v.remove(r0, r1, k);
+                self.unsettled_cols.insert((s, c));
+            }
+        }
+        for (s, r) in wide {
+            if let Some(v) = self.wide_deps.get_mut(&s) {
+                v.remove(r.start.row, r.end.row, (r.start.col, r.end.col, k));
+                self.unsettled_wide.insert(s);
+            }
+        }
+        self.dynamic.remove(&k);
+    }
+
+    /// Tidies the range indexes changed by `insert`/`remove` (queries stay correct without it,
+    /// just slower).
+    pub(super) fn settle(&mut self) {
+        for key in std::mem::take(&mut self.unsettled_cols) {
+            if let Some(v) = self.col_deps.get_mut(&key) {
+                v.settle();
+                if v.is_empty() {
+                    self.col_deps.remove(&key);
+                }
+            }
+        }
+        for key in std::mem::take(&mut self.unsettled_wide) {
+            if let Some(v) = self.wide_deps.get_mut(&key) {
+                v.settle();
+                if v.is_empty() {
+                    self.wide_deps.remove(&key);
+                }
+            }
+        }
+    }
+
+    /// Formulas that read cell `c` of `sheet`.
+    pub fn dependents(&self, sheet: usize, c: CellRef, out: &mut Vec<Key>) {
+        if let Some(v) = self.cell_deps.get(&(sheet, c)) {
+            out.extend(v.iter().copied());
+        }
+        if let Some(v) = self.col_deps.get(&(sheet, c.col)) {
+            v.query(c.row, c.row, &mut |k| out.push(*k));
+        }
+        if let Some(v) = self.wide_deps.get(&sheet) {
+            v.query(c.row, c.row, &mut |(c0, c1, k)| {
+                if *c0 <= c.col && c.col <= *c1 {
+                    out.push(*k);
+                }
+            });
+        }
+    }
+
+    /// Formulas that read any cell of `range` (a formula can be listed more than once).
+    pub fn dependents_of_range(&self, sheet: usize, range: RangeRef, out: &mut Vec<Key>) {
+        if range.count() <= 4096 {
+            for c in range.iter() {
+                if let Some(v) = self.cell_deps.get(&(sheet, c)) {
+                    out.extend(v.iter().copied());
+                }
+            }
+        } else {
+            for ((s, c), v) in &self.cell_deps {
+                if *s == sheet && range.contains(*c) {
+                    out.extend(v.iter().copied());
+                }
+            }
+        }
+        let (r0, r1) = (range.start.row, range.end.row);
+        if (range.width() as usize) <= self.col_deps.len() {
+            for col in range.start.col..=range.end.col {
+                if let Some(v) = self.col_deps.get(&(sheet, col)) {
+                    v.query(r0, r1, &mut |k| out.push(*k));
+                }
+            }
+        } else {
+            for ((s, col), v) in &self.col_deps {
+                if *s == sheet && range.start.col <= *col && *col <= range.end.col {
+                    v.query(r0, r1, &mut |k| out.push(*k));
+                }
+            }
+        }
+        if let Some(v) = self.wide_deps.get(&sheet) {
+            v.query(r0, r1, &mut |(c0, c1, k)| {
+                if *c0 <= range.end.col && range.start.col <= *c1 {
+                    out.push(*k);
+                }
+            });
+        }
+    }
+
+    /// Precedent areas of a formula cell (for Trace Precedents).
+    pub fn precedents_of(&self, k: Key) -> Vec<Area> {
+        self.nodes.get(&k).map(|n| n.areas.clone()).unwrap_or_default()
+    }
+}
diff --git a/crates/calc/src/recalc/pass_host.rs b/crates/calc/src/recalc/pass_host.rs
new file mode 100644
index 000000000..00e92e82b
--- /dev/null
+++ b/crates/calc/src/recalc/pass_host.rs
@@ -0,0 +1,554 @@
+use super::graph::{HashMap, HashSet, Key};
+use super::*;
+
+/// Formulas a formula may calculate on demand one inside the other (each needing one another's
+/// value before it is done). Each level takes stack, so a chain deeper than this is suspended and
+/// calculated from the top instead (see [`PassHost::calculate`]): long dependency chains calculate
+/// whatever order they come in, with bounded stack.
+const MAX_NESTED: usize = 64;
+
+/// Formula evaluations iterative calculation may spend on one recalculation (passes × formulas
+/// evaluated again), however high Maximum Iterations is.
+const MAX_ITERATION_WORK: usize = 10_000_000;
+
+pub(super) struct PassHost<'a> {
+    wb: &'a Workbook,
+    exprs: &'a HashMap<Key, std::sync::Arc<Expr>>,
+    pub(super) results: HashMap<Key, Value>,
+    pending: HashSet<Key>,
+    in_progress: HashSet<Key>,
+    /// New spills found during the pass: anchor → array.
+    pub(super) spills: HashMap<Key, std::sync::Arc<Array>>,
+    /// Used range per sheet: the workbook doesn't change during a pass, and working it out walks
+    /// every row, so once per sheet rather than once per range read.
+    used: HashMap<usize, Option<RangeRef>>,
+    rng: &'a mut u64,
+    now: f64,
+    cycle: bool,
+    pub(super) cycles: Vec<Key>,
+    depth: usize,
+    /// A formula needed at [`MAX_NESTED`] levels deep: the evaluations in progress are abandoned
+    /// and it is calculated first.
+    suspend: Option<Key>,
+    /// Formulas whose evaluation was abandoned for another one, to be calculated again after it.
+    /// They all need it, so reading one of them while it is calculated is a circular reference,
+    /// as reading a formula in progress is.
+    waiting: HashSet<Key>,
+    /// The formulas abandoned since the last suspension.
+    abandoned: Vec<Key>,
+    /// Other formulas read at [`MAX_NESTED`] levels deep by the evaluations being abandoned. They
+    /// are calculated along with the suspended one, rather than one per restart (a wide range
+    /// read at the limit would restart the abandoned evaluations once per cell in it).
+    also: Vec<Key>,
+    /// Suspensions so far (tests check that a wide read at the limit needs one, not one per cell).
+    #[cfg(test)]
+    pub(super) suspensions: usize,
+    /// The formulas in `cycles`.
+    cycle_seen: HashSet<Key>,
+    /// Iterative calculation: a circular reference reads the cell's previous value instead of
+    /// giving `#CIRC!`.
+    pub(super) iterate: bool,
+    /// Values from the previous iteration; cells not in it read their stored value.
+    prev: HashMap<Key, Value>,
+    /// Formulas being evaluated, innermost last (kept only when iterating).
+    stack: Vec<Key>,
+    /// Formulas found on a circular reference (when iterating).
+    pub(super) members: HashSet<Key>,
+    /// Results that read a previous value, directly or through other formulas.
+    pub(super) tainted: HashSet<Key>,
+    /// Whether the formula being evaluated has read a previous value.
+    taint: bool,
+    /// `stack_position()` where the outermost formula being calculated started.
+    stack_top: usize,
+    /// Whether an evaluation ran past the stack budget since the innermost formula started.
+    out_of_stack: bool,
+}
+
+impl<'a> PassHost<'a> {
+    pub(super) fn new(wb: &'a Workbook, exprs: &'a HashMap<Key, std::sync::Arc<Expr>>, rng: &'a mut u64, now: f64) -> Self {
+        PassHost {
+            wb,
+            exprs,
+            results: HashMap::with_capacity_and_hasher(exprs.len(), Default::default()),
+            pending: exprs.keys().copied().collect(),
+            in_progress: HashSet::default(),
+            spills: HashMap::default(),
+            used: HashMap::default(),
+            rng,
+            now,
+            cycle: false,
+            cycles: vec![],
+            depth: 0,
+            suspend: None,
+            waiting: HashSet::default(),
+            abandoned: Vec::new(),
+            also: Vec::new(),
+            #[cfg(test)]
+            suspensions: 0,
+            cycle_seen: HashSet::default(),
+            iterate: false,
+            prev: HashMap::default(),
+            stack: Vec::new(),
+            members: HashSet::default(),
+            tainted: HashSet::default(),
+            taint: false,
+            stack_top: 0,
+            out_of_stack: false,
+        }
+    }
+}
+
+/// Whether an array result at `k` can't spill: it is in a table, or its area runs off the sheet,
+/// overlaps merged cells, holds other cells, or another formula's spill (unless that formula is
+/// recalculated in this pass, and so may spill elsewhere now).
+fn spill_blocked(host: &PassHost<'_>, (sheet, anchor): Key, a: &Array) -> bool {
+    let Some(sh) = host.wb.sheet(sheet) else { return false };
+    let end =
+        CellRef::new(anchor.row.saturating_add((a.rows as u32).saturating_sub(1)), anchor.col.saturating_add((a.cols as u32).saturating_sub(1)));
+    let range = RangeRef::new(anchor, end);
+    let own = sh.spill_ranges.get(&anchor);
+    let spilled_over = |c: CellRef| {
+        !own.is_some_and(|o| o.contains(c))
+            && sh.spill_ranges.iter().any(|(o, r)| *o != anchor && r.contains(c) && !host.exprs.contains_key(&(sheet, *o)))
+    };
+    end.row >= gridcraft_core::MAX_ROWS
+        || end.col >= gridcraft_core::MAX_COLS
+        || sh.merges.iter().any(|m| m.intersects(&range))
+        || sh.tables.iter().any(|t| t.range.contains(anchor))
+        || sh.cells.iter_range(range).any(|(c, cell)| c != anchor && (!cell.value.is_empty() || cell.formula.is_some()))
+        || sh.spill.range(range.start..=range.end).any(|(c, _)| range.contains(*c) && spilled_over(*c))
+}
+
+/// Whether `arr`, anchored at `anchor`, would spill exactly what the sheet already holds over
+/// `range`: the same area, nothing new in the way, and the same values.
+pub(super) fn spills_as_before(sheet: &gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, arr: &Array) -> bool {
+    let end =
+        CellRef::new(anchor.row.saturating_add((arr.rows as u32).saturating_sub(1)), anchor.col.saturating_add((arr.cols as u32).saturating_sub(1)));
+    RangeRef::new(anchor, end) == range
+        && !sheet.merges.iter().any(|m| m.intersects(&range))
+        && !sheet.tables.iter().any(|t| t.range.contains(anchor))
+        && range
+            .iter()
+            .enumerate()
+            .all(|(i, c)| c == anchor || (!sheet.cells.has(c) && sheet.spill.get(&c) == Some(arr.data.get(i).unwrap_or(&Value::Empty))))
+}
+
+impl PassHost<'_> {
+    /// Calculates `k` (and the formulas it reads) with bounded stack: when [`Self::compute`] would
+    /// go deeper than [`MAX_NESTED`], it suspends what is in progress, the formula it needed is
+    /// calculated from here, then the suspended ones again (reading the results kept so far).
+    pub(super) fn calculate(&mut self, k: Key) {
+        // Formulas to calculate, innermost last, each with the ones abandoned to calculate the
+        // next.
+        let mut work: Vec<(Key, Vec<Key>)> = vec![(k, Vec::new())];
+        while let Some(&(top, _)) = work.last() {
+            self.compute(top);
+            match self.suspend.take() {
+                Some(next) => {
+                    #[cfg(test)]
+                    {
+                        self.suspensions += 1;
+                    }
+                    let held = std::mem::take(&mut self.abandoned);
+                    self.waiting.extend(held.iter().copied());
+                    if let Some(entry) = work.last_mut() {
+                        entry.1 = held;
+                    }
+                    // The other formulas read at the limit are calculated after `next`, before the
+                    // held evaluations restart. Each has nothing held of its own, so the held ones
+                    // are released only when the last of them is done.
+                    let mut seen: HashSet<Key> = HashSet::default();
+                    seen.insert(next);
+                    for s in std::mem::take(&mut self.also) {
+                        if seen.insert(s) {
+                            work.push((s, Vec::new()));
+                        }
+                    }
+                    work.push((next, Vec::new()));
+                }
+                None => {
+                    work.pop();
+                    if let Some(entry) = work.last_mut() {
+                        for a in entry.1.drain(..) {
+                            self.waiting.remove(&a);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn compute(&mut self, k: Key) -> Value {
+        if let Some(v) = self.results.get(&k) {
+            let v = v.clone();
+            if self.iterate && self.tainted.contains(&k) {
+                self.taint = true;
+            }
+            return v;
+        }
+        let Some(expr) = self.exprs.get(&k) else {
+            return self.wb.sheet(k.0).map(|s| s.value(k.1)).unwrap_or_default();
+        };
+        if self.suspend.is_some() {
+            // Unwinding to `calculate`: the value is thrown away. A formula read at the limit is
+            // calculated with the suspended one, so the evaluations are not restarted for each.
+            if self.depth >= MAX_NESTED && !self.in_progress.contains(&k) && !self.waiting.contains(&k) {
+                self.also.push(k);
+            }
+            return Value::Error(CellError::Calc);
+        }
+        if self.in_progress.contains(&k) || self.waiting.contains(&k) {
+            self.cycle = true;
+            if self.iterate {
+                return self.circular_read(k);
+            }
+            // Once each, though a suspended evaluation meets it again.
+            if self.cycle_seen.insert(k) {
+                self.cycles.push(k);
+            }
+            return Value::Error(CellError::Circ);
+        }
+        if self.depth >= MAX_NESTED {
+            self.suspend = Some(k);
+            return Value::Error(CellError::Calc);
+        }
+        if self.depth == 0 {
+            self.stack_top = stack_position();
+        }
+        self.in_progress.insert(k);
+        self.depth += 1;
+        let outer_taint = std::mem::replace(&mut self.taint, false);
+        if self.iterate {
+            self.stack.push(k);
+        }
+        let expr = std::sync::Arc::clone(expr);
+        let outer_out_of_stack = std::mem::replace(&mut self.out_of_stack, false);
+        let v = {
+            let mut ev = Evaluator::new(self, k.0, k.1);
+            ev.value(&expr)
+        };
+        let out_of_stack = std::mem::replace(&mut self.out_of_stack, outer_out_of_stack);
+        if out_of_stack && self.depth > 1 && self.suspend.is_none() {
+            // It ran out of the stack left below the formulas that read it: it is calculated
+            // from the top instead, as a formula needed at `MAX_NESTED` levels deep is.
+            self.suspend = Some(k);
+            self.depth -= 1;
+            self.in_progress.remove(&k);
+            if self.iterate {
+                self.stack.pop();
+            }
+            self.taint = outer_taint;
+            return Value::Error(CellError::Calc);
+        }
+        if self.suspend.is_some() {
+            // Abandoned: `calculate` evaluates this formula again once the one it needs is done.
+            self.depth -= 1;
+            self.in_progress.remove(&k);
+            self.abandoned.push(k);
+            if self.iterate {
+                self.stack.pop();
+            }
+            self.taint = outer_taint;
+            return Value::Error(CellError::Calc);
+        }
+        // A legacy array formula fills the range it was entered in.
+        let legacy = self.wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.as_ref()).and_then(|f| f.array);
+        let v = match legacy {
+            Some(range) => fit_to_range(v, range),
+            None => v,
+        };
+        self.depth -= 1;
+        self.in_progress.remove(&k);
+        self.pending.remove(&k);
+        if self.iterate {
+            self.stack.pop();
+            if self.taint {
+                self.tainted.insert(k);
+            } else {
+                self.tainted.remove(&k);
+            }
+        }
+        self.taint |= outer_taint;
+        // A blank cell shows as 0 in a formula's result, inside an array as well (`=A1:A3`,
+        // FILTER or SORT of a range with blanks). GROUPBY and PIVOTBY lay out blank cells
+        // of their own, which stay blank.
+        let keep_blanks = matches!(&*expr, Expr::Call(n, _) if matches!(n.as_str(), "GROUPBY" | "PIVOTBY"));
+        let v = match v {
+            Value::Array(a) => {
+                let a = if keep_blanks || !a.data.iter().any(|x| matches!(x, Value::Empty)) {
+                    a
+                } else {
+                    let data = a.data.iter().map(|x| if matches!(x, Value::Empty) { Value::Number(0.0) } else { x.clone() }).collect();
+                    Array::new(a.rows, a.cols, data).map(std::sync::Arc::new).unwrap_or(a)
+                };
+                // A dynamic-array formula anchors a spill range even while its result is one
+                // value -- a FILTER matching one row, a SORT or UNIQUE over one item -- so `C1#`
+                // is the 1 x 1 range and `ROWS(C1#)` is 1, as in Excel (#1491). A formula that
+                // returns a scalar never reaches this arm, so it does not become an anchor.
+                self.spills.insert(k, a.clone());
+                a.data.first().cloned().unwrap_or_default()
+            }
+            Value::Empty => Value::Number(0.0),
+            v => v,
+        };
+        // An array that can't spill is #SPILL! for the formulas evaluated after it in this pass too.
+        let v = match self.spills.get(&k) {
+            Some(a) if spill_blocked(self, k, a) => {
+                self.spills.remove(&k);
+                Value::Error(CellError::Spill)
+            }
+            _ => v,
+        };
+        self.results.insert(k, v.clone());
+        v
+    }
+
+    /// A formula's previous value for iterative calculation: from the last iteration, else the
+    /// value it shows. Blank, and the `#CIRC!` of a loop calculated with iteration off, are 0.
+    fn previous(&self, k: Key) -> Value {
+        let v = match self.prev.get(&k) {
+            Some(v) => v.clone(),
+            None => self.wb.sheet(k.0).map(|s| s.value(k.1)).unwrap_or_default(),
+        };
+        if matches!(v, Value::Empty | Value::Error(CellError::Circ)) { Value::Number(0.0) } else { v }
+    }
+
+    /// Reading `k` while it is being evaluated, with iterative calculation on: its previous value.
+    /// The formulas around the loop are the ones whose changes decide when iteration stops.
+    fn circular_read(&mut self, k: Key) -> Value {
+        self.taint = true;
+        match self.stack.iter().rposition(|s| *s == k) {
+            Some(i) => self.members.extend(self.stack.get(i..).unwrap_or_default().iter().copied()),
+            // Too deep to follow: the formula itself is watched.
+            None => {
+                self.members.insert(k);
+            }
+        }
+        self.previous(k)
+    }
+
+    /// Iterative calculation, after a first pass over `order` that met circular references. The
+    /// formulas that read a previous value (the loops and what depends on them) are evaluated
+    /// again in the same order, each pass starting from the last one's values and reading what it
+    /// has already produced (Gauss-Seidel), until no formula on a loop changes by `max_change` or
+    /// more, or after `max_iterations` passes in all. Returns the number of passes.
+    pub(super) fn iterate_loops(&mut self, order: &[Key], max_iterations: u32, max_change: f64) -> u32 {
+        let again: Vec<Key> = order.iter().copied().filter(|k| self.tainted.contains(k)).collect();
+        let set: HashSet<Key> = again.iter().copied().collect();
+        // Bounds the work whatever Maximum Iterations says.
+        let max_passes = u32::try_from(MAX_ITERATION_WORK / again.len().max(1)).unwrap_or(u32::MAX).max(1);
+        let mut passes = 1u32;
+        while passes < max_iterations.min(max_passes) && !self.converged(max_change) {
+            self.prev = again.iter().filter_map(|k| self.results.remove(k).map(|v| (*k, v))).collect();
+            self.pending = set.clone();
+            self.spills.retain(|a, _| !set.contains(a));
+            for k in &again {
+                self.calculate(*k);
+            }
+            passes += 1;
+        }
+        passes
+    }
+
+    /// Whether every formula on a loop changed by less than `max_change` in the last pass (text,
+    /// logical and error values: not at all).
+    fn converged(&self, max_change: f64) -> bool {
+        self.members.iter().all(|k| {
+            let Some(new) = self.results.get(k) else { return true };
+            match (new, &self.previous(*k)) {
+                (Value::Number(a), Value::Number(b)) => {
+                    let d = (a - b).abs();
+                    d < max_change || d == 0.0
+                }
+                (new, old) => new == old,
+            }
+        })
+    }
+}
+
+/// A legacy (Ctrl+Shift+Enter) array formula's result fitted to the range it was entered in, as
+/// Excel does: a single row or column repeats across the range, a single value fills it, cells
+/// past the result show `#N/A`, and a result larger than the range is cut off.
+fn fit_to_range(v: Value, range: RangeRef) -> Value {
+    if range.count() > crate::eval::MAX_CELLS {
+        return Value::Error(CellError::Num);
+    }
+    let (h, w) = (range.height() as usize, range.width() as usize);
+    let Value::Array(a) = v else {
+        return if h * w == 1 { v } else { Array::new(h, w, vec![v; h * w]).map(Value::from).unwrap_or(Value::Error(CellError::Value)) };
+    };
+    if h * w == 1 {
+        return a.data.first().cloned().unwrap_or_default();
+    }
+    let mut data = Vec::with_capacity(h * w);
+    for r in 0..h {
+        for c in 0..w {
+            let (r, c) = (if a.rows == 1 { 0 } else { r }, if a.cols == 1 { 0 } else { c });
+            data.push(a.get(r, c).cloned().unwrap_or(Value::Error(CellError::NA)));
+        }
+    }
+    Array::new(h, w, data).map(Value::from).unwrap_or(Value::Error(CellError::Value))
+}
+
+impl Host for PassHost<'_> {
+    fn workbook(&self) -> &Workbook {
+        self.wb
+    }
+    fn stack_top(&self) -> Option<usize> {
+        (self.depth > 1).then_some(self.stack_top)
+    }
+    fn stack_exhausted(&mut self) {
+        self.out_of_stack = true;
+    }
+    fn spill_range(&mut self, sheet: usize, anchor: CellRef) -> Option<RangeRef> {
+        let k = (sheet, anchor);
+        if !(self.pending.contains(&k) || self.results.contains_key(&k)) {
+            return self.wb.sheet(sheet)?.spill_ranges.get(&anchor).copied();
+        }
+        // Recalculated in this pass: its new array, unless something blocks it (#SPILL!).
+        self.compute(k);
+        let arr = self.spills.get(&k)?;
+        let end = CellRef::new(
+            anchor.row.saturating_add((arr.rows as u32).saturating_sub(1)),
+            anchor.col.saturating_add((arr.cols as u32).saturating_sub(1)),
+        );
+        let range = RangeRef::new(anchor, end);
+        let sh = self.wb.sheet(sheet)?;
+        let blocked = end.row >= gridcraft_core::MAX_ROWS
+            || end.col >= gridcraft_core::MAX_COLS
+            || sh.cells.iter_range(range).any(|(c, cell)| c != anchor && (cell.formula.is_some() || !cell.value.is_empty()))
+            || sh.merges.iter().any(|m| m.intersects(&range));
+        (!blocked).then_some(range)
+    }
+    fn cell_value(&mut self, sheet: usize, c: CellRef) -> Value {
+        let k = (sheet, c);
+        if self.pending.contains(&k) || self.results.contains_key(&k) {
+            return self.compute(k);
+        }
+        // A cell covered by a spill computed in this pass.
+        for (anchor, arr) in &self.spills {
+            if anchor.0 == sheet && c.row >= anchor.1.row && c.col >= anchor.1.col {
+                let (dr, dc) = ((c.row - anchor.1.row) as usize, (c.col - anchor.1.col) as usize);
+                if dr < arr.rows && dc < arr.cols {
+                    if self.iterate && self.tainted.contains(anchor) {
+                        self.taint = true;
+                    }
+                    return arr.get(dr, dc).cloned().unwrap_or_default();
+                }
+            }
+        }
+        self.wb.sheet(sheet).map(|s| s.value(c)).unwrap_or_default()
+    }
+    fn range_values(&mut self, sheet: usize, range: RangeRef) -> Vec<Value> {
+        let (h, w) = (range.height() as usize, range.width() as usize);
+        let mut out = vec![Value::Empty; h * w];
+        let Some(sh) = self.wb.sheet(sheet) else { return out };
+        // Sparse walk: only stored cells; formula cells that are (or were) dirty go through
+        // `compute`, constants are copied straight from the store.
+        let mut formulas: Vec<(usize, CellRef)> = Vec::new();
+        for (c, cell) in sh.cells.iter_range(range) {
+            let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
+            if cell.formula.is_some() {
+                formulas.push((i, c));
+            } else if let Some(slot) = out.get_mut(i) {
+                *slot = cell.value.clone();
+            }
+        }
+        for (c, v) in sh.spill.range(range.start..=range.end) {
+            if range.contains(*c) {
+                let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
+                if let Some(slot) = out.get_mut(i)
+                    && slot.is_empty()
+                {
+                    *slot = v.clone();
+                }
+            }
+        }
+        for (i, c) in formulas {
+            let v = self.cell_value(sheet, c);
+            if let Some(slot) = out.get_mut(i) {
+                *slot = v;
+            }
+        }
+        if !self.spills.is_empty() {
+            let new: Vec<(usize, Value)> = self
+                .spills
+                .iter()
+                .filter(|(a, _)| a.0 == sheet)
+                .flat_map(|(a, arr)| {
+                    let mut v = Vec::new();
+                    for r in 0..arr.rows {
+                        for cc in 0..arr.cols {
+                            let c = CellRef::new(a.1.row.saturating_add(r as u32), a.1.col.saturating_add(cc as u32));
+                            if c != a.1 && range.contains(c) {
+                                v.push((
+                                    (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize,
+                                    arr.get(r, cc).cloned().unwrap_or_default(),
+                                ));
+                            }
+                        }
+                    }
+                    v
+                })
+                .collect();
+            // Iterating: an array spilled by a formula that read a previous value.
+            if self.iterate
+                && self.spills.iter().any(|(a, arr)| {
+                    let end = CellRef::new(
+                        a.1.row.saturating_add((arr.rows as u32).saturating_sub(1)),
+                        a.1.col.saturating_add((arr.cols as u32).saturating_sub(1)),
+                    );
+                    a.0 == sheet && self.tainted.contains(a) && RangeRef::new(a.1, end).intersects(&range)
+                })
+            {
+                self.taint = true;
+            }
+            for (i, v) in new {
+                if let Some(slot) = out.get_mut(i) {
+                    *slot = v;
+                }
+            }
+        }
+        out
+    }
+    fn visit_range(&mut self, sheet: usize, range: RangeRef, f: &mut dyn FnMut(&Value) -> bool) -> bool {
+        let wb = self.wb;
+        let Some(sh) = wb.sheet(sheet) else { return false };
+        // Formula cells first, in row-major order like `range_values`: reading one calculates it
+        // and the pass remembers the value, so the walk below gets the same value again without
+        // this method holding any.
+        for (c, cell) in sh.cells.iter_range(range) {
+            if cell.formula.is_some() {
+                let _ = self.cell_value(sheet, c);
+            }
+        }
+        // Spilled values sit between the stored cells (and the formulas just calculated may have
+        // produced some): leave such blocks to `range_values`.
+        if self.spills.keys().any(|a| a.0 == sheet) || sh.spill.range(range.start..=range.end).any(|(c, _)| range.contains(*c)) {
+            return false;
+        }
+        for (c, cell) in sh.cells.iter_range(range) {
+            let go = if cell.formula.is_some() { f(&self.cell_value(sheet, c)) } else { f(&cell.value) };
+            if !go {
+                break;
+            }
+        }
+        true
+    }
+    fn used_range(&mut self, sheet: usize) -> Option<RangeRef> {
+        let wb = self.wb;
+        *self.used.entry(sheet).or_insert_with(|| wb.sheet(sheet).and_then(|s| s.used_range()))
+    }
+    fn now_serial(&self) -> f64 {
+        self.now
+    }
+    fn random(&mut self) -> f64 {
+        // xorshift64*
+        let mut x = *self.rng;
+        x ^= x >> 12;
+        x ^= x << 25;
+        x ^= x >> 27;
+        *self.rng = x;
+        (x.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 11) as f64 / (1u64 << 53) as f64
+    }
+}

From 3813413b651ee9bc142ac1f6b271ad5fa51421ab Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:04:39 +0000
Subject: [PATCH 45/76] refactor(chart): move render.rs items to render/

---
 crates/chart/src/render.rs           | 1661 +-------------------------
 crates/chart/src/render/cartesian.rs |  431 +++++++
 crates/chart/src/render/frame.rs     |  245 ++++
 crates/chart/src/render/kinds.rs     |  505 ++++++++
 crates/chart/src/render/legend.rs    |  161 +++
 crates/chart/src/render/lines.rs     |  157 +++
 crates/chart/src/render/trend.rs     |  166 +++
 7 files changed, 1679 insertions(+), 1647 deletions(-)
 create mode 100644 crates/chart/src/render/cartesian.rs
 create mode 100644 crates/chart/src/render/frame.rs
 create mode 100644 crates/chart/src/render/kinds.rs
 create mode 100644 crates/chart/src/render/legend.rs
 create mode 100644 crates/chart/src/render/lines.rs
 create mode 100644 crates/chart/src/render/trend.rs

diff --git a/crates/chart/src/render.rs b/crates/chart/src/render.rs
index 3257082bb..76a1619e3 100644
--- a/crates/chart/src/render.rs
+++ b/crates/chart/src/render.rs
@@ -10,6 +10,20 @@ use crate::resolve::{MAX_POINTS, MAX_SERIES, MAX_TRENDLINES, series_color};
 use crate::trend::{auto_name, fit_trendline, moving_average};
 use crate::{ChartData, HAlign, Measure, Prim, Rgba, SeriesData, VAlign};
 
+mod cartesian;
+mod frame;
+mod kinds;
+mod legend;
+mod lines;
+mod trend;
+
+use cartesian::{cartesian, scatter};
+use frame::{Bx, axis_titles, chart_title};
+use kinds::{box_whisker, funnel, histogram, pie, radar, stock, treemap, waterfall};
+use legend::draw_legend;
+pub use legend::{Swatch, legend_entries};
+pub use trend::supports_trendline;
+
 pub(crate) const TEXT: Rgba = [0x59, 0x59, 0x59, 0xFF];
 const DARK_TEXT: Rgba = [0x26, 0x26, 0x26, 0xFF];
 const GRID: Rgba = [0xD9, 0xD9, 0xD9, 0xFF];
@@ -31,32 +45,6 @@ const MAX_MARKERS: usize = 5000;
 /// Data labels are skipped when a series has more points than this.
 const MAX_LABELS: usize = 200;
 
-#[derive(Clone, Copy, Debug)]
-struct Bx {
-    x: f32,
-    y: f32,
-    w: f32,
-    h: f32,
-}
-
-impl Bx {
-    fn right(&self) -> f32 {
-        self.x + self.w
-    }
-    fn bottom(&self) -> f32 {
-        self.y + self.h
-    }
-    fn ok(&self) -> bool {
-        self.w.is_finite() && self.h.is_finite() && self.w > 4.0 && self.h > 4.0
-    }
-    fn cx(&self) -> f32 {
-        self.x + self.w / 2.0
-    }
-    fn cy(&self) -> f32 {
-        self.y + self.h / 2.0
-    }
-}
-
 struct Ctx<'a> {
     out: Vec<Prim>,
     m: &'a dyn Measure,
@@ -105,85 +93,6 @@ impl Ctx<'_> {
     }
 }
 
-/// Text colour readable on `fill`.
-fn on(fill: Rgba) -> Rgba {
-    let l = 0.299 * fill[0] as f32 + 0.587 * fill[1] as f32 + 0.114 * fill[2] as f32;
-    if l < 150.0 { WHITE } else { DARK_TEXT }
-}
-
-/// How a legend entry's swatch is drawn.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Swatch {
-    Box,
-    Line,
-    LineMarker,
-    Marker,
-}
-
-/// The kind a series is drawn as (per-series kinds only apply to combo charts).
-fn plot_kind(chart: &Chart, s: &SeriesData) -> ChartKind {
-    if chart.kind == ChartKind::Combo { if s.kind == ChartKind::Combo { ChartKind::Line } else { s.kind } } else { chart.kind }
-}
-
-/// Colour of point `j` for charts that colour by point (pie, doughnut, treemap, sunburst).
-fn point_color(data: &ChartData, j: usize) -> Rgba {
-    match (j, data.series.first()) {
-        (0, Some(s)) => s.color,
-        _ => j.checked_rem(data.palette.len()).and_then(|k| data.palette.get(k)).copied().unwrap_or_else(|| series_color(&Theme::default(), j)),
-    }
-}
-
-fn first_len(data: &ChartData) -> usize {
-    data.series.first().map(|s| s.values.len()).unwrap_or(0)
-}
-
-fn cat_label(data: &ChartData, j: usize) -> String {
-    data.categories.get(j).cloned().unwrap_or_else(|| (j + 1).to_string())
-}
-
-/// Legend entries (text, colour, swatch) `render` draws for this chart; empty when hidden.
-pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swatch)> {
-    if chart.legend == LegendPos::None {
-        return vec![];
-    }
-    match chart.kind {
-        ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst => {
-            let n = first_len(data).min(MAX_CATS);
-            (0..n).map(|j| (cat_label(data, j), point_color(data, j), Swatch::Box)).collect()
-        }
-        ChartKind::Histogram | ChartKind::Funnel | ChartKind::Stock => vec![],
-        ChartKind::Waterfall => {
-            if data.series.is_empty() {
-                return vec![];
-            }
-            let total = data.series.first().map(|s| s.color).unwrap_or(TEXT);
-            vec![("Increase".into(), UP, Swatch::Box), ("Decrease".into(), DOWN, Swatch::Box), ("Total".into(), total, Swatch::Box)]
-        }
-        _ => {
-            let series = data.series.iter().take(MAX_SERIES);
-            let mut out: Vec<(String, Rgba, Swatch)> = series
-                .clone()
-                .map(|s| {
-                    let sw = match plot_kind(chart, s) {
-                        ChartKind::Line | ChartKind::LineStacked | ChartKind::Radar | ChartKind::ScatterLines => Swatch::Line,
-                        ChartKind::LineMarkers => Swatch::LineMarker,
-                        ChartKind::Scatter | ChartKind::Bubble => Swatch::Marker,
-                        _ => Swatch::Box,
-                    };
-                    (s.name.clone(), s.color, sw)
-                })
-                .collect();
-            // Trendlines follow the series, named "Linear (Sales)" unless given a name.
-            for s in series.filter(|s| supports_trendline(plot_kind(chart, s))) {
-                for t in s.trendlines.iter().take(MAX_TRENDLINES) {
-                    out.push((t.spec.name.clone().unwrap_or_else(|| auto_name(t.spec.kind, &s.name)), t.color, Swatch::Line));
-                }
-            }
-            out
-        }
-    }
-}
-
 fn sanitize_vals(v: &[Option<f64>]) -> Vec<Option<f64>> {
     v.iter().take(MAX_POINTS).map(|x| x.filter(|n| n.is_finite()).map(clean)).collect()
 }
@@ -213,14 +122,6 @@ fn sanitize(d: &ChartData) -> ChartData {
     }
 }
 
-fn chart_title(chart: &Chart, data: &ChartData) -> Option<String> {
-    match &chart.title {
-        Some(t) => Some(t.trim().to_string()).filter(|t| !t.is_empty()),
-        None if data.series.len() == 1 => data.series.first().map(|s| s.name.clone()).filter(|t| !t.is_empty()),
-        None => None,
-    }
-}
-
 /// Lays out and draws a chart into a `w`×`h` box at the origin. Empty for a degenerate box.
 pub fn render(chart: &Chart, data: &ChartData, w: f32, h: f32, m: &dyn Measure) -> Vec<Prim> {
     if !(w.is_finite() && h.is_finite()) || w < 1.0 || h < 1.0 || w > 1e7 || h > 1e7 {
@@ -276,1483 +177,6 @@ fn draw_kind(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
     }
 }
 
-fn axis_titles(ctx: &mut Ctx, chart: &Chart, mut area: Bx) -> Bx {
-    let lh = AXIS_TITLE_SIZE * 1.4 + 2.0;
-    if let Some(t) = chart.x_title.as_deref().map(str::trim).filter(|t| !t.is_empty()) {
-        let t = ctx.fit(t, AXIS_TITLE_SIZE, area.w);
-        ctx.text(area.cx(), area.bottom(), &t, AXIS_TITLE_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-        area.h -= lh;
-    }
-    if let Some(t) = chart.y_title.as_deref().map(str::trim).filter(|t| !t.is_empty()) {
-        let t = ctx.fit(t, AXIS_TITLE_SIZE, area.h);
-        if !t.is_empty() {
-            ctx.out.push(Prim::Text {
-                x: area.x,
-                y: area.cy(),
-                text: t,
-                size: AXIS_TITLE_SIZE,
-                color: TEXT,
-                bold: false,
-                align: HAlign::Center,
-                valign: VAlign::Top,
-                rotation: -PI / 2.0,
-            });
-        }
-        area.x += lh;
-        area.w -= lh;
-    }
-    area
-}
-
-// ---------------------------------------------------------------- legend
-
-fn swatch_w(sw: Swatch, s: f32) -> f32 {
-    if sw == Swatch::Box { s } else { s * 2.0 }
-}
-
-fn draw_swatch(ctx: &mut Ctx, sw: Swatch, x: f32, yc: f32, s: f32, color: Rgba) {
-    match sw {
-        Swatch::Box => ctx.rect(x, yc - s / 2.0, s, s, color, None),
-        Swatch::Line => ctx.hline(x, x + 2.0 * s, yc, color, 2.0),
-        Swatch::LineMarker => {
-            ctx.hline(x, x + 2.0 * s, yc, color, 2.0);
-            ctx.out.push(Prim::Circle { cx: x + s, cy: yc, r: s * 0.35, fill: Some(color), stroke: None });
-        }
-        Swatch::Marker => ctx.out.push(Prim::Circle { cx: x + s, cy: yc, r: s * 0.4, fill: Some(color), stroke: None }),
-    }
-}
-
-fn draw_legend(ctx: &mut Ctx, entries: &[(String, Rgba, Swatch)], pos: LegendPos, area: Bx) -> Bx {
-    let size = LABEL_SIZE;
-    let row_h = size * 1.6;
-    let s = size * 0.8;
-    let gap = 4.0;
-    let spacing = size * 1.3;
-    let item_w = |ctx: &Ctx, e: &(String, Rgba, Swatch)| swatch_w(e.2, s) + gap + ctx.tw(&e.0, size);
-    match pos {
-        LegendPos::None => area,
-        LegendPos::Top | LegendPos::Bottom => {
-            let max_rows = ((area.h * 0.3 / row_h).floor() as usize).max(1);
-            let mut rows: Vec<Vec<(usize, f32)>> = vec![vec![]];
-            let mut cur = 0.0f32;
-            for (i, e) in entries.iter().enumerate() {
-                let iw = item_w(ctx, e).min(area.w);
-                let need = if cur > 0.0 { spacing + iw } else { iw };
-                if cur > 0.0 && cur + need > area.w {
-                    if rows.len() >= max_rows {
-                        break;
-                    }
-                    rows.push(vec![]);
-                    cur = 0.0;
-                }
-                cur += if cur > 0.0 { spacing + iw } else { iw };
-                if let Some(r) = rows.last_mut() {
-                    r.push((i, iw));
-                }
-            }
-            let lh = rows.len() as f32 * row_h;
-            let y0 = if pos == LegendPos::Bottom { area.bottom() - lh } else { area.y };
-            for (ri, row) in rows.iter().enumerate() {
-                let total: f32 = row.iter().map(|(_, w)| w).sum::<f32>() + spacing * row.len().saturating_sub(1) as f32;
-                let mut x = area.x + (area.w - total).max(0.0) / 2.0;
-                let yc = y0 + ri as f32 * row_h + row_h / 2.0;
-                for &(i, iw) in row {
-                    if let Some(e) = entries.get(i) {
-                        draw_swatch(ctx, e.2, x, yc, s, e.1);
-                        let sx = swatch_w(e.2, s) + gap;
-                        let t = ctx.fit(&e.0, size, (iw - sx).max(0.0) + 0.5);
-                        ctx.text(x + sx, yc, &t, size, TEXT, HAlign::Left, VAlign::Middle);
-                    }
-                    x += iw + spacing;
-                }
-            }
-            let used = lh + 4.0;
-            if pos == LegendPos::Bottom { Bx { h: area.h - used, ..area } } else { Bx { y: area.y + used, h: area.h - used, ..area } }
-        }
-        LegendPos::Left | LegendPos::Right => {
-            let colw = entries.iter().map(|e| item_w(ctx, e)).fold(0.0f32, f32::max).min(area.w * 0.35);
-            let max_rows = ((area.h / row_h).floor() as usize).max(1);
-            let n = entries.len().min(max_rows);
-            let lh = n as f32 * row_h;
-            let y0 = area.y + (area.h - lh).max(0.0) / 2.0;
-            let x0 = if pos == LegendPos::Right { area.right() - colw } else { area.x };
-            for (i, e) in entries.iter().take(n).enumerate() {
-                let yc = y0 + i as f32 * row_h + row_h / 2.0;
-                draw_swatch(ctx, e.2, x0, yc, s, e.1);
-                let sx = swatch_w(e.2, s) + gap;
-                let t = ctx.fit(&e.0, size, (colw - sx).max(0.0) + 0.5);
-                ctx.text(x0 + sx, yc, &t, size, TEXT, HAlign::Left, VAlign::Middle);
-            }
-            let used = colw + 8.0;
-            if pos == LegendPos::Right { Bx { w: area.w - used, ..area } } else { Bx { x: area.x + used, w: area.w - used, ..area } }
-        }
-    }
-}
-
-// ---------------------------------------------------------------- axes frame
-
-enum CatAxis<'a> {
-    /// Category labels and, for a multi-level axis, the outer levels (nearest the labels first;
-    /// one entry per category, non-empty where a group starts).
-    Labels(&'a [String], &'a [Vec<String>]),
-    Numeric(Scale, &'a Fmt),
-}
-
-/// Groups of an outer category level: `(first, end)` index pairs, a group starting at every
-/// non-empty entry (and at the first category).
-fn level_groups(level: &[String], n: usize) -> Vec<(usize, usize)> {
-    let mut starts: Vec<usize> = (0..n).filter(|&j| j == 0 || level.get(j).is_some_and(|t| !t.is_empty())).collect();
-    starts.push(n);
-    starts.windows(2).filter_map(|w| Some((*w.first()?, *w.get(1)?))).collect()
-}
-
-struct ValAxis<'a> {
-    scale: Scale,
-    fmt: &'a Fmt,
-}
-
-impl ValAxis<'_> {
-    fn labels(&self) -> Vec<(f64, String)> {
-        self.scale.ticks().into_iter().map(|v| (v, self.fmt.format(v, Some(self.scale.step)))).collect()
-    }
-}
-
-/// Draws gridlines, axis labels and the category axis line; returns the plot rectangle.
-fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Option<&ValAxis>, horizontal: bool, grid: bool) -> Bx {
-    let ls = LABEL_SIZE;
-    let lh = ls * 1.4;
-    let ylabels = y.labels();
-    let maxw = |ctx: &Ctx, l: &[(f64, String)]| l.iter().map(|(_, t)| ctx.tw(t, ls)).fold(0.0f32, f32::max);
-    if !horizontal {
-        let left = (maxw(ctx, &ylabels) + 6.0).min(area.w * 0.4);
-        let y2labels = y2.map(ValAxis::labels);
-        let right = match (&y2labels, &cat) {
-            (Some(l), _) => (maxw(ctx, l) + 6.0).min(area.w * 0.3),
-            (None, CatAxis::Numeric(s, f)) => (ctx.tw(&f.format(s.max, Some(s.step)), ls) / 2.0).min(area.w * 0.2),
-            _ => 4.0,
-        };
-        let levels = match &cat {
-            CatAxis::Labels(_, o) => o.len() as f32,
-            CatAxis::Numeric(..) => 0.0,
-        };
-        let plot = Bx { x: area.x + left, y: area.y + lh * 0.5, w: area.w - left - right, h: area.h - lh * 1.5 - 4.0 - lh * levels };
-        if !plot.ok() {
-            return plot;
-        }
-        for (v, t) in &ylabels {
-            let yy = plot.bottom() - y.scale.frac(*v) * plot.h;
-            if grid {
-                ctx.hline(plot.x, plot.right(), yy, GRID, 0.75);
-            }
-            ctx.text(plot.x - 4.0, yy, t, ls, TEXT, HAlign::Right, VAlign::Middle);
-        }
-        if let (Some(a), Some(l)) = (y2, &y2labels) {
-            for (v, t) in l {
-                let yy = plot.bottom() - a.scale.frac(*v) * plot.h;
-                ctx.text(plot.right() + 4.0, yy, t, ls, TEXT, HAlign::Left, VAlign::Middle);
-            }
-        }
-        let zero = if y.scale.min <= 0.0 && y.scale.max >= 0.0 { 0.0 } else { y.scale.min };
-        let y0 = plot.bottom() - y.scale.frac(zero) * plot.h;
-        ctx.hline(plot.x, plot.right(), y0, AXIS, 0.75);
-        match cat {
-            CatAxis::Labels(l, outer) => {
-                let n = l.len().max(1);
-                let cw = plot.w / n as f32;
-                let lw = l.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max);
-                let k = (((lw + 6.0) / cw.max(1e-3)).ceil() as usize).clamp(1, n);
-                for (j, t) in l.iter().enumerate().step_by(k) {
-                    let t = ctx.fit(t, ls, cw * k as f32 - 2.0);
-                    ctx.text(plot.x + (j as f32 + 0.5) * cw, plot.bottom() + 3.0, &t, ls, TEXT, HAlign::Center, VAlign::Top);
-                }
-                // Outer levels, one row each below the labels: a group's name centred under its
-                // categories, and a separator at each group boundary down through the rows.
-                for (i, level) in outer.iter().enumerate() {
-                    let top = plot.bottom() + 3.0 + lh * (i as f32 + 1.0);
-                    for (first, end) in level_groups(level, n) {
-                        let (x0, x1) = (plot.x + first as f32 * cw, plot.x + end as f32 * cw);
-                        if let Some(t) = level.get(first).filter(|t| !t.is_empty()) {
-                            let t = ctx.fit(t, ls, x1 - x0 - 2.0);
-                            ctx.text((x0 + x1) / 2.0, top, &t, ls, TEXT, HAlign::Center, VAlign::Top);
-                        }
-                        if first > 0 {
-                            ctx.vline(x0, plot.bottom(), top + lh - 2.0, AXIS, 0.75);
-                        }
-                    }
-                    ctx.vline(plot.right(), plot.bottom(), top + lh - 2.0, AXIS, 0.75);
-                }
-            }
-            CatAxis::Numeric(s, f) => {
-                let ticks = s.ticks();
-                let labels: Vec<String> = ticks.iter().map(|v| f.format(*v, Some(s.step))).collect();
-                let lw = labels.iter().map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max);
-                let slot = plot.w / ticks.len().max(1) as f32;
-                let k = (((lw + 6.0) / slot.max(1e-3)).ceil() as usize).max(1);
-                for (v, t) in ticks.iter().zip(&labels).step_by(k) {
-                    let xx = plot.x + s.frac(*v) * plot.w;
-                    ctx.text(xx, plot.bottom() + 3.0, t, ls, TEXT, HAlign::Center, VAlign::Top);
-                }
-                if s.min <= 0.0 && s.max >= 0.0 {
-                    let xx = plot.x + s.frac(0.0) * plot.w;
-                    ctx.vline(xx, plot.y, plot.bottom(), AXIS, 0.75);
-                }
-            }
-        }
-        plot
-    } else {
-        let (labels, outer): (Vec<String>, &[Vec<String>]) = match cat {
-            CatAxis::Labels(l, o) => (l.to_vec(), o),
-            CatAxis::Numeric(..) => (vec![], &[]),
-        };
-        let lw = (labels.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max) + 6.0).min(area.w * 0.35);
-        // Outer levels stand in columns left of the labels, each as wide as its longest name.
-        let level_w: Vec<f32> =
-            outer.iter().map(|l| (l.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max) + 6.0).min(area.w * 0.15)).collect();
-        let levels_w: f32 = level_w.iter().sum();
-        let right = ylabels.last().map(|(_, t)| ctx.tw(t, ls) / 2.0).unwrap_or(0.0).min(area.w * 0.2) + 2.0;
-        let plot = Bx { x: area.x + lw + levels_w, y: area.y + 2.0, w: area.w - lw - levels_w - right, h: area.h - lh - 6.0 };
-        if !plot.ok() {
-            return plot;
-        }
-        let vw = maxw(ctx, &ylabels);
-        let slot = plot.w / ylabels.len().max(1) as f32;
-        let k = (((vw + 6.0) / slot.max(1e-3)).ceil() as usize).max(1);
-        for (i, (v, t)) in ylabels.iter().enumerate() {
-            let xx = plot.x + y.scale.frac(*v) * plot.w;
-            if grid {
-                ctx.vline(xx, plot.y, plot.bottom(), GRID, 0.75);
-            }
-            if i % k == 0 {
-                ctx.text(xx, plot.bottom() + 3.0, t, ls, TEXT, HAlign::Center, VAlign::Top);
-            }
-        }
-        let zero = if y.scale.min <= 0.0 && y.scale.max >= 0.0 { 0.0 } else { y.scale.min };
-        let x0 = plot.x + y.scale.frac(zero) * plot.w;
-        ctx.vline(x0, plot.y, plot.bottom(), AXIS, 0.75);
-        let n = labels.len().max(1);
-        let ch = plot.h / n as f32;
-        let k = ((lh / ch.max(1e-3)).ceil() as usize).clamp(1, n);
-        for (j, t) in labels.iter().enumerate().step_by(k) {
-            let t = ctx.fit(t, ls, lw - 6.0);
-            ctx.text(plot.x - 4.0, plot.bottom() - (j as f32 + 0.5) * ch, &t, ls, TEXT, HAlign::Right, VAlign::Middle);
-        }
-        // Outer levels: a group's name centred beside its categories, separators at the
-        // boundaries running right to the axis.
-        let mut x1 = plot.x - lw;
-        for (level, w) in outer.iter().zip(&level_w) {
-            let x0 = x1 - w;
-            for (first, end) in level_groups(level, n) {
-                let (y0, y1) = (plot.bottom() - end as f32 * ch, plot.bottom() - first as f32 * ch);
-                if let Some(t) = level.get(first).filter(|t| !t.is_empty()) {
-                    let t = ctx.fit(t, ls, w - 4.0);
-                    ctx.text((x0 + x1) / 2.0, (y0 + y1) / 2.0, &t, ls, TEXT, HAlign::Center, VAlign::Middle);
-                }
-                if first > 0 {
-                    ctx.hline(x0, plot.x, y1, AXIS, 0.75);
-                }
-            }
-            ctx.hline(x0, plot.x, plot.y, AXIS, 0.75);
-            x1 = x0;
-        }
-        plot
-    }
-}
-
-// ---------------------------------------------------------------- helpers
-
-/// Reduces a long polyline to first/min/max/last per pixel column.
-fn decimate(pts: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> {
-    if pts.len() <= max {
-        return pts;
-    }
-    let mut out = Vec::with_capacity(max * 2);
-    let mut i = 0;
-    while let Some(p) = pts.get(i) {
-        let col = p[0].floor();
-        let (start, mut mn, mut mx) = (i, i, i);
-        let mut k = i + 1;
-        while let Some(q) = pts.get(k) {
-            if q[0].floor() != col {
-                break;
-            }
-            if pts.get(mn).is_some_and(|m| q[1] < m[1]) {
-                mn = k;
-            }
-            if pts.get(mx).is_some_and(|m| q[1] > m[1]) {
-                mx = k;
-            }
-            k += 1;
-        }
-        let mut idx = [start, mn, mx, k - 1];
-        idx.sort_unstable();
-        let mut last = usize::MAX;
-        for ix in idx {
-            if ix != last
-                && let Some(q) = pts.get(ix)
-            {
-                out.push(*q);
-                last = ix;
-            }
-        }
-        i = k;
-    }
-    if out.len() > max * 4 {
-        let step = out.len() / (max * 2) + 1;
-        let last = out.last().copied();
-        let mut s: Vec<[f32; 2]> = out.into_iter().step_by(step).collect();
-        if let Some(l) = last
-            && s.last() != Some(&l)
-        {
-            s.push(l);
-        }
-        return s;
-    }
-    out
-}
-
-/// Draws a polyline split at gaps (`None`), decimated when long. With `smooth` (the plot box),
-/// each run is interpolated with a Catmull-Rom spline so the line curves through the data points.
-fn draw_runs(ctx: &mut Ctx, pts: &[Option<[f32; 2]>], color: Rgba, width: f32, smooth: Option<Bx>) {
-    let mut run: Vec<[f32; 2]> = Vec::new();
-    for p in pts.iter().chain(std::iter::once(&None)) {
-        match p {
-            Some(p) => run.push(*p),
-            None => {
-                if run.len() >= 2 {
-                    let r = decimate(std::mem::take(&mut run), MAX_LINE_PTS);
-                    let r = match smooth {
-                        Some(plot) => smooth_run(r, plot),
-                        None => r,
-                    };
-                    ctx.line(r, color, width);
-                } else {
-                    run.clear();
-                }
-            }
-        }
-    }
-}
-
-/// Catmull-Rom spline through `pts`: every segment gets the same number of sub-segments (up to
-/// 100), chosen so the whole curve stays within `MAX_LINE_PTS * 2` points. Endpoints are
-/// duplicated so the curve passes through the first and last points, and the curve is clamped
-/// to the `plot` box (a spline overshoots its data near sharp turns).
-fn smooth_run(pts: Vec<[f32; 2]>, plot: Bx) -> Vec<[f32; 2]> {
-    let n = pts.len();
-    if n < 3 {
-        return pts;
-    }
-    let cap = MAX_LINE_PTS * 2;
-    let steps = (cap / n).clamp(1, 100);
-    let mut out: Vec<[f32; 2]> = Vec::with_capacity(n.saturating_mul(steps).min(cap) + 1);
-    let at = |i: isize| -> [f32; 2] {
-        let j = i.clamp(0, n as isize - 1) as usize;
-        pts.get(j).copied().unwrap_or([0.0, 0.0])
-    };
-    let (x0, x1) = (plot.x.min(plot.right()), plot.x.max(plot.right()));
-    let (y0, y1) = (plot.y.min(plot.bottom()), plot.y.max(plot.bottom()));
-    let clip = |p: [f32; 2]| [p[0].clamp(x0, x1), p[1].clamp(y0, y1)];
-    for i in 0..n.saturating_sub(1) {
-        let (p0, p1, p2, p3) = (at(i as isize - 1), at(i as isize), at(i as isize + 1), at(i as isize + 2));
-        for s in 0..steps {
-            let t = s as f32 / steps as f32;
-            out.push(clip(catmull(p0, p1, p2, p3, t)));
-        }
-    }
-    out.push(clip(at(n as isize - 1)));
-    out
-}
-
-/// One Catmull-Rom point between `p1` and `p2` (uniform parameterisation), tangent-scaled by 0.5.
-fn catmull(p0: [f32; 2], p1: [f32; 2], p2: [f32; 2], p3: [f32; 2], t: f32) -> [f32; 2] {
-    let t2 = t * t;
-    let t3 = t2 * t;
-    let mut o = [0.0f32; 2];
-    for k in 0..2 {
-        let (a0, a1, a2, a3) = (p0[k], p1[k], p2[k], p3[k]);
-        o[k] = 0.5 * ((2.0 * a1) + (-a0 + a2) * t + (2.0 * a0 - 5.0 * a1 + 4.0 * a2 - a3) * t2 + (-a0 + 3.0 * a1 - 3.0 * a2 + a3) * t3);
-    }
-    o
-}
-
-fn draw_markers(ctx: &mut Ctx, pts: impl Iterator<Item = [f32; 2]>, r: f32, color: Rgba) {
-    let mut seen = HashSet::new();
-    for p in pts {
-        if seen.len() >= MAX_MARKERS {
-            break;
-        }
-        if seen.insert(((p[0] * 0.5) as i32, (p[1] * 0.5) as i32)) {
-            ctx.out.push(Prim::Circle { cx: p[0], cy: p[1], r, fill: Some(color), stroke: Some((WHITE, 0.75)) });
-        }
-    }
-}
-
-fn value_range(it: impl Iterator<Item = f64>) -> Option<(f64, f64)> {
-    it.fold(None, |acc, v| match acc {
-        None => Some((v, v)),
-        Some((a, b)) => Some((a.min(v), b.max(v))),
-    })
-}
-
-// ---------------------------------------------------------------- trendlines
-
-/// Samples along a regression trendline.
-const TREND_STEPS: usize = 200;
-
-/// Whether series drawn as `k` show trendlines (Excel offers them on 2-D unstacked column,
-/// bar, line, area, scatter and bubble charts).
-pub fn supports_trendline(k: ChartKind) -> bool {
-    use ChartKind::*;
-    matches!(k, ColumnClustered | BarClustered | Line | LineMarkers | Area | Scatter | ScatterLines | Bubble)
-}
-
-/// A forecast distance as drawn: finite, non-negative and bounded.
-fn forecast(v: f64) -> f64 {
-    if v.is_finite() && v > 0.0 { v.min(1e9) } else { 0.0 }
-}
-
-/// Most empty category slots a forward forecast may add after `ncat` categories: four times the
-/// data (at least 32), and never past `MAX_CATS` in total. A larger forecast would shrink every
-/// column to nothing.
-fn max_forward_slots(ncat: usize) -> f64 {
-    (ncat.saturating_mul(4).max(32)).min(MAX_CATS.saturating_sub(ncat)) as f64
-}
-
-/// Longest forward forecast among `s`'s regression trendlines.
-fn max_forward(s: &SeriesData) -> f64 {
-    s.trendlines.iter().filter(|t| !matches!(t.spec.kind, TrendlineKind::MovingAverage(_))).map(|t| forecast(t.spec.forward)).fold(0.0, f64::max)
-}
-
-/// Longest backward forecast among `s`'s regression trendlines.
-fn max_backward(s: &SeriesData) -> f64 {
-    s.trendlines.iter().filter(|t| !matches!(t.spec.kind, TrendlineKind::MovingAverage(_))).map(|t| forecast(t.spec.backward)).fold(0.0, f64::max)
-}
-
-/// Liang–Barsky: the part of segment `a`–`b` inside the unit square, with whether the start and
-/// end were cut.
-#[allow(clippy::type_complexity)]
-fn clip_segment(a: (f64, f64), b: (f64, f64)) -> Option<((f64, f64), (f64, f64), bool, bool)> {
-    let (dx, dy) = (b.0 - a.0, b.1 - a.1);
-    let (mut t0, mut t1) = (0.0f64, 1.0f64);
-    for (p, q) in [(-dx, a.0), (dx, 1.0 - a.0), (-dy, a.1), (dy, 1.0 - a.1)] {
-        if p == 0.0 {
-            if q < 0.0 {
-                return None;
-            }
-        } else {
-            let r = q / p;
-            if p < 0.0 {
-                if r > t1 {
-                    return None;
-                }
-                t0 = t0.max(r);
-            } else {
-                if r < t0 {
-                    return None;
-                }
-                t1 = t1.min(r);
-            }
-        }
-    }
-    Some(((a.0 + t0 * dx, a.1 + t0 * dy), (a.0 + t1 * dx, a.1 + t1 * dy), t0 > 0.0, t1 < 1.0))
-}
-
-/// Clips a sampled polyline in plot fractions (`None` = gap) to the plot box (the unit
-/// square), returning the visible runs.
-fn clip_unit(pts: &[Option<(f64, f64)>]) -> Vec<Vec<(f64, f64)>> {
-    const LIM: f64 = 1e9;
-    let ok = |p: &(f64, f64)| p.0.is_finite() && p.1.is_finite();
-    let cl = |p: (f64, f64)| (p.0.clamp(-LIM, LIM), p.1.clamp(-LIM, LIM));
-    let mut runs: Vec<Vec<(f64, f64)>> = Vec::new();
-    let mut run: Vec<(f64, f64)> = Vec::new();
-    for w in pts.windows(2) {
-        let seg = match w {
-            [Some(a), Some(b)] if ok(a) && ok(b) => clip_segment(cl(*a), cl(*b)),
-            _ => None,
-        };
-        match seg {
-            Some((p, q, cut_start, cut_end)) => {
-                if cut_start || run.is_empty() {
-                    if run.len() >= 2 {
-                        runs.push(std::mem::take(&mut run));
-                    }
-                    run.clear();
-                    run.push(p);
-                }
-                run.push(q);
-                if cut_end {
-                    runs.push(std::mem::take(&mut run));
-                }
-            }
-            None => {
-                if run.len() >= 2 {
-                    runs.push(std::mem::take(&mut run));
-                }
-                run.clear();
-            }
-        }
-    }
-    if run.len() >= 2 {
-        runs.push(run);
-    }
-    runs
-}
-
-/// Draws `s`'s trendlines fitted to its plotted points `pts` (data x, y). `frac` maps data to
-/// fractions of the plot box (0..1 inside, along the x and y axes), `px` fractions to pixels.
-/// Equation and R² label lines are appended to `labels`. Degenerate fits draw nothing.
-fn draw_trendlines(
-    ctx: &mut Ctx,
-    s: &SeriesData,
-    pts: &[(f64, f64)],
-    frac: &dyn Fn(f64, f64) -> (f64, f64),
-    px: &dyn Fn((f64, f64)) -> [f32; 2],
-    labels: &mut Vec<String>,
-    window: (f64, f64),
-) {
-    let Some((xlo, xhi)) = value_range(pts.iter().map(|p| p.0)) else { return };
-    for t in s.trendlines.iter().take(MAX_TRENDLINES) {
-        let spec = &t.spec;
-        let samples: Vec<Option<(f64, f64)>> = match spec.kind {
-            TrendlineKind::MovingAverage(p) => moving_average(pts, p).into_iter().map(|(x, y)| Some(frac(x, y))).collect(),
-            _ => {
-                let Some(fit) = fit_trendline(spec, pts) else { continue };
-                // Sample only the part of the forecast that is on the plot.
-                let (lo, hi) = ((xlo - forecast(spec.backward)).max(window.0), (xhi + forecast(spec.forward)).min(window.1));
-                if spec.display_equation {
-                    labels.push(fit.equation());
-                }
-                if spec.display_r_squared {
-                    labels.push(fit.r_squared());
-                }
-                (0..=TREND_STEPS)
-                    .map(|i| {
-                        let x = lo + (hi - lo) * i as f64 / TREND_STEPS as f64;
-                        fit.eval(x).map(|y| frac(x, y))
-                    })
-                    .collect()
-            }
-        };
-        let width = spec.width.filter(|w| w.is_finite()).unwrap_or(1.5).clamp(0.25, 12.0);
-        let dash = spec.dash != Some(LineDash::Solid);
-        for run in clip_unit(&samples) {
-            let line = decimate(run.into_iter().map(px).collect(), MAX_LINE_PTS);
-            if line.len() >= 2 {
-                ctx.out.push(Prim::Line { pts: line, color: t.color, width, dash });
-            }
-        }
-    }
-}
-
-/// Trendline equation / R² labels, stacked in the plot's top-right corner.
-fn draw_trend_labels(ctx: &mut Ctx, plot: Bx, labels: &[String]) {
-    let lh = LABEL_SIZE * 1.3;
-    for (i, t) in labels.iter().enumerate() {
-        let y = plot.y + 4.0 + i as f32 * lh;
-        if y + lh > plot.bottom() {
-            break;
-        }
-        let t = ctx.fit(t, LABEL_SIZE, plot.w - 8.0);
-        ctx.text(plot.right() - 4.0, y, &t, LABEL_SIZE, TEXT, HAlign::Right, VAlign::Top);
-    }
-}
-
-// ---------------------------------------------------------------- cartesian (column/bar/line/area/combo)
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Fam {
-    Col,
-    ColStack,
-    Col100,
-    Line,
-    LineStack,
-    Area,
-    AreaStack,
-    Area100,
-}
-
-fn family(k: ChartKind) -> Fam {
-    use ChartKind::*;
-    match k {
-        ColumnStacked | BarStacked => Fam::ColStack,
-        ColumnStacked100 | BarStacked100 => Fam::Col100,
-        Line | LineMarkers | Scatter | ScatterLines | Radar | Stock => Fam::Line,
-        LineStacked => Fam::LineStack,
-        Area => Fam::Area,
-        AreaStacked => Fam::AreaStack,
-        AreaStacked100 => Fam::Area100,
-        _ => Fam::Col,
-    }
-}
-
-/// Families stacked to 100%: each category's values are shares of its total.
-fn is_100(f: Fam) -> bool {
-    matches!(f, Fam::Col100 | Fam::Area100)
-}
-
-fn is_col(f: Fam) -> bool {
-    matches!(f, Fam::Col | Fam::ColStack | Fam::Col100)
-}
-fn is_line(f: Fam) -> bool {
-    matches!(f, Fam::Line | Fam::LineStack)
-}
-
-fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, horizontal: bool) {
-    let ncat = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).min(MAX_CATS);
-    if ncat == 0 {
-        return;
-    }
-    let kinds: Vec<ChartKind> = data.series.iter().map(|s| if horizontal { chart.kind } else { plot_kind(chart, s) }).collect();
-    let fams: Vec<Fam> = kinds.iter().map(|k| family(*k)).collect();
-    let any_primary = data.series.iter().any(|s| !s.secondary);
-    let sec: Vec<bool> = data.series.iter().map(|s| s.secondary && any_primary && !horizontal).collect();
-
-    // Totals for 100% stacking, per axis and family (100% columns and 100% areas stack apart).
-    let mut totals: Vec<((bool, Fam), Vec<f64>)> = Vec::new();
-    for (i, s) in data.series.iter().enumerate() {
-        let fam = fams.get(i).copied().unwrap_or(Fam::Col);
-        if is_100(fam) {
-            let key = (sec.get(i).copied().unwrap_or(false), fam);
-            let p = match totals.iter().position(|(k, _)| *k == key) {
-                Some(p) => p,
-                None => {
-                    totals.push((key, vec![0.0; ncat]));
-                    totals.len() - 1
-                }
-            };
-            for (j, v) in s.values.iter().take(ncat).enumerate() {
-                if let (Some(v), Some(t)) = (v, totals.get_mut(p).and_then(|(_, t)| t.get_mut(j))) {
-                    *t += v.abs();
-                }
-            }
-        }
-    }
-    // A value's share of its category's total, for the 100% families.
-    let share = |key: (bool, Fam), j: usize, v: f64| {
-        let t = totals.iter().find(|(k, _)| *k == key).and_then(|(_, t)| t.get(j)).copied().unwrap_or(0.0);
-        if t > 0.0 { v / t } else { 0.0 }
-    };
-    // Stack accumulators keyed by (axis, family): positive and negative running sums.
-    let mut stacks: Vec<((bool, Fam), Vec<f64>, Vec<f64>)> = Vec::new();
-    let mut spans: Vec<Vec<Option<(f64, f64)>>> = Vec::with_capacity(data.series.len());
-    for (i, s) in data.series.iter().enumerate() {
-        let fam = fams.get(i).copied().unwrap_or(Fam::Col);
-        let a = sec.get(i).copied().unwrap_or(false);
-        let stacked = matches!(fam, Fam::ColStack | Fam::Col100 | Fam::LineStack | Fam::AreaStack | Fam::Area100);
-        let key = (a, fam);
-        let si = if stacked {
-            match stacks.iter().position(|(k, _, _)| *k == key) {
-                Some(p) => Some(p),
-                None => {
-                    stacks.push((key, vec![0.0; ncat], vec![0.0; ncat]));
-                    Some(stacks.len() - 1)
-                }
-            }
-        } else {
-            None
-        };
-        let mut row = Vec::with_capacity(ncat);
-        for j in 0..ncat {
-            let v = s.values.get(j).copied().flatten();
-            let span = match (si.and_then(|p| stacks.get_mut(p)), fam) {
-                (Some((_, pos, neg)), Fam::ColStack | Fam::Col100) => v.and_then(|v| {
-                    let v = if fam == Fam::Col100 { share(key, j, v) } else { v };
-                    let acc = if v >= 0.0 { pos.get_mut(j) } else { neg.get_mut(j) }?;
-                    let base = *acc;
-                    *acc += v;
-                    Some((base, *acc))
-                }),
-                (Some((_, pos, _)), _) => {
-                    let v = v.unwrap_or(0.0);
-                    let v = if fam == Fam::Area100 { share(key, j, v) } else { v };
-                    pos.get_mut(j).map(|acc| {
-                        let base = *acc;
-                        *acc = clean(*acc + v);
-                        (base, *acc)
-                    })
-                }
-                (None, _) => v.map(|v| (0.0, v)),
-            };
-            row.push(span);
-        }
-        spans.push(row);
-    }
-
-    // Axis scales.
-    let mut axes: Vec<(Scale, Fmt)> = Vec::new();
-    for axis in [false, true] {
-        let members: Vec<usize> = (0..data.series.len()).filter(|i| sec.get(*i).copied().unwrap_or(false) == axis).collect();
-        if members.is_empty() {
-            continue;
-        }
-        let force_zero = members.iter().any(|i| fams.get(*i).is_some_and(|f| !is_line(*f)));
-        let all100 = members.iter().all(|i| fams.get(*i).is_some_and(|f| is_100(*f)));
-        let range = value_range(members.iter().flat_map(|i| {
-            let line = fams.get(*i).is_some_and(|f| is_line(*f));
-            spans.get(*i).into_iter().flatten().flatten().flat_map(move |(b, t)| if line { vec![*t] } else { vec![*b, *t] })
-        }));
-        let (lo, hi) = range.unwrap_or((0.0, 0.0));
-        let (scale, fmt) = if all100 {
-            (fixed_scale(if lo < -1e-9 { -1.0 } else { 0.0 }, if hi > 1e-9 || lo >= -1e-9 { 1.0 } else { 0.0 }, 0.2), Fmt::new("0%"))
-        } else {
-            let code = members.first().and_then(|i| data.series.get(*i)).map(|s| s.number_format.as_str()).unwrap_or("General");
-            (nice_scale(lo, hi, force_zero), Fmt::new(code))
-        };
-        axes.push((scale, fmt));
-        if !axis && sec.iter().all(|s| !s) {
-            break;
-        }
-    }
-    let Some((s1, f1)) = axes.first() else { return };
-    let y1 = ValAxis { scale: *s1, fmt: f1 };
-    let y2 = axes.get(1).map(|(s, f)| ValAxis { scale: *s, fmt: f });
-    // A forward forecast on a category axis adds empty category slots after the data.
-    let fwd = data
-        .series
-        .iter()
-        .enumerate()
-        .filter(|(i, _)| kinds.get(*i).is_some_and(|k| supports_trendline(*k)))
-        .map(|(_, s)| max_forward(s))
-        .fold(0.0, f64::max);
-    let ncat_slots = ncat.saturating_add(fwd.min(max_forward_slots(ncat)).ceil() as usize).min(MAX_CATS.max(ncat));
-    let labels: Vec<String> = (0..ncat_slots).map(|j| if j < ncat { cat_label(data, j) } else { String::new() }).collect();
-    // Outer levels padded to the slots (forecast slots stay in the last group).
-    let outer: Vec<Vec<String>> =
-        data.category_levels.iter().map(|l| (0..ncat_slots).map(|j| l.get(j).cloned().unwrap_or_default()).collect()).collect();
-    let plot = frame(ctx, area, CatAxis::Labels(&labels, &outer), &y1, y2.as_ref(), horizontal, chart.gridlines);
-    if !plot.ok() {
-        return;
-    }
-    let scale_of = |i: usize| -> Scale { if sec.get(i).copied().unwrap_or(false) { y2.as_ref().map(|a| a.scale).unwrap_or(*s1) } else { *s1 } };
-    let cat_len = if horizontal { plot.h } else { plot.w };
-    let cw = cat_len / ncat_slots as f32;
-    let center = |j: usize| if horizontal { plot.bottom() - (j as f32 + 0.5) * cw } else { plot.x + (j as f32 + 0.5) * cw };
-    let vpos = |v: f64, sc: &Scale| if horizontal { plot.x + sc.frac(v) * plot.w } else { plot.bottom() - sc.frac(v) * plot.h };
-
-    // Column slots: each clustered series gets one, each stack group shares one.
-    let mut slot_keys: Vec<(bool, Fam, usize)> = Vec::new();
-    let mut slot_of = vec![0usize; data.series.len()];
-    for (i, f) in fams.iter().enumerate() {
-        if !is_col(*f) {
-            continue;
-        }
-        let a = sec.get(i).copied().unwrap_or(false);
-        let key = if *f == Fam::Col { (a, *f, i) } else { (a, *f, usize::MAX) };
-        let k = match slot_keys.iter().position(|k| *k == key) {
-            Some(p) => p,
-            None => {
-                slot_keys.push(key);
-                slot_keys.len() - 1
-            }
-        };
-        if let Some(s) = slot_of.get_mut(i) {
-            *s = k;
-        }
-    }
-    let nslots = slot_keys.len().max(1) as f32;
-    let bw = cw / (nslots + 1.5);
-    let labels_on = chart.data_labels && ncat <= MAX_LABELS;
-    // Area labels wait until every area is filled, so a later (stacked) area can't paint over them.
-    let mut area_labels = Vec::new();
-
-    // Areas first, then columns, then lines on top.
-    for pass in 0..3 {
-        for (i, s) in data.series.iter().enumerate() {
-            let fam = fams.get(i).copied().unwrap_or(Fam::Col);
-            let want = match pass {
-                0 => matches!(fam, Fam::Area | Fam::AreaStack | Fam::Area100),
-                1 => is_col(fam),
-                _ => is_line(fam),
-            };
-            if !want {
-                continue;
-            }
-            let sc = scale_of(i);
-            let fmt = Fmt::new(&s.number_format);
-            let row = match spans.get(i) {
-                Some(r) => r,
-                None => continue,
-            };
-            match pass {
-                0 => {
-                    let mut top = Vec::with_capacity(ncat * 2);
-                    let mut base = Vec::with_capacity(ncat);
-                    for (j, sp) in row.iter().enumerate() {
-                        let (b, t) = sp.unwrap_or((0.0, 0.0));
-                        let c = center(j);
-                        top.push([c, vpos(t, &sc)]);
-                        base.push([c, vpos(b, &sc)]);
-                        // Source values (not stack totals), just above the top edge like the line labels.
-                        if labels_on
-                            && sp.is_some()
-                            && let Some(v) = s.values.get(j).copied().flatten()
-                        {
-                            area_labels.push((c, vpos(t, &sc) - 5.0, fmt.format(v, None)));
-                        }
-                    }
-                    if top.len() == 1 {
-                        // A single point: give it some width.
-                        if let (Some(t), Some(b)) = (top.first().copied(), base.first().copied()) {
-                            top = vec![[t[0] - cw * 0.3, t[1]], [t[0] + cw * 0.3, t[1]]];
-                            base = vec![[b[0] - cw * 0.3, b[1]], [b[0] + cw * 0.3, b[1]]];
-                        }
-                    }
-                    let top = decimate(top, MAX_LINE_PTS * 2);
-                    let base = decimate(base, MAX_LINE_PTS * 2);
-                    let mut poly = top;
-                    poly.extend(base.into_iter().rev());
-                    if poly.len() >= 3 {
-                        ctx.out.push(Prim::Polygon { pts: poly, fill: s.color, stroke: None });
-                    }
-                }
-                1 => {
-                    let k = slot_of.get(i).copied().unwrap_or(0) as f32;
-                    for (j, sp) in row.iter().enumerate() {
-                        let Some((b, t)) = sp else { continue };
-                        let (pb, pt) = (vpos(*b, &sc), vpos(*t, &sc));
-                        let c = center(j);
-                        let lo = pb.min(pt);
-                        let len = (pb - pt).abs();
-                        if horizontal {
-                            let y = c + nslots * bw / 2.0 - (k + 1.0) * bw;
-                            ctx.rect(lo, y, len, bw, s.color, None);
-                        } else {
-                            let x = c - nslots * bw / 2.0 + k * bw;
-                            ctx.rect(x, lo, bw, len, s.color, None);
-                        }
-                        if labels_on && let Some(v) = s.values.get(j).copied().flatten() {
-                            let t = fmt.format(v, None);
-                            let stacked = fam != Fam::Col;
-                            let mid = (pb + pt) / 2.0;
-                            if horizontal {
-                                let y = c + nslots * bw / 2.0 - (k + 0.5) * bw;
-                                if stacked {
-                                    ctx.text(mid, y, &t, LABEL_SIZE, on(s.color), HAlign::Center, VAlign::Middle);
-                                } else if v >= 0.0 {
-                                    ctx.text(pb.max(pt) + 3.0, y, &t, LABEL_SIZE, TEXT, HAlign::Left, VAlign::Middle);
-                                } else {
-                                    ctx.text(lo - 3.0, y, &t, LABEL_SIZE, TEXT, HAlign::Right, VAlign::Middle);
-                                }
-                            } else {
-                                let x = c - nslots * bw / 2.0 + (k + 0.5) * bw;
-                                if stacked {
-                                    ctx.text(x, mid, &t, LABEL_SIZE, on(s.color), HAlign::Center, VAlign::Middle);
-                                } else if v >= 0.0 {
-                                    ctx.text(x, lo - 2.0, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-                                } else {
-                                    ctx.text(x, lo + len + 2.0, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Top);
-                                }
-                            }
-                        }
-                    }
-                }
-                _ => {
-                    let pts: Vec<Option<[f32; 2]>> = row.iter().enumerate().map(|(j, sp)| sp.map(|(_, t)| [center(j), vpos(t, &sc)])).collect();
-                    draw_runs(ctx, &pts, s.color, 2.25, s.smooth.then_some(plot));
-                    let k = kinds.get(i).copied().unwrap_or(ChartKind::Line);
-                    if k == ChartKind::LineMarkers && cw >= 3.0 {
-                        draw_markers(ctx, pts.iter().flatten().copied(), 3.5, s.color);
-                    }
-                    if labels_on {
-                        for (j, p) in pts.iter().enumerate() {
-                            if let (Some(p), Some(v)) = (p, s.values.get(j).copied().flatten()) {
-                                ctx.text(p[0], p[1] - 5.0, &fmt.format(v, None), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        for (x, y, t) in area_labels.drain(..) {
-            ctx.text(x, y, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-        }
-    }
-    // Trendlines on top: x is the category number 1..n.
-    let mut trend_labels = Vec::new();
-    for (i, s) in data.series.iter().enumerate() {
-        if s.trendlines.is_empty() || !kinds.get(i).is_some_and(|k| supports_trendline(*k)) {
-            continue;
-        }
-        let sc = scale_of(i);
-        let pts: Vec<(f64, f64)> = s.values.iter().take(ncat).enumerate().filter_map(|(j, v)| v.map(|v| ((j + 1) as f64, v))).collect();
-        let frac = |x: f64, y: f64| ((x - 0.5) / ncat_slots as f64, (y - sc.min) / (sc.max - sc.min));
-        let px = |(fx, fy): (f64, f64)| {
-            if horizontal {
-                [plot.x + fy as f32 * plot.w, plot.bottom() - fx as f32 * plot.h]
-            } else {
-                [plot.x + fx as f32 * plot.w, plot.bottom() - fy as f32 * plot.h]
-            }
-        };
-        draw_trendlines(ctx, s, &pts, &frac, &px, &mut trend_labels, (0.5, ncat_slots as f64 + 0.5));
-    }
-    draw_trend_labels(ctx, plot, &trend_labels);
-}
-
-// ---------------------------------------------------------------- scatter & bubble
-
-fn scatter(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let pts_of = |s: &SeriesData| -> Vec<Option<(f64, f64)>> {
-        s.values
-            .iter()
-            .enumerate()
-            .map(|(j, v)| {
-                let x = match &s.x {
-                    Some(xs) => xs.get(j).copied().flatten(),
-                    None => Some((j + 1) as f64),
-                };
-                match (x, v) {
-                    (Some(x), Some(y)) => Some((x, *y)),
-                    _ => None,
-                }
-            })
-            .collect()
-    };
-    let all: Vec<Vec<Option<(f64, f64)>>> = data.series.iter().map(pts_of).collect();
-    let Some((mut xlo, mut xhi)) = value_range(all.iter().flatten().flatten().map(|p| p.0)) else { return };
-    // Forecasts extend the x axis to the trendline's ends.
-    for (s, pts) in data.series.iter().zip(&all) {
-        if let Some((lo, hi)) = value_range(pts.iter().flatten().map(|p| p.0)).filter(|_| !s.trendlines.is_empty()) {
-            xlo = xlo.min(lo - max_backward(s));
-            xhi = xhi.max(hi + max_forward(s));
-        }
-    }
-    let Some((ylo, yhi)) = value_range(all.iter().flatten().flatten().map(|p| p.1)) else { return };
-    let xs = nice_scale(xlo, xhi, false);
-    let ys = nice_scale(ylo, yhi, false);
-    let fx = Fmt::new("General");
-    let fy = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
-    let plot = frame(ctx, area, CatAxis::Numeric(xs, &fx), &ValAxis { scale: ys, fmt: &fy }, None, false, chart.gridlines);
-    if !plot.ok() {
-        return;
-    }
-    let map = |(x, y): (f64, f64)| [plot.x + xs.frac(x) * plot.w, plot.bottom() - ys.frac(y) * plot.h];
-    let bubble = chart.kind == ChartKind::Bubble;
-    let rmax = plot.w.min(plot.h) * 0.12;
-    for (s, pts) in data.series.iter().zip(&all) {
-        let px: Vec<Option<[f32; 2]>> = pts.iter().map(|p| p.map(map)).collect();
-        if bubble {
-            let sizes = s.sizes.as_deref().unwrap_or(&[]);
-            let smax = sizes.iter().flatten().fold(0.0f64, |a, b| a.max(*b));
-            let mut bubbles: Vec<([f32; 2], f64)> = px
-                .iter()
-                .enumerate()
-                .filter_map(|(j, p)| {
-                    let sz = if sizes.is_empty() { Some(1.0) } else { sizes.get(j).copied().flatten() };
-                    match (p, sz) {
-                        (Some(p), Some(sz)) if sz > 0.0 => Some((*p, sz)),
-                        _ => None,
-                    }
-                })
-                .take(MAX_MARKERS)
-                .collect();
-            bubbles.sort_by(|a, b| b.1.total_cmp(&a.1));
-            let smax = if sizes.is_empty() { 1.0 } else { smax };
-            let fill = [s.color[0], s.color[1], s.color[2], 0xC0];
-            for (p, sz) in bubbles {
-                let r = ((sz / smax).sqrt() as f32 * rmax).max(1.0);
-                ctx.out.push(Prim::Circle { cx: p[0], cy: p[1], r, fill: Some(fill), stroke: Some((WHITE, 0.75)) });
-            }
-        } else {
-            let lines = chart.kind == ChartKind::ScatterLines || s.kind == ChartKind::ScatterLines;
-            if lines {
-                draw_runs(ctx, &px, s.color, 2.0, s.smooth.then_some(plot));
-            }
-            if !lines || px.len() <= 500 {
-                draw_markers(ctx, px.iter().flatten().copied(), 3.5, s.color);
-            }
-        }
-        if chart.data_labels && pts.len() <= MAX_LABELS {
-            for (p, raw) in px.iter().zip(pts) {
-                if let (Some(p), Some((_, y))) = (p, raw) {
-                    ctx.text(p[0], p[1] - 6.0, &fy.format(*y, None), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-                }
-            }
-        }
-    }
-    let mut trend_labels = Vec::new();
-    for (s, pts) in data.series.iter().zip(&all) {
-        if s.trendlines.is_empty() {
-            continue;
-        }
-        let pts: Vec<(f64, f64)> = pts.iter().flatten().copied().collect();
-        let frac = |x: f64, y: f64| ((x - xs.min) / (xs.max - xs.min), (y - ys.min) / (ys.max - ys.min));
-        let px = |(fx, fy): (f64, f64)| [plot.x + fx as f32 * plot.w, plot.bottom() - fy as f32 * plot.h];
-        draw_trendlines(ctx, s, &pts, &frac, &px, &mut trend_labels, (xs.min, xs.max));
-    }
-    draw_trend_labels(ctx, plot, &trend_labels);
-}
-
-// ---------------------------------------------------------------- histogram
-
-fn histogram(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let Some(s) = data.series.first() else { return };
-    let vals: Vec<f64> = s.values.iter().flatten().copied().collect();
-    let Some((lo, hi)) = value_range(vals.iter().copied()) else { return };
-    let n = vals.len();
-    let span = hi - lo;
-    let mut bins = ((n as f64).sqrt().ceil() as usize).clamp(1, 100);
-    if !(span.is_finite() && span > 0.0) {
-        bins = 1;
-    }
-    let width = if bins == 1 && span.partial_cmp(&0.0) != Some(std::cmp::Ordering::Greater) { 1.0 } else { span / bins as f64 };
-    // Upper edge of each bin, exactly as shown in the labels below. Bins are right-inclusive (the first is closed on both sides), so a value
-    // equal to an edge belongs to the bin that ends there.
-    let edges: Vec<f64> = (0..bins).map(|b| if b + 1 == bins { hi.max(lo + b as f64 * width) } else { lo + (b + 1) as f64 * width }).collect();
-    let mut counts = vec![0usize; bins];
-    for v in &vals {
-        let b = edges.partition_point(|e| e < v).min(bins - 1);
-        if let Some(c) = counts.get_mut(b) {
-            *c += 1;
-        }
-    }
-    let f = Fmt::new(&s.number_format);
-    let labels: Vec<String> = (0..bins)
-        .map(|b| {
-            let a = lo + b as f64 * width;
-            let e = edges.get(b).copied().unwrap_or(a);
-            let open = if b == 0 { '[' } else { '(' };
-            format!("{open}{}, {}]", f.format(a, Some(width / 10.0)), f.format(e, Some(width / 10.0)))
-        })
-        .collect();
-    let maxc = counts.iter().copied().max().unwrap_or(0) as f64;
-    let ys = nice_scale(0.0, maxc, true);
-    let fc = Fmt::new("General");
-    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &fc }, None, false, chart.gridlines);
-    if !plot.ok() {
-        return;
-    }
-    let cw = plot.w / bins as f32;
-    for (b, c) in counts.iter().enumerate() {
-        let top = plot.bottom() - ys.frac(*c as f64) * plot.h;
-        let x = plot.x + b as f32 * cw;
-        ctx.rect(x, top, cw, plot.bottom() - top, s.color, Some((WHITE, 0.75)));
-        if chart.data_labels {
-            ctx.text(x + cw / 2.0, top - 2.0, &c.to_string(), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-        }
-    }
-}
-
-// ---------------------------------------------------------------- waterfall
-
-fn waterfall(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let Some(s) = data.series.first() else { return };
-    let mut ncat = data.categories.len().max(s.values.len()).min(MAX_CATS);
-    if ncat == 0 {
-        return;
-    }
-    let mut labels: Vec<String> = (0..ncat).map(|j| cat_label(data, j)).collect();
-    let mut vals: Vec<f64> = (0..ncat).map(|j| s.values.get(j).copied().flatten().unwrap_or(0.0)).collect();
-    let mut is_total = vec![false; ncat];
-    let last_total = labels.last().is_some_and(|l| l.to_lowercase().contains("total"));
-    if let Some(t) = is_total.last_mut() {
-        *t = last_total;
-    }
-    if !last_total {
-        labels.push("Total".into());
-        vals.push(0.0);
-        is_total.push(true);
-        ncat += 1;
-    }
-    let mut bars = Vec::with_capacity(ncat);
-    let mut cum = 0.0f64;
-    for (j, v) in vals.iter().enumerate() {
-        if is_total.get(j).copied().unwrap_or(false) {
-            let total = if last_total && j + 1 == ncat && *v != 0.0 { *v } else { cum };
-            bars.push((0.0, total, 0u8));
-            cum = total;
-        } else {
-            let top = clean(cum + v);
-            bars.push((cum, top, if *v >= 0.0 { 1 } else { 2 }));
-            cum = top;
-        }
-    }
-    let (lo, hi) = value_range(bars.iter().flat_map(|(b, t, _)| [*b, *t])).unwrap_or((0.0, 0.0));
-    let ys = nice_scale(lo, hi, true);
-    let f = Fmt::new(&s.number_format);
-    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &f }, None, false, chart.gridlines);
-    if !plot.ok() {
-        return;
-    }
-    let cw = plot.w / ncat as f32;
-    let bw = cw / 1.5;
-    let vy = |v: f64| plot.bottom() - ys.frac(v) * plot.h;
-    for (j, (b, t, kind)) in bars.iter().enumerate() {
-        let color = match kind {
-            1 => UP,
-            2 => DOWN,
-            _ => s.color,
-        };
-        let x = plot.x + (j as f32 + 0.5) * cw - bw / 2.0;
-        let (yb, yt) = (vy(*b), vy(*t));
-        ctx.rect(x, yb.min(yt), bw, (yb - yt).abs().max(0.5), color, None);
-        if j + 1 < bars.len() && ncat <= 500 {
-            ctx.out.push(Prim::Line { pts: vec![[x + bw, yt], [x + cw, yt]], color: AXIS, width: 0.75, dash: true });
-        }
-        if chart.data_labels && ncat <= MAX_LABELS {
-            let v = if *kind == 0 { *t } else { t - b };
-            ctx.text(x + bw / 2.0, yb.min(yt) - 2.0, &f.format(v, None), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
-        }
-    }
-}
-
-// ---------------------------------------------------------------- funnel
-
-fn funnel(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let Some(s) = data.series.first() else { return };
-    let n = data.categories.len().max(s.values.len()).min(MAX_CATS);
-    if n == 0 {
-        return;
-    }
-    let vals: Vec<f64> = (0..n).map(|j| s.values.get(j).copied().flatten().unwrap_or(0.0).abs()).collect();
-    let max = vals.iter().copied().fold(0.0f64, f64::max);
-    if max.is_nan() || max <= 0.0 {
-        return;
-    }
-    let labels: Vec<String> = (0..n).map(|j| cat_label(data, j)).collect();
-    let lw = (labels.iter().take(2000).map(|t| ctx.tw(t, LABEL_SIZE)).fold(0.0f32, f32::max) + 8.0).min(area.w * 0.35);
-    let plot = Bx { x: area.x + lw, w: area.w - lw, ..area };
-    if !plot.ok() {
-        return;
-    }
-    let slot = plot.h / n as f32;
-    let bh = slot * 0.85;
-    let f = Fmt::new(&s.number_format);
-    let show = slot >= LABEL_SIZE * 0.9;
-    for (j, v) in vals.iter().enumerate() {
-        let bw = (*v / max) as f32 * plot.w;
-        let x = plot.x + (plot.w - bw) / 2.0;
-        let y = plot.y + j as f32 * slot + (slot - bh) / 2.0;
-        if bw > 0.0 {
-            ctx.rect(x, y, bw, bh, s.color, None);
-        }
-        if show {
-            let yc = y + bh / 2.0;
-            if chart.data_labels {
-                let t = f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None);
-                let color = if ctx.tw(&t, LABEL_SIZE) + 4.0 <= bw { on(s.color) } else { TEXT };
-                ctx.text(plot.cx(), yc, &t, LABEL_SIZE, color, HAlign::Center, VAlign::Middle);
-            }
-            let l = ctx.fit(labels.get(j).map(String::as_str).unwrap_or(""), LABEL_SIZE, lw - 8.0);
-            ctx.text(plot.x - 6.0, yc, &l, LABEL_SIZE, TEXT, HAlign::Right, VAlign::Middle);
-        }
-    }
-}
-
-// ---------------------------------------------------------------- pie, doughnut, sunburst
-
-fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inner: f32, names: bool) {
-    let Some(s) = data.series.first() else { return };
-    let vals: Vec<f64> = s.values.iter().take(MAX_CATS).map(|v| v.map(f64::abs).unwrap_or(0.0)).collect();
-    let total: f64 = vals.iter().sum();
-    if !(total.is_finite() && total > 0.0) {
-        return;
-    }
-    let (cx, cy) = (area.cx(), area.cy());
-    let r = area.w.min(area.h) / 2.0 * 0.92;
-    if r < 2.0 {
-        return;
-    }
-    let ri = r * inner;
-    let f = Fmt::new(&s.number_format);
-    let mut a = 0.0f32;
-    let mut labels = Vec::new();
-    for (j, v) in vals.iter().enumerate() {
-        let sweep = (*v / total) as f32 * TAU;
-        if sweep > 1e-4 {
-            let fill = point_color(data, j);
-            ctx.out.push(Prim::Wedge { cx, cy, r_outer: r, r_inner: ri, a0: a, a1: (a + sweep).min(TAU), fill, stroke: Some((WHITE, 1.5)) });
-            if (chart.data_labels || names) && vals.len() <= MAX_LABELS {
-                let t = if names { cat_label(data, j) } else { f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None) };
-                let mid = a + sweep / 2.0;
-                let rr = if ri > 0.0 { (r + ri) / 2.0 } else { r * 0.65 };
-                let room = sweep * rr;
-                if ctx.tw(&t, LABEL_SIZE) <= room.max(r - ri) && room >= LABEL_SIZE {
-                    labels.push((cx + rr * mid.sin(), cy - rr * mid.cos(), t, on(fill)));
-                }
-            }
-        }
-        a += sweep;
-    }
-    for (x, y, t, c) in labels {
-        ctx.text(x, y, &t, LABEL_SIZE, c, HAlign::Center, VAlign::Middle);
-    }
-}
-
-// ---------------------------------------------------------------- treemap
-
-fn worst(row: &[f64], side: f64) -> f64 {
-    let s: f64 = row.iter().sum();
-    if s <= 0.0 || side <= 0.0 {
-        return f64::INFINITY;
-    }
-    let (mn, mx) = row.iter().fold((f64::INFINITY, 0.0f64), |(a, b), v| (a.min(*v), b.max(*v)));
-    let s2 = s * s;
-    let w2 = side * side;
-    (w2 * mx / s2).max(s2 / (w2 * mn))
-}
-
-/// Squarified treemap layout of (index, area) items, sorted descending, into `r`.
-fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
-    let total: f64 = items.iter().map(|i| i.1).sum();
-    let area = (r.w as f64) * (r.h as f64);
-    if !(total > 0.0 && area > 0.0) {
-        return vec![];
-    }
-    let scale = area / total;
-    let mut out = Vec::with_capacity(items.len());
-    let mut rem = r;
-    let mut row: Vec<(usize, f64)> = Vec::new();
-    let mut i = 0;
-    let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| {
-        let s: f64 = row.iter().map(|x| x.1).sum();
-        if s <= 0.0 {
-            return;
-        }
-        if rem.w >= rem.h {
-            let cw = (s / rem.h.max(1e-6) as f64) as f32;
-            let mut y = rem.y;
-            for (j, a) in row {
-                let h = (*a / cw.max(1e-6) as f64) as f32;
-                out.push((*j, Bx { x: rem.x, y, w: cw, h }));
-                y += h;
-            }
-            rem.x += cw;
-            rem.w = (rem.w - cw).max(0.0);
-        } else {
-            let rh = (s / rem.w.max(1e-6) as f64) as f32;
-            let mut x = rem.x;
-            for (j, a) in row {
-                let w = (*a / rh.max(1e-6) as f64) as f32;
-                out.push((*j, Bx { x, y: rem.y, w, h: rh }));
-                x += w;
-            }
-            rem.y += rh;
-            rem.h = (rem.h - rh).max(0.0);
-        }
-    };
-    while let Some(&(j, v)) = items.get(i) {
-        let a = v * scale;
-        let side = rem.w.min(rem.h) as f64;
-        let cur: Vec<f64> = row.iter().map(|x| x.1).collect();
-        let mut with = cur.clone();
-        with.push(a);
-        if row.is_empty() || worst(&with, side) <= worst(&cur, side) {
-            row.push((j, a));
-            i += 1;
-        } else {
-            layout(&row, &mut rem, &mut out);
-            row.clear();
-        }
-    }
-    if !row.is_empty() {
-        layout(&row, &mut rem, &mut out);
-    }
-    out
-}
-
-fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let Some(s) = data.series.first() else { return };
-    let mut items: Vec<(usize, f64)> =
-        s.values.iter().take(MAX_MARKERS).enumerate().filter_map(|(j, v)| v.filter(|v| *v > 0.0).map(|v| (j, v))).collect();
-    items.sort_by(|a, b| b.1.total_cmp(&a.1));
-    let f = Fmt::new(&s.number_format);
-    for (j, b) in squarify(&items, area) {
-        let fill = point_color(data, j);
-        ctx.rect(b.x, b.y, b.w, b.h, fill, Some((WHITE, 1.5)));
-        if b.w > 24.0 && b.h > LABEL_SIZE * 1.6 {
-            let name = ctx.fit(&cat_label(data, j), LABEL_SIZE, b.w - 8.0);
-            ctx.text(b.x + 4.0, b.y + 4.0, &name, LABEL_SIZE, on(fill), HAlign::Left, VAlign::Top);
-            if chart.data_labels && b.h > LABEL_SIZE * 3.2 {
-                let v = items.iter().find(|x| x.0 == j).map(|x| x.1).unwrap_or(0.0);
-                let t = ctx.fit(&f.format(v, None), LABEL_SIZE, b.w - 8.0);
-                ctx.text(b.x + 4.0, b.y + 4.0 + LABEL_SIZE * 1.4, &t, LABEL_SIZE, on(fill), HAlign::Left, VAlign::Top);
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------- radar
-
-fn radar(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let ncat = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).min(1000);
-    if ncat == 0 {
-        return;
-    }
-    let labels: Vec<String> = (0..ncat).map(|j| cat_label(data, j)).collect();
-    let lw = labels.iter().map(|t| ctx.tw(t, LABEL_SIZE)).fold(0.0f32, f32::max).min(area.w * 0.2);
-    let r = ((area.w - 2.0 * (lw + 8.0)).min(area.h - 2.0 * (LABEL_SIZE * 1.4 + 6.0)) / 2.0).max(0.0);
-    if r < 5.0 {
-        return;
-    }
-    let (cx, cy) = (area.cx(), area.cy());
-    let (lo, hi) = value_range(data.series.iter().flat_map(|s| s.values.iter().flatten().copied())).unwrap_or((0.0, 0.0));
-    let sc = nice_scale(lo, hi, true);
-    let f = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
-    let ang = |j: usize| j as f32 / ncat as f32 * TAU;
-    let pt = |a: f32, rr: f32| [cx + rr * a.sin(), cy - rr * a.cos()];
-    let ticks = sc.ticks();
-    let spacing = r / ticks.len().saturating_sub(1).max(1) as f32;
-    let every = ((LABEL_SIZE * 1.3 / spacing.max(1e-3)).ceil() as usize).max(1);
-    for (ti, t) in ticks.into_iter().enumerate() {
-        let rr = sc.frac(t) * r;
-        if rr > 0.5 && chart.gridlines {
-            let mut ring: Vec<[f32; 2]> = (0..ncat).map(|j| pt(ang(j), rr)).collect();
-            if ncat < 3 {
-                ring = (0..=48).map(|k| pt(k as f32 / 48.0 * TAU, rr)).collect();
-            } else if let Some(p) = ring.first().copied() {
-                ring.push(p);
-            }
-            ctx.line(ring, GRID, 0.75);
-        }
-        if ti % every == 0 {
-            ctx.text(cx - 3.0, cy - rr, &f.format(t, Some(sc.step)), LABEL_SIZE * 0.9, TEXT, HAlign::Right, VAlign::Middle);
-        }
-    }
-    let step = ncat.div_ceil(72).max(1);
-    for j in (0..ncat).step_by(step) {
-        let a = ang(j);
-        ctx.line(vec![[cx, cy], pt(a, r)], GRID, 0.75);
-        let p = pt(a, r + 6.0);
-        let (sa, ca) = (a.sin(), a.cos());
-        let align = if sa > 0.1 {
-            HAlign::Left
-        } else if sa < -0.1 {
-            HAlign::Right
-        } else {
-            HAlign::Center
-        };
-        let valign = if ca > 0.1 {
-            VAlign::Bottom
-        } else if ca < -0.1 {
-            VAlign::Top
-        } else {
-            VAlign::Middle
-        };
-        let t = ctx.fit(labels.get(j).map(String::as_str).unwrap_or(""), LABEL_SIZE, lw.max(20.0));
-        ctx.text(p[0], p[1], &t, LABEL_SIZE, TEXT, align, valign);
-    }
-    for s in &data.series {
-        let mut pts: Vec<[f32; 2]> = (0..ncat).map(|j| pt(ang(j), sc.frac(s.values.get(j).copied().flatten().unwrap_or(sc.min)) * r)).collect();
-        if let Some(p) = pts.first().copied() {
-            pts.push(p);
-        }
-        ctx.line(pts, s.color, 2.0);
-    }
-}
-
-// ---------------------------------------------------------------- box & whisker
-
-fn quantile(sorted: &[f64], q: f64, method: QuartileMethod) -> f64 {
-    let n = sorted.len();
-    if n == 0 {
-        return 0.0;
-    }
-    // Clamp exclusive ranks for short samples so one or two points remain drawable.
-    let pos = match method {
-        QuartileMethod::Inclusive => q * (n - 1) as f64,
-        QuartileMethod::Exclusive => (q * (n as f64 + 1.0) - 1.0).clamp(0.0, (n - 1) as f64),
-    };
-    let i = pos.floor() as usize;
-    let frac = pos - i as f64;
-    let a = sorted.get(i).copied().unwrap_or(0.0);
-    let b = sorted.get(i + 1).copied().unwrap_or(a);
-    a + (b - a) * frac
-}
-
-fn box_whisker(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let labels: Vec<String> = data.series.iter().map(|s| s.name.clone()).collect();
-    let Some((lo, hi)) = value_range(data.series.iter().flat_map(|s| s.values.iter().flatten().copied())) else { return };
-    let ys = nice_scale(lo, hi, false);
-    let f = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
-    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &f }, None, false, chart.gridlines);
-    if !plot.ok() {
-        return;
-    }
-    let n = data.series.len().max(1);
-    let cw = plot.w / n as f32;
-    let bw = (cw * 0.4).min(80.0);
-    let vy = |v: f64| plot.bottom() - ys.frac(v) * plot.h;
-    for (i, s) in data.series.iter().enumerate() {
-        let mut v: Vec<f64> = s.values.iter().flatten().copied().collect();
-        if v.is_empty() {
-            continue;
-        }
-        v.sort_by(f64::total_cmp);
-        let method = chart.series.get(i).map(|s| s.quartiles).unwrap_or_default();
-        let (q1, med, q3) = (quantile(&v, 0.25, method), quantile(&v, 0.5, method), quantile(&v, 0.75, method));
-        let iqr = q3 - q1;
-        let (flo, fhi) = (q1 - 1.5 * iqr, q3 + 1.5 * iqr);
-        let wlo = v.iter().copied().find(|x| *x >= flo).unwrap_or(q1);
-        let whi = v.iter().rev().copied().find(|x| *x <= fhi).unwrap_or(q3);
-        let mean = v.iter().sum::<f64>() / v.len() as f64;
-        let c = plot.x + (i as f32 + 0.5) * cw;
-        ctx.vline(c, vy(whi), vy(q3), s.color, 1.25);
-        ctx.vline(c, vy(q1), vy(wlo), s.color, 1.25);
-        ctx.hline(c - bw / 4.0, c + bw / 4.0, vy(whi), s.color, 1.25);
-        ctx.hline(c - bw / 4.0, c + bw / 4.0, vy(wlo), s.color, 1.25);
-        let (yt, yb) = (vy(q3), vy(q1));
-        ctx.rect(c - bw / 2.0, yt, bw, (yb - yt).max(0.5), s.color, None);
-        ctx.hline(c - bw / 2.0, c + bw / 2.0, vy(med), WHITE, 1.5);
-        let (mx, my, d) = (c, vy(mean), 3.0);
-        ctx.line(vec![[mx - d, my - d], [mx + d, my + d]], WHITE, 1.25);
-        ctx.line(vec![[mx - d, my + d], [mx + d, my - d]], WHITE, 1.25);
-        for o in v.iter().filter(|x| **x < flo || **x > fhi).take(MAX_MARKERS) {
-            ctx.out.push(Prim::Circle { cx: c, cy: vy(*o), r: 2.5, fill: None, stroke: Some((s.color, 1.0)) });
-        }
-    }
-}
-
-// ---------------------------------------------------------------- stock
-
-fn stock(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let ncat = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).min(MAX_CATS);
-    if ncat == 0 {
-        return;
-    }
-    let labels: Vec<String> = (0..ncat).map(|j| cat_label(data, j)).collect();
-    let Some((lo, hi)) = value_range(data.series.iter().flat_map(|s| s.values.iter().flatten().copied())) else { return };
-    let ys = nice_scale(lo, hi, false);
-    let f = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
-    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &f }, None, false, chart.gridlines);
-    if !plot.ok() {
-        return;
-    }
-    let ser = |k: usize| data.series.get(k);
-    let (open, high, low, close) = match data.series.len() {
-        0 => return,
-        1 => (None, None, None, ser(0)),
-        2 => (None, ser(0), ser(1), None),
-        3 => (None, ser(0), ser(1), ser(2)),
-        _ => (ser(0), ser(1), ser(2), ser(3)),
-    };
-    let get = |s: Option<&SeriesData>, j: usize| s.and_then(|s| s.values.get(j).copied().flatten());
-    let cw = plot.w / ncat as f32;
-    let tick = (cw * 0.25).max(1.0);
-    let vy = |v: f64| plot.bottom() - ys.frac(v) * plot.h;
-    for j in 0..ncat {
-        let c = plot.x + (j as f32 + 0.5) * cw;
-        if let (Some(h), Some(l)) = (get(high, j), get(low, j)) {
-            ctx.vline(c, vy(h), vy(l), STOCK, 1.25);
-        }
-        match (get(open, j), get(close, j)) {
-            (Some(o), Some(cl)) => {
-                let (yo, yc) = (vy(o), vy(cl));
-                let bw = (cw * 0.5).max(1.0);
-                let fill = if cl >= o { WHITE } else { STOCK };
-                ctx.rect(c - bw / 2.0, yo.min(yc), bw, (yo - yc).abs().max(0.75), fill, Some((STOCK, 1.0)));
-            }
-            (None, Some(cl)) => {
-                if high.is_some() {
-                    ctx.hline(c, c + tick, vy(cl), STOCK, 1.25);
-                } else {
-                    ctx.out.push(Prim::Circle { cx: c, cy: vy(cl), r: 2.5, fill: Some(STOCK), stroke: None });
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
 // ---------------------------------------------------------------- final safety pass
 
 fn fin(v: f32) -> bool {
@@ -1829,60 +253,3 @@ pub(crate) fn finalize(prims: Vec<Prim>, w: f32, h: f32) -> Vec<Prim> {
         })
         .collect()
 }
-
-#[cfg(test)]
-mod smooth_tests {
-    use super::*;
-
-    #[test]
-    fn long_runs_are_smoothed_uniformly_within_the_cap() {
-        let plot = Bx { x: 0.0, y: 0.0, w: 3000.0, h: 100.0 };
-        let pts: Vec<[f32; 2]> = (0..1500).map(|i| [i as f32 * 2.0, if i % 2 == 0 { 20.0 } else { 80.0 }]).collect();
-        let out = smooth_run(pts, plot);
-        assert!(out.len() <= MAX_LINE_PTS * 2 + 1, "{}", out.len());
-        // Two sub-segments per segment all the way to the end, not 100 each and then a straight tail.
-        assert_eq!(out.len(), 1499 * 2 + 1);
-        assert_eq!(out.last().copied(), Some([2998.0, 80.0]));
-    }
-
-    #[test]
-    fn spline_overshoot_is_clamped_to_the_plot() {
-        let plot = Bx { x: 0.0, y: 10.0, w: 300.0, h: 100.0 };
-        // A step right at the plot edges: Catmull-Rom overshoots past both.
-        let pts = vec![[0.0, 110.0], [100.0, 110.0], [110.0, 10.0], [200.0, 10.0], [300.0, 10.0]];
-        let out = smooth_run(pts, plot);
-        assert!(out.len() > 5);
-        assert!(out.iter().all(|p| (0.0..=300.0).contains(&p[0]) && (10.0..=110.0).contains(&p[1])));
-    }
-}
-
-#[cfg(test)]
-mod quartile_tests {
-    use super::*;
-
-    #[test]
-    fn box_whisker_default_quartiles_are_exclusive() {
-        let values = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
-        assert_eq!(quantile(&values, 0.25, QuartileMethod::default()), 1.75);
-        assert_eq!(quantile(&values, 0.5, QuartileMethod::default()), 3.5);
-        assert_eq!(quantile(&values, 0.75, QuartileMethod::default()), 5.25);
-    }
-
-    #[test]
-    fn quartile_methods_and_short_samples() {
-        for (values, exclusive, inclusive) in [
-            (vec![1., 2., 3.], (1., 3.), (1.5, 2.5)),
-            (vec![1., 2., 3., 4.], (1.25, 3.75), (1.75, 3.25)),
-            (vec![1., 2., 3., 4., 5.], (1.5, 4.5), (2., 4.)),
-            (vec![1., 2., 3., 4., 5., 6., 7.], (2., 6.), (2.5, 5.5)),
-            (vec![1., 1., 2., 3., 5., 8.], (1., 5.75), (1.25, 4.5)),
-            (vec![1., 2.], (1., 2.), (1.25, 1.75)),
-            (vec![1.], (1., 1.), (1., 1.)),
-            (vec![], (0., 0.), (0., 0.)),
-        ] {
-            for (method, expected) in [(QuartileMethod::Exclusive, exclusive), (QuartileMethod::Inclusive, inclusive)] {
-                assert_eq!((quantile(&values, 0.25, method), quantile(&values, 0.75, method)), expected);
-            }
-        }
-    }
-}
diff --git a/crates/chart/src/render/cartesian.rs b/crates/chart/src/render/cartesian.rs
new file mode 100644
index 000000000..85a577b08
--- /dev/null
+++ b/crates/chart/src/render/cartesian.rs
@@ -0,0 +1,431 @@
+use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range};
+use super::legend::{cat_label, plot_kind};
+use super::lines::{decimate, draw_markers, draw_runs};
+use super::trend::{draw_trend_labels, draw_trendlines, max_backward, max_forward, max_forward_slots, supports_trendline};
+use super::*;
+
+// ---------------------------------------------------------------- cartesian (column/bar/line/area/combo)
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Fam {
+    Col,
+    ColStack,
+    Col100,
+    Line,
+    LineStack,
+    Area,
+    AreaStack,
+    Area100,
+}
+
+fn family(k: ChartKind) -> Fam {
+    use ChartKind::*;
+    match k {
+        ColumnStacked | BarStacked => Fam::ColStack,
+        ColumnStacked100 | BarStacked100 => Fam::Col100,
+        Line | LineMarkers | Scatter | ScatterLines | Radar | Stock => Fam::Line,
+        LineStacked => Fam::LineStack,
+        Area => Fam::Area,
+        AreaStacked => Fam::AreaStack,
+        AreaStacked100 => Fam::Area100,
+        _ => Fam::Col,
+    }
+}
+
+/// Families stacked to 100%: each category's values are shares of its total.
+fn is_100(f: Fam) -> bool {
+    matches!(f, Fam::Col100 | Fam::Area100)
+}
+
+fn is_col(f: Fam) -> bool {
+    matches!(f, Fam::Col | Fam::ColStack | Fam::Col100)
+}
+
+fn is_line(f: Fam) -> bool {
+    matches!(f, Fam::Line | Fam::LineStack)
+}
+
+pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, horizontal: bool) {
+    let ncat = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).min(MAX_CATS);
+    if ncat == 0 {
+        return;
+    }
+    let kinds: Vec<ChartKind> = data.series.iter().map(|s| if horizontal { chart.kind } else { plot_kind(chart, s) }).collect();
+    let fams: Vec<Fam> = kinds.iter().map(|k| family(*k)).collect();
+    let any_primary = data.series.iter().any(|s| !s.secondary);
+    let sec: Vec<bool> = data.series.iter().map(|s| s.secondary && any_primary && !horizontal).collect();
+
+    // Totals for 100% stacking, per axis and family (100% columns and 100% areas stack apart).
+    let mut totals: Vec<((bool, Fam), Vec<f64>)> = Vec::new();
+    for (i, s) in data.series.iter().enumerate() {
+        let fam = fams.get(i).copied().unwrap_or(Fam::Col);
+        if is_100(fam) {
+            let key = (sec.get(i).copied().unwrap_or(false), fam);
+            let p = match totals.iter().position(|(k, _)| *k == key) {
+                Some(p) => p,
+                None => {
+                    totals.push((key, vec![0.0; ncat]));
+                    totals.len() - 1
+                }
+            };
+            for (j, v) in s.values.iter().take(ncat).enumerate() {
+                if let (Some(v), Some(t)) = (v, totals.get_mut(p).and_then(|(_, t)| t.get_mut(j))) {
+                    *t += v.abs();
+                }
+            }
+        }
+    }
+    // A value's share of its category's total, for the 100% families.
+    let share = |key: (bool, Fam), j: usize, v: f64| {
+        let t = totals.iter().find(|(k, _)| *k == key).and_then(|(_, t)| t.get(j)).copied().unwrap_or(0.0);
+        if t > 0.0 { v / t } else { 0.0 }
+    };
+    // Stack accumulators keyed by (axis, family): positive and negative running sums.
+    let mut stacks: Vec<((bool, Fam), Vec<f64>, Vec<f64>)> = Vec::new();
+    let mut spans: Vec<Vec<Option<(f64, f64)>>> = Vec::with_capacity(data.series.len());
+    for (i, s) in data.series.iter().enumerate() {
+        let fam = fams.get(i).copied().unwrap_or(Fam::Col);
+        let a = sec.get(i).copied().unwrap_or(false);
+        let stacked = matches!(fam, Fam::ColStack | Fam::Col100 | Fam::LineStack | Fam::AreaStack | Fam::Area100);
+        let key = (a, fam);
+        let si = if stacked {
+            match stacks.iter().position(|(k, _, _)| *k == key) {
+                Some(p) => Some(p),
+                None => {
+                    stacks.push((key, vec![0.0; ncat], vec![0.0; ncat]));
+                    Some(stacks.len() - 1)
+                }
+            }
+        } else {
+            None
+        };
+        let mut row = Vec::with_capacity(ncat);
+        for j in 0..ncat {
+            let v = s.values.get(j).copied().flatten();
+            let span = match (si.and_then(|p| stacks.get_mut(p)), fam) {
+                (Some((_, pos, neg)), Fam::ColStack | Fam::Col100) => v.and_then(|v| {
+                    let v = if fam == Fam::Col100 { share(key, j, v) } else { v };
+                    let acc = if v >= 0.0 { pos.get_mut(j) } else { neg.get_mut(j) }?;
+                    let base = *acc;
+                    *acc += v;
+                    Some((base, *acc))
+                }),
+                (Some((_, pos, _)), _) => {
+                    let v = v.unwrap_or(0.0);
+                    let v = if fam == Fam::Area100 { share(key, j, v) } else { v };
+                    pos.get_mut(j).map(|acc| {
+                        let base = *acc;
+                        *acc = clean(*acc + v);
+                        (base, *acc)
+                    })
+                }
+                (None, _) => v.map(|v| (0.0, v)),
+            };
+            row.push(span);
+        }
+        spans.push(row);
+    }
+
+    // Axis scales.
+    let mut axes: Vec<(Scale, Fmt)> = Vec::new();
+    for axis in [false, true] {
+        let members: Vec<usize> = (0..data.series.len()).filter(|i| sec.get(*i).copied().unwrap_or(false) == axis).collect();
+        if members.is_empty() {
+            continue;
+        }
+        let force_zero = members.iter().any(|i| fams.get(*i).is_some_and(|f| !is_line(*f)));
+        let all100 = members.iter().all(|i| fams.get(*i).is_some_and(|f| is_100(*f)));
+        let range = value_range(members.iter().flat_map(|i| {
+            let line = fams.get(*i).is_some_and(|f| is_line(*f));
+            spans.get(*i).into_iter().flatten().flatten().flat_map(move |(b, t)| if line { vec![*t] } else { vec![*b, *t] })
+        }));
+        let (lo, hi) = range.unwrap_or((0.0, 0.0));
+        let (scale, fmt) = if all100 {
+            (fixed_scale(if lo < -1e-9 { -1.0 } else { 0.0 }, if hi > 1e-9 || lo >= -1e-9 { 1.0 } else { 0.0 }, 0.2), Fmt::new("0%"))
+        } else {
+            let code = members.first().and_then(|i| data.series.get(*i)).map(|s| s.number_format.as_str()).unwrap_or("General");
+            (nice_scale(lo, hi, force_zero), Fmt::new(code))
+        };
+        axes.push((scale, fmt));
+        if !axis && sec.iter().all(|s| !s) {
+            break;
+        }
+    }
+    let Some((s1, f1)) = axes.first() else { return };
+    let y1 = ValAxis { scale: *s1, fmt: f1 };
+    let y2 = axes.get(1).map(|(s, f)| ValAxis { scale: *s, fmt: f });
+    // A forward forecast on a category axis adds empty category slots after the data.
+    let fwd = data
+        .series
+        .iter()
+        .enumerate()
+        .filter(|(i, _)| kinds.get(*i).is_some_and(|k| supports_trendline(*k)))
+        .map(|(_, s)| max_forward(s))
+        .fold(0.0, f64::max);
+    let ncat_slots = ncat.saturating_add(fwd.min(max_forward_slots(ncat)).ceil() as usize).min(MAX_CATS.max(ncat));
+    let labels: Vec<String> = (0..ncat_slots).map(|j| if j < ncat { cat_label(data, j) } else { String::new() }).collect();
+    // Outer levels padded to the slots (forecast slots stay in the last group).
+    let outer: Vec<Vec<String>> =
+        data.category_levels.iter().map(|l| (0..ncat_slots).map(|j| l.get(j).cloned().unwrap_or_default()).collect()).collect();
+    let plot = frame(ctx, area, CatAxis::Labels(&labels, &outer), &y1, y2.as_ref(), horizontal, chart.gridlines);
+    if !plot.ok() {
+        return;
+    }
+    let scale_of = |i: usize| -> Scale { if sec.get(i).copied().unwrap_or(false) { y2.as_ref().map(|a| a.scale).unwrap_or(*s1) } else { *s1 } };
+    let cat_len = if horizontal { plot.h } else { plot.w };
+    let cw = cat_len / ncat_slots as f32;
+    let center = |j: usize| if horizontal { plot.bottom() - (j as f32 + 0.5) * cw } else { plot.x + (j as f32 + 0.5) * cw };
+    let vpos = |v: f64, sc: &Scale| if horizontal { plot.x + sc.frac(v) * plot.w } else { plot.bottom() - sc.frac(v) * plot.h };
+
+    // Column slots: each clustered series gets one, each stack group shares one.
+    let mut slot_keys: Vec<(bool, Fam, usize)> = Vec::new();
+    let mut slot_of = vec![0usize; data.series.len()];
+    for (i, f) in fams.iter().enumerate() {
+        if !is_col(*f) {
+            continue;
+        }
+        let a = sec.get(i).copied().unwrap_or(false);
+        let key = if *f == Fam::Col { (a, *f, i) } else { (a, *f, usize::MAX) };
+        let k = match slot_keys.iter().position(|k| *k == key) {
+            Some(p) => p,
+            None => {
+                slot_keys.push(key);
+                slot_keys.len() - 1
+            }
+        };
+        if let Some(s) = slot_of.get_mut(i) {
+            *s = k;
+        }
+    }
+    let nslots = slot_keys.len().max(1) as f32;
+    let bw = cw / (nslots + 1.5);
+    let labels_on = chart.data_labels && ncat <= MAX_LABELS;
+    // Area labels wait until every area is filled, so a later (stacked) area can't paint over them.
+    let mut area_labels = Vec::new();
+
+    // Areas first, then columns, then lines on top.
+    for pass in 0..3 {
+        for (i, s) in data.series.iter().enumerate() {
+            let fam = fams.get(i).copied().unwrap_or(Fam::Col);
+            let want = match pass {
+                0 => matches!(fam, Fam::Area | Fam::AreaStack | Fam::Area100),
+                1 => is_col(fam),
+                _ => is_line(fam),
+            };
+            if !want {
+                continue;
+            }
+            let sc = scale_of(i);
+            let fmt = Fmt::new(&s.number_format);
+            let row = match spans.get(i) {
+                Some(r) => r,
+                None => continue,
+            };
+            match pass {
+                0 => {
+                    let mut top = Vec::with_capacity(ncat * 2);
+                    let mut base = Vec::with_capacity(ncat);
+                    for (j, sp) in row.iter().enumerate() {
+                        let (b, t) = sp.unwrap_or((0.0, 0.0));
+                        let c = center(j);
+                        top.push([c, vpos(t, &sc)]);
+                        base.push([c, vpos(b, &sc)]);
+                        // Source values (not stack totals), just above the top edge like the line labels.
+                        if labels_on
+                            && sp.is_some()
+                            && let Some(v) = s.values.get(j).copied().flatten()
+                        {
+                            area_labels.push((c, vpos(t, &sc) - 5.0, fmt.format(v, None)));
+                        }
+                    }
+                    if top.len() == 1 {
+                        // A single point: give it some width.
+                        if let (Some(t), Some(b)) = (top.first().copied(), base.first().copied()) {
+                            top = vec![[t[0] - cw * 0.3, t[1]], [t[0] + cw * 0.3, t[1]]];
+                            base = vec![[b[0] - cw * 0.3, b[1]], [b[0] + cw * 0.3, b[1]]];
+                        }
+                    }
+                    let top = decimate(top, MAX_LINE_PTS * 2);
+                    let base = decimate(base, MAX_LINE_PTS * 2);
+                    let mut poly = top;
+                    poly.extend(base.into_iter().rev());
+                    if poly.len() >= 3 {
+                        ctx.out.push(Prim::Polygon { pts: poly, fill: s.color, stroke: None });
+                    }
+                }
+                1 => {
+                    let k = slot_of.get(i).copied().unwrap_or(0) as f32;
+                    for (j, sp) in row.iter().enumerate() {
+                        let Some((b, t)) = sp else { continue };
+                        let (pb, pt) = (vpos(*b, &sc), vpos(*t, &sc));
+                        let c = center(j);
+                        let lo = pb.min(pt);
+                        let len = (pb - pt).abs();
+                        if horizontal {
+                            let y = c + nslots * bw / 2.0 - (k + 1.0) * bw;
+                            ctx.rect(lo, y, len, bw, s.color, None);
+                        } else {
+                            let x = c - nslots * bw / 2.0 + k * bw;
+                            ctx.rect(x, lo, bw, len, s.color, None);
+                        }
+                        if labels_on && let Some(v) = s.values.get(j).copied().flatten() {
+                            let t = fmt.format(v, None);
+                            let stacked = fam != Fam::Col;
+                            let mid = (pb + pt) / 2.0;
+                            if horizontal {
+                                let y = c + nslots * bw / 2.0 - (k + 0.5) * bw;
+                                if stacked {
+                                    ctx.text(mid, y, &t, LABEL_SIZE, on(s.color), HAlign::Center, VAlign::Middle);
+                                } else if v >= 0.0 {
+                                    ctx.text(pb.max(pt) + 3.0, y, &t, LABEL_SIZE, TEXT, HAlign::Left, VAlign::Middle);
+                                } else {
+                                    ctx.text(lo - 3.0, y, &t, LABEL_SIZE, TEXT, HAlign::Right, VAlign::Middle);
+                                }
+                            } else {
+                                let x = c - nslots * bw / 2.0 + (k + 0.5) * bw;
+                                if stacked {
+                                    ctx.text(x, mid, &t, LABEL_SIZE, on(s.color), HAlign::Center, VAlign::Middle);
+                                } else if v >= 0.0 {
+                                    ctx.text(x, lo - 2.0, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+                                } else {
+                                    ctx.text(x, lo + len + 2.0, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Top);
+                                }
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    let pts: Vec<Option<[f32; 2]>> = row.iter().enumerate().map(|(j, sp)| sp.map(|(_, t)| [center(j), vpos(t, &sc)])).collect();
+                    draw_runs(ctx, &pts, s.color, 2.25, s.smooth.then_some(plot));
+                    let k = kinds.get(i).copied().unwrap_or(ChartKind::Line);
+                    if k == ChartKind::LineMarkers && cw >= 3.0 {
+                        draw_markers(ctx, pts.iter().flatten().copied(), 3.5, s.color);
+                    }
+                    if labels_on {
+                        for (j, p) in pts.iter().enumerate() {
+                            if let (Some(p), Some(v)) = (p, s.values.get(j).copied().flatten()) {
+                                ctx.text(p[0], p[1] - 5.0, &fmt.format(v, None), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (x, y, t) in area_labels.drain(..) {
+            ctx.text(x, y, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+        }
+    }
+    // Trendlines on top: x is the category number 1..n.
+    let mut trend_labels = Vec::new();
+    for (i, s) in data.series.iter().enumerate() {
+        if s.trendlines.is_empty() || !kinds.get(i).is_some_and(|k| supports_trendline(*k)) {
+            continue;
+        }
+        let sc = scale_of(i);
+        let pts: Vec<(f64, f64)> = s.values.iter().take(ncat).enumerate().filter_map(|(j, v)| v.map(|v| ((j + 1) as f64, v))).collect();
+        let frac = |x: f64, y: f64| ((x - 0.5) / ncat_slots as f64, (y - sc.min) / (sc.max - sc.min));
+        let px = |(fx, fy): (f64, f64)| {
+            if horizontal {
+                [plot.x + fy as f32 * plot.w, plot.bottom() - fx as f32 * plot.h]
+            } else {
+                [plot.x + fx as f32 * plot.w, plot.bottom() - fy as f32 * plot.h]
+            }
+        };
+        draw_trendlines(ctx, s, &pts, &frac, &px, &mut trend_labels, (0.5, ncat_slots as f64 + 0.5));
+    }
+    draw_trend_labels(ctx, plot, &trend_labels);
+}
+
+// ---------------------------------------------------------------- scatter & bubble
+
+pub(super) fn scatter(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let pts_of = |s: &SeriesData| -> Vec<Option<(f64, f64)>> {
+        s.values
+            .iter()
+            .enumerate()
+            .map(|(j, v)| {
+                let x = match &s.x {
+                    Some(xs) => xs.get(j).copied().flatten(),
+                    None => Some((j + 1) as f64),
+                };
+                match (x, v) {
+                    (Some(x), Some(y)) => Some((x, *y)),
+                    _ => None,
+                }
+            })
+            .collect()
+    };
+    let all: Vec<Vec<Option<(f64, f64)>>> = data.series.iter().map(pts_of).collect();
+    let Some((mut xlo, mut xhi)) = value_range(all.iter().flatten().flatten().map(|p| p.0)) else { return };
+    // Forecasts extend the x axis to the trendline's ends.
+    for (s, pts) in data.series.iter().zip(&all) {
+        if let Some((lo, hi)) = value_range(pts.iter().flatten().map(|p| p.0)).filter(|_| !s.trendlines.is_empty()) {
+            xlo = xlo.min(lo - max_backward(s));
+            xhi = xhi.max(hi + max_forward(s));
+        }
+    }
+    let Some((ylo, yhi)) = value_range(all.iter().flatten().flatten().map(|p| p.1)) else { return };
+    let xs = nice_scale(xlo, xhi, false);
+    let ys = nice_scale(ylo, yhi, false);
+    let fx = Fmt::new("General");
+    let fy = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
+    let plot = frame(ctx, area, CatAxis::Numeric(xs, &fx), &ValAxis { scale: ys, fmt: &fy }, None, false, chart.gridlines);
+    if !plot.ok() {
+        return;
+    }
+    let map = |(x, y): (f64, f64)| [plot.x + xs.frac(x) * plot.w, plot.bottom() - ys.frac(y) * plot.h];
+    let bubble = chart.kind == ChartKind::Bubble;
+    let rmax = plot.w.min(plot.h) * 0.12;
+    for (s, pts) in data.series.iter().zip(&all) {
+        let px: Vec<Option<[f32; 2]>> = pts.iter().map(|p| p.map(map)).collect();
+        if bubble {
+            let sizes = s.sizes.as_deref().unwrap_or(&[]);
+            let smax = sizes.iter().flatten().fold(0.0f64, |a, b| a.max(*b));
+            let mut bubbles: Vec<([f32; 2], f64)> = px
+                .iter()
+                .enumerate()
+                .filter_map(|(j, p)| {
+                    let sz = if sizes.is_empty() { Some(1.0) } else { sizes.get(j).copied().flatten() };
+                    match (p, sz) {
+                        (Some(p), Some(sz)) if sz > 0.0 => Some((*p, sz)),
+                        _ => None,
+                    }
+                })
+                .take(MAX_MARKERS)
+                .collect();
+            bubbles.sort_by(|a, b| b.1.total_cmp(&a.1));
+            let smax = if sizes.is_empty() { 1.0 } else { smax };
+            let fill = [s.color[0], s.color[1], s.color[2], 0xC0];
+            for (p, sz) in bubbles {
+                let r = ((sz / smax).sqrt() as f32 * rmax).max(1.0);
+                ctx.out.push(Prim::Circle { cx: p[0], cy: p[1], r, fill: Some(fill), stroke: Some((WHITE, 0.75)) });
+            }
+        } else {
+            let lines = chart.kind == ChartKind::ScatterLines || s.kind == ChartKind::ScatterLines;
+            if lines {
+                draw_runs(ctx, &px, s.color, 2.0, s.smooth.then_some(plot));
+            }
+            if !lines || px.len() <= 500 {
+                draw_markers(ctx, px.iter().flatten().copied(), 3.5, s.color);
+            }
+        }
+        if chart.data_labels && pts.len() <= MAX_LABELS {
+            for (p, raw) in px.iter().zip(pts) {
+                if let (Some(p), Some((_, y))) = (p, raw) {
+                    ctx.text(p[0], p[1] - 6.0, &fy.format(*y, None), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+                }
+            }
+        }
+    }
+    let mut trend_labels = Vec::new();
+    for (s, pts) in data.series.iter().zip(&all) {
+        if s.trendlines.is_empty() {
+            continue;
+        }
+        let pts: Vec<(f64, f64)> = pts.iter().flatten().copied().collect();
+        let frac = |x: f64, y: f64| ((x - xs.min) / (xs.max - xs.min), (y - ys.min) / (ys.max - ys.min));
+        let px = |(fx, fy): (f64, f64)| [plot.x + fx as f32 * plot.w, plot.bottom() - fy as f32 * plot.h];
+        draw_trendlines(ctx, s, &pts, &frac, &px, &mut trend_labels, (xs.min, xs.max));
+    }
+    draw_trend_labels(ctx, plot, &trend_labels);
+}
diff --git a/crates/chart/src/render/frame.rs b/crates/chart/src/render/frame.rs
new file mode 100644
index 000000000..7fa2a54a1
--- /dev/null
+++ b/crates/chart/src/render/frame.rs
@@ -0,0 +1,245 @@
+use super::*;
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct Bx {
+    pub(super) x: f32,
+    pub(super) y: f32,
+    pub(super) w: f32,
+    pub(super) h: f32,
+}
+
+impl Bx {
+    pub(super) fn right(&self) -> f32 {
+        self.x + self.w
+    }
+    pub(super) fn bottom(&self) -> f32 {
+        self.y + self.h
+    }
+    pub(super) fn ok(&self) -> bool {
+        self.w.is_finite() && self.h.is_finite() && self.w > 4.0 && self.h > 4.0
+    }
+    pub(super) fn cx(&self) -> f32 {
+        self.x + self.w / 2.0
+    }
+    pub(super) fn cy(&self) -> f32 {
+        self.y + self.h / 2.0
+    }
+}
+
+/// Text colour readable on `fill`.
+pub(super) fn on(fill: Rgba) -> Rgba {
+    let l = 0.299 * fill[0] as f32 + 0.587 * fill[1] as f32 + 0.114 * fill[2] as f32;
+    if l < 150.0 { WHITE } else { DARK_TEXT }
+}
+
+pub(super) fn chart_title(chart: &Chart, data: &ChartData) -> Option<String> {
+    match &chart.title {
+        Some(t) => Some(t.trim().to_string()).filter(|t| !t.is_empty()),
+        None if data.series.len() == 1 => data.series.first().map(|s| s.name.clone()).filter(|t| !t.is_empty()),
+        None => None,
+    }
+}
+
+pub(super) fn axis_titles(ctx: &mut Ctx, chart: &Chart, mut area: Bx) -> Bx {
+    let lh = AXIS_TITLE_SIZE * 1.4 + 2.0;
+    if let Some(t) = chart.x_title.as_deref().map(str::trim).filter(|t| !t.is_empty()) {
+        let t = ctx.fit(t, AXIS_TITLE_SIZE, area.w);
+        ctx.text(area.cx(), area.bottom(), &t, AXIS_TITLE_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+        area.h -= lh;
+    }
+    if let Some(t) = chart.y_title.as_deref().map(str::trim).filter(|t| !t.is_empty()) {
+        let t = ctx.fit(t, AXIS_TITLE_SIZE, area.h);
+        if !t.is_empty() {
+            ctx.out.push(Prim::Text {
+                x: area.x,
+                y: area.cy(),
+                text: t,
+                size: AXIS_TITLE_SIZE,
+                color: TEXT,
+                bold: false,
+                align: HAlign::Center,
+                valign: VAlign::Top,
+                rotation: -PI / 2.0,
+            });
+        }
+        area.x += lh;
+        area.w -= lh;
+    }
+    area
+}
+
+// ---------------------------------------------------------------- axes frame
+
+pub(super) enum CatAxis<'a> {
+    /// Category labels and, for a multi-level axis, the outer levels (nearest the labels first;
+    /// one entry per category, non-empty where a group starts).
+    Labels(&'a [String], &'a [Vec<String>]),
+    Numeric(Scale, &'a Fmt),
+}
+
+/// Groups of an outer category level: `(first, end)` index pairs, a group starting at every
+/// non-empty entry (and at the first category).
+fn level_groups(level: &[String], n: usize) -> Vec<(usize, usize)> {
+    let mut starts: Vec<usize> = (0..n).filter(|&j| j == 0 || level.get(j).is_some_and(|t| !t.is_empty())).collect();
+    starts.push(n);
+    starts.windows(2).filter_map(|w| Some((*w.first()?, *w.get(1)?))).collect()
+}
+
+pub(super) struct ValAxis<'a> {
+    pub(super) scale: Scale,
+    pub(super) fmt: &'a Fmt,
+}
+
+impl ValAxis<'_> {
+    fn labels(&self) -> Vec<(f64, String)> {
+        self.scale.ticks().into_iter().map(|v| (v, self.fmt.format(v, Some(self.scale.step)))).collect()
+    }
+}
+
+/// Draws gridlines, axis labels and the category axis line; returns the plot rectangle.
+pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Option<&ValAxis>, horizontal: bool, grid: bool) -> Bx {
+    let ls = LABEL_SIZE;
+    let lh = ls * 1.4;
+    let ylabels = y.labels();
+    let maxw = |ctx: &Ctx, l: &[(f64, String)]| l.iter().map(|(_, t)| ctx.tw(t, ls)).fold(0.0f32, f32::max);
+    if !horizontal {
+        let left = (maxw(ctx, &ylabels) + 6.0).min(area.w * 0.4);
+        let y2labels = y2.map(ValAxis::labels);
+        let right = match (&y2labels, &cat) {
+            (Some(l), _) => (maxw(ctx, l) + 6.0).min(area.w * 0.3),
+            (None, CatAxis::Numeric(s, f)) => (ctx.tw(&f.format(s.max, Some(s.step)), ls) / 2.0).min(area.w * 0.2),
+            _ => 4.0,
+        };
+        let levels = match &cat {
+            CatAxis::Labels(_, o) => o.len() as f32,
+            CatAxis::Numeric(..) => 0.0,
+        };
+        let plot = Bx { x: area.x + left, y: area.y + lh * 0.5, w: area.w - left - right, h: area.h - lh * 1.5 - 4.0 - lh * levels };
+        if !plot.ok() {
+            return plot;
+        }
+        for (v, t) in &ylabels {
+            let yy = plot.bottom() - y.scale.frac(*v) * plot.h;
+            if grid {
+                ctx.hline(plot.x, plot.right(), yy, GRID, 0.75);
+            }
+            ctx.text(plot.x - 4.0, yy, t, ls, TEXT, HAlign::Right, VAlign::Middle);
+        }
+        if let (Some(a), Some(l)) = (y2, &y2labels) {
+            for (v, t) in l {
+                let yy = plot.bottom() - a.scale.frac(*v) * plot.h;
+                ctx.text(plot.right() + 4.0, yy, t, ls, TEXT, HAlign::Left, VAlign::Middle);
+            }
+        }
+        let zero = if y.scale.min <= 0.0 && y.scale.max >= 0.0 { 0.0 } else { y.scale.min };
+        let y0 = plot.bottom() - y.scale.frac(zero) * plot.h;
+        ctx.hline(plot.x, plot.right(), y0, AXIS, 0.75);
+        match cat {
+            CatAxis::Labels(l, outer) => {
+                let n = l.len().max(1);
+                let cw = plot.w / n as f32;
+                let lw = l.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max);
+                let k = (((lw + 6.0) / cw.max(1e-3)).ceil() as usize).clamp(1, n);
+                for (j, t) in l.iter().enumerate().step_by(k) {
+                    let t = ctx.fit(t, ls, cw * k as f32 - 2.0);
+                    ctx.text(plot.x + (j as f32 + 0.5) * cw, plot.bottom() + 3.0, &t, ls, TEXT, HAlign::Center, VAlign::Top);
+                }
+                // Outer levels, one row each below the labels: a group's name centred under its
+                // categories, and a separator at each group boundary down through the rows.
+                for (i, level) in outer.iter().enumerate() {
+                    let top = plot.bottom() + 3.0 + lh * (i as f32 + 1.0);
+                    for (first, end) in level_groups(level, n) {
+                        let (x0, x1) = (plot.x + first as f32 * cw, plot.x + end as f32 * cw);
+                        if let Some(t) = level.get(first).filter(|t| !t.is_empty()) {
+                            let t = ctx.fit(t, ls, x1 - x0 - 2.0);
+                            ctx.text((x0 + x1) / 2.0, top, &t, ls, TEXT, HAlign::Center, VAlign::Top);
+                        }
+                        if first > 0 {
+                            ctx.vline(x0, plot.bottom(), top + lh - 2.0, AXIS, 0.75);
+                        }
+                    }
+                    ctx.vline(plot.right(), plot.bottom(), top + lh - 2.0, AXIS, 0.75);
+                }
+            }
+            CatAxis::Numeric(s, f) => {
+                let ticks = s.ticks();
+                let labels: Vec<String> = ticks.iter().map(|v| f.format(*v, Some(s.step))).collect();
+                let lw = labels.iter().map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max);
+                let slot = plot.w / ticks.len().max(1) as f32;
+                let k = (((lw + 6.0) / slot.max(1e-3)).ceil() as usize).max(1);
+                for (v, t) in ticks.iter().zip(&labels).step_by(k) {
+                    let xx = plot.x + s.frac(*v) * plot.w;
+                    ctx.text(xx, plot.bottom() + 3.0, t, ls, TEXT, HAlign::Center, VAlign::Top);
+                }
+                if s.min <= 0.0 && s.max >= 0.0 {
+                    let xx = plot.x + s.frac(0.0) * plot.w;
+                    ctx.vline(xx, plot.y, plot.bottom(), AXIS, 0.75);
+                }
+            }
+        }
+        plot
+    } else {
+        let (labels, outer): (Vec<String>, &[Vec<String>]) = match cat {
+            CatAxis::Labels(l, o) => (l.to_vec(), o),
+            CatAxis::Numeric(..) => (vec![], &[]),
+        };
+        let lw = (labels.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max) + 6.0).min(area.w * 0.35);
+        // Outer levels stand in columns left of the labels, each as wide as its longest name.
+        let level_w: Vec<f32> =
+            outer.iter().map(|l| (l.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max) + 6.0).min(area.w * 0.15)).collect();
+        let levels_w: f32 = level_w.iter().sum();
+        let right = ylabels.last().map(|(_, t)| ctx.tw(t, ls) / 2.0).unwrap_or(0.0).min(area.w * 0.2) + 2.0;
+        let plot = Bx { x: area.x + lw + levels_w, y: area.y + 2.0, w: area.w - lw - levels_w - right, h: area.h - lh - 6.0 };
+        if !plot.ok() {
+            return plot;
+        }
+        let vw = maxw(ctx, &ylabels);
+        let slot = plot.w / ylabels.len().max(1) as f32;
+        let k = (((vw + 6.0) / slot.max(1e-3)).ceil() as usize).max(1);
+        for (i, (v, t)) in ylabels.iter().enumerate() {
+            let xx = plot.x + y.scale.frac(*v) * plot.w;
+            if grid {
+                ctx.vline(xx, plot.y, plot.bottom(), GRID, 0.75);
+            }
+            if i % k == 0 {
+                ctx.text(xx, plot.bottom() + 3.0, t, ls, TEXT, HAlign::Center, VAlign::Top);
+            }
+        }
+        let zero = if y.scale.min <= 0.0 && y.scale.max >= 0.0 { 0.0 } else { y.scale.min };
+        let x0 = plot.x + y.scale.frac(zero) * plot.w;
+        ctx.vline(x0, plot.y, plot.bottom(), AXIS, 0.75);
+        let n = labels.len().max(1);
+        let ch = plot.h / n as f32;
+        let k = ((lh / ch.max(1e-3)).ceil() as usize).clamp(1, n);
+        for (j, t) in labels.iter().enumerate().step_by(k) {
+            let t = ctx.fit(t, ls, lw - 6.0);
+            ctx.text(plot.x - 4.0, plot.bottom() - (j as f32 + 0.5) * ch, &t, ls, TEXT, HAlign::Right, VAlign::Middle);
+        }
+        // Outer levels: a group's name centred beside its categories, separators at the
+        // boundaries running right to the axis.
+        let mut x1 = plot.x - lw;
+        for (level, w) in outer.iter().zip(&level_w) {
+            let x0 = x1 - w;
+            for (first, end) in level_groups(level, n) {
+                let (y0, y1) = (plot.bottom() - end as f32 * ch, plot.bottom() - first as f32 * ch);
+                if let Some(t) = level.get(first).filter(|t| !t.is_empty()) {
+                    let t = ctx.fit(t, ls, w - 4.0);
+                    ctx.text((x0 + x1) / 2.0, (y0 + y1) / 2.0, &t, ls, TEXT, HAlign::Center, VAlign::Middle);
+                }
+                if first > 0 {
+                    ctx.hline(x0, plot.x, y1, AXIS, 0.75);
+                }
+            }
+            ctx.hline(x0, plot.x, plot.y, AXIS, 0.75);
+            x1 = x0;
+        }
+        plot
+    }
+}
+
+pub(super) fn value_range(it: impl Iterator<Item = f64>) -> Option<(f64, f64)> {
+    it.fold(None, |acc, v| match acc {
+        None => Some((v, v)),
+        Some((a, b)) => Some((a.min(v), b.max(v))),
+    })
+}
diff --git a/crates/chart/src/render/kinds.rs b/crates/chart/src/render/kinds.rs
new file mode 100644
index 000000000..2ffbfa3dd
--- /dev/null
+++ b/crates/chart/src/render/kinds.rs
@@ -0,0 +1,505 @@
+use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range};
+use super::legend::{cat_label, point_color};
+use super::*;
+
+// ---------------------------------------------------------------- histogram
+
+pub(super) fn histogram(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let Some(s) = data.series.first() else { return };
+    let vals: Vec<f64> = s.values.iter().flatten().copied().collect();
+    let Some((lo, hi)) = value_range(vals.iter().copied()) else { return };
+    let n = vals.len();
+    let span = hi - lo;
+    let mut bins = ((n as f64).sqrt().ceil() as usize).clamp(1, 100);
+    if !(span.is_finite() && span > 0.0) {
+        bins = 1;
+    }
+    let width = if bins == 1 && span.partial_cmp(&0.0) != Some(std::cmp::Ordering::Greater) { 1.0 } else { span / bins as f64 };
+    // Upper edge of each bin, exactly as shown in the labels below. Bins are right-inclusive (the first is closed on both sides), so a value
+    // equal to an edge belongs to the bin that ends there.
+    let edges: Vec<f64> = (0..bins).map(|b| if b + 1 == bins { hi.max(lo + b as f64 * width) } else { lo + (b + 1) as f64 * width }).collect();
+    let mut counts = vec![0usize; bins];
+    for v in &vals {
+        let b = edges.partition_point(|e| e < v).min(bins - 1);
+        if let Some(c) = counts.get_mut(b) {
+            *c += 1;
+        }
+    }
+    let f = Fmt::new(&s.number_format);
+    let labels: Vec<String> = (0..bins)
+        .map(|b| {
+            let a = lo + b as f64 * width;
+            let e = edges.get(b).copied().unwrap_or(a);
+            let open = if b == 0 { '[' } else { '(' };
+            format!("{open}{}, {}]", f.format(a, Some(width / 10.0)), f.format(e, Some(width / 10.0)))
+        })
+        .collect();
+    let maxc = counts.iter().copied().max().unwrap_or(0) as f64;
+    let ys = nice_scale(0.0, maxc, true);
+    let fc = Fmt::new("General");
+    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &fc }, None, false, chart.gridlines);
+    if !plot.ok() {
+        return;
+    }
+    let cw = plot.w / bins as f32;
+    for (b, c) in counts.iter().enumerate() {
+        let top = plot.bottom() - ys.frac(*c as f64) * plot.h;
+        let x = plot.x + b as f32 * cw;
+        ctx.rect(x, top, cw, plot.bottom() - top, s.color, Some((WHITE, 0.75)));
+        if chart.data_labels {
+            ctx.text(x + cw / 2.0, top - 2.0, &c.to_string(), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+        }
+    }
+}
+
+// ---------------------------------------------------------------- waterfall
+
+pub(super) fn waterfall(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let Some(s) = data.series.first() else { return };
+    let mut ncat = data.categories.len().max(s.values.len()).min(MAX_CATS);
+    if ncat == 0 {
+        return;
+    }
+    let mut labels: Vec<String> = (0..ncat).map(|j| cat_label(data, j)).collect();
+    let mut vals: Vec<f64> = (0..ncat).map(|j| s.values.get(j).copied().flatten().unwrap_or(0.0)).collect();
+    let mut is_total = vec![false; ncat];
+    let last_total = labels.last().is_some_and(|l| l.to_lowercase().contains("total"));
+    if let Some(t) = is_total.last_mut() {
+        *t = last_total;
+    }
+    if !last_total {
+        labels.push("Total".into());
+        vals.push(0.0);
+        is_total.push(true);
+        ncat += 1;
+    }
+    let mut bars = Vec::with_capacity(ncat);
+    let mut cum = 0.0f64;
+    for (j, v) in vals.iter().enumerate() {
+        if is_total.get(j).copied().unwrap_or(false) {
+            let total = if last_total && j + 1 == ncat && *v != 0.0 { *v } else { cum };
+            bars.push((0.0, total, 0u8));
+            cum = total;
+        } else {
+            let top = clean(cum + v);
+            bars.push((cum, top, if *v >= 0.0 { 1 } else { 2 }));
+            cum = top;
+        }
+    }
+    let (lo, hi) = value_range(bars.iter().flat_map(|(b, t, _)| [*b, *t])).unwrap_or((0.0, 0.0));
+    let ys = nice_scale(lo, hi, true);
+    let f = Fmt::new(&s.number_format);
+    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &f }, None, false, chart.gridlines);
+    if !plot.ok() {
+        return;
+    }
+    let cw = plot.w / ncat as f32;
+    let bw = cw / 1.5;
+    let vy = |v: f64| plot.bottom() - ys.frac(v) * plot.h;
+    for (j, (b, t, kind)) in bars.iter().enumerate() {
+        let color = match kind {
+            1 => UP,
+            2 => DOWN,
+            _ => s.color,
+        };
+        let x = plot.x + (j as f32 + 0.5) * cw - bw / 2.0;
+        let (yb, yt) = (vy(*b), vy(*t));
+        ctx.rect(x, yb.min(yt), bw, (yb - yt).abs().max(0.5), color, None);
+        if j + 1 < bars.len() && ncat <= 500 {
+            ctx.out.push(Prim::Line { pts: vec![[x + bw, yt], [x + cw, yt]], color: AXIS, width: 0.75, dash: true });
+        }
+        if chart.data_labels && ncat <= MAX_LABELS {
+            let v = if *kind == 0 { *t } else { t - b };
+            ctx.text(x + bw / 2.0, yb.min(yt) - 2.0, &f.format(v, None), LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+        }
+    }
+}
+
+// ---------------------------------------------------------------- funnel
+
+pub(super) fn funnel(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let Some(s) = data.series.first() else { return };
+    let n = data.categories.len().max(s.values.len()).min(MAX_CATS);
+    if n == 0 {
+        return;
+    }
+    let vals: Vec<f64> = (0..n).map(|j| s.values.get(j).copied().flatten().unwrap_or(0.0).abs()).collect();
+    let max = vals.iter().copied().fold(0.0f64, f64::max);
+    if max.is_nan() || max <= 0.0 {
+        return;
+    }
+    let labels: Vec<String> = (0..n).map(|j| cat_label(data, j)).collect();
+    let lw = (labels.iter().take(2000).map(|t| ctx.tw(t, LABEL_SIZE)).fold(0.0f32, f32::max) + 8.0).min(area.w * 0.35);
+    let plot = Bx { x: area.x + lw, w: area.w - lw, ..area };
+    if !plot.ok() {
+        return;
+    }
+    let slot = plot.h / n as f32;
+    let bh = slot * 0.85;
+    let f = Fmt::new(&s.number_format);
+    let show = slot >= LABEL_SIZE * 0.9;
+    for (j, v) in vals.iter().enumerate() {
+        let bw = (*v / max) as f32 * plot.w;
+        let x = plot.x + (plot.w - bw) / 2.0;
+        let y = plot.y + j as f32 * slot + (slot - bh) / 2.0;
+        if bw > 0.0 {
+            ctx.rect(x, y, bw, bh, s.color, None);
+        }
+        if show {
+            let yc = y + bh / 2.0;
+            if chart.data_labels {
+                let t = f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None);
+                let color = if ctx.tw(&t, LABEL_SIZE) + 4.0 <= bw { on(s.color) } else { TEXT };
+                ctx.text(plot.cx(), yc, &t, LABEL_SIZE, color, HAlign::Center, VAlign::Middle);
+            }
+            let l = ctx.fit(labels.get(j).map(String::as_str).unwrap_or(""), LABEL_SIZE, lw - 8.0);
+            ctx.text(plot.x - 6.0, yc, &l, LABEL_SIZE, TEXT, HAlign::Right, VAlign::Middle);
+        }
+    }
+}
+
+// ---------------------------------------------------------------- pie, doughnut, sunburst
+
+pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inner: f32, names: bool) {
+    let Some(s) = data.series.first() else { return };
+    let vals: Vec<f64> = s.values.iter().take(MAX_CATS).map(|v| v.map(f64::abs).unwrap_or(0.0)).collect();
+    let total: f64 = vals.iter().sum();
+    if !(total.is_finite() && total > 0.0) {
+        return;
+    }
+    let (cx, cy) = (area.cx(), area.cy());
+    let r = area.w.min(area.h) / 2.0 * 0.92;
+    if r < 2.0 {
+        return;
+    }
+    let ri = r * inner;
+    let f = Fmt::new(&s.number_format);
+    let mut a = 0.0f32;
+    let mut labels = Vec::new();
+    for (j, v) in vals.iter().enumerate() {
+        let sweep = (*v / total) as f32 * TAU;
+        if sweep > 1e-4 {
+            let fill = point_color(data, j);
+            ctx.out.push(Prim::Wedge { cx, cy, r_outer: r, r_inner: ri, a0: a, a1: (a + sweep).min(TAU), fill, stroke: Some((WHITE, 1.5)) });
+            if (chart.data_labels || names) && vals.len() <= MAX_LABELS {
+                let t = if names { cat_label(data, j) } else { f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None) };
+                let mid = a + sweep / 2.0;
+                let rr = if ri > 0.0 { (r + ri) / 2.0 } else { r * 0.65 };
+                let room = sweep * rr;
+                if ctx.tw(&t, LABEL_SIZE) <= room.max(r - ri) && room >= LABEL_SIZE {
+                    labels.push((cx + rr * mid.sin(), cy - rr * mid.cos(), t, on(fill)));
+                }
+            }
+        }
+        a += sweep;
+    }
+    for (x, y, t, c) in labels {
+        ctx.text(x, y, &t, LABEL_SIZE, c, HAlign::Center, VAlign::Middle);
+    }
+}
+
+// ---------------------------------------------------------------- treemap
+
+fn worst(row: &[f64], side: f64) -> f64 {
+    let s: f64 = row.iter().sum();
+    if s <= 0.0 || side <= 0.0 {
+        return f64::INFINITY;
+    }
+    let (mn, mx) = row.iter().fold((f64::INFINITY, 0.0f64), |(a, b), v| (a.min(*v), b.max(*v)));
+    let s2 = s * s;
+    let w2 = side * side;
+    (w2 * mx / s2).max(s2 / (w2 * mn))
+}
+
+/// Squarified treemap layout of (index, area) items, sorted descending, into `r`.
+fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
+    let total: f64 = items.iter().map(|i| i.1).sum();
+    let area = (r.w as f64) * (r.h as f64);
+    if !(total > 0.0 && area > 0.0) {
+        return vec![];
+    }
+    let scale = area / total;
+    let mut out = Vec::with_capacity(items.len());
+    let mut rem = r;
+    let mut row: Vec<(usize, f64)> = Vec::new();
+    let mut i = 0;
+    let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| {
+        let s: f64 = row.iter().map(|x| x.1).sum();
+        if s <= 0.0 {
+            return;
+        }
+        if rem.w >= rem.h {
+            let cw = (s / rem.h.max(1e-6) as f64) as f32;
+            let mut y = rem.y;
+            for (j, a) in row {
+                let h = (*a / cw.max(1e-6) as f64) as f32;
+                out.push((*j, Bx { x: rem.x, y, w: cw, h }));
+                y += h;
+            }
+            rem.x += cw;
+            rem.w = (rem.w - cw).max(0.0);
+        } else {
+            let rh = (s / rem.w.max(1e-6) as f64) as f32;
+            let mut x = rem.x;
+            for (j, a) in row {
+                let w = (*a / rh.max(1e-6) as f64) as f32;
+                out.push((*j, Bx { x, y: rem.y, w, h: rh }));
+                x += w;
+            }
+            rem.y += rh;
+            rem.h = (rem.h - rh).max(0.0);
+        }
+    };
+    while let Some(&(j, v)) = items.get(i) {
+        let a = v * scale;
+        let side = rem.w.min(rem.h) as f64;
+        let cur: Vec<f64> = row.iter().map(|x| x.1).collect();
+        let mut with = cur.clone();
+        with.push(a);
+        if row.is_empty() || worst(&with, side) <= worst(&cur, side) {
+            row.push((j, a));
+            i += 1;
+        } else {
+            layout(&row, &mut rem, &mut out);
+            row.clear();
+        }
+    }
+    if !row.is_empty() {
+        layout(&row, &mut rem, &mut out);
+    }
+    out
+}
+
+pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let Some(s) = data.series.first() else { return };
+    let mut items: Vec<(usize, f64)> =
+        s.values.iter().take(MAX_MARKERS).enumerate().filter_map(|(j, v)| v.filter(|v| *v > 0.0).map(|v| (j, v))).collect();
+    items.sort_by(|a, b| b.1.total_cmp(&a.1));
+    let f = Fmt::new(&s.number_format);
+    for (j, b) in squarify(&items, area) {
+        let fill = point_color(data, j);
+        ctx.rect(b.x, b.y, b.w, b.h, fill, Some((WHITE, 1.5)));
+        if b.w > 24.0 && b.h > LABEL_SIZE * 1.6 {
+            let name = ctx.fit(&cat_label(data, j), LABEL_SIZE, b.w - 8.0);
+            ctx.text(b.x + 4.0, b.y + 4.0, &name, LABEL_SIZE, on(fill), HAlign::Left, VAlign::Top);
+            if chart.data_labels && b.h > LABEL_SIZE * 3.2 {
+                let v = items.iter().find(|x| x.0 == j).map(|x| x.1).unwrap_or(0.0);
+                let t = ctx.fit(&f.format(v, None), LABEL_SIZE, b.w - 8.0);
+                ctx.text(b.x + 4.0, b.y + 4.0 + LABEL_SIZE * 1.4, &t, LABEL_SIZE, on(fill), HAlign::Left, VAlign::Top);
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------- radar
+
+pub(super) fn radar(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let ncat = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).min(1000);
+    if ncat == 0 {
+        return;
+    }
+    let labels: Vec<String> = (0..ncat).map(|j| cat_label(data, j)).collect();
+    let lw = labels.iter().map(|t| ctx.tw(t, LABEL_SIZE)).fold(0.0f32, f32::max).min(area.w * 0.2);
+    let r = ((area.w - 2.0 * (lw + 8.0)).min(area.h - 2.0 * (LABEL_SIZE * 1.4 + 6.0)) / 2.0).max(0.0);
+    if r < 5.0 {
+        return;
+    }
+    let (cx, cy) = (area.cx(), area.cy());
+    let (lo, hi) = value_range(data.series.iter().flat_map(|s| s.values.iter().flatten().copied())).unwrap_or((0.0, 0.0));
+    let sc = nice_scale(lo, hi, true);
+    let f = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
+    let ang = |j: usize| j as f32 / ncat as f32 * TAU;
+    let pt = |a: f32, rr: f32| [cx + rr * a.sin(), cy - rr * a.cos()];
+    let ticks = sc.ticks();
+    let spacing = r / ticks.len().saturating_sub(1).max(1) as f32;
+    let every = ((LABEL_SIZE * 1.3 / spacing.max(1e-3)).ceil() as usize).max(1);
+    for (ti, t) in ticks.into_iter().enumerate() {
+        let rr = sc.frac(t) * r;
+        if rr > 0.5 && chart.gridlines {
+            let mut ring: Vec<[f32; 2]> = (0..ncat).map(|j| pt(ang(j), rr)).collect();
+            if ncat < 3 {
+                ring = (0..=48).map(|k| pt(k as f32 / 48.0 * TAU, rr)).collect();
+            } else if let Some(p) = ring.first().copied() {
+                ring.push(p);
+            }
+            ctx.line(ring, GRID, 0.75);
+        }
+        if ti % every == 0 {
+            ctx.text(cx - 3.0, cy - rr, &f.format(t, Some(sc.step)), LABEL_SIZE * 0.9, TEXT, HAlign::Right, VAlign::Middle);
+        }
+    }
+    let step = ncat.div_ceil(72).max(1);
+    for j in (0..ncat).step_by(step) {
+        let a = ang(j);
+        ctx.line(vec![[cx, cy], pt(a, r)], GRID, 0.75);
+        let p = pt(a, r + 6.0);
+        let (sa, ca) = (a.sin(), a.cos());
+        let align = if sa > 0.1 {
+            HAlign::Left
+        } else if sa < -0.1 {
+            HAlign::Right
+        } else {
+            HAlign::Center
+        };
+        let valign = if ca > 0.1 {
+            VAlign::Bottom
+        } else if ca < -0.1 {
+            VAlign::Top
+        } else {
+            VAlign::Middle
+        };
+        let t = ctx.fit(labels.get(j).map(String::as_str).unwrap_or(""), LABEL_SIZE, lw.max(20.0));
+        ctx.text(p[0], p[1], &t, LABEL_SIZE, TEXT, align, valign);
+    }
+    for s in &data.series {
+        let mut pts: Vec<[f32; 2]> = (0..ncat).map(|j| pt(ang(j), sc.frac(s.values.get(j).copied().flatten().unwrap_or(sc.min)) * r)).collect();
+        if let Some(p) = pts.first().copied() {
+            pts.push(p);
+        }
+        ctx.line(pts, s.color, 2.0);
+    }
+}
+
+// ---------------------------------------------------------------- box & whisker
+
+fn quantile(sorted: &[f64], q: f64, method: QuartileMethod) -> f64 {
+    let n = sorted.len();
+    if n == 0 {
+        return 0.0;
+    }
+    // Clamp exclusive ranks for short samples so one or two points remain drawable.
+    let pos = match method {
+        QuartileMethod::Inclusive => q * (n - 1) as f64,
+        QuartileMethod::Exclusive => (q * (n as f64 + 1.0) - 1.0).clamp(0.0, (n - 1) as f64),
+    };
+    let i = pos.floor() as usize;
+    let frac = pos - i as f64;
+    let a = sorted.get(i).copied().unwrap_or(0.0);
+    let b = sorted.get(i + 1).copied().unwrap_or(a);
+    a + (b - a) * frac
+}
+
+pub(super) fn box_whisker(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let labels: Vec<String> = data.series.iter().map(|s| s.name.clone()).collect();
+    let Some((lo, hi)) = value_range(data.series.iter().flat_map(|s| s.values.iter().flatten().copied())) else { return };
+    let ys = nice_scale(lo, hi, false);
+    let f = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
+    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &f }, None, false, chart.gridlines);
+    if !plot.ok() {
+        return;
+    }
+    let n = data.series.len().max(1);
+    let cw = plot.w / n as f32;
+    let bw = (cw * 0.4).min(80.0);
+    let vy = |v: f64| plot.bottom() - ys.frac(v) * plot.h;
+    for (i, s) in data.series.iter().enumerate() {
+        let mut v: Vec<f64> = s.values.iter().flatten().copied().collect();
+        if v.is_empty() {
+            continue;
+        }
+        v.sort_by(f64::total_cmp);
+        let method = chart.series.get(i).map(|s| s.quartiles).unwrap_or_default();
+        let (q1, med, q3) = (quantile(&v, 0.25, method), quantile(&v, 0.5, method), quantile(&v, 0.75, method));
+        let iqr = q3 - q1;
+        let (flo, fhi) = (q1 - 1.5 * iqr, q3 + 1.5 * iqr);
+        let wlo = v.iter().copied().find(|x| *x >= flo).unwrap_or(q1);
+        let whi = v.iter().rev().copied().find(|x| *x <= fhi).unwrap_or(q3);
+        let mean = v.iter().sum::<f64>() / v.len() as f64;
+        let c = plot.x + (i as f32 + 0.5) * cw;
+        ctx.vline(c, vy(whi), vy(q3), s.color, 1.25);
+        ctx.vline(c, vy(q1), vy(wlo), s.color, 1.25);
+        ctx.hline(c - bw / 4.0, c + bw / 4.0, vy(whi), s.color, 1.25);
+        ctx.hline(c - bw / 4.0, c + bw / 4.0, vy(wlo), s.color, 1.25);
+        let (yt, yb) = (vy(q3), vy(q1));
+        ctx.rect(c - bw / 2.0, yt, bw, (yb - yt).max(0.5), s.color, None);
+        ctx.hline(c - bw / 2.0, c + bw / 2.0, vy(med), WHITE, 1.5);
+        let (mx, my, d) = (c, vy(mean), 3.0);
+        ctx.line(vec![[mx - d, my - d], [mx + d, my + d]], WHITE, 1.25);
+        ctx.line(vec![[mx - d, my + d], [mx + d, my - d]], WHITE, 1.25);
+        for o in v.iter().filter(|x| **x < flo || **x > fhi).take(MAX_MARKERS) {
+            ctx.out.push(Prim::Circle { cx: c, cy: vy(*o), r: 2.5, fill: None, stroke: Some((s.color, 1.0)) });
+        }
+    }
+}
+
+// ---------------------------------------------------------------- stock
+
+pub(super) fn stock(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
+    let ncat = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0)).min(MAX_CATS);
+    if ncat == 0 {
+        return;
+    }
+    let labels: Vec<String> = (0..ncat).map(|j| cat_label(data, j)).collect();
+    let Some((lo, hi)) = value_range(data.series.iter().flat_map(|s| s.values.iter().flatten().copied())) else { return };
+    let ys = nice_scale(lo, hi, false);
+    let f = Fmt::new(data.series.first().map(|s| s.number_format.as_str()).unwrap_or("General"));
+    let plot = frame(ctx, area, CatAxis::Labels(&labels, &[]), &ValAxis { scale: ys, fmt: &f }, None, false, chart.gridlines);
+    if !plot.ok() {
+        return;
+    }
+    let ser = |k: usize| data.series.get(k);
+    let (open, high, low, close) = match data.series.len() {
+        0 => return,
+        1 => (None, None, None, ser(0)),
+        2 => (None, ser(0), ser(1), None),
+        3 => (None, ser(0), ser(1), ser(2)),
+        _ => (ser(0), ser(1), ser(2), ser(3)),
+    };
+    let get = |s: Option<&SeriesData>, j: usize| s.and_then(|s| s.values.get(j).copied().flatten());
+    let cw = plot.w / ncat as f32;
+    let tick = (cw * 0.25).max(1.0);
+    let vy = |v: f64| plot.bottom() - ys.frac(v) * plot.h;
+    for j in 0..ncat {
+        let c = plot.x + (j as f32 + 0.5) * cw;
+        if let (Some(h), Some(l)) = (get(high, j), get(low, j)) {
+            ctx.vline(c, vy(h), vy(l), STOCK, 1.25);
+        }
+        match (get(open, j), get(close, j)) {
+            (Some(o), Some(cl)) => {
+                let (yo, yc) = (vy(o), vy(cl));
+                let bw = (cw * 0.5).max(1.0);
+                let fill = if cl >= o { WHITE } else { STOCK };
+                ctx.rect(c - bw / 2.0, yo.min(yc), bw, (yo - yc).abs().max(0.75), fill, Some((STOCK, 1.0)));
+            }
+            (None, Some(cl)) => {
+                if high.is_some() {
+                    ctx.hline(c, c + tick, vy(cl), STOCK, 1.25);
+                } else {
+                    ctx.out.push(Prim::Circle { cx: c, cy: vy(cl), r: 2.5, fill: Some(STOCK), stroke: None });
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod quartile_tests {
+    use super::*;
+
+    #[test]
+    fn box_whisker_default_quartiles_are_exclusive() {
+        let values = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
+        assert_eq!(quantile(&values, 0.25, QuartileMethod::default()), 1.75);
+        assert_eq!(quantile(&values, 0.5, QuartileMethod::default()), 3.5);
+        assert_eq!(quantile(&values, 0.75, QuartileMethod::default()), 5.25);
+    }
+
+    #[test]
+    fn quartile_methods_and_short_samples() {
+        for (values, exclusive, inclusive) in [
+            (vec![1., 2., 3.], (1., 3.), (1.5, 2.5)),
+            (vec![1., 2., 3., 4.], (1.25, 3.75), (1.75, 3.25)),
+            (vec![1., 2., 3., 4., 5.], (1.5, 4.5), (2., 4.)),
+            (vec![1., 2., 3., 4., 5., 6., 7.], (2., 6.), (2.5, 5.5)),
+            (vec![1., 1., 2., 3., 5., 8.], (1., 5.75), (1.25, 4.5)),
+            (vec![1., 2.], (1., 2.), (1.25, 1.75)),
+            (vec![1.], (1., 1.), (1., 1.)),
+            (vec![], (0., 0.), (0., 0.)),
+        ] {
+            for (method, expected) in [(QuartileMethod::Exclusive, exclusive), (QuartileMethod::Inclusive, inclusive)] {
+                assert_eq!((quantile(&values, 0.25, method), quantile(&values, 0.75, method)), expected);
+            }
+        }
+    }
+}
diff --git a/crates/chart/src/render/legend.rs b/crates/chart/src/render/legend.rs
new file mode 100644
index 000000000..95cb39d48
--- /dev/null
+++ b/crates/chart/src/render/legend.rs
@@ -0,0 +1,161 @@
+use super::frame::Bx;
+use super::trend::supports_trendline;
+use super::*;
+
+/// How a legend entry's swatch is drawn.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Swatch {
+    Box,
+    Line,
+    LineMarker,
+    Marker,
+}
+
+/// The kind a series is drawn as (per-series kinds only apply to combo charts).
+pub(super) fn plot_kind(chart: &Chart, s: &SeriesData) -> ChartKind {
+    if chart.kind == ChartKind::Combo { if s.kind == ChartKind::Combo { ChartKind::Line } else { s.kind } } else { chart.kind }
+}
+
+/// Colour of point `j` for charts that colour by point (pie, doughnut, treemap, sunburst).
+pub(super) fn point_color(data: &ChartData, j: usize) -> Rgba {
+    match (j, data.series.first()) {
+        (0, Some(s)) => s.color,
+        _ => j.checked_rem(data.palette.len()).and_then(|k| data.palette.get(k)).copied().unwrap_or_else(|| series_color(&Theme::default(), j)),
+    }
+}
+
+fn first_len(data: &ChartData) -> usize {
+    data.series.first().map(|s| s.values.len()).unwrap_or(0)
+}
+
+pub(super) fn cat_label(data: &ChartData, j: usize) -> String {
+    data.categories.get(j).cloned().unwrap_or_else(|| (j + 1).to_string())
+}
+
+/// Legend entries (text, colour, swatch) `render` draws for this chart; empty when hidden.
+pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swatch)> {
+    if chart.legend == LegendPos::None {
+        return vec![];
+    }
+    match chart.kind {
+        ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst => {
+            let n = first_len(data).min(MAX_CATS);
+            (0..n).map(|j| (cat_label(data, j), point_color(data, j), Swatch::Box)).collect()
+        }
+        ChartKind::Histogram | ChartKind::Funnel | ChartKind::Stock => vec![],
+        ChartKind::Waterfall => {
+            if data.series.is_empty() {
+                return vec![];
+            }
+            let total = data.series.first().map(|s| s.color).unwrap_or(TEXT);
+            vec![("Increase".into(), UP, Swatch::Box), ("Decrease".into(), DOWN, Swatch::Box), ("Total".into(), total, Swatch::Box)]
+        }
+        _ => {
+            let series = data.series.iter().take(MAX_SERIES);
+            let mut out: Vec<(String, Rgba, Swatch)> = series
+                .clone()
+                .map(|s| {
+                    let sw = match plot_kind(chart, s) {
+                        ChartKind::Line | ChartKind::LineStacked | ChartKind::Radar | ChartKind::ScatterLines => Swatch::Line,
+                        ChartKind::LineMarkers => Swatch::LineMarker,
+                        ChartKind::Scatter | ChartKind::Bubble => Swatch::Marker,
+                        _ => Swatch::Box,
+                    };
+                    (s.name.clone(), s.color, sw)
+                })
+                .collect();
+            // Trendlines follow the series, named "Linear (Sales)" unless given a name.
+            for s in series.filter(|s| supports_trendline(plot_kind(chart, s))) {
+                for t in s.trendlines.iter().take(MAX_TRENDLINES) {
+                    out.push((t.spec.name.clone().unwrap_or_else(|| auto_name(t.spec.kind, &s.name)), t.color, Swatch::Line));
+                }
+            }
+            out
+        }
+    }
+}
+
+// ---------------------------------------------------------------- legend
+
+fn swatch_w(sw: Swatch, s: f32) -> f32 {
+    if sw == Swatch::Box { s } else { s * 2.0 }
+}
+
+fn draw_swatch(ctx: &mut Ctx, sw: Swatch, x: f32, yc: f32, s: f32, color: Rgba) {
+    match sw {
+        Swatch::Box => ctx.rect(x, yc - s / 2.0, s, s, color, None),
+        Swatch::Line => ctx.hline(x, x + 2.0 * s, yc, color, 2.0),
+        Swatch::LineMarker => {
+            ctx.hline(x, x + 2.0 * s, yc, color, 2.0);
+            ctx.out.push(Prim::Circle { cx: x + s, cy: yc, r: s * 0.35, fill: Some(color), stroke: None });
+        }
+        Swatch::Marker => ctx.out.push(Prim::Circle { cx: x + s, cy: yc, r: s * 0.4, fill: Some(color), stroke: None }),
+    }
+}
+
+pub(super) fn draw_legend(ctx: &mut Ctx, entries: &[(String, Rgba, Swatch)], pos: LegendPos, area: Bx) -> Bx {
+    let size = LABEL_SIZE;
+    let row_h = size * 1.6;
+    let s = size * 0.8;
+    let gap = 4.0;
+    let spacing = size * 1.3;
+    let item_w = |ctx: &Ctx, e: &(String, Rgba, Swatch)| swatch_w(e.2, s) + gap + ctx.tw(&e.0, size);
+    match pos {
+        LegendPos::None => area,
+        LegendPos::Top | LegendPos::Bottom => {
+            let max_rows = ((area.h * 0.3 / row_h).floor() as usize).max(1);
+            let mut rows: Vec<Vec<(usize, f32)>> = vec![vec![]];
+            let mut cur = 0.0f32;
+            for (i, e) in entries.iter().enumerate() {
+                let iw = item_w(ctx, e).min(area.w);
+                let need = if cur > 0.0 { spacing + iw } else { iw };
+                if cur > 0.0 && cur + need > area.w {
+                    if rows.len() >= max_rows {
+                        break;
+                    }
+                    rows.push(vec![]);
+                    cur = 0.0;
+                }
+                cur += if cur > 0.0 { spacing + iw } else { iw };
+                if let Some(r) = rows.last_mut() {
+                    r.push((i, iw));
+                }
+            }
+            let lh = rows.len() as f32 * row_h;
+            let y0 = if pos == LegendPos::Bottom { area.bottom() - lh } else { area.y };
+            for (ri, row) in rows.iter().enumerate() {
+                let total: f32 = row.iter().map(|(_, w)| w).sum::<f32>() + spacing * row.len().saturating_sub(1) as f32;
+                let mut x = area.x + (area.w - total).max(0.0) / 2.0;
+                let yc = y0 + ri as f32 * row_h + row_h / 2.0;
+                for &(i, iw) in row {
+                    if let Some(e) = entries.get(i) {
+                        draw_swatch(ctx, e.2, x, yc, s, e.1);
+                        let sx = swatch_w(e.2, s) + gap;
+                        let t = ctx.fit(&e.0, size, (iw - sx).max(0.0) + 0.5);
+                        ctx.text(x + sx, yc, &t, size, TEXT, HAlign::Left, VAlign::Middle);
+                    }
+                    x += iw + spacing;
+                }
+            }
+            let used = lh + 4.0;
+            if pos == LegendPos::Bottom { Bx { h: area.h - used, ..area } } else { Bx { y: area.y + used, h: area.h - used, ..area } }
+        }
+        LegendPos::Left | LegendPos::Right => {
+            let colw = entries.iter().map(|e| item_w(ctx, e)).fold(0.0f32, f32::max).min(area.w * 0.35);
+            let max_rows = ((area.h / row_h).floor() as usize).max(1);
+            let n = entries.len().min(max_rows);
+            let lh = n as f32 * row_h;
+            let y0 = area.y + (area.h - lh).max(0.0) / 2.0;
+            let x0 = if pos == LegendPos::Right { area.right() - colw } else { area.x };
+            for (i, e) in entries.iter().take(n).enumerate() {
+                let yc = y0 + i as f32 * row_h + row_h / 2.0;
+                draw_swatch(ctx, e.2, x0, yc, s, e.1);
+                let sx = swatch_w(e.2, s) + gap;
+                let t = ctx.fit(&e.0, size, (colw - sx).max(0.0) + 0.5);
+                ctx.text(x0 + sx, yc, &t, size, TEXT, HAlign::Left, VAlign::Middle);
+            }
+            let used = colw + 8.0;
+            if pos == LegendPos::Right { Bx { w: area.w - used, ..area } } else { Bx { x: area.x + used, w: area.w - used, ..area } }
+        }
+    }
+}
diff --git a/crates/chart/src/render/lines.rs b/crates/chart/src/render/lines.rs
new file mode 100644
index 000000000..9cef4608c
--- /dev/null
+++ b/crates/chart/src/render/lines.rs
@@ -0,0 +1,157 @@
+use super::frame::Bx;
+use super::*;
+
+// ---------------------------------------------------------------- helpers
+
+/// Reduces a long polyline to first/min/max/last per pixel column.
+pub(super) fn decimate(pts: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> {
+    if pts.len() <= max {
+        return pts;
+    }
+    let mut out = Vec::with_capacity(max * 2);
+    let mut i = 0;
+    while let Some(p) = pts.get(i) {
+        let col = p[0].floor();
+        let (start, mut mn, mut mx) = (i, i, i);
+        let mut k = i + 1;
+        while let Some(q) = pts.get(k) {
+            if q[0].floor() != col {
+                break;
+            }
+            if pts.get(mn).is_some_and(|m| q[1] < m[1]) {
+                mn = k;
+            }
+            if pts.get(mx).is_some_and(|m| q[1] > m[1]) {
+                mx = k;
+            }
+            k += 1;
+        }
+        let mut idx = [start, mn, mx, k - 1];
+        idx.sort_unstable();
+        let mut last = usize::MAX;
+        for ix in idx {
+            if ix != last
+                && let Some(q) = pts.get(ix)
+            {
+                out.push(*q);
+                last = ix;
+            }
+        }
+        i = k;
+    }
+    if out.len() > max * 4 {
+        let step = out.len() / (max * 2) + 1;
+        let last = out.last().copied();
+        let mut s: Vec<[f32; 2]> = out.into_iter().step_by(step).collect();
+        if let Some(l) = last
+            && s.last() != Some(&l)
+        {
+            s.push(l);
+        }
+        return s;
+    }
+    out
+}
+
+/// Draws a polyline split at gaps (`None`), decimated when long. With `smooth` (the plot box),
+/// each run is interpolated with a Catmull-Rom spline so the line curves through the data points.
+pub(super) fn draw_runs(ctx: &mut Ctx, pts: &[Option<[f32; 2]>], color: Rgba, width: f32, smooth: Option<Bx>) {
+    let mut run: Vec<[f32; 2]> = Vec::new();
+    for p in pts.iter().chain(std::iter::once(&None)) {
+        match p {
+            Some(p) => run.push(*p),
+            None => {
+                if run.len() >= 2 {
+                    let r = decimate(std::mem::take(&mut run), MAX_LINE_PTS);
+                    let r = match smooth {
+                        Some(plot) => smooth_run(r, plot),
+                        None => r,
+                    };
+                    ctx.line(r, color, width);
+                } else {
+                    run.clear();
+                }
+            }
+        }
+    }
+}
+
+/// Catmull-Rom spline through `pts`: every segment gets the same number of sub-segments (up to
+/// 100), chosen so the whole curve stays within `MAX_LINE_PTS * 2` points. Endpoints are
+/// duplicated so the curve passes through the first and last points, and the curve is clamped
+/// to the `plot` box (a spline overshoots its data near sharp turns).
+fn smooth_run(pts: Vec<[f32; 2]>, plot: Bx) -> Vec<[f32; 2]> {
+    let n = pts.len();
+    if n < 3 {
+        return pts;
+    }
+    let cap = MAX_LINE_PTS * 2;
+    let steps = (cap / n).clamp(1, 100);
+    let mut out: Vec<[f32; 2]> = Vec::with_capacity(n.saturating_mul(steps).min(cap) + 1);
+    let at = |i: isize| -> [f32; 2] {
+        let j = i.clamp(0, n as isize - 1) as usize;
+        pts.get(j).copied().unwrap_or([0.0, 0.0])
+    };
+    let (x0, x1) = (plot.x.min(plot.right()), plot.x.max(plot.right()));
+    let (y0, y1) = (plot.y.min(plot.bottom()), plot.y.max(plot.bottom()));
+    let clip = |p: [f32; 2]| [p[0].clamp(x0, x1), p[1].clamp(y0, y1)];
+    for i in 0..n.saturating_sub(1) {
+        let (p0, p1, p2, p3) = (at(i as isize - 1), at(i as isize), at(i as isize + 1), at(i as isize + 2));
+        for s in 0..steps {
+            let t = s as f32 / steps as f32;
+            out.push(clip(catmull(p0, p1, p2, p3, t)));
+        }
+    }
+    out.push(clip(at(n as isize - 1)));
+    out
+}
+
+/// One Catmull-Rom point between `p1` and `p2` (uniform parameterisation), tangent-scaled by 0.5.
+fn catmull(p0: [f32; 2], p1: [f32; 2], p2: [f32; 2], p3: [f32; 2], t: f32) -> [f32; 2] {
+    let t2 = t * t;
+    let t3 = t2 * t;
+    let mut o = [0.0f32; 2];
+    for k in 0..2 {
+        let (a0, a1, a2, a3) = (p0[k], p1[k], p2[k], p3[k]);
+        o[k] = 0.5 * ((2.0 * a1) + (-a0 + a2) * t + (2.0 * a0 - 5.0 * a1 + 4.0 * a2 - a3) * t2 + (-a0 + 3.0 * a1 - 3.0 * a2 + a3) * t3);
+    }
+    o
+}
+
+pub(super) fn draw_markers(ctx: &mut Ctx, pts: impl Iterator<Item = [f32; 2]>, r: f32, color: Rgba) {
+    let mut seen = HashSet::new();
+    for p in pts {
+        if seen.len() >= MAX_MARKERS {
+            break;
+        }
+        if seen.insert(((p[0] * 0.5) as i32, (p[1] * 0.5) as i32)) {
+            ctx.out.push(Prim::Circle { cx: p[0], cy: p[1], r, fill: Some(color), stroke: Some((WHITE, 0.75)) });
+        }
+    }
+}
+
+#[cfg(test)]
+mod smooth_tests {
+    use super::*;
+
+    #[test]
+    fn long_runs_are_smoothed_uniformly_within_the_cap() {
+        let plot = Bx { x: 0.0, y: 0.0, w: 3000.0, h: 100.0 };
+        let pts: Vec<[f32; 2]> = (0..1500).map(|i| [i as f32 * 2.0, if i % 2 == 0 { 20.0 } else { 80.0 }]).collect();
+        let out = smooth_run(pts, plot);
+        assert!(out.len() <= MAX_LINE_PTS * 2 + 1, "{}", out.len());
+        // Two sub-segments per segment all the way to the end, not 100 each and then a straight tail.
+        assert_eq!(out.len(), 1499 * 2 + 1);
+        assert_eq!(out.last().copied(), Some([2998.0, 80.0]));
+    }
+
+    #[test]
+    fn spline_overshoot_is_clamped_to_the_plot() {
+        let plot = Bx { x: 0.0, y: 10.0, w: 300.0, h: 100.0 };
+        // A step right at the plot edges: Catmull-Rom overshoots past both.
+        let pts = vec![[0.0, 110.0], [100.0, 110.0], [110.0, 10.0], [200.0, 10.0], [300.0, 10.0]];
+        let out = smooth_run(pts, plot);
+        assert!(out.len() > 5);
+        assert!(out.iter().all(|p| (0.0..=300.0).contains(&p[0]) && (10.0..=110.0).contains(&p[1])));
+    }
+}
diff --git a/crates/chart/src/render/trend.rs b/crates/chart/src/render/trend.rs
new file mode 100644
index 000000000..38e435a47
--- /dev/null
+++ b/crates/chart/src/render/trend.rs
@@ -0,0 +1,166 @@
+use super::frame::{Bx, value_range};
+use super::lines::decimate;
+use super::*;
+
+// ---------------------------------------------------------------- trendlines
+
+/// Samples along a regression trendline.
+const TREND_STEPS: usize = 200;
+
+/// Whether series drawn as `k` show trendlines (Excel offers them on 2-D unstacked column,
+/// bar, line, area, scatter and bubble charts).
+pub fn supports_trendline(k: ChartKind) -> bool {
+    use ChartKind::*;
+    matches!(k, ColumnClustered | BarClustered | Line | LineMarkers | Area | Scatter | ScatterLines | Bubble)
+}
+
+/// A forecast distance as drawn: finite, non-negative and bounded.
+fn forecast(v: f64) -> f64 {
+    if v.is_finite() && v > 0.0 { v.min(1e9) } else { 0.0 }
+}
+
+/// Most empty category slots a forward forecast may add after `ncat` categories: four times the
+/// data (at least 32), and never past `MAX_CATS` in total. A larger forecast would shrink every
+/// column to nothing.
+pub(super) fn max_forward_slots(ncat: usize) -> f64 {
+    (ncat.saturating_mul(4).max(32)).min(MAX_CATS.saturating_sub(ncat)) as f64
+}
+
+/// Longest forward forecast among `s`'s regression trendlines.
+pub(super) fn max_forward(s: &SeriesData) -> f64 {
+    s.trendlines.iter().filter(|t| !matches!(t.spec.kind, TrendlineKind::MovingAverage(_))).map(|t| forecast(t.spec.forward)).fold(0.0, f64::max)
+}
+
+/// Longest backward forecast among `s`'s regression trendlines.
+pub(super) fn max_backward(s: &SeriesData) -> f64 {
+    s.trendlines.iter().filter(|t| !matches!(t.spec.kind, TrendlineKind::MovingAverage(_))).map(|t| forecast(t.spec.backward)).fold(0.0, f64::max)
+}
+
+/// Liang–Barsky: the part of segment `a`–`b` inside the unit square, with whether the start and
+/// end were cut.
+#[allow(clippy::type_complexity)]
+fn clip_segment(a: (f64, f64), b: (f64, f64)) -> Option<((f64, f64), (f64, f64), bool, bool)> {
+    let (dx, dy) = (b.0 - a.0, b.1 - a.1);
+    let (mut t0, mut t1) = (0.0f64, 1.0f64);
+    for (p, q) in [(-dx, a.0), (dx, 1.0 - a.0), (-dy, a.1), (dy, 1.0 - a.1)] {
+        if p == 0.0 {
+            if q < 0.0 {
+                return None;
+            }
+        } else {
+            let r = q / p;
+            if p < 0.0 {
+                if r > t1 {
+                    return None;
+                }
+                t0 = t0.max(r);
+            } else {
+                if r < t0 {
+                    return None;
+                }
+                t1 = t1.min(r);
+            }
+        }
+    }
+    Some(((a.0 + t0 * dx, a.1 + t0 * dy), (a.0 + t1 * dx, a.1 + t1 * dy), t0 > 0.0, t1 < 1.0))
+}
+
+/// Clips a sampled polyline in plot fractions (`None` = gap) to the plot box (the unit
+/// square), returning the visible runs.
+fn clip_unit(pts: &[Option<(f64, f64)>]) -> Vec<Vec<(f64, f64)>> {
+    const LIM: f64 = 1e9;
+    let ok = |p: &(f64, f64)| p.0.is_finite() && p.1.is_finite();
+    let cl = |p: (f64, f64)| (p.0.clamp(-LIM, LIM), p.1.clamp(-LIM, LIM));
+    let mut runs: Vec<Vec<(f64, f64)>> = Vec::new();
+    let mut run: Vec<(f64, f64)> = Vec::new();
+    for w in pts.windows(2) {
+        let seg = match w {
+            [Some(a), Some(b)] if ok(a) && ok(b) => clip_segment(cl(*a), cl(*b)),
+            _ => None,
+        };
+        match seg {
+            Some((p, q, cut_start, cut_end)) => {
+                if cut_start || run.is_empty() {
+                    if run.len() >= 2 {
+                        runs.push(std::mem::take(&mut run));
+                    }
+                    run.clear();
+                    run.push(p);
+                }
+                run.push(q);
+                if cut_end {
+                    runs.push(std::mem::take(&mut run));
+                }
+            }
+            None => {
+                if run.len() >= 2 {
+                    runs.push(std::mem::take(&mut run));
+                }
+                run.clear();
+            }
+        }
+    }
+    if run.len() >= 2 {
+        runs.push(run);
+    }
+    runs
+}
+
+/// Draws `s`'s trendlines fitted to its plotted points `pts` (data x, y). `frac` maps data to
+/// fractions of the plot box (0..1 inside, along the x and y axes), `px` fractions to pixels.
+/// Equation and R² label lines are appended to `labels`. Degenerate fits draw nothing.
+pub(super) fn draw_trendlines(
+    ctx: &mut Ctx,
+    s: &SeriesData,
+    pts: &[(f64, f64)],
+    frac: &dyn Fn(f64, f64) -> (f64, f64),
+    px: &dyn Fn((f64, f64)) -> [f32; 2],
+    labels: &mut Vec<String>,
+    window: (f64, f64),
+) {
+    let Some((xlo, xhi)) = value_range(pts.iter().map(|p| p.0)) else { return };
+    for t in s.trendlines.iter().take(MAX_TRENDLINES) {
+        let spec = &t.spec;
+        let samples: Vec<Option<(f64, f64)>> = match spec.kind {
+            TrendlineKind::MovingAverage(p) => moving_average(pts, p).into_iter().map(|(x, y)| Some(frac(x, y))).collect(),
+            _ => {
+                let Some(fit) = fit_trendline(spec, pts) else { continue };
+                // Sample only the part of the forecast that is on the plot.
+                let (lo, hi) = ((xlo - forecast(spec.backward)).max(window.0), (xhi + forecast(spec.forward)).min(window.1));
+                if spec.display_equation {
+                    labels.push(fit.equation());
+                }
+                if spec.display_r_squared {
+                    labels.push(fit.r_squared());
+                }
+                (0..=TREND_STEPS)
+                    .map(|i| {
+                        let x = lo + (hi - lo) * i as f64 / TREND_STEPS as f64;
+                        fit.eval(x).map(|y| frac(x, y))
+                    })
+                    .collect()
+            }
+        };
+        let width = spec.width.filter(|w| w.is_finite()).unwrap_or(1.5).clamp(0.25, 12.0);
+        let dash = spec.dash != Some(LineDash::Solid);
+        for run in clip_unit(&samples) {
+            let line = decimate(run.into_iter().map(px).collect(), MAX_LINE_PTS);
+            if line.len() >= 2 {
+                ctx.out.push(Prim::Line { pts: line, color: t.color, width, dash });
+            }
+        }
+    }
+}
+
+/// Trendline equation / R² labels, stacked in the plot's top-right corner.
+pub(super) fn draw_trend_labels(ctx: &mut Ctx, plot: Bx, labels: &[String]) {
+    let lh = LABEL_SIZE * 1.3;
+    for (i, t) in labels.iter().enumerate() {
+        let y = plot.y + 4.0 + i as f32 * lh;
+        if y + lh > plot.bottom() {
+            break;
+        }
+        let t = ctx.fit(t, LABEL_SIZE, plot.w - 8.0);
+        ctx.text(plot.right() - 4.0, y, &t, LABEL_SIZE, TEXT, HAlign::Right, VAlign::Top);
+    }
+}

From 6a40610bb448c5f91b177be493b8572043742bfa Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 18:44:03 +0000
Subject: [PATCH 46/76] refactor(ui-egui): move grid.rs items to grid/

---
 crates/ui-egui/src/grid.rs            | 4272 +------------------------
 crates/ui-egui/src/grid/cell_paint.rs |  310 ++
 crates/ui-egui/src/grid/cursor.rs     |  138 +
 crates/ui-egui/src/grid/editor.rs     |  161 +
 crates/ui-egui/src/grid/geo.rs        |  237 ++
 crates/ui-egui/src/grid/interact.rs   |  904 ++++++
 crates/ui-egui/src/grid/keyboard.rs   |  155 +
 crates/ui-egui/src/grid/menus.rs      |  551 ++++
 crates/ui-egui/src/grid/quadrant.rs   |  474 +++
 crates/ui-egui/src/grid/selection.rs  |  419 +++
 crates/ui-egui/src/grid/show.rs       |  861 +++++
 crates/ui-egui/src/grid/tables.rs     |   87 +
 12 files changed, 4328 insertions(+), 4241 deletions(-)
 create mode 100644 crates/ui-egui/src/grid/cell_paint.rs
 create mode 100644 crates/ui-egui/src/grid/cursor.rs
 create mode 100644 crates/ui-egui/src/grid/editor.rs
 create mode 100644 crates/ui-egui/src/grid/geo.rs
 create mode 100644 crates/ui-egui/src/grid/interact.rs
 create mode 100644 crates/ui-egui/src/grid/keyboard.rs
 create mode 100644 crates/ui-egui/src/grid/menus.rs
 create mode 100644 crates/ui-egui/src/grid/quadrant.rs
 create mode 100644 crates/ui-egui/src/grid/selection.rs
 create mode 100644 crates/ui-egui/src/grid/show.rs
 create mode 100644 crates/ui-egui/src/grid/tables.rs

diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index 970ab61dd..e3715a6de 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -15,6 +15,37 @@ use crate::SheetApp;
 use crate::editor::EditState;
 use crate::theme::{self, Tokens};
 
+mod cell_paint;
+mod cursor;
+mod editor;
+mod geo;
+mod interact;
+mod keyboard;
+mod menus;
+mod quadrant;
+mod selection;
+mod show;
+mod tables;
+
+pub(crate) use cell_paint::paint_border;
+#[cfg(test)]
+pub(crate) use cell_paint::{cell_text_y, rotated_text_pos, wrapped_cell_text_y};
+#[cfg(test)]
+use cell_paint::{center_across_end, display_text, look, numfmt_color, painted_halign};
+pub use editor::validation_arrow;
+#[cfg(test)]
+use editor::{editor_slack, editor_width, list_picker_height};
+pub use geo::Geo;
+pub use interact::{follow_link, freeze_handles, point_move};
+pub(crate) use quadrant::paint_quadrant;
+pub(crate) use selection::paint_selection;
+pub use selection::selection_fill;
+pub(crate) use show::horizontal_scrollbar;
+pub use show::show;
+#[cfg(test)]
+use tables::filter_table_range;
+pub use tables::{TableHeading, filter_button_rect, heading_table, table_headings};
+
 pub const COL_HEADER_H: f32 = 21.0;
 /// Sheet units are 96-dpi pixels (as in XLSX); on screen one unit is drawn at this many points,
 /// which matches desktop spreadsheet density (a default 20 px row is 16 pt tall).
@@ -238,3962 +269,6 @@ impl WheelZoom {
     }
 }
 
-/// Geometry of the grid for one frame (handles zoom and frozen panes).
-#[derive(Clone)]
-pub struct Geo {
-    pub rect: Rect,
-    pub cells: Rect,
-    pub z: f32,
-    pub header_w: f32,
-    pub header_h: f32,
-    /// The outline bands (grouped rows / columns): left of the row headers and above the column
-    /// headers; 0 without an outline (see `outline`).
-    pub band_w: f32,
-    pub band_h: f32,
-    pub row_outline: Arc<crate::outline::Axis>,
-    pub col_outline: Arc<crate::outline::Axis>,
-    pub fr: u32,
-    pub fc: u32,
-    pub frozen_w: f32,
-    pub frozen_h: f32,
-    pub scroll: egui::Vec2,
-    /// Sheet Right-to-Left: everything is laid out left-to-right as usual (these "logical"
-    /// coordinates are what `x`, `cell_rect`, `col_at`… return) and mirrored across `rect`'s
-    /// vertical centre line on screen: painted shapes by `mirror_painted`, widgets by
-    /// `mirror_rect`/`mirror_pos`, and pointer input back by `mirror_pos` (an involution).
-    pub rtl: bool,
-    /// Prefix sums over custom row heights / column widths, built once per frame.
-    ri: std::sync::Arc<LineIndex>,
-    ci: std::sync::Arc<LineIndex>,
-    /// Page Layout view: cells sit on pages (`scroll` is then in page-layout units).
-    pub paper: Option<Arc<gridcraft_engine::paper::PageGrid>>,
-}
-
-impl Geo {
-    pub fn new(sh: &Sheet, rect: Rect, scroll: egui::Vec2) -> Geo {
-        let zoom = (sh.zoom as f32 / 100.0).clamp(0.1, 4.0);
-        let z = zoom * DISPLAY_SCALE;
-        let header_h = if sh.show_headings { (COL_HEADER_H * zoom.max(0.75)).round() } else { 0.0 };
-        let ri = std::sync::Arc::new(LineIndex::new(&sh.rows, sh.default_row_height, MAX_ROWS));
-        let ci = std::sync::Arc::new(LineIndex::new(&sh.cols, sh.default_col_width, MAX_COLS));
-        let last_row = ri.at((scroll.y + rect.height() / z) as f64 + 200.0) + 1;
-        let digits = (last_row as f32).log10().floor() as i32 + 1;
-        let header_w = if sh.show_headings { ((digits.max(2) as f32 * 7.0 + 14.0) * zoom.max(0.75)).round() } else { 0.0 };
-        let (fr, fc) = sh.freeze.unwrap_or((0, 0));
-        let frozen_w = (ci.start(fc) as f32) * z;
-        let frozen_h = (ri.start(fr) as f32) * z;
-        let row_outline = Arc::new(crate::outline::Axis::of(sh, true));
-        let col_outline = Arc::new(crate::outline::Axis::of(sh, false));
-        // Show Outline Symbols off: no bands (the outline's hidden lines stay hidden).
-        let symbols = sh.show_outline_symbols;
-        let mut band_w = if symbols { crate::outline::band(row_outline.levels, zoom) } else { 0.0 };
-        let mut band_h = if symbols { crate::outline::band(col_outline.levels, zoom) } else { 0.0 };
-        // Without headings the level buttons still need a corner to sit in.
-        if symbols && row_outline.levels > 0 && header_h == 0.0 {
-            band_h = band_h.max(crate::outline::lane(zoom) + 3.0);
-        }
-        if symbols && col_outline.levels > 0 && header_w == 0.0 {
-            band_w = band_w.max(crate::outline::lane(zoom) + 3.0);
-        }
-        let cells = Rect::from_min_max(pos2(rect.left() + band_w + header_w, rect.top() + band_h + header_h), rect.max);
-        Geo {
-            rect,
-            cells,
-            z,
-            header_w,
-            header_h,
-            band_w,
-            band_h,
-            row_outline,
-            col_outline,
-            fr,
-            fc,
-            frozen_w,
-            frozen_h,
-            scroll,
-            rtl: sh.right_to_left,
-            ri,
-            ci,
-            paper: None,
-        }
-    }
-    /// Left edge of the row headers (right of the outline band).
-    pub fn head_left(&self) -> f32 {
-        self.cells.left() - self.header_w
-    }
-    /// Top edge of the column headers (below the outline band).
-    pub fn head_top(&self) -> f32 {
-        self.cells.top() - self.header_h
-    }
-    /// Page Layout view geometry: `rect` excludes the rulers; cells are drawn at the print scale
-    /// on pages laid out by `grid`; frozen panes don't apply (as in Excel).
-    pub fn paged(sh: &Sheet, rect: Rect, scroll: egui::Vec2, grid: Arc<gridcraft_engine::paper::PageGrid>) -> Geo {
-        let mut g = Geo::new(sh, rect, scroll);
-        let zoom = (sh.zoom as f32 / 100.0).clamp(0.1, 4.0);
-        g.z = zoom * DISPLAY_SCALE * grid.scale.clamp(0.1, 4.0);
-        (g.fr, g.fc, g.frozen_w, g.frozen_h) = (0, 0, 0.0, 0.0);
-        g.paper = Some(grid);
-        g
-    }
-    /// The point is over cells (in Page Layout view: on a page, inside its margins).
-    pub fn in_cells(&self, p: Pos2) -> bool {
-        if !self.cells.contains(p) {
-            return false;
-        }
-        match &self.paper {
-            Some(pg) => pg.on_cells(
-                self.scroll.x as f64 + ((p.x - self.cells.left()) / self.z) as f64,
-                self.scroll.y as f64 + ((p.y - self.cells.top()) / self.z) as f64,
-            ),
-            None => true,
-        }
-    }
-    /// Scroll offset (in `scroll` units) at which `row` reaches the top of the scrolled area.
-    pub fn scroll_top_of(&self, sh: &Sheet, row: u32) -> f32 {
-        match &self.paper {
-            Some(pg) => pg.row_y(row) as f32,
-            None => (sh.row_top(row) - sh.row_top(self.fr)) as f32,
-        }
-    }
-    /// Scroll offset (in `scroll` units) at which `col` reaches the left of the scrolled area.
-    pub fn scroll_left_of(&self, sh: &Sheet, col: u32) -> f32 {
-        match &self.paper {
-            Some(pg) => pg.col_x(col) as f32,
-            None => (sh.col_left(col) - sh.col_left(self.fc)) as f32,
-        }
-    }
-    /// Screen x for a logical x (and back): identity unless the sheet is right-to-left.
-    pub fn mirror_x(&self, x: f32) -> f32 {
-        if self.rtl { self.rect.left() + self.rect.right() - x } else { x }
-    }
-    pub fn mirror_pos(&self, p: Pos2) -> Pos2 {
-        pos2(self.mirror_x(p.x), p.y)
-    }
-    pub fn mirror_rect(&self, r: Rect) -> Rect {
-        if self.rtl { Rect::from_min_max(pos2(self.mirror_x(r.right()), r.top()), pos2(self.mirror_x(r.left()), r.bottom())) } else { r }
-    }
-    /// On-screen rectangle of a cell (`cell_rect` mirrored for right-to-left sheets).
-    pub fn screen_cell_rect(&self, sh: &Sheet, c: CellRef) -> Rect {
-        self.mirror_rect(self.cell_rect(sh, c))
-    }
-    pub fn x(&self, _sh: &Sheet, col: u32) -> f32 {
-        if let Some(pg) = &self.paper {
-            return self.cells.left() + (pg.col_x(col) - self.scroll.x as f64) as f32 * self.z;
-        }
-        if col < self.fc {
-            self.cells.left() + self.ci.start(col) as f32 * self.z
-        } else {
-            self.cells.left() + self.frozen_w + (self.ci.start(col) as f32 - self.ci.start(self.fc) as f32 - self.scroll.x) * self.z
-        }
-    }
-    pub fn y(&self, _sh: &Sheet, row: u32) -> f32 {
-        if let Some(pg) = &self.paper {
-            return self.cells.top() + (pg.row_y(row) - self.scroll.y as f64) as f32 * self.z;
-        }
-        if row < self.fr {
-            self.cells.top() + self.ri.start(row) as f32 * self.z
-        } else {
-            self.cells.top() + self.frozen_h + (self.ri.start(row) as f32 - self.ri.start(self.fr) as f32 - self.scroll.y) * self.z
-        }
-    }
-    pub fn cell_rect(&self, sh: &Sheet, c: CellRef) -> Rect {
-        Rect::from_min_max(
-            pos2(self.x(sh, c.col), self.y(sh, c.row)),
-            pos2(self.x(sh, c.col) + sh.col_width(c.col) * self.z, self.y(sh, c.row) + sh.row_height(c.row) * self.z),
-        )
-    }
-    pub fn range_rect(&self, sh: &Sheet, r: RangeRef) -> Rect {
-        let a = self.cell_rect(sh, r.start);
-        let b = self.cell_rect(sh, r.end);
-        Rect::from_min_max(a.min, b.max)
-    }
-    pub fn col_at(&self, _sh: &Sheet, x: f32) -> u32 {
-        if let Some(pg) = &self.paper {
-            return pg.col_at(self.scroll.x as f64 + ((x - self.cells.left()) / self.z) as f64);
-        }
-        let dx = (x - self.cells.left()) / self.z;
-        if dx < self.frozen_w / self.z {
-            self.ci.at(dx.max(0.0) as f64)
-        } else {
-            self.ci.at(self.ci.start(self.fc) + self.scroll.x as f64 + (dx - self.frozen_w / self.z) as f64)
-        }
-    }
-    pub fn row_at(&self, _sh: &Sheet, y: f32) -> u32 {
-        if let Some(pg) = &self.paper {
-            return pg.row_at(self.scroll.y as f64 + ((y - self.cells.top()) / self.z) as f64);
-        }
-        let dy = (y - self.cells.top()) / self.z;
-        if dy < self.frozen_h / self.z {
-            self.ri.at(dy.max(0.0) as f64)
-        } else {
-            self.ri.at(self.ri.start(self.fr) + self.scroll.y as f64 + (dy - self.frozen_h / self.z) as f64)
-        }
-    }
-    pub fn cell_at(&self, sh: &Sheet, p: Pos2) -> CellRef {
-        CellRef::new(self.row_at(sh, p.y), self.col_at(sh, p.x))
-    }
-    /// Visible scrolled rows (from the first visible row after the frozen ones).
-    fn scroll_rows(&self, _sh: &Sheet) -> (u32, u32) {
-        let top = self.ri.start(self.fr) + self.scroll.y as f64;
-        let r0 = self.ri.at(top).max(self.fr);
-        let r1 = self.ri.at(top + ((self.cells.height() - self.frozen_h) / self.z) as f64).min(MAX_ROWS - 1);
-        (r0, r1)
-    }
-    fn scroll_cols(&self, _sh: &Sheet) -> (u32, u32) {
-        let left = self.ci.start(self.fc) + self.scroll.x as f64;
-        let c0 = self.ci.at(left).max(self.fc);
-        let c1 = self.ci.at(left + ((self.cells.width() - self.frozen_w) / self.z) as f64).min(MAX_COLS - 1);
-        (c0, c1)
-    }
-    /// Screen areas of the panes (frozen rows/columns or the scrolling part) that hold part of `r`.
-    /// The panes share one coordinate system, so a range that is not clipped to these is also drawn
-    /// over the frozen rows/columns when it is scrolled under them.
-    pub fn range_panes(&self, r: RangeRef) -> Vec<Rect> {
-        let split = pos2(self.cells.left() + self.frozen_w, self.cells.top() + self.frozen_h);
-        let mut xs = Vec::new();
-        if r.start.col < self.fc {
-            xs.push((self.cells.left(), split.x));
-        }
-        if r.end.col >= self.fc {
-            xs.push((split.x, self.cells.right()));
-        }
-        let mut ys = Vec::new();
-        if r.start.row < self.fr {
-            ys.push((self.cells.top(), split.y));
-        }
-        if r.end.row >= self.fr {
-            ys.push((split.y, self.cells.bottom()));
-        }
-        ys.iter().flat_map(|&(y0, y1)| xs.iter().map(move |&(x0, x1)| Rect::from_min_max(pos2(x0, y0), pos2(x1, y1)))).collect()
-    }
-    /// True when cell `c` is in the scrolling pane but scrolled entirely under the frozen rows or columns.
-    pub fn hidden_under_frozen(&self, sh: &Sheet, c: CellRef) -> bool {
-        let r = self.cell_rect(sh, c);
-        (self.fc > 0 && c.col >= self.fc && r.right() <= self.cells.left() + self.frozen_w)
-            || (self.fr > 0 && c.row >= self.fr && r.bottom() <= self.cells.top() + self.frozen_h)
-    }
-}
-
-/// Resolved look of a cell for painting.
-struct Look {
-    style: Style,
-    fill: Option<Color32>,
-    text_color: Color32,
-}
-
-fn col32(c: Color, wb: &Workbook, default: Color32) -> Color32 {
-    c.resolve(&wb.theme).map(theme::color32).unwrap_or(default)
-}
-
-fn numfmt_color(c: gridcraft_engine::numfmt::FormatColor) -> Color32 {
-    c.rgb().map(|[r, g, b]| Color32::from_rgb(r, g, b)).unwrap_or(Color32::BLACK)
-}
-
-/// Last column of a Center Across Selection run starting at `start`: it extends over following columns (up to `limit`) while `continues` holds.
-fn center_across_end(start: u32, limit: u32, continues: impl Fn(u32) -> bool) -> u32 {
-    let mut end = start;
-    while end < limit && end + 1 < MAX_COLS && continues(end + 1) {
-        end += 1;
-    }
-    end
-}
-
-fn look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut CfCache) -> (Look, Option<CfLook>) {
-    let mut style = wb.styles.get(sh.style_id(c)).clone();
-    if let Some(t) = sh.table_at(c) {
-        style = gridcraft_engine::tables::table_cell_style(wb, si, t, c);
-    }
-    let cfl = cf.look(wb, si, c);
-    if let Some(l) = &cfl
-        && let Some(st) = &l.style
-    {
-        if st.fill.pattern != PatternType::None {
-            style.fill = st.fill;
-        }
-        if st.font.color != Color::Auto {
-            style.font.color = st.font.color;
-        }
-        if st.font.bold {
-            style.font.bold = true;
-        }
-        if st.font.italic {
-            style.font.italic = true;
-        }
-        if st.font.underline != Underline::None {
-            style.font.underline = st.font.underline;
-        }
-        if st.font.strike {
-            style.font.strike = true;
-        }
-        // In a differential style General means "not set" (#1163).
-        if st.num_fmt.as_str() != "General" {
-            style.num_fmt = st.num_fmt.clone();
-        }
-        for (dst, src) in [
-            (&mut style.borders.left, st.borders.left),
-            (&mut style.borders.right, st.borders.right),
-            (&mut style.borders.top, st.borders.top),
-            (&mut style.borders.bottom, st.borders.bottom),
-        ] {
-            if !src.is_none() {
-                *dst = src;
-            }
-        }
-    }
-    let mut fill = match style.fill.pattern {
-        PatternType::None => None,
-        PatternType::Solid => style.fill.fg.resolve(&wb.theme).map(theme::color32),
-        _ => {
-            // Patterns: approximate with a blend of foreground and background.
-            let fg = style.fill.fg.resolve(&wb.theme).unwrap_or([0, 0, 0]);
-            let bg = style.fill.bg.resolve(&wb.theme).unwrap_or([255, 255, 255]);
-            Some(Color32::from_rgb(
-                ((fg[0] as u16 + bg[0] as u16 * 3) / 4) as u8,
-                ((fg[1] as u16 + bg[1] as u16 * 3) / 4) as u8,
-                ((fg[2] as u16 + bg[2] as u16 * 3) / 4) as u8,
-            ))
-        }
-    };
-    if let Some(l) = &cfl
-        && let Some(rgb) = l.scale_fill
-    {
-        fill = Some(theme::color32(rgb));
-    }
-    let text_color = col32(style.font.color, wb, Color32::BLACK);
-    (Look { style, fill, text_color }, cfl)
-}
-
-/// Text for a value with General narrowing to the available width.
-fn display_text(
-    wb: &Workbook,
-    sh: &Sheet,
-    c: CellRef,
-    v: &Value,
-    st: &Style,
-    width_px: f32,
-    char_w: f32,
-) -> (String, Option<Color32>, bool, Option<(char, usize)>) {
-    if sh.show_formulas
-        && let Some(f) = sh.cell(c).and_then(|x| x.formula.as_ref())
-    {
-        return (format!("={}", f.text), None, false, None);
-    }
-    if !sh.show_zeros && v.as_f64() == Some(0.0) {
-        return (String::new(), None, false, None);
-    }
-    let code = st.num_fmt.as_str();
-    // A checkbox cell draws TRUE/FALSE (and empty) as a box; other values show as General.
-    if code == "checkbox" && matches!(v, Value::Bool(_) | Value::Empty) {
-        return (String::new(), None, false, None);
-    }
-    if code == "General"
-        && let Value::Number(n) = v
-    {
-        let max_chars = ((width_px - 4.0) / char_w).floor().max(1.0) as usize;
-        return match gridcraft_engine::numfmt::format_general_fit(*n, max_chars.min(11)) {
-            Some(t) => (t, None, true, None),
-            None => ("#".repeat(max_chars.max(1)), None, true, None),
-        };
-    }
-    let f = gridcraft_engine::display::format(v, code, wb);
-    (f.text, f.color.map(numfmt_color), f.numeric, f.fill)
-}
-
-pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
-    let t = Tokens::get(ui.ctx());
-    let available = ui.available_rect_before_wrap();
-    // A right-to-left sheet has its vertical scrollbar on the left.
-    let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
-    let bar = 14.0_f32.min(available.width());
-    let rect = if rtl {
-        Rect::from_min_max(pos2(available.left() + bar, available.top()), available.max)
-    } else {
-        Rect::from_min_max(available.min, pos2(available.right() - bar, available.bottom()))
-    };
-    let resp = ui.allocate_rect(rect, Sense::click_and_drag());
-    app.grid.rect = Some(rect);
-    let Some(d) = app.session.active() else { return };
-    let wb: Arc<Workbook> = d.wb.clone();
-    let si = wb.active_sheet();
-    let Some(sh) = wb.sheet(si) else { return };
-    let sel = d.selection.clone();
-    let place = (d.uid, si);
-    let mut view = app.view();
-    // Page Layout view: pages on a desk, rulers above and left of the headings.
-    let paper = sh.view == gridcraft_engine::model::SheetViewMode::PageLayout;
-    let ruler = if paper && !app.session.hide_ruler { crate::paper_view::RULER } else { 0.0 };
-    // Right-to-left sheets carry the vertical ruler on the right, beside the row headings.
-    let grid_rect = if rtl {
-        Rect::from_min_max(pos2(rect.left(), (rect.top() + ruler).min(rect.bottom())), pos2((rect.right() - ruler).max(rect.left()), rect.bottom()))
-    } else {
-        Rect::from_min_max(pos2((rect.left() + ruler).min(rect.right()), (rect.top() + ruler).min(rect.bottom())), rect.max)
-    };
-    let make_geo = |app: &mut SheetApp, scroll: egui::Vec2| -> Geo {
-        if paper {
-            let probe = Geo::new(sh, grid_rect, scroll);
-            if let Some(g) = crate::paper_view::grid_for(app, &wb, si, sh, probe.cells.size(), scroll) {
-                let g = crate::paper_view::with_dragged_margin(app, &wb, si, g);
-                return Geo::paged(sh, grid_rect, scroll, g);
-            }
-        }
-        Geo::new(sh, rect, scroll)
-    };
-    // Scrolling.
-    let (scroll_delta, zoom_delta, modifiers, now) = ui.input(|i| (i.smooth_scroll_delta, i.zoom_delta(), i.modifiers, i.time));
-    if (resp.hovered() || resp.contains_pointer()) && !crate::text_box::contains_pointer(app, ui.ctx()) {
-        if zoom_delta != 1.0 {
-            // egui's zoom factor is e^(speed × points); one notch is `line_scroll_speed` points.
-            let notch = ui.ctx().options(|o| o.input_options.scroll_zoom_speed * o.input_options.line_scroll_speed);
-            let turned = zoom_delta.ln() / notch;
-            let mut zooming = WheelZoom::at(app, place, sh.zoom, now);
-            if now - zooming.time > WHEEL_ZOOM_IDLE {
-                zooming.notches = 0.0;
-            }
-            if turned.is_finite() {
-                zooming.notches = (zooming.notches + turned).clamp(-32.0, 32.0);
-            }
-            zooming.time = now;
-            // A notch steps once 60% of it has turned, and the rest of it brings `notches` back to
-            // about 0. (Past half, so what's left after a step can't step back.) Steps count from
-            // where a glide is going, not from where it has got to.
-            let from = zooming.glide.map_or(sh.zoom, |(to, _)| to);
-            let mut z = from;
-            while zooming.notches >= 0.6 {
-                z = wheel_zoom_step(z, true);
-                zooming.notches -= 1.0;
-            }
-            while zooming.notches <= -0.6 {
-                z = wheel_zoom_step(z, false);
-                zooming.notches += 1.0;
-            }
-            if z != from {
-                zooming.glide = Some((z, sh.zoom));
-            }
-            app.grid.wheel_zoom = Some(zooming);
-        } else if scroll_delta != egui::Vec2::ZERO {
-            let z = if paper { make_geo(app, view.scroll).z } else { sh.zoom as f32 / 100.0 * DISPLAY_SCALE };
-            let mut d = scroll_delta;
-            // A horizontal swipe moves the content the way the fingers go, which is towards
-            // higher columns on a mirrored sheet.
-            if sh.right_to_left {
-                d.x = -d.x;
-            }
-            if modifiers.shift && d.x == 0.0 {
-                d = vec2(d.y, 0.0);
-            }
-            view.scroll -= d / z;
-        }
-    }
-    // A one-finger touch drag pans the sheet, the content following the finger; it doesn't select.
-    // (Two fingers pinch-zoom through `zoom_delta` above.)
-    if resp.drag_started() && ui.input(|i| i.any_touches()) {
-        app.grid.touch_pan = true;
-    }
-    if app.grid.touch_pan && resp.dragged() && ui.input(|i| i.multi_touch().is_none()) {
-        let z = if paper { make_geo(app, view.scroll).z } else { sh.zoom as f32 / 100.0 * DISPLAY_SCALE };
-        let mut d = resp.drag_delta();
-        if sh.right_to_left {
-            d.x = -d.x;
-        }
-        view.scroll -= d / z;
-    }
-    // The zoom glides to its step like egui eases a wheel notch (90% of the way in 0.1 s), or goes
-    // there at once without animations (as for the selection outline below: View › Animations
-    // off, egui's off in the headless harness, or a screenshot on its way).
-    let mut zooming = WheelZoom::at(app, place, sh.zoom, now);
-    if let Some((to, shown)) = zooming.glide {
-        let glides = app.ui.animations && ui.ctx().global_style().animation_time > 0.0 && !app.shots.in_flight();
-        let share = egui::emath::exponential_smooth_factor(0.9, 0.1, ui.input(|i| i.stable_dt).min(0.1));
-        let z = if glides { zoom_glide_step(shown, to, share) } else { to };
-        let _ = app.session.run("view.zoom", json!({"percent": z}));
-        zooming.glide = (z != to).then_some((to, z));
-        ui.ctx().request_repaint();
-    }
-    // Store a glide's progress, or that it stopped.
-    if app.grid.wheel_zoom.is_some_and(|w| w.glide.is_some()) {
-        app.grid.wheel_zoom = Some(zooming);
-    }
-    view.scroll = view.scroll.max(egui::Vec2::ZERO);
-    let (mut max_x, mut max_y) = (sh.col_left(MAX_COLS - 20) as f32, sh.row_top(MAX_ROWS - 40) as f32);
-    if paper {
-        // Page layout units run past sheet units (margins and gaps); the end is known once the
-        // pages reach the last row / column.
-        let g = make_geo(app, view.scroll);
-        if let Some(pg) = &g.paper {
-            let (ex, ey) = pg.extent();
-            max_x = if pg.cols_complete { (ex as f32 - g.cells.width() / g.z).max(0.0) } else { 1.0e9 };
-            max_y = if pg.rows_complete { (ey as f32 - g.cells.height() / g.z).max(0.0) } else { 1.0e9 };
-        }
-    }
-    view.scroll.x = view.scroll.x.min(max_x);
-    view.scroll.y = view.scroll.y.min(max_y);
-    let mut geo = make_geo(app, view.scroll);
-    // Keep the active cell (or the moving end of an extension) visible after keyboard moves.
-    if app.grid.ensure_visible {
-        app.grid.ensure_visible = false;
-        let moving = std::mem::take(&mut app.grid.reveal_moving_end);
-        let cell = if moving { sel.moving_end() } else { sel.active };
-        let from = app.grid.reveal_from.take();
-        let target = app.editor.as_ref().and_then(|e| e.point_cell).unwrap_or(cell);
-        // A whole column's moving end sits on the sheet's last row (a whole row's on its last
-        // column): when an extension moves it only across, the view keeps its place the other way.
-        // An extension that reaches the last row itself (Ctrl+Shift+Down past the data) still
-        // follows it.
-        let extended = (moving && target == cell).then(|| sel.current());
-        let before = view.scroll;
-        if paper {
-            crate::paper_view::ensure_covers(app, &wb, si, target);
-            geo = make_geo(app, view.scroll);
-        }
-        let cr = geo.cell_rect(sh, target);
-        let area = Rect::from_min_max(pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h), geo.cells.max);
-        if target.row >= geo.fr {
-            if cr.top() < area.top() {
-                view.scroll.y -= (area.top() - cr.top()) / geo.z;
-            } else if cr.bottom() > area.bottom() - 2.0 {
-                view.scroll.y += (cr.bottom() - area.bottom() + 2.0) / geo.z;
-            }
-        } else if from.is_some_and(|f| f.row >= geo.fr) {
-            // A move from the scrolled rows into the frozen ones (Page Up or Ctrl+Up onto a frozen
-            // row 1) brings the scrolled rows back to their top; the rows it passed over would
-            // otherwise stay out of sight.
-            view.scroll.y = 0.0;
-        }
-        if target.col >= geo.fc {
-            if cr.left() < area.left() {
-                view.scroll.x -= (area.left() - cr.left()) / geo.z;
-            } else if cr.right() > area.right() - 2.0 {
-                view.scroll.x += ((cr.right() - area.right() + 2.0) / geo.z).min(cr.left() - area.left());
-            }
-        } else if from.is_some_and(|f| f.col >= geo.fc) {
-            view.scroll.x = 0.0;
-        }
-        if extended.is_some_and(|r| r.is_full_cols()) && from.is_some_and(|f| f.row == cell.row) {
-            view.scroll.y = before.y;
-        }
-        if extended.is_some_and(|r| r.is_full_rows()) && from.is_some_and(|f| f.col == cell.col) {
-            view.scroll.x = before.x;
-        }
-        view.scroll = view.scroll.max(egui::Vec2::ZERO);
-        geo = make_geo(app, view.scroll);
-    }
-    // Snap scrolling to whole rows/columns at rest like Excel? Keep smooth (better on trackpads).
-    if let Some(v) = app.view_mut() {
-        *v = view;
-    }
-    app.grid.cells_rect = Some(geo.mirror_rect(geo.cells));
-    // The selection outline glides to a new selection. It stays on its cells when Animations is
-    // off, when egui's animations are (the headless harness), and while a screenshot is on its way.
-    // A mouse button held down (a click or a drag selecting cells) moves it at once, as in Excel:
-    // a gliding outline trails the pointer and reads as lag.
-    let pointer_selecting = ui.input(|i| i.pointer.any_down());
-    let outline = app.grid.glide.frame(crate::selection_glide::Frame {
-        place,
-        range: sel.current(),
-        target: geo.range_rect(sh, sel.current()),
-        view: geo.cells,
-        now,
-        frame_nr: ui.ctx().cumulative_frame_nr(),
-        animate: app.ui.animations && ui.ctx().global_style().animation_time > 0.0 && !app.shots.in_flight() && !pointer_selecting,
-    });
-    if app.grid.glide.is_gliding() {
-        ui.ctx().request_repaint();
-    }
-    app.grid.geo = Some(geo.clone());
-    let painter = ui.painter_at(rect);
-    painter.rect_filled(rect, 0.0, t.grid_bg);
-    // Everything up to the headers is painted in logical (left-to-right) coordinates.
-    let mirror_from = painter.add(egui::Shape::Noop);
-    let mut cf = CfCache::new();
-    let quads = if geo.paper.is_some() {
-        crate::paper_view::paint_pages(app, &painter, &geo, &wb, si, sh, &sel, outline, &mut cf, &t)
-    } else {
-        paint_panes(app, &painter, &geo, &wb, si, sh, &sel, outline, &mut cf, &t)
-    };
-    // Objects above cells. A hidden object can't stay selected: Delete or the Format pane would act
-    // on something the user can't see.
-    if crate::chartview::objects_hidden(&wb) {
-        app.selected_chart = None;
-    }
-    let objects = crate::chartview::paint_objects(app, &painter.with_clip_rect(geo.cells), &geo, &wb, si, sh);
-    paint_overlays(app, ui, &painter.with_clip_rect(geo.cells), &geo, &wb, si, sh, &sel);
-    if sh.view == gridcraft_engine::model::SheetViewMode::PageBreakPreview {
-        paint_pages(app, &painter.with_clip_rect(geo.cells), &geo, sh);
-    }
-    if geo.paper.is_some() {
-        crate::paper_view::paint_headers_footers(app, ui, &painter, &geo, &wb, sh);
-    }
-    // Headers.
-    if sh.show_headings {
-        let headings = table_headings(&geo, sh, sel.active);
-        paint_headers(&painter, &geo, sh, &sel, &t, &quads, &headings);
-        paint_freeze_handles(&painter, &geo, sh, &app.grid.drag, &t);
-    }
-    crate::outline::paint(&painter, &geo, sh, &t);
-    if geo.rtl {
-        let mirror_to = painter.add(egui::Shape::Noop);
-        mirror_painted(ui.ctx(), painter.layer_id(), mirror_from.0..mirror_to.0, &geo, &objects);
-    }
-    if geo.paper.is_some() {
-        crate::paper_view::paint_rulers(app, &painter, rect, &geo, &t);
-    }
-    // Interaction.
-    let previous_popups = (app.grid.filter_menu, app.grid.list_picker, app.grid.header_menu, app.grid.fill_menu);
-    // A pan the grid never saw end (it was hidden mid-drag) must not swallow the next press.
-    if app.grid.touch_pan && !resp.dragged() && !resp.drag_stopped() {
-        app.grid.touch_pan = false;
-    }
-    if app.grid.touch_pan {
-        // Skip the frames of a touch pan, its release included.
-        if !resp.dragged() {
-            app.grid.touch_pan = false;
-        }
-    } else {
-        crate::paper_view::interact(app, ui, &resp, &geo, sh, &wb);
-        interact(app, ui, &resp, &geo, sh, &wb);
-    }
-    update_cursor(app, ui, &resp, &geo, sh);
-    crate::text_box::show(app, ui, &geo, sh);
-    if app.editor.as_ref().is_some_and(|e| !e.from_formula_bar) {
-        in_cell_editor(app, ui, &geo, sh, &wb);
-    }
-    filter_menu(app, ui, &geo, previous_popups.0 == app.grid.filter_menu);
-    list_picker(app, ui, &geo, previous_popups.1 == app.grid.list_picker);
-    header_menu(app, ui, previous_popups.2 == app.grid.header_menu);
-    context_menu(app, ui);
-    fill_menu(app, ui, previous_popups.3 == app.grid.fill_menu);
-    fill_options_tag(app, ui, &geo, sh);
-    object_menu(app, ui);
-    error_check_tag(app, ui, &geo, sh);
-    let track_x = if rtl { (available.left(), rect.left()) } else { (rect.right(), available.right()) };
-    // The track starts below the column headings and frozen rows; the bar's column beside them
-    // takes its colour too instead of showing a light square in dark mode.
-    ui.painter().rect_filled(Rect::from_min_max(pos2(track_x.0, rect.top()), pos2(track_x.1, rect.bottom())), 0.0, t.tab_bar);
-    vertical_scrollbar(app, ui, sh, &geo, track_x, max_y, &t);
-    if app.session.clipboard.is_some() {
-        // By the clock, not per frame: a gliding outline repaints more often than the ants step.
-        app.grid.marching_phase = crate::selection_glide::ants_phase(now);
-        ui.ctx().request_repaint_after(std::time::Duration::from_millis(60));
-    }
-}
-
-/// Normal view: up to four panes (frozen rows/columns), each painted with its own clip.
-#[allow(clippy::too_many_arguments)]
-fn paint_panes(
-    app: &SheetApp,
-    painter: &Painter,
-    geo: &Geo,
-    wb: &Workbook,
-    si: usize,
-    sh: &Sheet,
-    sel: &gridcraft_engine::Selection,
-    outline: Rect,
-    cf: &mut CfCache,
-    t: &Tokens,
-) -> Vec<((u32, u32), (u32, u32), Rect)> {
-    // Quadrants: (rows, cols, clip).
-    let (sr0, sr1) = geo.scroll_rows(sh);
-    let (sc0, sc1) = geo.scroll_cols(sh);
-    let fr_rows = (0, geo.fr.saturating_sub(1));
-    let fr_cols = (0, geo.fc.saturating_sub(1));
-    let split = pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h);
-    let mut quads = vec![((sr0, sr1), (sc0, sc1), Rect::from_min_max(split, geo.cells.max))];
-    if geo.fr > 0 {
-        quads.push((fr_rows, (sc0, sc1), Rect::from_min_max(pos2(split.x, geo.cells.top()), pos2(geo.cells.right(), split.y))));
-    }
-    if geo.fc > 0 {
-        quads.push(((sr0, sr1), fr_cols, Rect::from_min_max(pos2(geo.cells.left(), split.y), pos2(split.x, geo.cells.bottom()))));
-    }
-    if geo.fr > 0 && geo.fc > 0 {
-        quads.push((fr_rows, fr_cols, Rect::from_min_max(geo.cells.min, split)));
-    }
-    for (rows, cols, clip) in &quads {
-        if rows.0 > rows.1 || cols.0 > cols.1 {
-            continue;
-        }
-        let p = painter.with_clip_rect(*clip);
-        paint_quadrant(&p, geo, wb, si, sh, *rows, *cols, cf, t);
-        paint_selection(&p, geo, sh, sel, outline, t, app, *rows, *cols);
-    }
-    // Freeze lines.
-    if geo.fr > 0 {
-        painter.line_segment([pos2(geo.cells.left(), split.y), pos2(geo.cells.right(), split.y)], Stroke::new(1.0, Color32::from_gray(150)));
-    }
-    if geo.fc > 0 {
-        painter.line_segment([pos2(split.x, geo.cells.top()), pos2(split.x, geo.cells.bottom())], Stroke::new(1.0, Color32::from_gray(150)));
-    }
-    quads
-}
-
-/// The worksheet is painted virtually, so it needs its own scrollbar rather than a
-/// ScrollArea containing all million rows. Keep the scroll extent stable during a drag.
-fn vertical_scrollbar(app: &mut SheetApp, ui: &mut egui::Ui, sh: &Sheet, geo: &Geo, track_x: (f32, f32), limit: f32, t: &Tokens) {
-    let track = Rect::from_min_max(pos2(track_x.0, geo.cells.top() + geo.frozen_h), pos2(track_x.1, geo.cells.bottom()));
-    if track.height() <= 0.0 || track.width() <= 0.0 {
-        return;
-    }
-    let visible = track.height() / geo.z;
-    let scroll = app.view().scroll.y;
-    let last = sh.used_range().map(|r| r.end.row.saturating_add(10)).unwrap_or(100).clamp(100, MAX_ROWS - 1);
-    let content = geo.scroll_top_of(sh, last);
-    let extent = (content - visible).max(scroll).max(0.0).min(limit);
-    let id = ui.scope_id().with("vscroll");
-    let resp = ui.interact(track, id, Sense::click_and_drag());
-    let drag_id = id.with("extent");
-    if resp.drag_started() {
-        ui.ctx().data_mut(|d| d.insert_temp(drag_id, extent));
-    }
-    let extent = if resp.dragged() { ui.ctx().data(|d| d.get_temp::<f32>(drag_id)).unwrap_or(extent) } else { extent };
-    let thumb_h = (track.height() * visible / (extent + visible)).clamp(24.0_f32.min(track.height()), track.height());
-    let travel = track.height() - thumb_h;
-    let thumb_top = track.top() + if extent > 0.0 { travel * (scroll / extent).clamp(0.0, 1.0) } else { 0.0 };
-    let thumb = Rect::from_min_size(pos2(track.left() + 3.0, thumb_top), vec2((track.width() - 6.0).max(0.0), thumb_h));
-    ui.painter().rect_filled(track, 0.0, t.tab_bar);
-    ui.painter().rect_filled(thumb, 4.0, if resp.hovered() || resp.dragged() { t.text_dim } else { t.text_disabled });
-    let mut next = scroll;
-    if resp.dragged() && travel > 0.0 {
-        next += resp.drag_delta().y / travel * extent;
-    } else if resp.clicked()
-        && let Some(p) = resp.interact_pointer_pos()
-    {
-        if p.y < thumb.top() {
-            next -= visible;
-        } else if p.y > thumb.bottom() {
-            next += visible;
-        }
-    }
-    if resp.hovered() {
-        next -= ui.input(|i| i.smooth_scroll_delta.y) / geo.z;
-    }
-    next = next.clamp(0.0, limit);
-    if next != scroll {
-        if let Some(v) = app.view_mut() {
-            v.scroll.y = next;
-        }
-        ui.ctx().request_repaint();
-    }
-}
-
-/// The horizontal counterpart of `vertical_scrollbar`, drawn in the sheet tab bar as in Excel. The tab
-/// bar is laid out before the grid, so this reads the last frame's geometry and leaves clamping the
-/// far end to the grid, which runs later in the same frame.
-pub(crate) fn horizontal_scrollbar(app: &mut SheetApp, ui: &mut egui::Ui, track: Rect, t: &Tokens) {
-    app.grid.hscroll = Some(track);
-    if track.height() <= 0.0 || track.width() <= 0.0 {
-        return;
-    }
-    let Some(geo) = app.grid.geo.clone() else { return };
-    let Some(wb) = app.session.active().map(|d| d.wb.clone()) else { return };
-    let Some(sh) = wb.active() else { return };
-    let visible = ((geo.cells.width() - geo.frozen_w) / geo.z).max(0.0);
-    let scroll = app.view().scroll.x;
-    let last = sh.used_range().map(|r| r.end.col.saturating_add(10)).unwrap_or(26).clamp(26, MAX_COLS - 1);
-    let content = geo.scroll_left_of(sh, last);
-    let extent = (content - visible).max(scroll).max(0.0);
-    let id = ui.scope_id().with("hscroll");
-    let resp = ui.interact(track, id, Sense::click_and_drag());
-    let drag_id = id.with("extent");
-    if resp.drag_started() {
-        ui.ctx().data_mut(|d| d.insert_temp(drag_id, extent));
-    }
-    let extent = if resp.dragged() { ui.ctx().data(|d| d.get_temp::<f32>(drag_id)).unwrap_or(extent) } else { extent };
-    let thumb_w = (track.width() * visible / (extent + visible).max(1.0)).clamp(24.0_f32.min(track.width()), track.width());
-    let travel = track.width() - thumb_w;
-    let offset = if extent > 0.0 { travel * (scroll / extent).clamp(0.0, 1.0) } else { 0.0 };
-    // A right-to-left sheet scrolls towards the left, so its thumb starts at the right end.
-    let dir = if geo.rtl { -1.0 } else { 1.0 };
-    let thumb_left = if geo.rtl { track.right() - thumb_w - offset } else { track.left() + offset };
-    let thumb = Rect::from_min_size(pos2(thumb_left, track.top() + 3.0), vec2(thumb_w, (track.height() - 6.0).max(0.0)));
-    ui.painter().rect_filled(track, 0.0, t.tab_bar);
-    ui.painter().rect_filled(thumb, 4.0, if resp.hovered() || resp.dragged() { t.text_dim } else { t.text_disabled });
-    let mut next = scroll;
-    if resp.dragged() && travel > 0.0 {
-        next += dir * resp.drag_delta().x / travel * extent;
-    } else if resp.clicked()
-        && let Some(p) = resp.interact_pointer_pos()
-    {
-        if p.x < thumb.left() {
-            next -= dir * visible;
-        } else if p.x > thumb.right() {
-            next += dir * visible;
-        }
-    }
-    if resp.hovered() {
-        let d = ui.input(|i| i.smooth_scroll_delta);
-        next -= (if d.x != 0.0 { dir * d.x } else { d.y }) / geo.z;
-    }
-    next = next.max(0.0);
-    if next != scroll {
-        if let Some(v) = app.view_mut() {
-            v.scroll.x = next;
-        }
-        ui.ctx().request_repaint();
-    }
-}
-
-pub(crate) fn wrapped_cell_text_y(valign: VAlign, rect: Rect, gh: f32, z: f32) -> f32 {
-    let pad_v = 1.5 * z;
-    let y_top = rect.top() + pad_v;
-    // Not clamped to `y_top`: text taller than the row overflows upward (Bottom) or both ways
-    // (Center), and the cell's clip rect trims it, so Middle and Bottom stay distinct from Top.
-    let y_bottom = rect.bottom() - gh - pad_v;
-    match valign {
-        VAlign::Top => y_top,
-        VAlign::Center | VAlign::Justify | VAlign::Distributed => (y_top + y_bottom) / 2.0,
-        VAlign::Bottom => y_bottom,
-    }
-}
-
-pub(crate) fn cell_text_y(valign: VAlign, rect: Rect, gh: f32, z: f32) -> f32 {
-    let top_inset = 1.0 * z;
-    let y_top = rect.top() - top_inset;
-    let y_bottom = (rect.bottom() - gh - 0.5 * z).max(y_top);
-    match valign {
-        VAlign::Top => y_top,
-        VAlign::Center | VAlign::Justify | VAlign::Distributed => (y_top + y_bottom) / 2.0,
-        VAlign::Bottom => y_bottom,
-    }
-}
-
-/// Where to put a `TextShape` holding a galley of `size` turned by `angle` (egui radians, so
-/// negative for upward text) for it to sit in `rect` per the cell's alignment. egui turns the
-/// galley about `pos`, its top-left corner, so the turned box is placed first and `pos` follows.
-/// General keeps the text at the left. Bottom (the default) puts upward text at the bottom, but
-/// downward text at the top, where it starts reading.
-pub(crate) fn rotated_text_pos(rect: Rect, size: egui::Vec2, angle: f32, h: HAlign, v: VAlign, pad: f32, indent: f32) -> Pos2 {
-    let rot = egui::emath::Rot2::from_angle(angle);
-    let turned = Rect::from_points(&[vec2(0.0, 0.0), vec2(size.x, 0.0), vec2(0.0, size.y), size].map(|c| (rot * c).to_pos2()));
-    let x = match h {
-        HAlign::Center | HAlign::CenterAcross | HAlign::Distributed => rect.center().x - turned.width() / 2.0,
-        HAlign::Right => rect.right() - pad - indent - turned.width(),
-        _ => rect.left() + pad + indent,
-    };
-    let y = match v {
-        VAlign::Center | VAlign::Justify | VAlign::Distributed => rect.center().y - turned.height() / 2.0,
-        VAlign::Bottom if angle < 0.0 => rect.bottom() - pad - turned.height(),
-        _ => rect.top() + pad,
-    };
-    pos2(x, y) - turned.min.to_vec2()
-}
-
-/// Mirror what the grid painted into `layer` (the shape indices in `range`) for a right-to-left
-/// sheet. Geometry is reflected; text and meshes (glyphs, pictures) keep their reading direction
-/// and only move so that their box lands mirrored. Floating objects (`objects`: shape index
-/// ranges with their logical rect) move as a whole, so a chart keeps its axes and a picture
-/// isn't flipped.
-fn mirror_painted(ctx: &egui::Context, layer: egui::LayerId, range: std::ops::Range<usize>, geo: &Geo, objects: &[crate::chartview::PaintedObject]) {
-    let axis = geo.rect.left() + geo.rect.right();
-    ctx.graphics_mut(|g| {
-        let list = g.entry(layer);
-        for i in range {
-            let object = objects.iter().find(|o| o.shapes.contains(&i));
-            list.mutate_shape(egui::layers::ShapeIdx(i), |cs| {
-                cs.clip_rect = geo.mirror_rect(cs.clip_rect);
-                match object {
-                    Some(o) => cs.shape.translate(vec2(axis - o.rect.right() - o.rect.left(), 0.0)),
-                    None => mirror_shape(&mut cs.shape, axis),
-                }
-            });
-        }
-    });
-}
-
-/// Reflect one shape across the vertical line `x = axis / 2`.
-fn mirror_shape(shape: &mut egui::Shape, axis: f32) {
-    use egui::Shape;
-    let flip = |p: &mut Pos2| p.x = axis - p.x;
-    match shape {
-        Shape::Noop | Shape::Callback(_) => {}
-        Shape::Vec(v) => v.iter_mut().for_each(|s| mirror_shape(s, axis)),
-        Shape::Circle(c) => flip(&mut c.center),
-        Shape::Ellipse(e) => flip(&mut e.center),
-        Shape::LineSegment { points, .. } => points.iter_mut().for_each(flip),
-        Shape::Path(p) => {
-            p.points.iter_mut().for_each(flip);
-            // Keep the preferred (clockwise) winding for filled polygons.
-            p.points.reverse();
-        }
-        Shape::Rect(r) => {
-            r.rect = Rect::from_min_max(pos2(axis - r.rect.right(), r.rect.top()), pos2(axis - r.rect.left(), r.rect.bottom()));
-            let c = r.corner_radius;
-            r.corner_radius = egui::CornerRadius { nw: c.ne, ne: c.nw, sw: c.se, se: c.sw };
-        }
-        Shape::QuadraticBezier(b) => b.points.iter_mut().for_each(flip),
-        Shape::CubicBezier(b) => b.points.iter_mut().for_each(flip),
-        _ => {
-            let b = shape.visual_bounding_rect();
-            if b.is_finite() {
-                shape.translate(vec2(axis - b.right() - b.left(), 0.0));
-            }
-        }
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn paint_quadrant(
-    p: &Painter,
-    geo: &Geo,
-    wb: &Workbook,
-    si: usize,
-    sh: &Sheet,
-    rows: (u32, u32),
-    cols: (u32, u32),
-    cf: &mut CfCache,
-    t: &Tokens,
-) {
-    let z = geo.z;
-    let (r0, r1) = rows;
-    let (c0, c1) = cols;
-    let range = RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1));
-    // Merges are looked up 20 columns beyond the quadrant too: text overflowing in from off-screen cells stops at them.
-    let near = RangeRef::new(CellRef::new(r0, c0.saturating_sub(20)), CellRef::new(r1, c1.saturating_add(20).min(MAX_COLS - 1)));
-    let merges: Vec<RangeRef> = sh.merges.iter().filter(|m| m.intersects(&near)).copied().collect();
-    let in_merge = |c: CellRef| merges.iter().find(|m| m.contains(c)).copied();
-    // Gridlines.
-    if sh.show_gridlines {
-        let stroke = Stroke::new(1.0, t.gridline);
-        let top = geo.y(sh, r0);
-        let bottom = geo.y(sh, r1 + 1);
-        let left = geo.x(sh, c0);
-        let right = geo.x(sh, c1 + 1);
-        for c in c0..=c1 + 1 {
-            if c <= c1 && sh.col_width(c) == 0.0 {
-                continue;
-            }
-            let x = geo.x(sh, c).round() - 0.5;
-            p.line_segment([pos2(x, top), pos2(x, bottom)], stroke);
-        }
-        for r in r0..=r1 + 1 {
-            if r <= r1 && sh.row_height(r) == 0.0 {
-                continue;
-            }
-            let y = geo.y(sh, r).round() - 0.5;
-            p.line_segment([pos2(left, y), pos2(right, y)], stroke);
-        }
-    }
-    // Merged areas: blank them (no inner gridlines) and paint as one cell.
-    let mut cells: Vec<CellRef> = Vec::new();
-    for r in r0..=r1 {
-        if sh.row_height(r) == 0.0 {
-            continue;
-        }
-        for c in c0..=c1 {
-            if sh.col_width(c) == 0.0 {
-                continue;
-            }
-            cells.push(CellRef::new(r, c));
-        }
-    }
-    let empty_ok = |c: CellRef| -> bool { sh.value_ref(c).is_none_or(Value::is_empty) && in_merge(c).is_none() };
-    // Backgrounds.
-    let mut looks: Vec<(CellRef, Rect, Look, Option<CfLook>)> = Vec::with_capacity(cells.len().min(20_000));
-    for &c in &cells {
-        let (rect, anchor) = match in_merge(c) {
-            Some(m) if m.start != c && !(c.row == r0.max(m.start.row) && c.col == c0.max(m.start.col)) => continue,
-            Some(m) => (geo.range_rect(sh, m), m.start),
-            None => (geo.cell_rect(sh, c), c),
-        };
-        let (lk, cfl) = look(wb, si, sh, anchor, cf);
-        if let Some(f) = lk.fill {
-            p.rect_filled(rect.expand(0.0), 0.0, f);
-        } else if in_merge(c).is_some() {
-            p.rect_filled(rect.shrink(0.5), 0.0, Color32::WHITE);
-        }
-        looks.push((anchor, rect, lk, cfl));
-    }
-    // Text cells just outside the quadrant whose text may overflow into it: the nearest non-empty
-    // cell left of `c0` and right of `c1` in each row (within the same frozen / scrolled pane).
-    let mut outside: Vec<(CellRef, Rect, Look, Option<CfLook>)> = Vec::new();
-    let same_pane = |col: u32| (col < geo.fc) == (c0 < geo.fc);
-    for r in r0..=r1 {
-        if sh.row_height(r) == 0.0 {
-            continue;
-        }
-        let left = (c0.saturating_sub(20)..c0).rev().map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n));
-        let right = (c1.saturating_add(1)..=c1.saturating_add(20).min(MAX_COLS - 1)).map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n));
-        for n in [left, right].into_iter().flatten() {
-            if same_pane(n.col) && sh.col_width(n.col) > 0.0 && in_merge(n).is_none() {
-                let (lk, cfl) = look(wb, si, sh, n, cf);
-                outside.push((n, geo.cell_rect(sh, n), lk, cfl));
-            }
-        }
-    }
-    // Text and per-cell decorations.
-    for (c, rect, lk, cfl) in looks.iter().chain(&outside) {
-        let c = *c;
-        if let Some(picture) = sh.cell_pictures.get(&c) {
-            crate::cell_pictures::paint(p, *rect, picture);
-            continue;
-        }
-        let v = sh.value(c);
-        if let Some(l) = cfl
-            && let Some((frac, rgb, gradient)) = l.bar
-        {
-            let bar = Rect::from_min_size(pos2(rect.left() + 2.0, rect.top() + 2.0), vec2((rect.width() - 4.0) * frac, rect.height() - 4.0));
-            let col = theme::color32(rgb);
-            if gradient {
-                let mut mesh = egui::Mesh::default();
-                let light = Color32::from_rgb(
-                    ((rgb[0] as u16 + 255 * 3) / 4) as u8,
-                    ((rgb[1] as u16 + 255 * 3) / 4) as u8,
-                    ((rgb[2] as u16 + 255 * 3) / 4) as u8,
-                );
-                let i = mesh.vertices.len() as u32;
-                for (pt, cc) in [(bar.left_top(), col), (bar.right_top(), light), (bar.right_bottom(), light), (bar.left_bottom(), col)] {
-                    mesh.colored_vertex(pt, cc);
-                }
-                mesh.add_triangle(i, i + 1, i + 2);
-                mesh.add_triangle(i, i + 2, i + 3);
-                p.add(mesh);
-                p.rect_stroke(bar, 0.0, Stroke::new(1.0, col), StrokeKind::Inside);
-            } else {
-                p.rect_filled(bar, 0.0, col);
-            }
-        }
-        let mut text_left = rect.left();
-        if let Some(l) = cfl
-            && let Some((set, idx)) = &l.icon
-        {
-            let r = Rect::from_min_size(pos2(rect.left() + 2.0, rect.center().y - 6.0 * z), vec2(12.0 * z, 12.0 * z));
-            paint_cf_icon(p, r, set, *idx);
-            text_left += 15.0 * z;
-        }
-        if lk.style.num_fmt.as_str() == "checkbox" && matches!(v, Value::Bool(_) | Value::Empty) {
-            let s = (11.0 * z * 1.2).clamp(8.0, 24.0);
-            let b = Rect::from_center_size(rect.center(), vec2(s, s));
-            let on = v == Value::Bool(true);
-            p.rect_filled(b, 2.0, if on { Color32::from_rgb(0x10, 0x7C, 0x41) } else { Color32::WHITE });
-            p.rect_stroke(
-                b,
-                2.0,
-                Stroke::new(1.0, if on { Color32::from_rgb(0x10, 0x7C, 0x41) } else { Color32::from_gray(110) }),
-                StrokeKind::Inside,
-            );
-            if on {
-                crate::icons::paint_on_sheet(p, b.shrink(1.5), crate::icons::Icon::Check, Color32::WHITE);
-            }
-            continue;
-        }
-        if cfl.as_ref().is_some_and(|l| l.hide_value) || v.is_empty() {
-            continue;
-        }
-        // Align and clip header text inside the content area, away from the dropdown.
-        let filter_space = sh.filter_button_space(c) * z;
-        let text_rect = Rect::from_min_max(rect.min, pos2((rect.right() - filter_space).max(rect.left()), rect.bottom()));
-        let rect = &text_rect;
-        let st = &lk.style;
-        let size = st.font.size * 96.0 / 72.0 * z;
-        let fam = theme::cell_family(&st.font.name, st.font.bold, st.font.italic);
-        let font = FontId::new(size, fam);
-        // Digits fit by the cell's own font and size, not the default 11pt (9pt marks in narrow columns).
-        let char_w = p.layout_no_wrap("0".to_string(), font.clone(), Color32::PLACEHOLDER).size().x.max(1.0);
-        let avail_w = rect.right() - text_left;
-        let (mut text, ncolor, numeric, fill_char) = display_text(wb, sh, c, &v, st, avail_w / z.max(0.1) * z, char_w);
-        if sh.show_formulas && sh.cell(c).is_some_and(|cell| cell.formula.is_some()) {
-            text = crate::formula_locale::display(&text, crate::i18n::current(p.ctx()).formula_locale(), wb, si);
-        }
-        if text.is_empty() {
-            continue;
-        }
-        let color = ncolor.unwrap_or(lk.text_color);
-        let halign = match st.align.h {
-            HAlign::General => match v {
-                Value::Number(_) => HAlign::Right,
-                Value::Bool(_) | Value::Error(_) => HAlign::Center,
-                _ if numeric => HAlign::Right,
-                _ => HAlign::Left,
-            },
-            h => painted_halign(h, geo.rtl),
-        };
-        let indent = st.align.indent as f32 * 9.0 * z;
-        let pad = 2.5 * z;
-        let rotated = st.align.rotation != 0 && st.align.rotation != 255;
-        // Rotated text wraps along its own direction (below), not across the column width.
-        if !rotated && (st.align.wrap || st.align.h == HAlign::Justify) {
-            let wrap_w = (rect.width() - 2.0 * pad - indent).max(4.0);
-            let mut job = egui::text::LayoutJob::simple(text.clone(), font.clone(), color, wrap_w);
-            job.halign = match halign {
-                HAlign::Center | HAlign::CenterAcross => egui::Align::Center,
-                HAlign::Right => egui::Align::RIGHT,
-                _ => egui::Align::LEFT,
-            };
-            let galley = p.layout_job(job);
-            let x = match halign {
-                HAlign::Center | HAlign::CenterAcross => rect.center().x,
-                HAlign::Right => rect.right() - pad,
-                _ => text_left + pad + indent,
-            };
-            let y = wrapped_cell_text_y(st.align.v, *rect, galley.size().y, z);
-            p.with_clip_rect(rect.intersect(p.clip_rect())).galley(pos2(x, y), galley, color);
-            continue;
-        }
-        // Wrap Text off: Excel ignores the line breaks and draws the whole string on one line.
-        let first_line: String = text.chars().filter(|&ch| ch != '\n' && ch != '\r').collect();
-        // The fill position indexes `text`; move it back by the breaks removed before it.
-        let fill_char = fill_char.map(|(ch, pos)| (ch, pos.saturating_sub(text.get(..pos).map_or(0, |s| s.matches(['\n', '\r']).count()))));
-        // Shrink to fit: too-wide content is drawn in a smaller font so it fits the cell (or the
-        // merged area): it neither spills, nor is clipped, nor turns into ####.
-        let small = (st.align.shrink && !rotated && st.align.h != HAlign::Fill && fill_char.is_none())
-            .then(|| shrink_font(p, &first_line, &font, avail_w - 2.0 * pad - indent))
-            .flatten();
-        let shrunk = small.is_some();
-        let font = small.unwrap_or(font);
-        let mut galley = p.layout_no_wrap(first_line.clone(), font.clone(), color);
-        let mut w = galley.size().x;
-        // Numbers and dates never overflow: they show #### when too narrow.
-        let hashed = !shrunk && (numeric || matches!(v, Value::Number(_))) && w > avail_w - 2.0 * pad && st.align.h != HAlign::Fill;
-        if hashed {
-            // Measured on `#` itself: it is wider than `0` in some fonts, and #### must fit its cell.
-            let hash_w = p.layout_no_wrap("#".to_string(), font.clone(), color).size().x.max(1.0);
-            let n = ((avail_w - 2.0 * pad) / hash_w).floor().max(1.0) as usize;
-            galley = p.layout_no_wrap("#".repeat(n), font.clone(), color);
-            w = galley.size().x;
-        }
-        // Repeat fill (`*` in number formats) / Fill alignment. A number already shown as #### keeps
-        // it: rebuilding it from the text would overflow and clip its leading digits.
-        if let Some((ch, pos)) = fill_char
-            && !hashed
-            && pos <= first_line.len()
-        {
-            let base_w = w;
-            let cw = p.layout_no_wrap(ch.to_string(), font.clone(), color).size().x.max(1.0);
-            let n = (((avail_w - 2.0 * pad) - base_w) / cw).floor().max(0.0) as usize;
-            let mut s = first_line.clone();
-            if first_line.is_char_boundary(pos) {
-                s.insert_str(pos, &ch.to_string().repeat(n));
-            }
-            galley = p.layout_no_wrap(s, font.clone(), color);
-            w = galley.size().x;
-        }
-        // Center Across Selection: the text is centred over this cell and the empty cells to its right that also use it.
-        let across_end = if halign == HAlign::CenterAcross && !rotated && in_merge(c).is_none() {
-            center_across_end(c.col, c1 + 20, |col| {
-                let n = CellRef::new(c.row, col);
-                empty_ok(n) && wb.styles.get(sh.style_id(n)).align.h == HAlign::CenterAcross
-            })
-        } else {
-            c.col
-        };
-        // Overflow into empty neighbours for text (not upright text, whose width is its line height).
-        let mut clip = *rect;
-        let overflows = !numeric && !matches!(v, Value::Number(_)) && st.align.rotation.abs() != 90 && w > rect.width() - 2.0 * pad;
-        if filter_space == 0.0 && (overflows || across_end > c.col) && in_merge(c).is_none() {
-            let mut right = rect.right();
-            let mut left = rect.left();
-            if across_end > c.col {
-                right = geo.x(sh, across_end + 1);
-            }
-            if matches!(halign, HAlign::Left | HAlign::Center | HAlign::Justify) {
-                let mut cc = c.col + 1;
-                while right - rect.left() < w + 2.0 * pad && cc < MAX_COLS && empty_ok(CellRef::new(c.row, cc)) && cc <= c1 + 20 {
-                    right = geo.x(sh, cc + 1);
-                    cc += 1;
-                }
-            }
-            if matches!(halign, HAlign::Right | HAlign::Center) {
-                let mut cc = c.col;
-                while rect.right() - left < w + 2.0 * pad && cc > 0 && empty_ok(CellRef::new(c.row, cc - 1)) && cc + 20 > c0 {
-                    cc -= 1;
-                    left = geo.x(sh, cc);
-                }
-            }
-            clip = Rect::from_min_max(pos2(left, rect.top()), pos2(right, rect.bottom()));
-            // Paint over the gridlines the text passes through.
-            if lk.fill.is_none() {
-                let inner = Rect::from_min_max(pos2(clip.left() + 1.0, clip.top() + 0.5), pos2(clip.right() - 1.0, clip.bottom() - 1.0));
-                let extra_l = Rect::from_min_max(inner.min, pos2(rect.left() + 1.0, inner.bottom()));
-                let extra_r = Rect::from_min_max(pos2(rect.right() - 1.0, inner.top()), inner.max);
-                if extra_l.width() > 0.0 {
-                    p.rect_filled(extra_l, 0.0, t.grid_bg);
-                }
-                if extra_r.width() > 0.0 {
-                    p.rect_filled(extra_r, 0.0, t.grid_bg);
-                }
-            }
-        }
-        let x = match halign {
-            HAlign::CenterAcross => clip.center().x - w / 2.0,
-            HAlign::Center | HAlign::Distributed => rect.center().x - w / 2.0,
-            HAlign::Right => rect.right() - pad - w - indent,
-            _ => text_left + pad + indent,
-        };
-        let gh = galley.size().y;
-        let y = cell_text_y(st.align.v, *rect, gh, z);
-        let cp = p.with_clip_rect(clip.intersect(p.clip_rect()));
-        if rotated {
-            let angle = -(st.align.rotation as f32).to_radians();
-            // Upright (±90°) wrapped text wraps to the row height: lines then stack across the column.
-            let galley = if st.align.wrap && st.align.rotation.abs() == 90 {
-                let job = egui::text::LayoutJob::simple(text.clone(), font.clone(), color, (rect.height() - 2.0 * pad).max(4.0));
-                p.layout_job(job)
-            } else {
-                galley.clone()
-            };
-            let pos = rotated_text_pos(*rect, galley.size(), angle, painted_halign(st.align.h, geo.rtl), st.align.v, pad, indent);
-            let mut shape = egui::epaint::TextShape::new(pos, galley, color);
-            shape.angle = angle;
-            cp.add(shape);
-        } else {
-            cp.galley(pos2(x, y), galley.clone(), color);
-        }
-        let baseline = y + gh * 0.82;
-        match st.font.underline {
-            Underline::None => {}
-            Underline::Double | Underline::DoubleAccounting => {
-                cp.line_segment([pos2(x, baseline + 1.0), pos2(x + w, baseline + 1.0)], Stroke::new(1.0, color));
-                cp.line_segment([pos2(x, baseline + 3.0), pos2(x + w, baseline + 3.0)], Stroke::new(1.0, color));
-            }
-            _ => {
-                cp.line_segment([pos2(x, baseline + 1.0), pos2(x + w, baseline + 1.0)], Stroke::new(1.0, color));
-            }
-        }
-        if st.font.strike {
-            cp.line_segment([pos2(x, y + gh * 0.55), pos2(x + w, y + gh * 0.55)], Stroke::new(1.0, color));
-        }
-    }
-    // Borders (over fills and text).
-    for (c, rect, lk, _) in &looks {
-        let b = &lk.style.borders;
-        let merge = merges.iter().find(|m| m.start == *c);
-        let edges = match merge {
-            // A merged area's outline lives on the cells along each of its edges (Excel writes the
-            // right edge on the last column's cells and the bottom edge on the last row's), so each
-            // edge is drawn cell by cell from the cell it belongs to.
-            Some(m) => merged_edges(wb, si, sh, geo, *m, *rect, (r0, r1), (c0, c1), cf),
-            None => vec![
-                (b.top, [rect.left_top(), rect.right_top()]),
-                (b.bottom, [rect.left_bottom(), rect.right_bottom()]),
-                (b.left, [rect.left_top(), rect.left_bottom()]),
-                (b.right, [rect.right_top(), rect.right_bottom()]),
-            ],
-        };
-        for (line, pts) in edges {
-            if line.is_none() {
-                continue;
-            }
-            let col = col32(line.color, wb, Color32::BLACK);
-            paint_border(p, pts, line.style, col);
-        }
-        if !b.diag_down.is_none() {
-            paint_border(p, [rect.left_top(), rect.right_bottom()], b.diag_down.style, col32(b.diag_down.color, wb, Color32::BLACK));
-        }
-        if !b.diag_up.is_none() {
-            paint_border(p, [rect.left_bottom(), rect.right_top()], b.diag_up.style, col32(b.diag_up.color, wb, Color32::BLACK));
-        }
-        // Comment / note indicator.
-        if let Some(cm) = sh.comments.get(c) {
-            let tri_col = if cm.threaded { Color32::from_rgb(0x88, 0x55, 0xC8) } else { Color32::from_rgb(0xD0, 0x2E, 0x2E) };
-            let s = 6.0 * z.max(0.7);
-            p.add(egui::Shape::convex_polygon(
-                vec![rect.right_top(), pos2(rect.right(), rect.top() + s), pos2(rect.right() - s, rect.top())],
-                tri_col,
-                Stroke::NONE,
-            ));
-        }
-        // Background error checking: a number stored as text gets Excel's green corner (#1994).
-        if !sh.show_formulas && sh.cell(*c).and_then(gridcraft_engine::cmd::formulas::number_stored_as_text).is_some() {
-            let s = 6.0 * z.max(0.7);
-            p.add(egui::Shape::convex_polygon(
-                vec![rect.left_top(), pos2(rect.left() + s, rect.top()), pos2(rect.left(), rect.top() + s)],
-                t.error_check_green,
-                Stroke::NONE,
-            ));
-        }
-    }
-    // Sparklines.
-    for sp in &sh.sparklines {
-        if !range.contains(sp.cell) {
-            continue;
-        }
-        let rect = geo.cell_rect(sh, sp.cell).shrink(3.0);
-        let vals: Vec<Option<f64>> = match gridcraft_engine::calc::evaluate(wb, si, sp.cell, &sp.source) {
-            Value::Array(a) => a.data.iter().map(Value::as_f64).collect(),
-            v => vec![v.as_f64()],
-        };
-        let col = sp.color.resolve(&wb.theme).unwrap_or([0x2B, 0x7C, 0xD3]);
-        let prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [col[0], col[1], col[2], 255], sp.markers, rect.width(), rect.height());
-        crate::chartview::paint_prims(p, rect.min, &prims, 1.0);
-    }
-    // Filter buttons.
-    let mut buttons: Vec<(CellRef, bool)> = Vec::new();
-    if let Some(af) = &sh.autofilter {
-        for col in af.range.start.col..=af.range.end.col {
-            let active = af.criteria.iter().any(|(o, _)| af.range.start.col + o == col);
-            buttons.push((CellRef::new(af.range.start.row, col), active));
-        }
-    }
-    for tb in &sh.tables {
-        if tb.filter_button && tb.header_row {
-            for col in tb.range.start.col..=tb.range.end.col {
-                buttons.push((CellRef::new(tb.range.start.row, col), false));
-            }
-        }
-    }
-    for (c, active) in buttons {
-        if !range.contains(c) {
-            continue;
-        }
-        paint_filter_button(p, filter_button_rect(geo, sh, c), active);
-    }
-}
-
-pub fn filter_button_rect(geo: &Geo, sh: &Sheet, c: CellRef) -> Rect {
-    let rect = geo.cell_rect(sh, c);
-    // Keep the button within the same header slot that AutoFit reserves.
-    let pad = 2.0 * geo.z;
-    let s = (rect.height() - 4.0).clamp(10.0, 18.0).min((sh.filter_button_space(c) * geo.z - pad).max(0.0));
-    Rect::from_min_size(pos2(rect.right() - s - pad, rect.bottom() - s - pad), vec2(s, s))
-}
-
-/// A Table column heading that shows the column's header name in place of its letters.
-#[derive(Clone, Debug)]
-pub struct TableHeading {
-    pub col: u32,
-    /// The table's header row, which the filter menu is keyed by.
-    pub header_row: u32,
-    pub name: String,
-    /// The heading slot over the column (logical coordinates).
-    pub rect: Rect,
-    /// The filter button, when the table shows filter buttons.
-    pub button: Option<Rect>,
-    /// The column is filtered (the button shows the funnel).
-    pub filtered: bool,
-}
-
-/// The Table whose header names replace the column letters: the one holding the active cell,
-/// with its header row scrolled out of view and some of its rows still in view (Excel, #1423).
-pub fn heading_table<'a>(geo: &Geo, sh: &'a Sheet, active: CellRef) -> Option<&'a gridcraft_engine::model::Table> {
-    // Page Layout view keeps the letters.
-    if geo.paper.is_some() || geo.header_h <= 0.0 {
-        return None;
-    }
-    let tb = sh.tables.iter().find(|t| t.header_row && t.range.contains(active))?;
-    let header = tb.range.start.row;
-    // A header row in the frozen rows is always on screen.
-    if header < geo.fr {
-        return None;
-    }
-    let top = geo.cells.top() + geo.frozen_h;
-    let bottom = |r: u32| geo.y(sh, r) + sh.row_height(r) * geo.z;
-    (bottom(header) <= top + 0.5 && bottom(tb.range.end.row) > top + 0.5).then_some(tb)
-}
-
-/// The headings of `heading_table`'s visible columns.
-pub fn table_headings(geo: &Geo, sh: &Sheet, active: CellRef) -> Vec<TableHeading> {
-    let Some(tb) = heading_table(geo, sh, active) else { return Vec::new() };
-    let af = sh.autofilter.as_ref().filter(|af| af.range == tb.range);
-    let mut out = Vec::new();
-    for col in tb.range.start.col..=tb.range.end.col {
-        let w = sh.col_width(col) * geo.z;
-        let off = col - tb.range.start.col;
-        let Some(column) = tb.columns.get(off as usize) else { continue };
-        if w <= 0.0 {
-            continue;
-        }
-        let rect = Rect::from_min_size(pos2(geo.x(sh, col), geo.head_top()), vec2(w, geo.header_h));
-        // Clear of the 4-point column resize edge, and never wider than the column.
-        let s = (rect.height() - 6.0).clamp(10.0, 16.0).min(w - 7.0);
-        let button = (tb.filter_button && s > 0.0).then(|| Rect::from_min_size(pos2(rect.right() - s - 5.0, rect.center().y - s / 2.0), vec2(s, s)));
-        let filtered = tb.filter.iter().any(|(o, _)| *o == off) || af.is_some_and(|af| af.criteria.iter().any(|(o, _)| *o == off));
-        out.push(TableHeading { col, header_row: tb.range.start.row, name: column.name.clone(), rect, button, filtered });
-    }
-    out
-}
-
-fn paint_filter_button(p: &Painter, r: Rect, filtered: bool) {
-    let t = Tokens::get(p.ctx());
-    p.rect_filled(r, 2.0, t.sheet_control_bg);
-    p.rect_stroke(r, 2.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Inside);
-    crate::icons::paint_on_sheet(
-        p,
-        r.shrink(1.5),
-        if filtered { crate::icons::Icon::Filter } else { crate::icons::Icon::Chevron },
-        t.sheet_control_text,
-    );
-}
-
-/// The outline segments of merged area `m` drawn at `rect`: the top and left edges come from the
-/// first row's and first column's cells, the bottom and right edges from the last row's and last
-/// column's cells, one segment per visible cell (limited to the visible `rows` × `cols`).
-#[allow(clippy::too_many_arguments)]
-fn merged_edges(
-    wb: &Workbook,
-    si: usize,
-    sh: &Sheet,
-    geo: &Geo,
-    m: RangeRef,
-    rect: Rect,
-    rows: (u32, u32),
-    cols: (u32, u32),
-    cf: &mut CfCache,
-) -> Vec<(BorderLine, [Pos2; 2])> {
-    let mut out = Vec::new();
-    let (cs, ce) = (m.start.col.max(cols.0), m.end.col.min(cols.1));
-    for col in cs..=ce {
-        if sh.col_width(col) == 0.0 {
-            continue;
-        }
-        let (x0, x1) = (geo.x(sh, col), geo.x(sh, col.saturating_add(1)));
-        let top = look(wb, si, sh, CellRef::new(m.start.row, col), cf).0.style.borders.top;
-        let bottom = look(wb, si, sh, CellRef::new(m.end.row, col), cf).0.style.borders.bottom;
-        out.push((top, [pos2(x0, rect.top()), pos2(x1, rect.top())]));
-        out.push((bottom, [pos2(x0, rect.bottom()), pos2(x1, rect.bottom())]));
-    }
-    let (rs, re) = (m.start.row.max(rows.0), m.end.row.min(rows.1));
-    for row in rs..=re {
-        if sh.row_height(row) == 0.0 {
-            continue;
-        }
-        let (y0, y1) = (geo.y(sh, row), geo.y(sh, row.saturating_add(1)));
-        let left = look(wb, si, sh, CellRef::new(row, m.start.col), cf).0.style.borders.left;
-        let right = look(wb, si, sh, CellRef::new(row, m.end.col), cf).0.style.borders.right;
-        out.push((left, [pos2(rect.left(), y0), pos2(rect.left(), y1)]));
-        out.push((right, [pos2(rect.right(), y0), pos2(rect.right(), y1)]));
-    }
-    out
-}
-
-/// The smaller font that makes `text` fit in `room` points of width (Shrink to fit), or `None`
-/// when it already fits at its own size.
-fn shrink_font(p: &Painter, text: &str, font: &FontId, room: f32) -> Option<FontId> {
-    let natural = p.layout_no_wrap(text.to_string(), font.clone(), Color32::PLACEHOLDER).size().x;
-    let room = room.max(1.0);
-    if natural.is_nan() || natural <= room {
-        return None;
-    }
-    // Glyph advances don't scale exactly linearly (rounding), so leave a little slack.
-    let size = (font.size * room / natural * 0.97).max(1.0);
-    Some(FontId::new(size, font.family.clone()))
-}
-
-pub(crate) fn paint_border(p: &Painter, pts: [Pos2; 2], style: BorderStyle, col: Color32) {
-    let w = style.width();
-    let (a, b) = (pts[0], pts[1]);
-    match style {
-        BorderStyle::Double => {
-            let horiz = (a.y - b.y).abs() < 0.5;
-            let off = if horiz { vec2(0.0, 1.5) } else { vec2(1.5, 0.0) };
-            p.line_segment([a - off, b - off], Stroke::new(1.0, col));
-            p.line_segment([a + off, b + off], Stroke::new(1.0, col));
-        }
-        BorderStyle::Dashed
-        | BorderStyle::MediumDashed
-        | BorderStyle::DashDot
-        | BorderStyle::MediumDashDot
-        | BorderStyle::DashDotDot
-        | BorderStyle::MediumDashDotDot
-        | BorderStyle::SlantDashDot => {
-            p.extend(egui::Shape::dashed_line(&[a, b], Stroke::new(w, col), 4.0, 2.0));
-        }
-        BorderStyle::Dotted | BorderStyle::Hair => {
-            p.extend(egui::Shape::dotted_line(&[a, b], col, 2.0, w * 0.5));
-        }
-        _ => {
-            p.line_segment([a, b], Stroke::new(w, col));
-        }
-    }
-}
-
-fn paint_cf_icon(p: &Painter, r: Rect, set: &str, idx: usize) {
-    let n = gridcraft_engine::cf::icon_count(set);
-    let palette3 = [Color32::from_rgb(0xD1, 0x3B, 0x2F), Color32::from_rgb(0xF2, 0xB8, 0x2E), Color32::from_rgb(0x2E, 0x9E, 0x4F)];
-    let col = if n <= 3 {
-        palette3.get(idx).copied().unwrap_or(Color32::GRAY)
-    } else {
-        let t = idx as f32 / (n - 1).max(1) as f32;
-        Color32::from_rgb(
-            (0xD1 as f32 * (1.0 - t) + 0x2E as f32 * t) as u8,
-            (0x3B as f32 * (1.0 - t) + 0x9E as f32 * t) as u8,
-            (0x2F as f32 * (1.0 - t) + 0x4F as f32 * t) as u8,
-        )
-    };
-    let lower = set.to_ascii_lowercase();
-    if lower.contains("arrow") {
-        let c = r.center();
-        let s = r.width() / 2.0;
-        let pts = if idx + 1 == n {
-            vec![pos2(c.x, c.y - s), pos2(c.x + s, c.y + 0.1 * s), pos2(c.x - s, c.y + 0.1 * s)]
-        } else if idx == 0 {
-            vec![pos2(c.x, c.y + s), pos2(c.x - s, c.y - 0.1 * s), pos2(c.x + s, c.y - 0.1 * s)]
-        } else {
-            vec![pos2(c.x + s, c.y), pos2(c.x - 0.1 * s, c.y - s), pos2(c.x - 0.1 * s, c.y + s)]
-        };
-        p.add(egui::Shape::convex_polygon(pts, col, Stroke::NONE));
-    } else if lower.contains("rating") || lower.contains("quarter") {
-        p.circle_stroke(r.center(), r.width() / 2.0 - 0.5, Stroke::new(1.0, Color32::GRAY));
-        let frac = idx as f32 / (n - 1).max(1) as f32;
-        p.rect_filled(
-            Rect::from_min_size(pos2(r.left() + 2.0, r.bottom() - 2.0 - (r.height() - 4.0) * frac), vec2(r.width() - 4.0, (r.height() - 4.0) * frac)),
-            1.0,
-            Color32::from_rgb(0x2B, 0x7C, 0xD3),
-        );
-    } else {
-        p.circle_filled(r.center(), r.width() / 2.0 - 0.5, col);
-    }
-}
-
-/// Where the active cell is on screen: the whole merged cell when it is part of one.
-fn active_rect(geo: &Geo, sh: &Sheet, sel: &gridcraft_engine::Selection) -> Rect {
-    match sh.merge_at(sel.active) {
-        Some(m) => geo.range_rect(sh, m),
-        None => geo.cell_rect(sh, sel.active),
-    }
-}
-
-/// The rectangles shaded for a selection: every area except the active cell, which stays clear so
-/// it is plain where typing goes. A single selected cell has no fill. `outline` is where the
-/// current area is drawn this frame: it glides to a new selection, and its fill with it.
-pub fn selection_fill(geo: &Geo, sh: &Sheet, sel: &gridcraft_engine::Selection, outline: Rect) -> Vec<Rect> {
-    selection_fill_where(geo, sh, sel, outline, |_| true)
-}
-
-/// `selection_fill` for the areas `keep` accepts (a frozen pane draws only the areas it shows).
-fn selection_fill_where(geo: &Geo, sh: &Sheet, sel: &gridcraft_engine::Selection, outline: Rect, keep: impl Fn(&RangeRef) -> bool) -> Vec<Rect> {
-    if sel.is_single_cell() {
-        return vec![];
-    }
-    let active = active_rect(geo, sh, sel);
-    let area = |r: &RangeRef| if *r == sel.current() { outline } else { geo.range_rect(sh, *r) };
-    sel.ranges.iter().filter(|r| keep(r)).flat_map(|r| rect_around(area(r), active)).collect()
-}
-
-/// `area` without `hole`: the strips above and below the hole, then what is left beside it. The
-/// selection fill is translucent, so the active cell can't be cleared by painting over it; the
-/// pieces never overlap for the same reason. Pieces with no size, or whose numbers aren't finite,
-/// are dropped.
-fn rect_around(area: Rect, hole: Rect) -> impl Iterator<Item = Rect> {
-    // `intersect` takes the sane side of a NaN, which would make a broken hole cover the area.
-    let hole = if hole.is_finite() { area.intersect(hole) } else { Rect::NOTHING };
-    let parts = if hole.is_positive() {
-        [
-            Rect::from_min_max(area.min, pos2(area.max.x, hole.min.y)),
-            Rect::from_min_max(pos2(area.min.x, hole.max.y), area.max),
-            Rect::from_min_max(pos2(area.min.x, hole.min.y), pos2(hole.min.x, hole.max.y)),
-            Rect::from_min_max(pos2(hole.max.x, hole.min.y), pos2(area.max.x, hole.max.y)),
-        ]
-    } else {
-        [area, Rect::NOTHING, Rect::NOTHING, Rect::NOTHING]
-    };
-    parts.into_iter().filter(|r| r.is_positive() && r.is_finite())
-}
-
-/// True when `r` covers at least one cell of the pane that shows `rows` x `cols` (inclusive).
-/// The panes of a frozen sheet share one coordinate system, so a range that lives only in the
-/// scrolling pane would otherwise be drawn over the frozen pane as well.
-fn range_in_pane(r: RangeRef, rows: (u32, u32), cols: (u32, u32)) -> bool {
-    r.start.row <= rows.1 && r.end.row >= rows.0 && r.start.col <= cols.1 && r.end.col >= cols.0
-}
-
-/// The four sides of a `width` wide outline centred on `rect`, cut to `clip` (a little beyond it).
-///
-/// A stroked rectangle that spans a whole column (20 million points tall) loses its precision in
-/// the tessellator and its left and right sides vanish; sides filled from rectangles that stay
-/// near the viewport do not. Sides wholly outside `clip` are left out.
-pub(crate) fn outline_bands(rect: Rect, width: f32, clip: Rect) -> Vec<Rect> {
-    if !rect.is_finite() || !clip.is_finite() {
-        return Vec::new();
-    }
-    let h = width / 2.0;
-    let clip = clip.expand(width * 2.0);
-    let sides = [
-        Rect::from_min_max(pos2(rect.left() - h, rect.top() - h), pos2(rect.left() + h, rect.bottom() + h)),
-        Rect::from_min_max(pos2(rect.right() - h, rect.top() - h), pos2(rect.right() + h, rect.bottom() + h)),
-        Rect::from_min_max(pos2(rect.left() - h, rect.top() - h), pos2(rect.right() + h, rect.top() + h)),
-        Rect::from_min_max(pos2(rect.left() - h, rect.bottom() - h), pos2(rect.right() + h, rect.bottom() + h)),
-    ];
-    sides.into_iter().map(|s| s.intersect(clip)).filter(|s| s.is_finite() && s.width() > 0.0 && s.height() > 0.0).collect()
-}
-
-/// `outline` is where the current area's border is drawn this frame (see `selection_glide`).
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn paint_selection(
-    p: &Painter,
-    geo: &Geo,
-    sh: &Sheet,
-    sel: &gridcraft_engine::Selection,
-    outline: Rect,
-    t: &Tokens,
-    app: &SheetApp,
-    rows: (u32, u32),
-    cols: (u32, u32),
-) {
-    // Fill all areas except the active cell.
-    for rect in selection_fill_where(geo, sh, sel, outline, |r| range_in_pane(*r, rows, cols)) {
-        p.rect_filled(rect, 0.0, t.sel_fill);
-    }
-    let active_range = sh.merge_at(sel.active).unwrap_or_else(|| RangeRef::cell(sel.active));
-    let active = active_rect(geo, sh, sel);
-    let active_here = range_in_pane(active_range, rows, cols);
-    let cur_here = range_in_pane(sel.current(), rows, cols);
-    // Editing a formula: outline its references instead of the selection.
-    if let Some(ed) = &app.editor
-        && ed.is_formula()
-        && app.session.active().is_some_and(|d| d.uid == ed.doc)
-    {
-        let origin = app.session.active().and_then(|d| d.wb.sheet(ed.sheet)).map_or(sh.name.as_str(), |o| o.name.as_str());
-        for (_, _, r, sheet, idx) in crate::editor::formula_refs(&ed.text) {
-            if !crate::editor::ref_is_on_sheet(sheet.as_deref(), origin, &sh.name) {
-                continue;
-            }
-            if !range_in_pane(r, rows, cols) {
-                continue;
-            }
-            let rr = geo.range_rect(sh, r);
-            let col = Tokens::get(p.ctx()).ref_color(idx, true);
-            p.rect_filled(rr, 0.0, col.gamma_multiply(0.12));
-            p.rect_stroke(rr, 0.0, Stroke::new(1.5, col), StrokeKind::Inside);
-            for corner in [rr.left_top(), rr.right_top(), rr.left_bottom(), rr.right_bottom()] {
-                p.rect_filled(Rect::from_center_size(corner, vec2(4.0, 4.0)), 0.0, col);
-            }
-        }
-    }
-    if cur_here {
-        for side in outline_bands(outline.expand(0.5), 2.0, p.clip_rect()) {
-            p.rect_filled(side, 0.0, t.sel_border);
-        }
-    }
-    if active_here && sel.ranges.len() > 1 {
-        p.rect_stroke(active, 0.0, Stroke::new(1.0, t.sel_border), StrokeKind::Inside);
-    }
-    // Fill handle (bottom-right of the current area).
-    if app.editor.is_none() && range_in_pane(RangeRef::cell(sel.current().end), rows, cols) {
-        let h = Rect::from_center_size(outline.right_bottom(), vec2(6.0, 6.0));
-        p.rect_filled(h.expand(1.0), 0.0, Color32::WHITE);
-        p.rect_filled(h, 0.0, t.sel_border);
-    }
-    // Fill-handle drag preview.
-    if let crate::grid::Drag::Fill { target: Some(tr), .. } = &app.grid.drag
-        && range_in_pane(*tr, rows, cols)
-    {
-        let rr = geo.range_rect(sh, *tr);
-        p.extend(egui::Shape::dashed_line(
-            &[rr.left_top(), rr.right_top(), rr.right_bottom(), rr.left_bottom(), rr.left_top()],
-            Stroke::new(1.5, Color32::from_gray(90)),
-            4.0,
-            3.0,
-        ));
-    }
-    if let crate::grid::Drag::Move { to: Some(to), .. } = &app.grid.drag {
-        let r = sel.current();
-        let moved = RangeRef::new(*to, to.offset_clamped(r.height() as i64 - 1, r.width() as i64 - 1));
-        if range_in_pane(moved, rows, cols) {
-            let rr = geo.range_rect(sh, moved);
-            p.rect_stroke(rr, 0.0, Stroke::new(2.0, Color32::from_gray(110)), StrokeKind::Middle);
-        }
-    }
-    if let crate::grid::Drag::MoveCols { before: Some(before), .. } = &app.grid.drag {
-        let x = geo.x(sh, *before);
-        p.line_segment([pos2(x, geo.rect.top()), pos2(x, geo.rect.bottom())], Stroke::new(3.0, t.accent));
-    }
-    // Marching ants around the copied range.
-    if let Some(clip) = &app.session.clipboard
-        && app.session.active().is_some_and(|d| d.uid == clip.doc_uid && d.wb.active_sheet() == clip.sheet)
-        && range_in_pane(clip.range, rows, cols)
-    {
-        // A multi-area copy marks each area as selected.
-        let areas = if clip.areas.is_empty() { std::slice::from_ref(&clip.range) } else { clip.areas.as_slice() };
-        for area in areas {
-            let rr = geo.range_rect(sh, *area).expand(0.5);
-            let phase = app.grid.marching_phase;
-            let pts = [rr.left_top(), rr.right_top(), rr.right_bottom(), rr.left_bottom(), rr.left_top()];
-            p.extend(egui::Shape::dashed_line_with_offset(&pts, Stroke::new(2.0, t.sel_border), &[4.0], &[4.0], phase));
-        }
-    }
-}
-
-pub(crate) fn paint_headers(
-    p: &Painter,
-    geo: &Geo,
-    sh: &Sheet,
-    sel: &gridcraft_engine::Selection,
-    t: &Tokens,
-    quads: &[((u32, u32), (u32, u32), Rect)],
-    headings: &[TableHeading],
-) {
-    let font = theme::ui_font(heading_font_size(geo.z));
-    // The headers' own area: inside the outline bands.
-    let r = Rect::from_min_max(pos2(geo.head_left(), geo.head_top()), geo.rect.max);
-    let top = Rect::from_min_max(pos2(geo.cells.left(), r.top()), pos2(r.right(), geo.cells.top()));
-    let left = Rect::from_min_max(pos2(r.left(), geo.cells.top()), pos2(geo.cells.left(), r.bottom()));
-    p.rect_filled(top, 0.0, t.header_bg);
-    p.rect_filled(left, 0.0, t.header_bg);
-    let bounds = sel.bounds();
-    let col_sel = |c: u32| sel.ranges.iter().any(|x| c >= x.start.col && c <= x.end.col);
-    let row_sel = |rr: u32| sel.ranges.iter().any(|x| rr >= x.start.row && rr <= x.end.row);
-    let full_col = |c: u32| sel.ranges.iter().any(|x| x.is_full_cols() && c >= x.start.col && c <= x.end.col);
-    let full_row = |rr: u32| sel.ranges.iter().any(|x| x.is_full_rows() && rr >= x.start.row && rr <= x.end.row);
-    let _ = bounds;
-    // Hidden columns and rows leave a double divider where they sit, as in Excel.
-    let hidden_mark = Stroke::new(1.0, t.header_text.gamma_multiply(0.6));
-    let mut done_cols = std::collections::HashSet::new();
-    let mut done_rows = std::collections::HashSet::new();
-    for (rows, cols, clip) in quads {
-        let pc = p.with_clip_rect(Rect::from_min_max(pos2(clip.left(), top.top()), pos2(clip.right(), top.bottom())));
-        if cols.0 <= cols.1 {
-            for c in cols.0..=cols.1 {
-                if !done_cols.insert((c, clip.left() as i32)) {
-                    continue;
-                }
-                let w = sh.col_width(c) * geo.z;
-                if w <= 0.0 {
-                    continue;
-                }
-                let x = geo.x(sh, c);
-                let cr = Rect::from_min_size(pos2(x, top.top()), vec2(w, top.height()));
-                if col_sel(c) {
-                    pc.rect_filled(cr, 0.0, if full_col(c) { t.header_all_bg } else { t.header_sel_bg });
-                    pc.line_segment([pos2(cr.left(), cr.bottom() - 1.0), pos2(cr.right(), cr.bottom() - 1.0)], Stroke::new(2.0, t.accent));
-                }
-                pc.line_segment([pos2(cr.right() - 0.5, cr.top() + 3.0), pos2(cr.right() - 0.5, cr.bottom())], Stroke::new(1.0, t.header_line));
-                let (before, after) = hidden_around(c, |i| sh.col_width(i));
-                for x in [before.then_some(cr.left()), after.then_some(cr.right())].into_iter().flatten() {
-                    for dx in [-1.5, 1.5] {
-                        pc.line_segment([pos2(x + dx, cr.top() + 3.0), pos2(x + dx, cr.bottom())], hidden_mark);
-                    }
-                }
-                let color = if col_sel(c) { t.header_sel_text } else { t.header_text };
-                match headings.iter().find(|h| h.col == c) {
-                    Some(h) => {
-                        // The name is cut off at the button, as a cell's text is at its neighbour.
-                        let end = h.button.map_or(cr.right(), |b| b.left()) - 2.0;
-                        let room = Rect::from_min_max(cr.min, pos2(end.max(cr.left()), cr.bottom())).intersect(pc.clip_rect());
-                        let pad = 4.0 * (geo.z / DISPLAY_SCALE).max(0.75);
-                        pc.with_clip_rect(room).text(pos2(cr.left() + pad, cr.center().y), Align2::LEFT_CENTER, &h.name, font.clone(), color);
-                        if let Some(b) = h.button {
-                            paint_filter_button(&pc, b, h.filtered);
-                        }
-                    }
-                    None => {
-                        pc.text(cr.center(), Align2::CENTER_CENTER, col_to_letters(c), font.clone(), color);
-                    }
-                }
-            }
-        }
-        let pr = p.with_clip_rect(Rect::from_min_max(pos2(left.left(), clip.top()), pos2(left.right(), clip.bottom())));
-        if rows.0 <= rows.1 {
-            for rr in rows.0..=rows.1 {
-                if !done_rows.insert((rr, clip.top() as i32)) {
-                    continue;
-                }
-                let h = sh.row_height(rr) * geo.z;
-                if h <= 0.0 {
-                    continue;
-                }
-                let y = geo.y(sh, rr);
-                let cr = Rect::from_min_size(pos2(left.left(), y), vec2(left.width(), h));
-                if row_sel(rr) {
-                    pr.rect_filled(cr, 0.0, if full_row(rr) { t.header_all_bg } else { t.header_sel_bg });
-                    pr.line_segment([pos2(cr.right() - 1.0, cr.top()), pos2(cr.right() - 1.0, cr.bottom())], Stroke::new(2.0, t.accent));
-                }
-                pr.line_segment([pos2(cr.left() + 3.0, cr.bottom() - 0.5), pos2(cr.right(), cr.bottom() - 0.5)], Stroke::new(1.0, t.header_line));
-                let (before, after) = hidden_around(rr, |i| sh.row_height(i));
-                for y in [before.then_some(cr.top()), after.then_some(cr.bottom())].into_iter().flatten() {
-                    for dy in [-1.5, 1.5] {
-                        pr.line_segment([pos2(cr.left() + 3.0, y + dy), pos2(cr.right(), y + dy)], hidden_mark);
-                    }
-                }
-                let color = if row_sel(rr) { t.header_sel_text } else { t.header_text };
-                pr.text(cr.center(), Align2::CENTER_CENTER, (rr as u64 + 1).to_string(), font.clone(), color);
-            }
-        }
-    }
-    // Corner (select all) and edges.
-    let corner = Rect::from_min_max(r.min, geo.cells.min);
-    p.rect_filled(corner, 0.0, t.header_bg);
-    let tri = vec![
-        pos2(corner.right() - 3.0, corner.top() + 5.0),
-        pos2(corner.right() - 3.0, corner.bottom() - 3.0),
-        pos2(corner.left() + 7.0, corner.bottom() - 3.0),
-    ];
-    p.add(egui::Shape::convex_polygon(tri, Color32::from_gray(190), Stroke::NONE));
-    p.line_segment([pos2(r.left(), geo.cells.top() - 0.5), pos2(r.right(), geo.cells.top() - 0.5)], Stroke::new(1.0, t.header_line));
-    p.line_segment([pos2(geo.cells.left() - 0.5, r.top()), pos2(geo.cells.left() - 0.5, r.bottom())], Stroke::new(1.0, t.header_line));
-}
-
-/// Whether the line before / after visible line `i` is hidden (zero size), so its header edges
-/// get the hidden marker. Line 0 has nothing before it.
-fn hidden_around(i: u32, size: impl Fn(u32) -> f32) -> (bool, bool) {
-    (i > 0 && size(i - 1) <= 0.0, i < u32::MAX && size(i + 1) <= 0.0)
-}
-
-// ------------------------------------------------------------------ interaction
-
-/// How close (in points) a press must be to an object's bottom-right corner to resize it instead of moving it.
-const OBJECT_RESIZE_RADIUS: f32 = 10.0;
-
-/// Decide after interaction so drag start and release use the new state in the same frame.
-fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet) {
-    if app.text_box_editor.is_some() || app.grid.hf_edit.is_some() {
-        return;
-    }
-    let ctx = ui.ctx();
-    let pointer = ctx.input(|i| i.pointer.clone());
-    let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p));
-    let in_cells = pos.is_some_and(|p| geo.in_cells(p));
-    let (freeze_cols, freeze_rows) = freeze_handles(geo);
-    // Hover bookkeeping also serves cell notes, independently of who owns the cursor.
-    if resp.hovered()
-        && let Some(p) = pos
-        && !freeze_cols.contains(p)
-        && !freeze_rows.contains(p)
-        && !matches!(app.grid.drag, Drag::Freeze { .. })
-    {
-        app.grid.hover_cell = in_cells.then(|| geo.cell_at(sh, p));
-    }
-    // Draw tools own the cursor over cells, including while recording a stroke.
-    if !app.session.draw_tool.is_empty() && in_cells {
-        ctx.set_cursor_icon(CursorIcon::Crosshair);
-        return;
-    }
-    // A held drag owns the cursor even outside the grid; a press below egui's threshold still
-    // has Drag::None and uses hover. A click can briefly leave a drag state after release.
-    if resp.dragged()
-        && pointer.primary_down()
-        && let Some(cursor) = drag_cursor(&app.grid.drag)
-    {
-        ctx.set_cursor_icon(cursor);
-        return;
-    }
-    if !resp.hovered() {
-        return;
-    }
-    let Some(p) = pos else { return };
-    hover_cursor(app, ctx, resp, &pointer, geo, sh, p);
-}
-
-/// The cursor a held drag shows, or `None` when the drag leaves it to hover.
-fn drag_cursor(drag: &Drag) -> Option<CursorIcon> {
-    match drag {
-        Drag::None => None,
-        Drag::Select => Some(CursorIcon::Cell),
-        Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default),
-        Drag::Fill { .. } => Some(CursorIcon::Crosshair),
-        Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { resize: false, .. } => Some(CursorIcon::Move),
-        Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn),
-        Drag::ResizeRow { .. } => Some(CursorIcon::ResizeRow),
-        Drag::Freeze { cols, .. } => Some(if *cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical }),
-        Drag::Object { resize: true, .. } => Some(CursorIcon::ResizeNwSe),
-    }
-}
-
-/// The cursor over the grid when no drag owns it: freeze bars, header edges, the fill handle, cells.
-fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, pointer: &egui::PointerState, geo: &Geo, sh: &Sheet, p: Pos2) {
-    let (freeze_cols, freeze_rows) = freeze_handles(geo);
-    if freeze_cols.contains(p) || freeze_rows.contains(p) {
-        freeze_cursor(app, ctx, resp, pointer, freeze_cols.contains(p));
-        return;
-    }
-    let in_cells = geo.in_cells(p);
-    let in_col_header = p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left();
-    let in_row_header = p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top();
-    let near_col_edge = in_col_header && col_edge(geo, sh, p.x).is_some();
-    let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default();
-    let cur_rect = geo.range_rect(sh, sel.current());
-    let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0));
-    let handle_panes = geo.range_panes(RangeRef::cell(sel.current().end));
-    let border_panes = geo.range_panes(sel.current());
-    let on_handle = handle.contains(p) && handle_panes.iter().any(|r| r.contains(p));
-    let on_cur_border = on_border(cur_rect, p) && border_panes.iter().any(|r| r.contains(p));
-    let selected_object = crate::chartview::hit(app, geo, sh, p).filter(|&(_, id, _)| app.selected_chart == Some(id));
-    let near_corner = selected_object.is_some_and(|(_, _, rect)| (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS);
-    if app.grid.drag == Drag::None && near_corner {
-        ctx.set_cursor_icon(CursorIcon::ResizeNwSe);
-    } else if near_col_edge || (in_row_header && row_edge(geo, sh, p.y).is_some()) {
-        header_edge_cursor(app, ctx, pointer, geo, sh, p, near_col_edge);
-    } else if on_handle && app.editor.is_none() {
-        ctx.set_cursor_icon(CursorIcon::Crosshair);
-        if app.grid.drag == Drag::None && !pointer.any_down() {
-            resp.clone().on_hover_text_at_pointer("Drag to fill cells. Drag from inside a cell to select a range.");
-        }
-    } else if in_cells && app.editor.is_none() && on_cur_border {
-        ctx.set_cursor_icon(CursorIcon::Move);
-    } else if in_cells {
-        ctx.set_cursor_icon(CursorIcon::Cell);
-    } else if in_col_header {
-        let col = geo.col_at(sh, p.x);
-        let selected = sel.ranges.len() == 1 && sel.current().is_full_cols() && sel.current().contains(CellRef::new(0, col));
-        ctx.set_cursor_icon(if selected { CursorIcon::Move } else { CursorIcon::Default });
-    }
-}
-
-/// The resize cursor for dragging a freeze bar.
-fn freeze_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, pointer: &egui::PointerState, cols: bool) {
-    ctx.set_cursor_icon(if cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical });
-    if app.grid.drag == Drag::None && !pointer.any_down() {
-        let tip = if cols { "Drag to freeze columns" } else { "Drag to freeze rows" };
-        resp.clone().on_hover_text_at_pointer(crate::i18n::current(ctx).tr(tip));
-    }
-}
-
-/// The resize cursor over a column or row header edge. Just past a hidden column or row, Excel
-/// shows a split cursor: dragging or double-clicking there unhides it.
-fn header_edge_cursor(app: &SheetApp, ctx: &egui::Context, pointer: &egui::PointerState, geo: &Geo, sh: &Sheet, p: Pos2, near_col_edge: bool) {
-    let hidden =
-        app.grid.drag == Drag::None && if near_col_edge { hidden_col_edge(geo, sh, p.x).is_some() } else { hidden_row_edge(geo, sh, p.y).is_some() };
-    match pointer.hover_pos() {
-        Some(at) if hidden => paint_split_cursor(ctx, at, near_col_edge),
-        _ => ctx.set_cursor_icon(if near_col_edge { CursorIcon::ResizeColumn } else { CursorIcon::ResizeRow }),
-    }
-}
-
-fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet, wb: &Workbook) {
-    // Text selection and editing must not also move the object or edit worksheet cells.
-    if app.text_box_editor.is_some() || app.grid.hf_edit.is_some() {
-        return;
-    }
-    let ctx = ui.ctx().clone();
-    // Enter/Space synthesize egui clicks; only real pointer clicks use sheet coordinates.
-    let primary_clicked = resp.clicked_by(egui::PointerButton::Primary);
-    let pointer = ctx.input(|i| i.pointer.clone());
-    let mods = ctx.input(|i| i.modifiers);
-    // Hit-testing works in logical coordinates (see `Geo::rtl`).
-    let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p));
-    let in_cells = pos.is_some_and(|p| geo.in_cells(p));
-    let in_col_header = pos.is_some_and(|p| p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left());
-    let in_row_header = pos.is_some_and(|p| p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top());
-    let in_corner = pos.is_some_and(|p| p.x < geo.cells.left() && p.y < geo.cells.top() && p.x >= geo.head_left() && p.y >= geo.head_top());
-    let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default();
-    let cur_rect = geo.range_rect(sh, sel.current());
-    let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0));
-    // The fill handle and the move border only react in the panes where they are painted, not
-    // over the frozen rows/columns that a scrolled selection lies under.
-    let handle_panes = geo.range_panes(RangeRef::cell(sel.current().end));
-    let border_panes = geo.range_panes(sel.current());
-    let on_handle = |p: Pos2| handle.contains(p) && handle_panes.iter().any(|r| r.contains(p));
-    let on_cur_border = |p: Pos2| on_border(cur_rect, p) && border_panes.iter().any(|r| r.contains(p));
-
-    let (freeze_cols, freeze_rows) = freeze_handles(geo);
-    // Draw tab tools: the pen records a stroke, the eraser deletes ink under the pointer.
-    if !app.session.draw_tool.is_empty() && in_cells {
-        ctx.set_cursor_icon(CursorIcon::Crosshair);
-        if app.session.draw_tool == "pen" {
-            if let Some(p) = pos
-                && resp.dragged()
-            {
-                // Through the cell under the pointer, so frozen panes and pages map right.
-                let c = geo.cell_at(sh, p);
-                let sx = sh.col_left(c.col) as f32 + (p.x - geo.x(sh, c.col)) / geo.z;
-                let sy = sh.row_top(c.row) as f32 + (p.y - geo.y(sh, c.row)) / geo.z;
-                app.grid.ink.push([sx, sy]);
-            }
-            if !app.grid.ink.is_empty() {
-                // Live preview.
-                let pts: Vec<Pos2> = app
-                    .grid
-                    .ink
-                    .iter()
-                    .map(|q| {
-                        let (col, row) = (sh.col_at(q[0].max(0.0) as f64), sh.row_at(q[1].max(0.0) as f64));
-                        geo.mirror_pos(pos2(
-                            geo.x(sh, col) + (q[0] - sh.col_left(col) as f32) * geo.z,
-                            geo.y(sh, row) + (q[1] - sh.row_top(row) as f32) * geo.z,
-                        ))
-                    })
-                    .collect();
-                ui.painter().add(egui::epaint::PathShape::line(pts, egui::epaint::PathStroke::new(2.0 * geo.z, Color32::from_rgb(0x1F, 0x5F, 0xC9))));
-            }
-            if resp.drag_stopped() && app.grid.ink.len() >= 2 {
-                let pts: Vec<[f32; 2]> = std::mem::take(&mut app.grid.ink);
-                let _ = app.run("draw.stroke", json!({"points": pts}));
-            }
-            return;
-        }
-        if app.session.draw_tool == "eraser" && (primary_clicked || resp.dragged()) {
-            if let Some(p) = pos
-                && let Some(("shape", id, _)) = crate::chartview::hit(app, geo, sh, p)
-                && sh.shapes.iter().any(|s| s.id == id && s.kind == gridcraft_engine::model::ShapeKind::Ink)
-            {
-                let _ = app.run("object.delete", json!({"kind": "shape", "id": id}));
-            }
-            return;
-        }
-    }
-    // A plain click on a slicer value tile toggles it (Ctrl/Cmd for multi-select); the clear
-    // button resets it. Runs before the generic object select/drag so tiles stay clickable.
-    if primary_clicked
-        && !resp.drag_started()
-        && let Some(p) = pos
-        && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p)
-    {
-        app.selected_chart = Some(id);
-        match act {
-            crate::chartview::SlicerAction::Toggle(value) => {
-                let _ = app.run("slicer.toggle", json!({"slicer": id, "value": value, "multi": mods.command || mods.ctrl}));
-            }
-            crate::chartview::SlicerAction::Clear => {
-                let _ = app.run("slicer.clear", json!({"slicer": id}));
-            }
-        }
-        return;
-    }
-    // Objects (charts, pictures, shapes, slicers) take clicks first. Only the primary button moves
-    // them: a right-click that wobbles into a drag still opens the object's menu (#2067).
-    let primary_drag = resp.drag_started_by(egui::PointerButton::Primary);
-    if primary_drag || primary_clicked {
-        // A drag is recognised only after the pointer has moved, so grab the object where the press began.
-        let at = if primary_drag { pointer.press_origin().or(pos) } else { pos };
-        if let Some(p) = at
-            && let Some((kind, id, rect)) = crate::chartview::hit(app, geo, sh, p)
-        {
-            app.selected_chart = Some(id);
-            if kind == "shape"
-                && resp.double_clicked()
-                && sh.shapes.iter().any(|s| s.id == id && s.kind == gridcraft_engine::model::ShapeKind::TextBox)
-            {
-                app.begin_text_box_edit(id);
-                return;
-            }
-            if kind == "chart" && resp.double_clicked() {
-                app.grid.pane = Some("formatChart".into());
-            }
-            if primary_drag {
-                let a = object_anchor(sh, kind, id);
-                let resize = (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS;
-                if let Some(a) = a {
-                    app.grid.drag = Drag::Object { kind, id, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), resize };
-                }
-            }
-            return;
-        }
-        app.selected_chart = None;
-    }
-    // A right-click on a chart, picture, shape or slicer opens the object's menu, not the cell's
-    // under it; a right press that wobbles into a drag counts too (#2067).
-    let secondary_drag = resp.drag_started_by(egui::PointerButton::Secondary);
-    if (resp.secondary_clicked() || secondary_drag)
-        && let Some(p) = if secondary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos }
-        && let Some((kind, id, _)) = crate::chartview::hit(app, geo, sh, p)
-    {
-        app.selected_chart = Some(id);
-        app.grid.object_menu = Some((geo.mirror_pos(p), kind, id));
-        return;
-    }
-
-    // A double-click is also a click: handle header AutoFit before resize setup returns.
-    if resp.double_clicked()
-        && let Some(p) = pos
-    {
-        let unhide = if in_col_header {
-            hidden_col_edge(geo, sh, p.x).map(|col| ("home.unhideColumns", json!({"cols": RangeRef::cols(col, col).a1()})))
-        } else if in_row_header {
-            hidden_row_edge(geo, sh, p.y).map(|row| ("home.unhideRows", json!({"rows": RangeRef::rows(row, row).a1()})))
-        } else {
-            None
-        };
-        let autofit = if unhide.is_some() {
-            unhide
-        } else if in_col_header {
-            col_edge(geo, sh, p.x).map(|(col, _)| {
-                let selected = sel.ranges.iter().any(|r| r.is_full_cols() && col >= r.start.col && col <= r.end.col);
-                ("home.autofitColumnWidth", if selected { json!({}) } else { json!({"cols": RangeRef::cols(col, col).a1()}) })
-            })
-        } else if in_row_header {
-            row_edge(geo, sh, p.y).map(|(row, _)| {
-                let selected = sel.ranges.iter().any(|r| r.is_full_rows() && row >= r.start.row && row <= r.end.row);
-                ("home.autofitRowHeight", if selected { json!({}) } else { json!({"rows": RangeRef::rows(row, row).a1()}) })
-            })
-        } else {
-            None
-        };
-        if let Some((command, params)) = autofit {
-            app.grid.drag = Drag::None;
-            app.grid.drag_select = false;
-            app.run_or_alert(command, params);
-            resp.request_focus();
-            return;
-        }
-    }
-
-    // Double-click the fill handle: a double-click is also a click, so run it before the handle press returns.
-    if resp.double_clicked()
-        && let Some(p) = pos
-        && on_handle(p)
-    {
-        // Fill down as far as the neighbouring column goes.
-        let src = sel.current();
-        let neighbour = if src.start.col > 0 { src.start.col - 1 } else { src.end.col + 1 };
-        let cap = src.end.row.saturating_add(1_000_000).min(MAX_ROWS - 1);
-        let last = if src.end.row < cap { sh.last_contiguous_nonempty(neighbour, src.end.row + 1, cap) } else { src.end.row };
-        if last > src.end.row {
-            let target = RangeRef::new(src.start, CellRef::new(last, src.end.col));
-            let _ = app.run("edit.autoFill", json!({"source": src.a1(), "target": target.a1()}));
-        }
-        app.grid.drag = Drag::None;
-        app.grid.drag_select = false;
-        resp.request_focus();
-        return;
-    }
-
-    // Press: decide the drag mode.
-    if resp.drag_started() || (primary_clicked && app.grid.drag == Drag::None) {
-        // Where the press began (a drag is only recognised after the pointer has moved).
-        let Some(p) = pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) else { return };
-        // The outline band's − / + and level buttons act on release, like buttons.
-        if let Some(action) = crate::outline::hit(geo, sh, p) {
-            if primary_clicked {
-                let (command, params) = action.command();
-                app.run_or_alert(command, params);
-            }
-            return;
-        }
-        // Freeze handles sit on the header edges (and the corner's edges when nothing is frozen).
-        if freeze_cols.contains(p) || freeze_rows.contains(p) {
-            app.grid.drag = Drag::Freeze { cols: freeze_cols.contains(p), to: None };
-            return;
-        }
-        if in_corner {
-            let _ = app.session.run("selection.set", json!({"range": RangeRef::all().a1()}));
-            return;
-        }
-        if in_col_header {
-            if let Some((c, x)) = col_edge(geo, sh, p.x) {
-                app.grid.drag = Drag::ResizeCol { col: c, start: p.x, orig: sh.col_width(c).max(0.0) * 0.0 + (x - geo.x(sh, c)) / geo.z };
-                return;
-            }
-            let c = geo.col_at(sh, p.x);
-            // A Table heading's filter button, while the header names stand in for the letters.
-            if let Some(h) = table_headings(geo, sh, sel.active).into_iter().find(|h| h.col == c && h.button.is_some_and(|b| b.contains(p))) {
-                app.grid.filter_menu = Some((c, h.header_row, geo.mirror_pos(p)));
-                return;
-            }
-            if point_header(app, wb, sh, RangeRef::cols(c, c), mods.shift, mods.command) {
-                return;
-            }
-            // An armed Format Painter paints the columns dragged over instead of moving them.
-            if resp.drag_started()
-                && !mods.any()
-                && app.session.format_painter.is_none()
-                && sel.ranges.len() == 1
-                && sel.current().is_full_cols()
-                && sel.current().contains(CellRef::new(0, c))
-            {
-                app.grid.drag = Drag::MoveCols { source: sel.current(), before: None };
-                return;
-            }
-            let range = if mods.shift { RangeRef::cols(sel.anchor.col.min(c), sel.anchor.col.max(c)) } else { RangeRef::cols(c, c) };
-            select_ranges(app, range, mods.command, CellRef::new(geo.row_at(sh, geo.cells.top() + 1.0), c));
-            app.grid.drag = Drag::Cols(if mods.shift { sel.anchor.col } else { c });
-            return;
-        }
-        if in_row_header {
-            if let Some((r, y)) = row_edge(geo, sh, p.y) {
-                app.grid.drag = Drag::ResizeRow { row: r, start: p.y, orig: (y - geo.y(sh, r)) / geo.z };
-                return;
-            }
-            let r = geo.row_at(sh, p.y);
-            if point_header(app, wb, sh, RangeRef::rows(r, r), mods.shift, mods.command) {
-                return;
-            }
-            let range = if mods.shift { RangeRef::rows(sel.anchor.row.min(r), sel.anchor.row.max(r)) } else { RangeRef::rows(r, r) };
-            select_ranges(app, range, mods.command, CellRef::new(r, geo.col_at(sh, geo.cells.left() + 1.0)));
-            app.grid.drag = Drag::Rows(if mods.shift { sel.anchor.row } else { r });
-            return;
-        }
-        if !in_cells {
-            return;
-        }
-        let c = geo.cell_at(sh, p);
-        // Data validation list arrow next to the active cell.
-        if let Some(r) = validation_arrow(sh, geo, sel.active)
-            && r.contains(p)
-        {
-            app.grid.list_picker = Some(sel.active);
-            return;
-        }
-        // Filter dropdown buttons.
-        if is_filter_button(sh, geo, p) {
-            app.grid.filter_menu = Some((c.col, c.row, geo.mirror_pos(p)));
-            return;
-        }
-        // A dialog's formula box in point mode (New Formatting Rule) takes the reference; the
-        // selection, which the dialog acts on, stays.
-        if let Some(d) = app.dialog.as_mut().filter(|d| d.picks_references()) {
-            d.pick_reference(c, &sh.name, false);
-            app.grid.drag = Drag::Select;
-            app.grid.drag_select = true;
-            if resp.drag_started()
-                && let Some(p) = pos
-            {
-                select_to_pointer(app, geo, sh, wb, p);
-            }
-            return;
-        }
-        // Point mode while editing a formula: clicking inserts a reference.
-        if let Some(ed) = app.editor.as_mut()
-            && ed.can_point()
-        {
-            let anchor = if mods.shift && ed.point_at_caret() {
-                ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet()).map(|(_, cell)| cell).unwrap_or(c)
-            } else {
-                c
-            };
-            let range = RangeRef::new(anchor, c);
-            let text = if range.is_single() { c.a1() } else { range.a1() };
-            let sheet_name = (ed.sheet != wb.active_sheet()).then(|| sh.name.clone());
-            let r = match sheet_name {
-                Some(n) => format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&n)),
-                None => text,
-            };
-            if mods.command && !mods.shift {
-                ed.append_ref(&r);
-            } else {
-                ed.insert_ref(&r);
-            }
-            ed.request_focus = true;
-            ed.point_cell = Some(c);
-            ed.point_anchor = Some((wb.active_sheet(), anchor));
-            app.grid.drag = Drag::Select;
-            app.grid.drag_select = true;
-            if resp.drag_started()
-                && let Some(p) = pos
-            {
-                select_to_pointer(app, geo, sh, wb, p);
-            }
-            return;
-        }
-        if app.editor.is_some() && !app.commit_edit(0, 0, false, false) {
-            return;
-        }
-        if on_handle(p) {
-            app.grid.drag = Drag::Fill { target: None, menu: resp.drag_started_by(egui::PointerButton::Secondary) };
-            return;
-        }
-        if on_cur_border(p) && resp.drag_started() {
-            app.grid.drag = Drag::Move { grab: c, to: None };
-            return;
-        }
-        // Double-click edits.
-        let now = crate::now_ms();
-        if let Some((last, at)) = app.grid.last_click
-            && last == c
-            && now - at < 450.0
-            && !mods.shift
-        {
-            app.grid.last_click = None;
-            // A PivotTable's value cell shows its source records on a new sheet (Excel's Show
-            // Details); its labels and headers still edit.
-            if sh.pivots.iter().any(|pt| pt.last_range.is_some_and(|r| r.contains(c))) {
-                let not_a_value_cell =
-                    gridcraft_engine::EngineError::Disabled("pivot.showDetails".into(), gridcraft_engine::pivot::NOT_A_VALUE_CELL.into()).to_string();
-                match app.run("pivot.showDetails", json!({"cell": c.a1()})) {
-                    Ok(_) => return,
-                    Err(e) if e == not_a_value_cell => {}
-                    Err(e) => {
-                        app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
-                        return;
-                    }
-                }
-            }
-            // Following a hyperlink requires a single click in Excel; double-click edits.
-            app.begin_edit(None, false);
-            return;
-        }
-        app.grid.last_click = Some((c, now));
-        if mods.shift {
-            let _ = app.session.run("selection.set", json!({"range": RangeRef::new(sel.anchor, c).a1(), "active": sel.active.a1()}));
-            if let Some(d) = app.session.active_mut() {
-                d.selection.anchor = sel.anchor;
-            }
-        } else if mods.command {
-            // Ctrl+click (without Alt) on a hyperlink's text follows it instead of adding the cell to the selection.
-            if let Some(h) = sh.hyperlinks.get(&c).cloned()
-                && primary_clicked
-                && !mods.alt
-                && p.x < geo.cell_rect(sh, c).left() + geo.cell_rect(sh, c).width() * 0.8
-            {
-                follow_link(app, &h.target);
-            } else {
-                select_ranges(app, RangeRef::cell(c), true, c);
-            }
-        } else {
-            let _ = app.session.run("selection.set", json!({"cell": c.a1()}));
-            if primary_clicked && wb.styles.get(sh.style_id(c)).num_fmt.as_str() == "checkbox" {
-                let _ = app.run("cell.toggleCheckbox", json!({"cell": c.a1()}));
-            }
-            // A click on a hyperlink's text follows it (like Excel); elsewhere in the cell selects.
-            if let Some(h) = sh.hyperlinks.get(&c).cloned()
-                && primary_clicked
-                && !mods.any()
-            {
-                let r = geo.cell_rect(sh, c);
-                if p.x < r.left() + r.width() * 0.8 {
-                    follow_link(app, &h.target);
-                }
-            }
-        }
-        app.grid.drag = Drag::Select;
-        app.grid.drag_select = true;
-        if resp.drag_started()
-            && let Some(p) = pos
-        {
-            // The first recognised drag already includes movement away from the press.
-            select_to_pointer(app, geo, sh, wb, p);
-        }
-        return;
-    }
-
-    // Dragging.
-    if resp.dragged()
-        && let Some(p) = pos
-    {
-        // Auto-scroll near edges.
-        let edge = 24.0;
-        let mut auto = egui::Vec2::ZERO;
-        if p.y > geo.cells.bottom() - edge {
-            auto.y = 20.0;
-        }
-        if p.y < geo.cells.top() + edge * 0.5 && !matches!(app.grid.drag, Drag::ResizeRow { .. }) {
-            auto.y = -20.0;
-        }
-        if p.x > geo.cells.right() - edge {
-            auto.x = 30.0;
-        }
-        if p.x < geo.cells.left() + edge * 0.5 && !matches!(app.grid.drag, Drag::ResizeCol { .. }) {
-            auto.x = -30.0;
-        }
-        let pc = CellRef::new(
-            geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)),
-            geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)),
-        );
-        match app.grid.drag.clone() {
-            Drag::Select => {
-                select_to_pointer(app, geo, sh, wb, p);
-                scroll_by(app, auto);
-            }
-            Drag::Rows(anchor) => {
-                let r = geo.row_at(sh, p.y);
-                let _ =
-                    app.session.run("selection.set", json!({"range": RangeRef::rows(anchor.min(r), anchor.max(r)).a1(), "active": sel.active.a1()}));
-                scroll_by(app, vec2(0.0, auto.y));
-            }
-            Drag::Cols(anchor) => {
-                let c = geo.col_at(sh, p.x);
-                let _ =
-                    app.session.run("selection.set", json!({"range": RangeRef::cols(anchor.min(c), anchor.max(c)).a1(), "active": sel.active.a1()}));
-                scroll_by(app, vec2(auto.x, 0.0));
-            }
-            Drag::MoveCols { source, .. } => {
-                let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0));
-                let midpoint = geo.x(sh, col) + sh.col_width(col) * geo.z * 0.5;
-                let before = (col + u32::from(p.x >= midpoint)).min(MAX_COLS - 1);
-                let before = (!(source.start.col..=source.end.col + 1).contains(&before)).then_some(before);
-                app.grid.drag = Drag::MoveCols { source, before };
-                scroll_by(app, vec2(auto.x, 0.0));
-            }
-            Drag::ResizeCol { col, start, orig } => {
-                let w = (orig + (p.x - start) / geo.z).max(0.0);
-                app.toast =
-                    Some((format!("Width: {:.2} ({} pixels)", gridcraft_engine::cmd::format::points_to_chars(w as f64), w.round()), crate::now_ms()));
-                // Inside a selection of whole columns, every selected column takes the new width
-                // (Ctrl-selected areas included); otherwise only the dragged one.
-                let cols = if sel.ranges.iter().any(|r| r.is_full_cols() && col >= r.start.col && col <= r.end.col) {
-                    sel.ranges.iter().filter(|r| r.is_full_cols()).map(|r| r.a1()).collect::<Vec<_>>().join(",")
-                } else {
-                    RangeRef::cols(col, col).a1()
-                };
-                let _ = app.session.run("home.columnWidth", json!({"cols": cols, "width": w.round()}));
-                coalesce_last_undo(app);
-            }
-            Drag::ResizeRow { row, start, orig } => {
-                let h = (orig + (p.y - start) / geo.z).max(0.0);
-                app.toast = Some((format!("Height: {:.2} ({} pixels)", h * 0.75, h.round()), crate::now_ms()));
-                let rows = if sel.ranges.iter().any(|r| r.is_full_rows() && row >= r.start.row && row <= r.end.row) {
-                    sel.ranges
-                        .iter()
-                        .filter(|r| r.is_full_rows())
-                        .map(|r| format!("{}:{}", r.start.row + 1, r.end.row + 1))
-                        .collect::<Vec<_>>()
-                        .join(",")
-                } else {
-                    format!("{}:{}", row + 1, row + 1)
-                };
-                let _ = app.session.run("home.rowHeight", json!({"rows": rows, "height": h.round()}));
-                coalesce_last_undo(app);
-            }
-            Drag::Freeze { cols, .. } => {
-                app.grid.drag = Drag::Freeze { cols, to: Some(freeze_boundary(geo, sh, p, cols)) };
-            }
-            Drag::Fill { menu, .. } => {
-                let src = sel.current();
-                let target = fill_target(src, pc);
-                app.grid.drag = Drag::Fill { target: Some(target), menu };
-                scroll_by(app, auto);
-            }
-            Drag::Move { grab, .. } => {
-                let src = sel.current();
-                let dr = pc.row as i64 - grab.row as i64;
-                let dc = pc.col as i64 - grab.col as i64;
-                app.grid.drag = Drag::Move { grab, to: Some(src.start.offset_clamped(dr, dc)) };
-                scroll_by(app, auto);
-            }
-            Drag::Object { kind, id, start, orig, resize } => {
-                let d = (p - start) / geo.z;
-                let (cell, dx, dy, w, h) = orig;
-                let params = if resize {
-                    json!({"kind": kind, "id": id, "width": (w + d.x).max(20.0), "height": (h + d.y).max(20.0)})
-                } else {
-                    // Re-anchor at the cell under the new top-left.
-                    let x0 = sh.col_left(cell.col) as f32 + dx + d.x;
-                    let y0 = sh.row_top(cell.row) as f32 + dy + d.y;
-                    let nc = CellRef::new(sh.row_at(y0.max(0.0) as f64), sh.col_at(x0.max(0.0) as f64));
-                    json!({"kind": kind, "id": id, "at": nc.a1(), "dx": x0.max(0.0) - sh.col_left(nc.col) as f32, "dy": y0.max(0.0) - sh.row_top(nc.row) as f32})
-                };
-                let _ = app.session.run("object.move", params);
-                coalesce_last_undo(app);
-            }
-            Drag::None => {}
-        }
-    }
-
-    // Release.
-    if resp.drag_stopped() || (!pointer.any_down() && app.grid.drag != Drag::None && !resp.dragged()) {
-        match std::mem::take(&mut app.grid.drag) {
-            Drag::Select => {
-                if resp.drag_stopped()
-                    && let Some(p) = pos
-                {
-                    select_to_pointer(app, geo, sh, wb, p);
-                }
-                format_painter_apply(app);
-            }
-            // Whole rows or columns clicked or dragged over by their headers.
-            Drag::Rows(_) | Drag::Cols(_) => format_painter_apply(app),
-            // Esc mid-drag lands here too (egui ends the drag on Esc): no menu, and the key is
-            // spent on the drag so the grid's Esc doesn't also drop the copy.
-            Drag::Fill { target: Some(t), menu: true } => {
-                if let Some(p) = pos
-                    && t != sel.current()
-                    && !ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape))
-                {
-                    app.grid.fill_menu = Some((sel.current(), t, geo.mirror_pos(p)));
-                }
-            }
-            Drag::Fill { target: Some(t), menu: false } => {
-                let src = sel.current();
-                if t != src {
-                    // Ctrl (Cmd on macOS) swaps copying and extending, as in Excel.
-                    let mode = if mods.command { "alternate" } else { "series" };
-                    match app.run("edit.autoFill", json!({"source": src.a1(), "target": t.a1(), "mode": mode})) {
-                        Ok(_) => set_fill_tag(app, src, t),
-                        Err(e) => app.message = Some(("GridCraft".into(), crate::clean_error(&e))),
-                    }
-                }
-            }
-            Drag::Freeze { cols, to: Some(to) } => {
-                let (rows_now, cols_now) = (geo.fr, geo.fc);
-                let (rows, cols) = if cols { (rows_now, to) } else { (to, cols_now) };
-                if (rows, cols) != (rows_now, cols_now) {
-                    // A1 (nothing left frozen) unfreezes.
-                    app.run_or_alert("view.freezePanes", json!({"cell": CellRef::new(rows, cols).a1()}));
-                }
-            }
-            Drag::Move { to: Some(to), .. } => {
-                let src = sel.current();
-                if to != src.start {
-                    let _ = app.session.run("edit.cut", json!({"range": src.a1()}));
-                    let _ = app.run("edit.paste", json!({"at": to.a1()}));
-                }
-            }
-            Drag::MoveCols { source, before: Some(before) } => {
-                if let Err(e) = app.run("sheet.moveColumns", json!({"cols": source.a1(), "before": before})) {
-                    app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
-                }
-            }
-            _ => {}
-        }
-        app.grid.drag_select = false;
-    }
-
-    // Right-click: context menu.
-    if resp.secondary_clicked()
-        && let Some(p) = pos
-    {
-        if in_cells && !sel.contains(geo.cell_at(sh, p)) {
-            let _ = app.session.run("selection.set", json!({"cell": geo.cell_at(sh, p).a1()}));
-        }
-        if in_col_header || in_row_header {
-            let (rows, idx) = if in_row_header { (true, geo.row_at(sh, p.y)) } else { (false, geo.col_at(sh, p.x)) };
-            let inside = sel.ranges.iter().any(|r| {
-                if rows {
-                    r.is_full_rows() && idx >= r.start.row && idx <= r.end.row
-                } else {
-                    r.is_full_cols() && idx >= r.start.col && idx <= r.end.col
-                }
-            });
-            if !inside {
-                let range = if rows { RangeRef::rows(idx, idx) } else { RangeRef::cols(idx, idx) };
-                let _ = app.session.run("selection.set", json!({"range": range.a1()}));
-            }
-            app.grid.header_menu = Some((geo.mirror_pos(p), rows));
-        } else {
-            app.grid.context_menu = Some(geo.mirror_pos(p));
-            app.grid.context_menu_frame = ui.ctx().cumulative_frame_nr();
-        }
-    }
-
-    if primary_clicked || resp.drag_started() {
-        resp.request_focus();
-    }
-    keyboard(app, &ctx, resp, geo, sh);
-}
-
-/// An armed Format Painter pastes onto the cells just clicked or dragged over (not while
-/// pointing a formula reference, which also drags a Select).
-fn format_painter_apply(app: &mut SheetApp) {
-    if app.session.format_painter.is_some()
-        && !app.editor.as_ref().is_some_and(|ed| ed.can_point())
-        && !app.dialog.as_ref().is_some_and(|d| d.picks_references())
-    {
-        let dest = app.session.active().map(|d| d.selection.current().a1());
-        if let Some(dest) = dest
-            && let Err(e) = app.run("edit.formatPainter", json!({"apply": dest}))
-        {
-            app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
-        }
-    }
-}
-
-/// Point mode on a header: inserts a whole-row or whole-column reference instead of selecting.
-fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, extend: bool, add: bool) -> bool {
-    let Some(ed) = app.editor.as_mut().filter(|ed| ed.can_point()) else { return false };
-    let edit_sheet = ed.sheet;
-    let active_sheet = wb.active_sheet();
-    let range = if extend {
-        ed.point
-            .and_then(|point| crate::editor::formula_refs(&ed.text).into_iter().find(|(start, end, ..)| (*start, *end) == point))
-            .and_then(|(_, _, previous, previous_sheet, _)| {
-                let previous_sheet = previous_sheet.as_deref().map(|name| wb.sheet_index(name)).unwrap_or(Some(edit_sheet));
-                if previous_sheet != Some(active_sheet) {
-                    return None;
-                }
-                if range.is_full_cols() && previous.is_full_cols() {
-                    Some(RangeRef::cols(previous.start.col.min(range.start.col), previous.end.col.max(range.end.col)))
-                } else if range.is_full_rows() && previous.is_full_rows() {
-                    Some(RangeRef::rows(previous.start.row.min(range.start.row), previous.end.row.max(range.end.row)))
-                } else {
-                    None
-                }
-            })
-            .unwrap_or(range)
-    } else {
-        range
-    };
-    let reference = range.a1();
-    let reference =
-        if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference };
-    if add {
-        ed.append_ref(&reference);
-    } else {
-        ed.insert_ref(&reference);
-    }
-    ed.point_anchor = None;
-    ed.point_cell = Some(range.start);
-    ed.request_focus = true;
-    true
-}
-
-fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p: Pos2) {
-    let cell = CellRef::new(
-        geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)),
-        geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)),
-    );
-    if let Some(d) = app.dialog.as_mut().filter(|d| d.picks_references()) {
-        d.pick_reference(cell, &sh.name, true);
-    } else if let Some(ed) = app.editor.as_mut()
-        && ed.point.is_some()
-    {
-        if let Some(start) = ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet()).map(|(_, cell)| cell).or(ed.point_cell) {
-            let range = RangeRef::new(start, cell);
-            let text = if range.is_single() { range.start.a1() } else { range.a1() };
-            let text = if ed.sheet != wb.active_sheet() { format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { text };
-            ed.insert_ref(&text);
-            ed.point_cell = Some(cell);
-            ed.point_anchor = Some((wb.active_sheet(), start));
-        }
-    } else if let Some(d) = app.session.active() {
-        // Read the current anchor: starting a drag may have just replaced the selection.
-        let anchor = d.selection.anchor;
-        let active = d.selection.active;
-        let mut ranges: Vec<String> = d.selection.ranges.iter().map(|r| r.a1()).collect();
-        ranges.pop();
-        ranges.push(RangeRef::new(anchor, cell).a1());
-        let _ = app.session.run("selection.set", json!({"range": ranges.join(","), "active": active.a1()}));
-        if let Some(d) = app.session.active_mut() {
-            d.selection.anchor = anchor;
-        }
-    }
-}
-
-fn coalesce_last_undo(app: &mut SheetApp) {
-    // Merge consecutive drag steps into one undo entry.
-    if let Some(d) = app.session.active_mut()
-        && d.undo.len() >= 2
-    {
-        let n = d.undo.len();
-        if d.undo[n - 1].label == d.undo[n - 2].label {
-            d.undo.remove(n - 1);
-        }
-    }
-}
-
-fn scroll_by(app: &mut SheetApp, d: egui::Vec2) {
-    if d != egui::Vec2::ZERO
-        && let Some(v) = app.view_mut()
-    {
-        v.scroll = (v.scroll + d).max(egui::Vec2::ZERO);
-    }
-}
-
-fn fill_target(src: RangeRef, pc: CellRef) -> RangeRef {
-    let below = pc.row as i64 - src.end.row as i64;
-    let above = src.start.row as i64 - pc.row as i64;
-    let right = pc.col as i64 - src.end.col as i64;
-    let left = src.start.col as i64 - pc.col as i64;
-    let vert = below.max(above);
-    let horiz = right.max(left);
-    if vert <= 0 && horiz <= 0 {
-        return src;
-    }
-    if vert >= horiz {
-        if below > 0 {
-            RangeRef::new(src.start, CellRef::new(pc.row, src.end.col))
-        } else {
-            RangeRef::new(CellRef::new(pc.row, src.start.col), src.end)
-        }
-    } else if right > 0 {
-        RangeRef::new(src.start, CellRef::new(src.end.row, pc.col))
-    } else {
-        RangeRef::new(CellRef::new(src.start.row, pc.col), src.end)
-    }
-}
-
-fn on_border(r: Rect, p: Pos2) -> bool {
-    let outer = r.expand(3.0);
-    let inner = r.shrink(3.0);
-    outer.contains(p) && !inner.contains(p)
-}
-
-/// The freeze handles, as in Excel for the web: a bar in the upper part of the column-header strip
-/// on the frozen columns' right edge, and one in the left part of the row-header strip on the
-/// frozen rows' bottom edge. With nothing frozen they sit on the corner's edges. The rest of the
-/// header edge keeps resizing the column or row.
-pub fn freeze_handles(geo: &Geo) -> (Rect, Rect) {
-    let x = geo.cells.left() + geo.frozen_w;
-    let y = geo.cells.top() + geo.frozen_h;
-    let cols = Rect::from_min_max(pos2(x - 3.0, geo.head_top()), pos2(x + 3.0, geo.head_top() + geo.header_h * 0.4));
-    let rows = Rect::from_min_max(pos2(geo.head_left(), y - 3.0), pos2(geo.head_left() + geo.header_w * 0.4, y + 3.0));
-    (cols, rows)
-}
-
-/// How many columns (or rows) a freeze handle dropped at `p` freezes: the line boundary nearest
-/// the pointer, limited so the frozen pane leaves room for the scrolling one.
-fn freeze_boundary(geo: &Geo, sh: &Sheet, p: Pos2, cols: bool) -> u32 {
-    if cols {
-        if p.x <= geo.cells.left() {
-            return 0;
-        }
-        let c = geo.col_at(sh, p.x);
-        let (l, r) = (geo.x(sh, c), geo.x(sh, c.saturating_add(1).min(MAX_COLS - 1)));
-        let b = if p.x - l > r - p.x { c.saturating_add(1) } else { c };
-        let room = geo.ci.at((((geo.cells.width() - 40.0) / geo.z).max(0.0)) as f64);
-        b.min(room).min(MAX_COLS - 1)
-    } else {
-        if p.y <= geo.cells.top() {
-            return 0;
-        }
-        let rr = geo.row_at(sh, p.y);
-        let (t, b2) = (geo.y(sh, rr), geo.y(sh, rr.saturating_add(1).min(MAX_ROWS - 1)));
-        let b = if p.y - t > b2 - p.y { rr.saturating_add(1) } else { rr };
-        let room = geo.ri.at((((geo.cells.height() - 40.0) / geo.z).max(0.0)) as f64);
-        b.min(room).min(MAX_ROWS - 1)
-    }
-}
-
-/// Paints the freeze handles and, while one is dragged, where the freeze line will go.
-fn paint_freeze_handles(p: &Painter, geo: &Geo, sh: &Sheet, drag: &Drag, t: &Tokens) {
-    let (cols, rows) = freeze_handles(geo);
-    let bar = Color32::from_gray(150);
-    p.rect_filled(Rect::from_center_size(cols.center(), vec2(3.0, cols.height())), 1.0, bar);
-    p.rect_filled(Rect::from_center_size(rows.center(), vec2(rows.width(), 3.0)), 1.0, bar);
-    if let Drag::Freeze { cols, to: Some(to) } = *drag {
-        let stroke = Stroke::new(2.0, t.accent);
-        if cols {
-            let x = geo.cells.left() + sh.col_left(to) as f32 * geo.z;
-            p.line_segment([pos2(x, geo.head_top()), pos2(x, geo.cells.bottom())], stroke);
-        } else {
-            let y = geo.cells.top() + sh.row_top(to) as f32 * geo.z;
-            p.line_segment([pos2(geo.head_left(), y), pos2(geo.cells.right(), y)], stroke);
-        }
-    }
-}
-
-fn col_edge(geo: &Geo, sh: &Sheet, x: f32) -> Option<(u32, f32)> {
-    let c = geo.col_at(sh, x);
-    for cc in [c, c.saturating_sub(1)] {
-        let edge = geo.x(sh, cc) + sh.col_width(cc) * geo.z;
-        if (x - edge).abs() <= 4.0 {
-            return Some((cc, edge));
-        }
-    }
-    None
-}
-
-fn row_edge(geo: &Geo, sh: &Sheet, y: f32) -> Option<(u32, f32)> {
-    let r = geo.row_at(sh, y);
-    for rr in [r, r.saturating_sub(1)] {
-        let edge = geo.y(sh, rr) + sh.row_height(rr) * geo.z;
-        if (y - edge).abs() <= 3.0 {
-            return Some((rr, edge));
-        }
-    }
-    None
-}
-
-/// The hidden column whose (zero-width) edge is at `x`: only just right of the boundary, as the
-/// edge just left of it belongs to the visible column there.
-fn hidden_col_edge(geo: &Geo, sh: &Sheet, x: f32) -> Option<u32> {
-    col_edge(geo, sh, x).map(|(c, _)| c).filter(|&c| sh.col_width(c) <= 0.0)
-}
-
-fn hidden_row_edge(geo: &Geo, sh: &Sheet, y: f32) -> Option<u32> {
-    row_edge(geo, sh, y).map(|(r, _)| r).filter(|&r| sh.row_height(r) <= 0.0)
-}
-
-/// A split cursor (two bars with arrows either side) painted in place of the OS cursor, which
-/// has no such shape. Black on a white outline, like the system cursors.
-fn paint_split_cursor(ctx: &egui::Context, at: Pos2, cols: bool) {
-    ctx.set_cursor_icon(CursorIcon::None);
-    let p = ctx.layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("gridcraft.split_cursor")));
-    // Drawn for columns (bars vertical); rows swap the axes.
-    let pt = |x: f32, y: f32| if cols { pos2(at.x + x, at.y + y) } else { pos2(at.x + y, at.y + x) };
-    let arrow = |dir: f32| vec![pt(dir * 10.0, 0.0), pt(dir * 6.0, -4.0), pt(dir * 6.0, 4.0)];
-    for (width, color) in [(3.0, Color32::WHITE), (1.0, Color32::BLACK)] {
-        let stroke = Stroke::new(width, color);
-        for bx in [-1.5, 1.5] {
-            p.line_segment([pt(bx, -8.0), pt(bx, 8.0)], stroke);
-        }
-        p.line_segment([pt(-7.0, 0.0), pt(7.0, 0.0)], stroke);
-        for dir in [-1.0, 1.0] {
-            p.add(egui::Shape::convex_polygon(arrow(dir), color, Stroke::new(width - 1.0, color)));
-        }
-    }
-}
-
-fn is_filter_button(sh: &Sheet, geo: &Geo, p: Pos2) -> bool {
-    let c = geo.cell_at(sh, p);
-    sh.has_filter_button(c) && filter_button_rect(geo, sh, c).contains(p)
-}
-
-fn object_anchor(sh: &Sheet, kind: &str, id: u32) -> Option<gridcraft_engine::model::Anchor> {
-    match kind {
-        "chart" => sh.charts.iter().find(|c| c.id == id).map(|c| c.anchor),
-        "image" => sh.images.iter().find(|c| c.id == id).map(|c| c.anchor),
-        "slicer" => sh.slicers.iter().find(|c| c.id == id).map(|c| c.anchor),
-        _ => sh.shapes.iter().find(|c| c.id == id).map(|c| c.anchor),
-    }
-}
-
-fn delete_selected_object(app: &mut SheetApp, sh: &Sheet) -> bool {
-    let Some(id) = app.selected_chart else { return false };
-    let kind = if sh.charts.iter().any(|object| object.id == id) {
-        "chart"
-    } else if sh.images.iter().any(|object| object.id == id) {
-        "image"
-    } else if sh.shapes.iter().any(|object| object.id == id) {
-        "shape"
-    } else {
-        return false;
-    };
-    app.run_or_alert("object.delete", json!({"kind": kind, "id": id}));
-    app.selected_chart = None;
-    true
-}
-
-/// A click on a hyperlink. References select; web and e-mail addresses ask first (the dialog's
-/// OK runs `link.open`); every other kind is refused with a message. The decision is the
-/// engine's ([`gridcraft_engine::links::classify`]), the same one `link.open` applies.
-pub fn follow_link(app: &mut SheetApp, target: &str) {
-    use gridcraft_engine::links::{LinkKind, classify};
-    match classify(target) {
-        LinkKind::Internal(r) => {
-            let _ = app.session.run("edit.goTo", json!({"reference": r.trim_start_matches('#')}));
-            app.grid.ensure_visible = true;
-        }
-        LinkKind::External(url) => app.open_dialog("openLink", json!({"url": url})),
-        LinkKind::Refused(why) => app.message = Some(("Hyperlink".into(), why)),
-    }
-}
-
-/// The areas after a click: with `add` (Ctrl) the clicked area is added, or removed when it is already
-/// selected (unless it is the only one, so the selection never ends up empty).
-fn toggled_ranges(mut ranges: Vec<String>, clicked: String, add: bool) -> Vec<String> {
-    if !add {
-        return vec![clicked];
-    }
-    if ranges.len() > 1 && ranges.contains(&clicked) {
-        ranges.retain(|x| *x != clicked);
-    } else if !ranges.contains(&clicked) {
-        ranges.push(clicked);
-    }
-    ranges
-}
-
-fn select_ranges(app: &mut SheetApp, r: RangeRef, add: bool, active: CellRef) {
-    let current: Vec<String> =
-        if add { app.session.active().map(|d| d.selection.ranges.iter().map(|x| x.a1()).collect()).unwrap_or_default() } else { vec![] };
-    let clicked = r.a1();
-    let ranges = toggled_ranges(current, clicked.clone(), add);
-    // A removed area takes the active cell with it; `selection.set` then puts it at the start of the last area.
-    let params =
-        if ranges.contains(&clicked) { json!({"range": ranges.join(","), "active": active.a1()}) } else { json!({"range": ranges.join(",")}) };
-    let _ = app.session.run("selection.set", params);
-}
-
-/// Grid keyboard handling when no text field has focus.
-fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Response, geo: &Geo, sh: &Sheet) {
-    // Focus left on an editor that no longer exists goes back to the grid.
-    let stale = [egui::Id::unique("gridcraft.cell_editor"), egui::Id::unique("gridcraft.formula_bar"), crate::text_box::editor_id()];
-    let editing = app.editor.is_some() || app.text_box_editor.is_some();
-    if !editing && ctx.memory(|m| m.focused()).is_some_and(|f| stale.contains(&f)) {
-        resp.request_focus();
-    }
-    let other_focus = ctx.memory(|m| m.focused()).is_some_and(|f| f != resp.id && (editing || !stale.contains(&f)));
-    // An open filter menu owns the keyboard even when a click inside it left focus on nothing (#1516).
-    // So do the fill menu (its Esc closes it, not the copy) and the right-drag that opens it (an
-    // arrow key would move the selection the menu fills from).
-    if editing
-        || app.dialog.is_some()
-        || other_focus
-        || app.message.is_some()
-        || app.grid.filter_menu.is_some()
-        || app.grid.fill_menu.is_some()
-        || matches!(app.grid.drag, Drag::Fill { menu: true, .. })
-    {
-        return;
-    }
-    if ctx.memory(|m| m.focused()).is_none() {
-        resp.request_focus();
-    }
-    // The grid owns arrows, Tab and Escape (egui would otherwise move focus between widgets).
-    ctx.memory_mut(|m| {
-        m.set_focus_lock_filter(resp.id, egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, escape: true })
-    });
-    let events = ctx.input(|i| i.events.clone());
-    // A shortcut key that also types a character (Shift+Space sends Text(" ")) must not start an edit.
-    let shortcut_pressed = events.iter().any(|e| {
-        matches!(e, egui::Event::Key { pressed: true, modifiers: m, key, .. }
-            if !m.alt && (m.ctrl || m.command || (m.shift && *key == egui::Key::Space)))
-    });
-    let page = ((geo.cells.height() / geo.z) / sh.default_row_height).floor().max(1.0) as i64;
-    // Alt shortcuts type their character too on Windows and Linux (Alt+= sends Text("=")): once
-    // a shortcut ran, that text must not start an edit over what it just did.
-    let mut shortcut_ran = false;
-    for ev in events {
-        match ev {
-            egui::Event::Copy => {
-                app.copy_to_clipboard(ctx, "edit.copy");
-            }
-            egui::Event::Cut => {
-                app.copy_to_clipboard(ctx, "edit.cut");
-            }
-            egui::Event::Paste(text) => app.paste_external(text),
-            // GridCraft has no image-clipboard pipeline and no cell-picture insert-from-clipboard
-            // command. Choosing to ignore `PasteImage` is explicit: inserting the bytes as a
-            // floating picture without a chosen anchor/size would be a new feature, not parity.
-            // A text representation, when the clipboard has one, still arrives as `Paste` above.
-            egui::Event::PasteImage(_) => {}
-            // PRIMARY middle-click paste belongs to egui's TextEdit; the grid has no caret to
-            // insert text at, so a middle click on a cell is deliberately not a paste.
-            egui::Event::MiddleClickPaste { .. } => {}
-            egui::Event::Text(_) if shortcut_pressed || shortcut_ran => {}
-            egui::Event::Text(text) if text.chars().all(|c| !c.is_control()) && !text.is_empty() => {
-                app.begin_edit(Some(text), false);
-                if let Some(ed) = app.editor.as_mut() {
-                    ed.caret = ed.text.chars().count();
-                }
-                return;
-            }
-            egui::Event::Key { key, physical_key, pressed: true, modifiers: m, .. } => {
-                use egui::Key;
-                if crate::keymap::dispatch(app, ctx, key, physical_key, m, geo, sh) {
-                    shortcut_ran = true;
-                    continue;
-                }
-                let cmd = m.command;
-                let shift = m.shift;
-                let mv = |app: &mut SheetApp, dr: i64, dc: i64| {
-                    let from = app.session.active().map(|d| if shift { d.selection.moving_end() } else { d.selection.active });
-                    let _ = app.session.run("selection.move", json!({"dr": dr, "dc": dc, "extend": shift, "jump": cmd}));
-                    app.grid.ensure_visible = true;
-                    app.grid.reveal_moving_end = shift;
-                    app.grid.reveal_from = from;
-                };
-                match key {
-                    Key::ArrowUp => mv(app, -1, 0),
-                    Key::ArrowDown => mv(app, 1, 0),
-                    // Arrows follow the screen: on a right-to-left sheet Left goes to the next column.
-                    Key::ArrowLeft => mv(app, 0, if sh.right_to_left { 1 } else { -1 }),
-                    Key::ArrowRight => mv(app, 0, if sh.right_to_left { -1 } else { 1 }),
-                    Key::PageDown if !cmd => mv(app, page, 0),
-                    Key::PageUp if !cmd => mv(app, -page, 0),
-                    Key::PageDown => app.run_or_alert("sheet.next", json!({})),
-                    Key::PageUp => app.run_or_alert("sheet.previous", json!({})),
-                    Key::Home if cmd => {
-                        let r = sh.freeze.map(|f| f.0).unwrap_or(0);
-                        let c = sh.freeze.map(|f| f.1).unwrap_or(0);
-                        let _ = app.session.run("selection.set", json!({"cell": CellRef::new(r, c).a1()}));
-                        app.grid.ensure_visible = true;
-                    }
-                    Key::End if cmd => {
-                        let end = sh.used_range().map(|u| u.end).unwrap_or_default();
-                        let _ = app.session.run("selection.set", json!({"cell": end.a1()}));
-                        app.grid.ensure_visible = true;
-                    }
-                    Key::Home => {
-                        let a = app.session.active().map(|d| d.selection.active).unwrap_or_default();
-                        let _ = app.session.run("selection.set", json!({"cell": CellRef::new(a.row, 0).a1()}));
-                        app.grid.ensure_visible = true;
-                    }
-                    // Excel: Enter while a copied range is marked pastes it and ends copy mode.
-                    Key::Enter if !m.alt && !m.ctrl && !shift && !cmd && app.session.clipboard.is_some() => {
-                        app.run_or_alert("edit.paste", json!({}));
-                        app.session.clipboard = None;
-                        app.grid.ensure_visible = true;
-                    }
-                    Key::Enter => {
-                        if m.alt || m.ctrl {
-                            app.begin_edit(None, false);
-                        } else {
-                            app.move_after_enter(if shift { -1 } else { 1 }, 0);
-                        }
-                    }
-                    Key::Tab => app.move_after_enter(0, if shift { -1 } else { 1 }),
-                    Key::F2 => app.begin_edit(None, false),
-                    Key::Delete if delete_selected_object(app, sh) => {}
-                    Key::Delete => app.run_or_alert("edit.clearContents", json!({})),
-                    Key::Backspace if delete_selected_object(app, sh) => {}
-                    Key::Backspace => {
-                        // Excel for Mac: Delete clears the cell and starts editing it.
-                        app.run_or_alert("edit.clearContents", json!({}));
-                        if app.session.active().is_some_and(|d| d.selection.is_single_cell()) {
-                            app.begin_edit(Some(String::new()), false);
-                        }
-                    }
-                    Key::Escape => {
-                        app.session.clipboard = None;
-                        app.session.format_painter = None;
-                    }
-                    Key::Space if !cmd && !shift && is_checkbox(sh, app) => app.run_or_alert("cell.toggleCheckbox", json!({})),
-                    Key::F8 if m.alt => {
-                        app.open_dialog("macros", json!({}));
-                    }
-                    Key::F9 => app.run_or_alert("formulas.calculateNow", json!({})),
-                    Key::F4 if !cmd => {}
-                    _ if cmd && !crate::keymap::altgr_text(ctx, m, ctx.os() == egui::os::OperatingSystem::Mac) => {
-                        crate::ribbon::shortcut(app, key, m)
-                    }
-                    _ => {}
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
-/// Room the in-cell editor keeps right of its text. It is sized from the text of the last frame, so
-/// the next typed character must still fit: a fixed 14 px was less than one glyph at high zoom,
-/// and the field scrolled and snapped back on every key (#2336). `size` is the font size in px.
-fn editor_slack(size: f32) -> f32 {
-    14.0 + size
-}
-
-/// Width of the one-line in-cell editor. While the text fits the cell (with the usual 14 px margin) the
-/// editor is exactly the cell wide, as in Excel; once it overflows, the extra `editor_slack` applies.
-fn editor_width(text_w: f32, cell_w: f32, size: f32) -> f32 {
-    if text_w + 14.0 <= cell_w { cell_w } else { text_w + editor_slack(size) }
-}
-
-/// Draws the in-cell editor, growing and wrapping with its text, mirroring for right-to-left sheets, choosing contrasting caret ink and clipping cells hidden under frozen panes.
-fn in_cell_editor(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet, wb: &Workbook) {
-    let Some(ed) = app.editor.as_ref() else { return };
-    if app.view_key() != Some((ed.doc, ed.sheet)) {
-        return;
-    }
-    let cell = ed.cell;
-    let rect = match sh.merge_at(cell) {
-        Some(m) => geo.range_rect(sh, m),
-        None => geo.cell_rect(sh, cell),
-    };
-    let st = wb.styles.get(sh.style_id(cell)).clone();
-    let size = st.font.size * 96.0 / 72.0 * geo.z;
-    let font = FontId::new(size, theme::cell_family(&st.font.name, st.font.bold, st.font.italic));
-    let lines = ed.text.lines().count().max(1) as f32 + if ed.text.ends_with('\n') { 1.0 } else { 0.0 };
-    // Grows with the text: the in-cell editor shows every line and never scrolls (the formula bar
-    // is the one that stops at five lines).
-    let shown = lines;
-    // Wrap Text: the editor keeps the column's width and wraps, growing down as Excel's does.
-    // Otherwise it widens to the text's one-line width.
-    let wrap = st.align.wrap;
-    let (w, h) = if wrap {
-        // The field wraps at the width it is given (the editor's less its 2 px inset a side): its
-        // frame is `Frame::NONE`, so no text margin is taken off.
-        let wrapped = ui.painter().layout(ed.text.clone(), font.clone(), Color32::BLACK, (rect.width() - 4.0).max(1.0));
-        (rect.width(), (wrapped.size().y.max(size * 1.3 * shown) + 4.0).max(rect.height()))
-    } else {
-        let text_w = ui.painter().layout_no_wrap(ed.text.clone(), font.clone(), Color32::BLACK).size().x;
-        // Excel keeps the cell's height for one line and only grows for extra lines.
-        let h = if lines > 1.0 { (size * 1.3 * lines + 4.0).max(rect.height()) } else { rect.height() };
-        (editor_width(text_w, rect.width(), size).min(geo.cells.right() - rect.left()), h)
-    };
-    // Grows to the left on a right-to-left sheet.
-    let erect = geo.mirror_rect(Rect::from_min_size(rect.min, vec2(w, h)));
-    let fill = match st.fill.pattern {
-        PatternType::Solid => st.fill.fg.resolve(&wb.theme).map(theme::color32).unwrap_or(Color32::WHITE),
-        _ => Color32::WHITE,
-    };
-    let split = pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h);
-    let quadrant = Rect::from_min_max(
-        pos2(if cell.col >= geo.fc { split.x } else { geo.cells.left() }, if cell.row >= geo.fr { split.y } else { geo.cells.top() }),
-        pos2(if cell.col >= geo.fc { geo.cells.right() } else { split.x }, if cell.row >= geo.fr { geo.cells.bottom() } else { split.y }),
-    );
-    // A cell scrolled entirely under a frozen row/column keeps its edit (Escape still works),
-    // but neither the cell nor its helper may paint. Test the cell's own visible quadrant and
-    // give the shared editor an empty clip when the cell is hidden: a one-line cell editor's
-    // field can be larger than the cell (egui 0.37 gives text fields a minimum height), so its
-    // own max_rect is not a reliable "is the cell on screen" test at the frozen boundary. The
-    // pre-wrap cell rect must also be positive: a hidden row/column has zero height/width, but
-    // Wrap Text can expand the editor below/right of it, which must not paint over the next line.
-    let cell_visible = rect.width() > 0.0 && rect.height() > 0.0;
-    // `erect` and `ui.clip_rect()` are in screen coordinates; `quadrant` is logical until mirrored.
-    let screen_quadrant = geo.mirror_rect(quadrant);
-    let on_screen = cell_visible && erect.intersect(screen_quadrant).is_positive() && !geo.hidden_under_frozen(sh, cell);
-    let clip = if on_screen { ui.clip_rect().intersect(screen_quadrant) } else { Rect::NOTHING };
-    let painter = ui.painter().with_clip_rect(clip);
-    painter.rect_filled(erect, 0.0, fill);
-    painter.rect_stroke(erect.expand(1.0), 0.0, Stroke::new(2.0, Tokens::get(ui.ctx()).sel_border), StrokeKind::Middle);
-    let id = egui::Id::unique("gridcraft.cell_editor");
-    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(erect.shrink2(vec2(2.0, 1.0))));
-    child.set_clip_rect(clip);
-    // The theme's caret is meant for the UI chrome and vanishes on some fills (and, in the dark
-    // theme, on the white paper): pick black or white against the fill, like Excel.
-    child.visuals_mut().text_cursor.stroke.color = ink_on(fill);
-    crate::formula_bar::editor_widget(app, &mut child, id, font, wrap, erect.width() - 4.0, erect.height() - 2.0);
-    ui.ctx().data_mut(|d| d.insert_temp(egui::Id::unique("gridcraft.cell_editor.rect"), erect));
-}
-
-/// Test the popup itself, not whether the pointer is over any part of the app.
-/// A trigger can sit outside its popup, so its opening click must be ignored.
-fn popup_dismissed(response: &egui::Response, was_open: bool) -> bool {
-    response.ctx.input(|i| !i.focused || i.key_pressed(egui::Key::Escape)) || (was_open && response.clicked_elsewhere())
-}
-
-/// Black or white, whichever reads on `fill` (the threshold chart labels use).
-fn ink_on(fill: Color32) -> Color32 {
-    let l = 0.299 * fill.r() as f32 + 0.587 * fill.g() as f32 + 0.114 * fill.b() as f32;
-    if l < 150.0 { Color32::WHITE } else { Color32::BLACK }
-}
-
-/// The table whose header cell (`row`, `col`) was clicked, not just the first table in the column.
-fn filter_table_range(sh: &Sheet, col: u32, row: u32) -> Option<RangeRef> {
-    sh.tables.iter().find(|t| t.range.start.row == row && col >= t.range.start.col && col <= t.range.end.col).map(|t| t.range)
-}
-
-/// Draws the filter-header popup: sort, search/select-all, apply/clear, a lazily installed table autofilter, new-open search focus and dismissal.
-fn filter_menu(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_open: bool) {
-    let Some((col, row, at)) = app.grid.filter_menu else { return };
-    let Some(d) = app.session.active() else { return };
-    let wb = d.wb.clone();
-    let si = wb.active_sheet();
-    let Some(sh) = wb.sheet(si) else { return };
-    let _ = geo;
-    // Tables get an autofilter on demand.
-    let table_range = filter_table_range(sh, col, row);
-    if sh.autofilter.is_none()
-        && let Some(r) = table_range
-    {
-        let _ = app.session.run("data.filter", json!({"range": r.a1()}));
-        let _ = app.session.run("data.filter", json!({"range": r.a1()}));
-        if let Some(sh2) = app.session.active().and_then(|d| d.wb.active()).map(|s| s.autofilter.is_some())
-            && !sh2
-        {
-            let d = app.session.active_mut();
-            if let Some(d) = d {
-                let wbm = Arc::make_mut(&mut d.wb);
-                if let Some(s) = wbm.sheet_mut(si) {
-                    s.autofilter = Some(gridcraft_engine::model::AutoFilter { range: r, criteria: vec![] });
-                }
-            }
-        }
-    }
-    let wb = app.session.active().map(|d| d.wb.clone()).unwrap_or(wb);
-    let values = gridcraft_engine::cmd::data::filter_values(&wb, si, col);
-    let key = egui::Id::unique(("filter_sel", col));
-    let search_key = egui::Id::unique(("filter_search", col));
-    let buttons_key = egui::Id::unique(("filter_buttons", col));
-    // Enter is the menu's OK, as in Excel: taken before the search box (which would only drop its
-    // focus) and the value checkboxes (which would toggle) see it. A focused button keeps it as its click.
-    let buttons: Vec<egui::Id> = ui.ctx().data_mut(|d| d.get_temp(buttons_key)).unwrap_or_default();
-    let on_button = ui.ctx().memory(|m| m.focused()).is_some_and(|f| buttons.contains(&f));
-    let enter = !on_button && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Enter));
-    let mut close = false;
-    let area = egui::Area::new(egui::Id::unique("filter_menu")).fixed_pos(at + vec2(-180.0, 10.0)).order(egui::Order::Foreground);
-    let response = area.show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_width(230.0);
-            let ascending = ui.button("↑  Sort Ascending");
-            if ascending.clicked() {
-                let _ = app.run("data.sortAscending", json!({"column": col_to_letters(col)}));
-                close = true;
-            }
-            let descending = ui.button("↓  Sort Descending");
-            if descending.clicked() {
-                let _ = app.run("data.sortDescending", json!({"column": col_to_letters(col)}));
-                close = true;
-            }
-            ui.separator();
-            ui.label(egui::RichText::new("Filter").strong());
-            let mut checks: Vec<(String, bool)> = ui.ctx().data_mut(|d| d.get_temp::<Vec<(String, bool)>>(key)).unwrap_or(values.clone());
-            // A search narrows the list; Select All and Apply then only cover the matches.
-            let mut search: String = ui.ctx().data_mut(|d| d.get_temp(search_key)).unwrap_or_default();
-            let field = ui.add(egui::TextEdit::singleline(&mut search).hint_text("Search").desired_width(f32::INFINITY));
-            if !was_open {
-                field.request_focus();
-            }
-            let needle = search.trim().to_lowercase();
-            let matches = |v: &str| needle.is_empty() || v.to_lowercase().contains(&needle);
-            let all = checks.iter().filter(|(v, _)| matches(v)).all(|(_, b)| *b);
-            let mut all_new = all;
-            let label = if needle.is_empty() { "(Select All)" } else { "(Select All Search Results)" };
-            if ui.checkbox(&mut all_new, label).changed() {
-                for c in checks.iter_mut().filter(|(v, _)| matches(v)) {
-                    c.1 = all_new;
-                }
-            }
-            // Full width: shrunk to the longest value, the scroll bar sat mid-menu and the wheel only
-            // worked over the values themselves (#432).
-            egui::ScrollArea::vertical().max_height(220.0).auto_shrink([false, true]).show(ui, |ui| {
-                for (v, on) in checks.iter_mut().filter(|(v, _)| matches(v)) {
-                    ui.checkbox(on, v.as_str());
-                }
-            });
-            ui.ctx().data_mut(|d| {
-                d.insert_temp(key, checks.clone());
-                d.insert_temp(search_key, search.clone());
-            });
-            let checks: Vec<(String, bool)> = checks.iter().map(|(v, on)| (v.clone(), *on && matches(v))).collect();
-            ui.separator();
-            ui.horizontal(|ui| {
-                let clear = ui.button("Clear Filter");
-                if clear.clicked() {
-                    let _ = app.run("data.filterBy", json!({"column": col_to_letters(col), "clear": true}));
-                    close = true;
-                }
-                // Nothing checked would hide every row, so Enter (unlike a click on Apply) does nothing then.
-                let any = checks.iter().any(|(_, on)| *on);
-                let apply = ui.button("Apply");
-                ui.ctx().data_mut(|d| d.insert_temp(buttons_key, vec![ascending.id, descending.id, clear.id, apply.id]));
-                if apply.clicked() || (enter && any) {
-                    let blanks = checks.iter().any(|(v, on)| v == "(Blanks)" && *on);
-                    let vals: Vec<String> = checks.iter().filter(|(v, on)| *on && v != "(Blanks)").map(|(v, _)| v.clone()).collect();
-                    let p = if checks.iter().all(|(_, b)| *b) {
-                        json!({"column": col_to_letters(col), "clear": true})
-                    } else {
-                        json!({"column": col_to_letters(col), "values": vals, "blanks": blanks})
-                    };
-                    let _ = app.run("data.filterBy", p);
-                    close = true;
-                }
-            });
-        });
-    });
-    if close || popup_dismissed(&response.response, was_open) {
-        ui.ctx().data_mut(|d| {
-            d.remove::<Vec<(String, bool)>>(key);
-            d.remove::<String>(search_key);
-            d.remove::<Vec<egui::Id>>(buttons_key);
-        });
-        app.grid.filter_menu = None;
-    }
-}
-
-/// Draws and dispatches the cell context menu, including Show Details when offered, clipboard and insert/format actions; closes on Esc or an outside press.
-fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
-    let Some(at) = app.grid.context_menu else { return };
-    let mut close = false;
-    let resp = egui::Area::new(egui::Id::unique("cell_context")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_min_width(200.0);
-            let insert_copied = insert_copied_item(app);
-            let mut items: Vec<(&str, &str)> = vec![
-                ("Cut", "edit.cut"),
-                ("Copy", "edit.copy"),
-                ("Paste", "edit.paste"),
-                ("Paste Special…", "ui:pasteSpecial"),
-                ("-", ""),
-                ("Insert…", "ui:insertCells"),
-                ("Delete…", "ui:deleteCells"),
-                ("Clear Contents", "edit.clearContents"),
-                ("-", ""),
-                ("Filter by Selected Cell's Value", "ui:filterValue"),
-                ("Sort A to Z", "data.sortAscending"),
-                ("Sort Z to A", "data.sortDescending"),
-                ("-", ""),
-                ("New Comment", "ui:newComment"),
-                ("New Note", "ui:newNote"),
-                ("-", ""),
-                ("Format Cells…", "ui:formatCells"),
-                ("Pick From Drop-down List…", "ui:pickList"),
-                ("Define Name…", "ui:defineName"),
-                ("Link…", "ui:insertLink"),
-            ];
-            if let Some(item) = insert_copied {
-                items.insert(6, item);
-            }
-            if show_details_offered(app)
-                && let Some(i) = items.iter().position(|(_, id)| *id == "data.sortDescending")
-            {
-                items.insert(i + 1, ("-", ""));
-                items.insert(i + 2, ("Show Details", "pivot.showDetails"));
-            }
-            let lang = crate::i18n::current(ui.ctx());
-            for (label, id) in items {
-                if label == "-" {
-                    ui.separator();
-                    continue;
-                }
-                if ui.add(egui::Button::new(lang.tr(label)).frame_when_inactive(false).min_size(vec2(190.0, 20.0))).clicked() {
-                    close = true;
-                    match id {
-                        "ui:pasteSpecial" => app.open_dialog("pasteSpecial", json!({})),
-                        "ui:insertPaste" => app.open_dialog("insertPaste", json!({})),
-                        "ui:insertCells" => app.open_dialog("insertCells", json!({})),
-                        "ui:deleteCells" => app.open_dialog("deleteCells", json!({})),
-                        "ui:formatCells" => app.open_dialog("formatCells", json!({})),
-                        "ui:newComment" => app.open_dialog("comment", json!({"threaded": true})),
-                        "ui:newNote" => app.open_dialog("comment", json!({"threaded": false})),
-                        "ui:defineName" => app.open_dialog("defineName", json!({})),
-                        "ui:insertLink" => app.open_dialog("insertLink", json!({})),
-                        "ui:pickList" => app.open_dialog("pickList", json!({})),
-                        "ui:filterValue" => {
-                            if let Some(d) = app.session.active() {
-                                let a = d.selection.active;
-                                let text = d.wb.active().map(|sh| gridcraft_engine::display::cell_text(&d.wb, sh, a)).unwrap_or_default();
-                                let has = d.wb.active().is_some_and(|sh| sh.autofilter.is_some());
-                                if !has {
-                                    let _ = app.run("data.filter", json!({}));
-                                }
-                                app.run_or_alert("data.filterBy", json!({"column": col_to_letters(a.col), "values": [text]}));
-                            }
-                        }
-                        "edit.copy" | "edit.cut" => {
-                            app.copy_to_clipboard(ui.ctx(), id);
-                        }
-                        "edit.paste" => app.paste_from_clipboard(),
-                        other => app.run_or_alert(other, json!({})),
-                    }
-                }
-            }
-        });
-    });
-    // A quick right-click presses and releases in one frame, and the menu's corner snaps to the
-    // nearest physical pixel, which can put the pointer just outside it: that press opened the
-    // menu, so it doesn't count as a click elsewhere.
-    let opened_now = app.grid.context_menu_frame == ui.ctx().cumulative_frame_nr();
-    if close
-        || ui.input(|i| i.key_pressed(egui::Key::Escape))
-        || (!opened_now
-            && ui.input(|i| i.pointer.any_pressed())
-            && !resp.response.contains_pointer()
-            && !resp.response.hovered()
-            && ui.input(|i| i.pointer.interact_pos()).is_some_and(|p| !resp.response.rect.contains(p)))
-    {
-        app.grid.context_menu = None;
-    }
-}
-
-/// Whether the cell menu offers Show Details (Excel's right-click › Show Details): the active cell
-/// is a value, subtotal or grand total cell of a PivotTable, or a cell of a report that is out of
-/// date, where running the command says so. Labels and headers of a current report don't offer it,
-/// and no cell does while the PivotTable's Enable show details option is off.
-fn show_details_offered(app: &mut SheetApp) -> bool {
-    let Some(d) = app.session.active() else { return false };
-    let (si, at) = (d.wb.active_sheet(), d.selection.active);
-    let Some((pi, pt)) = d.wb.active().and_then(|sh| sh.pivots.iter().enumerate().find(|(_, pt)| pt.last_range.is_some_and(|r| r.contains(at))))
-    else {
-        return false;
-    };
-    if !pt.enable_show_details {
-        return false;
-    }
-    let origin = pt.last_range.map(|r| r.start).unwrap_or_default();
-    let cell = (at.row.saturating_sub(origin.row), at.col.saturating_sub(origin.col));
-    let key = (d.uid, d.revision, si, pi);
-    if let Some((k, cells)) = &app.grid.show_details_cells
-        && *k == key
-    {
-        return cells.as_ref().is_none_or(|c| c.contains(&cell));
-    }
-    let cells = gridcraft_engine::pivot::detail_cells(&d.wb, pt, si).ok();
-    let on = cells.as_ref().is_none_or(|c| c.contains(&cell));
-    app.grid.show_details_cells = Some((key, cells));
-    on
-}
-
-/// The ways to fill a dragged range, as the fill menu and the Auto Fill Options button list them.
-const FILL_MODES: [(&str, &str); 4] =
-    [("Copy Cells", "copy"), ("Fill Series", "extend"), ("Fill Formatting Only", "formats"), ("Fill Without Formatting", "values")];
-
-/// The ways to fill from a date, which both menus add after [`FILL_MODES`] when the source starts
-/// with one.
-const DATE_FILL_MODES: [(&str, &str); 4] = [("Fill Days", "days"), ("Fill Weekdays", "weekdays"), ("Fill Months", "months"), ("Fill Years", "years")];
-
-/// The fill modes the menus list for a fill from `src` on the active sheet.
-fn fill_modes(app: &SheetApp, src: RangeRef) -> Vec<(&'static str, &'static str)> {
-    let dates = app.session.active().is_some_and(|d| gridcraft_engine::fill::starts_with_date(&d.wb, d.wb.active_sheet(), src));
-    FILL_MODES.into_iter().chain(DATE_FILL_MODES.into_iter().filter(|_| dates)).collect()
-}
-
-/// Remembers the fill just made so the Auto Fill Options button can offer the other ways.
-fn set_fill_tag(app: &mut SheetApp, src: RangeRef, target: RangeRef) {
-    app.grid.fill_tag =
-        app.session.active().map(|d| FillTag { src, target, uid: d.uid, sheet: d.wb.active_sheet(), revision: d.revision, undo_len: d.undo.len() });
-}
-
-/// The Auto Fill Options button below the bottom-right corner of cells a left-drag of the fill
-/// handle just filled. Its menu redoes that fill as Copy Cells, Fill Series, Fill Formatting Only
-/// or Fill Without Formatting, and from a date also as Fill Days, Fill Weekdays, Fill Months or
-/// Fill Years: it undoes the drag's fill, then runs `edit.autoFill` in that mode.
-/// The button goes away as soon as anything else changes the workbook or the selection moves.
-fn fill_options_tag(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet) {
-    let Some(tag) = app.grid.fill_tag.clone() else { return };
-    let current = app.session.active().is_some_and(|d| {
-        d.uid == tag.uid
-            && d.wb.active_sheet() == tag.sheet
-            && d.revision == tag.revision
-            && d.undo.len() == tag.undo_len
-            && d.selection.ranges.len() == 1
-            && d.selection.ranges.first().is_some_and(|r| *r == tag.target)
-    });
-    if !current {
-        app.grid.fill_tag = None;
-        return;
-    }
-    if app.editor.is_some() || app.dialog.is_some() || app.grid.drag != Drag::None {
-        return;
-    }
-    let size = vec2(18.0, 18.0);
-    let corner = geo.range_rect(sh, tag.target).right_bottom();
-    let button = geo.mirror_rect(Rect::from_min_size(corner + vec2(2.0, 2.0), size));
-    // `button` is in screen space, so compare it with the mirrored cells area.
-    if !geo.mirror_rect(geo.cells).contains_rect(button) {
-        return;
-    }
-    let lang = crate::i18n::current(ui.ctx());
-    let resp = ui.interact(button, egui::Id::unique("gridcraft.fill_options_tag"), Sense::click()).on_hover_text(lang.tr("Auto Fill Options"));
-    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, lang.tr("Auto Fill Options")));
-    let t = Tokens::get(ui.ctx());
-    let p = ui.painter();
-    p.rect_filled(button, 3.0, if resp.hovered() { t.hover } else { t.window });
-    p.rect_stroke(button, 3.0, Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
-    // Two small cells and a drop-down arrow.
-    let c = button.center();
-    p.rect_stroke(Rect::from_min_size(pos2(c.x - 6.0, c.y - 6.0), vec2(6.0, 6.0)), 0.0, Stroke::new(1.0, t.text), egui::StrokeKind::Inside);
-    p.rect_stroke(Rect::from_min_size(pos2(c.x - 3.0, c.y - 3.0), vec2(6.0, 6.0)), 0.0, Stroke::new(1.0, t.text), egui::StrokeKind::Inside);
-    p.add(egui::Shape::convex_polygon(
-        vec![pos2(c.x + 1.0, c.y + 5.0), pos2(c.x + 7.0, c.y + 5.0), pos2(c.x + 4.0, c.y + 8.0)],
-        t.text,
-        Stroke::NONE,
-    ));
-    let mut chosen = None;
-    let modes = fill_modes(app, tag.src);
-    egui::Popup::menu(&resp).show(|ui| {
-        ui.set_min_width(190.0);
-        for (label, mode) in modes {
-            if ui.add(egui::Button::new(lang.tr(label)).frame(false).min_size(vec2(180.0, 20.0))).clicked() {
-                chosen = Some(mode);
-                ui.close();
-            }
-        }
-    });
-    if let Some(mode) = chosen {
-        if let Err(e) = app.run("edit.undo", json!({})) {
-            app.grid.fill_tag = None;
-            app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
-            return;
-        }
-        match app.run("edit.autoFill", json!({"source": tag.src.a1(), "target": tag.target.a1(), "mode": mode})) {
-            Ok(_) => set_fill_tag(app, tag.src, tag.target),
-            Err(e) => {
-                app.grid.fill_tag = None;
-                app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
-            }
-        }
-    }
-}
-
-/// The menu a right-drag of the fill handle opens on release, as in Excel.
-fn fill_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) {
-    let Some((src, target, at)) = app.grid.fill_menu else { return };
-    let mut close = false;
-    let mut items = fill_modes(app, src);
-    items.extend([("-", ""), ("Series…", "ui:series")]);
-    let response = egui::Area::new(egui::Id::unique("fill_menu")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_min_width(190.0);
-            let lang = crate::i18n::current(ui.ctx());
-            for (label, mode) in items {
-                if label == "-" {
-                    ui.separator();
-                    continue;
-                }
-                if ui.add(egui::Button::new(lang.tr(label)).frame(false).min_size(vec2(180.0, 20.0))).clicked() {
-                    close = true;
-                    if mode == "ui:series" {
-                        let _ = app.session.run("selection.set", json!({"range": target.union(&src).a1(), "active": src.start.a1()}));
-                        let direction = if target.width() != src.width() { "rows" } else { "columns" };
-                        app.open_dialog("series", json!({"direction": direction}));
-                    } else if let Err(e) = app.run("edit.autoFill", json!({"source": src.a1(), "target": target.a1(), "mode": mode})) {
-                        app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
-                    }
-                }
-            }
-        });
-    });
-    if close || popup_dismissed(&response.response, was_open) {
-        app.grid.fill_menu = None;
-    }
-}
-
-/// The right-click menu of a chart, picture, shape or slicer.
-fn object_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
-    let Some((at, kind, id)) = app.grid.object_menu else { return };
-    let mut close = false;
-    let resp = egui::Area::new(egui::Id::unique("object_context")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_min_width(200.0);
-            let mut items = vec![("Delete", "object.delete")];
-            if kind == "chart" {
-                items.extend([("-", ""), ("Select Data…", "ui:selectData"), ("Format Chart Area…", "ui:formatChart")]);
-            }
-            let lang = crate::i18n::current(ui.ctx());
-            for (label, action) in items {
-                if label == "-" {
-                    ui.separator();
-                    continue;
-                }
-                if ui.add(egui::Button::new(lang.tr(label)).frame(false).min_size(vec2(190.0, 20.0))).clicked() {
-                    close = true;
-                    match action {
-                        "ui:selectData" => app.open_dialog("selectData", json!({"chart": id})),
-                        "ui:formatChart" => app.grid.pane = Some("formatChart".into()),
-                        _ => {
-                            app.run_or_alert("object.delete", json!({"kind": kind, "id": id}));
-                            app.selected_chart = None;
-                        }
-                    }
-                }
-            }
-        });
-    });
-    if close
-        || ui.input(|i| i.key_pressed(egui::Key::Escape))
-        || (ui.input(|i| i.pointer.any_pressed())
-            && !resp.response.contains_pointer()
-            && !resp.response.hovered()
-            && ui.input(|i| i.pointer.interact_pos()).is_some_and(|p| !resp.response.rect.contains(p)))
-    {
-        app.grid.object_menu = None;
-    }
-}
-
-/// The warning button beside an active cell holding a number stored as text, as in Excel: its
-/// menu names the problem and offers Convert to Number for the selection (#1994).
-fn error_check_tag(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet) {
-    if app.editor.is_some() || app.dialog.is_some() || sh.show_formulas || app.grid.drag != Drag::None {
-        return;
-    }
-    let Some(active) = app.session.active().map(|d| d.selection.active) else { return };
-    if sh.cell(active).and_then(gridcraft_engine::cmd::formulas::number_stored_as_text).is_none() {
-        return;
-    }
-    let cell = geo.cell_rect(sh, active);
-    let size = vec2(18.0, 18.0);
-    // Left of the cell, or right of it when that would cover the row headings.
-    let left = if cell.left() - size.x - 2.0 >= geo.cells.left() { cell.left() - size.x - 2.0 } else { cell.right() + 2.0 };
-    let tag = geo.mirror_rect(Rect::from_min_size(pos2(left, cell.top()), size));
-    if !geo.cells.intersects(tag) {
-        return;
-    }
-    let lang = crate::i18n::current(ui.ctx());
-    let resp = ui.interact(tag, egui::Id::unique("gridcraft.error_check_tag"), Sense::click()).on_hover_text(lang.tr("Number Stored as Text"));
-    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, lang.tr("Error checking options")));
-    let t = Tokens::get(ui.ctx());
-    let p = ui.painter();
-    p.rect_filled(tag, 3.0, if resp.hovered() { t.hover } else { t.window });
-    p.rect_stroke(tag, 3.0, Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
-    // A warning sign: an amber diamond with an exclamation mark.
-    let c = tag.center();
-    let r = 6.0;
-    p.add(egui::Shape::convex_polygon(
-        vec![pos2(c.x, c.y - r), pos2(c.x + r, c.y), pos2(c.x, c.y + r), pos2(c.x - r, c.y)],
-        t.warning_fill,
-        Stroke::NONE,
-    ));
-    p.text(c, egui::Align2::CENTER_CENTER, "!", egui::FontId::proportional(10.0), t.warning_ink);
-    egui::Popup::menu(&resp).show(|ui| {
-        ui.label(egui::RichText::new(lang.tr("Number Stored as Text")).strong());
-        ui.separator();
-        if ui.button(lang.tr("Convert to Number")).clicked() {
-            app.run_or_alert("formulas.convertToNumber", json!({}));
-            ui.close();
-        }
-    });
-}
-
-/// Used by `EditState` users to keep the active cell visible while pointing.
-pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, extend: bool) {
-    let Some(d) = app.session.active() else { return };
-    let from = ed.point_cell.unwrap_or(ed.cell);
-    let to = from.offset_clamped(dr, dc);
-    let anchor = if extend {
-        // The anchor is the corner opposite the moving end: the written range is normalized, so
-        // after extending up or left its first cell is the moving end, not the anchor.
-        let pointed = ed.point.and_then(|(s, e)| ed.text.get(s..e)).and_then(RangeRef::parse);
-        let inferred_anchor = pointed
-            .map(|r| {
-                CellRef::new(
-                    if from.row == r.start.row { r.end.row } else { r.start.row },
-                    if from.col == r.start.col { r.end.col } else { r.start.col },
-                )
-            })
-            .unwrap_or(from);
-        ed.point_anchor.filter(|(sheet, _)| *sheet == d.wb.active_sheet()).map(|(_, cell)| cell).unwrap_or(inferred_anchor)
-    } else {
-        to
-    };
-    let text = if extend { RangeRef::new(anchor, to).a1() } else { to.a1() };
-    let sheet = d.wb.active_sheet();
-    ed.insert_ref(&text);
-    ed.point_cell = Some(to);
-    ed.point_anchor = Some((sheet, anchor));
-    app.grid.ensure_visible = true;
-}
-
-/// The dropdown arrow beside a cell with an in-cell list validation.
-pub fn validation_arrow(sh: &Sheet, geo: &Geo, c: CellRef) -> Option<Rect> {
-    let dv = sh.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(c)))?;
-    if dv.kind != gridcraft_engine::model::ValidationKind::List || !dv.in_cell_dropdown || geo.hidden_under_frozen(sh, c) {
-        return None;
-    }
-    let r = geo.cell_rect(sh, c);
-    let s = r.height().clamp(14.0, 22.0);
-    Some(Rect::from_min_size(pos2(r.right() + 1.0, r.bottom() - s), vec2(s, s)))
-}
-
-#[allow(clippy::too_many_arguments)]
-/// Paints the validation arrow and input message, notes, the hyperlink tooltip and trace precedent/dependent arrows.
-pub(crate) fn paint_overlays(
-    app: &mut SheetApp,
-    ui: &egui::Ui,
-    p: &Painter,
-    geo: &Geo,
-    wb: &Workbook,
-    si: usize,
-    sh: &Sheet,
-    sel: &gridcraft_engine::Selection,
-) {
-    // Validation dropdown arrow for the active cell.
-    if app.editor.is_none()
-        && let Some(r) = validation_arrow(sh, geo, sel.active)
-    {
-        let t = Tokens::get(p.ctx());
-        p.rect_filled(r, 2.0, t.sheet_control_bg);
-        p.rect_stroke(r, 2.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Inside);
-        crate::icons::paint_on_sheet(p, r.shrink(3.0), crate::icons::Icon::Chevron, t.sheet_control_text);
-    }
-    // Input message of the active cell's validation, hidden while its list is open: it would cover the items.
-    if app.editor.is_none()
-        && app.grid.list_picker != Some(sel.active)
-        && let Some(dv) = sh.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(sel.active)))
-        && dv.show_input
-        && !(dv.input_title.is_empty() && dv.input_message.is_empty())
-        && !geo.hidden_under_frozen(sh, sel.active)
-    {
-        let r = geo.cell_rect(sh, sel.active);
-        let (at, pivot) = (geo.mirror_pos(pos2(r.left() + 8.0, r.bottom() + 6.0)), if geo.rtl { Align2::RIGHT_TOP } else { Align2::LEFT_TOP });
-        egui::Area::new(egui::Id::unique("dv_input")).fixed_pos(at).pivot(pivot).order(egui::Order::Tooltip).interactable(false).show(
-            ui.ctx(),
-            |ui| {
-                egui::Frame::popup(ui.style()).fill(Color32::from_rgb(0xFF, 0xFF, 0xE1)).show(ui, |ui| {
-                    ui.set_max_width(220.0);
-                    if !dv.input_title.is_empty() {
-                        ui.label(egui::RichText::new(&dv.input_title).strong().color(Color32::BLACK));
-                    }
-                    ui.label(egui::RichText::new(&dv.input_message).color(Color32::BLACK));
-                });
-            },
-        );
-    }
-    // Notes: shown on hover (or always when marked visible).
-    let hover = app.grid.hover_cell;
-    let all_notes = app.session.show_all_notes;
-    for (c, cm) in &sh.comments {
-        let show = cm.visible || (all_notes && !cm.threaded) || hover == Some(*c);
-        if !show || app.grid.drag != Drag::None {
-            continue;
-        }
-        let r = geo.cell_rect(sh, *c);
-        if !p.clip_rect().intersects(r) || geo.hidden_under_frozen(sh, *c) {
-            continue;
-        }
-        let at = pos2(r.right() + 10.0, r.top());
-        p.line_segment([r.right_top(), at + vec2(0.0, 6.0)], Stroke::new(1.0, Color32::from_gray(90)));
-        let (at, pivot) = (geo.mirror_pos(at), if geo.rtl { Align2::RIGHT_TOP } else { Align2::LEFT_TOP });
-        egui::Area::new(egui::Id::unique(("note", c.row, c.col))).fixed_pos(at).pivot(pivot).order(egui::Order::Tooltip).interactable(false).show(
-            ui.ctx(),
-            |ui| {
-                egui::Frame::popup(ui.style()).fill(if cm.threaded { Color32::WHITE } else { Color32::from_rgb(0xFF, 0xFF, 0xE1) }).show(ui, |ui| {
-                    ui.set_max_width(240.0);
-                    ui.label(egui::RichText::new(format!("{}:", cm.author)).strong().color(Color32::BLACK));
-                    ui.label(egui::RichText::new(&cm.text).color(Color32::BLACK));
-                    for (a, t) in &cm.replies {
-                        ui.separator();
-                        ui.label(egui::RichText::new(format!("{a}: {t}")).color(Color32::BLACK));
-                    }
-                });
-            },
-        );
-    }
-    // Hyperlink tooltip.
-    if let Some(h) = hover.and_then(|c| sh.hyperlinks.get(&c))
-        && app.editor.is_none()
-    {
-        let tip = h.tooltip.clone().unwrap_or_else(|| format!("{}\nClick once to follow. Click and hold to select this cell.", h.target));
-        egui::Tooltip::always_open(ui.ctx().clone(), ui.layer_id(), egui::Id::unique("link_tip"), egui::PopupAnchor::Pointer).show(|ui| {
-            ui.label(tip);
-        });
-    }
-    // Trace precedents / dependents arrows.
-    if let Some(trace) = &app.grid.trace
-        && app.session.active().is_some_and(|d| d.uid == trace.uid && d.revision == trace.revision)
-        && trace.sheet == si
-        && let Some(items) = trace.items.as_array()
-    {
-        let blue = Color32::from_rgb(0x1F, 0x5F, 0xC9);
-        let active = geo.cell_rect(sh, trace.cell).center();
-        for it in items {
-            if it["sheet"].as_str().is_some_and(|s| !s.eq_ignore_ascii_case(&sh.name)) {
-                continue;
-            }
-            let target = it["range"].as_str().or(it["cell"].as_str()).and_then(RangeRef::parse);
-            let Some(t) = target else { continue };
-            let tr = geo.range_rect(sh, t);
-            if !t.is_single() {
-                for pane in geo.range_panes(t) {
-                    p.with_clip_rect(pane.intersect(p.clip_rect())).rect_stroke(tr, 0.0, Stroke::new(1.5, blue), StrokeKind::Inside);
-                }
-            }
-            let (from, to) = if it.get("range").is_some() { (tr.center(), active) } else { (active, tr.center()) };
-            p.line_segment([from, to], Stroke::new(1.5, blue));
-            p.circle_filled(from, 3.0, blue);
-            let d = (to - from).normalized();
-            let n = vec2(-d.y, d.x);
-            p.add(egui::Shape::convex_polygon(vec![to, to - d * 9.0 + n * 4.0, to - d * 9.0 - n * 4.0], blue, Stroke::NONE));
-        }
-    }
-    let _ = (wb, si);
-}
-
-/// Rows the list-validation dropdown shows before it scrolls (Excel shows 8).
-const LIST_PICKER_MAX_ROWS: usize = 8;
-const LIST_PICKER_ROW_H: f32 = 18.0;
-/// Popup frame around the rows: 2 px inner margin and the window stroke on each side, rounded up.
-const LIST_PICKER_CHROME: f32 = 8.0;
-
-/// Popup height for `n` items: every item up to `LIST_PICKER_MAX_ROWS`, then a scrollbar.
-fn list_picker_height(n: usize, row_h: f32, gap: f32) -> f32 {
-    let rows = n.clamp(1, LIST_PICKER_MAX_ROWS) as f32;
-    rows * row_h + (rows - 1.0) * gap
-}
-
-/// Draws the validation list popup, choosing above/below and left/right placement for RTL, and applies the clicked item with `cell.set`.
-fn list_picker(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_open: bool) {
-    let Some(c) = app.grid.list_picker else { return };
-    let Some(d) = app.session.active() else { return };
-    let wb = d.wb.clone();
-    let si = wb.active_sheet();
-    let Some(sh) = wb.sheet(si) else { return };
-    let Some(dv) = sh.validations.iter().find(|x| x.ranges.iter().any(|r| r.contains(c))).cloned() else {
-        app.grid.list_picker = None;
-        return;
-    };
-    let items = gridcraft_engine::cmd::data::list_items(&wb, si, &dv);
-    let r = geo.cell_rect(sh, c);
-    // Fit the popup to its rows (up to LIST_PICKER_MAX_ROWS); without a minimum the scroll area collapses to its 64 px default.
-    let height = list_picker_height(items.len(), LIST_PICKER_ROW_H, ui.spacing().item_spacing.y);
-    // Open below the cell, or above it when the rows would run past the bottom of the window (as Excel does).
-    let screen = ui.ctx().content_rect();
-    let above = r.bottom() + height + LIST_PICKER_CHROME > screen.bottom() && r.top() - height - LIST_PICKER_CHROME >= screen.top();
-    let (at, pivot) = match (above, geo.rtl) {
-        (false, false) => (geo.mirror_pos(r.left_bottom()), Align2::LEFT_TOP),
-        (false, true) => (geo.mirror_pos(r.left_bottom()), Align2::RIGHT_TOP),
-        (true, false) => (geo.mirror_pos(r.left_top()), Align2::LEFT_BOTTOM),
-        (true, true) => (geo.mirror_pos(r.left_top()), Align2::RIGHT_BOTTOM),
-    };
-    let mut close = false;
-    let response = egui::Area::new(egui::Id::unique("dv_list")).fixed_pos(at).pivot(pivot).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).inner_margin(2.0).show(ui, |ui| {
-            ui.set_min_width(r.width().max(100.0));
-            egui::ScrollArea::vertical().max_height(height).min_scrolled_height(height).show(ui, |ui| {
-                for it in &items {
-                    if ui
-                        .add(egui::Button::new(it.as_str()).frame_when_inactive(false).min_size(vec2(r.width().max(100.0), LIST_PICKER_ROW_H)))
-                        .clicked()
-                    {
-                        app.run_or_alert("cell.set", json!({"cell": c.a1(), "input": it}));
-                        close = true;
-                    }
-                }
-            });
-        });
-    });
-    if close || popup_dismissed(&response.response, was_open) {
-        app.grid.list_picker = None;
-    }
-}
-
-/// Draws row/column header context menus with insert/delete, format, size, hide/unhide and group actions, plus Insert Copied Cells when available.
-fn header_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) {
-    let Some((at, rows)) = app.grid.header_menu else { return };
-    let mut close = false;
-    let response = egui::Area::new(egui::Id::unique("header_menu")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_min_width(190.0);
-            let insert_copied = insert_copied_item(app);
-            let mut items: Vec<(&str, &str)> = if rows {
-                vec![
-                    ("Cut", "edit.cut"),
-                    ("Copy", "edit.copy"),
-                    ("Paste", "edit.paste"),
-                    ("-", ""),
-                    ("Insert", "home.insertRows"),
-                    ("Delete", "home.deleteRows"),
-                    ("Clear Contents", "edit.clearContents"),
-                    ("-", ""),
-                    ("Format Cells…", "ui:formatCells"),
-                    ("Row Height…", "ui:rowHeight"),
-                    ("AutoFit Row Height", "home.autofitRowHeight"),
-                    ("Hide", "home.hideRows"),
-                    ("Unhide", "home.unhideRows"),
-                    ("Group", "data.group"),
-                ]
-            } else {
-                vec![
-                    ("Cut", "edit.cut"),
-                    ("Copy", "edit.copy"),
-                    ("Paste", "edit.paste"),
-                    ("-", ""),
-                    ("Insert", "home.insertColumns"),
-                    ("Delete", "home.deleteColumns"),
-                    ("Clear Contents", "edit.clearContents"),
-                    ("-", ""),
-                    ("Format Cells…", "ui:formatCells"),
-                    ("Column Width…", "ui:columnWidth"),
-                    ("AutoFit Column Width", "home.autofitColumnWidth"),
-                    ("Hide", "home.hideColumns"),
-                    ("Unhide", "home.unhideColumns"),
-                    ("Sort A to Z", "data.sortAscending"),
-                    ("Group", "data.group"),
-                ]
-            };
-            if let Some(item) = insert_copied {
-                items.insert(5, item);
-            }
-            let lang = crate::i18n::current(ui.ctx());
-            for (label, id) in items {
-                if label == "-" {
-                    ui.separator();
-                    continue;
-                }
-                if ui.add(egui::Button::new(lang.tr(label)).frame_when_inactive(false).min_size(vec2(180.0, 20.0))).clicked() {
-                    close = true;
-                    match id {
-                        "ui:insertPaste" => app.open_dialog("insertPaste", json!({})),
-                        "ui:rowHeight" => app.open_dialog("rowHeight", json!({})),
-                        "ui:formatCells" => app.open_dialog("formatCells", json!({})),
-                        "ui:columnWidth" => app.open_dialog("columnWidth", json!({})),
-                        "edit.copy" | "edit.cut" => {
-                            app.copy_to_clipboard(ui.ctx(), id);
-                        }
-                        "edit.paste" => app.paste_from_clipboard(),
-                        other => app.run_or_alert(other, json!({})),
-                    }
-                }
-            }
-        });
-    });
-    if close || popup_dismissed(&response.response, was_open) {
-        app.grid.header_menu = None;
-    }
-}
-
-/// The context-menu entry for Insert Copied Cells / Insert Cut Cells, when the clipboard holds a
-/// copy or cut of this app: whole rows or columns insert at once, a block asks which way to shift
-/// (Insert Paste). A cut block can only be pasted, so it gets no entry.
-fn insert_copied_item(app: &SheetApp) -> Option<(&'static str, &'static str)> {
-    let clip = app.session.clipboard.as_ref()?;
-    let lines = clip.selected.is_full_rows() != clip.selected.is_full_cols();
-    let cut = clip.cut && app.session.active().is_some_and(|d| d.uid == clip.doc_uid);
-    match (cut, lines) {
-        (true, true) => Some(("Insert Cut Cells", "home.insertCopiedCells")),
-        (true, false) => None,
-        (false, true) => Some(("Insert Copied Cells", "home.insertCopiedCells")),
-        (false, false) => Some(("Insert Copied Cells…", "ui:insertPaste")),
-    }
-}
-
-fn is_checkbox(sh: &Sheet, app: &SheetApp) -> bool {
-    let Some(d) = app.session.active() else { return false };
-    d.wb.styles.get(sh.style_id(d.selection.active)).num_fmt.as_str() == "checkbox"
-}
-
-fn paint_pages(app: &mut SheetApp, p: &Painter, geo: &Geo, sh: &Sheet) {
-    let Some(d) = app.session.active() else { return };
-    let key = (d.uid, d.revision, d.wb.active_sheet());
-    if app.grid.pages.as_ref().is_none_or(|(k, _)| *k != key) {
-        let pages: Vec<(RangeRef, u32)> = app
-            .session
-            .run("file.printPreview", json!({}))
-            .ok()
-            .and_then(|v| {
-                v["pageList"].as_array().map(|a| {
-                    a.iter()
-                        .filter(|pg| pg["sheet"].as_str() == Some(sh.name.as_str()))
-                        .filter_map(|pg| Some((RangeRef::parse(pg["range"].as_str()?)?, pg["page"].as_u64()? as u32)))
-                        .collect()
-                })
-            })
-            .unwrap_or_default();
-        app.grid.pages = Some((key, pages));
-    }
-    let Some((_, pages)) = &app.grid.pages else { return };
-    if pages.is_empty() {
-        return;
-    }
-    // Grey everything, then clear the printed pages.
-    let mut printed = pages[0].0;
-    for (r, _) in pages {
-        printed = printed.union(r);
-    }
-    let pr = geo.range_rect(sh, printed);
-    let grey = Color32::from_black_alpha(70);
-    let c = p.clip_rect();
-    for r in [
-        Rect::from_min_max(c.min, pos2(c.right(), pr.top())),
-        Rect::from_min_max(pos2(c.left(), pr.bottom()), c.max),
-        Rect::from_min_max(pos2(c.left(), pr.top()), pos2(pr.left(), pr.bottom())),
-        Rect::from_min_max(pos2(pr.right(), pr.top()), pos2(c.right(), pr.bottom())),
-    ] {
-        if r.is_positive() {
-            p.rect_filled(r, 0.0, grey);
-        }
-    }
-    let blue = Color32::from_rgb(0x2E, 0x6F, 0xD8);
-    for (r, n) in pages {
-        let rr = geo.range_rect(sh, *r);
-        if !rr.intersects(c) {
-            continue;
-        }
-        p.extend(egui::Shape::dashed_line(
-            &[rr.left_top(), rr.right_top(), rr.right_bottom(), rr.left_bottom(), rr.left_top()],
-            Stroke::new(2.0, blue),
-            6.0,
-            3.0,
-        ));
-        p.text(
-            rr.center(),
-            Align2::CENTER_CENTER,
-            format!("Page {n}"),
-            theme::ui_bold((rr.height().min(rr.width()) / 6.0).clamp(14.0, 72.0)),
-            Color32::from_black_alpha(45),
-        );
-    }
-    p.rect_stroke(pr, 0.0, Stroke::new(3.0, blue), StrokeKind::Outside);
-}
-
-#[cfg(test)]
-mod selection_fill_tests {
-    use super::*;
-
-    #[test]
-    fn rect_around_leaves_the_hole_and_never_overlaps() {
-        let area = Rect::from_min_max(pos2(100.0, 50.0), pos2(400.0, 250.0));
-        let check = |hole: Rect, pieces: usize| {
-            let parts: Vec<Rect> = rect_around(area, hole).collect();
-            assert_eq!(parts.len(), pieces, "{hole:?}: {parts:?}");
-            let cut = area.intersect(hole);
-            let cut_area = if cut.is_positive() { cut.area() } else { 0.0 };
-            let shaded: f32 = parts.iter().map(Rect::area).sum();
-            assert!((shaded - (area.area() - cut_area)).abs() < 0.5, "everything but the hole is shaded: {hole:?}");
-            for (i, a) in parts.iter().enumerate() {
-                assert!(area.contains_rect(*a), "nothing outside the area: {a:?}");
-                assert!(!a.shrink(0.01).intersects(hole), "the hole stays clear: {a:?} vs {hole:?}");
-                // The fill is translucent: a part shaded twice would show darker.
-                assert!(parts.iter().skip(i + 1).all(|b| !a.shrink(0.01).intersects(*b)), "{parts:?}");
-            }
-        };
-        let cell = |x: f32, y: f32| Rect::from_min_size(pos2(x, y), vec2(64.0, 16.0));
-        // In the middle, in each corner (where a drag began), along an edge.
-        check(cell(200.0, 100.0), 4);
-        check(cell(100.0, 50.0), 2);
-        check(cell(336.0, 50.0), 2);
-        check(cell(100.0, 234.0), 2);
-        check(cell(336.0, 234.0), 2);
-        check(cell(100.0, 100.0), 3);
-        // A merged cell as wide, or as tall, as the area; one that is all of it, or more.
-        check(Rect::from_min_max(pos2(100.0, 100.0), pos2(400.0, 132.0)), 2);
-        check(Rect::from_min_max(pos2(200.0, 50.0), pos2(264.0, 250.0)), 2);
-        check(area, 0);
-        check(area.expand(30.0), 0);
-        // The active cell is in another area, touches this one, or is only partly inside it.
-        check(cell(500.0, 300.0), 1);
-        check(cell(400.0, 50.0), 1);
-        check(cell(380.0, 240.0), 2);
-    }
-
-    #[test]
-    fn rect_around_survives_hostile_numbers() {
-        let sane = Rect::from_min_max(pos2(0.0, 0.0), pos2(64.0, 16.0));
-        let bad = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::MIN, -1.0, 0.0];
-        for a in bad {
-            for b in bad {
-                let weird = Rect::from_min_max(pos2(a, b), pos2(b, a));
-                for (area, hole) in [(sane, weird), (weird, sane), (weird, weird)] {
-                    for part in rect_around(area, hole) {
-                        assert!(part.is_positive() && part.is_finite(), "{area:?} around {hole:?}: {part:?}");
-                    }
-                }
-                // A hole that makes no sense leaves the whole area shaded.
-                if !weird.intersects(sane) {
-                    assert_eq!(rect_around(sane, weird).collect::<Vec<_>>(), vec![sane]);
-                }
-            }
-        }
-    }
-}
-
-/// The horizontal alignment to paint with. Cells are painted left to right and a right-to-left
-/// sheet is mirrored afterwards, so an explicit Left or Right is swapped first to end up on the
-/// side the user chose: Align Right stays on the right in either sheet direction, as in Excel.
-/// General alignment is resolved from the value before this and follows the sheet direction.
-fn painted_halign(h: HAlign, rtl: bool) -> HAlign {
-    match h {
-        HAlign::Left if rtl => HAlign::Right,
-        HAlign::Right if rtl => HAlign::Left,
-        h => h,
-    }
-}
-
 /// Row and column heading labels grow with the zoom as the cells do, as in Excel (at 400% the
 /// labels are four times their 100% size), and never get smaller than a readable 8.5 points.
 pub(crate) fn heading_font_size(zoom: f32) -> f32 {
@@ -4202,288 +277,3 @@ pub(crate) fn heading_font_size(zoom: f32) -> f32 {
 
 #[cfg(test)]
 mod tests;
-
-#[cfg(test)]
-mod pane_tests {
-    use super::*;
-
-    fn rng(r0: u32, c0: u32, r1: u32, c1: u32) -> RangeRef {
-        RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1))
-    }
-
-    #[test]
-    fn selection_in_scrolling_pane_is_not_drawn_in_frozen_pane() {
-        // Frozen: 2 rows and 2 columns; the scrolling pane shows rows 2..=20 and columns 2..=10.
-        let frozen_cols = ((2, 20), (0, 1));
-        let frozen_rows = ((0, 1), (2, 10));
-        let corner = ((0, 1), (0, 1));
-        let scrolled = ((2, 20), (2, 10));
-        let sel = rng(5, 4, 7, 6);
-        assert!(range_in_pane(sel, scrolled.0, scrolled.1));
-        assert!(!range_in_pane(sel, frozen_cols.0, frozen_cols.1));
-        assert!(!range_in_pane(sel, frozen_rows.0, frozen_rows.1));
-        assert!(!range_in_pane(sel, corner.0, corner.1));
-    }
-
-    #[test]
-    fn ctrl_click_on_a_selected_header_deselects_it() {
-        let s = |v: &[&str]| v.iter().map(|x| x.to_string()).collect::<Vec<_>>();
-        assert_eq!(toggled_ranges(s(&["A:A", "C:C"]), "C:C".into(), true), s(&["A:A"]));
-        assert_eq!(toggled_ranges(s(&["A:A"]), "C:C".into(), true), s(&["A:A", "C:C"]));
-        assert_eq!(toggled_ranges(s(&["A:A"]), "A:A".into(), true), s(&["A:A"]));
-        assert_eq!(toggled_ranges(s(&["A1", "B2", "3:3"]), "B2".into(), true), s(&["A1", "3:3"]));
-        assert_eq!(toggled_ranges(s(&["A:A", "C:C"]), "C:C".into(), false), s(&["C:C"]));
-    }
-
-    #[test]
-    fn selection_across_the_freeze_line_is_drawn_in_both_panes() {
-        let sel = rng(5, 0, 7, 6);
-        assert!(range_in_pane(sel, (2, 20), (0, 1)));
-        assert!(range_in_pane(sel, (2, 20), (2, 10)));
-    }
-
-    #[test]
-    fn hidden_outline_symbols_take_no_room() {
-        let rect = Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0));
-        let mut sh = Sheet::new("S");
-        sh.rows.entry(3).or_default().outline = 1;
-        sh.cols.entry(2).or_default().outline = 2;
-        let shown = Geo::new(&sh, rect, vec2(0.0, 0.0));
-        assert!(shown.band_w > 0.0 && shown.band_h > 0.0);
-        sh.show_outline_symbols = false;
-        let hidden = Geo::new(&sh, rect, vec2(0.0, 0.0));
-        assert_eq!((hidden.band_w, hidden.band_h), (0.0, 0.0));
-        assert!(hidden.cells.left() < shown.cells.left() && hidden.cells.top() < shown.cells.top());
-        // Without headings too.
-        sh.show_headings = false;
-        let bare = Geo::new(&sh, rect, vec2(0.0, 0.0));
-        assert_eq!((bare.band_w, bare.band_h), (0.0, 0.0));
-        // No button answers a click on the empty bands' edges (the grid's left and top), where the
-        // level buttons would sit with no headings to hold them.
-        for geo in [&hidden, &bare] {
-            for i in 0..400 {
-                let t = i as f32 * 0.5;
-                for p in [pos2(geo.rect.left(), geo.rect.top() + t), pos2(geo.rect.left() + t, geo.rect.top())] {
-                    assert_eq!(crate::outline::hit(geo, &sh, p), None, "{p:?}");
-                }
-            }
-        }
-    }
-
-    /// Two frozen rows and columns, scrolled right so that columns C:E lie under the frozen columns.
-    fn frozen_geo(sh: &mut Sheet) -> Geo {
-        sh.freeze = Some((2, 2));
-        let scroll = vec2(3.0 * sh.default_col_width + 8.0, 0.0);
-        Geo::new(sh, Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0)), scroll)
-    }
-
-    #[test]
-    fn the_edge_just_past_a_hidden_line_unhides_it() {
-        let mut sh = Sheet::new("S");
-        sh.cols.entry(11).or_default().hidden = true; // L
-        sh.rows.entry(26).or_default().hidden = true; // 27
-        let geo = Geo::new(&sh, Rect::from_min_size(pos2(0.0, 0.0), vec2(2000.0, 1200.0)), vec2(0.0, 0.0));
-        let x = geo.x(&sh, 12); // between K and M
-        assert_eq!(hidden_col_edge(&geo, &sh, x + 2.0), Some(11));
-        assert_eq!(hidden_col_edge(&geo, &sh, x - 2.0), None); // K's own edge
-        assert_eq!(hidden_col_edge(&geo, &sh, geo.x(&sh, 5)), None);
-        let y = geo.y(&sh, 27); // between 26 and 28
-        assert_eq!(hidden_row_edge(&geo, &sh, y + 2.0), Some(26));
-        assert_eq!(hidden_row_edge(&geo, &sh, y - 2.0), None);
-    }
-
-    #[test]
-    fn headers_mark_the_edges_next_to_hidden_lines() {
-        let mut sh = Sheet::new("S");
-        sh.cols.entry(0).or_default().hidden = true; // A
-        sh.cols.entry(11).or_default().hidden = true; // L
-        sh.rows.entry(26).or_default().hidden = true; // 27
-        let col = |c| hidden_around(c, |i| sh.col_width(i));
-        assert_eq!(col(1), (true, false)); // B, after hidden A
-        assert_eq!(col(10), (false, true)); // K
-        assert_eq!(col(12), (true, false)); // M
-        assert_eq!(col(5), (false, false));
-        let row = |r| hidden_around(r, |i| sh.row_height(i));
-        assert_eq!(row(25), (false, true));
-        assert_eq!(row(27), (true, false));
-        assert_eq!(row(0), (false, false));
-    }
-
-    #[test]
-    fn overlays_skip_cells_scrolled_under_the_frozen_columns() {
-        let mut sh = Sheet::new("S");
-        let geo = frozen_geo(&mut sh);
-        assert!(geo.hidden_under_frozen(&sh, CellRef::new(5, 2)));
-        assert!(geo.hidden_under_frozen(&sh, CellRef::new(5, 4)));
-        assert!(!geo.hidden_under_frozen(&sh, CellRef::new(5, 5)));
-        assert!(!geo.hidden_under_frozen(&sh, CellRef::new(5, 0)));
-        let unscrolled = Geo::new(&sh, geo.rect, vec2(0.0, 0.0));
-        assert!(!unscrolled.hidden_under_frozen(&sh, CellRef::new(5, 2)));
-    }
-
-    #[test]
-    fn ranges_are_clipped_to_the_panes_that_hold_them() {
-        let mut sh = Sheet::new("S");
-        let geo = frozen_geo(&mut sh);
-        let split = pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h);
-        assert_eq!(geo.range_panes(rng(5, 3, 7, 6)), [Rect::from_min_max(split, geo.cells.max)]);
-        assert_eq!(geo.range_panes(rng(5, 0, 7, 6)).len(), 2);
-        assert_eq!(geo.range_panes(rng(0, 0, 7, 6)).len(), 4);
-        assert_eq!(geo.range_panes(rng(0, 0, 1, 1)), [Rect::from_min_max(geo.cells.min, split)]);
-        // The fill handle of D6:E7 sits over the frozen columns, where nothing of it is shown.
-        let handle = geo.range_rect(&sh, rng(5, 3, 6, 4)).right_bottom();
-        assert!(handle.x < split.x);
-        assert!(!geo.range_panes(rng(6, 4, 6, 4)).iter().any(|r| r.contains(handle)));
-    }
-}
-
-#[cfg(test)]
-mod outline_band_tests {
-    use super::*;
-
-    #[test]
-    fn whole_column_outline_keeps_left_and_right_sides_near_viewport() {
-        let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(800.0, 600.0));
-        let col = Rect::from_min_max(pos2(100.0, 40.0), pos2(180.0, 20_971_540.0));
-        let sides = outline_bands(col, 2.0, clip);
-        // Left, right and top (in view); the bottom is 20 million points away.
-        assert_eq!(sides.len(), 3);
-        assert!(sides.iter().all(|s| s.bottom() <= clip.bottom() + 4.0 + f32::EPSILON));
-        assert!(sides.iter().any(|s| s.left() < 100.0 && s.right() > 100.0 && s.height() > 500.0));
-        assert!(sides.iter().any(|s| s.left() < 180.0 && s.right() > 180.0 && s.height() > 500.0));
-    }
-
-    #[test]
-    fn outline_outside_the_view_and_non_finite_draw_nothing() {
-        let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(800.0, 600.0));
-        assert!(outline_bands(Rect::from_min_max(pos2(900.0, 0.0), pos2(950.0, 20.0)), 2.0, clip).is_empty());
-        assert!(outline_bands(Rect::from_min_max(pos2(f32::NAN, 0.0), pos2(1.0, 1.0)), 2.0, clip).is_empty());
-    }
-}
-
-#[cfg(test)]
-mod trace_arrow_tests {
-    use super::*;
-
-    fn app() -> SheetApp {
-        let mut s = gridcraft_engine::Session::new();
-        s.new_workbook();
-        SheetApp::new(s, Default::default())
-    }
-
-    fn select(app: &mut SheetApp, cell: &str) {
-        app.run("selection.set", json!({"cell": cell})).unwrap();
-    }
-
-    /// What the ribbon's Trace Precedents / Trace Dependents buttons do.
-    fn trace(app: &mut SheetApp, id: &str) {
-        let r = app.run(id, json!({})).unwrap();
-        app.grid.trace = Trace::new(app, r);
-    }
-
-    /// The arrows `paint_overlays` draws on the active sheet, as (tail, head) points.
-    fn arrows(app: &mut SheetApp) -> (Geo, Vec<(Pos2, Pos2)>) {
-        let d = app.session.active().unwrap();
-        let (wb, si, sel) = (d.wb.clone(), d.wb.active_sheet(), d.selection.clone());
-        let sh = wb.sheet(si).unwrap();
-        let geo = Geo::new(sh, Rect::from_min_size(pos2(0.0, 0.0), vec2(1200.0, 800.0)), vec2(0.0, 0.0));
-        let ctx = egui::Context::default();
-        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
-            let p = ui.painter().clone();
-            paint_overlays(app, ui, &p, &geo, &wb, si, sh, &sel);
-        });
-        // No renderer consumes the font atlas upload here.
-        out.textures_delta.clear();
-        let blue = Color32::from_rgb(0x1F, 0x5F, 0xC9);
-        let mut lines = Vec::new();
-        for s in out.shapes {
-            if let egui::Shape::LineSegment { points, stroke } = s.shape
-                && stroke.color == blue
-            {
-                lines.push((points[0], points[1]));
-            }
-        }
-        (geo, lines)
-    }
-
-    fn center(app: &SheetApp, geo: &Geo, cell: &str) -> Pos2 {
-        let d = app.session.active().unwrap();
-        let sh = d.wb.sheet(d.wb.active_sheet()).unwrap();
-        geo.cell_rect(sh, CellRef::parse(cell).unwrap()).center()
-    }
-
-    #[test]
-    fn precedent_arrows_stay_on_the_traced_cell_when_the_selection_moves() {
-        let mut app = app();
-        for (c, v) in [("B2", "1"), ("B3", "2"), ("D2", "1"), ("D3", "2"), ("F7", "=B2+B3+SUM(D2:D3)")] {
-            app.run("cell.set", json!({"cell": c, "input": v})).unwrap();
-        }
-        select(&mut app, "F7");
-        trace(&mut app, "formulas.tracePrecedents");
-        select(&mut app, "H7");
-        let (geo, lines) = arrows(&mut app);
-        assert_eq!(lines.len(), 3, "B2, B3 and D2:D3: {lines:?}");
-        let f7 = center(&app, &geo, "F7");
-        assert!(lines.iter().all(|&(_, head)| head == f7), "every arrow points at F7, not at the active H7: {lines:?}");
-    }
-
-    #[test]
-    fn dependent_arrows_stay_on_the_traced_cell_when_the_selection_moves() {
-        let mut app = app();
-        for (c, v) in [("B2", "1"), ("D4", "=B2*2"), ("E6", "=B2+1")] {
-            app.run("cell.set", json!({"cell": c, "input": v})).unwrap();
-        }
-        select(&mut app, "B2");
-        trace(&mut app, "formulas.traceDependents");
-        select(&mut app, "C9");
-        let (geo, lines) = arrows(&mut app);
-        assert_eq!(lines.len(), 2, "D4 and E6: {lines:?}");
-        let b2 = center(&app, &geo, "B2");
-        assert!(lines.iter().all(|&(tail, _)| tail == b2), "every arrow starts at B2, not at the active C9: {lines:?}");
-    }
-
-    #[test]
-    fn arrows_stay_on_the_sheet_of_the_traced_cell() {
-        let mut app = app();
-        app.run("home.insertSheet", json!({"name": "Two"})).unwrap();
-        app.run("cell.set", json!({"sheet": "Sheet1", "cell": "B2", "input": "1"})).unwrap();
-        app.run("sheet.activate", json!({"sheet": "Two"})).unwrap();
-        app.run("cell.set", json!({"cell": "F7", "input": "=Sheet1!B2"})).unwrap();
-        select(&mut app, "F7");
-        trace(&mut app, "formulas.tracePrecedents");
-        // The precedent lives on Sheet1, but the arrow belongs to Two's F7.
-        app.run("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-        assert!(arrows(&mut app).1.is_empty(), "no arrow on Sheet1 from B2 to where F7 would be");
-    }
-
-    #[test]
-    fn inserting_a_row_removes_the_arrows() {
-        let mut app = app();
-        app.run("cell.set", json!({"cell": "B2", "input": "1"})).unwrap();
-        app.run("cell.set", json!({"cell": "F7", "input": "=B2"})).unwrap();
-        select(&mut app, "F7");
-        trace(&mut app, "formulas.tracePrecedents");
-        assert_eq!(arrows(&mut app).1.len(), 1);
-        app.run("home.insertRows", json!({"rows": "4"})).unwrap();
-        assert!(arrows(&mut app).1.is_empty(), "F7 is now F8: the old arrows would point at the wrong cell");
-    }
-
-    #[test]
-    fn arrows_stay_in_their_workbook() {
-        let mut app = app();
-        app.session.new_workbook();
-        // Two books with the same cells and the same revision: only the document tells them apart.
-        for book in [1, 0] {
-            app.session.set_active(book);
-            app.run("cell.set", json!({"cell": "B2", "input": "1"})).unwrap();
-            app.run("cell.set", json!({"cell": "F7", "input": "=B2"})).unwrap();
-        }
-        select(&mut app, "F7");
-        trace(&mut app, "formulas.tracePrecedents");
-        assert_eq!(arrows(&mut app).1.len(), 1);
-        app.session.set_active(1);
-        let revisions: Vec<u64> = app.session.documents().iter().map(|d| d.revision).collect();
-        assert_eq!(revisions[0], revisions[1]);
-        assert!(arrows(&mut app).1.is_empty(), "Book1's arrows are not drawn on Book2");
-    }
-}
diff --git a/crates/ui-egui/src/grid/cell_paint.rs b/crates/ui-egui/src/grid/cell_paint.rs
new file mode 100644
index 000000000..99ff2320e
--- /dev/null
+++ b/crates/ui-egui/src/grid/cell_paint.rs
@@ -0,0 +1,310 @@
+use super::geo::Geo;
+use super::*;
+
+/// Resolved look of a cell for painting.
+pub(super) struct Look {
+    pub(super) style: Style,
+    pub(super) fill: Option<Color32>,
+    pub(super) text_color: Color32,
+}
+
+pub(super) fn col32(c: Color, wb: &Workbook, default: Color32) -> Color32 {
+    c.resolve(&wb.theme).map(theme::color32).unwrap_or(default)
+}
+
+pub(super) fn numfmt_color(c: gridcraft_engine::numfmt::FormatColor) -> Color32 {
+    c.rgb().map(|[r, g, b]| Color32::from_rgb(r, g, b)).unwrap_or(Color32::BLACK)
+}
+
+/// Last column of a Center Across Selection run starting at `start`: it extends over following columns (up to `limit`) while `continues` holds.
+pub(super) fn center_across_end(start: u32, limit: u32, continues: impl Fn(u32) -> bool) -> u32 {
+    let mut end = start;
+    while end < limit && end + 1 < MAX_COLS && continues(end + 1) {
+        end += 1;
+    }
+    end
+}
+
+pub(super) fn look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut CfCache) -> (Look, Option<CfLook>) {
+    let mut style = wb.styles.get(sh.style_id(c)).clone();
+    if let Some(t) = sh.table_at(c) {
+        style = gridcraft_engine::tables::table_cell_style(wb, si, t, c);
+    }
+    let cfl = cf.look(wb, si, c);
+    if let Some(l) = &cfl
+        && let Some(st) = &l.style
+    {
+        if st.fill.pattern != PatternType::None {
+            style.fill = st.fill;
+        }
+        if st.font.color != Color::Auto {
+            style.font.color = st.font.color;
+        }
+        if st.font.bold {
+            style.font.bold = true;
+        }
+        if st.font.italic {
+            style.font.italic = true;
+        }
+        if st.font.underline != Underline::None {
+            style.font.underline = st.font.underline;
+        }
+        if st.font.strike {
+            style.font.strike = true;
+        }
+        // In a differential style General means "not set" (#1163).
+        if st.num_fmt.as_str() != "General" {
+            style.num_fmt = st.num_fmt.clone();
+        }
+        for (dst, src) in [
+            (&mut style.borders.left, st.borders.left),
+            (&mut style.borders.right, st.borders.right),
+            (&mut style.borders.top, st.borders.top),
+            (&mut style.borders.bottom, st.borders.bottom),
+        ] {
+            if !src.is_none() {
+                *dst = src;
+            }
+        }
+    }
+    let mut fill = match style.fill.pattern {
+        PatternType::None => None,
+        PatternType::Solid => style.fill.fg.resolve(&wb.theme).map(theme::color32),
+        _ => {
+            // Patterns: approximate with a blend of foreground and background.
+            let fg = style.fill.fg.resolve(&wb.theme).unwrap_or([0, 0, 0]);
+            let bg = style.fill.bg.resolve(&wb.theme).unwrap_or([255, 255, 255]);
+            Some(Color32::from_rgb(
+                ((fg[0] as u16 + bg[0] as u16 * 3) / 4) as u8,
+                ((fg[1] as u16 + bg[1] as u16 * 3) / 4) as u8,
+                ((fg[2] as u16 + bg[2] as u16 * 3) / 4) as u8,
+            ))
+        }
+    };
+    if let Some(l) = &cfl
+        && let Some(rgb) = l.scale_fill
+    {
+        fill = Some(theme::color32(rgb));
+    }
+    let text_color = col32(style.font.color, wb, Color32::BLACK);
+    (Look { style, fill, text_color }, cfl)
+}
+
+/// Text for a value with General narrowing to the available width.
+pub(super) fn display_text(
+    wb: &Workbook,
+    sh: &Sheet,
+    c: CellRef,
+    v: &Value,
+    st: &Style,
+    width_px: f32,
+    char_w: f32,
+) -> (String, Option<Color32>, bool, Option<(char, usize)>) {
+    if sh.show_formulas
+        && let Some(f) = sh.cell(c).and_then(|x| x.formula.as_ref())
+    {
+        return (format!("={}", f.text), None, false, None);
+    }
+    if !sh.show_zeros && v.as_f64() == Some(0.0) {
+        return (String::new(), None, false, None);
+    }
+    let code = st.num_fmt.as_str();
+    // A checkbox cell draws TRUE/FALSE (and empty) as a box; other values show as General.
+    if code == "checkbox" && matches!(v, Value::Bool(_) | Value::Empty) {
+        return (String::new(), None, false, None);
+    }
+    if code == "General"
+        && let Value::Number(n) = v
+    {
+        let max_chars = ((width_px - 4.0) / char_w).floor().max(1.0) as usize;
+        return match gridcraft_engine::numfmt::format_general_fit(*n, max_chars.min(11)) {
+            Some(t) => (t, None, true, None),
+            None => ("#".repeat(max_chars.max(1)), None, true, None),
+        };
+    }
+    let f = gridcraft_engine::display::format(v, code, wb);
+    (f.text, f.color.map(numfmt_color), f.numeric, f.fill)
+}
+
+pub(crate) fn wrapped_cell_text_y(valign: VAlign, rect: Rect, gh: f32, z: f32) -> f32 {
+    let pad_v = 1.5 * z;
+    let y_top = rect.top() + pad_v;
+    // Not clamped to `y_top`: text taller than the row overflows upward (Bottom) or both ways
+    // (Center), and the cell's clip rect trims it, so Middle and Bottom stay distinct from Top.
+    let y_bottom = rect.bottom() - gh - pad_v;
+    match valign {
+        VAlign::Top => y_top,
+        VAlign::Center | VAlign::Justify | VAlign::Distributed => (y_top + y_bottom) / 2.0,
+        VAlign::Bottom => y_bottom,
+    }
+}
+
+pub(crate) fn cell_text_y(valign: VAlign, rect: Rect, gh: f32, z: f32) -> f32 {
+    let top_inset = 1.0 * z;
+    let y_top = rect.top() - top_inset;
+    let y_bottom = (rect.bottom() - gh - 0.5 * z).max(y_top);
+    match valign {
+        VAlign::Top => y_top,
+        VAlign::Center | VAlign::Justify | VAlign::Distributed => (y_top + y_bottom) / 2.0,
+        VAlign::Bottom => y_bottom,
+    }
+}
+
+/// Where to put a `TextShape` holding a galley of `size` turned by `angle` (egui radians, so
+/// negative for upward text) for it to sit in `rect` per the cell's alignment. egui turns the
+/// galley about `pos`, its top-left corner, so the turned box is placed first and `pos` follows.
+/// General keeps the text at the left. Bottom (the default) puts upward text at the bottom, but
+/// downward text at the top, where it starts reading.
+pub(crate) fn rotated_text_pos(rect: Rect, size: egui::Vec2, angle: f32, h: HAlign, v: VAlign, pad: f32, indent: f32) -> Pos2 {
+    let rot = egui::emath::Rot2::from_angle(angle);
+    let turned = Rect::from_points(&[vec2(0.0, 0.0), vec2(size.x, 0.0), vec2(0.0, size.y), size].map(|c| (rot * c).to_pos2()));
+    let x = match h {
+        HAlign::Center | HAlign::CenterAcross | HAlign::Distributed => rect.center().x - turned.width() / 2.0,
+        HAlign::Right => rect.right() - pad - indent - turned.width(),
+        _ => rect.left() + pad + indent,
+    };
+    let y = match v {
+        VAlign::Center | VAlign::Justify | VAlign::Distributed => rect.center().y - turned.height() / 2.0,
+        VAlign::Bottom if angle < 0.0 => rect.bottom() - pad - turned.height(),
+        _ => rect.top() + pad,
+    };
+    pos2(x, y) - turned.min.to_vec2()
+}
+
+/// The outline segments of merged area `m` drawn at `rect`: the top and left edges come from the
+/// first row's and first column's cells, the bottom and right edges from the last row's and last
+/// column's cells, one segment per visible cell (limited to the visible `rows` × `cols`).
+#[allow(clippy::too_many_arguments)]
+pub(super) fn merged_edges(
+    wb: &Workbook,
+    si: usize,
+    sh: &Sheet,
+    geo: &Geo,
+    m: RangeRef,
+    rect: Rect,
+    rows: (u32, u32),
+    cols: (u32, u32),
+    cf: &mut CfCache,
+) -> Vec<(BorderLine, [Pos2; 2])> {
+    let mut out = Vec::new();
+    let (cs, ce) = (m.start.col.max(cols.0), m.end.col.min(cols.1));
+    for col in cs..=ce {
+        if sh.col_width(col) == 0.0 {
+            continue;
+        }
+        let (x0, x1) = (geo.x(sh, col), geo.x(sh, col.saturating_add(1)));
+        let top = look(wb, si, sh, CellRef::new(m.start.row, col), cf).0.style.borders.top;
+        let bottom = look(wb, si, sh, CellRef::new(m.end.row, col), cf).0.style.borders.bottom;
+        out.push((top, [pos2(x0, rect.top()), pos2(x1, rect.top())]));
+        out.push((bottom, [pos2(x0, rect.bottom()), pos2(x1, rect.bottom())]));
+    }
+    let (rs, re) = (m.start.row.max(rows.0), m.end.row.min(rows.1));
+    for row in rs..=re {
+        if sh.row_height(row) == 0.0 {
+            continue;
+        }
+        let (y0, y1) = (geo.y(sh, row), geo.y(sh, row.saturating_add(1)));
+        let left = look(wb, si, sh, CellRef::new(row, m.start.col), cf).0.style.borders.left;
+        let right = look(wb, si, sh, CellRef::new(row, m.end.col), cf).0.style.borders.right;
+        out.push((left, [pos2(rect.left(), y0), pos2(rect.left(), y1)]));
+        out.push((right, [pos2(rect.right(), y0), pos2(rect.right(), y1)]));
+    }
+    out
+}
+
+/// The smaller font that makes `text` fit in `room` points of width (Shrink to fit), or `None`
+/// when it already fits at its own size.
+pub(super) fn shrink_font(p: &Painter, text: &str, font: &FontId, room: f32) -> Option<FontId> {
+    let natural = p.layout_no_wrap(text.to_string(), font.clone(), Color32::PLACEHOLDER).size().x;
+    let room = room.max(1.0);
+    if natural.is_nan() || natural <= room {
+        return None;
+    }
+    // Glyph advances don't scale exactly linearly (rounding), so leave a little slack.
+    let size = (font.size * room / natural * 0.97).max(1.0);
+    Some(FontId::new(size, font.family.clone()))
+}
+
+pub(crate) fn paint_border(p: &Painter, pts: [Pos2; 2], style: BorderStyle, col: Color32) {
+    let w = style.width();
+    let (a, b) = (pts[0], pts[1]);
+    match style {
+        BorderStyle::Double => {
+            let horiz = (a.y - b.y).abs() < 0.5;
+            let off = if horiz { vec2(0.0, 1.5) } else { vec2(1.5, 0.0) };
+            p.line_segment([a - off, b - off], Stroke::new(1.0, col));
+            p.line_segment([a + off, b + off], Stroke::new(1.0, col));
+        }
+        BorderStyle::Dashed
+        | BorderStyle::MediumDashed
+        | BorderStyle::DashDot
+        | BorderStyle::MediumDashDot
+        | BorderStyle::DashDotDot
+        | BorderStyle::MediumDashDotDot
+        | BorderStyle::SlantDashDot => {
+            p.extend(egui::Shape::dashed_line(&[a, b], Stroke::new(w, col), 4.0, 2.0));
+        }
+        BorderStyle::Dotted | BorderStyle::Hair => {
+            p.extend(egui::Shape::dotted_line(&[a, b], col, 2.0, w * 0.5));
+        }
+        _ => {
+            p.line_segment([a, b], Stroke::new(w, col));
+        }
+    }
+}
+
+pub(super) fn paint_cf_icon(p: &Painter, r: Rect, set: &str, idx: usize) {
+    let n = gridcraft_engine::cf::icon_count(set);
+    let palette3 = [Color32::from_rgb(0xD1, 0x3B, 0x2F), Color32::from_rgb(0xF2, 0xB8, 0x2E), Color32::from_rgb(0x2E, 0x9E, 0x4F)];
+    let col = if n <= 3 {
+        palette3.get(idx).copied().unwrap_or(Color32::GRAY)
+    } else {
+        let t = idx as f32 / (n - 1).max(1) as f32;
+        Color32::from_rgb(
+            (0xD1 as f32 * (1.0 - t) + 0x2E as f32 * t) as u8,
+            (0x3B as f32 * (1.0 - t) + 0x9E as f32 * t) as u8,
+            (0x2F as f32 * (1.0 - t) + 0x4F as f32 * t) as u8,
+        )
+    };
+    let lower = set.to_ascii_lowercase();
+    if lower.contains("arrow") {
+        let c = r.center();
+        let s = r.width() / 2.0;
+        let pts = if idx + 1 == n {
+            vec![pos2(c.x, c.y - s), pos2(c.x + s, c.y + 0.1 * s), pos2(c.x - s, c.y + 0.1 * s)]
+        } else if idx == 0 {
+            vec![pos2(c.x, c.y + s), pos2(c.x - s, c.y - 0.1 * s), pos2(c.x + s, c.y - 0.1 * s)]
+        } else {
+            vec![pos2(c.x + s, c.y), pos2(c.x - 0.1 * s, c.y - s), pos2(c.x - 0.1 * s, c.y + s)]
+        };
+        p.add(egui::Shape::convex_polygon(pts, col, Stroke::NONE));
+    } else if lower.contains("rating") || lower.contains("quarter") {
+        p.circle_stroke(r.center(), r.width() / 2.0 - 0.5, Stroke::new(1.0, Color32::GRAY));
+        let frac = idx as f32 / (n - 1).max(1) as f32;
+        p.rect_filled(
+            Rect::from_min_size(pos2(r.left() + 2.0, r.bottom() - 2.0 - (r.height() - 4.0) * frac), vec2(r.width() - 4.0, (r.height() - 4.0) * frac)),
+            1.0,
+            Color32::from_rgb(0x2B, 0x7C, 0xD3),
+        );
+    } else {
+        p.circle_filled(r.center(), r.width() / 2.0 - 0.5, col);
+    }
+}
+
+/// Black or white, whichever reads on `fill` (the threshold chart labels use).
+pub(super) fn ink_on(fill: Color32) -> Color32 {
+    let l = 0.299 * fill.r() as f32 + 0.587 * fill.g() as f32 + 0.114 * fill.b() as f32;
+    if l < 150.0 { Color32::WHITE } else { Color32::BLACK }
+}
+
+/// The horizontal alignment to paint with. Cells are painted left to right and a right-to-left
+/// sheet is mirrored afterwards, so an explicit Left or Right is swapped first to end up on the
+/// side the user chose: Align Right stays on the right in either sheet direction, as in Excel.
+/// General alignment is resolved from the value before this and follows the sheet direction.
+pub(super) fn painted_halign(h: HAlign, rtl: bool) -> HAlign {
+    match h {
+        HAlign::Left if rtl => HAlign::Right,
+        HAlign::Right if rtl => HAlign::Left,
+        h => h,
+    }
+}
diff --git a/crates/ui-egui/src/grid/cursor.rs b/crates/ui-egui/src/grid/cursor.rs
new file mode 100644
index 000000000..b72f9e160
--- /dev/null
+++ b/crates/ui-egui/src/grid/cursor.rs
@@ -0,0 +1,138 @@
+use super::geo::Geo;
+use super::interact::{OBJECT_RESIZE_RADIUS, col_edge, freeze_handles, hidden_col_edge, hidden_row_edge, on_border, row_edge};
+use super::*;
+
+/// Decide after interaction so drag start and release use the new state in the same frame.
+pub(super) fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet) {
+    if app.text_box_editor.is_some() || app.grid.hf_edit.is_some() {
+        return;
+    }
+    let ctx = ui.ctx();
+    let pointer = ctx.input(|i| i.pointer.clone());
+    let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p));
+    let in_cells = pos.is_some_and(|p| geo.in_cells(p));
+    let (freeze_cols, freeze_rows) = freeze_handles(geo);
+    // Hover bookkeeping also serves cell notes, independently of who owns the cursor.
+    if resp.hovered()
+        && let Some(p) = pos
+        && !freeze_cols.contains(p)
+        && !freeze_rows.contains(p)
+        && !matches!(app.grid.drag, Drag::Freeze { .. })
+    {
+        app.grid.hover_cell = in_cells.then(|| geo.cell_at(sh, p));
+    }
+    // Draw tools own the cursor over cells, including while recording a stroke.
+    if !app.session.draw_tool.is_empty() && in_cells {
+        ctx.set_cursor_icon(CursorIcon::Crosshair);
+        return;
+    }
+    // A held drag owns the cursor even outside the grid; a press below egui's threshold still
+    // has Drag::None and uses hover. A click can briefly leave a drag state after release.
+    if resp.dragged()
+        && pointer.primary_down()
+        && let Some(cursor) = drag_cursor(&app.grid.drag)
+    {
+        ctx.set_cursor_icon(cursor);
+        return;
+    }
+    if !resp.hovered() {
+        return;
+    }
+    let Some(p) = pos else { return };
+    hover_cursor(app, ctx, resp, &pointer, geo, sh, p);
+}
+
+/// The cursor a held drag shows, or `None` when the drag leaves it to hover.
+fn drag_cursor(drag: &Drag) -> Option<CursorIcon> {
+    match drag {
+        Drag::None => None,
+        Drag::Select => Some(CursorIcon::Cell),
+        Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default),
+        Drag::Fill { .. } => Some(CursorIcon::Crosshair),
+        Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { resize: false, .. } => Some(CursorIcon::Move),
+        Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn),
+        Drag::ResizeRow { .. } => Some(CursorIcon::ResizeRow),
+        Drag::Freeze { cols, .. } => Some(if *cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical }),
+        Drag::Object { resize: true, .. } => Some(CursorIcon::ResizeNwSe),
+    }
+}
+
+/// The cursor over the grid when no drag owns it: freeze bars, header edges, the fill handle, cells.
+fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, pointer: &egui::PointerState, geo: &Geo, sh: &Sheet, p: Pos2) {
+    let (freeze_cols, freeze_rows) = freeze_handles(geo);
+    if freeze_cols.contains(p) || freeze_rows.contains(p) {
+        freeze_cursor(app, ctx, resp, pointer, freeze_cols.contains(p));
+        return;
+    }
+    let in_cells = geo.in_cells(p);
+    let in_col_header = p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left();
+    let in_row_header = p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top();
+    let near_col_edge = in_col_header && col_edge(geo, sh, p.x).is_some();
+    let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default();
+    let cur_rect = geo.range_rect(sh, sel.current());
+    let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0));
+    let handle_panes = geo.range_panes(RangeRef::cell(sel.current().end));
+    let border_panes = geo.range_panes(sel.current());
+    let on_handle = handle.contains(p) && handle_panes.iter().any(|r| r.contains(p));
+    let on_cur_border = on_border(cur_rect, p) && border_panes.iter().any(|r| r.contains(p));
+    let selected_object = crate::chartview::hit(app, geo, sh, p).filter(|&(_, id, _)| app.selected_chart == Some(id));
+    let near_corner = selected_object.is_some_and(|(_, _, rect)| (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS);
+    if app.grid.drag == Drag::None && near_corner {
+        ctx.set_cursor_icon(CursorIcon::ResizeNwSe);
+    } else if near_col_edge || (in_row_header && row_edge(geo, sh, p.y).is_some()) {
+        header_edge_cursor(app, ctx, pointer, geo, sh, p, near_col_edge);
+    } else if on_handle && app.editor.is_none() {
+        ctx.set_cursor_icon(CursorIcon::Crosshair);
+        if app.grid.drag == Drag::None && !pointer.any_down() {
+            resp.clone().on_hover_text_at_pointer("Drag to fill cells. Drag from inside a cell to select a range.");
+        }
+    } else if in_cells && app.editor.is_none() && on_cur_border {
+        ctx.set_cursor_icon(CursorIcon::Move);
+    } else if in_cells {
+        ctx.set_cursor_icon(CursorIcon::Cell);
+    } else if in_col_header {
+        let col = geo.col_at(sh, p.x);
+        let selected = sel.ranges.len() == 1 && sel.current().is_full_cols() && sel.current().contains(CellRef::new(0, col));
+        ctx.set_cursor_icon(if selected { CursorIcon::Move } else { CursorIcon::Default });
+    }
+}
+
+/// The resize cursor for dragging a freeze bar.
+fn freeze_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, pointer: &egui::PointerState, cols: bool) {
+    ctx.set_cursor_icon(if cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical });
+    if app.grid.drag == Drag::None && !pointer.any_down() {
+        let tip = if cols { "Drag to freeze columns" } else { "Drag to freeze rows" };
+        resp.clone().on_hover_text_at_pointer(crate::i18n::current(ctx).tr(tip));
+    }
+}
+
+/// The resize cursor over a column or row header edge. Just past a hidden column or row, Excel
+/// shows a split cursor: dragging or double-clicking there unhides it.
+fn header_edge_cursor(app: &SheetApp, ctx: &egui::Context, pointer: &egui::PointerState, geo: &Geo, sh: &Sheet, p: Pos2, near_col_edge: bool) {
+    let hidden =
+        app.grid.drag == Drag::None && if near_col_edge { hidden_col_edge(geo, sh, p.x).is_some() } else { hidden_row_edge(geo, sh, p.y).is_some() };
+    match pointer.hover_pos() {
+        Some(at) if hidden => paint_split_cursor(ctx, at, near_col_edge),
+        _ => ctx.set_cursor_icon(if near_col_edge { CursorIcon::ResizeColumn } else { CursorIcon::ResizeRow }),
+    }
+}
+
+/// A split cursor (two bars with arrows either side) painted in place of the OS cursor, which
+/// has no such shape. Black on a white outline, like the system cursors.
+fn paint_split_cursor(ctx: &egui::Context, at: Pos2, cols: bool) {
+    ctx.set_cursor_icon(CursorIcon::None);
+    let p = ctx.layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("gridcraft.split_cursor")));
+    // Drawn for columns (bars vertical); rows swap the axes.
+    let pt = |x: f32, y: f32| if cols { pos2(at.x + x, at.y + y) } else { pos2(at.x + y, at.y + x) };
+    let arrow = |dir: f32| vec![pt(dir * 10.0, 0.0), pt(dir * 6.0, -4.0), pt(dir * 6.0, 4.0)];
+    for (width, color) in [(3.0, Color32::WHITE), (1.0, Color32::BLACK)] {
+        let stroke = Stroke::new(width, color);
+        for bx in [-1.5, 1.5] {
+            p.line_segment([pt(bx, -8.0), pt(bx, 8.0)], stroke);
+        }
+        p.line_segment([pt(-7.0, 0.0), pt(7.0, 0.0)], stroke);
+        for dir in [-1.0, 1.0] {
+            p.add(egui::Shape::convex_polygon(arrow(dir), color, Stroke::new(width - 1.0, color)));
+        }
+    }
+}
diff --git a/crates/ui-egui/src/grid/editor.rs b/crates/ui-egui/src/grid/editor.rs
new file mode 100644
index 000000000..d87ec385a
--- /dev/null
+++ b/crates/ui-egui/src/grid/editor.rs
@@ -0,0 +1,161 @@
+use super::cell_paint::ink_on;
+use super::geo::Geo;
+use super::*;
+
+/// Room the in-cell editor keeps right of its text. It is sized from the text of the last frame, so
+/// the next typed character must still fit: a fixed 14 px was less than one glyph at high zoom,
+/// and the field scrolled and snapped back on every key (#2336). `size` is the font size in px.
+pub(super) fn editor_slack(size: f32) -> f32 {
+    14.0 + size
+}
+
+/// Width of the one-line in-cell editor. While the text fits the cell (with the usual 14 px margin) the
+/// editor is exactly the cell wide, as in Excel; once it overflows, the extra `editor_slack` applies.
+pub(super) fn editor_width(text_w: f32, cell_w: f32, size: f32) -> f32 {
+    if text_w + 14.0 <= cell_w { cell_w } else { text_w + editor_slack(size) }
+}
+
+/// Draws the in-cell editor, growing and wrapping with its text, mirroring for right-to-left sheets, choosing contrasting caret ink and clipping cells hidden under frozen panes.
+pub(super) fn in_cell_editor(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet, wb: &Workbook) {
+    let Some(ed) = app.editor.as_ref() else { return };
+    if app.view_key() != Some((ed.doc, ed.sheet)) {
+        return;
+    }
+    let cell = ed.cell;
+    let rect = match sh.merge_at(cell) {
+        Some(m) => geo.range_rect(sh, m),
+        None => geo.cell_rect(sh, cell),
+    };
+    let st = wb.styles.get(sh.style_id(cell)).clone();
+    let size = st.font.size * 96.0 / 72.0 * geo.z;
+    let font = FontId::new(size, theme::cell_family(&st.font.name, st.font.bold, st.font.italic));
+    let lines = ed.text.lines().count().max(1) as f32 + if ed.text.ends_with('\n') { 1.0 } else { 0.0 };
+    // Grows with the text: the in-cell editor shows every line and never scrolls (the formula bar
+    // is the one that stops at five lines).
+    let shown = lines;
+    // Wrap Text: the editor keeps the column's width and wraps, growing down as Excel's does.
+    // Otherwise it widens to the text's one-line width.
+    let wrap = st.align.wrap;
+    let (w, h) = if wrap {
+        // The field wraps at the width it is given (the editor's less its 2 px inset a side): its
+        // frame is `Frame::NONE`, so no text margin is taken off.
+        let wrapped = ui.painter().layout(ed.text.clone(), font.clone(), Color32::BLACK, (rect.width() - 4.0).max(1.0));
+        (rect.width(), (wrapped.size().y.max(size * 1.3 * shown) + 4.0).max(rect.height()))
+    } else {
+        let text_w = ui.painter().layout_no_wrap(ed.text.clone(), font.clone(), Color32::BLACK).size().x;
+        // Excel keeps the cell's height for one line and only grows for extra lines.
+        let h = if lines > 1.0 { (size * 1.3 * lines + 4.0).max(rect.height()) } else { rect.height() };
+        (editor_width(text_w, rect.width(), size).min(geo.cells.right() - rect.left()), h)
+    };
+    // Grows to the left on a right-to-left sheet.
+    let erect = geo.mirror_rect(Rect::from_min_size(rect.min, vec2(w, h)));
+    let fill = match st.fill.pattern {
+        PatternType::Solid => st.fill.fg.resolve(&wb.theme).map(theme::color32).unwrap_or(Color32::WHITE),
+        _ => Color32::WHITE,
+    };
+    let split = pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h);
+    let quadrant = Rect::from_min_max(
+        pos2(if cell.col >= geo.fc { split.x } else { geo.cells.left() }, if cell.row >= geo.fr { split.y } else { geo.cells.top() }),
+        pos2(if cell.col >= geo.fc { geo.cells.right() } else { split.x }, if cell.row >= geo.fr { geo.cells.bottom() } else { split.y }),
+    );
+    // A cell scrolled entirely under a frozen row/column keeps its edit (Escape still works),
+    // but neither the cell nor its helper may paint. Test the cell's own visible quadrant and
+    // give the shared editor an empty clip when the cell is hidden: a one-line cell editor's
+    // field can be larger than the cell (egui 0.37 gives text fields a minimum height), so its
+    // own max_rect is not a reliable "is the cell on screen" test at the frozen boundary. The
+    // pre-wrap cell rect must also be positive: a hidden row/column has zero height/width, but
+    // Wrap Text can expand the editor below/right of it, which must not paint over the next line.
+    let cell_visible = rect.width() > 0.0 && rect.height() > 0.0;
+    // `erect` and `ui.clip_rect()` are in screen coordinates; `quadrant` is logical until mirrored.
+    let screen_quadrant = geo.mirror_rect(quadrant);
+    let on_screen = cell_visible && erect.intersect(screen_quadrant).is_positive() && !geo.hidden_under_frozen(sh, cell);
+    let clip = if on_screen { ui.clip_rect().intersect(screen_quadrant) } else { Rect::NOTHING };
+    let painter = ui.painter().with_clip_rect(clip);
+    painter.rect_filled(erect, 0.0, fill);
+    painter.rect_stroke(erect.expand(1.0), 0.0, Stroke::new(2.0, Tokens::get(ui.ctx()).sel_border), StrokeKind::Middle);
+    let id = egui::Id::unique("gridcraft.cell_editor");
+    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(erect.shrink2(vec2(2.0, 1.0))));
+    child.set_clip_rect(clip);
+    // The theme's caret is meant for the UI chrome and vanishes on some fills (and, in the dark
+    // theme, on the white paper): pick black or white against the fill, like Excel.
+    child.visuals_mut().text_cursor.stroke.color = ink_on(fill);
+    crate::formula_bar::editor_widget(app, &mut child, id, font, wrap, erect.width() - 4.0, erect.height() - 2.0);
+    ui.ctx().data_mut(|d| d.insert_temp(egui::Id::unique("gridcraft.cell_editor.rect"), erect));
+}
+
+/// Test the popup itself, not whether the pointer is over any part of the app.
+/// A trigger can sit outside its popup, so its opening click must be ignored.
+pub(super) fn popup_dismissed(response: &egui::Response, was_open: bool) -> bool {
+    response.ctx.input(|i| !i.focused || i.key_pressed(egui::Key::Escape)) || (was_open && response.clicked_elsewhere())
+}
+
+/// The dropdown arrow beside a cell with an in-cell list validation.
+pub fn validation_arrow(sh: &Sheet, geo: &Geo, c: CellRef) -> Option<Rect> {
+    let dv = sh.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(c)))?;
+    if dv.kind != gridcraft_engine::model::ValidationKind::List || !dv.in_cell_dropdown || geo.hidden_under_frozen(sh, c) {
+        return None;
+    }
+    let r = geo.cell_rect(sh, c);
+    let s = r.height().clamp(14.0, 22.0);
+    Some(Rect::from_min_size(pos2(r.right() + 1.0, r.bottom() - s), vec2(s, s)))
+}
+
+/// Rows the list-validation dropdown shows before it scrolls (Excel shows 8).
+const LIST_PICKER_MAX_ROWS: usize = 8;
+
+const LIST_PICKER_ROW_H: f32 = 18.0;
+
+/// Popup frame around the rows: 2 px inner margin and the window stroke on each side, rounded up.
+const LIST_PICKER_CHROME: f32 = 8.0;
+
+/// Popup height for `n` items: every item up to `LIST_PICKER_MAX_ROWS`, then a scrollbar.
+pub(super) fn list_picker_height(n: usize, row_h: f32, gap: f32) -> f32 {
+    let rows = n.clamp(1, LIST_PICKER_MAX_ROWS) as f32;
+    rows * row_h + (rows - 1.0) * gap
+}
+
+/// Draws the validation list popup, choosing above/below and left/right placement for RTL, and applies the clicked item with `cell.set`.
+pub(super) fn list_picker(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_open: bool) {
+    let Some(c) = app.grid.list_picker else { return };
+    let Some(d) = app.session.active() else { return };
+    let wb = d.wb.clone();
+    let si = wb.active_sheet();
+    let Some(sh) = wb.sheet(si) else { return };
+    let Some(dv) = sh.validations.iter().find(|x| x.ranges.iter().any(|r| r.contains(c))).cloned() else {
+        app.grid.list_picker = None;
+        return;
+    };
+    let items = gridcraft_engine::cmd::data::list_items(&wb, si, &dv);
+    let r = geo.cell_rect(sh, c);
+    // Fit the popup to its rows (up to LIST_PICKER_MAX_ROWS); without a minimum the scroll area collapses to its 64 px default.
+    let height = list_picker_height(items.len(), LIST_PICKER_ROW_H, ui.spacing().item_spacing.y);
+    // Open below the cell, or above it when the rows would run past the bottom of the window (as Excel does).
+    let screen = ui.ctx().content_rect();
+    let above = r.bottom() + height + LIST_PICKER_CHROME > screen.bottom() && r.top() - height - LIST_PICKER_CHROME >= screen.top();
+    let (at, pivot) = match (above, geo.rtl) {
+        (false, false) => (geo.mirror_pos(r.left_bottom()), Align2::LEFT_TOP),
+        (false, true) => (geo.mirror_pos(r.left_bottom()), Align2::RIGHT_TOP),
+        (true, false) => (geo.mirror_pos(r.left_top()), Align2::LEFT_BOTTOM),
+        (true, true) => (geo.mirror_pos(r.left_top()), Align2::RIGHT_BOTTOM),
+    };
+    let mut close = false;
+    let response = egui::Area::new(egui::Id::unique("dv_list")).fixed_pos(at).pivot(pivot).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
+        egui::Frame::popup(ui.style()).inner_margin(2.0).show(ui, |ui| {
+            ui.set_min_width(r.width().max(100.0));
+            egui::ScrollArea::vertical().max_height(height).min_scrolled_height(height).show(ui, |ui| {
+                for it in &items {
+                    if ui
+                        .add(egui::Button::new(it.as_str()).frame_when_inactive(false).min_size(vec2(r.width().max(100.0), LIST_PICKER_ROW_H)))
+                        .clicked()
+                    {
+                        app.run_or_alert("cell.set", json!({"cell": c.a1(), "input": it}));
+                        close = true;
+                    }
+                }
+            });
+        });
+    });
+    if close || popup_dismissed(&response.response, was_open) {
+        app.grid.list_picker = None;
+    }
+}
diff --git a/crates/ui-egui/src/grid/geo.rs b/crates/ui-egui/src/grid/geo.rs
new file mode 100644
index 000000000..0c17e173a
--- /dev/null
+++ b/crates/ui-egui/src/grid/geo.rs
@@ -0,0 +1,237 @@
+use super::*;
+
+/// Geometry of the grid for one frame (handles zoom and frozen panes).
+#[derive(Clone)]
+pub struct Geo {
+    pub rect: Rect,
+    pub cells: Rect,
+    pub z: f32,
+    pub header_w: f32,
+    pub header_h: f32,
+    /// The outline bands (grouped rows / columns): left of the row headers and above the column
+    /// headers; 0 without an outline (see `outline`).
+    pub band_w: f32,
+    pub band_h: f32,
+    pub row_outline: Arc<crate::outline::Axis>,
+    pub col_outline: Arc<crate::outline::Axis>,
+    pub fr: u32,
+    pub fc: u32,
+    pub frozen_w: f32,
+    pub frozen_h: f32,
+    pub scroll: egui::Vec2,
+    /// Sheet Right-to-Left: everything is laid out left-to-right as usual (these "logical"
+    /// coordinates are what `x`, `cell_rect`, `col_at`… return) and mirrored across `rect`'s
+    /// vertical centre line on screen: painted shapes by `mirror_painted`, widgets by
+    /// `mirror_rect`/`mirror_pos`, and pointer input back by `mirror_pos` (an involution).
+    pub rtl: bool,
+    /// Prefix sums over custom row heights / column widths, built once per frame.
+    pub(super) ri: std::sync::Arc<LineIndex>,
+    pub(super) ci: std::sync::Arc<LineIndex>,
+    /// Page Layout view: cells sit on pages (`scroll` is then in page-layout units).
+    pub paper: Option<Arc<gridcraft_engine::paper::PageGrid>>,
+}
+
+impl Geo {
+    pub fn new(sh: &Sheet, rect: Rect, scroll: egui::Vec2) -> Geo {
+        let zoom = (sh.zoom as f32 / 100.0).clamp(0.1, 4.0);
+        let z = zoom * DISPLAY_SCALE;
+        let header_h = if sh.show_headings { (COL_HEADER_H * zoom.max(0.75)).round() } else { 0.0 };
+        let ri = std::sync::Arc::new(LineIndex::new(&sh.rows, sh.default_row_height, MAX_ROWS));
+        let ci = std::sync::Arc::new(LineIndex::new(&sh.cols, sh.default_col_width, MAX_COLS));
+        let last_row = ri.at((scroll.y + rect.height() / z) as f64 + 200.0) + 1;
+        let digits = (last_row as f32).log10().floor() as i32 + 1;
+        let header_w = if sh.show_headings { ((digits.max(2) as f32 * 7.0 + 14.0) * zoom.max(0.75)).round() } else { 0.0 };
+        let (fr, fc) = sh.freeze.unwrap_or((0, 0));
+        let frozen_w = (ci.start(fc) as f32) * z;
+        let frozen_h = (ri.start(fr) as f32) * z;
+        let row_outline = Arc::new(crate::outline::Axis::of(sh, true));
+        let col_outline = Arc::new(crate::outline::Axis::of(sh, false));
+        // Show Outline Symbols off: no bands (the outline's hidden lines stay hidden).
+        let symbols = sh.show_outline_symbols;
+        let mut band_w = if symbols { crate::outline::band(row_outline.levels, zoom) } else { 0.0 };
+        let mut band_h = if symbols { crate::outline::band(col_outline.levels, zoom) } else { 0.0 };
+        // Without headings the level buttons still need a corner to sit in.
+        if symbols && row_outline.levels > 0 && header_h == 0.0 {
+            band_h = band_h.max(crate::outline::lane(zoom) + 3.0);
+        }
+        if symbols && col_outline.levels > 0 && header_w == 0.0 {
+            band_w = band_w.max(crate::outline::lane(zoom) + 3.0);
+        }
+        let cells = Rect::from_min_max(pos2(rect.left() + band_w + header_w, rect.top() + band_h + header_h), rect.max);
+        Geo {
+            rect,
+            cells,
+            z,
+            header_w,
+            header_h,
+            band_w,
+            band_h,
+            row_outline,
+            col_outline,
+            fr,
+            fc,
+            frozen_w,
+            frozen_h,
+            scroll,
+            rtl: sh.right_to_left,
+            ri,
+            ci,
+            paper: None,
+        }
+    }
+    /// Left edge of the row headers (right of the outline band).
+    pub fn head_left(&self) -> f32 {
+        self.cells.left() - self.header_w
+    }
+    /// Top edge of the column headers (below the outline band).
+    pub fn head_top(&self) -> f32 {
+        self.cells.top() - self.header_h
+    }
+    /// Page Layout view geometry: `rect` excludes the rulers; cells are drawn at the print scale
+    /// on pages laid out by `grid`; frozen panes don't apply (as in Excel).
+    pub fn paged(sh: &Sheet, rect: Rect, scroll: egui::Vec2, grid: Arc<gridcraft_engine::paper::PageGrid>) -> Geo {
+        let mut g = Geo::new(sh, rect, scroll);
+        let zoom = (sh.zoom as f32 / 100.0).clamp(0.1, 4.0);
+        g.z = zoom * DISPLAY_SCALE * grid.scale.clamp(0.1, 4.0);
+        (g.fr, g.fc, g.frozen_w, g.frozen_h) = (0, 0, 0.0, 0.0);
+        g.paper = Some(grid);
+        g
+    }
+    /// The point is over cells (in Page Layout view: on a page, inside its margins).
+    pub fn in_cells(&self, p: Pos2) -> bool {
+        if !self.cells.contains(p) {
+            return false;
+        }
+        match &self.paper {
+            Some(pg) => pg.on_cells(
+                self.scroll.x as f64 + ((p.x - self.cells.left()) / self.z) as f64,
+                self.scroll.y as f64 + ((p.y - self.cells.top()) / self.z) as f64,
+            ),
+            None => true,
+        }
+    }
+    /// Scroll offset (in `scroll` units) at which `row` reaches the top of the scrolled area.
+    pub fn scroll_top_of(&self, sh: &Sheet, row: u32) -> f32 {
+        match &self.paper {
+            Some(pg) => pg.row_y(row) as f32,
+            None => (sh.row_top(row) - sh.row_top(self.fr)) as f32,
+        }
+    }
+    /// Scroll offset (in `scroll` units) at which `col` reaches the left of the scrolled area.
+    pub fn scroll_left_of(&self, sh: &Sheet, col: u32) -> f32 {
+        match &self.paper {
+            Some(pg) => pg.col_x(col) as f32,
+            None => (sh.col_left(col) - sh.col_left(self.fc)) as f32,
+        }
+    }
+    /// Screen x for a logical x (and back): identity unless the sheet is right-to-left.
+    pub fn mirror_x(&self, x: f32) -> f32 {
+        if self.rtl { self.rect.left() + self.rect.right() - x } else { x }
+    }
+    pub fn mirror_pos(&self, p: Pos2) -> Pos2 {
+        pos2(self.mirror_x(p.x), p.y)
+    }
+    pub fn mirror_rect(&self, r: Rect) -> Rect {
+        if self.rtl { Rect::from_min_max(pos2(self.mirror_x(r.right()), r.top()), pos2(self.mirror_x(r.left()), r.bottom())) } else { r }
+    }
+    /// On-screen rectangle of a cell (`cell_rect` mirrored for right-to-left sheets).
+    pub fn screen_cell_rect(&self, sh: &Sheet, c: CellRef) -> Rect {
+        self.mirror_rect(self.cell_rect(sh, c))
+    }
+    pub fn x(&self, _sh: &Sheet, col: u32) -> f32 {
+        if let Some(pg) = &self.paper {
+            return self.cells.left() + (pg.col_x(col) - self.scroll.x as f64) as f32 * self.z;
+        }
+        if col < self.fc {
+            self.cells.left() + self.ci.start(col) as f32 * self.z
+        } else {
+            self.cells.left() + self.frozen_w + (self.ci.start(col) as f32 - self.ci.start(self.fc) as f32 - self.scroll.x) * self.z
+        }
+    }
+    pub fn y(&self, _sh: &Sheet, row: u32) -> f32 {
+        if let Some(pg) = &self.paper {
+            return self.cells.top() + (pg.row_y(row) - self.scroll.y as f64) as f32 * self.z;
+        }
+        if row < self.fr {
+            self.cells.top() + self.ri.start(row) as f32 * self.z
+        } else {
+            self.cells.top() + self.frozen_h + (self.ri.start(row) as f32 - self.ri.start(self.fr) as f32 - self.scroll.y) * self.z
+        }
+    }
+    pub fn cell_rect(&self, sh: &Sheet, c: CellRef) -> Rect {
+        Rect::from_min_max(
+            pos2(self.x(sh, c.col), self.y(sh, c.row)),
+            pos2(self.x(sh, c.col) + sh.col_width(c.col) * self.z, self.y(sh, c.row) + sh.row_height(c.row) * self.z),
+        )
+    }
+    pub fn range_rect(&self, sh: &Sheet, r: RangeRef) -> Rect {
+        let a = self.cell_rect(sh, r.start);
+        let b = self.cell_rect(sh, r.end);
+        Rect::from_min_max(a.min, b.max)
+    }
+    pub fn col_at(&self, _sh: &Sheet, x: f32) -> u32 {
+        if let Some(pg) = &self.paper {
+            return pg.col_at(self.scroll.x as f64 + ((x - self.cells.left()) / self.z) as f64);
+        }
+        let dx = (x - self.cells.left()) / self.z;
+        if dx < self.frozen_w / self.z {
+            self.ci.at(dx.max(0.0) as f64)
+        } else {
+            self.ci.at(self.ci.start(self.fc) + self.scroll.x as f64 + (dx - self.frozen_w / self.z) as f64)
+        }
+    }
+    pub fn row_at(&self, _sh: &Sheet, y: f32) -> u32 {
+        if let Some(pg) = &self.paper {
+            return pg.row_at(self.scroll.y as f64 + ((y - self.cells.top()) / self.z) as f64);
+        }
+        let dy = (y - self.cells.top()) / self.z;
+        if dy < self.frozen_h / self.z {
+            self.ri.at(dy.max(0.0) as f64)
+        } else {
+            self.ri.at(self.ri.start(self.fr) + self.scroll.y as f64 + (dy - self.frozen_h / self.z) as f64)
+        }
+    }
+    pub fn cell_at(&self, sh: &Sheet, p: Pos2) -> CellRef {
+        CellRef::new(self.row_at(sh, p.y), self.col_at(sh, p.x))
+    }
+    /// Visible scrolled rows (from the first visible row after the frozen ones).
+    pub(super) fn scroll_rows(&self, _sh: &Sheet) -> (u32, u32) {
+        let top = self.ri.start(self.fr) + self.scroll.y as f64;
+        let r0 = self.ri.at(top).max(self.fr);
+        let r1 = self.ri.at(top + ((self.cells.height() - self.frozen_h) / self.z) as f64).min(MAX_ROWS - 1);
+        (r0, r1)
+    }
+    pub(super) fn scroll_cols(&self, _sh: &Sheet) -> (u32, u32) {
+        let left = self.ci.start(self.fc) + self.scroll.x as f64;
+        let c0 = self.ci.at(left).max(self.fc);
+        let c1 = self.ci.at(left + ((self.cells.width() - self.frozen_w) / self.z) as f64).min(MAX_COLS - 1);
+        (c0, c1)
+    }
+    /// Screen areas of the panes (frozen rows/columns or the scrolling part) that hold part of `r`.
+    /// The panes share one coordinate system, so a range that is not clipped to these is also drawn
+    /// over the frozen rows/columns when it is scrolled under them.
+    pub fn range_panes(&self, r: RangeRef) -> Vec<Rect> {
+        let split = pos2(self.cells.left() + self.frozen_w, self.cells.top() + self.frozen_h);
+        let mut xs = Vec::new();
+        if r.start.col < self.fc {
+            xs.push((self.cells.left(), split.x));
+        }
+        if r.end.col >= self.fc {
+            xs.push((split.x, self.cells.right()));
+        }
+        let mut ys = Vec::new();
+        if r.start.row < self.fr {
+            ys.push((self.cells.top(), split.y));
+        }
+        if r.end.row >= self.fr {
+            ys.push((split.y, self.cells.bottom()));
+        }
+        ys.iter().flat_map(|&(y0, y1)| xs.iter().map(move |&(x0, x1)| Rect::from_min_max(pos2(x0, y0), pos2(x1, y1)))).collect()
+    }
+    /// True when cell `c` is in the scrolling pane but scrolled entirely under the frozen rows or columns.
+    pub fn hidden_under_frozen(&self, sh: &Sheet, c: CellRef) -> bool {
+        let r = self.cell_rect(sh, c);
+        (self.fc > 0 && c.col >= self.fc && r.right() <= self.cells.left() + self.frozen_w)
+            || (self.fr > 0 && c.row >= self.fr && r.bottom() <= self.cells.top() + self.frozen_h)
+    }
+}
diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs
new file mode 100644
index 000000000..f59f367a7
--- /dev/null
+++ b/crates/ui-egui/src/grid/interact.rs
@@ -0,0 +1,904 @@
+use super::editor::validation_arrow;
+use super::geo::Geo;
+use super::keyboard::keyboard;
+use super::menus::set_fill_tag;
+use super::selection::select_ranges;
+use super::tables::{is_filter_button, table_headings};
+use super::*;
+
+// ------------------------------------------------------------------ interaction
+
+/// How close (in points) a press must be to an object's bottom-right corner to resize it instead of moving it.
+pub(super) const OBJECT_RESIZE_RADIUS: f32 = 10.0;
+
+pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet, wb: &Workbook) {
+    // Text selection and editing must not also move the object or edit worksheet cells.
+    if app.text_box_editor.is_some() || app.grid.hf_edit.is_some() {
+        return;
+    }
+    let ctx = ui.ctx().clone();
+    // Enter/Space synthesize egui clicks; only real pointer clicks use sheet coordinates.
+    let primary_clicked = resp.clicked_by(egui::PointerButton::Primary);
+    let pointer = ctx.input(|i| i.pointer.clone());
+    let mods = ctx.input(|i| i.modifiers);
+    // Hit-testing works in logical coordinates (see `Geo::rtl`).
+    let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p));
+    let in_cells = pos.is_some_and(|p| geo.in_cells(p));
+    let in_col_header = pos.is_some_and(|p| p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left());
+    let in_row_header = pos.is_some_and(|p| p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top());
+    let in_corner = pos.is_some_and(|p| p.x < geo.cells.left() && p.y < geo.cells.top() && p.x >= geo.head_left() && p.y >= geo.head_top());
+    let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default();
+    let cur_rect = geo.range_rect(sh, sel.current());
+    let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0));
+    // The fill handle and the move border only react in the panes where they are painted, not
+    // over the frozen rows/columns that a scrolled selection lies under.
+    let handle_panes = geo.range_panes(RangeRef::cell(sel.current().end));
+    let border_panes = geo.range_panes(sel.current());
+    let on_handle = |p: Pos2| handle.contains(p) && handle_panes.iter().any(|r| r.contains(p));
+    let on_cur_border = |p: Pos2| on_border(cur_rect, p) && border_panes.iter().any(|r| r.contains(p));
+
+    let (freeze_cols, freeze_rows) = freeze_handles(geo);
+    // Draw tab tools: the pen records a stroke, the eraser deletes ink under the pointer.
+    if !app.session.draw_tool.is_empty() && in_cells {
+        ctx.set_cursor_icon(CursorIcon::Crosshair);
+        if app.session.draw_tool == "pen" {
+            if let Some(p) = pos
+                && resp.dragged()
+            {
+                // Through the cell under the pointer, so frozen panes and pages map right.
+                let c = geo.cell_at(sh, p);
+                let sx = sh.col_left(c.col) as f32 + (p.x - geo.x(sh, c.col)) / geo.z;
+                let sy = sh.row_top(c.row) as f32 + (p.y - geo.y(sh, c.row)) / geo.z;
+                app.grid.ink.push([sx, sy]);
+            }
+            if !app.grid.ink.is_empty() {
+                // Live preview.
+                let pts: Vec<Pos2> = app
+                    .grid
+                    .ink
+                    .iter()
+                    .map(|q| {
+                        let (col, row) = (sh.col_at(q[0].max(0.0) as f64), sh.row_at(q[1].max(0.0) as f64));
+                        geo.mirror_pos(pos2(
+                            geo.x(sh, col) + (q[0] - sh.col_left(col) as f32) * geo.z,
+                            geo.y(sh, row) + (q[1] - sh.row_top(row) as f32) * geo.z,
+                        ))
+                    })
+                    .collect();
+                ui.painter().add(egui::epaint::PathShape::line(pts, egui::epaint::PathStroke::new(2.0 * geo.z, Color32::from_rgb(0x1F, 0x5F, 0xC9))));
+            }
+            if resp.drag_stopped() && app.grid.ink.len() >= 2 {
+                let pts: Vec<[f32; 2]> = std::mem::take(&mut app.grid.ink);
+                let _ = app.run("draw.stroke", json!({"points": pts}));
+            }
+            return;
+        }
+        if app.session.draw_tool == "eraser" && (primary_clicked || resp.dragged()) {
+            if let Some(p) = pos
+                && let Some(("shape", id, _)) = crate::chartview::hit(app, geo, sh, p)
+                && sh.shapes.iter().any(|s| s.id == id && s.kind == gridcraft_engine::model::ShapeKind::Ink)
+            {
+                let _ = app.run("object.delete", json!({"kind": "shape", "id": id}));
+            }
+            return;
+        }
+    }
+    // A plain click on a slicer value tile toggles it (Ctrl/Cmd for multi-select); the clear
+    // button resets it. Runs before the generic object select/drag so tiles stay clickable.
+    if primary_clicked
+        && !resp.drag_started()
+        && let Some(p) = pos
+        && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p)
+    {
+        app.selected_chart = Some(id);
+        match act {
+            crate::chartview::SlicerAction::Toggle(value) => {
+                let _ = app.run("slicer.toggle", json!({"slicer": id, "value": value, "multi": mods.command || mods.ctrl}));
+            }
+            crate::chartview::SlicerAction::Clear => {
+                let _ = app.run("slicer.clear", json!({"slicer": id}));
+            }
+        }
+        return;
+    }
+    // Objects (charts, pictures, shapes, slicers) take clicks first. Only the primary button moves
+    // them: a right-click that wobbles into a drag still opens the object's menu (#2067).
+    let primary_drag = resp.drag_started_by(egui::PointerButton::Primary);
+    if primary_drag || primary_clicked {
+        // A drag is recognised only after the pointer has moved, so grab the object where the press began.
+        let at = if primary_drag { pointer.press_origin().or(pos) } else { pos };
+        if let Some(p) = at
+            && let Some((kind, id, rect)) = crate::chartview::hit(app, geo, sh, p)
+        {
+            app.selected_chart = Some(id);
+            if kind == "shape"
+                && resp.double_clicked()
+                && sh.shapes.iter().any(|s| s.id == id && s.kind == gridcraft_engine::model::ShapeKind::TextBox)
+            {
+                app.begin_text_box_edit(id);
+                return;
+            }
+            if kind == "chart" && resp.double_clicked() {
+                app.grid.pane = Some("formatChart".into());
+            }
+            if primary_drag {
+                let a = object_anchor(sh, kind, id);
+                let resize = (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS;
+                if let Some(a) = a {
+                    app.grid.drag = Drag::Object { kind, id, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), resize };
+                }
+            }
+            return;
+        }
+        app.selected_chart = None;
+    }
+    // A right-click on a chart, picture, shape or slicer opens the object's menu, not the cell's
+    // under it; a right press that wobbles into a drag counts too (#2067).
+    let secondary_drag = resp.drag_started_by(egui::PointerButton::Secondary);
+    if (resp.secondary_clicked() || secondary_drag)
+        && let Some(p) = if secondary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos }
+        && let Some((kind, id, _)) = crate::chartview::hit(app, geo, sh, p)
+    {
+        app.selected_chart = Some(id);
+        app.grid.object_menu = Some((geo.mirror_pos(p), kind, id));
+        return;
+    }
+
+    // A double-click is also a click: handle header AutoFit before resize setup returns.
+    if resp.double_clicked()
+        && let Some(p) = pos
+    {
+        let unhide = if in_col_header {
+            hidden_col_edge(geo, sh, p.x).map(|col| ("home.unhideColumns", json!({"cols": RangeRef::cols(col, col).a1()})))
+        } else if in_row_header {
+            hidden_row_edge(geo, sh, p.y).map(|row| ("home.unhideRows", json!({"rows": RangeRef::rows(row, row).a1()})))
+        } else {
+            None
+        };
+        let autofit = if unhide.is_some() {
+            unhide
+        } else if in_col_header {
+            col_edge(geo, sh, p.x).map(|(col, _)| {
+                let selected = sel.ranges.iter().any(|r| r.is_full_cols() && col >= r.start.col && col <= r.end.col);
+                ("home.autofitColumnWidth", if selected { json!({}) } else { json!({"cols": RangeRef::cols(col, col).a1()}) })
+            })
+        } else if in_row_header {
+            row_edge(geo, sh, p.y).map(|(row, _)| {
+                let selected = sel.ranges.iter().any(|r| r.is_full_rows() && row >= r.start.row && row <= r.end.row);
+                ("home.autofitRowHeight", if selected { json!({}) } else { json!({"rows": RangeRef::rows(row, row).a1()}) })
+            })
+        } else {
+            None
+        };
+        if let Some((command, params)) = autofit {
+            app.grid.drag = Drag::None;
+            app.grid.drag_select = false;
+            app.run_or_alert(command, params);
+            resp.request_focus();
+            return;
+        }
+    }
+
+    // Double-click the fill handle: a double-click is also a click, so run it before the handle press returns.
+    if resp.double_clicked()
+        && let Some(p) = pos
+        && on_handle(p)
+    {
+        // Fill down as far as the neighbouring column goes.
+        let src = sel.current();
+        let neighbour = if src.start.col > 0 { src.start.col - 1 } else { src.end.col + 1 };
+        let cap = src.end.row.saturating_add(1_000_000).min(MAX_ROWS - 1);
+        let last = if src.end.row < cap { sh.last_contiguous_nonempty(neighbour, src.end.row + 1, cap) } else { src.end.row };
+        if last > src.end.row {
+            let target = RangeRef::new(src.start, CellRef::new(last, src.end.col));
+            let _ = app.run("edit.autoFill", json!({"source": src.a1(), "target": target.a1()}));
+        }
+        app.grid.drag = Drag::None;
+        app.grid.drag_select = false;
+        resp.request_focus();
+        return;
+    }
+
+    // Press: decide the drag mode.
+    if resp.drag_started() || (primary_clicked && app.grid.drag == Drag::None) {
+        // Where the press began (a drag is only recognised after the pointer has moved).
+        let Some(p) = pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) else { return };
+        // The outline band's − / + and level buttons act on release, like buttons.
+        if let Some(action) = crate::outline::hit(geo, sh, p) {
+            if primary_clicked {
+                let (command, params) = action.command();
+                app.run_or_alert(command, params);
+            }
+            return;
+        }
+        // Freeze handles sit on the header edges (and the corner's edges when nothing is frozen).
+        if freeze_cols.contains(p) || freeze_rows.contains(p) {
+            app.grid.drag = Drag::Freeze { cols: freeze_cols.contains(p), to: None };
+            return;
+        }
+        if in_corner {
+            let _ = app.session.run("selection.set", json!({"range": RangeRef::all().a1()}));
+            return;
+        }
+        if in_col_header {
+            if let Some((c, x)) = col_edge(geo, sh, p.x) {
+                app.grid.drag = Drag::ResizeCol { col: c, start: p.x, orig: sh.col_width(c).max(0.0) * 0.0 + (x - geo.x(sh, c)) / geo.z };
+                return;
+            }
+            let c = geo.col_at(sh, p.x);
+            // A Table heading's filter button, while the header names stand in for the letters.
+            if let Some(h) = table_headings(geo, sh, sel.active).into_iter().find(|h| h.col == c && h.button.is_some_and(|b| b.contains(p))) {
+                app.grid.filter_menu = Some((c, h.header_row, geo.mirror_pos(p)));
+                return;
+            }
+            if point_header(app, wb, sh, RangeRef::cols(c, c), mods.shift, mods.command) {
+                return;
+            }
+            // An armed Format Painter paints the columns dragged over instead of moving them.
+            if resp.drag_started()
+                && !mods.any()
+                && app.session.format_painter.is_none()
+                && sel.ranges.len() == 1
+                && sel.current().is_full_cols()
+                && sel.current().contains(CellRef::new(0, c))
+            {
+                app.grid.drag = Drag::MoveCols { source: sel.current(), before: None };
+                return;
+            }
+            let range = if mods.shift { RangeRef::cols(sel.anchor.col.min(c), sel.anchor.col.max(c)) } else { RangeRef::cols(c, c) };
+            select_ranges(app, range, mods.command, CellRef::new(geo.row_at(sh, geo.cells.top() + 1.0), c));
+            app.grid.drag = Drag::Cols(if mods.shift { sel.anchor.col } else { c });
+            return;
+        }
+        if in_row_header {
+            if let Some((r, y)) = row_edge(geo, sh, p.y) {
+                app.grid.drag = Drag::ResizeRow { row: r, start: p.y, orig: (y - geo.y(sh, r)) / geo.z };
+                return;
+            }
+            let r = geo.row_at(sh, p.y);
+            if point_header(app, wb, sh, RangeRef::rows(r, r), mods.shift, mods.command) {
+                return;
+            }
+            let range = if mods.shift { RangeRef::rows(sel.anchor.row.min(r), sel.anchor.row.max(r)) } else { RangeRef::rows(r, r) };
+            select_ranges(app, range, mods.command, CellRef::new(r, geo.col_at(sh, geo.cells.left() + 1.0)));
+            app.grid.drag = Drag::Rows(if mods.shift { sel.anchor.row } else { r });
+            return;
+        }
+        if !in_cells {
+            return;
+        }
+        let c = geo.cell_at(sh, p);
+        // Data validation list arrow next to the active cell.
+        if let Some(r) = validation_arrow(sh, geo, sel.active)
+            && r.contains(p)
+        {
+            app.grid.list_picker = Some(sel.active);
+            return;
+        }
+        // Filter dropdown buttons.
+        if is_filter_button(sh, geo, p) {
+            app.grid.filter_menu = Some((c.col, c.row, geo.mirror_pos(p)));
+            return;
+        }
+        // A dialog's formula box in point mode (New Formatting Rule) takes the reference; the
+        // selection, which the dialog acts on, stays.
+        if let Some(d) = app.dialog.as_mut().filter(|d| d.picks_references()) {
+            d.pick_reference(c, &sh.name, false);
+            app.grid.drag = Drag::Select;
+            app.grid.drag_select = true;
+            if resp.drag_started()
+                && let Some(p) = pos
+            {
+                select_to_pointer(app, geo, sh, wb, p);
+            }
+            return;
+        }
+        // Point mode while editing a formula: clicking inserts a reference.
+        if let Some(ed) = app.editor.as_mut()
+            && ed.can_point()
+        {
+            let anchor = if mods.shift && ed.point_at_caret() {
+                ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet()).map(|(_, cell)| cell).unwrap_or(c)
+            } else {
+                c
+            };
+            let range = RangeRef::new(anchor, c);
+            let text = if range.is_single() { c.a1() } else { range.a1() };
+            let sheet_name = (ed.sheet != wb.active_sheet()).then(|| sh.name.clone());
+            let r = match sheet_name {
+                Some(n) => format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&n)),
+                None => text,
+            };
+            if mods.command && !mods.shift {
+                ed.append_ref(&r);
+            } else {
+                ed.insert_ref(&r);
+            }
+            ed.request_focus = true;
+            ed.point_cell = Some(c);
+            ed.point_anchor = Some((wb.active_sheet(), anchor));
+            app.grid.drag = Drag::Select;
+            app.grid.drag_select = true;
+            if resp.drag_started()
+                && let Some(p) = pos
+            {
+                select_to_pointer(app, geo, sh, wb, p);
+            }
+            return;
+        }
+        if app.editor.is_some() && !app.commit_edit(0, 0, false, false) {
+            return;
+        }
+        if on_handle(p) {
+            app.grid.drag = Drag::Fill { target: None, menu: resp.drag_started_by(egui::PointerButton::Secondary) };
+            return;
+        }
+        if on_cur_border(p) && resp.drag_started() {
+            app.grid.drag = Drag::Move { grab: c, to: None };
+            return;
+        }
+        // Double-click edits.
+        let now = crate::now_ms();
+        if let Some((last, at)) = app.grid.last_click
+            && last == c
+            && now - at < 450.0
+            && !mods.shift
+        {
+            app.grid.last_click = None;
+            // A PivotTable's value cell shows its source records on a new sheet (Excel's Show
+            // Details); its labels and headers still edit.
+            if sh.pivots.iter().any(|pt| pt.last_range.is_some_and(|r| r.contains(c))) {
+                let not_a_value_cell =
+                    gridcraft_engine::EngineError::Disabled("pivot.showDetails".into(), gridcraft_engine::pivot::NOT_A_VALUE_CELL.into()).to_string();
+                match app.run("pivot.showDetails", json!({"cell": c.a1()})) {
+                    Ok(_) => return,
+                    Err(e) if e == not_a_value_cell => {}
+                    Err(e) => {
+                        app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+                        return;
+                    }
+                }
+            }
+            // Following a hyperlink requires a single click in Excel; double-click edits.
+            app.begin_edit(None, false);
+            return;
+        }
+        app.grid.last_click = Some((c, now));
+        if mods.shift {
+            let _ = app.session.run("selection.set", json!({"range": RangeRef::new(sel.anchor, c).a1(), "active": sel.active.a1()}));
+            if let Some(d) = app.session.active_mut() {
+                d.selection.anchor = sel.anchor;
+            }
+        } else if mods.command {
+            // Ctrl+click (without Alt) on a hyperlink's text follows it instead of adding the cell to the selection.
+            if let Some(h) = sh.hyperlinks.get(&c).cloned()
+                && primary_clicked
+                && !mods.alt
+                && p.x < geo.cell_rect(sh, c).left() + geo.cell_rect(sh, c).width() * 0.8
+            {
+                follow_link(app, &h.target);
+            } else {
+                select_ranges(app, RangeRef::cell(c), true, c);
+            }
+        } else {
+            let _ = app.session.run("selection.set", json!({"cell": c.a1()}));
+            if primary_clicked && wb.styles.get(sh.style_id(c)).num_fmt.as_str() == "checkbox" {
+                let _ = app.run("cell.toggleCheckbox", json!({"cell": c.a1()}));
+            }
+            // A click on a hyperlink's text follows it (like Excel); elsewhere in the cell selects.
+            if let Some(h) = sh.hyperlinks.get(&c).cloned()
+                && primary_clicked
+                && !mods.any()
+            {
+                let r = geo.cell_rect(sh, c);
+                if p.x < r.left() + r.width() * 0.8 {
+                    follow_link(app, &h.target);
+                }
+            }
+        }
+        app.grid.drag = Drag::Select;
+        app.grid.drag_select = true;
+        if resp.drag_started()
+            && let Some(p) = pos
+        {
+            // The first recognised drag already includes movement away from the press.
+            select_to_pointer(app, geo, sh, wb, p);
+        }
+        return;
+    }
+
+    // Dragging.
+    if resp.dragged()
+        && let Some(p) = pos
+    {
+        // Auto-scroll near edges.
+        let edge = 24.0;
+        let mut auto = egui::Vec2::ZERO;
+        if p.y > geo.cells.bottom() - edge {
+            auto.y = 20.0;
+        }
+        if p.y < geo.cells.top() + edge * 0.5 && !matches!(app.grid.drag, Drag::ResizeRow { .. }) {
+            auto.y = -20.0;
+        }
+        if p.x > geo.cells.right() - edge {
+            auto.x = 30.0;
+        }
+        if p.x < geo.cells.left() + edge * 0.5 && !matches!(app.grid.drag, Drag::ResizeCol { .. }) {
+            auto.x = -30.0;
+        }
+        let pc = CellRef::new(
+            geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)),
+            geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)),
+        );
+        match app.grid.drag.clone() {
+            Drag::Select => {
+                select_to_pointer(app, geo, sh, wb, p);
+                scroll_by(app, auto);
+            }
+            Drag::Rows(anchor) => {
+                let r = geo.row_at(sh, p.y);
+                let _ =
+                    app.session.run("selection.set", json!({"range": RangeRef::rows(anchor.min(r), anchor.max(r)).a1(), "active": sel.active.a1()}));
+                scroll_by(app, vec2(0.0, auto.y));
+            }
+            Drag::Cols(anchor) => {
+                let c = geo.col_at(sh, p.x);
+                let _ =
+                    app.session.run("selection.set", json!({"range": RangeRef::cols(anchor.min(c), anchor.max(c)).a1(), "active": sel.active.a1()}));
+                scroll_by(app, vec2(auto.x, 0.0));
+            }
+            Drag::MoveCols { source, .. } => {
+                let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0));
+                let midpoint = geo.x(sh, col) + sh.col_width(col) * geo.z * 0.5;
+                let before = (col + u32::from(p.x >= midpoint)).min(MAX_COLS - 1);
+                let before = (!(source.start.col..=source.end.col + 1).contains(&before)).then_some(before);
+                app.grid.drag = Drag::MoveCols { source, before };
+                scroll_by(app, vec2(auto.x, 0.0));
+            }
+            Drag::ResizeCol { col, start, orig } => {
+                let w = (orig + (p.x - start) / geo.z).max(0.0);
+                app.toast =
+                    Some((format!("Width: {:.2} ({} pixels)", gridcraft_engine::cmd::format::points_to_chars(w as f64), w.round()), crate::now_ms()));
+                // Inside a selection of whole columns, every selected column takes the new width
+                // (Ctrl-selected areas included); otherwise only the dragged one.
+                let cols = if sel.ranges.iter().any(|r| r.is_full_cols() && col >= r.start.col && col <= r.end.col) {
+                    sel.ranges.iter().filter(|r| r.is_full_cols()).map(|r| r.a1()).collect::<Vec<_>>().join(",")
+                } else {
+                    RangeRef::cols(col, col).a1()
+                };
+                let _ = app.session.run("home.columnWidth", json!({"cols": cols, "width": w.round()}));
+                coalesce_last_undo(app);
+            }
+            Drag::ResizeRow { row, start, orig } => {
+                let h = (orig + (p.y - start) / geo.z).max(0.0);
+                app.toast = Some((format!("Height: {:.2} ({} pixels)", h * 0.75, h.round()), crate::now_ms()));
+                let rows = if sel.ranges.iter().any(|r| r.is_full_rows() && row >= r.start.row && row <= r.end.row) {
+                    sel.ranges
+                        .iter()
+                        .filter(|r| r.is_full_rows())
+                        .map(|r| format!("{}:{}", r.start.row + 1, r.end.row + 1))
+                        .collect::<Vec<_>>()
+                        .join(",")
+                } else {
+                    format!("{}:{}", row + 1, row + 1)
+                };
+                let _ = app.session.run("home.rowHeight", json!({"rows": rows, "height": h.round()}));
+                coalesce_last_undo(app);
+            }
+            Drag::Freeze { cols, .. } => {
+                app.grid.drag = Drag::Freeze { cols, to: Some(freeze_boundary(geo, sh, p, cols)) };
+            }
+            Drag::Fill { menu, .. } => {
+                let src = sel.current();
+                let target = fill_target(src, pc);
+                app.grid.drag = Drag::Fill { target: Some(target), menu };
+                scroll_by(app, auto);
+            }
+            Drag::Move { grab, .. } => {
+                let src = sel.current();
+                let dr = pc.row as i64 - grab.row as i64;
+                let dc = pc.col as i64 - grab.col as i64;
+                app.grid.drag = Drag::Move { grab, to: Some(src.start.offset_clamped(dr, dc)) };
+                scroll_by(app, auto);
+            }
+            Drag::Object { kind, id, start, orig, resize } => {
+                let d = (p - start) / geo.z;
+                let (cell, dx, dy, w, h) = orig;
+                let params = if resize {
+                    json!({"kind": kind, "id": id, "width": (w + d.x).max(20.0), "height": (h + d.y).max(20.0)})
+                } else {
+                    // Re-anchor at the cell under the new top-left.
+                    let x0 = sh.col_left(cell.col) as f32 + dx + d.x;
+                    let y0 = sh.row_top(cell.row) as f32 + dy + d.y;
+                    let nc = CellRef::new(sh.row_at(y0.max(0.0) as f64), sh.col_at(x0.max(0.0) as f64));
+                    json!({"kind": kind, "id": id, "at": nc.a1(), "dx": x0.max(0.0) - sh.col_left(nc.col) as f32, "dy": y0.max(0.0) - sh.row_top(nc.row) as f32})
+                };
+                let _ = app.session.run("object.move", params);
+                coalesce_last_undo(app);
+            }
+            Drag::None => {}
+        }
+    }
+
+    // Release.
+    if resp.drag_stopped() || (!pointer.any_down() && app.grid.drag != Drag::None && !resp.dragged()) {
+        match std::mem::take(&mut app.grid.drag) {
+            Drag::Select => {
+                if resp.drag_stopped()
+                    && let Some(p) = pos
+                {
+                    select_to_pointer(app, geo, sh, wb, p);
+                }
+                format_painter_apply(app);
+            }
+            // Whole rows or columns clicked or dragged over by their headers.
+            Drag::Rows(_) | Drag::Cols(_) => format_painter_apply(app),
+            // Esc mid-drag lands here too (egui ends the drag on Esc): no menu, and the key is
+            // spent on the drag so the grid's Esc doesn't also drop the copy.
+            Drag::Fill { target: Some(t), menu: true } => {
+                if let Some(p) = pos
+                    && t != sel.current()
+                    && !ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape))
+                {
+                    app.grid.fill_menu = Some((sel.current(), t, geo.mirror_pos(p)));
+                }
+            }
+            Drag::Fill { target: Some(t), menu: false } => {
+                let src = sel.current();
+                if t != src {
+                    // Ctrl (Cmd on macOS) swaps copying and extending, as in Excel.
+                    let mode = if mods.command { "alternate" } else { "series" };
+                    match app.run("edit.autoFill", json!({"source": src.a1(), "target": t.a1(), "mode": mode})) {
+                        Ok(_) => set_fill_tag(app, src, t),
+                        Err(e) => app.message = Some(("GridCraft".into(), crate::clean_error(&e))),
+                    }
+                }
+            }
+            Drag::Freeze { cols, to: Some(to) } => {
+                let (rows_now, cols_now) = (geo.fr, geo.fc);
+                let (rows, cols) = if cols { (rows_now, to) } else { (to, cols_now) };
+                if (rows, cols) != (rows_now, cols_now) {
+                    // A1 (nothing left frozen) unfreezes.
+                    app.run_or_alert("view.freezePanes", json!({"cell": CellRef::new(rows, cols).a1()}));
+                }
+            }
+            Drag::Move { to: Some(to), .. } => {
+                let src = sel.current();
+                if to != src.start {
+                    let _ = app.session.run("edit.cut", json!({"range": src.a1()}));
+                    let _ = app.run("edit.paste", json!({"at": to.a1()}));
+                }
+            }
+            Drag::MoveCols { source, before: Some(before) } => {
+                if let Err(e) = app.run("sheet.moveColumns", json!({"cols": source.a1(), "before": before})) {
+                    app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+                }
+            }
+            _ => {}
+        }
+        app.grid.drag_select = false;
+    }
+
+    // Right-click: context menu.
+    if resp.secondary_clicked()
+        && let Some(p) = pos
+    {
+        if in_cells && !sel.contains(geo.cell_at(sh, p)) {
+            let _ = app.session.run("selection.set", json!({"cell": geo.cell_at(sh, p).a1()}));
+        }
+        if in_col_header || in_row_header {
+            let (rows, idx) = if in_row_header { (true, geo.row_at(sh, p.y)) } else { (false, geo.col_at(sh, p.x)) };
+            let inside = sel.ranges.iter().any(|r| {
+                if rows {
+                    r.is_full_rows() && idx >= r.start.row && idx <= r.end.row
+                } else {
+                    r.is_full_cols() && idx >= r.start.col && idx <= r.end.col
+                }
+            });
+            if !inside {
+                let range = if rows { RangeRef::rows(idx, idx) } else { RangeRef::cols(idx, idx) };
+                let _ = app.session.run("selection.set", json!({"range": range.a1()}));
+            }
+            app.grid.header_menu = Some((geo.mirror_pos(p), rows));
+        } else {
+            app.grid.context_menu = Some(geo.mirror_pos(p));
+            app.grid.context_menu_frame = ui.ctx().cumulative_frame_nr();
+        }
+    }
+
+    if primary_clicked || resp.drag_started() {
+        resp.request_focus();
+    }
+    keyboard(app, &ctx, resp, geo, sh);
+}
+
+/// An armed Format Painter pastes onto the cells just clicked or dragged over (not while
+/// pointing a formula reference, which also drags a Select).
+fn format_painter_apply(app: &mut SheetApp) {
+    if app.session.format_painter.is_some()
+        && !app.editor.as_ref().is_some_and(|ed| ed.can_point())
+        && !app.dialog.as_ref().is_some_and(|d| d.picks_references())
+    {
+        let dest = app.session.active().map(|d| d.selection.current().a1());
+        if let Some(dest) = dest
+            && let Err(e) = app.run("edit.formatPainter", json!({"apply": dest}))
+        {
+            app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+        }
+    }
+}
+
+/// Point mode on a header: inserts a whole-row or whole-column reference instead of selecting.
+fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, extend: bool, add: bool) -> bool {
+    let Some(ed) = app.editor.as_mut().filter(|ed| ed.can_point()) else { return false };
+    let edit_sheet = ed.sheet;
+    let active_sheet = wb.active_sheet();
+    let range = if extend {
+        ed.point
+            .and_then(|point| crate::editor::formula_refs(&ed.text).into_iter().find(|(start, end, ..)| (*start, *end) == point))
+            .and_then(|(_, _, previous, previous_sheet, _)| {
+                let previous_sheet = previous_sheet.as_deref().map(|name| wb.sheet_index(name)).unwrap_or(Some(edit_sheet));
+                if previous_sheet != Some(active_sheet) {
+                    return None;
+                }
+                if range.is_full_cols() && previous.is_full_cols() {
+                    Some(RangeRef::cols(previous.start.col.min(range.start.col), previous.end.col.max(range.end.col)))
+                } else if range.is_full_rows() && previous.is_full_rows() {
+                    Some(RangeRef::rows(previous.start.row.min(range.start.row), previous.end.row.max(range.end.row)))
+                } else {
+                    None
+                }
+            })
+            .unwrap_or(range)
+    } else {
+        range
+    };
+    let reference = range.a1();
+    let reference =
+        if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference };
+    if add {
+        ed.append_ref(&reference);
+    } else {
+        ed.insert_ref(&reference);
+    }
+    ed.point_anchor = None;
+    ed.point_cell = Some(range.start);
+    ed.request_focus = true;
+    true
+}
+
+fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p: Pos2) {
+    let cell = CellRef::new(
+        geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)),
+        geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)),
+    );
+    if let Some(d) = app.dialog.as_mut().filter(|d| d.picks_references()) {
+        d.pick_reference(cell, &sh.name, true);
+    } else if let Some(ed) = app.editor.as_mut()
+        && ed.point.is_some()
+    {
+        if let Some(start) = ed.point_anchor.filter(|(sheet, _)| *sheet == wb.active_sheet()).map(|(_, cell)| cell).or(ed.point_cell) {
+            let range = RangeRef::new(start, cell);
+            let text = if range.is_single() { range.start.a1() } else { range.a1() };
+            let text = if ed.sheet != wb.active_sheet() { format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { text };
+            ed.insert_ref(&text);
+            ed.point_cell = Some(cell);
+            ed.point_anchor = Some((wb.active_sheet(), start));
+        }
+    } else if let Some(d) = app.session.active() {
+        // Read the current anchor: starting a drag may have just replaced the selection.
+        let anchor = d.selection.anchor;
+        let active = d.selection.active;
+        let mut ranges: Vec<String> = d.selection.ranges.iter().map(|r| r.a1()).collect();
+        ranges.pop();
+        ranges.push(RangeRef::new(anchor, cell).a1());
+        let _ = app.session.run("selection.set", json!({"range": ranges.join(","), "active": active.a1()}));
+        if let Some(d) = app.session.active_mut() {
+            d.selection.anchor = anchor;
+        }
+    }
+}
+
+fn coalesce_last_undo(app: &mut SheetApp) {
+    // Merge consecutive drag steps into one undo entry.
+    if let Some(d) = app.session.active_mut()
+        && d.undo.len() >= 2
+    {
+        let n = d.undo.len();
+        if d.undo[n - 1].label == d.undo[n - 2].label {
+            d.undo.remove(n - 1);
+        }
+    }
+}
+
+fn scroll_by(app: &mut SheetApp, d: egui::Vec2) {
+    if d != egui::Vec2::ZERO
+        && let Some(v) = app.view_mut()
+    {
+        v.scroll = (v.scroll + d).max(egui::Vec2::ZERO);
+    }
+}
+
+fn fill_target(src: RangeRef, pc: CellRef) -> RangeRef {
+    let below = pc.row as i64 - src.end.row as i64;
+    let above = src.start.row as i64 - pc.row as i64;
+    let right = pc.col as i64 - src.end.col as i64;
+    let left = src.start.col as i64 - pc.col as i64;
+    let vert = below.max(above);
+    let horiz = right.max(left);
+    if vert <= 0 && horiz <= 0 {
+        return src;
+    }
+    if vert >= horiz {
+        if below > 0 {
+            RangeRef::new(src.start, CellRef::new(pc.row, src.end.col))
+        } else {
+            RangeRef::new(CellRef::new(pc.row, src.start.col), src.end)
+        }
+    } else if right > 0 {
+        RangeRef::new(src.start, CellRef::new(src.end.row, pc.col))
+    } else {
+        RangeRef::new(CellRef::new(src.start.row, pc.col), src.end)
+    }
+}
+
+pub(super) fn on_border(r: Rect, p: Pos2) -> bool {
+    let outer = r.expand(3.0);
+    let inner = r.shrink(3.0);
+    outer.contains(p) && !inner.contains(p)
+}
+
+/// The freeze handles, as in Excel for the web: a bar in the upper part of the column-header strip
+/// on the frozen columns' right edge, and one in the left part of the row-header strip on the
+/// frozen rows' bottom edge. With nothing frozen they sit on the corner's edges. The rest of the
+/// header edge keeps resizing the column or row.
+pub fn freeze_handles(geo: &Geo) -> (Rect, Rect) {
+    let x = geo.cells.left() + geo.frozen_w;
+    let y = geo.cells.top() + geo.frozen_h;
+    let cols = Rect::from_min_max(pos2(x - 3.0, geo.head_top()), pos2(x + 3.0, geo.head_top() + geo.header_h * 0.4));
+    let rows = Rect::from_min_max(pos2(geo.head_left(), y - 3.0), pos2(geo.head_left() + geo.header_w * 0.4, y + 3.0));
+    (cols, rows)
+}
+
+/// How many columns (or rows) a freeze handle dropped at `p` freezes: the line boundary nearest
+/// the pointer, limited so the frozen pane leaves room for the scrolling one.
+fn freeze_boundary(geo: &Geo, sh: &Sheet, p: Pos2, cols: bool) -> u32 {
+    if cols {
+        if p.x <= geo.cells.left() {
+            return 0;
+        }
+        let c = geo.col_at(sh, p.x);
+        let (l, r) = (geo.x(sh, c), geo.x(sh, c.saturating_add(1).min(MAX_COLS - 1)));
+        let b = if p.x - l > r - p.x { c.saturating_add(1) } else { c };
+        let room = geo.ci.at((((geo.cells.width() - 40.0) / geo.z).max(0.0)) as f64);
+        b.min(room).min(MAX_COLS - 1)
+    } else {
+        if p.y <= geo.cells.top() {
+            return 0;
+        }
+        let rr = geo.row_at(sh, p.y);
+        let (t, b2) = (geo.y(sh, rr), geo.y(sh, rr.saturating_add(1).min(MAX_ROWS - 1)));
+        let b = if p.y - t > b2 - p.y { rr.saturating_add(1) } else { rr };
+        let room = geo.ri.at((((geo.cells.height() - 40.0) / geo.z).max(0.0)) as f64);
+        b.min(room).min(MAX_ROWS - 1)
+    }
+}
+
+/// Paints the freeze handles and, while one is dragged, where the freeze line will go.
+pub(super) fn paint_freeze_handles(p: &Painter, geo: &Geo, sh: &Sheet, drag: &Drag, t: &Tokens) {
+    let (cols, rows) = freeze_handles(geo);
+    let bar = Color32::from_gray(150);
+    p.rect_filled(Rect::from_center_size(cols.center(), vec2(3.0, cols.height())), 1.0, bar);
+    p.rect_filled(Rect::from_center_size(rows.center(), vec2(rows.width(), 3.0)), 1.0, bar);
+    if let Drag::Freeze { cols, to: Some(to) } = *drag {
+        let stroke = Stroke::new(2.0, t.accent);
+        if cols {
+            let x = geo.cells.left() + sh.col_left(to) as f32 * geo.z;
+            p.line_segment([pos2(x, geo.head_top()), pos2(x, geo.cells.bottom())], stroke);
+        } else {
+            let y = geo.cells.top() + sh.row_top(to) as f32 * geo.z;
+            p.line_segment([pos2(geo.head_left(), y), pos2(geo.cells.right(), y)], stroke);
+        }
+    }
+}
+
+pub(super) fn col_edge(geo: &Geo, sh: &Sheet, x: f32) -> Option<(u32, f32)> {
+    let c = geo.col_at(sh, x);
+    for cc in [c, c.saturating_sub(1)] {
+        let edge = geo.x(sh, cc) + sh.col_width(cc) * geo.z;
+        if (x - edge).abs() <= 4.0 {
+            return Some((cc, edge));
+        }
+    }
+    None
+}
+
+pub(super) fn row_edge(geo: &Geo, sh: &Sheet, y: f32) -> Option<(u32, f32)> {
+    let r = geo.row_at(sh, y);
+    for rr in [r, r.saturating_sub(1)] {
+        let edge = geo.y(sh, rr) + sh.row_height(rr) * geo.z;
+        if (y - edge).abs() <= 3.0 {
+            return Some((rr, edge));
+        }
+    }
+    None
+}
+
+/// The hidden column whose (zero-width) edge is at `x`: only just right of the boundary, as the
+/// edge just left of it belongs to the visible column there.
+pub(super) fn hidden_col_edge(geo: &Geo, sh: &Sheet, x: f32) -> Option<u32> {
+    col_edge(geo, sh, x).map(|(c, _)| c).filter(|&c| sh.col_width(c) <= 0.0)
+}
+
+pub(super) fn hidden_row_edge(geo: &Geo, sh: &Sheet, y: f32) -> Option<u32> {
+    row_edge(geo, sh, y).map(|(r, _)| r).filter(|&r| sh.row_height(r) <= 0.0)
+}
+
+fn object_anchor(sh: &Sheet, kind: &str, id: u32) -> Option<gridcraft_engine::model::Anchor> {
+    match kind {
+        "chart" => sh.charts.iter().find(|c| c.id == id).map(|c| c.anchor),
+        "image" => sh.images.iter().find(|c| c.id == id).map(|c| c.anchor),
+        "slicer" => sh.slicers.iter().find(|c| c.id == id).map(|c| c.anchor),
+        _ => sh.shapes.iter().find(|c| c.id == id).map(|c| c.anchor),
+    }
+}
+
+pub(super) fn delete_selected_object(app: &mut SheetApp, sh: &Sheet) -> bool {
+    let Some(id) = app.selected_chart else { return false };
+    let kind = if sh.charts.iter().any(|object| object.id == id) {
+        "chart"
+    } else if sh.images.iter().any(|object| object.id == id) {
+        "image"
+    } else if sh.shapes.iter().any(|object| object.id == id) {
+        "shape"
+    } else {
+        return false;
+    };
+    app.run_or_alert("object.delete", json!({"kind": kind, "id": id}));
+    app.selected_chart = None;
+    true
+}
+
+/// A click on a hyperlink. References select; web and e-mail addresses ask first (the dialog's
+/// OK runs `link.open`); every other kind is refused with a message. The decision is the
+/// engine's ([`gridcraft_engine::links::classify`]), the same one `link.open` applies.
+pub fn follow_link(app: &mut SheetApp, target: &str) {
+    use gridcraft_engine::links::{LinkKind, classify};
+    match classify(target) {
+        LinkKind::Internal(r) => {
+            let _ = app.session.run("edit.goTo", json!({"reference": r.trim_start_matches('#')}));
+            app.grid.ensure_visible = true;
+        }
+        LinkKind::External(url) => app.open_dialog("openLink", json!({"url": url})),
+        LinkKind::Refused(why) => app.message = Some(("Hyperlink".into(), why)),
+    }
+}
+
+/// Used by `EditState` users to keep the active cell visible while pointing.
+pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, extend: bool) {
+    let Some(d) = app.session.active() else { return };
+    let from = ed.point_cell.unwrap_or(ed.cell);
+    let to = from.offset_clamped(dr, dc);
+    let anchor = if extend {
+        // The anchor is the corner opposite the moving end: the written range is normalized, so
+        // after extending up or left its first cell is the moving end, not the anchor.
+        let pointed = ed.point.and_then(|(s, e)| ed.text.get(s..e)).and_then(RangeRef::parse);
+        let inferred_anchor = pointed
+            .map(|r| {
+                CellRef::new(
+                    if from.row == r.start.row { r.end.row } else { r.start.row },
+                    if from.col == r.start.col { r.end.col } else { r.start.col },
+                )
+            })
+            .unwrap_or(from);
+        ed.point_anchor.filter(|(sheet, _)| *sheet == d.wb.active_sheet()).map(|(_, cell)| cell).unwrap_or(inferred_anchor)
+    } else {
+        to
+    };
+    let text = if extend { RangeRef::new(anchor, to).a1() } else { to.a1() };
+    let sheet = d.wb.active_sheet();
+    ed.insert_ref(&text);
+    ed.point_cell = Some(to);
+    ed.point_anchor = Some((sheet, anchor));
+    app.grid.ensure_visible = true;
+}
diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs
new file mode 100644
index 000000000..6cb4a8c9c
--- /dev/null
+++ b/crates/ui-egui/src/grid/keyboard.rs
@@ -0,0 +1,155 @@
+use super::geo::Geo;
+use super::interact::delete_selected_object;
+use super::menus::is_checkbox;
+use super::*;
+
+/// Grid keyboard handling when no text field has focus.
+pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Response, geo: &Geo, sh: &Sheet) {
+    // Focus left on an editor that no longer exists goes back to the grid.
+    let stale = [egui::Id::unique("gridcraft.cell_editor"), egui::Id::unique("gridcraft.formula_bar"), crate::text_box::editor_id()];
+    let editing = app.editor.is_some() || app.text_box_editor.is_some();
+    if !editing && ctx.memory(|m| m.focused()).is_some_and(|f| stale.contains(&f)) {
+        resp.request_focus();
+    }
+    let other_focus = ctx.memory(|m| m.focused()).is_some_and(|f| f != resp.id && (editing || !stale.contains(&f)));
+    // An open filter menu owns the keyboard even when a click inside it left focus on nothing (#1516).
+    // So do the fill menu (its Esc closes it, not the copy) and the right-drag that opens it (an
+    // arrow key would move the selection the menu fills from).
+    if editing
+        || app.dialog.is_some()
+        || other_focus
+        || app.message.is_some()
+        || app.grid.filter_menu.is_some()
+        || app.grid.fill_menu.is_some()
+        || matches!(app.grid.drag, Drag::Fill { menu: true, .. })
+    {
+        return;
+    }
+    if ctx.memory(|m| m.focused()).is_none() {
+        resp.request_focus();
+    }
+    // The grid owns arrows, Tab and Escape (egui would otherwise move focus between widgets).
+    ctx.memory_mut(|m| {
+        m.set_focus_lock_filter(resp.id, egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, escape: true })
+    });
+    let events = ctx.input(|i| i.events.clone());
+    // A shortcut key that also types a character (Shift+Space sends Text(" ")) must not start an edit.
+    let shortcut_pressed = events.iter().any(|e| {
+        matches!(e, egui::Event::Key { pressed: true, modifiers: m, key, .. }
+            if !m.alt && (m.ctrl || m.command || (m.shift && *key == egui::Key::Space)))
+    });
+    let page = ((geo.cells.height() / geo.z) / sh.default_row_height).floor().max(1.0) as i64;
+    // Alt shortcuts type their character too on Windows and Linux (Alt+= sends Text("=")): once
+    // a shortcut ran, that text must not start an edit over what it just did.
+    let mut shortcut_ran = false;
+    for ev in events {
+        match ev {
+            egui::Event::Copy => {
+                app.copy_to_clipboard(ctx, "edit.copy");
+            }
+            egui::Event::Cut => {
+                app.copy_to_clipboard(ctx, "edit.cut");
+            }
+            egui::Event::Paste(text) => app.paste_external(text),
+            // GridCraft has no image-clipboard pipeline and no cell-picture insert-from-clipboard
+            // command. Choosing to ignore `PasteImage` is explicit: inserting the bytes as a
+            // floating picture without a chosen anchor/size would be a new feature, not parity.
+            // A text representation, when the clipboard has one, still arrives as `Paste` above.
+            egui::Event::PasteImage(_) => {}
+            // PRIMARY middle-click paste belongs to egui's TextEdit; the grid has no caret to
+            // insert text at, so a middle click on a cell is deliberately not a paste.
+            egui::Event::MiddleClickPaste { .. } => {}
+            egui::Event::Text(_) if shortcut_pressed || shortcut_ran => {}
+            egui::Event::Text(text) if text.chars().all(|c| !c.is_control()) && !text.is_empty() => {
+                app.begin_edit(Some(text), false);
+                if let Some(ed) = app.editor.as_mut() {
+                    ed.caret = ed.text.chars().count();
+                }
+                return;
+            }
+            egui::Event::Key { key, physical_key, pressed: true, modifiers: m, .. } => {
+                use egui::Key;
+                if crate::keymap::dispatch(app, ctx, key, physical_key, m, geo, sh) {
+                    shortcut_ran = true;
+                    continue;
+                }
+                let cmd = m.command;
+                let shift = m.shift;
+                let mv = |app: &mut SheetApp, dr: i64, dc: i64| {
+                    let from = app.session.active().map(|d| if shift { d.selection.moving_end() } else { d.selection.active });
+                    let _ = app.session.run("selection.move", json!({"dr": dr, "dc": dc, "extend": shift, "jump": cmd}));
+                    app.grid.ensure_visible = true;
+                    app.grid.reveal_moving_end = shift;
+                    app.grid.reveal_from = from;
+                };
+                match key {
+                    Key::ArrowUp => mv(app, -1, 0),
+                    Key::ArrowDown => mv(app, 1, 0),
+                    // Arrows follow the screen: on a right-to-left sheet Left goes to the next column.
+                    Key::ArrowLeft => mv(app, 0, if sh.right_to_left { 1 } else { -1 }),
+                    Key::ArrowRight => mv(app, 0, if sh.right_to_left { -1 } else { 1 }),
+                    Key::PageDown if !cmd => mv(app, page, 0),
+                    Key::PageUp if !cmd => mv(app, -page, 0),
+                    Key::PageDown => app.run_or_alert("sheet.next", json!({})),
+                    Key::PageUp => app.run_or_alert("sheet.previous", json!({})),
+                    Key::Home if cmd => {
+                        let r = sh.freeze.map(|f| f.0).unwrap_or(0);
+                        let c = sh.freeze.map(|f| f.1).unwrap_or(0);
+                        let _ = app.session.run("selection.set", json!({"cell": CellRef::new(r, c).a1()}));
+                        app.grid.ensure_visible = true;
+                    }
+                    Key::End if cmd => {
+                        let end = sh.used_range().map(|u| u.end).unwrap_or_default();
+                        let _ = app.session.run("selection.set", json!({"cell": end.a1()}));
+                        app.grid.ensure_visible = true;
+                    }
+                    Key::Home => {
+                        let a = app.session.active().map(|d| d.selection.active).unwrap_or_default();
+                        let _ = app.session.run("selection.set", json!({"cell": CellRef::new(a.row, 0).a1()}));
+                        app.grid.ensure_visible = true;
+                    }
+                    // Excel: Enter while a copied range is marked pastes it and ends copy mode.
+                    Key::Enter if !m.alt && !m.ctrl && !shift && !cmd && app.session.clipboard.is_some() => {
+                        app.run_or_alert("edit.paste", json!({}));
+                        app.session.clipboard = None;
+                        app.grid.ensure_visible = true;
+                    }
+                    Key::Enter => {
+                        if m.alt || m.ctrl {
+                            app.begin_edit(None, false);
+                        } else {
+                            app.move_after_enter(if shift { -1 } else { 1 }, 0);
+                        }
+                    }
+                    Key::Tab => app.move_after_enter(0, if shift { -1 } else { 1 }),
+                    Key::F2 => app.begin_edit(None, false),
+                    Key::Delete if delete_selected_object(app, sh) => {}
+                    Key::Delete => app.run_or_alert("edit.clearContents", json!({})),
+                    Key::Backspace if delete_selected_object(app, sh) => {}
+                    Key::Backspace => {
+                        // Excel for Mac: Delete clears the cell and starts editing it.
+                        app.run_or_alert("edit.clearContents", json!({}));
+                        if app.session.active().is_some_and(|d| d.selection.is_single_cell()) {
+                            app.begin_edit(Some(String::new()), false);
+                        }
+                    }
+                    Key::Escape => {
+                        app.session.clipboard = None;
+                        app.session.format_painter = None;
+                    }
+                    Key::Space if !cmd && !shift && is_checkbox(sh, app) => app.run_or_alert("cell.toggleCheckbox", json!({})),
+                    Key::F8 if m.alt => {
+                        app.open_dialog("macros", json!({}));
+                    }
+                    Key::F9 => app.run_or_alert("formulas.calculateNow", json!({})),
+                    Key::F4 if !cmd => {}
+                    _ if cmd && !crate::keymap::altgr_text(ctx, m, ctx.os() == egui::os::OperatingSystem::Mac) => {
+                        crate::ribbon::shortcut(app, key, m)
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+    }
+}
diff --git a/crates/ui-egui/src/grid/menus.rs b/crates/ui-egui/src/grid/menus.rs
new file mode 100644
index 000000000..b239c7eac
--- /dev/null
+++ b/crates/ui-egui/src/grid/menus.rs
@@ -0,0 +1,551 @@
+use super::editor::popup_dismissed;
+use super::geo::Geo;
+use super::tables::filter_table_range;
+use super::*;
+
+/// Draws the filter-header popup: sort, search/select-all, apply/clear, a lazily installed table autofilter, new-open search focus and dismissal.
+pub(super) fn filter_menu(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_open: bool) {
+    let Some((col, row, at)) = app.grid.filter_menu else { return };
+    let Some(d) = app.session.active() else { return };
+    let wb = d.wb.clone();
+    let si = wb.active_sheet();
+    let Some(sh) = wb.sheet(si) else { return };
+    let _ = geo;
+    // Tables get an autofilter on demand.
+    let table_range = filter_table_range(sh, col, row);
+    if sh.autofilter.is_none()
+        && let Some(r) = table_range
+    {
+        let _ = app.session.run("data.filter", json!({"range": r.a1()}));
+        let _ = app.session.run("data.filter", json!({"range": r.a1()}));
+        if let Some(sh2) = app.session.active().and_then(|d| d.wb.active()).map(|s| s.autofilter.is_some())
+            && !sh2
+        {
+            let d = app.session.active_mut();
+            if let Some(d) = d {
+                let wbm = Arc::make_mut(&mut d.wb);
+                if let Some(s) = wbm.sheet_mut(si) {
+                    s.autofilter = Some(gridcraft_engine::model::AutoFilter { range: r, criteria: vec![] });
+                }
+            }
+        }
+    }
+    let wb = app.session.active().map(|d| d.wb.clone()).unwrap_or(wb);
+    let values = gridcraft_engine::cmd::data::filter_values(&wb, si, col);
+    let key = egui::Id::unique(("filter_sel", col));
+    let search_key = egui::Id::unique(("filter_search", col));
+    let buttons_key = egui::Id::unique(("filter_buttons", col));
+    // Enter is the menu's OK, as in Excel: taken before the search box (which would only drop its
+    // focus) and the value checkboxes (which would toggle) see it. A focused button keeps it as its click.
+    let buttons: Vec<egui::Id> = ui.ctx().data_mut(|d| d.get_temp(buttons_key)).unwrap_or_default();
+    let on_button = ui.ctx().memory(|m| m.focused()).is_some_and(|f| buttons.contains(&f));
+    let enter = !on_button && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Enter));
+    let mut close = false;
+    let area = egui::Area::new(egui::Id::unique("filter_menu")).fixed_pos(at + vec2(-180.0, 10.0)).order(egui::Order::Foreground);
+    let response = area.show(ui.ctx(), |ui| {
+        egui::Frame::popup(ui.style()).show(ui, |ui| {
+            ui.set_width(230.0);
+            let ascending = ui.button("↑  Sort Ascending");
+            if ascending.clicked() {
+                let _ = app.run("data.sortAscending", json!({"column": col_to_letters(col)}));
+                close = true;
+            }
+            let descending = ui.button("↓  Sort Descending");
+            if descending.clicked() {
+                let _ = app.run("data.sortDescending", json!({"column": col_to_letters(col)}));
+                close = true;
+            }
+            ui.separator();
+            ui.label(egui::RichText::new("Filter").strong());
+            let mut checks: Vec<(String, bool)> = ui.ctx().data_mut(|d| d.get_temp::<Vec<(String, bool)>>(key)).unwrap_or(values.clone());
+            // A search narrows the list; Select All and Apply then only cover the matches.
+            let mut search: String = ui.ctx().data_mut(|d| d.get_temp(search_key)).unwrap_or_default();
+            let field = ui.add(egui::TextEdit::singleline(&mut search).hint_text("Search").desired_width(f32::INFINITY));
+            if !was_open {
+                field.request_focus();
+            }
+            let needle = search.trim().to_lowercase();
+            let matches = |v: &str| needle.is_empty() || v.to_lowercase().contains(&needle);
+            let all = checks.iter().filter(|(v, _)| matches(v)).all(|(_, b)| *b);
+            let mut all_new = all;
+            let label = if needle.is_empty() { "(Select All)" } else { "(Select All Search Results)" };
+            if ui.checkbox(&mut all_new, label).changed() {
+                for c in checks.iter_mut().filter(|(v, _)| matches(v)) {
+                    c.1 = all_new;
+                }
+            }
+            // Full width: shrunk to the longest value, the scroll bar sat mid-menu and the wheel only
+            // worked over the values themselves (#432).
+            egui::ScrollArea::vertical().max_height(220.0).auto_shrink([false, true]).show(ui, |ui| {
+                for (v, on) in checks.iter_mut().filter(|(v, _)| matches(v)) {
+                    ui.checkbox(on, v.as_str());
+                }
+            });
+            ui.ctx().data_mut(|d| {
+                d.insert_temp(key, checks.clone());
+                d.insert_temp(search_key, search.clone());
+            });
+            let checks: Vec<(String, bool)> = checks.iter().map(|(v, on)| (v.clone(), *on && matches(v))).collect();
+            ui.separator();
+            ui.horizontal(|ui| {
+                let clear = ui.button("Clear Filter");
+                if clear.clicked() {
+                    let _ = app.run("data.filterBy", json!({"column": col_to_letters(col), "clear": true}));
+                    close = true;
+                }
+                // Nothing checked would hide every row, so Enter (unlike a click on Apply) does nothing then.
+                let any = checks.iter().any(|(_, on)| *on);
+                let apply = ui.button("Apply");
+                ui.ctx().data_mut(|d| d.insert_temp(buttons_key, vec![ascending.id, descending.id, clear.id, apply.id]));
+                if apply.clicked() || (enter && any) {
+                    let blanks = checks.iter().any(|(v, on)| v == "(Blanks)" && *on);
+                    let vals: Vec<String> = checks.iter().filter(|(v, on)| *on && v != "(Blanks)").map(|(v, _)| v.clone()).collect();
+                    let p = if checks.iter().all(|(_, b)| *b) {
+                        json!({"column": col_to_letters(col), "clear": true})
+                    } else {
+                        json!({"column": col_to_letters(col), "values": vals, "blanks": blanks})
+                    };
+                    let _ = app.run("data.filterBy", p);
+                    close = true;
+                }
+            });
+        });
+    });
+    if close || popup_dismissed(&response.response, was_open) {
+        ui.ctx().data_mut(|d| {
+            d.remove::<Vec<(String, bool)>>(key);
+            d.remove::<String>(search_key);
+            d.remove::<Vec<egui::Id>>(buttons_key);
+        });
+        app.grid.filter_menu = None;
+    }
+}
+
+/// Draws and dispatches the cell context menu, including Show Details when offered, clipboard and insert/format actions; closes on Esc or an outside press.
+pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
+    let Some(at) = app.grid.context_menu else { return };
+    let mut close = false;
+    let resp = egui::Area::new(egui::Id::unique("cell_context")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
+        egui::Frame::popup(ui.style()).show(ui, |ui| {
+            ui.set_min_width(200.0);
+            let insert_copied = insert_copied_item(app);
+            let mut items: Vec<(&str, &str)> = vec![
+                ("Cut", "edit.cut"),
+                ("Copy", "edit.copy"),
+                ("Paste", "edit.paste"),
+                ("Paste Special…", "ui:pasteSpecial"),
+                ("-", ""),
+                ("Insert…", "ui:insertCells"),
+                ("Delete…", "ui:deleteCells"),
+                ("Clear Contents", "edit.clearContents"),
+                ("-", ""),
+                ("Filter by Selected Cell's Value", "ui:filterValue"),
+                ("Sort A to Z", "data.sortAscending"),
+                ("Sort Z to A", "data.sortDescending"),
+                ("-", ""),
+                ("New Comment", "ui:newComment"),
+                ("New Note", "ui:newNote"),
+                ("-", ""),
+                ("Format Cells…", "ui:formatCells"),
+                ("Pick From Drop-down List…", "ui:pickList"),
+                ("Define Name…", "ui:defineName"),
+                ("Link…", "ui:insertLink"),
+            ];
+            if let Some(item) = insert_copied {
+                items.insert(6, item);
+            }
+            if show_details_offered(app)
+                && let Some(i) = items.iter().position(|(_, id)| *id == "data.sortDescending")
+            {
+                items.insert(i + 1, ("-", ""));
+                items.insert(i + 2, ("Show Details", "pivot.showDetails"));
+            }
+            let lang = crate::i18n::current(ui.ctx());
+            for (label, id) in items {
+                if label == "-" {
+                    ui.separator();
+                    continue;
+                }
+                if ui.add(egui::Button::new(lang.tr(label)).frame_when_inactive(false).min_size(vec2(190.0, 20.0))).clicked() {
+                    close = true;
+                    match id {
+                        "ui:pasteSpecial" => app.open_dialog("pasteSpecial", json!({})),
+                        "ui:insertPaste" => app.open_dialog("insertPaste", json!({})),
+                        "ui:insertCells" => app.open_dialog("insertCells", json!({})),
+                        "ui:deleteCells" => app.open_dialog("deleteCells", json!({})),
+                        "ui:formatCells" => app.open_dialog("formatCells", json!({})),
+                        "ui:newComment" => app.open_dialog("comment", json!({"threaded": true})),
+                        "ui:newNote" => app.open_dialog("comment", json!({"threaded": false})),
+                        "ui:defineName" => app.open_dialog("defineName", json!({})),
+                        "ui:insertLink" => app.open_dialog("insertLink", json!({})),
+                        "ui:pickList" => app.open_dialog("pickList", json!({})),
+                        "ui:filterValue" => {
+                            if let Some(d) = app.session.active() {
+                                let a = d.selection.active;
+                                let text = d.wb.active().map(|sh| gridcraft_engine::display::cell_text(&d.wb, sh, a)).unwrap_or_default();
+                                let has = d.wb.active().is_some_and(|sh| sh.autofilter.is_some());
+                                if !has {
+                                    let _ = app.run("data.filter", json!({}));
+                                }
+                                app.run_or_alert("data.filterBy", json!({"column": col_to_letters(a.col), "values": [text]}));
+                            }
+                        }
+                        "edit.copy" | "edit.cut" => {
+                            app.copy_to_clipboard(ui.ctx(), id);
+                        }
+                        "edit.paste" => app.paste_from_clipboard(),
+                        other => app.run_or_alert(other, json!({})),
+                    }
+                }
+            }
+        });
+    });
+    // A quick right-click presses and releases in one frame, and the menu's corner snaps to the
+    // nearest physical pixel, which can put the pointer just outside it: that press opened the
+    // menu, so it doesn't count as a click elsewhere.
+    let opened_now = app.grid.context_menu_frame == ui.ctx().cumulative_frame_nr();
+    if close
+        || ui.input(|i| i.key_pressed(egui::Key::Escape))
+        || (!opened_now
+            && ui.input(|i| i.pointer.any_pressed())
+            && !resp.response.contains_pointer()
+            && !resp.response.hovered()
+            && ui.input(|i| i.pointer.interact_pos()).is_some_and(|p| !resp.response.rect.contains(p)))
+    {
+        app.grid.context_menu = None;
+    }
+}
+
+/// Whether the cell menu offers Show Details (Excel's right-click › Show Details): the active cell
+/// is a value, subtotal or grand total cell of a PivotTable, or a cell of a report that is out of
+/// date, where running the command says so. Labels and headers of a current report don't offer it,
+/// and no cell does while the PivotTable's Enable show details option is off.
+fn show_details_offered(app: &mut SheetApp) -> bool {
+    let Some(d) = app.session.active() else { return false };
+    let (si, at) = (d.wb.active_sheet(), d.selection.active);
+    let Some((pi, pt)) = d.wb.active().and_then(|sh| sh.pivots.iter().enumerate().find(|(_, pt)| pt.last_range.is_some_and(|r| r.contains(at))))
+    else {
+        return false;
+    };
+    if !pt.enable_show_details {
+        return false;
+    }
+    let origin = pt.last_range.map(|r| r.start).unwrap_or_default();
+    let cell = (at.row.saturating_sub(origin.row), at.col.saturating_sub(origin.col));
+    let key = (d.uid, d.revision, si, pi);
+    if let Some((k, cells)) = &app.grid.show_details_cells
+        && *k == key
+    {
+        return cells.as_ref().is_none_or(|c| c.contains(&cell));
+    }
+    let cells = gridcraft_engine::pivot::detail_cells(&d.wb, pt, si).ok();
+    let on = cells.as_ref().is_none_or(|c| c.contains(&cell));
+    app.grid.show_details_cells = Some((key, cells));
+    on
+}
+
+/// The ways to fill a dragged range, as the fill menu and the Auto Fill Options button list them.
+const FILL_MODES: [(&str, &str); 4] =
+    [("Copy Cells", "copy"), ("Fill Series", "extend"), ("Fill Formatting Only", "formats"), ("Fill Without Formatting", "values")];
+
+/// The ways to fill from a date, which both menus add after [`FILL_MODES`] when the source starts
+/// with one.
+const DATE_FILL_MODES: [(&str, &str); 4] = [("Fill Days", "days"), ("Fill Weekdays", "weekdays"), ("Fill Months", "months"), ("Fill Years", "years")];
+
+/// The fill modes the menus list for a fill from `src` on the active sheet.
+fn fill_modes(app: &SheetApp, src: RangeRef) -> Vec<(&'static str, &'static str)> {
+    let dates = app.session.active().is_some_and(|d| gridcraft_engine::fill::starts_with_date(&d.wb, d.wb.active_sheet(), src));
+    FILL_MODES.into_iter().chain(DATE_FILL_MODES.into_iter().filter(|_| dates)).collect()
+}
+
+/// Remembers the fill just made so the Auto Fill Options button can offer the other ways.
+pub(super) fn set_fill_tag(app: &mut SheetApp, src: RangeRef, target: RangeRef) {
+    app.grid.fill_tag =
+        app.session.active().map(|d| FillTag { src, target, uid: d.uid, sheet: d.wb.active_sheet(), revision: d.revision, undo_len: d.undo.len() });
+}
+
+/// The Auto Fill Options button below the bottom-right corner of cells a left-drag of the fill
+/// handle just filled. Its menu redoes that fill as Copy Cells, Fill Series, Fill Formatting Only
+/// or Fill Without Formatting, and from a date also as Fill Days, Fill Weekdays, Fill Months or
+/// Fill Years: it undoes the drag's fill, then runs `edit.autoFill` in that mode.
+/// The button goes away as soon as anything else changes the workbook or the selection moves.
+pub(super) fn fill_options_tag(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet) {
+    let Some(tag) = app.grid.fill_tag.clone() else { return };
+    let current = app.session.active().is_some_and(|d| {
+        d.uid == tag.uid
+            && d.wb.active_sheet() == tag.sheet
+            && d.revision == tag.revision
+            && d.undo.len() == tag.undo_len
+            && d.selection.ranges.len() == 1
+            && d.selection.ranges.first().is_some_and(|r| *r == tag.target)
+    });
+    if !current {
+        app.grid.fill_tag = None;
+        return;
+    }
+    if app.editor.is_some() || app.dialog.is_some() || app.grid.drag != Drag::None {
+        return;
+    }
+    let size = vec2(18.0, 18.0);
+    let corner = geo.range_rect(sh, tag.target).right_bottom();
+    let button = geo.mirror_rect(Rect::from_min_size(corner + vec2(2.0, 2.0), size));
+    // `button` is in screen space, so compare it with the mirrored cells area.
+    if !geo.mirror_rect(geo.cells).contains_rect(button) {
+        return;
+    }
+    let lang = crate::i18n::current(ui.ctx());
+    let resp = ui.interact(button, egui::Id::unique("gridcraft.fill_options_tag"), Sense::click()).on_hover_text(lang.tr("Auto Fill Options"));
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, lang.tr("Auto Fill Options")));
+    let t = Tokens::get(ui.ctx());
+    let p = ui.painter();
+    p.rect_filled(button, 3.0, if resp.hovered() { t.hover } else { t.window });
+    p.rect_stroke(button, 3.0, Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
+    // Two small cells and a drop-down arrow.
+    let c = button.center();
+    p.rect_stroke(Rect::from_min_size(pos2(c.x - 6.0, c.y - 6.0), vec2(6.0, 6.0)), 0.0, Stroke::new(1.0, t.text), egui::StrokeKind::Inside);
+    p.rect_stroke(Rect::from_min_size(pos2(c.x - 3.0, c.y - 3.0), vec2(6.0, 6.0)), 0.0, Stroke::new(1.0, t.text), egui::StrokeKind::Inside);
+    p.add(egui::Shape::convex_polygon(
+        vec![pos2(c.x + 1.0, c.y + 5.0), pos2(c.x + 7.0, c.y + 5.0), pos2(c.x + 4.0, c.y + 8.0)],
+        t.text,
+        Stroke::NONE,
+    ));
+    let mut chosen = None;
+    let modes = fill_modes(app, tag.src);
+    egui::Popup::menu(&resp).show(|ui| {
+        ui.set_min_width(190.0);
+        for (label, mode) in modes {
+            if ui.add(egui::Button::new(lang.tr(label)).frame(false).min_size(vec2(180.0, 20.0))).clicked() {
+                chosen = Some(mode);
+                ui.close();
+            }
+        }
+    });
+    if let Some(mode) = chosen {
+        if let Err(e) = app.run("edit.undo", json!({})) {
+            app.grid.fill_tag = None;
+            app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+            return;
+        }
+        match app.run("edit.autoFill", json!({"source": tag.src.a1(), "target": tag.target.a1(), "mode": mode})) {
+            Ok(_) => set_fill_tag(app, tag.src, tag.target),
+            Err(e) => {
+                app.grid.fill_tag = None;
+                app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+            }
+        }
+    }
+}
+
+/// The menu a right-drag of the fill handle opens on release, as in Excel.
+pub(super) fn fill_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) {
+    let Some((src, target, at)) = app.grid.fill_menu else { return };
+    let mut close = false;
+    let mut items = fill_modes(app, src);
+    items.extend([("-", ""), ("Series…", "ui:series")]);
+    let response = egui::Area::new(egui::Id::unique("fill_menu")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
+        egui::Frame::popup(ui.style()).show(ui, |ui| {
+            ui.set_min_width(190.0);
+            let lang = crate::i18n::current(ui.ctx());
+            for (label, mode) in items {
+                if label == "-" {
+                    ui.separator();
+                    continue;
+                }
+                if ui.add(egui::Button::new(lang.tr(label)).frame(false).min_size(vec2(180.0, 20.0))).clicked() {
+                    close = true;
+                    if mode == "ui:series" {
+                        let _ = app.session.run("selection.set", json!({"range": target.union(&src).a1(), "active": src.start.a1()}));
+                        let direction = if target.width() != src.width() { "rows" } else { "columns" };
+                        app.open_dialog("series", json!({"direction": direction}));
+                    } else if let Err(e) = app.run("edit.autoFill", json!({"source": src.a1(), "target": target.a1(), "mode": mode})) {
+                        app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+                    }
+                }
+            }
+        });
+    });
+    if close || popup_dismissed(&response.response, was_open) {
+        app.grid.fill_menu = None;
+    }
+}
+
+/// The right-click menu of a chart, picture, shape or slicer.
+pub(super) fn object_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
+    let Some((at, kind, id)) = app.grid.object_menu else { return };
+    let mut close = false;
+    let resp = egui::Area::new(egui::Id::unique("object_context")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
+        egui::Frame::popup(ui.style()).show(ui, |ui| {
+            ui.set_min_width(200.0);
+            let mut items = vec![("Delete", "object.delete")];
+            if kind == "chart" {
+                items.extend([("-", ""), ("Select Data…", "ui:selectData"), ("Format Chart Area…", "ui:formatChart")]);
+            }
+            let lang = crate::i18n::current(ui.ctx());
+            for (label, action) in items {
+                if label == "-" {
+                    ui.separator();
+                    continue;
+                }
+                if ui.add(egui::Button::new(lang.tr(label)).frame(false).min_size(vec2(190.0, 20.0))).clicked() {
+                    close = true;
+                    match action {
+                        "ui:selectData" => app.open_dialog("selectData", json!({"chart": id})),
+                        "ui:formatChart" => app.grid.pane = Some("formatChart".into()),
+                        _ => {
+                            app.run_or_alert("object.delete", json!({"kind": kind, "id": id}));
+                            app.selected_chart = None;
+                        }
+                    }
+                }
+            }
+        });
+    });
+    if close
+        || ui.input(|i| i.key_pressed(egui::Key::Escape))
+        || (ui.input(|i| i.pointer.any_pressed())
+            && !resp.response.contains_pointer()
+            && !resp.response.hovered()
+            && ui.input(|i| i.pointer.interact_pos()).is_some_and(|p| !resp.response.rect.contains(p)))
+    {
+        app.grid.object_menu = None;
+    }
+}
+
+/// The warning button beside an active cell holding a number stored as text, as in Excel: its
+/// menu names the problem and offers Convert to Number for the selection (#1994).
+pub(super) fn error_check_tag(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, sh: &Sheet) {
+    if app.editor.is_some() || app.dialog.is_some() || sh.show_formulas || app.grid.drag != Drag::None {
+        return;
+    }
+    let Some(active) = app.session.active().map(|d| d.selection.active) else { return };
+    if sh.cell(active).and_then(gridcraft_engine::cmd::formulas::number_stored_as_text).is_none() {
+        return;
+    }
+    let cell = geo.cell_rect(sh, active);
+    let size = vec2(18.0, 18.0);
+    // Left of the cell, or right of it when that would cover the row headings.
+    let left = if cell.left() - size.x - 2.0 >= geo.cells.left() { cell.left() - size.x - 2.0 } else { cell.right() + 2.0 };
+    let tag = geo.mirror_rect(Rect::from_min_size(pos2(left, cell.top()), size));
+    if !geo.cells.intersects(tag) {
+        return;
+    }
+    let lang = crate::i18n::current(ui.ctx());
+    let resp = ui.interact(tag, egui::Id::unique("gridcraft.error_check_tag"), Sense::click()).on_hover_text(lang.tr("Number Stored as Text"));
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, lang.tr("Error checking options")));
+    let t = Tokens::get(ui.ctx());
+    let p = ui.painter();
+    p.rect_filled(tag, 3.0, if resp.hovered() { t.hover } else { t.window });
+    p.rect_stroke(tag, 3.0, Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
+    // A warning sign: an amber diamond with an exclamation mark.
+    let c = tag.center();
+    let r = 6.0;
+    p.add(egui::Shape::convex_polygon(
+        vec![pos2(c.x, c.y - r), pos2(c.x + r, c.y), pos2(c.x, c.y + r), pos2(c.x - r, c.y)],
+        t.warning_fill,
+        Stroke::NONE,
+    ));
+    p.text(c, egui::Align2::CENTER_CENTER, "!", egui::FontId::proportional(10.0), t.warning_ink);
+    egui::Popup::menu(&resp).show(|ui| {
+        ui.label(egui::RichText::new(lang.tr("Number Stored as Text")).strong());
+        ui.separator();
+        if ui.button(lang.tr("Convert to Number")).clicked() {
+            app.run_or_alert("formulas.convertToNumber", json!({}));
+            ui.close();
+        }
+    });
+}
+
+/// Draws row/column header context menus with insert/delete, format, size, hide/unhide and group actions, plus Insert Copied Cells when available.
+pub(super) fn header_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) {
+    let Some((at, rows)) = app.grid.header_menu else { return };
+    let mut close = false;
+    let response = egui::Area::new(egui::Id::unique("header_menu")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| {
+        egui::Frame::popup(ui.style()).show(ui, |ui| {
+            ui.set_min_width(190.0);
+            let insert_copied = insert_copied_item(app);
+            let mut items: Vec<(&str, &str)> = if rows {
+                vec![
+                    ("Cut", "edit.cut"),
+                    ("Copy", "edit.copy"),
+                    ("Paste", "edit.paste"),
+                    ("-", ""),
+                    ("Insert", "home.insertRows"),
+                    ("Delete", "home.deleteRows"),
+                    ("Clear Contents", "edit.clearContents"),
+                    ("-", ""),
+                    ("Format Cells…", "ui:formatCells"),
+                    ("Row Height…", "ui:rowHeight"),
+                    ("AutoFit Row Height", "home.autofitRowHeight"),
+                    ("Hide", "home.hideRows"),
+                    ("Unhide", "home.unhideRows"),
+                    ("Group", "data.group"),
+                ]
+            } else {
+                vec![
+                    ("Cut", "edit.cut"),
+                    ("Copy", "edit.copy"),
+                    ("Paste", "edit.paste"),
+                    ("-", ""),
+                    ("Insert", "home.insertColumns"),
+                    ("Delete", "home.deleteColumns"),
+                    ("Clear Contents", "edit.clearContents"),
+                    ("-", ""),
+                    ("Format Cells…", "ui:formatCells"),
+                    ("Column Width…", "ui:columnWidth"),
+                    ("AutoFit Column Width", "home.autofitColumnWidth"),
+                    ("Hide", "home.hideColumns"),
+                    ("Unhide", "home.unhideColumns"),
+                    ("Sort A to Z", "data.sortAscending"),
+                    ("Group", "data.group"),
+                ]
+            };
+            if let Some(item) = insert_copied {
+                items.insert(5, item);
+            }
+            let lang = crate::i18n::current(ui.ctx());
+            for (label, id) in items {
+                if label == "-" {
+                    ui.separator();
+                    continue;
+                }
+                if ui.add(egui::Button::new(lang.tr(label)).frame_when_inactive(false).min_size(vec2(180.0, 20.0))).clicked() {
+                    close = true;
+                    match id {
+                        "ui:insertPaste" => app.open_dialog("insertPaste", json!({})),
+                        "ui:rowHeight" => app.open_dialog("rowHeight", json!({})),
+                        "ui:formatCells" => app.open_dialog("formatCells", json!({})),
+                        "ui:columnWidth" => app.open_dialog("columnWidth", json!({})),
+                        "edit.copy" | "edit.cut" => {
+                            app.copy_to_clipboard(ui.ctx(), id);
+                        }
+                        "edit.paste" => app.paste_from_clipboard(),
+                        other => app.run_or_alert(other, json!({})),
+                    }
+                }
+            }
+        });
+    });
+    if close || popup_dismissed(&response.response, was_open) {
+        app.grid.header_menu = None;
+    }
+}
+
+/// The context-menu entry for Insert Copied Cells / Insert Cut Cells, when the clipboard holds a
+/// copy or cut of this app: whole rows or columns insert at once, a block asks which way to shift
+/// (Insert Paste). A cut block can only be pasted, so it gets no entry.
+fn insert_copied_item(app: &SheetApp) -> Option<(&'static str, &'static str)> {
+    let clip = app.session.clipboard.as_ref()?;
+    let lines = clip.selected.is_full_rows() != clip.selected.is_full_cols();
+    let cut = clip.cut && app.session.active().is_some_and(|d| d.uid == clip.doc_uid);
+    match (cut, lines) {
+        (true, true) => Some(("Insert Cut Cells", "home.insertCopiedCells")),
+        (true, false) => None,
+        (false, true) => Some(("Insert Copied Cells", "home.insertCopiedCells")),
+        (false, false) => Some(("Insert Copied Cells…", "ui:insertPaste")),
+    }
+}
+
+pub(super) fn is_checkbox(sh: &Sheet, app: &SheetApp) -> bool {
+    let Some(d) = app.session.active() else { return false };
+    d.wb.styles.get(sh.style_id(d.selection.active)).num_fmt.as_str() == "checkbox"
+}
diff --git a/crates/ui-egui/src/grid/quadrant.rs b/crates/ui-egui/src/grid/quadrant.rs
new file mode 100644
index 000000000..aa9e6fc07
--- /dev/null
+++ b/crates/ui-egui/src/grid/quadrant.rs
@@ -0,0 +1,474 @@
+use super::cell_paint::{
+    Look, cell_text_y, center_across_end, col32, display_text, look, merged_edges, paint_border, paint_cf_icon, painted_halign, rotated_text_pos,
+    shrink_font, wrapped_cell_text_y,
+};
+use super::geo::Geo;
+use super::tables::{filter_button_rect, paint_filter_button};
+use super::*;
+
+/// Mirror what the grid painted into `layer` (the shape indices in `range`) for a right-to-left
+/// sheet. Geometry is reflected; text and meshes (glyphs, pictures) keep their reading direction
+/// and only move so that their box lands mirrored. Floating objects (`objects`: shape index
+/// ranges with their logical rect) move as a whole, so a chart keeps its axes and a picture
+/// isn't flipped.
+pub(super) fn mirror_painted(
+    ctx: &egui::Context,
+    layer: egui::LayerId,
+    range: std::ops::Range<usize>,
+    geo: &Geo,
+    objects: &[crate::chartview::PaintedObject],
+) {
+    let axis = geo.rect.left() + geo.rect.right();
+    ctx.graphics_mut(|g| {
+        let list = g.entry(layer);
+        for i in range {
+            let object = objects.iter().find(|o| o.shapes.contains(&i));
+            list.mutate_shape(egui::layers::ShapeIdx(i), |cs| {
+                cs.clip_rect = geo.mirror_rect(cs.clip_rect);
+                match object {
+                    Some(o) => cs.shape.translate(vec2(axis - o.rect.right() - o.rect.left(), 0.0)),
+                    None => mirror_shape(&mut cs.shape, axis),
+                }
+            });
+        }
+    });
+}
+
+/// Reflect one shape across the vertical line `x = axis / 2`.
+fn mirror_shape(shape: &mut egui::Shape, axis: f32) {
+    use egui::Shape;
+    let flip = |p: &mut Pos2| p.x = axis - p.x;
+    match shape {
+        Shape::Noop | Shape::Callback(_) => {}
+        Shape::Vec(v) => v.iter_mut().for_each(|s| mirror_shape(s, axis)),
+        Shape::Circle(c) => flip(&mut c.center),
+        Shape::Ellipse(e) => flip(&mut e.center),
+        Shape::LineSegment { points, .. } => points.iter_mut().for_each(flip),
+        Shape::Path(p) => {
+            p.points.iter_mut().for_each(flip);
+            // Keep the preferred (clockwise) winding for filled polygons.
+            p.points.reverse();
+        }
+        Shape::Rect(r) => {
+            r.rect = Rect::from_min_max(pos2(axis - r.rect.right(), r.rect.top()), pos2(axis - r.rect.left(), r.rect.bottom()));
+            let c = r.corner_radius;
+            r.corner_radius = egui::CornerRadius { nw: c.ne, ne: c.nw, sw: c.se, se: c.sw };
+        }
+        Shape::QuadraticBezier(b) => b.points.iter_mut().for_each(flip),
+        Shape::CubicBezier(b) => b.points.iter_mut().for_each(flip),
+        _ => {
+            let b = shape.visual_bounding_rect();
+            if b.is_finite() {
+                shape.translate(vec2(axis - b.right() - b.left(), 0.0));
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn paint_quadrant(
+    p: &Painter,
+    geo: &Geo,
+    wb: &Workbook,
+    si: usize,
+    sh: &Sheet,
+    rows: (u32, u32),
+    cols: (u32, u32),
+    cf: &mut CfCache,
+    t: &Tokens,
+) {
+    let z = geo.z;
+    let (r0, r1) = rows;
+    let (c0, c1) = cols;
+    let range = RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1));
+    // Merges are looked up 20 columns beyond the quadrant too: text overflowing in from off-screen cells stops at them.
+    let near = RangeRef::new(CellRef::new(r0, c0.saturating_sub(20)), CellRef::new(r1, c1.saturating_add(20).min(MAX_COLS - 1)));
+    let merges: Vec<RangeRef> = sh.merges.iter().filter(|m| m.intersects(&near)).copied().collect();
+    let in_merge = |c: CellRef| merges.iter().find(|m| m.contains(c)).copied();
+    // Gridlines.
+    if sh.show_gridlines {
+        let stroke = Stroke::new(1.0, t.gridline);
+        let top = geo.y(sh, r0);
+        let bottom = geo.y(sh, r1 + 1);
+        let left = geo.x(sh, c0);
+        let right = geo.x(sh, c1 + 1);
+        for c in c0..=c1 + 1 {
+            if c <= c1 && sh.col_width(c) == 0.0 {
+                continue;
+            }
+            let x = geo.x(sh, c).round() - 0.5;
+            p.line_segment([pos2(x, top), pos2(x, bottom)], stroke);
+        }
+        for r in r0..=r1 + 1 {
+            if r <= r1 && sh.row_height(r) == 0.0 {
+                continue;
+            }
+            let y = geo.y(sh, r).round() - 0.5;
+            p.line_segment([pos2(left, y), pos2(right, y)], stroke);
+        }
+    }
+    // Merged areas: blank them (no inner gridlines) and paint as one cell.
+    let mut cells: Vec<CellRef> = Vec::new();
+    for r in r0..=r1 {
+        if sh.row_height(r) == 0.0 {
+            continue;
+        }
+        for c in c0..=c1 {
+            if sh.col_width(c) == 0.0 {
+                continue;
+            }
+            cells.push(CellRef::new(r, c));
+        }
+    }
+    let empty_ok = |c: CellRef| -> bool { sh.value_ref(c).is_none_or(Value::is_empty) && in_merge(c).is_none() };
+    // Backgrounds.
+    let mut looks: Vec<(CellRef, Rect, Look, Option<CfLook>)> = Vec::with_capacity(cells.len().min(20_000));
+    for &c in &cells {
+        let (rect, anchor) = match in_merge(c) {
+            Some(m) if m.start != c && !(c.row == r0.max(m.start.row) && c.col == c0.max(m.start.col)) => continue,
+            Some(m) => (geo.range_rect(sh, m), m.start),
+            None => (geo.cell_rect(sh, c), c),
+        };
+        let (lk, cfl) = look(wb, si, sh, anchor, cf);
+        if let Some(f) = lk.fill {
+            p.rect_filled(rect.expand(0.0), 0.0, f);
+        } else if in_merge(c).is_some() {
+            p.rect_filled(rect.shrink(0.5), 0.0, Color32::WHITE);
+        }
+        looks.push((anchor, rect, lk, cfl));
+    }
+    // Text cells just outside the quadrant whose text may overflow into it: the nearest non-empty
+    // cell left of `c0` and right of `c1` in each row (within the same frozen / scrolled pane).
+    let mut outside: Vec<(CellRef, Rect, Look, Option<CfLook>)> = Vec::new();
+    let same_pane = |col: u32| (col < geo.fc) == (c0 < geo.fc);
+    for r in r0..=r1 {
+        if sh.row_height(r) == 0.0 {
+            continue;
+        }
+        let left = (c0.saturating_sub(20)..c0).rev().map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n));
+        let right = (c1.saturating_add(1)..=c1.saturating_add(20).min(MAX_COLS - 1)).map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n));
+        for n in [left, right].into_iter().flatten() {
+            if same_pane(n.col) && sh.col_width(n.col) > 0.0 && in_merge(n).is_none() {
+                let (lk, cfl) = look(wb, si, sh, n, cf);
+                outside.push((n, geo.cell_rect(sh, n), lk, cfl));
+            }
+        }
+    }
+    // Text and per-cell decorations.
+    for (c, rect, lk, cfl) in looks.iter().chain(&outside) {
+        let c = *c;
+        if let Some(picture) = sh.cell_pictures.get(&c) {
+            crate::cell_pictures::paint(p, *rect, picture);
+            continue;
+        }
+        let v = sh.value(c);
+        if let Some(l) = cfl
+            && let Some((frac, rgb, gradient)) = l.bar
+        {
+            let bar = Rect::from_min_size(pos2(rect.left() + 2.0, rect.top() + 2.0), vec2((rect.width() - 4.0) * frac, rect.height() - 4.0));
+            let col = theme::color32(rgb);
+            if gradient {
+                let mut mesh = egui::Mesh::default();
+                let light = Color32::from_rgb(
+                    ((rgb[0] as u16 + 255 * 3) / 4) as u8,
+                    ((rgb[1] as u16 + 255 * 3) / 4) as u8,
+                    ((rgb[2] as u16 + 255 * 3) / 4) as u8,
+                );
+                let i = mesh.vertices.len() as u32;
+                for (pt, cc) in [(bar.left_top(), col), (bar.right_top(), light), (bar.right_bottom(), light), (bar.left_bottom(), col)] {
+                    mesh.colored_vertex(pt, cc);
+                }
+                mesh.add_triangle(i, i + 1, i + 2);
+                mesh.add_triangle(i, i + 2, i + 3);
+                p.add(mesh);
+                p.rect_stroke(bar, 0.0, Stroke::new(1.0, col), StrokeKind::Inside);
+            } else {
+                p.rect_filled(bar, 0.0, col);
+            }
+        }
+        let mut text_left = rect.left();
+        if let Some(l) = cfl
+            && let Some((set, idx)) = &l.icon
+        {
+            let r = Rect::from_min_size(pos2(rect.left() + 2.0, rect.center().y - 6.0 * z), vec2(12.0 * z, 12.0 * z));
+            paint_cf_icon(p, r, set, *idx);
+            text_left += 15.0 * z;
+        }
+        if lk.style.num_fmt.as_str() == "checkbox" && matches!(v, Value::Bool(_) | Value::Empty) {
+            let s = (11.0 * z * 1.2).clamp(8.0, 24.0);
+            let b = Rect::from_center_size(rect.center(), vec2(s, s));
+            let on = v == Value::Bool(true);
+            p.rect_filled(b, 2.0, if on { Color32::from_rgb(0x10, 0x7C, 0x41) } else { Color32::WHITE });
+            p.rect_stroke(
+                b,
+                2.0,
+                Stroke::new(1.0, if on { Color32::from_rgb(0x10, 0x7C, 0x41) } else { Color32::from_gray(110) }),
+                StrokeKind::Inside,
+            );
+            if on {
+                crate::icons::paint_on_sheet(p, b.shrink(1.5), crate::icons::Icon::Check, Color32::WHITE);
+            }
+            continue;
+        }
+        if cfl.as_ref().is_some_and(|l| l.hide_value) || v.is_empty() {
+            continue;
+        }
+        // Align and clip header text inside the content area, away from the dropdown.
+        let filter_space = sh.filter_button_space(c) * z;
+        let text_rect = Rect::from_min_max(rect.min, pos2((rect.right() - filter_space).max(rect.left()), rect.bottom()));
+        let rect = &text_rect;
+        let st = &lk.style;
+        let size = st.font.size * 96.0 / 72.0 * z;
+        let fam = theme::cell_family(&st.font.name, st.font.bold, st.font.italic);
+        let font = FontId::new(size, fam);
+        // Digits fit by the cell's own font and size, not the default 11pt (9pt marks in narrow columns).
+        let char_w = p.layout_no_wrap("0".to_string(), font.clone(), Color32::PLACEHOLDER).size().x.max(1.0);
+        let avail_w = rect.right() - text_left;
+        let (mut text, ncolor, numeric, fill_char) = display_text(wb, sh, c, &v, st, avail_w / z.max(0.1) * z, char_w);
+        if sh.show_formulas && sh.cell(c).is_some_and(|cell| cell.formula.is_some()) {
+            text = crate::formula_locale::display(&text, crate::i18n::current(p.ctx()).formula_locale(), wb, si);
+        }
+        if text.is_empty() {
+            continue;
+        }
+        let color = ncolor.unwrap_or(lk.text_color);
+        let halign = match st.align.h {
+            HAlign::General => match v {
+                Value::Number(_) => HAlign::Right,
+                Value::Bool(_) | Value::Error(_) => HAlign::Center,
+                _ if numeric => HAlign::Right,
+                _ => HAlign::Left,
+            },
+            h => painted_halign(h, geo.rtl),
+        };
+        let indent = st.align.indent as f32 * 9.0 * z;
+        let pad = 2.5 * z;
+        let rotated = st.align.rotation != 0 && st.align.rotation != 255;
+        // Rotated text wraps along its own direction (below), not across the column width.
+        if !rotated && (st.align.wrap || st.align.h == HAlign::Justify) {
+            let wrap_w = (rect.width() - 2.0 * pad - indent).max(4.0);
+            let mut job = egui::text::LayoutJob::simple(text.clone(), font.clone(), color, wrap_w);
+            job.halign = match halign {
+                HAlign::Center | HAlign::CenterAcross => egui::Align::Center,
+                HAlign::Right => egui::Align::RIGHT,
+                _ => egui::Align::LEFT,
+            };
+            let galley = p.layout_job(job);
+            let x = match halign {
+                HAlign::Center | HAlign::CenterAcross => rect.center().x,
+                HAlign::Right => rect.right() - pad,
+                _ => text_left + pad + indent,
+            };
+            let y = wrapped_cell_text_y(st.align.v, *rect, galley.size().y, z);
+            p.with_clip_rect(rect.intersect(p.clip_rect())).galley(pos2(x, y), galley, color);
+            continue;
+        }
+        // Wrap Text off: Excel ignores the line breaks and draws the whole string on one line.
+        let first_line: String = text.chars().filter(|&ch| ch != '\n' && ch != '\r').collect();
+        // The fill position indexes `text`; move it back by the breaks removed before it.
+        let fill_char = fill_char.map(|(ch, pos)| (ch, pos.saturating_sub(text.get(..pos).map_or(0, |s| s.matches(['\n', '\r']).count()))));
+        // Shrink to fit: too-wide content is drawn in a smaller font so it fits the cell (or the
+        // merged area): it neither spills, nor is clipped, nor turns into ####.
+        let small = (st.align.shrink && !rotated && st.align.h != HAlign::Fill && fill_char.is_none())
+            .then(|| shrink_font(p, &first_line, &font, avail_w - 2.0 * pad - indent))
+            .flatten();
+        let shrunk = small.is_some();
+        let font = small.unwrap_or(font);
+        let mut galley = p.layout_no_wrap(first_line.clone(), font.clone(), color);
+        let mut w = galley.size().x;
+        // Numbers and dates never overflow: they show #### when too narrow.
+        let hashed = !shrunk && (numeric || matches!(v, Value::Number(_))) && w > avail_w - 2.0 * pad && st.align.h != HAlign::Fill;
+        if hashed {
+            // Measured on `#` itself: it is wider than `0` in some fonts, and #### must fit its cell.
+            let hash_w = p.layout_no_wrap("#".to_string(), font.clone(), color).size().x.max(1.0);
+            let n = ((avail_w - 2.0 * pad) / hash_w).floor().max(1.0) as usize;
+            galley = p.layout_no_wrap("#".repeat(n), font.clone(), color);
+            w = galley.size().x;
+        }
+        // Repeat fill (`*` in number formats) / Fill alignment. A number already shown as #### keeps
+        // it: rebuilding it from the text would overflow and clip its leading digits.
+        if let Some((ch, pos)) = fill_char
+            && !hashed
+            && pos <= first_line.len()
+        {
+            let base_w = w;
+            let cw = p.layout_no_wrap(ch.to_string(), font.clone(), color).size().x.max(1.0);
+            let n = (((avail_w - 2.0 * pad) - base_w) / cw).floor().max(0.0) as usize;
+            let mut s = first_line.clone();
+            if first_line.is_char_boundary(pos) {
+                s.insert_str(pos, &ch.to_string().repeat(n));
+            }
+            galley = p.layout_no_wrap(s, font.clone(), color);
+            w = galley.size().x;
+        }
+        // Center Across Selection: the text is centred over this cell and the empty cells to its right that also use it.
+        let across_end = if halign == HAlign::CenterAcross && !rotated && in_merge(c).is_none() {
+            center_across_end(c.col, c1 + 20, |col| {
+                let n = CellRef::new(c.row, col);
+                empty_ok(n) && wb.styles.get(sh.style_id(n)).align.h == HAlign::CenterAcross
+            })
+        } else {
+            c.col
+        };
+        // Overflow into empty neighbours for text (not upright text, whose width is its line height).
+        let mut clip = *rect;
+        let overflows = !numeric && !matches!(v, Value::Number(_)) && st.align.rotation.abs() != 90 && w > rect.width() - 2.0 * pad;
+        if filter_space == 0.0 && (overflows || across_end > c.col) && in_merge(c).is_none() {
+            let mut right = rect.right();
+            let mut left = rect.left();
+            if across_end > c.col {
+                right = geo.x(sh, across_end + 1);
+            }
+            if matches!(halign, HAlign::Left | HAlign::Center | HAlign::Justify) {
+                let mut cc = c.col + 1;
+                while right - rect.left() < w + 2.0 * pad && cc < MAX_COLS && empty_ok(CellRef::new(c.row, cc)) && cc <= c1 + 20 {
+                    right = geo.x(sh, cc + 1);
+                    cc += 1;
+                }
+            }
+            if matches!(halign, HAlign::Right | HAlign::Center) {
+                let mut cc = c.col;
+                while rect.right() - left < w + 2.0 * pad && cc > 0 && empty_ok(CellRef::new(c.row, cc - 1)) && cc + 20 > c0 {
+                    cc -= 1;
+                    left = geo.x(sh, cc);
+                }
+            }
+            clip = Rect::from_min_max(pos2(left, rect.top()), pos2(right, rect.bottom()));
+            // Paint over the gridlines the text passes through.
+            if lk.fill.is_none() {
+                let inner = Rect::from_min_max(pos2(clip.left() + 1.0, clip.top() + 0.5), pos2(clip.right() - 1.0, clip.bottom() - 1.0));
+                let extra_l = Rect::from_min_max(inner.min, pos2(rect.left() + 1.0, inner.bottom()));
+                let extra_r = Rect::from_min_max(pos2(rect.right() - 1.0, inner.top()), inner.max);
+                if extra_l.width() > 0.0 {
+                    p.rect_filled(extra_l, 0.0, t.grid_bg);
+                }
+                if extra_r.width() > 0.0 {
+                    p.rect_filled(extra_r, 0.0, t.grid_bg);
+                }
+            }
+        }
+        let x = match halign {
+            HAlign::CenterAcross => clip.center().x - w / 2.0,
+            HAlign::Center | HAlign::Distributed => rect.center().x - w / 2.0,
+            HAlign::Right => rect.right() - pad - w - indent,
+            _ => text_left + pad + indent,
+        };
+        let gh = galley.size().y;
+        let y = cell_text_y(st.align.v, *rect, gh, z);
+        let cp = p.with_clip_rect(clip.intersect(p.clip_rect()));
+        if rotated {
+            let angle = -(st.align.rotation as f32).to_radians();
+            // Upright (±90°) wrapped text wraps to the row height: lines then stack across the column.
+            let galley = if st.align.wrap && st.align.rotation.abs() == 90 {
+                let job = egui::text::LayoutJob::simple(text.clone(), font.clone(), color, (rect.height() - 2.0 * pad).max(4.0));
+                p.layout_job(job)
+            } else {
+                galley.clone()
+            };
+            let pos = rotated_text_pos(*rect, galley.size(), angle, painted_halign(st.align.h, geo.rtl), st.align.v, pad, indent);
+            let mut shape = egui::epaint::TextShape::new(pos, galley, color);
+            shape.angle = angle;
+            cp.add(shape);
+        } else {
+            cp.galley(pos2(x, y), galley.clone(), color);
+        }
+        let baseline = y + gh * 0.82;
+        match st.font.underline {
+            Underline::None => {}
+            Underline::Double | Underline::DoubleAccounting => {
+                cp.line_segment([pos2(x, baseline + 1.0), pos2(x + w, baseline + 1.0)], Stroke::new(1.0, color));
+                cp.line_segment([pos2(x, baseline + 3.0), pos2(x + w, baseline + 3.0)], Stroke::new(1.0, color));
+            }
+            _ => {
+                cp.line_segment([pos2(x, baseline + 1.0), pos2(x + w, baseline + 1.0)], Stroke::new(1.0, color));
+            }
+        }
+        if st.font.strike {
+            cp.line_segment([pos2(x, y + gh * 0.55), pos2(x + w, y + gh * 0.55)], Stroke::new(1.0, color));
+        }
+    }
+    // Borders (over fills and text).
+    for (c, rect, lk, _) in &looks {
+        let b = &lk.style.borders;
+        let merge = merges.iter().find(|m| m.start == *c);
+        let edges = match merge {
+            // A merged area's outline lives on the cells along each of its edges (Excel writes the
+            // right edge on the last column's cells and the bottom edge on the last row's), so each
+            // edge is drawn cell by cell from the cell it belongs to.
+            Some(m) => merged_edges(wb, si, sh, geo, *m, *rect, (r0, r1), (c0, c1), cf),
+            None => vec![
+                (b.top, [rect.left_top(), rect.right_top()]),
+                (b.bottom, [rect.left_bottom(), rect.right_bottom()]),
+                (b.left, [rect.left_top(), rect.left_bottom()]),
+                (b.right, [rect.right_top(), rect.right_bottom()]),
+            ],
+        };
+        for (line, pts) in edges {
+            if line.is_none() {
+                continue;
+            }
+            let col = col32(line.color, wb, Color32::BLACK);
+            paint_border(p, pts, line.style, col);
+        }
+        if !b.diag_down.is_none() {
+            paint_border(p, [rect.left_top(), rect.right_bottom()], b.diag_down.style, col32(b.diag_down.color, wb, Color32::BLACK));
+        }
+        if !b.diag_up.is_none() {
+            paint_border(p, [rect.left_bottom(), rect.right_top()], b.diag_up.style, col32(b.diag_up.color, wb, Color32::BLACK));
+        }
+        // Comment / note indicator.
+        if let Some(cm) = sh.comments.get(c) {
+            let tri_col = if cm.threaded { Color32::from_rgb(0x88, 0x55, 0xC8) } else { Color32::from_rgb(0xD0, 0x2E, 0x2E) };
+            let s = 6.0 * z.max(0.7);
+            p.add(egui::Shape::convex_polygon(
+                vec![rect.right_top(), pos2(rect.right(), rect.top() + s), pos2(rect.right() - s, rect.top())],
+                tri_col,
+                Stroke::NONE,
+            ));
+        }
+        // Background error checking: a number stored as text gets Excel's green corner (#1994).
+        if !sh.show_formulas && sh.cell(*c).and_then(gridcraft_engine::cmd::formulas::number_stored_as_text).is_some() {
+            let s = 6.0 * z.max(0.7);
+            p.add(egui::Shape::convex_polygon(
+                vec![rect.left_top(), pos2(rect.left() + s, rect.top()), pos2(rect.left(), rect.top() + s)],
+                t.error_check_green,
+                Stroke::NONE,
+            ));
+        }
+    }
+    // Sparklines.
+    for sp in &sh.sparklines {
+        if !range.contains(sp.cell) {
+            continue;
+        }
+        let rect = geo.cell_rect(sh, sp.cell).shrink(3.0);
+        let vals: Vec<Option<f64>> = match gridcraft_engine::calc::evaluate(wb, si, sp.cell, &sp.source) {
+            Value::Array(a) => a.data.iter().map(Value::as_f64).collect(),
+            v => vec![v.as_f64()],
+        };
+        let col = sp.color.resolve(&wb.theme).unwrap_or([0x2B, 0x7C, 0xD3]);
+        let prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [col[0], col[1], col[2], 255], sp.markers, rect.width(), rect.height());
+        crate::chartview::paint_prims(p, rect.min, &prims, 1.0);
+    }
+    // Filter buttons.
+    let mut buttons: Vec<(CellRef, bool)> = Vec::new();
+    if let Some(af) = &sh.autofilter {
+        for col in af.range.start.col..=af.range.end.col {
+            let active = af.criteria.iter().any(|(o, _)| af.range.start.col + o == col);
+            buttons.push((CellRef::new(af.range.start.row, col), active));
+        }
+    }
+    for tb in &sh.tables {
+        if tb.filter_button && tb.header_row {
+            for col in tb.range.start.col..=tb.range.end.col {
+                buttons.push((CellRef::new(tb.range.start.row, col), false));
+            }
+        }
+    }
+    for (c, active) in buttons {
+        if !range.contains(c) {
+            continue;
+        }
+        paint_filter_button(p, filter_button_rect(geo, sh, c), active);
+    }
+}
diff --git a/crates/ui-egui/src/grid/selection.rs b/crates/ui-egui/src/grid/selection.rs
new file mode 100644
index 000000000..3b5339f61
--- /dev/null
+++ b/crates/ui-egui/src/grid/selection.rs
@@ -0,0 +1,419 @@
+use super::geo::Geo;
+#[cfg(test)]
+use super::interact::{hidden_col_edge, hidden_row_edge};
+#[cfg(test)]
+use super::show::hidden_around;
+use super::*;
+
+/// Where the active cell is on screen: the whole merged cell when it is part of one.
+fn active_rect(geo: &Geo, sh: &Sheet, sel: &gridcraft_engine::Selection) -> Rect {
+    match sh.merge_at(sel.active) {
+        Some(m) => geo.range_rect(sh, m),
+        None => geo.cell_rect(sh, sel.active),
+    }
+}
+
+/// The rectangles shaded for a selection: every area except the active cell, which stays clear so
+/// it is plain where typing goes. A single selected cell has no fill. `outline` is where the
+/// current area is drawn this frame: it glides to a new selection, and its fill with it.
+pub fn selection_fill(geo: &Geo, sh: &Sheet, sel: &gridcraft_engine::Selection, outline: Rect) -> Vec<Rect> {
+    selection_fill_where(geo, sh, sel, outline, |_| true)
+}
+
+/// `selection_fill` for the areas `keep` accepts (a frozen pane draws only the areas it shows).
+fn selection_fill_where(geo: &Geo, sh: &Sheet, sel: &gridcraft_engine::Selection, outline: Rect, keep: impl Fn(&RangeRef) -> bool) -> Vec<Rect> {
+    if sel.is_single_cell() {
+        return vec![];
+    }
+    let active = active_rect(geo, sh, sel);
+    let area = |r: &RangeRef| if *r == sel.current() { outline } else { geo.range_rect(sh, *r) };
+    sel.ranges.iter().filter(|r| keep(r)).flat_map(|r| rect_around(area(r), active)).collect()
+}
+
+/// `area` without `hole`: the strips above and below the hole, then what is left beside it. The
+/// selection fill is translucent, so the active cell can't be cleared by painting over it; the
+/// pieces never overlap for the same reason. Pieces with no size, or whose numbers aren't finite,
+/// are dropped.
+fn rect_around(area: Rect, hole: Rect) -> impl Iterator<Item = Rect> {
+    // `intersect` takes the sane side of a NaN, which would make a broken hole cover the area.
+    let hole = if hole.is_finite() { area.intersect(hole) } else { Rect::NOTHING };
+    let parts = if hole.is_positive() {
+        [
+            Rect::from_min_max(area.min, pos2(area.max.x, hole.min.y)),
+            Rect::from_min_max(pos2(area.min.x, hole.max.y), area.max),
+            Rect::from_min_max(pos2(area.min.x, hole.min.y), pos2(hole.min.x, hole.max.y)),
+            Rect::from_min_max(pos2(hole.max.x, hole.min.y), pos2(area.max.x, hole.max.y)),
+        ]
+    } else {
+        [area, Rect::NOTHING, Rect::NOTHING, Rect::NOTHING]
+    };
+    parts.into_iter().filter(|r| r.is_positive() && r.is_finite())
+}
+
+/// True when `r` covers at least one cell of the pane that shows `rows` x `cols` (inclusive).
+/// The panes of a frozen sheet share one coordinate system, so a range that lives only in the
+/// scrolling pane would otherwise be drawn over the frozen pane as well.
+fn range_in_pane(r: RangeRef, rows: (u32, u32), cols: (u32, u32)) -> bool {
+    r.start.row <= rows.1 && r.end.row >= rows.0 && r.start.col <= cols.1 && r.end.col >= cols.0
+}
+
+/// The four sides of a `width` wide outline centred on `rect`, cut to `clip` (a little beyond it).
+///
+/// A stroked rectangle that spans a whole column (20 million points tall) loses its precision in
+/// the tessellator and its left and right sides vanish; sides filled from rectangles that stay
+/// near the viewport do not. Sides wholly outside `clip` are left out.
+pub(crate) fn outline_bands(rect: Rect, width: f32, clip: Rect) -> Vec<Rect> {
+    if !rect.is_finite() || !clip.is_finite() {
+        return Vec::new();
+    }
+    let h = width / 2.0;
+    let clip = clip.expand(width * 2.0);
+    let sides = [
+        Rect::from_min_max(pos2(rect.left() - h, rect.top() - h), pos2(rect.left() + h, rect.bottom() + h)),
+        Rect::from_min_max(pos2(rect.right() - h, rect.top() - h), pos2(rect.right() + h, rect.bottom() + h)),
+        Rect::from_min_max(pos2(rect.left() - h, rect.top() - h), pos2(rect.right() + h, rect.top() + h)),
+        Rect::from_min_max(pos2(rect.left() - h, rect.bottom() - h), pos2(rect.right() + h, rect.bottom() + h)),
+    ];
+    sides.into_iter().map(|s| s.intersect(clip)).filter(|s| s.is_finite() && s.width() > 0.0 && s.height() > 0.0).collect()
+}
+
+/// `outline` is where the current area's border is drawn this frame (see `selection_glide`).
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn paint_selection(
+    p: &Painter,
+    geo: &Geo,
+    sh: &Sheet,
+    sel: &gridcraft_engine::Selection,
+    outline: Rect,
+    t: &Tokens,
+    app: &SheetApp,
+    rows: (u32, u32),
+    cols: (u32, u32),
+) {
+    // Fill all areas except the active cell.
+    for rect in selection_fill_where(geo, sh, sel, outline, |r| range_in_pane(*r, rows, cols)) {
+        p.rect_filled(rect, 0.0, t.sel_fill);
+    }
+    let active_range = sh.merge_at(sel.active).unwrap_or_else(|| RangeRef::cell(sel.active));
+    let active = active_rect(geo, sh, sel);
+    let active_here = range_in_pane(active_range, rows, cols);
+    let cur_here = range_in_pane(sel.current(), rows, cols);
+    // Editing a formula: outline its references instead of the selection.
+    if let Some(ed) = &app.editor
+        && ed.is_formula()
+        && app.session.active().is_some_and(|d| d.uid == ed.doc)
+    {
+        let origin = app.session.active().and_then(|d| d.wb.sheet(ed.sheet)).map_or(sh.name.as_str(), |o| o.name.as_str());
+        for (_, _, r, sheet, idx) in crate::editor::formula_refs(&ed.text) {
+            if !crate::editor::ref_is_on_sheet(sheet.as_deref(), origin, &sh.name) {
+                continue;
+            }
+            if !range_in_pane(r, rows, cols) {
+                continue;
+            }
+            let rr = geo.range_rect(sh, r);
+            let col = Tokens::get(p.ctx()).ref_color(idx, true);
+            p.rect_filled(rr, 0.0, col.gamma_multiply(0.12));
+            p.rect_stroke(rr, 0.0, Stroke::new(1.5, col), StrokeKind::Inside);
+            for corner in [rr.left_top(), rr.right_top(), rr.left_bottom(), rr.right_bottom()] {
+                p.rect_filled(Rect::from_center_size(corner, vec2(4.0, 4.0)), 0.0, col);
+            }
+        }
+    }
+    if cur_here {
+        for side in outline_bands(outline.expand(0.5), 2.0, p.clip_rect()) {
+            p.rect_filled(side, 0.0, t.sel_border);
+        }
+    }
+    if active_here && sel.ranges.len() > 1 {
+        p.rect_stroke(active, 0.0, Stroke::new(1.0, t.sel_border), StrokeKind::Inside);
+    }
+    // Fill handle (bottom-right of the current area).
+    if app.editor.is_none() && range_in_pane(RangeRef::cell(sel.current().end), rows, cols) {
+        let h = Rect::from_center_size(outline.right_bottom(), vec2(6.0, 6.0));
+        p.rect_filled(h.expand(1.0), 0.0, Color32::WHITE);
+        p.rect_filled(h, 0.0, t.sel_border);
+    }
+    // Fill-handle drag preview.
+    if let crate::grid::Drag::Fill { target: Some(tr), .. } = &app.grid.drag
+        && range_in_pane(*tr, rows, cols)
+    {
+        let rr = geo.range_rect(sh, *tr);
+        p.extend(egui::Shape::dashed_line(
+            &[rr.left_top(), rr.right_top(), rr.right_bottom(), rr.left_bottom(), rr.left_top()],
+            Stroke::new(1.5, Color32::from_gray(90)),
+            4.0,
+            3.0,
+        ));
+    }
+    if let crate::grid::Drag::Move { to: Some(to), .. } = &app.grid.drag {
+        let r = sel.current();
+        let moved = RangeRef::new(*to, to.offset_clamped(r.height() as i64 - 1, r.width() as i64 - 1));
+        if range_in_pane(moved, rows, cols) {
+            let rr = geo.range_rect(sh, moved);
+            p.rect_stroke(rr, 0.0, Stroke::new(2.0, Color32::from_gray(110)), StrokeKind::Middle);
+        }
+    }
+    if let crate::grid::Drag::MoveCols { before: Some(before), .. } = &app.grid.drag {
+        let x = geo.x(sh, *before);
+        p.line_segment([pos2(x, geo.rect.top()), pos2(x, geo.rect.bottom())], Stroke::new(3.0, t.accent));
+    }
+    // Marching ants around the copied range.
+    if let Some(clip) = &app.session.clipboard
+        && app.session.active().is_some_and(|d| d.uid == clip.doc_uid && d.wb.active_sheet() == clip.sheet)
+        && range_in_pane(clip.range, rows, cols)
+    {
+        // A multi-area copy marks each area as selected.
+        let areas = if clip.areas.is_empty() { std::slice::from_ref(&clip.range) } else { clip.areas.as_slice() };
+        for area in areas {
+            let rr = geo.range_rect(sh, *area).expand(0.5);
+            let phase = app.grid.marching_phase;
+            let pts = [rr.left_top(), rr.right_top(), rr.right_bottom(), rr.left_bottom(), rr.left_top()];
+            p.extend(egui::Shape::dashed_line_with_offset(&pts, Stroke::new(2.0, t.sel_border), &[4.0], &[4.0], phase));
+        }
+    }
+}
+
+/// The areas after a click: with `add` (Ctrl) the clicked area is added, or removed when it is already
+/// selected (unless it is the only one, so the selection never ends up empty).
+fn toggled_ranges(mut ranges: Vec<String>, clicked: String, add: bool) -> Vec<String> {
+    if !add {
+        return vec![clicked];
+    }
+    if ranges.len() > 1 && ranges.contains(&clicked) {
+        ranges.retain(|x| *x != clicked);
+    } else if !ranges.contains(&clicked) {
+        ranges.push(clicked);
+    }
+    ranges
+}
+
+pub(super) fn select_ranges(app: &mut SheetApp, r: RangeRef, add: bool, active: CellRef) {
+    let current: Vec<String> =
+        if add { app.session.active().map(|d| d.selection.ranges.iter().map(|x| x.a1()).collect()).unwrap_or_default() } else { vec![] };
+    let clicked = r.a1();
+    let ranges = toggled_ranges(current, clicked.clone(), add);
+    // A removed area takes the active cell with it; `selection.set` then puts it at the start of the last area.
+    let params =
+        if ranges.contains(&clicked) { json!({"range": ranges.join(","), "active": active.a1()}) } else { json!({"range": ranges.join(",")}) };
+    let _ = app.session.run("selection.set", params);
+}
+
+#[cfg(test)]
+mod selection_fill_tests {
+    use super::*;
+
+    #[test]
+    fn rect_around_leaves_the_hole_and_never_overlaps() {
+        let area = Rect::from_min_max(pos2(100.0, 50.0), pos2(400.0, 250.0));
+        let check = |hole: Rect, pieces: usize| {
+            let parts: Vec<Rect> = rect_around(area, hole).collect();
+            assert_eq!(parts.len(), pieces, "{hole:?}: {parts:?}");
+            let cut = area.intersect(hole);
+            let cut_area = if cut.is_positive() { cut.area() } else { 0.0 };
+            let shaded: f32 = parts.iter().map(Rect::area).sum();
+            assert!((shaded - (area.area() - cut_area)).abs() < 0.5, "everything but the hole is shaded: {hole:?}");
+            for (i, a) in parts.iter().enumerate() {
+                assert!(area.contains_rect(*a), "nothing outside the area: {a:?}");
+                assert!(!a.shrink(0.01).intersects(hole), "the hole stays clear: {a:?} vs {hole:?}");
+                // The fill is translucent: a part shaded twice would show darker.
+                assert!(parts.iter().skip(i + 1).all(|b| !a.shrink(0.01).intersects(*b)), "{parts:?}");
+            }
+        };
+        let cell = |x: f32, y: f32| Rect::from_min_size(pos2(x, y), vec2(64.0, 16.0));
+        // In the middle, in each corner (where a drag began), along an edge.
+        check(cell(200.0, 100.0), 4);
+        check(cell(100.0, 50.0), 2);
+        check(cell(336.0, 50.0), 2);
+        check(cell(100.0, 234.0), 2);
+        check(cell(336.0, 234.0), 2);
+        check(cell(100.0, 100.0), 3);
+        // A merged cell as wide, or as tall, as the area; one that is all of it, or more.
+        check(Rect::from_min_max(pos2(100.0, 100.0), pos2(400.0, 132.0)), 2);
+        check(Rect::from_min_max(pos2(200.0, 50.0), pos2(264.0, 250.0)), 2);
+        check(area, 0);
+        check(area.expand(30.0), 0);
+        // The active cell is in another area, touches this one, or is only partly inside it.
+        check(cell(500.0, 300.0), 1);
+        check(cell(400.0, 50.0), 1);
+        check(cell(380.0, 240.0), 2);
+    }
+
+    #[test]
+    fn rect_around_survives_hostile_numbers() {
+        let sane = Rect::from_min_max(pos2(0.0, 0.0), pos2(64.0, 16.0));
+        let bad = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::MIN, -1.0, 0.0];
+        for a in bad {
+            for b in bad {
+                let weird = Rect::from_min_max(pos2(a, b), pos2(b, a));
+                for (area, hole) in [(sane, weird), (weird, sane), (weird, weird)] {
+                    for part in rect_around(area, hole) {
+                        assert!(part.is_positive() && part.is_finite(), "{area:?} around {hole:?}: {part:?}");
+                    }
+                }
+                // A hole that makes no sense leaves the whole area shaded.
+                if !weird.intersects(sane) {
+                    assert_eq!(rect_around(sane, weird).collect::<Vec<_>>(), vec![sane]);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod pane_tests {
+    use super::*;
+
+    fn rng(r0: u32, c0: u32, r1: u32, c1: u32) -> RangeRef {
+        RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1))
+    }
+
+    #[test]
+    fn selection_in_scrolling_pane_is_not_drawn_in_frozen_pane() {
+        // Frozen: 2 rows and 2 columns; the scrolling pane shows rows 2..=20 and columns 2..=10.
+        let frozen_cols = ((2, 20), (0, 1));
+        let frozen_rows = ((0, 1), (2, 10));
+        let corner = ((0, 1), (0, 1));
+        let scrolled = ((2, 20), (2, 10));
+        let sel = rng(5, 4, 7, 6);
+        assert!(range_in_pane(sel, scrolled.0, scrolled.1));
+        assert!(!range_in_pane(sel, frozen_cols.0, frozen_cols.1));
+        assert!(!range_in_pane(sel, frozen_rows.0, frozen_rows.1));
+        assert!(!range_in_pane(sel, corner.0, corner.1));
+    }
+
+    #[test]
+    fn ctrl_click_on_a_selected_header_deselects_it() {
+        let s = |v: &[&str]| v.iter().map(|x| x.to_string()).collect::<Vec<_>>();
+        assert_eq!(toggled_ranges(s(&["A:A", "C:C"]), "C:C".into(), true), s(&["A:A"]));
+        assert_eq!(toggled_ranges(s(&["A:A"]), "C:C".into(), true), s(&["A:A", "C:C"]));
+        assert_eq!(toggled_ranges(s(&["A:A"]), "A:A".into(), true), s(&["A:A"]));
+        assert_eq!(toggled_ranges(s(&["A1", "B2", "3:3"]), "B2".into(), true), s(&["A1", "3:3"]));
+        assert_eq!(toggled_ranges(s(&["A:A", "C:C"]), "C:C".into(), false), s(&["C:C"]));
+    }
+
+    #[test]
+    fn selection_across_the_freeze_line_is_drawn_in_both_panes() {
+        let sel = rng(5, 0, 7, 6);
+        assert!(range_in_pane(sel, (2, 20), (0, 1)));
+        assert!(range_in_pane(sel, (2, 20), (2, 10)));
+    }
+
+    #[test]
+    fn hidden_outline_symbols_take_no_room() {
+        let rect = Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0));
+        let mut sh = Sheet::new("S");
+        sh.rows.entry(3).or_default().outline = 1;
+        sh.cols.entry(2).or_default().outline = 2;
+        let shown = Geo::new(&sh, rect, vec2(0.0, 0.0));
+        assert!(shown.band_w > 0.0 && shown.band_h > 0.0);
+        sh.show_outline_symbols = false;
+        let hidden = Geo::new(&sh, rect, vec2(0.0, 0.0));
+        assert_eq!((hidden.band_w, hidden.band_h), (0.0, 0.0));
+        assert!(hidden.cells.left() < shown.cells.left() && hidden.cells.top() < shown.cells.top());
+        // Without headings too.
+        sh.show_headings = false;
+        let bare = Geo::new(&sh, rect, vec2(0.0, 0.0));
+        assert_eq!((bare.band_w, bare.band_h), (0.0, 0.0));
+        // No button answers a click on the empty bands' edges (the grid's left and top), where the
+        // level buttons would sit with no headings to hold them.
+        for geo in [&hidden, &bare] {
+            for i in 0..400 {
+                let t = i as f32 * 0.5;
+                for p in [pos2(geo.rect.left(), geo.rect.top() + t), pos2(geo.rect.left() + t, geo.rect.top())] {
+                    assert_eq!(crate::outline::hit(geo, &sh, p), None, "{p:?}");
+                }
+            }
+        }
+    }
+
+    /// Two frozen rows and columns, scrolled right so that columns C:E lie under the frozen columns.
+    fn frozen_geo(sh: &mut Sheet) -> Geo {
+        sh.freeze = Some((2, 2));
+        let scroll = vec2(3.0 * sh.default_col_width + 8.0, 0.0);
+        Geo::new(sh, Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0)), scroll)
+    }
+
+    #[test]
+    fn the_edge_just_past_a_hidden_line_unhides_it() {
+        let mut sh = Sheet::new("S");
+        sh.cols.entry(11).or_default().hidden = true; // L
+        sh.rows.entry(26).or_default().hidden = true; // 27
+        let geo = Geo::new(&sh, Rect::from_min_size(pos2(0.0, 0.0), vec2(2000.0, 1200.0)), vec2(0.0, 0.0));
+        let x = geo.x(&sh, 12); // between K and M
+        assert_eq!(hidden_col_edge(&geo, &sh, x + 2.0), Some(11));
+        assert_eq!(hidden_col_edge(&geo, &sh, x - 2.0), None); // K's own edge
+        assert_eq!(hidden_col_edge(&geo, &sh, geo.x(&sh, 5)), None);
+        let y = geo.y(&sh, 27); // between 26 and 28
+        assert_eq!(hidden_row_edge(&geo, &sh, y + 2.0), Some(26));
+        assert_eq!(hidden_row_edge(&geo, &sh, y - 2.0), None);
+    }
+
+    #[test]
+    fn headers_mark_the_edges_next_to_hidden_lines() {
+        let mut sh = Sheet::new("S");
+        sh.cols.entry(0).or_default().hidden = true; // A
+        sh.cols.entry(11).or_default().hidden = true; // L
+        sh.rows.entry(26).or_default().hidden = true; // 27
+        let col = |c| hidden_around(c, |i| sh.col_width(i));
+        assert_eq!(col(1), (true, false)); // B, after hidden A
+        assert_eq!(col(10), (false, true)); // K
+        assert_eq!(col(12), (true, false)); // M
+        assert_eq!(col(5), (false, false));
+        let row = |r| hidden_around(r, |i| sh.row_height(i));
+        assert_eq!(row(25), (false, true));
+        assert_eq!(row(27), (true, false));
+        assert_eq!(row(0), (false, false));
+    }
+
+    #[test]
+    fn overlays_skip_cells_scrolled_under_the_frozen_columns() {
+        let mut sh = Sheet::new("S");
+        let geo = frozen_geo(&mut sh);
+        assert!(geo.hidden_under_frozen(&sh, CellRef::new(5, 2)));
+        assert!(geo.hidden_under_frozen(&sh, CellRef::new(5, 4)));
+        assert!(!geo.hidden_under_frozen(&sh, CellRef::new(5, 5)));
+        assert!(!geo.hidden_under_frozen(&sh, CellRef::new(5, 0)));
+        let unscrolled = Geo::new(&sh, geo.rect, vec2(0.0, 0.0));
+        assert!(!unscrolled.hidden_under_frozen(&sh, CellRef::new(5, 2)));
+    }
+
+    #[test]
+    fn ranges_are_clipped_to_the_panes_that_hold_them() {
+        let mut sh = Sheet::new("S");
+        let geo = frozen_geo(&mut sh);
+        let split = pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h);
+        assert_eq!(geo.range_panes(rng(5, 3, 7, 6)), [Rect::from_min_max(split, geo.cells.max)]);
+        assert_eq!(geo.range_panes(rng(5, 0, 7, 6)).len(), 2);
+        assert_eq!(geo.range_panes(rng(0, 0, 7, 6)).len(), 4);
+        assert_eq!(geo.range_panes(rng(0, 0, 1, 1)), [Rect::from_min_max(geo.cells.min, split)]);
+        // The fill handle of D6:E7 sits over the frozen columns, where nothing of it is shown.
+        let handle = geo.range_rect(&sh, rng(5, 3, 6, 4)).right_bottom();
+        assert!(handle.x < split.x);
+        assert!(!geo.range_panes(rng(6, 4, 6, 4)).iter().any(|r| r.contains(handle)));
+    }
+}
+
+#[cfg(test)]
+mod outline_band_tests {
+    use super::*;
+
+    #[test]
+    fn whole_column_outline_keeps_left_and_right_sides_near_viewport() {
+        let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(800.0, 600.0));
+        let col = Rect::from_min_max(pos2(100.0, 40.0), pos2(180.0, 20_971_540.0));
+        let sides = outline_bands(col, 2.0, clip);
+        // Left, right and top (in view); the bottom is 20 million points away.
+        assert_eq!(sides.len(), 3);
+        assert!(sides.iter().all(|s| s.bottom() <= clip.bottom() + 4.0 + f32::EPSILON));
+        assert!(sides.iter().any(|s| s.left() < 100.0 && s.right() > 100.0 && s.height() > 500.0));
+        assert!(sides.iter().any(|s| s.left() < 180.0 && s.right() > 180.0 && s.height() > 500.0));
+    }
+
+    #[test]
+    fn outline_outside_the_view_and_non_finite_draw_nothing() {
+        let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(800.0, 600.0));
+        assert!(outline_bands(Rect::from_min_max(pos2(900.0, 0.0), pos2(950.0, 20.0)), 2.0, clip).is_empty());
+        assert!(outline_bands(Rect::from_min_max(pos2(f32::NAN, 0.0), pos2(1.0, 1.0)), 2.0, clip).is_empty());
+    }
+}
diff --git a/crates/ui-egui/src/grid/show.rs b/crates/ui-egui/src/grid/show.rs
new file mode 100644
index 000000000..442a4722d
--- /dev/null
+++ b/crates/ui-egui/src/grid/show.rs
@@ -0,0 +1,861 @@
+use super::cursor::update_cursor;
+use super::editor::{in_cell_editor, list_picker, validation_arrow};
+use super::geo::Geo;
+use super::interact::{interact, paint_freeze_handles};
+use super::menus::{context_menu, error_check_tag, fill_menu, fill_options_tag, filter_menu, header_menu, object_menu};
+use super::quadrant::{mirror_painted, paint_quadrant};
+use super::selection::paint_selection;
+use super::tables::{TableHeading, paint_filter_button, table_headings};
+use super::*;
+
+pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
+    let t = Tokens::get(ui.ctx());
+    let available = ui.available_rect_before_wrap();
+    // A right-to-left sheet has its vertical scrollbar on the left.
+    let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
+    let bar = 14.0_f32.min(available.width());
+    let rect = if rtl {
+        Rect::from_min_max(pos2(available.left() + bar, available.top()), available.max)
+    } else {
+        Rect::from_min_max(available.min, pos2(available.right() - bar, available.bottom()))
+    };
+    let resp = ui.allocate_rect(rect, Sense::click_and_drag());
+    app.grid.rect = Some(rect);
+    let Some(d) = app.session.active() else { return };
+    let wb: Arc<Workbook> = d.wb.clone();
+    let si = wb.active_sheet();
+    let Some(sh) = wb.sheet(si) else { return };
+    let sel = d.selection.clone();
+    let place = (d.uid, si);
+    let mut view = app.view();
+    // Page Layout view: pages on a desk, rulers above and left of the headings.
+    let paper = sh.view == gridcraft_engine::model::SheetViewMode::PageLayout;
+    let ruler = if paper && !app.session.hide_ruler { crate::paper_view::RULER } else { 0.0 };
+    // Right-to-left sheets carry the vertical ruler on the right, beside the row headings.
+    let grid_rect = if rtl {
+        Rect::from_min_max(pos2(rect.left(), (rect.top() + ruler).min(rect.bottom())), pos2((rect.right() - ruler).max(rect.left()), rect.bottom()))
+    } else {
+        Rect::from_min_max(pos2((rect.left() + ruler).min(rect.right()), (rect.top() + ruler).min(rect.bottom())), rect.max)
+    };
+    let make_geo = |app: &mut SheetApp, scroll: egui::Vec2| -> Geo {
+        if paper {
+            let probe = Geo::new(sh, grid_rect, scroll);
+            if let Some(g) = crate::paper_view::grid_for(app, &wb, si, sh, probe.cells.size(), scroll) {
+                let g = crate::paper_view::with_dragged_margin(app, &wb, si, g);
+                return Geo::paged(sh, grid_rect, scroll, g);
+            }
+        }
+        Geo::new(sh, rect, scroll)
+    };
+    // Scrolling.
+    let (scroll_delta, zoom_delta, modifiers, now) = ui.input(|i| (i.smooth_scroll_delta, i.zoom_delta(), i.modifiers, i.time));
+    if (resp.hovered() || resp.contains_pointer()) && !crate::text_box::contains_pointer(app, ui.ctx()) {
+        if zoom_delta != 1.0 {
+            // egui's zoom factor is e^(speed × points); one notch is `line_scroll_speed` points.
+            let notch = ui.ctx().options(|o| o.input_options.scroll_zoom_speed * o.input_options.line_scroll_speed);
+            let turned = zoom_delta.ln() / notch;
+            let mut zooming = WheelZoom::at(app, place, sh.zoom, now);
+            if now - zooming.time > WHEEL_ZOOM_IDLE {
+                zooming.notches = 0.0;
+            }
+            if turned.is_finite() {
+                zooming.notches = (zooming.notches + turned).clamp(-32.0, 32.0);
+            }
+            zooming.time = now;
+            // A notch steps once 60% of it has turned, and the rest of it brings `notches` back to
+            // about 0. (Past half, so what's left after a step can't step back.) Steps count from
+            // where a glide is going, not from where it has got to.
+            let from = zooming.glide.map_or(sh.zoom, |(to, _)| to);
+            let mut z = from;
+            while zooming.notches >= 0.6 {
+                z = wheel_zoom_step(z, true);
+                zooming.notches -= 1.0;
+            }
+            while zooming.notches <= -0.6 {
+                z = wheel_zoom_step(z, false);
+                zooming.notches += 1.0;
+            }
+            if z != from {
+                zooming.glide = Some((z, sh.zoom));
+            }
+            app.grid.wheel_zoom = Some(zooming);
+        } else if scroll_delta != egui::Vec2::ZERO {
+            let z = if paper { make_geo(app, view.scroll).z } else { sh.zoom as f32 / 100.0 * DISPLAY_SCALE };
+            let mut d = scroll_delta;
+            // A horizontal swipe moves the content the way the fingers go, which is towards
+            // higher columns on a mirrored sheet.
+            if sh.right_to_left {
+                d.x = -d.x;
+            }
+            if modifiers.shift && d.x == 0.0 {
+                d = vec2(d.y, 0.0);
+            }
+            view.scroll -= d / z;
+        }
+    }
+    // A one-finger touch drag pans the sheet, the content following the finger; it doesn't select.
+    // (Two fingers pinch-zoom through `zoom_delta` above.)
+    if resp.drag_started() && ui.input(|i| i.any_touches()) {
+        app.grid.touch_pan = true;
+    }
+    if app.grid.touch_pan && resp.dragged() && ui.input(|i| i.multi_touch().is_none()) {
+        let z = if paper { make_geo(app, view.scroll).z } else { sh.zoom as f32 / 100.0 * DISPLAY_SCALE };
+        let mut d = resp.drag_delta();
+        if sh.right_to_left {
+            d.x = -d.x;
+        }
+        view.scroll -= d / z;
+    }
+    // The zoom glides to its step like egui eases a wheel notch (90% of the way in 0.1 s), or goes
+    // there at once without animations (as for the selection outline below: View › Animations
+    // off, egui's off in the headless harness, or a screenshot on its way).
+    let mut zooming = WheelZoom::at(app, place, sh.zoom, now);
+    if let Some((to, shown)) = zooming.glide {
+        let glides = app.ui.animations && ui.ctx().global_style().animation_time > 0.0 && !app.shots.in_flight();
+        let share = egui::emath::exponential_smooth_factor(0.9, 0.1, ui.input(|i| i.stable_dt).min(0.1));
+        let z = if glides { zoom_glide_step(shown, to, share) } else { to };
+        let _ = app.session.run("view.zoom", json!({"percent": z}));
+        zooming.glide = (z != to).then_some((to, z));
+        ui.ctx().request_repaint();
+    }
+    // Store a glide's progress, or that it stopped.
+    if app.grid.wheel_zoom.is_some_and(|w| w.glide.is_some()) {
+        app.grid.wheel_zoom = Some(zooming);
+    }
+    view.scroll = view.scroll.max(egui::Vec2::ZERO);
+    let (mut max_x, mut max_y) = (sh.col_left(MAX_COLS - 20) as f32, sh.row_top(MAX_ROWS - 40) as f32);
+    if paper {
+        // Page layout units run past sheet units (margins and gaps); the end is known once the
+        // pages reach the last row / column.
+        let g = make_geo(app, view.scroll);
+        if let Some(pg) = &g.paper {
+            let (ex, ey) = pg.extent();
+            max_x = if pg.cols_complete { (ex as f32 - g.cells.width() / g.z).max(0.0) } else { 1.0e9 };
+            max_y = if pg.rows_complete { (ey as f32 - g.cells.height() / g.z).max(0.0) } else { 1.0e9 };
+        }
+    }
+    view.scroll.x = view.scroll.x.min(max_x);
+    view.scroll.y = view.scroll.y.min(max_y);
+    let mut geo = make_geo(app, view.scroll);
+    // Keep the active cell (or the moving end of an extension) visible after keyboard moves.
+    if app.grid.ensure_visible {
+        app.grid.ensure_visible = false;
+        let moving = std::mem::take(&mut app.grid.reveal_moving_end);
+        let cell = if moving { sel.moving_end() } else { sel.active };
+        let from = app.grid.reveal_from.take();
+        let target = app.editor.as_ref().and_then(|e| e.point_cell).unwrap_or(cell);
+        // A whole column's moving end sits on the sheet's last row (a whole row's on its last
+        // column): when an extension moves it only across, the view keeps its place the other way.
+        // An extension that reaches the last row itself (Ctrl+Shift+Down past the data) still
+        // follows it.
+        let extended = (moving && target == cell).then(|| sel.current());
+        let before = view.scroll;
+        if paper {
+            crate::paper_view::ensure_covers(app, &wb, si, target);
+            geo = make_geo(app, view.scroll);
+        }
+        let cr = geo.cell_rect(sh, target);
+        let area = Rect::from_min_max(pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h), geo.cells.max);
+        if target.row >= geo.fr {
+            if cr.top() < area.top() {
+                view.scroll.y -= (area.top() - cr.top()) / geo.z;
+            } else if cr.bottom() > area.bottom() - 2.0 {
+                view.scroll.y += (cr.bottom() - area.bottom() + 2.0) / geo.z;
+            }
+        } else if from.is_some_and(|f| f.row >= geo.fr) {
+            // A move from the scrolled rows into the frozen ones (Page Up or Ctrl+Up onto a frozen
+            // row 1) brings the scrolled rows back to their top; the rows it passed over would
+            // otherwise stay out of sight.
+            view.scroll.y = 0.0;
+        }
+        if target.col >= geo.fc {
+            if cr.left() < area.left() {
+                view.scroll.x -= (area.left() - cr.left()) / geo.z;
+            } else if cr.right() > area.right() - 2.0 {
+                view.scroll.x += ((cr.right() - area.right() + 2.0) / geo.z).min(cr.left() - area.left());
+            }
+        } else if from.is_some_and(|f| f.col >= geo.fc) {
+            view.scroll.x = 0.0;
+        }
+        if extended.is_some_and(|r| r.is_full_cols()) && from.is_some_and(|f| f.row == cell.row) {
+            view.scroll.y = before.y;
+        }
+        if extended.is_some_and(|r| r.is_full_rows()) && from.is_some_and(|f| f.col == cell.col) {
+            view.scroll.x = before.x;
+        }
+        view.scroll = view.scroll.max(egui::Vec2::ZERO);
+        geo = make_geo(app, view.scroll);
+    }
+    // Snap scrolling to whole rows/columns at rest like Excel? Keep smooth (better on trackpads).
+    if let Some(v) = app.view_mut() {
+        *v = view;
+    }
+    app.grid.cells_rect = Some(geo.mirror_rect(geo.cells));
+    // The selection outline glides to a new selection. It stays on its cells when Animations is
+    // off, when egui's animations are (the headless harness), and while a screenshot is on its way.
+    // A mouse button held down (a click or a drag selecting cells) moves it at once, as in Excel:
+    // a gliding outline trails the pointer and reads as lag.
+    let pointer_selecting = ui.input(|i| i.pointer.any_down());
+    let outline = app.grid.glide.frame(crate::selection_glide::Frame {
+        place,
+        range: sel.current(),
+        target: geo.range_rect(sh, sel.current()),
+        view: geo.cells,
+        now,
+        frame_nr: ui.ctx().cumulative_frame_nr(),
+        animate: app.ui.animations && ui.ctx().global_style().animation_time > 0.0 && !app.shots.in_flight() && !pointer_selecting,
+    });
+    if app.grid.glide.is_gliding() {
+        ui.ctx().request_repaint();
+    }
+    app.grid.geo = Some(geo.clone());
+    let painter = ui.painter_at(rect);
+    painter.rect_filled(rect, 0.0, t.grid_bg);
+    // Everything up to the headers is painted in logical (left-to-right) coordinates.
+    let mirror_from = painter.add(egui::Shape::Noop);
+    let mut cf = CfCache::new();
+    let quads = if geo.paper.is_some() {
+        crate::paper_view::paint_pages(app, &painter, &geo, &wb, si, sh, &sel, outline, &mut cf, &t)
+    } else {
+        paint_panes(app, &painter, &geo, &wb, si, sh, &sel, outline, &mut cf, &t)
+    };
+    // Objects above cells. A hidden object can't stay selected: Delete or the Format pane would act
+    // on something the user can't see.
+    if crate::chartview::objects_hidden(&wb) {
+        app.selected_chart = None;
+    }
+    let objects = crate::chartview::paint_objects(app, &painter.with_clip_rect(geo.cells), &geo, &wb, si, sh);
+    paint_overlays(app, ui, &painter.with_clip_rect(geo.cells), &geo, &wb, si, sh, &sel);
+    if sh.view == gridcraft_engine::model::SheetViewMode::PageBreakPreview {
+        paint_pages(app, &painter.with_clip_rect(geo.cells), &geo, sh);
+    }
+    if geo.paper.is_some() {
+        crate::paper_view::paint_headers_footers(app, ui, &painter, &geo, &wb, sh);
+    }
+    // Headers.
+    if sh.show_headings {
+        let headings = table_headings(&geo, sh, sel.active);
+        paint_headers(&painter, &geo, sh, &sel, &t, &quads, &headings);
+        paint_freeze_handles(&painter, &geo, sh, &app.grid.drag, &t);
+    }
+    crate::outline::paint(&painter, &geo, sh, &t);
+    if geo.rtl {
+        let mirror_to = painter.add(egui::Shape::Noop);
+        mirror_painted(ui.ctx(), painter.layer_id(), mirror_from.0..mirror_to.0, &geo, &objects);
+    }
+    if geo.paper.is_some() {
+        crate::paper_view::paint_rulers(app, &painter, rect, &geo, &t);
+    }
+    // Interaction.
+    let previous_popups = (app.grid.filter_menu, app.grid.list_picker, app.grid.header_menu, app.grid.fill_menu);
+    // A pan the grid never saw end (it was hidden mid-drag) must not swallow the next press.
+    if app.grid.touch_pan && !resp.dragged() && !resp.drag_stopped() {
+        app.grid.touch_pan = false;
+    }
+    if app.grid.touch_pan {
+        // Skip the frames of a touch pan, its release included.
+        if !resp.dragged() {
+            app.grid.touch_pan = false;
+        }
+    } else {
+        crate::paper_view::interact(app, ui, &resp, &geo, sh, &wb);
+        interact(app, ui, &resp, &geo, sh, &wb);
+    }
+    update_cursor(app, ui, &resp, &geo, sh);
+    crate::text_box::show(app, ui, &geo, sh);
+    if app.editor.as_ref().is_some_and(|e| !e.from_formula_bar) {
+        in_cell_editor(app, ui, &geo, sh, &wb);
+    }
+    filter_menu(app, ui, &geo, previous_popups.0 == app.grid.filter_menu);
+    list_picker(app, ui, &geo, previous_popups.1 == app.grid.list_picker);
+    header_menu(app, ui, previous_popups.2 == app.grid.header_menu);
+    context_menu(app, ui);
+    fill_menu(app, ui, previous_popups.3 == app.grid.fill_menu);
+    fill_options_tag(app, ui, &geo, sh);
+    object_menu(app, ui);
+    error_check_tag(app, ui, &geo, sh);
+    let track_x = if rtl { (available.left(), rect.left()) } else { (rect.right(), available.right()) };
+    // The track starts below the column headings and frozen rows; the bar's column beside them
+    // takes its colour too instead of showing a light square in dark mode.
+    ui.painter().rect_filled(Rect::from_min_max(pos2(track_x.0, rect.top()), pos2(track_x.1, rect.bottom())), 0.0, t.tab_bar);
+    vertical_scrollbar(app, ui, sh, &geo, track_x, max_y, &t);
+    if app.session.clipboard.is_some() {
+        // By the clock, not per frame: a gliding outline repaints more often than the ants step.
+        app.grid.marching_phase = crate::selection_glide::ants_phase(now);
+        ui.ctx().request_repaint_after(std::time::Duration::from_millis(60));
+    }
+}
+
+/// Normal view: up to four panes (frozen rows/columns), each painted with its own clip.
+#[allow(clippy::too_many_arguments)]
+fn paint_panes(
+    app: &SheetApp,
+    painter: &Painter,
+    geo: &Geo,
+    wb: &Workbook,
+    si: usize,
+    sh: &Sheet,
+    sel: &gridcraft_engine::Selection,
+    outline: Rect,
+    cf: &mut CfCache,
+    t: &Tokens,
+) -> Vec<((u32, u32), (u32, u32), Rect)> {
+    // Quadrants: (rows, cols, clip).
+    let (sr0, sr1) = geo.scroll_rows(sh);
+    let (sc0, sc1) = geo.scroll_cols(sh);
+    let fr_rows = (0, geo.fr.saturating_sub(1));
+    let fr_cols = (0, geo.fc.saturating_sub(1));
+    let split = pos2(geo.cells.left() + geo.frozen_w, geo.cells.top() + geo.frozen_h);
+    let mut quads = vec![((sr0, sr1), (sc0, sc1), Rect::from_min_max(split, geo.cells.max))];
+    if geo.fr > 0 {
+        quads.push((fr_rows, (sc0, sc1), Rect::from_min_max(pos2(split.x, geo.cells.top()), pos2(geo.cells.right(), split.y))));
+    }
+    if geo.fc > 0 {
+        quads.push(((sr0, sr1), fr_cols, Rect::from_min_max(pos2(geo.cells.left(), split.y), pos2(split.x, geo.cells.bottom()))));
+    }
+    if geo.fr > 0 && geo.fc > 0 {
+        quads.push((fr_rows, fr_cols, Rect::from_min_max(geo.cells.min, split)));
+    }
+    for (rows, cols, clip) in &quads {
+        if rows.0 > rows.1 || cols.0 > cols.1 {
+            continue;
+        }
+        let p = painter.with_clip_rect(*clip);
+        paint_quadrant(&p, geo, wb, si, sh, *rows, *cols, cf, t);
+        paint_selection(&p, geo, sh, sel, outline, t, app, *rows, *cols);
+    }
+    // Freeze lines.
+    if geo.fr > 0 {
+        painter.line_segment([pos2(geo.cells.left(), split.y), pos2(geo.cells.right(), split.y)], Stroke::new(1.0, Color32::from_gray(150)));
+    }
+    if geo.fc > 0 {
+        painter.line_segment([pos2(split.x, geo.cells.top()), pos2(split.x, geo.cells.bottom())], Stroke::new(1.0, Color32::from_gray(150)));
+    }
+    quads
+}
+
+/// The worksheet is painted virtually, so it needs its own scrollbar rather than a
+/// ScrollArea containing all million rows. Keep the scroll extent stable during a drag.
+fn vertical_scrollbar(app: &mut SheetApp, ui: &mut egui::Ui, sh: &Sheet, geo: &Geo, track_x: (f32, f32), limit: f32, t: &Tokens) {
+    let track = Rect::from_min_max(pos2(track_x.0, geo.cells.top() + geo.frozen_h), pos2(track_x.1, geo.cells.bottom()));
+    if track.height() <= 0.0 || track.width() <= 0.0 {
+        return;
+    }
+    let visible = track.height() / geo.z;
+    let scroll = app.view().scroll.y;
+    let last = sh.used_range().map(|r| r.end.row.saturating_add(10)).unwrap_or(100).clamp(100, MAX_ROWS - 1);
+    let content = geo.scroll_top_of(sh, last);
+    let extent = (content - visible).max(scroll).max(0.0).min(limit);
+    let id = ui.scope_id().with("vscroll");
+    let resp = ui.interact(track, id, Sense::click_and_drag());
+    let drag_id = id.with("extent");
+    if resp.drag_started() {
+        ui.ctx().data_mut(|d| d.insert_temp(drag_id, extent));
+    }
+    let extent = if resp.dragged() { ui.ctx().data(|d| d.get_temp::<f32>(drag_id)).unwrap_or(extent) } else { extent };
+    let thumb_h = (track.height() * visible / (extent + visible)).clamp(24.0_f32.min(track.height()), track.height());
+    let travel = track.height() - thumb_h;
+    let thumb_top = track.top() + if extent > 0.0 { travel * (scroll / extent).clamp(0.0, 1.0) } else { 0.0 };
+    let thumb = Rect::from_min_size(pos2(track.left() + 3.0, thumb_top), vec2((track.width() - 6.0).max(0.0), thumb_h));
+    ui.painter().rect_filled(track, 0.0, t.tab_bar);
+    ui.painter().rect_filled(thumb, 4.0, if resp.hovered() || resp.dragged() { t.text_dim } else { t.text_disabled });
+    let mut next = scroll;
+    if resp.dragged() && travel > 0.0 {
+        next += resp.drag_delta().y / travel * extent;
+    } else if resp.clicked()
+        && let Some(p) = resp.interact_pointer_pos()
+    {
+        if p.y < thumb.top() {
+            next -= visible;
+        } else if p.y > thumb.bottom() {
+            next += visible;
+        }
+    }
+    if resp.hovered() {
+        next -= ui.input(|i| i.smooth_scroll_delta.y) / geo.z;
+    }
+    next = next.clamp(0.0, limit);
+    if next != scroll {
+        if let Some(v) = app.view_mut() {
+            v.scroll.y = next;
+        }
+        ui.ctx().request_repaint();
+    }
+}
+
+/// The horizontal counterpart of `vertical_scrollbar`, drawn in the sheet tab bar as in Excel. The tab
+/// bar is laid out before the grid, so this reads the last frame's geometry and leaves clamping the
+/// far end to the grid, which runs later in the same frame.
+pub(crate) fn horizontal_scrollbar(app: &mut SheetApp, ui: &mut egui::Ui, track: Rect, t: &Tokens) {
+    app.grid.hscroll = Some(track);
+    if track.height() <= 0.0 || track.width() <= 0.0 {
+        return;
+    }
+    let Some(geo) = app.grid.geo.clone() else { return };
+    let Some(wb) = app.session.active().map(|d| d.wb.clone()) else { return };
+    let Some(sh) = wb.active() else { return };
+    let visible = ((geo.cells.width() - geo.frozen_w) / geo.z).max(0.0);
+    let scroll = app.view().scroll.x;
+    let last = sh.used_range().map(|r| r.end.col.saturating_add(10)).unwrap_or(26).clamp(26, MAX_COLS - 1);
+    let content = geo.scroll_left_of(sh, last);
+    let extent = (content - visible).max(scroll).max(0.0);
+    let id = ui.scope_id().with("hscroll");
+    let resp = ui.interact(track, id, Sense::click_and_drag());
+    let drag_id = id.with("extent");
+    if resp.drag_started() {
+        ui.ctx().data_mut(|d| d.insert_temp(drag_id, extent));
+    }
+    let extent = if resp.dragged() { ui.ctx().data(|d| d.get_temp::<f32>(drag_id)).unwrap_or(extent) } else { extent };
+    let thumb_w = (track.width() * visible / (extent + visible).max(1.0)).clamp(24.0_f32.min(track.width()), track.width());
+    let travel = track.width() - thumb_w;
+    let offset = if extent > 0.0 { travel * (scroll / extent).clamp(0.0, 1.0) } else { 0.0 };
+    // A right-to-left sheet scrolls towards the left, so its thumb starts at the right end.
+    let dir = if geo.rtl { -1.0 } else { 1.0 };
+    let thumb_left = if geo.rtl { track.right() - thumb_w - offset } else { track.left() + offset };
+    let thumb = Rect::from_min_size(pos2(thumb_left, track.top() + 3.0), vec2(thumb_w, (track.height() - 6.0).max(0.0)));
+    ui.painter().rect_filled(track, 0.0, t.tab_bar);
+    ui.painter().rect_filled(thumb, 4.0, if resp.hovered() || resp.dragged() { t.text_dim } else { t.text_disabled });
+    let mut next = scroll;
+    if resp.dragged() && travel > 0.0 {
+        next += dir * resp.drag_delta().x / travel * extent;
+    } else if resp.clicked()
+        && let Some(p) = resp.interact_pointer_pos()
+    {
+        if p.x < thumb.left() {
+            next -= dir * visible;
+        } else if p.x > thumb.right() {
+            next += dir * visible;
+        }
+    }
+    if resp.hovered() {
+        let d = ui.input(|i| i.smooth_scroll_delta);
+        next -= (if d.x != 0.0 { dir * d.x } else { d.y }) / geo.z;
+    }
+    next = next.max(0.0);
+    if next != scroll {
+        if let Some(v) = app.view_mut() {
+            v.scroll.x = next;
+        }
+        ui.ctx().request_repaint();
+    }
+}
+
+pub(crate) fn paint_headers(
+    p: &Painter,
+    geo: &Geo,
+    sh: &Sheet,
+    sel: &gridcraft_engine::Selection,
+    t: &Tokens,
+    quads: &[((u32, u32), (u32, u32), Rect)],
+    headings: &[TableHeading],
+) {
+    let font = theme::ui_font(heading_font_size(geo.z));
+    // The headers' own area: inside the outline bands.
+    let r = Rect::from_min_max(pos2(geo.head_left(), geo.head_top()), geo.rect.max);
+    let top = Rect::from_min_max(pos2(geo.cells.left(), r.top()), pos2(r.right(), geo.cells.top()));
+    let left = Rect::from_min_max(pos2(r.left(), geo.cells.top()), pos2(geo.cells.left(), r.bottom()));
+    p.rect_filled(top, 0.0, t.header_bg);
+    p.rect_filled(left, 0.0, t.header_bg);
+    let bounds = sel.bounds();
+    let col_sel = |c: u32| sel.ranges.iter().any(|x| c >= x.start.col && c <= x.end.col);
+    let row_sel = |rr: u32| sel.ranges.iter().any(|x| rr >= x.start.row && rr <= x.end.row);
+    let full_col = |c: u32| sel.ranges.iter().any(|x| x.is_full_cols() && c >= x.start.col && c <= x.end.col);
+    let full_row = |rr: u32| sel.ranges.iter().any(|x| x.is_full_rows() && rr >= x.start.row && rr <= x.end.row);
+    let _ = bounds;
+    // Hidden columns and rows leave a double divider where they sit, as in Excel.
+    let hidden_mark = Stroke::new(1.0, t.header_text.gamma_multiply(0.6));
+    let mut done_cols = std::collections::HashSet::new();
+    let mut done_rows = std::collections::HashSet::new();
+    for (rows, cols, clip) in quads {
+        let pc = p.with_clip_rect(Rect::from_min_max(pos2(clip.left(), top.top()), pos2(clip.right(), top.bottom())));
+        if cols.0 <= cols.1 {
+            for c in cols.0..=cols.1 {
+                if !done_cols.insert((c, clip.left() as i32)) {
+                    continue;
+                }
+                let w = sh.col_width(c) * geo.z;
+                if w <= 0.0 {
+                    continue;
+                }
+                let x = geo.x(sh, c);
+                let cr = Rect::from_min_size(pos2(x, top.top()), vec2(w, top.height()));
+                if col_sel(c) {
+                    pc.rect_filled(cr, 0.0, if full_col(c) { t.header_all_bg } else { t.header_sel_bg });
+                    pc.line_segment([pos2(cr.left(), cr.bottom() - 1.0), pos2(cr.right(), cr.bottom() - 1.0)], Stroke::new(2.0, t.accent));
+                }
+                pc.line_segment([pos2(cr.right() - 0.5, cr.top() + 3.0), pos2(cr.right() - 0.5, cr.bottom())], Stroke::new(1.0, t.header_line));
+                let (before, after) = hidden_around(c, |i| sh.col_width(i));
+                for x in [before.then_some(cr.left()), after.then_some(cr.right())].into_iter().flatten() {
+                    for dx in [-1.5, 1.5] {
+                        pc.line_segment([pos2(x + dx, cr.top() + 3.0), pos2(x + dx, cr.bottom())], hidden_mark);
+                    }
+                }
+                let color = if col_sel(c) { t.header_sel_text } else { t.header_text };
+                match headings.iter().find(|h| h.col == c) {
+                    Some(h) => {
+                        // The name is cut off at the button, as a cell's text is at its neighbour.
+                        let end = h.button.map_or(cr.right(), |b| b.left()) - 2.0;
+                        let room = Rect::from_min_max(cr.min, pos2(end.max(cr.left()), cr.bottom())).intersect(pc.clip_rect());
+                        let pad = 4.0 * (geo.z / DISPLAY_SCALE).max(0.75);
+                        pc.with_clip_rect(room).text(pos2(cr.left() + pad, cr.center().y), Align2::LEFT_CENTER, &h.name, font.clone(), color);
+                        if let Some(b) = h.button {
+                            paint_filter_button(&pc, b, h.filtered);
+                        }
+                    }
+                    None => {
+                        pc.text(cr.center(), Align2::CENTER_CENTER, col_to_letters(c), font.clone(), color);
+                    }
+                }
+            }
+        }
+        let pr = p.with_clip_rect(Rect::from_min_max(pos2(left.left(), clip.top()), pos2(left.right(), clip.bottom())));
+        if rows.0 <= rows.1 {
+            for rr in rows.0..=rows.1 {
+                if !done_rows.insert((rr, clip.top() as i32)) {
+                    continue;
+                }
+                let h = sh.row_height(rr) * geo.z;
+                if h <= 0.0 {
+                    continue;
+                }
+                let y = geo.y(sh, rr);
+                let cr = Rect::from_min_size(pos2(left.left(), y), vec2(left.width(), h));
+                if row_sel(rr) {
+                    pr.rect_filled(cr, 0.0, if full_row(rr) { t.header_all_bg } else { t.header_sel_bg });
+                    pr.line_segment([pos2(cr.right() - 1.0, cr.top()), pos2(cr.right() - 1.0, cr.bottom())], Stroke::new(2.0, t.accent));
+                }
+                pr.line_segment([pos2(cr.left() + 3.0, cr.bottom() - 0.5), pos2(cr.right(), cr.bottom() - 0.5)], Stroke::new(1.0, t.header_line));
+                let (before, after) = hidden_around(rr, |i| sh.row_height(i));
+                for y in [before.then_some(cr.top()), after.then_some(cr.bottom())].into_iter().flatten() {
+                    for dy in [-1.5, 1.5] {
+                        pr.line_segment([pos2(cr.left() + 3.0, y + dy), pos2(cr.right(), y + dy)], hidden_mark);
+                    }
+                }
+                let color = if row_sel(rr) { t.header_sel_text } else { t.header_text };
+                pr.text(cr.center(), Align2::CENTER_CENTER, (rr as u64 + 1).to_string(), font.clone(), color);
+            }
+        }
+    }
+    // Corner (select all) and edges.
+    let corner = Rect::from_min_max(r.min, geo.cells.min);
+    p.rect_filled(corner, 0.0, t.header_bg);
+    let tri = vec![
+        pos2(corner.right() - 3.0, corner.top() + 5.0),
+        pos2(corner.right() - 3.0, corner.bottom() - 3.0),
+        pos2(corner.left() + 7.0, corner.bottom() - 3.0),
+    ];
+    p.add(egui::Shape::convex_polygon(tri, Color32::from_gray(190), Stroke::NONE));
+    p.line_segment([pos2(r.left(), geo.cells.top() - 0.5), pos2(r.right(), geo.cells.top() - 0.5)], Stroke::new(1.0, t.header_line));
+    p.line_segment([pos2(geo.cells.left() - 0.5, r.top()), pos2(geo.cells.left() - 0.5, r.bottom())], Stroke::new(1.0, t.header_line));
+}
+
+/// Whether the line before / after visible line `i` is hidden (zero size), so its header edges
+/// get the hidden marker. Line 0 has nothing before it.
+pub(super) fn hidden_around(i: u32, size: impl Fn(u32) -> f32) -> (bool, bool) {
+    (i > 0 && size(i - 1) <= 0.0, i < u32::MAX && size(i + 1) <= 0.0)
+}
+
+#[allow(clippy::too_many_arguments)]
+/// Paints the validation arrow and input message, notes, the hyperlink tooltip and trace precedent/dependent arrows.
+pub(crate) fn paint_overlays(
+    app: &mut SheetApp,
+    ui: &egui::Ui,
+    p: &Painter,
+    geo: &Geo,
+    wb: &Workbook,
+    si: usize,
+    sh: &Sheet,
+    sel: &gridcraft_engine::Selection,
+) {
+    // Validation dropdown arrow for the active cell.
+    if app.editor.is_none()
+        && let Some(r) = validation_arrow(sh, geo, sel.active)
+    {
+        let t = Tokens::get(p.ctx());
+        p.rect_filled(r, 2.0, t.sheet_control_bg);
+        p.rect_stroke(r, 2.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Inside);
+        crate::icons::paint_on_sheet(p, r.shrink(3.0), crate::icons::Icon::Chevron, t.sheet_control_text);
+    }
+    // Input message of the active cell's validation, hidden while its list is open: it would cover the items.
+    if app.editor.is_none()
+        && app.grid.list_picker != Some(sel.active)
+        && let Some(dv) = sh.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(sel.active)))
+        && dv.show_input
+        && !(dv.input_title.is_empty() && dv.input_message.is_empty())
+        && !geo.hidden_under_frozen(sh, sel.active)
+    {
+        let r = geo.cell_rect(sh, sel.active);
+        let (at, pivot) = (geo.mirror_pos(pos2(r.left() + 8.0, r.bottom() + 6.0)), if geo.rtl { Align2::RIGHT_TOP } else { Align2::LEFT_TOP });
+        egui::Area::new(egui::Id::unique("dv_input")).fixed_pos(at).pivot(pivot).order(egui::Order::Tooltip).interactable(false).show(
+            ui.ctx(),
+            |ui| {
+                egui::Frame::popup(ui.style()).fill(Color32::from_rgb(0xFF, 0xFF, 0xE1)).show(ui, |ui| {
+                    ui.set_max_width(220.0);
+                    if !dv.input_title.is_empty() {
+                        ui.label(egui::RichText::new(&dv.input_title).strong().color(Color32::BLACK));
+                    }
+                    ui.label(egui::RichText::new(&dv.input_message).color(Color32::BLACK));
+                });
+            },
+        );
+    }
+    // Notes: shown on hover (or always when marked visible).
+    let hover = app.grid.hover_cell;
+    let all_notes = app.session.show_all_notes;
+    for (c, cm) in &sh.comments {
+        let show = cm.visible || (all_notes && !cm.threaded) || hover == Some(*c);
+        if !show || app.grid.drag != Drag::None {
+            continue;
+        }
+        let r = geo.cell_rect(sh, *c);
+        if !p.clip_rect().intersects(r) || geo.hidden_under_frozen(sh, *c) {
+            continue;
+        }
+        let at = pos2(r.right() + 10.0, r.top());
+        p.line_segment([r.right_top(), at + vec2(0.0, 6.0)], Stroke::new(1.0, Color32::from_gray(90)));
+        let (at, pivot) = (geo.mirror_pos(at), if geo.rtl { Align2::RIGHT_TOP } else { Align2::LEFT_TOP });
+        egui::Area::new(egui::Id::unique(("note", c.row, c.col))).fixed_pos(at).pivot(pivot).order(egui::Order::Tooltip).interactable(false).show(
+            ui.ctx(),
+            |ui| {
+                egui::Frame::popup(ui.style()).fill(if cm.threaded { Color32::WHITE } else { Color32::from_rgb(0xFF, 0xFF, 0xE1) }).show(ui, |ui| {
+                    ui.set_max_width(240.0);
+                    ui.label(egui::RichText::new(format!("{}:", cm.author)).strong().color(Color32::BLACK));
+                    ui.label(egui::RichText::new(&cm.text).color(Color32::BLACK));
+                    for (a, t) in &cm.replies {
+                        ui.separator();
+                        ui.label(egui::RichText::new(format!("{a}: {t}")).color(Color32::BLACK));
+                    }
+                });
+            },
+        );
+    }
+    // Hyperlink tooltip.
+    if let Some(h) = hover.and_then(|c| sh.hyperlinks.get(&c))
+        && app.editor.is_none()
+    {
+        let tip = h.tooltip.clone().unwrap_or_else(|| format!("{}\nClick once to follow. Click and hold to select this cell.", h.target));
+        egui::Tooltip::always_open(ui.ctx().clone(), ui.layer_id(), egui::Id::unique("link_tip"), egui::PopupAnchor::Pointer).show(|ui| {
+            ui.label(tip);
+        });
+    }
+    // Trace precedents / dependents arrows.
+    if let Some(trace) = &app.grid.trace
+        && app.session.active().is_some_and(|d| d.uid == trace.uid && d.revision == trace.revision)
+        && trace.sheet == si
+        && let Some(items) = trace.items.as_array()
+    {
+        let blue = Color32::from_rgb(0x1F, 0x5F, 0xC9);
+        let active = geo.cell_rect(sh, trace.cell).center();
+        for it in items {
+            if it["sheet"].as_str().is_some_and(|s| !s.eq_ignore_ascii_case(&sh.name)) {
+                continue;
+            }
+            let target = it["range"].as_str().or(it["cell"].as_str()).and_then(RangeRef::parse);
+            let Some(t) = target else { continue };
+            let tr = geo.range_rect(sh, t);
+            if !t.is_single() {
+                for pane in geo.range_panes(t) {
+                    p.with_clip_rect(pane.intersect(p.clip_rect())).rect_stroke(tr, 0.0, Stroke::new(1.5, blue), StrokeKind::Inside);
+                }
+            }
+            let (from, to) = if it.get("range").is_some() { (tr.center(), active) } else { (active, tr.center()) };
+            p.line_segment([from, to], Stroke::new(1.5, blue));
+            p.circle_filled(from, 3.0, blue);
+            let d = (to - from).normalized();
+            let n = vec2(-d.y, d.x);
+            p.add(egui::Shape::convex_polygon(vec![to, to - d * 9.0 + n * 4.0, to - d * 9.0 - n * 4.0], blue, Stroke::NONE));
+        }
+    }
+    let _ = (wb, si);
+}
+
+fn paint_pages(app: &mut SheetApp, p: &Painter, geo: &Geo, sh: &Sheet) {
+    let Some(d) = app.session.active() else { return };
+    let key = (d.uid, d.revision, d.wb.active_sheet());
+    if app.grid.pages.as_ref().is_none_or(|(k, _)| *k != key) {
+        let pages: Vec<(RangeRef, u32)> = app
+            .session
+            .run("file.printPreview", json!({}))
+            .ok()
+            .and_then(|v| {
+                v["pageList"].as_array().map(|a| {
+                    a.iter()
+                        .filter(|pg| pg["sheet"].as_str() == Some(sh.name.as_str()))
+                        .filter_map(|pg| Some((RangeRef::parse(pg["range"].as_str()?)?, pg["page"].as_u64()? as u32)))
+                        .collect()
+                })
+            })
+            .unwrap_or_default();
+        app.grid.pages = Some((key, pages));
+    }
+    let Some((_, pages)) = &app.grid.pages else { return };
+    if pages.is_empty() {
+        return;
+    }
+    // Grey everything, then clear the printed pages.
+    let mut printed = pages[0].0;
+    for (r, _) in pages {
+        printed = printed.union(r);
+    }
+    let pr = geo.range_rect(sh, printed);
+    let grey = Color32::from_black_alpha(70);
+    let c = p.clip_rect();
+    for r in [
+        Rect::from_min_max(c.min, pos2(c.right(), pr.top())),
+        Rect::from_min_max(pos2(c.left(), pr.bottom()), c.max),
+        Rect::from_min_max(pos2(c.left(), pr.top()), pos2(pr.left(), pr.bottom())),
+        Rect::from_min_max(pos2(pr.right(), pr.top()), pos2(c.right(), pr.bottom())),
+    ] {
+        if r.is_positive() {
+            p.rect_filled(r, 0.0, grey);
+        }
+    }
+    let blue = Color32::from_rgb(0x2E, 0x6F, 0xD8);
+    for (r, n) in pages {
+        let rr = geo.range_rect(sh, *r);
+        if !rr.intersects(c) {
+            continue;
+        }
+        p.extend(egui::Shape::dashed_line(
+            &[rr.left_top(), rr.right_top(), rr.right_bottom(), rr.left_bottom(), rr.left_top()],
+            Stroke::new(2.0, blue),
+            6.0,
+            3.0,
+        ));
+        p.text(
+            rr.center(),
+            Align2::CENTER_CENTER,
+            format!("Page {n}"),
+            theme::ui_bold((rr.height().min(rr.width()) / 6.0).clamp(14.0, 72.0)),
+            Color32::from_black_alpha(45),
+        );
+    }
+    p.rect_stroke(pr, 0.0, Stroke::new(3.0, blue), StrokeKind::Outside);
+}
+
+#[cfg(test)]
+mod trace_arrow_tests {
+    use super::*;
+
+    fn app() -> SheetApp {
+        let mut s = gridcraft_engine::Session::new();
+        s.new_workbook();
+        SheetApp::new(s, Default::default())
+    }
+
+    fn select(app: &mut SheetApp, cell: &str) {
+        app.run("selection.set", json!({"cell": cell})).unwrap();
+    }
+
+    /// What the ribbon's Trace Precedents / Trace Dependents buttons do.
+    fn trace(app: &mut SheetApp, id: &str) {
+        let r = app.run(id, json!({})).unwrap();
+        app.grid.trace = Trace::new(app, r);
+    }
+
+    /// The arrows `paint_overlays` draws on the active sheet, as (tail, head) points.
+    fn arrows(app: &mut SheetApp) -> (Geo, Vec<(Pos2, Pos2)>) {
+        let d = app.session.active().unwrap();
+        let (wb, si, sel) = (d.wb.clone(), d.wb.active_sheet(), d.selection.clone());
+        let sh = wb.sheet(si).unwrap();
+        let geo = Geo::new(sh, Rect::from_min_size(pos2(0.0, 0.0), vec2(1200.0, 800.0)), vec2(0.0, 0.0));
+        let ctx = egui::Context::default();
+        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
+            let p = ui.painter().clone();
+            paint_overlays(app, ui, &p, &geo, &wb, si, sh, &sel);
+        });
+        // No renderer consumes the font atlas upload here.
+        out.textures_delta.clear();
+        let blue = Color32::from_rgb(0x1F, 0x5F, 0xC9);
+        let mut lines = Vec::new();
+        for s in out.shapes {
+            if let egui::Shape::LineSegment { points, stroke } = s.shape
+                && stroke.color == blue
+            {
+                lines.push((points[0], points[1]));
+            }
+        }
+        (geo, lines)
+    }
+
+    fn center(app: &SheetApp, geo: &Geo, cell: &str) -> Pos2 {
+        let d = app.session.active().unwrap();
+        let sh = d.wb.sheet(d.wb.active_sheet()).unwrap();
+        geo.cell_rect(sh, CellRef::parse(cell).unwrap()).center()
+    }
+
+    #[test]
+    fn precedent_arrows_stay_on_the_traced_cell_when_the_selection_moves() {
+        let mut app = app();
+        for (c, v) in [("B2", "1"), ("B3", "2"), ("D2", "1"), ("D3", "2"), ("F7", "=B2+B3+SUM(D2:D3)")] {
+            app.run("cell.set", json!({"cell": c, "input": v})).unwrap();
+        }
+        select(&mut app, "F7");
+        trace(&mut app, "formulas.tracePrecedents");
+        select(&mut app, "H7");
+        let (geo, lines) = arrows(&mut app);
+        assert_eq!(lines.len(), 3, "B2, B3 and D2:D3: {lines:?}");
+        let f7 = center(&app, &geo, "F7");
+        assert!(lines.iter().all(|&(_, head)| head == f7), "every arrow points at F7, not at the active H7: {lines:?}");
+    }
+
+    #[test]
+    fn dependent_arrows_stay_on_the_traced_cell_when_the_selection_moves() {
+        let mut app = app();
+        for (c, v) in [("B2", "1"), ("D4", "=B2*2"), ("E6", "=B2+1")] {
+            app.run("cell.set", json!({"cell": c, "input": v})).unwrap();
+        }
+        select(&mut app, "B2");
+        trace(&mut app, "formulas.traceDependents");
+        select(&mut app, "C9");
+        let (geo, lines) = arrows(&mut app);
+        assert_eq!(lines.len(), 2, "D4 and E6: {lines:?}");
+        let b2 = center(&app, &geo, "B2");
+        assert!(lines.iter().all(|&(tail, _)| tail == b2), "every arrow starts at B2, not at the active C9: {lines:?}");
+    }
+
+    #[test]
+    fn arrows_stay_on_the_sheet_of_the_traced_cell() {
+        let mut app = app();
+        app.run("home.insertSheet", json!({"name": "Two"})).unwrap();
+        app.run("cell.set", json!({"sheet": "Sheet1", "cell": "B2", "input": "1"})).unwrap();
+        app.run("sheet.activate", json!({"sheet": "Two"})).unwrap();
+        app.run("cell.set", json!({"cell": "F7", "input": "=Sheet1!B2"})).unwrap();
+        select(&mut app, "F7");
+        trace(&mut app, "formulas.tracePrecedents");
+        // The precedent lives on Sheet1, but the arrow belongs to Two's F7.
+        app.run("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
+        assert!(arrows(&mut app).1.is_empty(), "no arrow on Sheet1 from B2 to where F7 would be");
+    }
+
+    #[test]
+    fn inserting_a_row_removes_the_arrows() {
+        let mut app = app();
+        app.run("cell.set", json!({"cell": "B2", "input": "1"})).unwrap();
+        app.run("cell.set", json!({"cell": "F7", "input": "=B2"})).unwrap();
+        select(&mut app, "F7");
+        trace(&mut app, "formulas.tracePrecedents");
+        assert_eq!(arrows(&mut app).1.len(), 1);
+        app.run("home.insertRows", json!({"rows": "4"})).unwrap();
+        assert!(arrows(&mut app).1.is_empty(), "F7 is now F8: the old arrows would point at the wrong cell");
+    }
+
+    #[test]
+    fn arrows_stay_in_their_workbook() {
+        let mut app = app();
+        app.session.new_workbook();
+        // Two books with the same cells and the same revision: only the document tells them apart.
+        for book in [1, 0] {
+            app.session.set_active(book);
+            app.run("cell.set", json!({"cell": "B2", "input": "1"})).unwrap();
+            app.run("cell.set", json!({"cell": "F7", "input": "=B2"})).unwrap();
+        }
+        select(&mut app, "F7");
+        trace(&mut app, "formulas.tracePrecedents");
+        assert_eq!(arrows(&mut app).1.len(), 1);
+        app.session.set_active(1);
+        let revisions: Vec<u64> = app.session.documents().iter().map(|d| d.revision).collect();
+        assert_eq!(revisions[0], revisions[1]);
+        assert!(arrows(&mut app).1.is_empty(), "Book1's arrows are not drawn on Book2");
+    }
+}
diff --git a/crates/ui-egui/src/grid/tables.rs b/crates/ui-egui/src/grid/tables.rs
new file mode 100644
index 000000000..a283b2b22
--- /dev/null
+++ b/crates/ui-egui/src/grid/tables.rs
@@ -0,0 +1,87 @@
+use super::geo::Geo;
+use super::*;
+
+pub fn filter_button_rect(geo: &Geo, sh: &Sheet, c: CellRef) -> Rect {
+    let rect = geo.cell_rect(sh, c);
+    // Keep the button within the same header slot that AutoFit reserves.
+    let pad = 2.0 * geo.z;
+    let s = (rect.height() - 4.0).clamp(10.0, 18.0).min((sh.filter_button_space(c) * geo.z - pad).max(0.0));
+    Rect::from_min_size(pos2(rect.right() - s - pad, rect.bottom() - s - pad), vec2(s, s))
+}
+
+/// A Table column heading that shows the column's header name in place of its letters.
+#[derive(Clone, Debug)]
+pub struct TableHeading {
+    pub col: u32,
+    /// The table's header row, which the filter menu is keyed by.
+    pub header_row: u32,
+    pub name: String,
+    /// The heading slot over the column (logical coordinates).
+    pub rect: Rect,
+    /// The filter button, when the table shows filter buttons.
+    pub button: Option<Rect>,
+    /// The column is filtered (the button shows the funnel).
+    pub filtered: bool,
+}
+
+/// The Table whose header names replace the column letters: the one holding the active cell,
+/// with its header row scrolled out of view and some of its rows still in view (Excel, #1423).
+pub fn heading_table<'a>(geo: &Geo, sh: &'a Sheet, active: CellRef) -> Option<&'a gridcraft_engine::model::Table> {
+    // Page Layout view keeps the letters.
+    if geo.paper.is_some() || geo.header_h <= 0.0 {
+        return None;
+    }
+    let tb = sh.tables.iter().find(|t| t.header_row && t.range.contains(active))?;
+    let header = tb.range.start.row;
+    // A header row in the frozen rows is always on screen.
+    if header < geo.fr {
+        return None;
+    }
+    let top = geo.cells.top() + geo.frozen_h;
+    let bottom = |r: u32| geo.y(sh, r) + sh.row_height(r) * geo.z;
+    (bottom(header) <= top + 0.5 && bottom(tb.range.end.row) > top + 0.5).then_some(tb)
+}
+
+/// The headings of `heading_table`'s visible columns.
+pub fn table_headings(geo: &Geo, sh: &Sheet, active: CellRef) -> Vec<TableHeading> {
+    let Some(tb) = heading_table(geo, sh, active) else { return Vec::new() };
+    let af = sh.autofilter.as_ref().filter(|af| af.range == tb.range);
+    let mut out = Vec::new();
+    for col in tb.range.start.col..=tb.range.end.col {
+        let w = sh.col_width(col) * geo.z;
+        let off = col - tb.range.start.col;
+        let Some(column) = tb.columns.get(off as usize) else { continue };
+        if w <= 0.0 {
+            continue;
+        }
+        let rect = Rect::from_min_size(pos2(geo.x(sh, col), geo.head_top()), vec2(w, geo.header_h));
+        // Clear of the 4-point column resize edge, and never wider than the column.
+        let s = (rect.height() - 6.0).clamp(10.0, 16.0).min(w - 7.0);
+        let button = (tb.filter_button && s > 0.0).then(|| Rect::from_min_size(pos2(rect.right() - s - 5.0, rect.center().y - s / 2.0), vec2(s, s)));
+        let filtered = tb.filter.iter().any(|(o, _)| *o == off) || af.is_some_and(|af| af.criteria.iter().any(|(o, _)| *o == off));
+        out.push(TableHeading { col, header_row: tb.range.start.row, name: column.name.clone(), rect, button, filtered });
+    }
+    out
+}
+
+pub(super) fn paint_filter_button(p: &Painter, r: Rect, filtered: bool) {
+    let t = Tokens::get(p.ctx());
+    p.rect_filled(r, 2.0, t.sheet_control_bg);
+    p.rect_stroke(r, 2.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Inside);
+    crate::icons::paint_on_sheet(
+        p,
+        r.shrink(1.5),
+        if filtered { crate::icons::Icon::Filter } else { crate::icons::Icon::Chevron },
+        t.sheet_control_text,
+    );
+}
+
+pub(super) fn is_filter_button(sh: &Sheet, geo: &Geo, p: Pos2) -> bool {
+    let c = geo.cell_at(sh, p);
+    sh.has_filter_button(c) && filter_button_rect(geo, sh, c).contains(p)
+}
+
+/// The table whose header cell (`row`, `col`) was clicked, not just the first table in the column.
+pub(super) fn filter_table_range(sh: &Sheet, col: u32, row: u32) -> Option<RangeRef> {
+    sh.tables.iter().find(|t| t.range.start.row == row && col >= t.range.start.col && col <= t.range.end.col).map(|t| t.range)
+}

From 9eb2a3d68e1f1e728569af7aeda20809a3c19144 Mon Sep 17 00:00:00 2001
From: skylar <hi@skylar.cc>
Date: Mon, 26 Oct 2026 14:13:04 -0600
Subject: [PATCH 47/76] ci: require nextest 0.9.150

Use the fixed release for GHSA-vc25-qg58-w57c.
---
 .config/nextest.toml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .config/nextest.toml

diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 000000000..2a4cd2cb9
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,3 @@
+# Minimum cargo-nextest for this repository: GHSA-vc25-qg58-w57c is fixed in 0.9.150 and CI
+# installs exactly that version, so an older nextest refuses to run (exit 92 REQUIRED_VERSION_NOT_MET).
+nextest-version = "0.9.150"

From 228cf80593fd770c9703a7219a006fe9f13652a2 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:43:39 +0000
Subject: [PATCH 48/76] refactor(ui-egui): move dialogs.rs items to dialogs/

---
 crates/ui-egui/src/dialogs.rs                 | 2420 +----------------
 crates/ui-egui/src/dialogs/about.rs           |   26 +
 crates/ui-egui/src/dialogs/analysis.rs        |  344 +++
 crates/ui-egui/src/dialogs/charts.rs          |  187 ++
 crates/ui-egui/src/dialogs/command_search.rs  |   88 +
 .../ui-egui/src/dialogs/cond_format_rules.rs  |   28 +
 crates/ui-egui/src/dialogs/data.rs            |  327 +++
 crates/ui-egui/src/dialogs/find.rs            |  151 +
 crates/ui-egui/src/dialogs/format_cells.rs    |  227 ++
 crates/ui-egui/src/dialogs/insert_function.rs |   72 +
 crates/ui-egui/src/dialogs/macros.rs          |   40 +
 crates/ui-egui/src/dialogs/names.rs           |  134 +
 crates/ui-egui/src/dialogs/paste.rs           |  139 +
 crates/ui-egui/src/dialogs/show.rs            |  577 ++++
 crates/ui-egui/src/dialogs/spelling.rs        |   54 +
 crates/ui-egui/src/dialogs/zoom.rs            |   39 +
 16 files changed, 2459 insertions(+), 2394 deletions(-)
 create mode 100644 crates/ui-egui/src/dialogs/about.rs
 create mode 100644 crates/ui-egui/src/dialogs/analysis.rs
 create mode 100644 crates/ui-egui/src/dialogs/charts.rs
 create mode 100644 crates/ui-egui/src/dialogs/command_search.rs
 create mode 100644 crates/ui-egui/src/dialogs/cond_format_rules.rs
 create mode 100644 crates/ui-egui/src/dialogs/data.rs
 create mode 100644 crates/ui-egui/src/dialogs/find.rs
 create mode 100644 crates/ui-egui/src/dialogs/format_cells.rs
 create mode 100644 crates/ui-egui/src/dialogs/insert_function.rs
 create mode 100644 crates/ui-egui/src/dialogs/macros.rs
 create mode 100644 crates/ui-egui/src/dialogs/names.rs
 create mode 100644 crates/ui-egui/src/dialogs/paste.rs
 create mode 100644 crates/ui-egui/src/dialogs/show.rs
 create mode 100644 crates/ui-egui/src/dialogs/spelling.rs
 create mode 100644 crates/ui-egui/src/dialogs/zoom.rs

diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 8d8e71665..3a6003f0f 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -13,6 +13,32 @@ use serde_json::{Map, Value as Json, json};
 use crate::SheetApp;
 use crate::theme;
 
+mod about;
+mod analysis;
+mod charts;
+mod command_search;
+mod cond_format_rules;
+mod data;
+mod find;
+mod format_cells;
+mod insert_function;
+mod macros;
+mod names;
+mod paste;
+mod show;
+mod spelling;
+mod zoom;
+
+use analysis::toolpak_defaults;
+use charts::select_chart;
+use data::{abs, data_validation_fields, remove_duplicates_range, validation_defaults};
+use find::go_to_entries;
+pub(crate) use names::insert_name;
+use names::pasteable_names;
+pub(crate) use show::build_params;
+pub use show::show;
+use zoom::zoom_preset;
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum Field {
     Text { key: &'static str, label: &'static str },
@@ -999,2400 +1025,6 @@ impl Dialog {
     }
 }
 
-/// Initial values of the Data Validation form: the rule stored on the active cell, so OK without
-/// edits keeps it; a plain list rule when the cell has none.
-fn validation_defaults(app: &SheetApp) -> Json {
-    let mut v = json!({"type": "list", "operator": "between", "ignoreBlank": true, "dropdown": true, "errorStyle": "stop"});
-    let Some(doc) = app.session.active() else { return v };
-    let Some(dv) = doc.wb.active().and_then(|s| s.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(doc.selection.active)))) else {
-        return v;
-    };
-    // The enums serialize as their variant names; the command takes them in camelCase.
-    let camel = |x: Json| {
-        let name = x.as_str().unwrap_or_default();
-        let mut chars = name.chars();
-        chars.next().map(|c| c.to_lowercase().chain(chars).collect::<String>()).unwrap_or_default()
-    };
-    v["type"] = json!(camel(json!(dv.kind)));
-    v["operator"] = json!(camel(json!(dv.op)));
-    v["errorStyle"] = json!(camel(json!(dv.error_style)));
-    v["formula1"] = json!(dv.f1);
-    if let Some(f2) = &dv.f2 {
-        v["formula2"] = json!(f2);
-    }
-    v["ignoreBlank"] = json!(dv.allow_blank);
-    v["dropdown"] = json!(dv.in_cell_dropdown);
-    v["inputTitle"] = json!(dv.input_title);
-    v["inputMessage"] = json!(dv.input_message);
-    v["errorTitle"] = json!(dv.error_title);
-    v["errorMessage"] = json!(dv.error_message);
-    v
-}
-
-/// The range Remove Duplicates starts with. A block selection is used as given; with only the
-/// cursor placed, the table's data rows or the current region, as the command picks when it gets
-/// no range (a single-cell range would remove nothing).
-fn remove_duplicates_range(app: &SheetApp, sel: &str) -> String {
-    let Some(d) = app.session.active() else { return sel.to_string() };
-    let Some(sh) = d.wb.active() else { return sel.to_string() };
-    if !d.selection.current().is_single() {
-        return sel.to_string();
-    }
-    let range = match sh.table_at(d.selection.active) {
-        Some(t) => t.data_range().map(|dr| gridcraft_engine::core::RangeRef::new(t.range.start, dr.end)).unwrap_or(t.range),
-        None => gridcraft_engine::selection::current_region(sh, d.selection.active),
-    };
-    range.a1()
-}
-
-fn abs(r: &gridcraft_engine::core::RangeRef) -> String {
-    let a = |c: gridcraft_engine::core::CellRef| format!("${}${}", gridcraft_engine::core::col_to_letters(c.col), c.row + 1);
-    if r.is_single() { a(r.start) } else { format!("{}:{}", a(r.start), a(r.end)) }
-}
-
-/// The criterion controls in Excel's Settings tab depend on both Allow and Data.
-/// `formula1` is the sole source for a list or custom rule; `formula2` is a
-/// second bound only for Between and Not between.
-fn data_validation_fields(kind: &str, operator: &str) -> Vec<Field> {
-    use Field::*;
-    let mut fields = vec![Choice {
-        key: "type",
-        label: "Allow",
-        options: vec![
-            ("any", "Any value"),
-            ("whole", "Whole number"),
-            ("decimal", "Decimal"),
-            ("list", "List"),
-            ("date", "Date"),
-            ("time", "Time"),
-            ("textLength", "Text length"),
-            ("custom", "Custom"),
-        ],
-    }];
-    let two_bounds = matches!(operator, "between" | "notBetween");
-    match kind {
-        "list" => {
-            fields.push(Text { key: "formula1", label: "Source:" });
-            fields.push(Check { key: "ignoreBlank", label: "Ignore blank" });
-            fields.push(Check { key: "dropdown", label: "In-cell dropdown" });
-        }
-        "custom" => {
-            fields.push(Text { key: "formula1", label: "Formula:" });
-            fields.push(Check { key: "ignoreBlank", label: "Ignore blank" });
-        }
-        "whole" | "decimal" | "date" | "time" | "textLength" => {
-            fields.push(Choice {
-                key: "operator",
-                label: "Data",
-                options: vec![
-                    ("between", "between"),
-                    ("notBetween", "not between"),
-                    ("equal", "equal to"),
-                    ("notEqual", "not equal to"),
-                    ("greater", "greater than"),
-                    ("less", "less than"),
-                    ("greaterOrEqual", "greater than or equal to"),
-                    ("lessOrEqual", "less than or equal to"),
-                ],
-            });
-            let lower = matches!(operator, "greater" | "greaterOrEqual");
-            let (first, second) = match kind {
-                "date" => (
-                    if two_bounds || lower {
-                        "Start date:"
-                    } else if matches!(operator, "less" | "lessOrEqual") {
-                        "End date:"
-                    } else {
-                        "Date:"
-                    },
-                    "End date:",
-                ),
-                "time" => (
-                    if two_bounds || lower {
-                        "Start time:"
-                    } else if matches!(operator, "less" | "lessOrEqual") {
-                        "End time:"
-                    } else {
-                        "Time:"
-                    },
-                    "End time:",
-                ),
-                _ => (
-                    if two_bounds || lower {
-                        "Minimum:"
-                    } else if matches!(operator, "less" | "lessOrEqual") {
-                        "Maximum:"
-                    } else {
-                        "Value:"
-                    },
-                    "Maximum:",
-                ),
-            };
-            fields.push(Text { key: "formula1", label: first });
-            if two_bounds {
-                fields.push(Text { key: "formula2", label: second });
-            }
-            fields.push(Check { key: "ignoreBlank", label: "Ignore blank" });
-        }
-        _ => {}
-    }
-    fields.push(Text { key: "inputMessage", label: "Input message:" });
-    fields.push(Choice {
-        key: "errorStyle",
-        label: "Error style",
-        options: vec![("stop", "Stop"), ("warning", "Warning"), ("information", "Information")],
-    });
-    fields.push(Text { key: "errorMessage", label: "Error message:" });
-    fields
-}
-
-fn data_validation_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    let kind = d.values.get("type").and_then(Json::as_str).unwrap_or("any");
-    let operator = d.values.get("operator").and_then(Json::as_str).unwrap_or("between");
-    d.fields = data_validation_fields(kind, operator);
-    form_fields(ui, d);
-    ok_cancel(ui, confirm, open);
-}
-
-fn advanced_filter_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    use Field::*;
-    let copy = d.values.get("action").and_then(Json::as_str) == Some("copy");
-    d.fields = vec![
-        Choice {
-            key: "action",
-            label: "Action",
-            options: vec![("inPlace", "Show matching rows in place"), ("copy", "Copy matching rows elsewhere")],
-        },
-        Text { key: "range", label: "List range:" },
-        Text { key: "criteria", label: "Criteria range (optional):" },
-    ];
-    if copy {
-        d.fields.push(Text { key: "copyTo", label: "Copy to:" });
-    }
-    d.fields.push(Check { key: "unique", label: "Unique rows only" });
-    form_fields(ui, d);
-    // Constrain the button row: the shared right-to-left layout otherwise
-    // consumes the window's remaining height instead of fitting the buttons.
-    ui.allocate_ui(vec2(ui.available_width(), ui.spacing().interact_size.y + 8.0), |ui| ok_cancel(ui, confirm, open));
-}
-
-/// Builds the command params from form values for dialogs that need translation.
-/// The parameters OK sends to the dialog's command: its field values, reshaped per dialog.
-pub(crate) fn build_params(d: &Dialog) -> Json {
-    let mut v = Json::Object(d.values.clone());
-    match d.name.as_str() {
-        "advancedFilter" => {
-            if let Some(m) = v.as_object_mut() {
-                m.remove("action");
-                if d.values.get("action").and_then(Json::as_str) != Some("copy") {
-                    m.remove("copyTo");
-                }
-                if m.get("criteria").and_then(Json::as_str).is_some_and(|s| s.trim().is_empty()) {
-                    m.remove("criteria");
-                }
-            }
-        }
-        "dataValidation" => {
-            let kind = d.values.get("type").and_then(Json::as_str).unwrap_or("any");
-            let operator = d.values.get("operator").and_then(Json::as_str).unwrap_or("between");
-            if let Some(m) = v.as_object_mut() {
-                if !matches!(operator, "between" | "notBetween") || matches!(kind, "any" | "list" | "custom") {
-                    m.remove("formula2");
-                }
-                if matches!(kind, "any" | "list" | "custom") {
-                    m.remove("operator");
-                }
-                if kind == "any" {
-                    m.remove("formula1");
-                }
-                if kind != "list" {
-                    m.remove("dropdown");
-                }
-            }
-        }
-        "textToColumns" => {
-            let mut delims = Vec::new();
-            for (k, c) in [("tab", "\t"), ("semicolon", ";"), ("comma", ","), ("space", " ")] {
-                if d.values.get(k).and_then(Json::as_bool) == Some(true) {
-                    delims.push(json!(c));
-                }
-            }
-            v["delimiters"] = Json::Array(delims);
-        }
-        "removeDuplicates" | "subtotal" => {
-            if let Some(t) = d.values.get("columnsText").and_then(Json::as_str).filter(|t| !t.trim().is_empty()) {
-                v["columns"] = Json::Array(t.split(',').map(|c| json!(c.trim().to_ascii_uppercase())).collect());
-            }
-        }
-        "allowEditRanges" => {
-            if let Some(m) = v.as_object_mut() {
-                // Blank fields mean "unchanged"; the check box clears a password.
-                m.retain(|_, x| x.as_str().is_none_or(|s| !s.trim().is_empty()));
-                if m.remove("removePassword").and_then(|x| x.as_bool()) == Some(true) {
-                    m.insert("password".into(), json!(""));
-                }
-            }
-        }
-        "cfQuick" => {
-            let mut rule = Map::new();
-            for (k, val) in &d.values {
-                rule.insert(k.clone(), val.clone());
-            }
-            v = json!({"rule": Json::Object(rule)});
-            if let Some(pick) = d.pick.as_ref().filter(|pick| !pick.applies_to.is_empty() && !pick.sheet.is_empty()) {
-                v["sheet"] = json!(pick.sheet.as_str());
-                v["range"] = json!(pick.applies_to);
-            }
-        }
-        "series" => {
-            if let Some(s) = d.values.get("stop").and_then(Json::as_str).and_then(|s| s.parse::<f64>().ok()) {
-                v["stop"] = json!(s);
-            } else if let Some(m) = v.as_object_mut() {
-                m.remove("stop");
-            }
-        }
-        "defineName" => {
-            if let Some(m) = v.as_object_mut() {
-                for key in ["scope", "oldScope"] {
-                    if m.get(key).and_then(Json::as_str) == Some("Workbook") {
-                        m.remove(key);
-                    }
-                }
-            }
-        }
-        _ => {}
-    }
-    v
-}
-
-/// Takes and draws the active dialog, dispatches its body by name, consumes picture-inbox results, runs OK/confirm commands, handles Esc/close and restores the back-dialog stack.
-pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
-    let Some(mut d) = app.dialog.take() else { return };
-    let home = app.ui_window();
-    if d.name == "pasteSpecial" {
-        paste_special_shortcuts(&mut d, ctx);
-    }
-    let mut open = true;
-    let mut win_open = true;
-    let mut confirm = false;
-    let width = match d.name.as_str() {
-        "formatCells" => 560.0,
-        "about" => 660.0,
-        "insertFunction" | "commandSearch" | "nameManager" | "manageRules" | "journal" | "agents" | "macros" => 520.0,
-        "recommendedCharts" => 600.0,
-        "analysisToolPak" => 420.0,
-        "solver" => 460.0,
-        "zoom" => 220.0,
-        "pasteSpecial" => 480.0,
-        _ => 380.0,
-    };
-    let window = egui::Window::new(app.ui.language.tr(&d.title))
-        .id(egui::Id::unique("dialog").with(&d.name))
-        .collapsible(false)
-        .resizable(false)
-        .default_width(width)
-        // A default position, not an anchor: egui anchors can't be dragged, and dialogs move by their title bar.
-        .pivot(egui::Align2::CENTER_CENTER)
-        .default_pos(ctx.content_rect().center() + vec2(0.0, -40.0))
-        .open(&mut win_open);
-    let window = match d.name.as_str() {
-        "insertPicture" => window.default_height(240.0),
-        "advancedFilter" => window.default_height(0.0),
-        _ => window,
-    };
-    window.show(ctx, |ui| {
-            ui.set_min_width(width - 20.0);
-            match d.name.as_str() {
-                "formatCells" => format_cells(app, ui, &mut d, &mut confirm),
-                "dataValidation" => data_validation_form(ui, &mut d, &mut confirm, &mut open),
-                "advancedFilter" => advanced_filter_form(ui, &mut d, &mut confirm, &mut open),
-                "insertFunction" => insert_function(app, ui, &mut d, &mut confirm),
-                "find" => find(app, ui, &mut d),
-                "goTo" => go_to(app, ui, &mut d, &mut confirm),
-                "zoom" => zoom(ui, &mut d, &mut confirm, &mut open),
-                "sort" => sort(app, ui, &mut d, &mut confirm),
-                "nameManager" => name_manager(app, ui, &mut d, &mut open),
-                "pasteName" => paste_name(app, ui, &mut d, &mut confirm, &mut open),
-                "manageRules" => manage_rules(app, ui),
-                "recommendedCharts" => recommended_charts(app, ui, &mut d, &mut confirm, &mut open),
-                "selectData" => select_data(app, ui, &mut d, &mut confirm, &mut open),
-                "commandSearch" => command_search(app, ui, &mut d, &mut confirm),
-                "goalSeek" => goal_seek(app, ui, &mut d, &mut confirm),
-                "pasteSpecial" => paste_special(app, ui, &mut d, &mut confirm, &mut open),
-                "analysisToolPak" => analysis_toolpak(app, ui, &mut d, &mut confirm, &mut open),
-                "solver" => solver(ui, &mut d, &mut confirm, &mut open),
-                "solverResults" => solver_results(app, ui, &mut d, &mut open),
-                "spelling" => spelling(app, ui, &mut d, &mut open),
-                "agents" => {
-                    ui.label("GridCraft is fully drivable by agents. Every menu item, button and gesture is a command:");
-                    ui.add_space(4.0);
-                    ui.monospace("gridcraft --control 7979        # JSON-lines control channel\ngridcraft-cli mcp --connect 7979   # MCP bridged to this window\ngridcraft-cli mcp                   # headless MCP server");
-                    ui.add_space(4.0);
-                    ui.label(format!("{} engine commands are available. See docs/mcp.md and docs/control-protocol.md.", gridcraft_engine::command_specs().len()));
-                }
-                "about" => about(ui, &mut d),
-                "journal" => {
-                    egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
-                        for (id, p) in app.session.journal.iter().rev().take(500) {
-                            ui.monospace(format!("{id} {p}"));
-                        }
-                    });
-                }
-                "macros" => macros(app, ui, &mut d),
-                "statistics" | "accessibility" | "errorChecking" | "evaluateFormula" | "comments" => {
-                    let r = if d.name == "comments" {
-                        app.session.active().and_then(|doc| doc.wb.active().map(|s| json!(s.comments.iter().map(|(c, m)| json!({"cell": c.a1(), "author": m.author, "text": m.text})).collect::<Vec<_>>())))
-                    } else {
-                        d.result.clone()
-                    };
-                    egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
-                        ui.monospace(serde_json::to_string_pretty(&r.unwrap_or(Json::Null)).unwrap_or_default());
-                    });
-                }
-                "insertPicture" => {
-                    // A private inbox dies with this dialog; late browser results
-                    // cannot affect a later picture choice or another workbook.
-                    let arrived = d.picture_inbox.as_ref().and_then(|inbox| {
-                        inbox.lock().unwrap_or_else(std::sync::PoisonError::into_inner).pop()
-                    });
-                    if let Some((name, bytes)) = arrived {
-                        d.picture_inbox = None;
-                        if bytes.len() > 16 * 1024 * 1024 {
-                            app.message = Some((d.title.clone(), "Choose a PNG or JPEG no larger than 16 MB.".into()));
-                        } else {
-                            d.values.remove("path");
-                            d.values.insert("alt".into(), json!(name));
-                            d.values.insert("base64".into(), json!(gridcraft_engine::io::base64_encode(&bytes)));
-                        }
-                    }
-                    if app.services.pick_picture_async.is_some() {
-                        let name = d.values.get("alt").and_then(Json::as_str).unwrap_or("No picture selected");
-                        ui.label(name);
-                    } else {
-                        ui.label("Picture file path (PNG or JPEG):");
-                        let mut path = d.values.get("path").and_then(Json::as_str).unwrap_or("").to_string();
-                        if ui.text_edit_singleline(&mut path).changed() {
-                            d.values.remove("base64");
-                            d.values.insert("path".into(), json!(path));
-                        }
-                    }
-                    if (app.services.pick_picture.is_some() || app.services.pick_picture_async.is_some()) && ui.button("Browse…").clicked() {
-                        if let Some(start) = &app.services.pick_picture_async {
-                            let inbox = crate::Inbox::default();
-                            start(inbox.clone());
-                            d.picture_inbox = Some(inbox);
-                        } else if let Some(pick) = &app.services.pick_picture
-                            && let Some(path) = pick()
-                        {
-                            d.values.remove("base64");
-                            let alt = std::path::Path::new(&path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("");
-                            d.values.insert("alt".into(), json!(alt));
-                            d.values.insert("path".into(), json!(path));
-                        }
-                    }
-                    ui.label("Description (optional):");
-                    let mut alt = d.values.get("alt").and_then(Json::as_str).unwrap_or("").to_string();
-                    if ui.text_edit_singleline(&mut alt).changed() {
-                        d.values.insert("alt".into(), json!(alt));
-                    }
-                    if d.values.get("placement").and_then(Json::as_str) == Some("cell") {
-                        ui.label(egui::RichText::new("Fits inside the selected cell and moves with its content.").small());
-                    }
-                    ok_cancel(ui, &mut confirm, &mut open);
-                }
-                "pickList" => {
-                    let items: Vec<String> = app
-                        .session
-                        .active()
-                        .and_then(|doc| {
-                            let sh = doc.wb.active()?;
-                            let a = doc.selection.active;
-                            let mut seen = std::collections::BTreeSet::new();
-                            let mut r = a.row;
-                            while r > 0 && !sh.value(gridcraft_engine::core::CellRef::new(r - 1, a.col)).is_empty() {
-                                r -= 1;
-                                seen.insert(sh.value(gridcraft_engine::core::CellRef::new(r, a.col)).display());
-                            }
-                            Some(seen.into_iter().collect())
-                        })
-                        .unwrap_or_default();
-                    for it in items {
-                        if ui.button(&it).clicked() {
-                            app.run_or_alert("cell.set", json!({"input": it}));
-                            open = false;
-                        }
-                    }
-                }
-                "saveCopy" => {
-                    let fmt = d.values.get("format").and_then(Json::as_str).unwrap_or("xlsx").to_string();
-                    ui.label(format!("Save a copy as .{fmt}"));
-                    let mut path = d.values.get("path").and_then(Json::as_str).unwrap_or("").to_string();
-                    ui.text_edit_singleline(&mut path);
-                    d.values.insert("path".into(), json!(path.clone()));
-                    ok_cancel(ui, &mut confirm, &mut open);
-                    if confirm {
-                        // A bare name has no folder: written as typed it would land in the
-                        // process's working directory (`/` from the Finder, the install folder on
-                        // Windows), never where the user looks. The picker chooses the folder.
-                        let pick = app.services.pick_save.as_ref();
-                        let target = if path.is_empty() {
-                            pick.and_then(|f| f(&format!("Copy.{fmt}")))
-                        } else if let Some(f) = pick.filter(|_| std::path::Path::new(&path).is_relative()) {
-                            f(&if path.ends_with(&format!(".{fmt}")) { path } else { format!("{path}.{fmt}") })
-                        } else {
-                            Some(path)
-                        };
-                        if let Some(t) = target {
-                            let id = match fmt.as_str() {
-                                "csv" => "file.exportCsv",
-                                "html" => "file.exportHtml",
-                                _ => "file.saveAs",
-                            };
-                            app.run_or_alert(id, json!({"path": t}));
-                        }
-                    }
-                }
-                "saveChanges" => {
-                    ui.label(format!("Do you want to save the changes you made to {}?", d.values.get("title").and_then(Json::as_str).unwrap_or("this workbook")));
-                    let quitting = d.values.get("quit").and_then(Json::as_bool) == Some(true);
-                    ui.horizontal(|ui| {
-                        for (label, answer) in
-                            [("Don't Save", crate::SaveAnswer::DontSave), ("Cancel", crate::SaveAnswer::Cancel), ("Save", crate::SaveAnswer::Save)]
-                        {
-                            if ui.button(label).clicked() && app.answer_save_changes(answer, quitting, ui.ctx()) {
-                                open = false;
-                            }
-                        }
-                    });
-                }
-                "start" => {
-                    ui.heading("Start a new workbook");
-                    ui.horizontal_wrapped(|ui| {
-                        if ui.button("Blank workbook").clicked() {
-                            app.run_or_alert("file.new", json!({}));
-                            open = false;
-                        }
-                        for (n, t) in gridcraft_engine::sample::SAMPLES {
-                            if ui.button(*t).clicked() {
-                                app.run_or_alert("file.new", json!({"sample": n}));
-                                open = false;
-                            }
-                        }
-                    });
-                    ui.separator();
-                    ui.label(egui::RichText::new("Recent").strong());
-                    for path in app.ui.recent.clone() {
-                        if ui.link(&path).clicked() {
-                            app.open_path(&path);
-                            open = false;
-                        }
-                    }
-                    if ui.button("Open…").clicked() {
-                        app.open_dialog("open", json!({}));
-                        open = false;
-                    }
-                }
-                _ => form(ui, &mut d, &mut confirm, &mut open),
-            }
-        });
-    // Hyperlinks inside dialogs (About ▸ Contributors) open through the host's `open_url`, since
-    // the native shell has no browser integration of its own.
-    if let Some(open_url) = &app.services.open_url {
-        let urls: Vec<String> = ctx.output_mut(|o| {
-            let mut urls = vec![];
-            o.commands.retain(|c| match c {
-                egui::OutputCommand::OpenUrl(u) => {
-                    urls.push(u.url.clone());
-                    false
-                }
-                _ => true,
-            });
-            urls
-        });
-        for u in urls {
-            open_url(&u);
-        }
-    }
-    if ctx.input(|i| i.key_pressed(Key::Escape)) || !win_open {
-        open = false;
-    }
-    if confirm && d.name == "insertPicture" && d.picture_target != app.view_key() {
-        app.message = Some((d.title.clone(), "Return to the original worksheet to insert this picture, or cancel and choose another cell.".into()));
-        confirm = false;
-    }
-    if confirm && let Some(cmd) = d.command {
-        let params = build_params(&d);
-        match app.run(cmd, params) {
-            Ok(r) => {
-                open = false;
-                if d.name == "solver" {
-                    app.open_dialog("solverResults", r);
-                } else if d.name == "openPassword" {
-                    let path = d.values.get("path").and_then(Json::as_str).map(str::to_string);
-                    app.after_open(path.as_deref(), &r);
-                }
-            }
-            // Data Analysis asks before replacing data in its output range.
-            Err(e) if d.name == "analysisToolPak" && e.contains(gridcraft_engine::cmd::analysis::OVERWRITE_ERROR) => {
-                d.values.insert("askOverwrite".into(), json!(true));
-            }
-            // A wrong password: say so, clear the field and stay open for another try.
-            Err(e) if d.name == "openPassword" => {
-                d.values.insert("password".into(), json!(""));
-                app.message = Some((d.title.clone(), crate::clean_error(&e)));
-            }
-            Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))),
-        }
-    } else if confirm {
-        open = false;
-    }
-    if app.ui_window() != home {
-        // A command run from the dialog switched windows: whatever it opened shows in the new
-        // window, and this dialog (or the one it returns to) stays in its own.
-        let keep = if open { Some(d) } else { d.back.take().map(|b| *b) };
-        if let Some(keep) = keep {
-            app.return_dialog(home, keep);
-        }
-        return;
-    }
-    if let Some(child) = app.dialog.as_mut() {
-        // The body opened another dialog (Name Manager › New…). It takes over; this one waits
-        // behind it and comes back when it closes, as Excel returns to the Name Manager. Go To
-        // hands over to Go To Special for good, as in Excel.
-        if open && d.name != "goTo" {
-            child.back = Some(Box::new(d));
-        } else if child.back.is_none() {
-            child.back = d.back.take();
-        }
-        return;
-    }
-    if open {
-        app.dialog = Some(d);
-    } else if let Some(back) = d.back.take() {
-        app.dialog = Some(*back);
-    }
-}
-
-/// Paste Special as Excel lays it out: Paste and Operation each in two columns of options, Skip
-/// blanks and Transpose side by side, and Paste Link as a button that pastes at once. The options
-/// come from the dialog's `fields`, so the letter shortcuts and the control channel see the same.
-fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    let lang = app.ui.language;
-    let t = theme::Tokens::get(ui.ctx());
-    let choices: Vec<(&'static str, &'static str, Vec<(&'static str, &'static str)>)> = d
-        .fields
-        .iter()
-        .filter_map(|f| match f {
-            Field::Choice { key, label, options } => Some((*key, *label, options.clone())),
-            _ => None,
-        })
-        .collect();
-    for (key, label, options) in choices {
-        ui.add_space(4.0);
-        ui.label(egui::RichText::new(lang.tr(label)).strong());
-        egui::Frame::new().stroke(Stroke::new(1.0, t.separator)).corner_radius(4.0).inner_margin(egui::Margin::symmetric(10, 6)).show(ui, |ui| {
-            ui.set_min_width(ui.available_width());
-            let cur = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
-            // Column by column, as Excel fills them.
-            let rows = options.len().div_ceil(2);
-            egui::Grid::new(("paste_special", key)).num_columns(2).min_col_width(200.0).spacing(vec2(16.0, 4.0)).show(ui, |ui| {
-                for r in 0..rows {
-                    for c in 0..2 {
-                        if let Some((value, text)) = options.get(c * rows + r) {
-                            if ui.radio(cur == *value, lang.tr(text)).clicked() {
-                                d.set_value(key, json!(value));
-                            }
-                        } else {
-                            ui.label("");
-                        }
-                    }
-                    ui.end_row();
-                }
-            });
-        });
-    }
-    ui.add_space(8.0);
-    // In the same columns as the options above.
-    egui::Frame::new().inner_margin(egui::Margin::symmetric(11, 0)).show(ui, |ui| {
-        egui::Grid::new("paste_special_checks").num_columns(2).min_col_width(200.0).spacing(vec2(16.0, 4.0)).show(ui, |ui| {
-            for (key, label) in [("skipBlanks", "Skip blanks"), ("transpose", "Transpose (E)")] {
-                let mut b = d.values.get(key).and_then(Json::as_bool).unwrap_or(false);
-                if ui.checkbox(&mut b, lang.tr(label)).changed() {
-                    d.values.insert(key.into(), json!(b));
-                }
-            }
-            ui.end_row();
-        });
-    });
-    ui.add_space(8.0);
-    ui.separator();
-    ui.horizontal(|ui| {
-        // Excel's Paste Link pastes references to the copied cells straight away.
-        if ui.button(lang.tr("Paste Link")).on_hover_text(lang.tr("Paste formulas that refer to the copied cells")).clicked() {
-            d.values.insert("what".into(), json!("all"));
-            d.values.insert("operation".into(), json!("none"));
-            d.values.insert("link".into(), json!(true));
-            *confirm = true;
-        }
-        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-            let ok = ui.add(egui::Button::new(egui::RichText::new(format!("   {}   ", lang.tr("OK"))).color(t.on_accent)).fill(t.accent));
-            if ok.clicked() || ui.input(|i| i.key_pressed(Key::Enter)) {
-                *confirm = true;
-            }
-            if ui.button(format!(" {} ", lang.tr("Cancel"))).clicked() {
-                *open = false;
-            }
-        });
-    });
-}
-
-/// Paste Special's legacy mnemonics select options; Enter still performs the paste.
-fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) {
-    if ctx.text_edit_focused() {
-        return;
-    }
-    let right_alt = ctx.input(|i| {
-        i.key_down(Key::AltRight)
-            || i.events.iter().any(|event| {
-                matches!(event, egui::Event::Key { key: Key::AltRight, .. })
-                    || matches!(event, egui::Event::Key { physical_key: Some(Key::AltRight), .. })
-            })
-    });
-    let mac = ctx.os() == egui::os::OperatingSystem::Mac;
-    let allowed = |m: egui::Modifiers| !m.ctrl && !m.command && !m.mac_cmd && !(m.alt && (mac || right_alt));
-    let mnemonic = |key| match key {
-        Key::T => Some('t'),
-        Key::V => Some('v'),
-        Key::F => Some('f'),
-        Key::C => Some('c'),
-        Key::E => Some('e'),
-        _ => None,
-    };
-    let mut text_to_consume = Vec::new();
-    for event in ctx.input(|i| i.events.clone()) {
-        let egui::Event::Key { key, pressed: true, repeat, modifiers, .. } = event else { continue };
-        if !allowed(modifiers) {
-            continue;
-        }
-        let Some(letter) = mnemonic(key) else { continue };
-        text_to_consume.push(letter);
-        if repeat {
-            continue;
-        }
-        if key == Key::E {
-            let transpose = d.values.get("transpose").and_then(Json::as_bool).unwrap_or(false);
-            d.values.insert("transpose".into(), json!(!transpose));
-        } else {
-            let what = match key {
-                Key::T => "formats",
-                Key::V => "values",
-                Key::F => "formulas",
-                _ => "comments",
-            };
-            d.values.insert("what".into(), json!(what));
-        }
-    }
-    // Browsers can deliver Text before or after Key. Act only on Key, then remove
-    // its matching text so one physical press cannot toggle Transpose twice.
-    ctx.input_mut(|i| {
-        i.events.retain(|event| match event {
-            egui::Event::Key { key, modifiers, .. } => !(allowed(*modifiers) && mnemonic(*key).is_some()),
-            egui::Event::Text(text) if text.len() == 1 => {
-                let letter = text.chars().next().unwrap_or_default().to_ascii_lowercase();
-                if let Some(index) = text_to_consume.iter().position(|&c| c == letter) {
-                    text_to_consume.remove(index);
-                    false
-                } else {
-                    true
-                }
-            }
-            _ => true,
-        });
-    });
-}
-
-fn ok_cancel(ui: &mut egui::Ui, confirm: &mut bool, open: &mut bool) {
-    ui.add_space(8.0);
-    // A row as tall as the buttons: a right-to-left layout straight in the window takes all the
-    // height it is offered, which stretched every form dialog to the screen's height.
-    ui.horizontal(|ui| {
-        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-            let lang = crate::i18n::current(ui.ctx());
-            let t = crate::theme::Tokens::get(ui.ctx());
-            let ok = ui.add(egui::Button::new(egui::RichText::new(format!("   {}   ", lang.tr("OK"))).color(t.on_accent)).fill(t.accent));
-            if ok.clicked() || ui.input(|i| i.key_pressed(Key::Enter)) {
-                *confirm = true;
-            }
-            if ui.button(format!(" {} ", lang.tr("Cancel"))).clicked() {
-                *open = false;
-            }
-        })
-    });
-}
-
-fn form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    form_fields(ui, d);
-    ok_cancel(ui, confirm, open);
-}
-
-/// Gives keyboard focus to the first text or number field the first time a form is drawn. A
-/// focused number field is in typing mode with its value selected, so Alt+H, O, W then 12 and
-/// Enter sets the width, as in Excel.
-/// Keeps asking until the field really has focus: a new window's first frame is an invisible
-/// sizing pass where a focus request is ignored.
-fn take_first_focus(d: &mut Dialog, r: &egui::Response) {
-    if !d.focus_first_field {
-        return;
-    }
-    if !r.has_focus() {
-        r.request_focus();
-        return;
-    }
-    // Focus has landed, and the field is now a text box: select its whole value so typing
-    // replaces it (the field's own select-on-focus fired before it was a text box).
-    let mut state = egui::text_edit::TextEditState::load(&r.ctx, r.id).unwrap_or_default();
-    let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(usize::MAX / 2));
-    state.cursor.set_char_range(Some(all));
-    state.store(&r.ctx, r.id);
-    d.focus_first_field = false;
-}
-
-/// Keeps a picking formula box's caret, and gives it the keyboard back after a grid click put a
-/// reference in it (the click took the focus), its caret after the reference.
-fn track_pick(pick: &mut RefPick, r: &egui::Response, typed: bool) {
-    if typed {
-        pick.point = None;
-    }
-    if pick.refocus {
-        let mut state = egui::text_edit::TextEditState::load(&r.ctx, r.id).unwrap_or_default();
-        state.cursor.set_char_range(Some(egui::text::CCursorRange::one(egui::text::CCursor::new(pick.caret))));
-        state.store(&r.ctx, r.id);
-        r.request_focus();
-        pick.refocus = false;
-    } else if r.has_focus()
-        && let Some(range) = egui::text_edit::TextEditState::load(&r.ctx, r.id).and_then(|state| state.cursor.char_range())
-    {
-        pick.caret = range.primary.index.into();
-    }
-}
-
-/// Draws a dialog's `fields`, editing its values.
-fn form_fields(ui: &mut egui::Ui, d: &mut Dialog) {
-    // Field labels, choices and notes are English source strings, translated as they are drawn.
-    let lang = crate::i18n::current(ui.ctx());
-    egui::Grid::new("form").num_columns(1).spacing(vec2(8.0, 6.0)).show(ui, |ui| {
-        for f in d.fields.clone() {
-            match f {
-                Field::Text { key, label } => {
-                    ui.vertical(|ui| {
-                        let label = ui.label(lang.tr(label));
-                        let mut s = d
-                            .values
-                            .get(key)
-                            .map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| if v.is_null() { String::new() } else { v.to_string() }))
-                            .unwrap_or_default();
-                        let multiline = key == "text";
-                        let r = if multiline {
-                            ui.add(egui::TextEdit::multiline(&mut s).desired_rows(4).desired_width(320.0)).labelled_by(label.id)
-                        } else {
-                            ui.add(egui::TextEdit::singleline(&mut s).desired_width(320.0)).labelled_by(label.id)
-                        };
-                        take_first_focus(d, &r);
-                        if r.changed() {
-                            d.values.insert(key.into(), json!(s));
-                        }
-                        if let Some(pick) = d.pick.as_mut().filter(|pick| pick.key == key) {
-                            track_pick(pick, &r, r.changed());
-                        }
-                    });
-                }
-                Field::Password { key, label } => {
-                    // Masked as typed (Excel shows dots); "Show password" reveals it on purpose.
-                    ui.vertical(|ui| {
-                        let label = ui.label(lang.tr(label));
-                        let mut s = d.values.get(key).and_then(Json::as_str).unwrap_or_default().to_string();
-                        if ui.add(egui::TextEdit::singleline(&mut s).password(!d.show_password).desired_width(320.0)).labelled_by(label.id).changed()
-                        {
-                            d.values.insert(key.into(), json!(s));
-                        }
-                        ui.checkbox(&mut d.show_password, lang.tr("Show password"));
-                    });
-                }
-                Field::Number { key, label } => {
-                    ui.horizontal(|ui| {
-                        let label = ui.label(lang.tr(label));
-                        let mut n = d.values.get(key).and_then(Json::as_f64).unwrap_or(0.0);
-                        // Typed values count straight away: otherwise Enter or OK in the same frame
-                        // confirms the old value, because a number field only commits when it loses focus.
-                        let r = ui.add(egui::DragValue::new(&mut n).speed(0.5).update_while_editing(true)).labelled_by(label.id);
-                        take_first_focus(d, &r);
-                        if r.changed() {
-                            d.values.insert(key.into(), json!(n));
-                        }
-                    });
-                }
-                Field::Choice { key, label, options } => {
-                    ui.vertical(|ui| {
-                        let field_label = ui.label(egui::RichText::new(lang.tr(label)).strong());
-                        let cur = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
-                        if d.name == "dataValidation" {
-                            let selected = options.iter().find(|(val, _)| *val == cur).map(|(_, text)| lang.tr(text)).unwrap_or("");
-                            egui::ComboBox::from_id_salt(("dataValidation", key))
-                                .selected_text(selected)
-                                .width(300.0)
-                                .show_ui(ui, |ui| {
-                                    for (val, text) in options {
-                                        if ui.selectable_label(cur == val, lang.tr(text)).clicked() {
-                                            d.set_value(key, json!(val));
-                                        }
-                                    }
-                                })
-                                .response
-                                .labelled_by(field_label.id);
-                        } else {
-                            for (val, text) in options {
-                                if ui.radio(cur == val, lang.tr(text)).clicked() {
-                                    d.set_value(key, json!(val));
-                                }
-                            }
-                        }
-                    });
-                }
-                Field::Check { key, label } => {
-                    let mut b = d.values.get(key).and_then(Json::as_bool).unwrap_or(false);
-                    if ui.checkbox(&mut b, lang.tr(label)).changed() {
-                        d.values.insert(key.into(), json!(b));
-                    }
-                }
-                Field::Note(t) => {
-                    // A note can carry user data (a URL, a file or sheet name); `tr` reads a `|` as a
-                    // context separator, so such a note is shown as it is.
-                    let text = if t.contains('|') { t.as_str() } else { lang.tr(&t) };
-                    ui.label(egui::RichText::new(text).small());
-                }
-            }
-            ui.end_row();
-        }
-    });
-}
-
-/// Help ▸ About GridCraft: the app, its contributors and the AI models that helped. The credits
-/// are compiled in (`crate::credits`, docs/contributors.md).
-fn about(ui: &mut egui::Ui, d: &mut Dialog) {
-    ui.horizontal(|ui| {
-        for tab in ["About", "Contributors", "Models"] {
-            if ui.selectable_label(d.tab == tab, tab).clicked() {
-                d.tab = tab.to_string();
-            }
-        }
-    });
-    ui.separator();
-    match d.tab.as_str() {
-        "Contributors" => crate::credits::contributors_ui(ui),
-        "Models" => crate::credits::models_ui(ui),
-        _ => {
-            ui.heading("GridCraft");
-            ui.label(format!("Version {}", env!("CARGO_PKG_VERSION")));
-            ui.add_space(4.0);
-            ui.label("A clean-room, open-source, Rust-native spreadsheet. Part of ArtCraft.");
-            ui.hyperlink_to("getartcraft.com/apps/gridcraft", "https://getartcraft.com/apps/gridcraft");
-            ui.hyperlink_to("Join the ArtCraft Discord", "https://discord.gg/artcraft");
-        }
-    }
-}
-
-/// The Macros dialog: lists GridCraft's own recorded scripts and (if the file carries one) the
-/// preserved VBA project. Mirrors Excel's Developer ▸ Macros list, but is honest that VBA is
-/// preserved and not executed.
-fn macros(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) {
-    ui.label("Automation in this workbook. GridCraft runs its own scripts; a file's VBA project is preserved but not executed.");
-    ui.add_space(6.0);
-    let items: Vec<Json> = d.result.as_ref().and_then(Json::as_array).cloned().unwrap_or_default();
-    if items.is_empty() {
-        ui.weak("This workbook has no scripts or macros.");
-        return;
-    }
-    // Scripts that came with a file stay disabled until the user trusts the workbook (#2178).
-    if items.iter().any(|it| it.get("trusted").and_then(Json::as_bool) == Some(false)) {
-        ui.horizontal(|ui| {
-            ui.weak("Scripts in this workbook came from a file and are disabled.");
-            if ui.button("Trust Scripts").on_hover_text("Let this workbook's scripts run for the rest of this session").clicked() {
-                let _ = app.run("automate.trustScripts", json!({"trusted": true}));
-                d.result = app.session.run("view.macros", json!({})).ok();
-            }
-        });
-        ui.add_space(6.0);
-    }
-    egui::ScrollArea::vertical().max_height(300.0).show(ui, |ui| {
-        for it in &items {
-            let name = it.get("name").and_then(Json::as_str).unwrap_or("(unnamed)");
-            let is_vba = it.get("kind").and_then(Json::as_str) == Some("vba");
-            ui.horizontal(|ui| {
-                ui.label(egui::RichText::new(name).strong());
-                if is_vba {
-                    ui.weak("— VBA project (preserved, not run)");
-                } else {
-                    let steps = it.get("steps").and_then(Json::as_u64).unwrap_or(0);
-                    ui.weak(format!("— {steps} step{}", if steps == 1 { "" } else { "s" }));
-                }
-            });
-        }
-    });
-}
-
-/// Draws the six-tab Format Cells editor (number, alignment, font, border, fill, protection); the Number tab shows a sample preview, and the style draft updates.
-fn format_cells(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
-    // `d.tab` stays the English name (it is what `open_dialog` and tests pass); only the drawn
-    // labels are translated. The Fill tab is keyed by context: the Alignment tab's "Fill" is a
-    // different word in some languages.
-    let lang = app.ui.language;
-    ui.horizontal(|ui| {
-        for (tab, key) in [
-            ("Number", "Number"),
-            ("Alignment", "Alignment"),
-            ("Font", "Font"),
-            ("Border", "Border"),
-            ("Fill", "Format Cells|Fill"),
-            ("Protection", "Protection"),
-        ] {
-            if ui.selectable_label(d.tab == tab, lang.tr(key)).clicked() {
-                d.tab = tab.to_string();
-            }
-        }
-    });
-    ui.separator();
-    let mut st: gridcraft_engine::model::Style = d.values.get("style").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or_default();
-    let sample = app.session.active().and_then(|doc| doc.wb.active().map(|s| s.value(doc.selection.active))).unwrap_or_default();
-    match d.tab.as_str() {
-        "Number" => {
-            let mut code = st.num_fmt.as_str().to_string();
-            ui.columns(2, |cols| {
-                cols[0].label(egui::RichText::new(lang.tr("Category:")).strong());
-                for name in
-                    ["General", "Number", "Currency", "Accounting", "Short Date", "Long Date", "Time", "Percentage", "Fraction", "Scientific", "Text"]
-                {
-                    let c = gridcraft_engine::cmd::format::format_code_for(name).to_string();
-                    if cols[0].selectable_label(code == c, lang.tr(name)).clicked() {
-                        code = c;
-                    }
-                }
-                cols[1].label(egui::RichText::new(lang.tr("Sample")).strong());
-                let preview = app.session.active().map(|doc| gridcraft_engine::display::format(&sample, &code, &doc.wb).text).unwrap_or_default();
-                cols[1].label(egui::RichText::new(preview).font(theme::ui_font(15.0)));
-                cols[1].add_space(8.0);
-                let label = cols[1].label(lang.tr("Type (custom format code):"));
-                cols[1].text_edit_singleline(&mut code).labelled_by(label.id);
-                for c in [
-                    "0",
-                    "0.00",
-                    "#,##0",
-                    "#,##0.00",
-                    "#,##0;[Red]-#,##0",
-                    "0%",
-                    "0.00%",
-                    "0.00E+00",
-                    "# ?/?",
-                    "m/d/yyyy",
-                    "d-mmm-yy",
-                    "mmmm d, yyyy",
-                    "h:mm AM/PM",
-                    "h:mm:ss",
-                    "[h]:mm:ss",
-                    "@",
-                ] {
-                    if cols[1].small_button(c).clicked() {
-                        code = c.to_string();
-                    }
-                }
-            });
-            st.num_fmt = gridcraft_engine::model::NumFmt::new(&code);
-        }
-        "Alignment" => {
-            use gridcraft_engine::model::{HAlign, VAlign};
-            ui.label(egui::RichText::new(lang.tr("Horizontal")).strong());
-            ui.horizontal_wrapped(|ui| {
-                for (h, n) in [
-                    (HAlign::General, "General"),
-                    (HAlign::Left, "Left"),
-                    (HAlign::Center, "Center"),
-                    (HAlign::Right, "Right"),
-                    (HAlign::Fill, "Fill"),
-                    (HAlign::Justify, "Justify"),
-                    (HAlign::CenterAcross, "Center Across Selection"),
-                    (HAlign::Distributed, "Distributed"),
-                ] {
-                    ui.radio_value(&mut st.align.h, h, lang.tr(n));
-                }
-            });
-            ui.label(egui::RichText::new(lang.tr("Vertical")).strong());
-            ui.horizontal_wrapped(|ui| {
-                for (v, n) in [
-                    (VAlign::Top, "Top"),
-                    (VAlign::Center, "Center"),
-                    (VAlign::Bottom, "Bottom"),
-                    (VAlign::Justify, "Justify"),
-                    (VAlign::Distributed, "Distributed"),
-                ] {
-                    ui.radio_value(&mut st.align.v, v, lang.tr(n));
-                }
-            });
-            let mut indent = st.align.indent as f32;
-            ui.add(egui::Slider::new(&mut indent, 0.0..=15.0).text(lang.tr("Indent")));
-            st.align.indent = indent as u8;
-            let mut rot = if st.align.rotation == 255 { 0.0 } else { st.align.rotation as f32 };
-            ui.add(egui::Slider::new(&mut rot, -90.0..=90.0).text(lang.tr("Orientation (degrees)")));
-            st.align.rotation = rot as i16;
-            ui.checkbox(&mut st.align.wrap, lang.tr("Wrap text"));
-            ui.checkbox(&mut st.align.shrink, lang.tr("Shrink to fit"));
-        }
-        "Font" => {
-            egui::ComboBox::from_label(lang.tr("Font")).selected_text(st.font.name.clone()).show_ui(ui, |ui| {
-                for f in crate::fonts::families() {
-                    ui.selectable_value(&mut st.font.name, f.clone(), f.clone());
-                }
-            });
-            ui.add(egui::Slider::new(&mut st.font.size, 6.0..=72.0).text(lang.tr("Size")));
-            ui.horizontal(|ui| {
-                ui.checkbox(&mut st.font.bold, lang.tr("Bold"));
-                ui.checkbox(&mut st.font.italic, lang.tr("Italic"));
-                ui.checkbox(&mut st.font.strike, lang.tr("Strikethrough"));
-            });
-            use gridcraft_engine::model::{Underline, VertAlign};
-            ui.horizontal(|ui| {
-                for (u, n) in [
-                    (Underline::None, "None"),
-                    (Underline::Single, "Single"),
-                    (Underline::Double, "Double"),
-                    (Underline::SingleAccounting, "Single Accounting"),
-                    (Underline::DoubleAccounting, "Double Accounting"),
-                ] {
-                    ui.radio_value(&mut st.font.underline, u, lang.tr(n));
-                }
-            });
-            ui.horizontal(|ui| {
-                ui.radio_value(&mut st.font.vert, VertAlign::Baseline, lang.tr("Normal"));
-                ui.radio_value(&mut st.font.vert, VertAlign::Superscript, lang.tr("Superscript"));
-                ui.radio_value(&mut st.font.vert, VertAlign::Subscript, lang.tr("Subscript"));
-            });
-            ui.label(lang.tr("Color:"));
-            let colors = app.session.active().map(|doc| doc.wb.theme.colors).unwrap_or_default();
-            if let Some(c) = crate::widgets::color_palette(ui, &colors, lang.tr("Automatic")) {
-                st.font.color =
-                    if c == "none" { gridcraft_engine::model::Color::Auto } else { gridcraft_engine::model::Color::from_hex(&c).unwrap_or_default() };
-            }
-        }
-        "Border" => {
-            use gridcraft_engine::model::{BorderLine, BorderStyle};
-            let line = BorderLine { style: BorderStyle::Thin, color: gridcraft_engine::model::Color::Auto };
-            ui.horizontal(|ui| {
-                if ui.button(lang.tr("None")).clicked() {
-                    st.borders = Default::default();
-                }
-                if ui.button(lang.tr("Outline")).clicked() {
-                    st.borders.top = line;
-                    st.borders.bottom = line;
-                    st.borders.left = line;
-                    st.borders.right = line;
-                }
-            });
-            for (n, slot) in [
-                ("Top", &mut st.borders.top),
-                ("Bottom", &mut st.borders.bottom),
-                ("Left", &mut st.borders.left),
-                ("Right", &mut st.borders.right),
-                ("Diagonal ↘", &mut st.borders.diag_down),
-                ("Diagonal ↗", &mut st.borders.diag_up),
-            ] {
-                let n = lang.tr(n);
-                ui.horizontal(|ui| {
-                    ui.label(format!("{n}:"));
-                    for (s, label) in [
-                        (BorderStyle::None, "none"),
-                        (BorderStyle::Thin, "thin"),
-                        (BorderStyle::Medium, "medium"),
-                        (BorderStyle::Thick, "thick"),
-                        (BorderStyle::Dashed, "dashed"),
-                        (BorderStyle::Dotted, "dotted"),
-                        (BorderStyle::Double, "double"),
-                    ] {
-                        let label = lang.tr(label);
-                        let response = ui.selectable_label(slot.style == s, label);
-                        let selected = slot.style == s;
-                        response.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), selected, format!("{n} {label}")));
-                        if response.clicked() {
-                            slot.style = s;
-                        }
-                    }
-                });
-            }
-            let theme = app.session.active().map(|doc| &doc.wb.theme).cloned().unwrap_or_default();
-            crate::border_preview::sample(ui, &st.borders, &theme);
-        }
-        "Fill" => {
-            let colors = app.session.active().map(|doc| doc.wb.theme.colors).unwrap_or_default();
-            ui.label(lang.tr("Background Color:"));
-            if let Some(c) = crate::widgets::color_palette(ui, &colors, lang.tr("No Color")) {
-                st.fill = if c == "none" {
-                    Default::default()
-                } else {
-                    gridcraft_engine::model::Fill::solid(gridcraft_engine::model::Color::from_hex(&c).unwrap_or_default())
-                };
-            }
-        }
-        "Protection" => {
-            ui.checkbox(&mut st.protection.locked, lang.tr("Locked"));
-            ui.checkbox(&mut st.protection.hidden, lang.tr("Hidden"));
-            ui.label(
-                egui::RichText::new(
-                    lang.tr("Locking cells or hiding formulas has no effect until you protect the worksheet (Review › Protect Sheet)."),
-                )
-                .small(),
-            );
-        }
-        _ => {}
-    }
-    if let Ok(v) = serde_json::to_value(&st) {
-        d.values.insert("style".into(), v);
-    }
-    let mut open = true;
-    ok_cancel(ui, confirm, &mut open);
-    if *confirm && let Some(style) = d.values.get("style").cloned() {
-        app.run_or_alert("home.formatCells", json!({"style": style}));
-    }
-    if !open {
-        app.dialog = None;
-        *confirm = true; // closes
-    }
-}
-
-/// Insert Function: searches names (as the formula language spells them) and descriptions, shows
-/// each hit's category and description, and starts editing `=NAME(` (or appends to the formula).
-fn insert_function(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
-    let language = app.ui.language;
-    ui.horizontal(|ui| {
-        ui.label(language.tr("Search:"));
-        let r = ui.add(egui::TextEdit::singleline(&mut d.search).desired_width(300.0).hint_text(language.tr("e.g. lookup, average, date")));
-        r.request_focus();
-    });
-    let locale = language.formula_locale();
-    let list = gridcraft_engine::cmd::formulas::function_list();
-    // The names and descriptions searched are the ones shown, so in the interface language.
-    let q = d.search.to_lowercase();
-    let hits: Vec<&Json> = list
-        .iter()
-        .filter(|f| {
-            q.is_empty()
-                || f["name"].as_str().is_some_and(|n| locale.function_name(n).to_lowercase().contains(&q))
-                || f["description"].as_str().is_some_and(|n| language.function_description(n).unwrap_or(n).to_lowercase().contains(&q))
-        })
-        .take(300)
-        .collect();
-    egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
-        for (i, f) in hits.iter().enumerate() {
-            let name = locale.function_name(f["name"].as_str().unwrap_or(""));
-            let category = language.tr(function_category_label(f["category"].as_str().unwrap_or("")));
-            let r = ui.add(egui::Button::selectable(i == d.list_index, format!("{name:<18} {category}")).min_size(vec2(480.0, 20.0)));
-            if r.clicked() {
-                d.list_index = i;
-            }
-            if r.double_clicked() {
-                d.list_index = i;
-                *confirm = true;
-            }
-        }
-    });
-    if let Some(f) = hits.get(d.list_index) {
-        let name = f["name"].as_str().unwrap_or("");
-        ui.separator();
-        ui.label(egui::RichText::new(crate::formula_locale::signature(name, locale, language).unwrap_or_default()).strong());
-        ui.label(crate::formula_locale::description(name, locale, language).unwrap_or_default());
-    }
-    let mut open = true;
-    ok_cancel(ui, confirm, &mut open);
-    if *confirm && let Some(n) = hits.get(d.list_index).and_then(|f| f["name"].as_str()) {
-        let n = app.session.active().map(|doc| crate::formula_locale::completion_name(n, locale, &doc.wb, doc.wb.active_sheet())).unwrap_or(n);
-        let cur = app.editor.as_ref().map(|e| e.text.clone());
-        let text = match cur {
-            Some(t) if t.starts_with('=') => format!("{t}{n}("),
-            _ => format!("={n}("),
-        };
-        app.begin_edit(Some(text), false);
-    }
-    if !open {
-        *confirm = true;
-    }
-}
-
-/// Excel's name for a function category, given the catalog's id (`MathTrig`).
-fn function_category_label(id: &str) -> &str {
-    match id {
-        "DateTime" => "Date & Time",
-        "Lookup" => "Lookup & Reference",
-        "MathTrig" => "Math & Trig",
-        "AddIn" => "Add-in and Automation",
-        // Financial, Logical, Text, Statistical, Engineering, Database, Information, …
-        other => other,
-    }
-}
-
-/// Draws the Find/Replace form with case, whole-cell and workbook options, requests field focus once, and runs find/replace with the current parameters.
-fn find(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) {
-    ui.horizontal(|ui| {
-        for tab in ["Find", "Replace"] {
-            if ui.selectable_label(d.tab == tab, tab).clicked() {
-                d.tab = tab.into();
-            }
-        }
-    });
-    let mut what = d.values.get("what").and_then(Json::as_str).unwrap_or("").to_string();
-    let mut with = d.values.get("with").and_then(Json::as_str).unwrap_or("").to_string();
-    ui.horizontal(|ui| {
-        let label = ui.label("Find what:");
-        let r = ui.add(egui::TextEdit::singleline(&mut what).desired_width(260.0)).labelled_by(label.id);
-        // Like Excel, the cursor starts in "Find what" - asked for once, so clicking another field still works.
-        if !d.values.contains_key("focused") {
-            r.request_focus();
-            d.values.insert("focused".into(), json!(true));
-        }
-    });
-    if d.tab == "Replace" {
-        ui.horizontal(|ui| {
-            let label = ui.label("Replace with:");
-            ui.add(egui::TextEdit::singleline(&mut with).desired_width(244.0)).labelled_by(label.id);
-        });
-    }
-    let mut case = d.values.get("matchCase").and_then(Json::as_bool).unwrap_or(false);
-    let mut whole = d.values.get("wholeCell").and_then(Json::as_bool).unwrap_or(false);
-    let mut wb = d.values.get("within").and_then(Json::as_str) == Some("workbook");
-    ui.horizontal(|ui| {
-        ui.checkbox(&mut case, "Match case");
-        ui.checkbox(&mut whole, "Match entire cell contents");
-        ui.checkbox(&mut wb, "Within workbook");
-    });
-    d.values.insert("what".into(), json!(what));
-    d.values.insert("with".into(), json!(with));
-    d.values.insert("matchCase".into(), json!(case));
-    d.values.insert("wholeCell".into(), json!(whole));
-    d.values.insert("within".into(), json!(if wb { "workbook" } else { "sheet" }));
-    let base = json!({"what": what, "matchCase": case, "wholeCell": whole, "within": if wb { "workbook" } else { "sheet" }});
-    ui.horizontal(|ui| {
-        if d.tab == "Replace" {
-            if ui.button("Replace All").clicked() {
-                let mut p = base.clone();
-                p["with"] = json!(with);
-                p["all"] = json!(true);
-                match app.run("edit.replace", p) {
-                    Ok(r) => app.toast = Some((format!("All done. We made {} replacements.", r["replaced"]), crate::now_ms())),
-                    Err(e) => app.message = Some(("Find and Replace".into(), crate::clean_error(&e))),
-                }
-            }
-            if ui.button("Replace").clicked() {
-                let mut p = base.clone();
-                p["with"] = json!(with);
-                p["all"] = json!(false);
-                let _ = app.run("edit.replace", p);
-                let _ = app.run("edit.find", base.clone());
-            }
-        }
-        if ui.button("Find All").clicked() {
-            let mut p = base.clone();
-            p["all"] = json!(true);
-            d.result = app.run("edit.find", p).ok();
-        }
-        if ui.button("Find Next").clicked() || ui.input(|i| i.key_pressed(Key::Enter)) {
-            if let Err(e) = app.run("edit.find", base.clone()) {
-                app.message = Some(("Find and Replace".into(), crate::clean_error(&e)));
-            }
-            app.grid.ensure_visible = true;
-        }
-    });
-    if let Some(r) = &d.result
-        && let Some(list) = r["results"].as_array()
-    {
-        ui.separator();
-        ui.label(format!("{} cell(s) found", list.len()));
-        egui::ScrollArea::vertical().max_height(180.0).show(ui, |ui| {
-            for item in list {
-                let label = format!(
-                    "{}  {}  {}",
-                    item["sheet"].as_str().unwrap_or(""),
-                    item["cell"].as_str().unwrap_or(""),
-                    item["value"].as_str().unwrap_or("")
-                );
-                if ui.selectable_label(false, label).clicked() {
-                    if let Some(s) = item["sheet"].as_str() {
-                        let _ = app.run("sheet.activate", json!({"sheet": s}));
-                    }
-                    let _ = app.run("selection.set", json!({"cell": item["cell"]}));
-                    app.grid.ensure_visible = true;
-                }
-            }
-        });
-    }
-}
-
-/// Zoom's Magnification presets, as `preset` values and labels, in Excel's order.
-const ZOOM_PRESETS: [(&str, &str); 5] = [("200", "200%"), ("100", "100%"), ("75", "75%"), ("50", "50%"), ("25", "25%")];
-
-/// The `preset` that shows a zoom percentage: its Magnification entry, or Custom.
-fn zoom_preset(percent: f64) -> &'static str {
-    ZOOM_PRESETS.iter().map(|(val, _)| *val).find(|val| val.parse::<f64>().ok() == Some(percent)).unwrap_or("custom")
-}
-
-/// View › Zoom, laid out as Excel's: one Magnification column of 200% to 25%, Fit selection and
-/// Custom with its percentage box. The current zoom is pre-selected; typing a percentage
-/// selects Custom; Fit selection zooms so the selected cells fill the grid.
-fn zoom(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    let lang = crate::i18n::current(ui.ctx());
-    let cur = d.values.get("preset").and_then(Json::as_str).unwrap_or("custom").to_string();
-    ui.label(egui::RichText::new(lang.tr("Magnification")).strong());
-    for (val, text) in ZOOM_PRESETS {
-        if ui.radio(cur == val, text).clicked() {
-            d.set_value("preset", json!(val));
-        }
-    }
-    if ui.radio(cur == "fit", lang.tr("Fit selection")).clicked() {
-        d.set_value("preset", json!("fit"));
-    }
-    ui.horizontal(|ui| {
-        if ui.radio(cur == "custom", format!("{}:", lang.tr("Custom"))).clicked() {
-            d.set_value("preset", json!("custom"));
-        }
-        // Whole percentages, as Excel shows them; the engine clamps to 10..400 as well.
-        let mut percent = d.values.get("percent").and_then(Json::as_f64).unwrap_or(100.0).round() as i64;
-        if ui.add(egui::DragValue::new(&mut percent).range(10..=400).speed(1.0)).changed() {
-            d.set_value("percent", json!(percent));
-        }
-        ui.label("%");
-    });
-    ok_cancel(ui, confirm, open);
-}
-
-/// What the Go To dialog lists: the named ranges of every sheet, then the references gone to
-/// before, newest first.
-fn go_to_entries(app: &SheetApp) -> Vec<String> {
-    app.session
-        .active()
-        .map(|doc| {
-            let mut v = gridcraft_engine::cmd::edit::go_to_names(&doc.wb, doc.wb.active_sheet());
-            v.extend(doc.go_to_recent.iter().cloned());
-            v
-        })
-        .unwrap_or_default()
-}
-
-/// Draws a virtualized name/reference list and editable reference field, links to Go To Special, and confirms with `edit.goTo`.
-fn go_to(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
-    let lang = app.ui.language;
-    let entries: Vec<String> =
-        d.result.as_ref().and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_str).map(str::to_owned).collect()).unwrap_or_default();
-    let current = d.values.get("reference").and_then(Json::as_str).unwrap_or("").to_string();
-    // A workbook can hold thousands of names: only the rows in view are laid out.
-    let row_height = ui.text_style_height(&egui::TextStyle::Button) + 2.0 * ui.spacing().button_padding.y;
-    egui::ScrollArea::vertical().max_height(160.0).auto_shrink([false, true]).show_rows(ui, row_height, entries.len(), |ui, rows| {
-        for n in entries.get(rows).unwrap_or_default() {
-            let resp = ui.selectable_label(current == *n, n);
-            if resp.clicked() || resp.double_clicked() {
-                d.values.insert("reference".into(), json!(n));
-            }
-            if resp.double_clicked() {
-                *confirm = true;
-            }
-        }
-    });
-    let mut r = d.values.get("reference").and_then(Json::as_str).unwrap_or("").to_string();
-    ui.horizontal(|ui| {
-        let label = ui.label(lang.tr("Reference:"));
-        ui.text_edit_singleline(&mut r).labelled_by(label.id).request_focus();
-    });
-    d.values.insert("reference".into(), json!(r.clone()));
-    if ui.button("Special…").clicked() {
-        app.open_dialog("goToSpecial", json!({}));
-        return;
-    }
-    let mut open = true;
-    ok_cancel(ui, confirm, &mut open);
-    if *confirm {
-        app.run_or_alert("edit.goTo", json!({"reference": r, "record": true}));
-        app.grid.ensure_visible = true;
-    }
-    if !open {
-        *confirm = true;
-    }
-}
-
-/// Draws the sort-level editor: header toggle, column/by/order controls, add/remove level, and `data.sort` on confirmation.
-fn sort(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
-    let lang = app.ui.language;
-    let mut header = d.values.get("header").and_then(Json::as_bool).unwrap_or(true);
-    ui.checkbox(&mut header, "My list has headers");
-    d.values.insert("header".into(), json!(header));
-    let mut levels: Vec<Json> = d.values.get("levels").and_then(Json::as_array).cloned().unwrap_or_default();
-    // Columns of the region around the active cell, labelled with their header (or first value).
-    let columns: Vec<(String, String)> = app
-        .session
-        .active()
-        .and_then(|d| {
-            let sh = d.wb.active()?;
-            let region = gridcraft_engine::selection::current_region(sh, d.selection.active);
-            Some(
-                (region.start.col..=region.end.col)
-                    .map(|c| {
-                        let letter = gridcraft_engine::core::col_to_letters(c);
-                        // The region starts at the header row when one is present, so the
-                        // label always comes from start.row: header text with headers on,
-                        // first data value with them off.
-                        let label_row = region.start.row;
-                        let text = gridcraft_engine::display::cell_text(&d.wb, sh, gridcraft_engine::core::CellRef::new(label_row, c));
-                        let text: String = text.chars().take(24).collect();
-                        (letter.clone(), if text.is_empty() { letter } else { format!("{letter}: {text}") })
-                    })
-                    .collect(),
-            )
-        })
-        .unwrap_or_default();
-    let mut remove = None;
-    for (i, lv) in levels.iter_mut().enumerate() {
-        ui.horizontal(|ui| {
-            let label = ui.label(lang.tr(if i == 0 { "Sort by" } else { "Then by" }));
-            let mut col = lv["column"].as_str().unwrap_or("A").to_string();
-            if columns.is_empty() {
-                ui.add(egui::TextEdit::singleline(&mut col).desired_width(50.0)).labelled_by(label.id);
-            } else {
-                egui::ComboBox::from_id_salt(("sort_col", i))
-                    .selected_text(col.clone())
-                    .show_ui(ui, |ui| {
-                        for (letter, label) in &columns {
-                            ui.selectable_value(&mut col, letter.clone(), label.as_str());
-                        }
-                    })
-                    .response
-                    .labelled_by(label.id);
-            }
-            lv["column"] = json!(col.to_ascii_uppercase());
-            let mut by = lv["by"].as_str().unwrap_or("values").to_string();
-            egui::ComboBox::from_id_salt(("by", i))
-                .selected_text(match by.as_str() {
-                    "cellColor" => "Cell Color",
-                    "fontColor" => "Font Color",
-                    _ => "Cell Values",
-                })
-                .show_ui(ui, |ui| {
-                    ui.selectable_value(&mut by, "values".into(), "Cell Values");
-                    ui.selectable_value(&mut by, "cellColor".into(), "Cell Color");
-                    ui.selectable_value(&mut by, "fontColor".into(), "Font Color");
-                })
-                .response
-                .accessible_name(lang.tr("Sort On"));
-            lv["by"] = json!(by);
-            let mut desc = lv["order"].as_str() == Some("desc");
-            ui.radio_value(&mut desc, false, "A to Z");
-            ui.radio_value(&mut desc, true, "Z to A");
-            lv["order"] = json!(if desc { "desc" } else { "asc" });
-            if crate::widgets::icon_button(ui, Icon::Close, crate::theme::Tokens::get(ui.ctx()).text_dim, "Remove level", vec2(18.0, 18.0)).clicked()
-            {
-                remove = Some(i);
-            }
-        });
-    }
-    if let Some(i) = remove
-        && levels.len() > 1
-    {
-        levels.remove(i);
-    }
-    if ui.button("+ Add Level").clicked() {
-        let used: Vec<String> = levels.iter().filter_map(|l| l.get("column").and_then(Json::as_str).map(str::to_string)).collect();
-        let next = columns
-            .iter()
-            .map(|(l, _)| l)
-            .find(|l| !used.contains(l))
-            .cloned()
-            .or_else(|| columns.last().map(|(l, _)| l.clone()))
-            .unwrap_or_else(|| "B".into());
-        levels.push(json!({"column": next, "order": "asc"}));
-    }
-    d.values.insert("levels".into(), Json::Array(levels.clone()));
-    let mut open = true;
-    ok_cancel(ui, confirm, &mut open);
-    if *confirm {
-        app.run_or_alert("data.sort", json!({"header": header, "keys": levels}));
-    }
-    if !open {
-        *confirm = true;
-    }
-}
-
-fn name_manager(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, open: &mut bool) {
-    let list = app.session.run("formulas.nameManager", json!({})).unwrap_or(Json::Null);
-    let names = list.as_array().cloned().unwrap_or_default();
-    let selected = names.get(d.list_index).cloned();
-    let field = |n: &Json, k: &str| n.get(k).and_then(Json::as_str).unwrap_or("").to_string();
-    ui.horizontal(|ui| {
-        if ui.button("New…").clicked() {
-            app.open_dialog("defineName", json!({}));
-        }
-        if ui.add_enabled(selected.is_some(), egui::Button::new("Edit…")).clicked()
-            && let Some(n) = &selected
-        {
-            app.open_dialog(
-                "defineName",
-                json!({
-                    "name": field(n, "name"), "scope": field(n, "scope"), "comment": field(n, "comment"),
-                    "refersTo": field(n, "refersTo"), "oldName": field(n, "name"), "oldScope": field(n, "scope"),
-                }),
-            );
-        }
-        if ui.add_enabled(selected.is_some(), egui::Button::new("Delete")).clicked()
-            && let Some(n) = &selected
-        {
-            app.run_or_alert("formulas.deleteName", json!({"name": field(n, "name"), "scope": field(n, "scope")}));
-        }
-    });
-    ui.add_space(4.0);
-    egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
-        egui::Grid::new("names").striped(true).num_columns(4).show(ui, |ui| {
-            ui.strong("Name");
-            ui.strong("Value");
-            ui.strong("Refers To");
-            ui.strong("Scope");
-            ui.end_row();
-            if names.is_empty() {
-                ui.label(egui::RichText::new("No names defined").italics());
-                ui.end_row();
-            }
-            for (i, n) in names.iter().enumerate() {
-                if ui.selectable_label(i == d.list_index, field(n, "name")).clicked() {
-                    d.list_index = i;
-                }
-                ui.label(n.get("value").map(|v| v.to_string()).unwrap_or_default().chars().take(30).collect::<String>());
-                ui.label(field(n, "refersTo"));
-                ui.label(field(n, "scope"));
-                ui.end_row();
-            }
-        });
-    });
-    ui.add_space(8.0);
-    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-        if ui.button(" Close ").clicked() {
-            *open = false;
-        }
-    });
-}
-
-/// The names Paste Names offers in the active workbook.
-fn pasteable_names(app: &SheetApp) -> Vec<String> {
-    app.session
-        .active()
-        .map(|doc| gridcraft_engine::cmd::formulas::pasteable_names(&doc.wb).into_iter().map(|(n, _)| n).collect())
-        .unwrap_or_default()
-}
-
-/// Puts a defined name into the formula being edited, at the caret. Without an edit under way it
-/// starts one in the active cell with `=` and the name.
-pub(crate) fn insert_name(app: &mut SheetApp, name: &str) {
-    match app.editor.as_mut() {
-        Some(ed) => ed.insert_at_caret(name),
-        None => app.begin_edit(Some(format!("={name}")), false),
-    }
-}
-
-/// Paste Name (F3, Formulas › Use in Formula › Paste Names…): OK, or a double-click, inserts the
-/// selected name (`formulas.pasteName` with `name`); Paste List writes every name and what it
-/// refers to from the active cell.
-fn paste_name(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    let names: Vec<String> =
-        d.result.as_ref().and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_str).map(str::to_owned).collect()).unwrap_or_default();
-    // The `name` value is the selection, so `ui.dialog.set` can choose one too.
-    if let Some(i) = d.values.get("name").and_then(Json::as_str).and_then(|n| names.iter().position(|x| x == n)) {
-        d.list_index = i;
-    }
-    let (down, up) = ui.input_mut(|i| (i.consume_key(egui::Modifiers::NONE, Key::ArrowDown), i.consume_key(egui::Modifiers::NONE, Key::ArrowUp)));
-    let last = names.len().saturating_sub(1);
-    if down {
-        d.list_index = (d.list_index + 1).min(last);
-    }
-    if up {
-        d.list_index = d.list_index.saturating_sub(1);
-    }
-    d.list_index = d.list_index.min(last);
-    ui.label(app.ui.language.tr("Paste name"));
-    if names.is_empty() {
-        ui.label(egui::RichText::new(app.ui.language.tr("No names defined")).italics());
-    }
-    // A workbook can hold thousands of names: only the rows in view are laid out.
-    let row_height = ui.text_style_height(&egui::TextStyle::Button) + 2.0 * ui.spacing().button_padding.y;
-    let step = row_height + ui.spacing().item_spacing.y;
-    egui::ScrollArea::vertical().max_height(220.0).auto_shrink([false, true]).show_rows(ui, row_height, names.len(), |ui, rows| {
-        let top = ui.cursor().top() - rows.start as f32 * step;
-        for (i, n) in names.iter().enumerate().skip(rows.start).take(rows.len()) {
-            let r = ui.selectable_label(i == d.list_index, n);
-            if r.clicked() {
-                d.list_index = i;
-            }
-            if r.double_clicked() {
-                *confirm = true;
-            }
-        }
-        // The arrow keys can move the selection onto a row that isn't laid out.
-        if down || up {
-            let rect = egui::Rect::from_min_size(egui::pos2(ui.min_rect().left(), top + d.list_index as f32 * step), egui::vec2(1.0, row_height));
-            if !ui.clip_rect().contains_rect(rect) {
-                ui.scroll_to_rect(rect, Some(if down { egui::Align::Max } else { egui::Align::Min }));
-            }
-        }
-    });
-    ui.add_space(4.0);
-    // Paste List is disabled while a cell is being edited.
-    if ui.add_enabled(!names.is_empty() && app.editor.is_none(), egui::Button::new(app.ui.language.tr("Paste List"))).clicked() {
-        app.run_or_alert("formulas.pasteName", json!({"list": true}));
-        *open = false;
-        return;
-    }
-    if let Some(n) = names.get(d.list_index) {
-        d.values.insert("name".into(), json!(n));
-    }
-    ok_cancel(ui, confirm, open);
-}
-
-/// Every chart type the All Charts tab offers: `(type, subtype, label)` for `insert.chart`.
-const ALL_CHARTS: [(&str, &str, &str); 21] = [
-    ("column", "", "Clustered Column"),
-    ("column", "stacked", "Stacked Column"),
-    ("column", "stacked100", "100% Stacked Column"),
-    ("bar", "", "Clustered Bar"),
-    ("bar", "stacked", "Stacked Bar"),
-    ("bar", "stacked100", "100% Stacked Bar"),
-    ("line", "", "Line"),
-    ("line", "markers", "Line with Markers"),
-    ("line", "stacked", "Stacked Line"),
-    ("pie", "", "Pie"),
-    ("doughnut", "", "Doughnut"),
-    ("area", "", "Area"),
-    ("area", "stacked", "Stacked Area"),
-    ("area", "stacked100", "100% Stacked Area"),
-    ("scatter", "", "Scatter"),
-    ("scatter", "lines", "Scatter with Lines"),
-    ("radar", "", "Radar"),
-    ("histogram", "", "Histogram"),
-    ("waterfall", "", "Waterfall"),
-    ("funnel", "", "Funnel"),
-    ("combo", "", "Combo"),
-];
-
-/// The chart types listed on the dialog's current tab.
-fn chart_choices(d: &Dialog) -> Vec<(String, String, String)> {
-    if d.tab == "All Charts" {
-        return ALL_CHARTS.iter().map(|(t, s, l)| (t.to_string(), s.to_string(), l.to_string())).collect();
-    }
-    let field = |x: &Json, k: &str| x.get(k).and_then(Json::as_str).unwrap_or("").to_string();
-    d.result
-        .as_ref()
-        .and_then(Json::as_array)
-        .map(|a| a.iter().map(|x| (field(x, "type"), field(x, "subtype"), field(x, "label"))).collect())
-        .unwrap_or_default()
-}
-
-/// Selects entry `i` of the current tab: OK inserts it.
-fn select_chart(d: &mut Dialog, i: usize) {
-    let Some((t, sub, _)) = chart_choices(d).into_iter().nth(i) else { return };
-    d.list_index = i;
-    d.values.insert("type".into(), json!(t));
-    d.values.insert("subtype".into(), json!(sub));
-}
-
-fn chart_icon(t: &str) -> Icon {
-    match t {
-        "column" | "bar" | "histogram" | "waterfall" | "funnel" | "combo" => Icon::ChartBar,
-        "line" | "area" | "radar" => Icon::ChartLine,
-        "pie" | "doughnut" => Icon::ChartPie,
-        "scatter" | "bubble" => Icon::ChartScatter,
-        _ => Icon::Chart,
-    }
-}
-
-fn recommended_charts(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    ui.horizontal(|ui| {
-        for tab in ["Recommended Charts", "All Charts"] {
-            if ui.selectable_label(d.tab == tab, tab).clicked() && d.tab != tab {
-                d.tab = tab.to_string();
-                select_chart(d, 0);
-            }
-        }
-    });
-    ui.separator();
-    let choices = chart_choices(d);
-    let t = crate::theme::Tokens::get(ui.ctx());
-    ui.horizontal_top(|ui| {
-        ui.vertical(|ui| {
-            ui.set_width(190.0);
-            egui::ScrollArea::vertical().id_salt("chart_choices").max_height(300.0).show(ui, |ui| {
-                for (i, (kind, _, label)) in choices.iter().enumerate() {
-                    let resp = ui
-                        .horizontal(|ui| {
-                            let (r, _) = ui.allocate_exact_size(vec2(22.0, 22.0), Sense::hover());
-                            icons::paint(ui.painter(), r.shrink(2.0), chart_icon(kind), t.text);
-                            ui.selectable_label(i == d.list_index, label.as_str())
-                        })
-                        .inner;
-                    if resp.clicked() {
-                        select_chart(d, i);
-                    }
-                    if resp.double_clicked() {
-                        select_chart(d, i);
-                        *confirm = true;
-                    }
-                }
-            });
-        });
-        ui.add_space(12.0);
-        ui.vertical(|ui| {
-            let label = choices.get(d.list_index).map(|c| c.2.clone()).unwrap_or_default();
-            ui.strong(label);
-            let (rect, _) = ui.allocate_exact_size(vec2(360.0, 216.0), Sense::hover());
-            ui.painter().rect_filled(rect, 2.0, Color32::WHITE);
-            ui.painter().rect_stroke(rect, 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
-            let params = json!({"type": d.values.get("type").cloned().unwrap_or(Json::Null), "subtype": d.values.get("subtype").cloned().unwrap_or(Json::Null)});
-            if let Some(doc) = app.session.active()
-                && let Ok((sheet, chart)) = gridcraft_engine::cmd::insert::build_chart(&app.session, &params)
-            {
-                crate::chartview::paint_chart(ui.painter(), rect, &doc.wb, sheet, &chart);
-            }
-        });
-    });
-    ok_cancel(ui, confirm, open);
-    if *confirm {
-        *confirm = false;
-        let params =
-            json!({"type": d.values.get("type").cloned().unwrap_or(Json::Null), "subtype": d.values.get("subtype").cloned().unwrap_or(Json::Null)});
-        match app.run("insert.chart", params) {
-            Ok(r) => {
-                // The new chart is selected, as after inserting any object.
-                app.selected_chart = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok());
-                *open = false;
-            }
-            Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))),
-        }
-    }
-}
-
-/// Draws chart range, series keep/remove and category-range controls and runs `chart.selectData` when something changed.
-fn select_data(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    let text = |d: &Dialog, k: &str| d.values.get(k).and_then(Json::as_str).unwrap_or("").to_string();
-    let edit = |ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str| {
-        let label = ui.label(label);
-        let mut v = text(d, key);
-        if ui.add(egui::TextEdit::singleline(&mut v).desired_width(420.0)).labelled_by(label.id).changed() {
-            d.values.insert(key.into(), json!(v));
-        }
-    };
-    edit(ui, d, "range", "Chart data range:");
-    ui.add_space(6.0);
-    ui.strong("Legend Entries (Series)");
-    let names: Vec<String> =
-        d.values.get("names").and_then(Json::as_array).map(|a| a.iter().map(|n| n.as_str().unwrap_or("").to_string()).collect()).unwrap_or_default();
-    let mut remove: Vec<u64> =
-        d.values.get("remove").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
-    let kept = names.len().saturating_sub(remove.len());
-    egui::ScrollArea::vertical().id_salt("series").max_height(160.0).show(ui, |ui| {
-        for (i, name) in names.iter().enumerate() {
-            let i = i as u64;
-            let removed = remove.contains(&i);
-            ui.horizontal(|ui| {
-                let label = if name.is_empty() { format!("Series{}", i + 1) } else { name.clone() };
-                ui.label(if removed { egui::RichText::new(label).strikethrough().weak() } else { egui::RichText::new(label) });
-                if removed {
-                    if ui.small_button("Keep").clicked() {
-                        remove.retain(|x| *x != i);
-                    }
-                } else if ui.add_enabled(kept > 1, egui::Button::new("Remove").small()).clicked() {
-                    remove.push(i);
-                }
-            });
-        }
-    });
-    d.values.insert("remove".into(), json!(remove));
-    ui.add_space(6.0);
-    edit(ui, d, "categories", "Horizontal (Category) Axis Labels:");
-    ok_cancel(ui, confirm, open);
-    if *confirm {
-        *confirm = false;
-        let mut params = serde_json::Map::new();
-        params.insert("chart".into(), d.values.get("chart").cloned().unwrap_or(Json::Null));
-        let range_changed = text(d, "range") != text(d, "range0");
-        if range_changed {
-            params.insert("range".into(), json!(text(d, "range")));
-        } else if !remove.is_empty() {
-            // A new range rebuilds the series; removals only apply to the current ones.
-            params.insert("removeSeries".into(), json!(remove));
-        }
-        if text(d, "categories") != text(d, "categories0") || (range_changed && !text(d, "categories").is_empty()) {
-            params.insert("categories".into(), json!(text(d, "categories")));
-        }
-        if params.len() == 1 {
-            *open = false;
-            return;
-        }
-        match app.run("chart.selectData", Json::Object(params)) {
-            Ok(_) => *open = false,
-            Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))),
-        }
-    }
-}
-
-fn manage_rules(app: &mut SheetApp, ui: &mut egui::Ui) {
-    let list = app.session.run("home.manageRules", json!({})).unwrap_or(Json::Null);
-    let rules = list["rules"].as_array().cloned().unwrap_or_default();
-    if rules.is_empty() {
-        ui.label("There are no conditional formatting rules on this sheet.");
-    }
-    for (i, r) in rules.iter().enumerate() {
-        ui.horizontal(|ui| {
-            let kind = r["rule"].as_object().and_then(|o| o.keys().next().cloned()).unwrap_or_default();
-            ui.label(format!(
-                "{}. {kind}  applies to {}",
-                i + 1,
-                r["ranges"].as_array().map(|a| a.iter().filter_map(|x| x.as_str()).collect::<Vec<_>>().join(",")).unwrap_or_default()
-            ));
-            if ui.small_button("▲").clicked() {
-                app.run_or_alert("home.manageRules", json!({"moveUp": i}));
-            }
-            if ui.small_button("▼").clicked() {
-                app.run_or_alert("home.manageRules", json!({"moveDown": i}));
-            }
-            if ui.small_button("Delete").clicked() {
-                app.run_or_alert("home.manageRules", json!({"delete": i}));
-            }
-        });
-    }
-}
-
-fn command_search(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
-    let (down, up, home, end, pgup, pgdn) = ui.input_mut(|i| {
-        (
-            i.consume_key(egui::Modifiers::NONE, Key::ArrowDown),
-            i.consume_key(egui::Modifiers::NONE, Key::ArrowUp),
-            i.consume_key(egui::Modifiers::CTRL, Key::Home),
-            i.consume_key(egui::Modifiers::CTRL, Key::End),
-            i.consume_key(egui::Modifiers::NONE, Key::PageUp),
-            i.consume_key(egui::Modifiers::NONE, Key::PageDown),
-        )
-    });
-    let width = ui.available_width();
-    let r = ui.add(egui::TextEdit::singleline(&mut d.search).desired_width(width).hint_text("Type a command, e.g. freeze, chart, bold…"));
-
-    if !d.focus_initialized {
-        r.request_focus();
-        d.focus_initialized = true;
-    }
-
-    let q = d.search.to_ascii_lowercase();
-    let cmds: Vec<(String, String, String)> = app
-        .session
-        .commands()
-        .into_iter()
-        .filter(|c| c.enabled)
-        .filter(|c| q.is_empty() || c.label.to_ascii_lowercase().contains(&q) || c.id.to_ascii_lowercase().contains(&q))
-        .map(|c| (c.id.to_string(), c.label.to_string(), c.menu.join(" › ")))
-        .take(40)
-        .collect();
-
-    let last = cmds.len().saturating_sub(1);
-
-    let row_h = ui.spacing().interact_size.y.max(20.0);
-    let row_step = row_h + ui.spacing().item_spacing.y;
-
-    const LIST_HEIGHT: f32 = 320.0;
-
-    let page_size = ((LIST_HEIGHT / row_step).floor() as usize).saturating_sub(1).max(1);
-
-    if down {
-        d.list_index = (d.list_index + 1).min(last);
-    }
-    if up {
-        d.list_index = d.list_index.saturating_sub(1);
-    }
-    if pgdn {
-        d.list_index = (d.list_index + page_size).min(last);
-    }
-    if pgup {
-        d.list_index = d.list_index.saturating_sub(page_size);
-    }
-    if home {
-        d.list_index = 0;
-    }
-    if end {
-        d.list_index = last;
-    }
-
-    d.list_index = d.list_index.min(last);
-
-    egui::ScrollArea::vertical().max_height(LIST_HEIGHT).auto_shrink([true, false]).show(ui, |ui| {
-        let scroll_area_width = ui.available_width();
-        for (i, (id, label, menu)) in cmds.iter().enumerate() {
-            let r = ui.add(egui::Button::selectable(i == d.list_index, format!("{label}    {menu}")).min_size(vec2(scroll_area_width, 20.0)));
-
-            if (down || up || home || end || pgup || pgdn) && i == d.list_index && !ui.clip_rect().contains_rect(r.rect) {
-                r.scroll_to_me(Some(if down || end || pgdn { egui::Align::Max } else { egui::Align::Min }));
-            }
-
-            if r.clicked() {
-                d.list_index = i;
-                *confirm = true;
-            }
-
-            r.on_hover_text(id);
-        }
-    });
-    if ui.input(|i| i.key_pressed(Key::Enter)) {
-        *confirm = true;
-    }
-    if *confirm && let Some((id, ..)) = cmds.get(d.list_index) {
-        let id = id.clone();
-        app.dialog = None;
-        app.run_or_alert(&id, json!({}));
-    }
-}
-
-fn goal_seek(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
-    let get = |k: &str| d.values.get(k).and_then(Json::as_str).unwrap_or("").to_string();
-    let (mut set, mut to, mut changing) = (get("set"), get("to"), get("changing"));
-    egui::Grid::new("gs").show(ui, |ui| {
-        ui.label("Set cell:");
-        ui.text_edit_singleline(&mut set);
-        ui.end_row();
-        ui.label("To value:");
-        ui.text_edit_singleline(&mut to);
-        ui.end_row();
-        ui.label("By changing cell:");
-        ui.text_edit_singleline(&mut changing);
-        ui.end_row();
-    });
-    d.values.insert("set".into(), json!(set.clone()));
-    d.values.insert("to".into(), json!(to.clone()));
-    d.values.insert("changing".into(), json!(changing.clone()));
-    let mut open = true;
-    ok_cancel(ui, confirm, &mut open);
-    if *confirm {
-        match app.run("data.goalSeek", json!({"set": set, "to": to.parse::<f64>().unwrap_or(0.0), "changing": changing})) {
-            Ok(r) => app.toast = Some((format!("Goal Seeking found a solution: {}", r["value"]), crate::now_ms())),
-            Err(e) => app.message = Some(("Goal Seek".into(), crate::clean_error(&e))),
-        }
-    }
-    if !open {
-        *confirm = true;
-    }
-}
-
-/// The fields of one Analysis ToolPak tool's form (input and options; output is drawn apart).
-fn toolpak_fields(tool: &str) -> Vec<Field> {
-    use Field::*;
-    let grouped = || Choice { key: "groupedBy", label: "Grouped By:", options: vec![("columns", "Columns"), ("rows", "Rows")] };
-    let labels = || Check { key: "labels", label: "Labels in first row" };
-    let range = || Text { key: "range", label: "Input Range:" };
-    let two = || vec![Text { key: "range1", label: "Variable 1 Range:" }, Text { key: "range2", label: "Variable 2 Range:" }];
-    match tool {
-        "descriptive" => vec![
-            range(),
-            grouped(),
-            labels(),
-            Check { key: "summary", label: "Summary statistics" },
-            Text { key: "confidence", label: "Confidence Level for Mean (%), blank for none:" },
-            Text { key: "kthLargest", label: "Kth Largest (blank for none):" },
-            Text { key: "kthSmallest", label: "Kth Smallest (blank for none):" },
-        ],
-        "histogram" => vec![
-            range(),
-            Text { key: "bins", label: "Bin Range (blank for automatic bins):" },
-            labels(),
-            Check { key: "pareto", label: "Pareto (sorted histogram)" },
-            Check { key: "cumulative", label: "Cumulative Percentage" },
-        ],
-        "correlation" | "covariance" | "rankPercentile" => vec![range(), grouped(), labels()],
-        "anovaSingle" => vec![range(), grouped(), labels(), Text { key: "alpha", label: "Alpha:" }],
-        "regression" => vec![
-            Text { key: "inputY", label: "Input Y Range:" },
-            Text { key: "inputX", label: "Input X Range:" },
-            labels(),
-            Check { key: "constantZero", label: "Constant is Zero" },
-            Text { key: "confidence", label: "Confidence Level (%):" },
-            Check { key: "residuals", label: "Residuals" },
-            Check { key: "standardizedResiduals", label: "Standardized Residuals" },
-            Check { key: "normalProbability", label: "Normal Probability" },
-        ],
-        "movingAverage" => {
-            vec![range(), labels(), Text { key: "interval", label: "Interval:" }, Check { key: "standardErrors", label: "Standard Errors" }]
-        }
-        "exponentialSmoothing" => {
-            vec![range(), labels(), Text { key: "damping", label: "Damping factor:" }, Check { key: "standardErrors", label: "Standard Errors" }]
-        }
-        "fTest" => {
-            let mut v = two();
-            v.extend([labels(), Text { key: "alpha", label: "Alpha:" }]);
-            v
-        }
-        _ => {
-            let mut v = two();
-            v.extend([
-                Text { key: "hypothesizedDifference", label: "Hypothesized Mean Difference:" },
-                labels(),
-                Text { key: "alpha", label: "Alpha:" },
-            ]);
-            v
-        }
-    }
-}
-
-/// The starting values of a tool's form: the selection as its input, a new sheet as output.
-fn toolpak_defaults(sel: &str, tool: &str) -> Map<String, Json> {
-    let mut v = json!({
-        "tool": tool, "range": sel, "inputY": "", "inputX": "", "range1": sel, "range2": "", "bins": "",
-        "groupedBy": "columns", "labels": false, "summary": true, "confidence": "", "kthLargest": "", "kthSmallest": "",
-        "interval": "3", "damping": "0.3", "alpha": "0.05", "hypothesizedDifference": "0",
-        "outputTo": "newSheet", "output": "", "newSheet": "",
-    });
-    if tool == "regression" {
-        v["confidence"] = json!("95");
-        v["inputY"] = json!(sel);
-    }
-    v.as_object().cloned().unwrap_or_default()
-}
-
-/// Data › Data Analysis: pick a tool, then fill in its form. OK runs `data.analysisToolPak`
-/// (through the dialog's command); a report that would replace data asks first.
-fn analysis_toolpak(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    use gridcraft_engine::cmd::analysis::TOOLS;
-    if d.values.get("askOverwrite").and_then(Json::as_bool) == Some(true) {
-        ui.label("The output range already holds data. Replace it with the report?");
-        ui.horizontal(|ui| {
-            if ui.button("Replace").clicked() {
-                d.values.remove("askOverwrite");
-                d.values.insert("overwrite".into(), json!(true));
-                *confirm = true;
-            }
-            if ui.button("Cancel").clicked() {
-                d.values.remove("askOverwrite");
-            }
-        });
-        return;
-    }
-    let tool = d.values.get("tool").and_then(Json::as_str).unwrap_or("").to_string();
-    let Some((_, label)) = TOOLS.iter().find(|(id, _)| *id == tool) else {
-        ui.label(egui::RichText::new("Analysis Tools").strong());
-        let pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
-        let mut chosen = false;
-        egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
-            for (id, label) in TOOLS {
-                let r = ui.selectable_label(pick == *id, *label);
-                if r.clicked() {
-                    d.values.insert("pick".into(), json!(id));
-                }
-                if r.double_clicked() {
-                    chosen = true;
-                }
-            }
-        });
-        let mut ok = false;
-        ok_cancel(ui, &mut ok, open);
-        let pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
-        if (ok || chosen) && TOOLS.iter().any(|(id, _)| *id == pick) {
-            let sel = app.session.active().map(|doc| doc.selection.current().a1()).unwrap_or_default();
-            d.values = toolpak_defaults(&sel, &pick);
-        }
-        return;
-    };
-    d.title = label.to_string();
-    d.fields = toolpak_fields(&tool);
-    form_fields(ui, d);
-    ui.separator();
-    ui.label(egui::RichText::new("Output options").strong());
-    let to = d.values.get("outputTo").and_then(Json::as_str).unwrap_or("newSheet").to_string();
-    for (key, choice, text_label) in [("output", "range", "Output Range:"), ("newSheet", "newSheet", "New Worksheet Ply:")] {
-        ui.horizontal(|ui| {
-            if ui.radio(to == choice, text_label).clicked() {
-                d.values.insert("outputTo".into(), json!(choice));
-            }
-            let mut t = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
-            if ui.add(egui::TextEdit::singleline(&mut t).desired_width(160.0)).changed() {
-                d.values.insert(key.into(), json!(t));
-                d.values.insert("outputTo".into(), json!(choice));
-            }
-        });
-    }
-    ok_cancel(ui, confirm, open);
-}
-
-/// Data › Solver: the Solver Parameters form. Solve runs `data.solver` through the dialog's
-/// command; the result opens Solver Results.
-fn solver(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
-    let lang = crate::i18n::current(ui.ctx());
-    let text = |d: &Dialog, k: &str| d.values.get(k).map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())).unwrap_or_default();
-    let edit = |ui: &mut egui::Ui, d: &mut Dialog, k: &str, width: f32, label: &str| {
-        let mut t = text(d, k);
-        if ui.add(egui::TextEdit::singleline(&mut t).desired_width(width)).accessible_name(lang.tr(label)).changed() {
-            d.values.insert(k.into(), json!(t));
-        }
-    };
-    ui.horizontal(|ui| {
-        ui.label("Set Objective:");
-        edit(ui, d, "objective", 200.0, "Set Objective:");
-    });
-    let goal = text(d, "goal");
-    ui.horizontal(|ui| {
-        ui.label("To:");
-        for (g, label) in [("max", "Max"), ("min", "Min"), ("value", "Value Of:")] {
-            if ui.radio(goal == g, label).clicked() {
-                d.values.insert("goal".into(), json!(g));
-            }
-        }
-        edit(ui, d, "value", 80.0, "Value Of:");
-    });
-    ui.label("By Changing Variable Cells:");
-    edit(ui, d, "variables", 420.0, "By Changing Variable Cells:");
-    ui.label("Subject to the Constraints:");
-    let list: Vec<String> = d
-        .values
-        .get("constraints")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().map(|c| c.as_str().map(str::to_string).unwrap_or_else(|| c.to_string())).collect())
-        .unwrap_or_default();
-    egui::Frame::group(ui.style()).show(ui, |ui| {
-        ui.set_min_size(vec2(420.0, 90.0));
-        egui::ScrollArea::vertical().max_height(110.0).show(ui, |ui| {
-            for (i, c) in list.iter().enumerate() {
-                if ui.selectable_label(d.list_index == i, c).clicked() {
-                    d.list_index = i;
-                }
-            }
-        });
-    });
-    ui.horizontal(|ui| {
-        edit(ui, d, "newLhs", 110.0, "Constraint Cell Reference");
-        let op = text(d, "newOp");
-        egui::ComboBox::from_id_salt("solverOp")
-            .selected_text(op.clone())
-            .width(60.0)
-            .show_ui(ui, |ui| {
-                for o in ["<=", "=", ">=", "int", "bin"] {
-                    if ui.selectable_label(op == o, o).clicked() {
-                        d.values.insert("newOp".into(), json!(o));
-                    }
-                }
-            })
-            .response
-            .accessible_name(lang.tr("Constraint Operator"));
-        if !matches!(op.as_str(), "int" | "bin") {
-            edit(ui, d, "newRhs", 110.0, "Constraint Value");
-        }
-        if ui.button("Add").clicked() {
-            let lhs = text(d, "newLhs");
-            if !lhs.trim().is_empty() {
-                let rhs = if matches!(op.as_str(), "int" | "bin") { String::new() } else { format!(" {}", text(d, "newRhs").trim()) };
-                let mut list = list.clone();
-                list.push(format!("{} {op}{rhs}", lhs.trim()));
-                d.values.insert("constraints".into(), json!(list));
-                d.values.insert("newLhs".into(), json!(""));
-                d.values.insert("newRhs".into(), json!(""));
-            }
-        }
-        if ui.add_enabled(d.list_index < list.len(), egui::Button::new("Delete")).clicked() {
-            let mut list = list.clone();
-            if d.list_index < list.len() {
-                list.remove(d.list_index);
-            }
-            d.values.insert("constraints".into(), json!(list));
-        }
-    });
-    let mut nonneg = d.values.get("nonNegative").and_then(Json::as_bool).unwrap_or(true);
-    if ui.checkbox(&mut nonneg, "Make Unconstrained Variables Non-Negative").changed() {
-        d.values.insert("nonNegative".into(), json!(nonneg));
-    }
-    let method = text(d, "method");
-    ui.horizontal(|ui| {
-        ui.label("Select a Solving Method:");
-        let label = |m: &str| match m {
-            "simplex" => "Simplex LP",
-            "evolutionary" => "Evolutionary",
-            _ => "GRG Nonlinear",
-        };
-        egui::ComboBox::from_id_salt("solverMethod")
-            .selected_text(label(&method))
-            .show_ui(ui, |ui| {
-                for m in ["grg", "simplex", "evolutionary"] {
-                    if ui.selectable_label(method == m, label(m)).clicked() {
-                        d.values.insert("method".into(), json!(m));
-                    }
-                }
-            })
-            .response
-            .accessible_name(lang.tr("Select a Solving Method:"));
-    });
-    ui.label(
-        egui::RichText::new(match method.as_str() {
-            "simplex" => "Simplex LP: for linear models; integer and binary constraints by branch and bound.",
-            "evolutionary" => "Evolutionary: a genetic search for models that aren't smooth; every variable cell needs bounds.",
-            _ => "GRG Nonlinear: a local optimum of a smooth model, from the current values.",
-        })
-        .small(),
-    );
-    ui.add_space(8.0);
-    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-        let t = crate::theme::Tokens::get(ui.ctx());
-        let solve = ui.add(egui::Button::new(egui::RichText::new("  Solve  ").color(t.on_accent)).fill(t.accent));
-        if solve.clicked() && !text(d, "objective").trim().is_empty() {
-            *confirm = true;
-        }
-        if ui.button(" Close ").clicked() {
-            *open = false;
-        }
-    });
-}
-
-/// Solver Results: the outcome, and keeping or restoring the variable cells.
-fn solver_results(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, open: &mut bool) {
-    let message = d.values.get("message").and_then(Json::as_str).unwrap_or("").to_string();
-    ui.label(message);
-    let changed = d.values.get("changed").and_then(Json::as_bool).unwrap_or(false);
-    let restore = d.values.get("restore").and_then(Json::as_bool).unwrap_or(false);
-    if changed {
-        ui.add_space(4.0);
-        if ui.radio(!restore, "Keep Solver Solution").clicked() {
-            d.values.insert("restore".into(), json!(false));
-        }
-        if ui.radio(restore, "Restore Original Values").clicked() {
-            d.values.insert("restore".into(), json!(true));
-        }
-    }
-    // Reports describe the solution whether it is kept or not.
-    let solved = d.values.get("values").and_then(Json::as_object).is_some_and(|v| !v.is_empty());
-    if solved {
-        ui.add_space(4.0);
-        ui.label("Reports:");
-        for (key, label) in [("answerReport", "Answer"), ("limitsReport", "Limits")] {
-            let mut on = d.values.get(key).and_then(Json::as_bool).unwrap_or(false);
-            if ui.checkbox(&mut on, label).changed() {
-                d.values.insert(key.into(), json!(on));
-            }
-        }
-    }
-    let mut confirm = false;
-    ok_cancel(ui, &mut confirm, open);
-    if confirm {
-        // The solution (and the saved model) is one undo step.
-        if changed && restore {
-            app.run_or_alert("edit.undo", json!({}));
-        }
-        let reports: Vec<&str> = [("answerReport", "answer"), ("limitsReport", "limits")]
-            .into_iter()
-            .filter(|(key, _)| d.values.get(*key).and_then(Json::as_bool) == Some(true))
-            .map(|(_, kind)| kind)
-            .collect();
-        if solved && !reports.is_empty() {
-            let field = |k: &str| d.values.get(k).cloned().unwrap_or(Json::Null);
-            let params = json!({"reports": reports, "model": field("model"), "values": field("values"), "original": field("original"), "message": field("message")});
-            app.run_or_alert("data.solverReport", params);
-        }
-        *open = false;
-    }
-}
-
-fn spelling(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, open: &mut bool) {
-    let r = d.result.clone().unwrap_or(Json::Null);
-    if let Some(e) = r.get("error").and_then(Json::as_str) {
-        ui.label(app.ui.language.tr_error(e));
-        return;
-    }
-    let issues = r["issues"].as_array().cloned().unwrap_or_default();
-    let Some(it) = issues.get(d.list_index) else {
-        ui.label("The spelling check is complete for the entire sheet.");
-        if ui.button("OK").clicked() {
-            *open = false;
-        }
-        return;
-    };
-    let word = it["word"].as_str().unwrap_or("").to_string();
-    let cell = it["cell"].as_str().unwrap_or("").to_string();
-    ui.label(format!("Not in Dictionary ({cell}):"));
-    ui.label(egui::RichText::new(&word).strong().color(crate::theme::Tokens::get(ui.ctx()).danger));
-    let sugg: Vec<String> =
-        it["suggestions"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default();
-    ui.label("Suggestions:");
-    let mut pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
-    for s in &sugg {
-        if ui.selectable_label(pick == *s, s).clicked() {
-            pick = s.clone();
-        }
-    }
-    if sugg.is_empty() {
-        ui.label(egui::RichText::new("(No suggestions)").italics());
-    }
-    d.values.insert("pick".into(), json!(pick.clone()));
-    let _ = app.session.run("selection.set", json!({"cell": cell}));
-    ui.horizontal(|ui| {
-        if ui.button("Ignore Once").clicked() {
-            d.list_index += 1;
-        }
-        if ui.button("Add to Dictionary").clicked() {
-            let _ = app.session.run("review.addToDictionary", json!({"word": word}));
-            d.list_index += 1;
-        }
-        if !pick.is_empty() {
-            if ui.button("Change").clicked() {
-                app.run_or_alert("review.changeSpelling", json!({"cell": cell, "word": word, "to": pick}));
-                d.list_index += 1;
-            }
-            if ui.button("Change All").clicked() {
-                app.run_or_alert("review.changeSpelling", json!({"word": word, "to": pick, "all": true}));
-                d.list_index += 1;
-            }
-        }
-    });
-}
-
-#[cfg(test)]
-mod data_validation_tests {
-    use super::*;
-
-    #[test]
-    fn list_uses_one_source_and_does_not_submit_a_second_list() {
-        let fields = data_validation_fields("list", "between");
-        assert!(fields.iter().any(|f| matches!(f, Field::Text { key: "formula1", label: "Source:" })));
-        assert!(!fields.iter().any(|f| matches!(f, Field::Text { key: "formula2", .. } | Field::Choice { key: "operator", .. })));
-
-        let dialog = Dialog::form(
-            "dataValidation",
-            "Data Validation",
-            "data.validation",
-            fields,
-            json!({"type": "list", "operator": "between", "formula1": "ABC,DEF", "formula2": "GHI,JKL", "dropdown": true}),
-        );
-        let params = build_params(&dialog);
-        assert_eq!(params["formula1"], "ABC,DEF");
-        assert!(params.get("formula2").is_none());
-        assert!(params.get("operator").is_none());
-    }
-
-    #[test]
-    fn only_between_operators_show_and_submit_two_bounds() {
-        let two = data_validation_fields("whole", "between");
-        assert!(two.iter().any(|f| matches!(f, Field::Text { key: "formula2", label: "Maximum:" })));
-        let one = data_validation_fields("date", "lessOrEqual");
-        assert!(one.iter().any(|f| matches!(f, Field::Text { key: "formula1", label: "End date:" })));
-        assert!(!one.iter().any(|f| matches!(f, Field::Text { key: "formula2", .. })));
-
-        let dialog = Dialog::form(
-            "dataValidation",
-            "Data Validation",
-            "data.validation",
-            one,
-            json!({"type": "date", "operator": "lessOrEqual", "formula1": "2026-10-12", "formula2": "2030-01-01"}),
-        );
-        let params = build_params(&dialog);
-        assert_eq!(params["operator"], "lessOrEqual");
-        assert_eq!(params["formula1"], "2026-10-12");
-        assert!(params.get("formula2").is_none());
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui-egui/src/dialogs/about.rs b/crates/ui-egui/src/dialogs/about.rs
new file mode 100644
index 000000000..a337627d9
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/about.rs
@@ -0,0 +1,26 @@
+use super::*;
+
+/// Help ▸ About GridCraft: the app, its contributors and the AI models that helped. The credits
+/// are compiled in (`crate::credits`, docs/contributors.md).
+pub(super) fn about(ui: &mut egui::Ui, d: &mut Dialog) {
+    ui.horizontal(|ui| {
+        for tab in ["About", "Contributors", "Models"] {
+            if ui.selectable_label(d.tab == tab, tab).clicked() {
+                d.tab = tab.to_string();
+            }
+        }
+    });
+    ui.separator();
+    match d.tab.as_str() {
+        "Contributors" => crate::credits::contributors_ui(ui),
+        "Models" => crate::credits::models_ui(ui),
+        _ => {
+            ui.heading("GridCraft");
+            ui.label(format!("Version {}", env!("CARGO_PKG_VERSION")));
+            ui.add_space(4.0);
+            ui.label("A clean-room, open-source, Rust-native spreadsheet. Part of ArtCraft.");
+            ui.hyperlink_to("getartcraft.com/apps/gridcraft", "https://getartcraft.com/apps/gridcraft");
+            ui.hyperlink_to("Join the ArtCraft Discord", "https://discord.gg/artcraft");
+        }
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/analysis.rs b/crates/ui-egui/src/dialogs/analysis.rs
new file mode 100644
index 000000000..595be229c
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/analysis.rs
@@ -0,0 +1,344 @@
+use super::show::{form_fields, ok_cancel};
+use super::*;
+
+pub(super) fn goal_seek(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
+    let get = |k: &str| d.values.get(k).and_then(Json::as_str).unwrap_or("").to_string();
+    let (mut set, mut to, mut changing) = (get("set"), get("to"), get("changing"));
+    egui::Grid::new("gs").show(ui, |ui| {
+        ui.label("Set cell:");
+        ui.text_edit_singleline(&mut set);
+        ui.end_row();
+        ui.label("To value:");
+        ui.text_edit_singleline(&mut to);
+        ui.end_row();
+        ui.label("By changing cell:");
+        ui.text_edit_singleline(&mut changing);
+        ui.end_row();
+    });
+    d.values.insert("set".into(), json!(set.clone()));
+    d.values.insert("to".into(), json!(to.clone()));
+    d.values.insert("changing".into(), json!(changing.clone()));
+    let mut open = true;
+    ok_cancel(ui, confirm, &mut open);
+    if *confirm {
+        match app.run("data.goalSeek", json!({"set": set, "to": to.parse::<f64>().unwrap_or(0.0), "changing": changing})) {
+            Ok(r) => app.toast = Some((format!("Goal Seeking found a solution: {}", r["value"]), crate::now_ms())),
+            Err(e) => app.message = Some(("Goal Seek".into(), crate::clean_error(&e))),
+        }
+    }
+    if !open {
+        *confirm = true;
+    }
+}
+
+/// The fields of one Analysis ToolPak tool's form (input and options; output is drawn apart).
+fn toolpak_fields(tool: &str) -> Vec<Field> {
+    use Field::*;
+    let grouped = || Choice { key: "groupedBy", label: "Grouped By:", options: vec![("columns", "Columns"), ("rows", "Rows")] };
+    let labels = || Check { key: "labels", label: "Labels in first row" };
+    let range = || Text { key: "range", label: "Input Range:" };
+    let two = || vec![Text { key: "range1", label: "Variable 1 Range:" }, Text { key: "range2", label: "Variable 2 Range:" }];
+    match tool {
+        "descriptive" => vec![
+            range(),
+            grouped(),
+            labels(),
+            Check { key: "summary", label: "Summary statistics" },
+            Text { key: "confidence", label: "Confidence Level for Mean (%), blank for none:" },
+            Text { key: "kthLargest", label: "Kth Largest (blank for none):" },
+            Text { key: "kthSmallest", label: "Kth Smallest (blank for none):" },
+        ],
+        "histogram" => vec![
+            range(),
+            Text { key: "bins", label: "Bin Range (blank for automatic bins):" },
+            labels(),
+            Check { key: "pareto", label: "Pareto (sorted histogram)" },
+            Check { key: "cumulative", label: "Cumulative Percentage" },
+        ],
+        "correlation" | "covariance" | "rankPercentile" => vec![range(), grouped(), labels()],
+        "anovaSingle" => vec![range(), grouped(), labels(), Text { key: "alpha", label: "Alpha:" }],
+        "regression" => vec![
+            Text { key: "inputY", label: "Input Y Range:" },
+            Text { key: "inputX", label: "Input X Range:" },
+            labels(),
+            Check { key: "constantZero", label: "Constant is Zero" },
+            Text { key: "confidence", label: "Confidence Level (%):" },
+            Check { key: "residuals", label: "Residuals" },
+            Check { key: "standardizedResiduals", label: "Standardized Residuals" },
+            Check { key: "normalProbability", label: "Normal Probability" },
+        ],
+        "movingAverage" => {
+            vec![range(), labels(), Text { key: "interval", label: "Interval:" }, Check { key: "standardErrors", label: "Standard Errors" }]
+        }
+        "exponentialSmoothing" => {
+            vec![range(), labels(), Text { key: "damping", label: "Damping factor:" }, Check { key: "standardErrors", label: "Standard Errors" }]
+        }
+        "fTest" => {
+            let mut v = two();
+            v.extend([labels(), Text { key: "alpha", label: "Alpha:" }]);
+            v
+        }
+        _ => {
+            let mut v = two();
+            v.extend([
+                Text { key: "hypothesizedDifference", label: "Hypothesized Mean Difference:" },
+                labels(),
+                Text { key: "alpha", label: "Alpha:" },
+            ]);
+            v
+        }
+    }
+}
+
+/// The starting values of a tool's form: the selection as its input, a new sheet as output.
+pub(super) fn toolpak_defaults(sel: &str, tool: &str) -> Map<String, Json> {
+    let mut v = json!({
+        "tool": tool, "range": sel, "inputY": "", "inputX": "", "range1": sel, "range2": "", "bins": "",
+        "groupedBy": "columns", "labels": false, "summary": true, "confidence": "", "kthLargest": "", "kthSmallest": "",
+        "interval": "3", "damping": "0.3", "alpha": "0.05", "hypothesizedDifference": "0",
+        "outputTo": "newSheet", "output": "", "newSheet": "",
+    });
+    if tool == "regression" {
+        v["confidence"] = json!("95");
+        v["inputY"] = json!(sel);
+    }
+    v.as_object().cloned().unwrap_or_default()
+}
+
+/// Data › Data Analysis: pick a tool, then fill in its form. OK runs `data.analysisToolPak`
+/// (through the dialog's command); a report that would replace data asks first.
+pub(super) fn analysis_toolpak(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    use gridcraft_engine::cmd::analysis::TOOLS;
+    if d.values.get("askOverwrite").and_then(Json::as_bool) == Some(true) {
+        ui.label("The output range already holds data. Replace it with the report?");
+        ui.horizontal(|ui| {
+            if ui.button("Replace").clicked() {
+                d.values.remove("askOverwrite");
+                d.values.insert("overwrite".into(), json!(true));
+                *confirm = true;
+            }
+            if ui.button("Cancel").clicked() {
+                d.values.remove("askOverwrite");
+            }
+        });
+        return;
+    }
+    let tool = d.values.get("tool").and_then(Json::as_str).unwrap_or("").to_string();
+    let Some((_, label)) = TOOLS.iter().find(|(id, _)| *id == tool) else {
+        ui.label(egui::RichText::new("Analysis Tools").strong());
+        let pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
+        let mut chosen = false;
+        egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
+            for (id, label) in TOOLS {
+                let r = ui.selectable_label(pick == *id, *label);
+                if r.clicked() {
+                    d.values.insert("pick".into(), json!(id));
+                }
+                if r.double_clicked() {
+                    chosen = true;
+                }
+            }
+        });
+        let mut ok = false;
+        ok_cancel(ui, &mut ok, open);
+        let pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
+        if (ok || chosen) && TOOLS.iter().any(|(id, _)| *id == pick) {
+            let sel = app.session.active().map(|doc| doc.selection.current().a1()).unwrap_or_default();
+            d.values = toolpak_defaults(&sel, &pick);
+        }
+        return;
+    };
+    d.title = label.to_string();
+    d.fields = toolpak_fields(&tool);
+    form_fields(ui, d);
+    ui.separator();
+    ui.label(egui::RichText::new("Output options").strong());
+    let to = d.values.get("outputTo").and_then(Json::as_str).unwrap_or("newSheet").to_string();
+    for (key, choice, text_label) in [("output", "range", "Output Range:"), ("newSheet", "newSheet", "New Worksheet Ply:")] {
+        ui.horizontal(|ui| {
+            if ui.radio(to == choice, text_label).clicked() {
+                d.values.insert("outputTo".into(), json!(choice));
+            }
+            let mut t = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
+            if ui.add(egui::TextEdit::singleline(&mut t).desired_width(160.0)).changed() {
+                d.values.insert(key.into(), json!(t));
+                d.values.insert("outputTo".into(), json!(choice));
+            }
+        });
+    }
+    ok_cancel(ui, confirm, open);
+}
+
+/// Data › Solver: the Solver Parameters form. Solve runs `data.solver` through the dialog's
+/// command; the result opens Solver Results.
+pub(super) fn solver(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    let lang = crate::i18n::current(ui.ctx());
+    let text = |d: &Dialog, k: &str| d.values.get(k).map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())).unwrap_or_default();
+    let edit = |ui: &mut egui::Ui, d: &mut Dialog, k: &str, width: f32, label: &str| {
+        let mut t = text(d, k);
+        if ui.add(egui::TextEdit::singleline(&mut t).desired_width(width)).accessible_name(lang.tr(label)).changed() {
+            d.values.insert(k.into(), json!(t));
+        }
+    };
+    ui.horizontal(|ui| {
+        ui.label("Set Objective:");
+        edit(ui, d, "objective", 200.0, "Set Objective:");
+    });
+    let goal = text(d, "goal");
+    ui.horizontal(|ui| {
+        ui.label("To:");
+        for (g, label) in [("max", "Max"), ("min", "Min"), ("value", "Value Of:")] {
+            if ui.radio(goal == g, label).clicked() {
+                d.values.insert("goal".into(), json!(g));
+            }
+        }
+        edit(ui, d, "value", 80.0, "Value Of:");
+    });
+    ui.label("By Changing Variable Cells:");
+    edit(ui, d, "variables", 420.0, "By Changing Variable Cells:");
+    ui.label("Subject to the Constraints:");
+    let list: Vec<String> = d
+        .values
+        .get("constraints")
+        .and_then(Json::as_array)
+        .map(|a| a.iter().map(|c| c.as_str().map(str::to_string).unwrap_or_else(|| c.to_string())).collect())
+        .unwrap_or_default();
+    egui::Frame::group(ui.style()).show(ui, |ui| {
+        ui.set_min_size(vec2(420.0, 90.0));
+        egui::ScrollArea::vertical().max_height(110.0).show(ui, |ui| {
+            for (i, c) in list.iter().enumerate() {
+                if ui.selectable_label(d.list_index == i, c).clicked() {
+                    d.list_index = i;
+                }
+            }
+        });
+    });
+    ui.horizontal(|ui| {
+        edit(ui, d, "newLhs", 110.0, "Constraint Cell Reference");
+        let op = text(d, "newOp");
+        egui::ComboBox::from_id_salt("solverOp")
+            .selected_text(op.clone())
+            .width(60.0)
+            .show_ui(ui, |ui| {
+                for o in ["<=", "=", ">=", "int", "bin"] {
+                    if ui.selectable_label(op == o, o).clicked() {
+                        d.values.insert("newOp".into(), json!(o));
+                    }
+                }
+            })
+            .response
+            .accessible_name(lang.tr("Constraint Operator"));
+        if !matches!(op.as_str(), "int" | "bin") {
+            edit(ui, d, "newRhs", 110.0, "Constraint Value");
+        }
+        if ui.button("Add").clicked() {
+            let lhs = text(d, "newLhs");
+            if !lhs.trim().is_empty() {
+                let rhs = if matches!(op.as_str(), "int" | "bin") { String::new() } else { format!(" {}", text(d, "newRhs").trim()) };
+                let mut list = list.clone();
+                list.push(format!("{} {op}{rhs}", lhs.trim()));
+                d.values.insert("constraints".into(), json!(list));
+                d.values.insert("newLhs".into(), json!(""));
+                d.values.insert("newRhs".into(), json!(""));
+            }
+        }
+        if ui.add_enabled(d.list_index < list.len(), egui::Button::new("Delete")).clicked() {
+            let mut list = list.clone();
+            if d.list_index < list.len() {
+                list.remove(d.list_index);
+            }
+            d.values.insert("constraints".into(), json!(list));
+        }
+    });
+    let mut nonneg = d.values.get("nonNegative").and_then(Json::as_bool).unwrap_or(true);
+    if ui.checkbox(&mut nonneg, "Make Unconstrained Variables Non-Negative").changed() {
+        d.values.insert("nonNegative".into(), json!(nonneg));
+    }
+    let method = text(d, "method");
+    ui.horizontal(|ui| {
+        ui.label("Select a Solving Method:");
+        let label = |m: &str| match m {
+            "simplex" => "Simplex LP",
+            "evolutionary" => "Evolutionary",
+            _ => "GRG Nonlinear",
+        };
+        egui::ComboBox::from_id_salt("solverMethod")
+            .selected_text(label(&method))
+            .show_ui(ui, |ui| {
+                for m in ["grg", "simplex", "evolutionary"] {
+                    if ui.selectable_label(method == m, label(m)).clicked() {
+                        d.values.insert("method".into(), json!(m));
+                    }
+                }
+            })
+            .response
+            .accessible_name(lang.tr("Select a Solving Method:"));
+    });
+    ui.label(
+        egui::RichText::new(match method.as_str() {
+            "simplex" => "Simplex LP: for linear models; integer and binary constraints by branch and bound.",
+            "evolutionary" => "Evolutionary: a genetic search for models that aren't smooth; every variable cell needs bounds.",
+            _ => "GRG Nonlinear: a local optimum of a smooth model, from the current values.",
+        })
+        .small(),
+    );
+    ui.add_space(8.0);
+    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+        let t = crate::theme::Tokens::get(ui.ctx());
+        let solve = ui.add(egui::Button::new(egui::RichText::new("  Solve  ").color(t.on_accent)).fill(t.accent));
+        if solve.clicked() && !text(d, "objective").trim().is_empty() {
+            *confirm = true;
+        }
+        if ui.button(" Close ").clicked() {
+            *open = false;
+        }
+    });
+}
+
+/// Solver Results: the outcome, and keeping or restoring the variable cells.
+pub(super) fn solver_results(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, open: &mut bool) {
+    let message = d.values.get("message").and_then(Json::as_str).unwrap_or("").to_string();
+    ui.label(message);
+    let changed = d.values.get("changed").and_then(Json::as_bool).unwrap_or(false);
+    let restore = d.values.get("restore").and_then(Json::as_bool).unwrap_or(false);
+    if changed {
+        ui.add_space(4.0);
+        if ui.radio(!restore, "Keep Solver Solution").clicked() {
+            d.values.insert("restore".into(), json!(false));
+        }
+        if ui.radio(restore, "Restore Original Values").clicked() {
+            d.values.insert("restore".into(), json!(true));
+        }
+    }
+    // Reports describe the solution whether it is kept or not.
+    let solved = d.values.get("values").and_then(Json::as_object).is_some_and(|v| !v.is_empty());
+    if solved {
+        ui.add_space(4.0);
+        ui.label("Reports:");
+        for (key, label) in [("answerReport", "Answer"), ("limitsReport", "Limits")] {
+            let mut on = d.values.get(key).and_then(Json::as_bool).unwrap_or(false);
+            if ui.checkbox(&mut on, label).changed() {
+                d.values.insert(key.into(), json!(on));
+            }
+        }
+    }
+    let mut confirm = false;
+    ok_cancel(ui, &mut confirm, open);
+    if confirm {
+        // The solution (and the saved model) is one undo step.
+        if changed && restore {
+            app.run_or_alert("edit.undo", json!({}));
+        }
+        let reports: Vec<&str> = [("answerReport", "answer"), ("limitsReport", "limits")]
+            .into_iter()
+            .filter(|(key, _)| d.values.get(*key).and_then(Json::as_bool) == Some(true))
+            .map(|(_, kind)| kind)
+            .collect();
+        if solved && !reports.is_empty() {
+            let field = |k: &str| d.values.get(k).cloned().unwrap_or(Json::Null);
+            let params = json!({"reports": reports, "model": field("model"), "values": field("values"), "original": field("original"), "message": field("message")});
+            app.run_or_alert("data.solverReport", params);
+        }
+        *open = false;
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/charts.rs b/crates/ui-egui/src/dialogs/charts.rs
new file mode 100644
index 000000000..bd7da3d66
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/charts.rs
@@ -0,0 +1,187 @@
+use super::show::ok_cancel;
+use super::*;
+
+/// Every chart type the All Charts tab offers: `(type, subtype, label)` for `insert.chart`.
+const ALL_CHARTS: [(&str, &str, &str); 21] = [
+    ("column", "", "Clustered Column"),
+    ("column", "stacked", "Stacked Column"),
+    ("column", "stacked100", "100% Stacked Column"),
+    ("bar", "", "Clustered Bar"),
+    ("bar", "stacked", "Stacked Bar"),
+    ("bar", "stacked100", "100% Stacked Bar"),
+    ("line", "", "Line"),
+    ("line", "markers", "Line with Markers"),
+    ("line", "stacked", "Stacked Line"),
+    ("pie", "", "Pie"),
+    ("doughnut", "", "Doughnut"),
+    ("area", "", "Area"),
+    ("area", "stacked", "Stacked Area"),
+    ("area", "stacked100", "100% Stacked Area"),
+    ("scatter", "", "Scatter"),
+    ("scatter", "lines", "Scatter with Lines"),
+    ("radar", "", "Radar"),
+    ("histogram", "", "Histogram"),
+    ("waterfall", "", "Waterfall"),
+    ("funnel", "", "Funnel"),
+    ("combo", "", "Combo"),
+];
+
+/// The chart types listed on the dialog's current tab.
+fn chart_choices(d: &Dialog) -> Vec<(String, String, String)> {
+    if d.tab == "All Charts" {
+        return ALL_CHARTS.iter().map(|(t, s, l)| (t.to_string(), s.to_string(), l.to_string())).collect();
+    }
+    let field = |x: &Json, k: &str| x.get(k).and_then(Json::as_str).unwrap_or("").to_string();
+    d.result
+        .as_ref()
+        .and_then(Json::as_array)
+        .map(|a| a.iter().map(|x| (field(x, "type"), field(x, "subtype"), field(x, "label"))).collect())
+        .unwrap_or_default()
+}
+
+/// Selects entry `i` of the current tab: OK inserts it.
+pub(super) fn select_chart(d: &mut Dialog, i: usize) {
+    let Some((t, sub, _)) = chart_choices(d).into_iter().nth(i) else { return };
+    d.list_index = i;
+    d.values.insert("type".into(), json!(t));
+    d.values.insert("subtype".into(), json!(sub));
+}
+
+fn chart_icon(t: &str) -> Icon {
+    match t {
+        "column" | "bar" | "histogram" | "waterfall" | "funnel" | "combo" => Icon::ChartBar,
+        "line" | "area" | "radar" => Icon::ChartLine,
+        "pie" | "doughnut" => Icon::ChartPie,
+        "scatter" | "bubble" => Icon::ChartScatter,
+        _ => Icon::Chart,
+    }
+}
+
+pub(super) fn recommended_charts(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    ui.horizontal(|ui| {
+        for tab in ["Recommended Charts", "All Charts"] {
+            if ui.selectable_label(d.tab == tab, tab).clicked() && d.tab != tab {
+                d.tab = tab.to_string();
+                select_chart(d, 0);
+            }
+        }
+    });
+    ui.separator();
+    let choices = chart_choices(d);
+    let t = crate::theme::Tokens::get(ui.ctx());
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(190.0);
+            egui::ScrollArea::vertical().id_salt("chart_choices").max_height(300.0).show(ui, |ui| {
+                for (i, (kind, _, label)) in choices.iter().enumerate() {
+                    let resp = ui
+                        .horizontal(|ui| {
+                            let (r, _) = ui.allocate_exact_size(vec2(22.0, 22.0), Sense::hover());
+                            icons::paint(ui.painter(), r.shrink(2.0), chart_icon(kind), t.text);
+                            ui.selectable_label(i == d.list_index, label.as_str())
+                        })
+                        .inner;
+                    if resp.clicked() {
+                        select_chart(d, i);
+                    }
+                    if resp.double_clicked() {
+                        select_chart(d, i);
+                        *confirm = true;
+                    }
+                }
+            });
+        });
+        ui.add_space(12.0);
+        ui.vertical(|ui| {
+            let label = choices.get(d.list_index).map(|c| c.2.clone()).unwrap_or_default();
+            ui.strong(label);
+            let (rect, _) = ui.allocate_exact_size(vec2(360.0, 216.0), Sense::hover());
+            ui.painter().rect_filled(rect, 2.0, Color32::WHITE);
+            ui.painter().rect_stroke(rect, 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
+            let params = json!({"type": d.values.get("type").cloned().unwrap_or(Json::Null), "subtype": d.values.get("subtype").cloned().unwrap_or(Json::Null)});
+            if let Some(doc) = app.session.active()
+                && let Ok((sheet, chart)) = gridcraft_engine::cmd::insert::build_chart(&app.session, &params)
+            {
+                crate::chartview::paint_chart(ui.painter(), rect, &doc.wb, sheet, &chart);
+            }
+        });
+    });
+    ok_cancel(ui, confirm, open);
+    if *confirm {
+        *confirm = false;
+        let params =
+            json!({"type": d.values.get("type").cloned().unwrap_or(Json::Null), "subtype": d.values.get("subtype").cloned().unwrap_or(Json::Null)});
+        match app.run("insert.chart", params) {
+            Ok(r) => {
+                // The new chart is selected, as after inserting any object.
+                app.selected_chart = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok());
+                *open = false;
+            }
+            Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))),
+        }
+    }
+}
+
+/// Draws chart range, series keep/remove and category-range controls and runs `chart.selectData` when something changed.
+pub(super) fn select_data(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    let text = |d: &Dialog, k: &str| d.values.get(k).and_then(Json::as_str).unwrap_or("").to_string();
+    let edit = |ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str| {
+        let label = ui.label(label);
+        let mut v = text(d, key);
+        if ui.add(egui::TextEdit::singleline(&mut v).desired_width(420.0)).labelled_by(label.id).changed() {
+            d.values.insert(key.into(), json!(v));
+        }
+    };
+    edit(ui, d, "range", "Chart data range:");
+    ui.add_space(6.0);
+    ui.strong("Legend Entries (Series)");
+    let names: Vec<String> =
+        d.values.get("names").and_then(Json::as_array).map(|a| a.iter().map(|n| n.as_str().unwrap_or("").to_string()).collect()).unwrap_or_default();
+    let mut remove: Vec<u64> =
+        d.values.get("remove").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
+    let kept = names.len().saturating_sub(remove.len());
+    egui::ScrollArea::vertical().id_salt("series").max_height(160.0).show(ui, |ui| {
+        for (i, name) in names.iter().enumerate() {
+            let i = i as u64;
+            let removed = remove.contains(&i);
+            ui.horizontal(|ui| {
+                let label = if name.is_empty() { format!("Series{}", i + 1) } else { name.clone() };
+                ui.label(if removed { egui::RichText::new(label).strikethrough().weak() } else { egui::RichText::new(label) });
+                if removed {
+                    if ui.small_button("Keep").clicked() {
+                        remove.retain(|x| *x != i);
+                    }
+                } else if ui.add_enabled(kept > 1, egui::Button::new("Remove").small()).clicked() {
+                    remove.push(i);
+                }
+            });
+        }
+    });
+    d.values.insert("remove".into(), json!(remove));
+    ui.add_space(6.0);
+    edit(ui, d, "categories", "Horizontal (Category) Axis Labels:");
+    ok_cancel(ui, confirm, open);
+    if *confirm {
+        *confirm = false;
+        let mut params = serde_json::Map::new();
+        params.insert("chart".into(), d.values.get("chart").cloned().unwrap_or(Json::Null));
+        let range_changed = text(d, "range") != text(d, "range0");
+        if range_changed {
+            params.insert("range".into(), json!(text(d, "range")));
+        } else if !remove.is_empty() {
+            // A new range rebuilds the series; removals only apply to the current ones.
+            params.insert("removeSeries".into(), json!(remove));
+        }
+        if text(d, "categories") != text(d, "categories0") || (range_changed && !text(d, "categories").is_empty()) {
+            params.insert("categories".into(), json!(text(d, "categories")));
+        }
+        if params.len() == 1 {
+            *open = false;
+            return;
+        }
+        match app.run("chart.selectData", Json::Object(params)) {
+            Ok(_) => *open = false,
+            Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))),
+        }
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/command_search.rs b/crates/ui-egui/src/dialogs/command_search.rs
new file mode 100644
index 000000000..509ca4700
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/command_search.rs
@@ -0,0 +1,88 @@
+use super::*;
+
+pub(super) fn command_search(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
+    let (down, up, home, end, pgup, pgdn) = ui.input_mut(|i| {
+        (
+            i.consume_key(egui::Modifiers::NONE, Key::ArrowDown),
+            i.consume_key(egui::Modifiers::NONE, Key::ArrowUp),
+            i.consume_key(egui::Modifiers::CTRL, Key::Home),
+            i.consume_key(egui::Modifiers::CTRL, Key::End),
+            i.consume_key(egui::Modifiers::NONE, Key::PageUp),
+            i.consume_key(egui::Modifiers::NONE, Key::PageDown),
+        )
+    });
+    let width = ui.available_width();
+    let r = ui.add(egui::TextEdit::singleline(&mut d.search).desired_width(width).hint_text("Type a command, e.g. freeze, chart, bold…"));
+
+    if !d.focus_initialized {
+        r.request_focus();
+        d.focus_initialized = true;
+    }
+
+    let q = d.search.to_ascii_lowercase();
+    let cmds: Vec<(String, String, String)> = app
+        .session
+        .commands()
+        .into_iter()
+        .filter(|c| c.enabled)
+        .filter(|c| q.is_empty() || c.label.to_ascii_lowercase().contains(&q) || c.id.to_ascii_lowercase().contains(&q))
+        .map(|c| (c.id.to_string(), c.label.to_string(), c.menu.join(" › ")))
+        .take(40)
+        .collect();
+
+    let last = cmds.len().saturating_sub(1);
+
+    let row_h = ui.spacing().interact_size.y.max(20.0);
+    let row_step = row_h + ui.spacing().item_spacing.y;
+
+    const LIST_HEIGHT: f32 = 320.0;
+
+    let page_size = ((LIST_HEIGHT / row_step).floor() as usize).saturating_sub(1).max(1);
+
+    if down {
+        d.list_index = (d.list_index + 1).min(last);
+    }
+    if up {
+        d.list_index = d.list_index.saturating_sub(1);
+    }
+    if pgdn {
+        d.list_index = (d.list_index + page_size).min(last);
+    }
+    if pgup {
+        d.list_index = d.list_index.saturating_sub(page_size);
+    }
+    if home {
+        d.list_index = 0;
+    }
+    if end {
+        d.list_index = last;
+    }
+
+    d.list_index = d.list_index.min(last);
+
+    egui::ScrollArea::vertical().max_height(LIST_HEIGHT).auto_shrink([true, false]).show(ui, |ui| {
+        let scroll_area_width = ui.available_width();
+        for (i, (id, label, menu)) in cmds.iter().enumerate() {
+            let r = ui.add(egui::Button::selectable(i == d.list_index, format!("{label}    {menu}")).min_size(vec2(scroll_area_width, 20.0)));
+
+            if (down || up || home || end || pgup || pgdn) && i == d.list_index && !ui.clip_rect().contains_rect(r.rect) {
+                r.scroll_to_me(Some(if down || end || pgdn { egui::Align::Max } else { egui::Align::Min }));
+            }
+
+            if r.clicked() {
+                d.list_index = i;
+                *confirm = true;
+            }
+
+            r.on_hover_text(id);
+        }
+    });
+    if ui.input(|i| i.key_pressed(Key::Enter)) {
+        *confirm = true;
+    }
+    if *confirm && let Some((id, ..)) = cmds.get(d.list_index) {
+        let id = id.clone();
+        app.dialog = None;
+        app.run_or_alert(&id, json!({}));
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/cond_format_rules.rs b/crates/ui-egui/src/dialogs/cond_format_rules.rs
new file mode 100644
index 000000000..216f79e31
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/cond_format_rules.rs
@@ -0,0 +1,28 @@
+use super::*;
+
+pub(super) fn manage_rules(app: &mut SheetApp, ui: &mut egui::Ui) {
+    let list = app.session.run("home.manageRules", json!({})).unwrap_or(Json::Null);
+    let rules = list["rules"].as_array().cloned().unwrap_or_default();
+    if rules.is_empty() {
+        ui.label("There are no conditional formatting rules on this sheet.");
+    }
+    for (i, r) in rules.iter().enumerate() {
+        ui.horizontal(|ui| {
+            let kind = r["rule"].as_object().and_then(|o| o.keys().next().cloned()).unwrap_or_default();
+            ui.label(format!(
+                "{}. {kind}  applies to {}",
+                i + 1,
+                r["ranges"].as_array().map(|a| a.iter().filter_map(|x| x.as_str()).collect::<Vec<_>>().join(",")).unwrap_or_default()
+            ));
+            if ui.small_button("▲").clicked() {
+                app.run_or_alert("home.manageRules", json!({"moveUp": i}));
+            }
+            if ui.small_button("▼").clicked() {
+                app.run_or_alert("home.manageRules", json!({"moveDown": i}));
+            }
+            if ui.small_button("Delete").clicked() {
+                app.run_or_alert("home.manageRules", json!({"delete": i}));
+            }
+        });
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/data.rs b/crates/ui-egui/src/dialogs/data.rs
new file mode 100644
index 000000000..615c64ab9
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/data.rs
@@ -0,0 +1,327 @@
+#[cfg(test)]
+use super::show::build_params;
+use super::show::{form_fields, ok_cancel};
+use super::*;
+
+/// Initial values of the Data Validation form: the rule stored on the active cell, so OK without
+/// edits keeps it; a plain list rule when the cell has none.
+pub(super) fn validation_defaults(app: &SheetApp) -> Json {
+    let mut v = json!({"type": "list", "operator": "between", "ignoreBlank": true, "dropdown": true, "errorStyle": "stop"});
+    let Some(doc) = app.session.active() else { return v };
+    let Some(dv) = doc.wb.active().and_then(|s| s.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(doc.selection.active)))) else {
+        return v;
+    };
+    // The enums serialize as their variant names; the command takes them in camelCase.
+    let camel = |x: Json| {
+        let name = x.as_str().unwrap_or_default();
+        let mut chars = name.chars();
+        chars.next().map(|c| c.to_lowercase().chain(chars).collect::<String>()).unwrap_or_default()
+    };
+    v["type"] = json!(camel(json!(dv.kind)));
+    v["operator"] = json!(camel(json!(dv.op)));
+    v["errorStyle"] = json!(camel(json!(dv.error_style)));
+    v["formula1"] = json!(dv.f1);
+    if let Some(f2) = &dv.f2 {
+        v["formula2"] = json!(f2);
+    }
+    v["ignoreBlank"] = json!(dv.allow_blank);
+    v["dropdown"] = json!(dv.in_cell_dropdown);
+    v["inputTitle"] = json!(dv.input_title);
+    v["inputMessage"] = json!(dv.input_message);
+    v["errorTitle"] = json!(dv.error_title);
+    v["errorMessage"] = json!(dv.error_message);
+    v
+}
+
+/// The range Remove Duplicates starts with. A block selection is used as given; with only the
+/// cursor placed, the table's data rows or the current region, as the command picks when it gets
+/// no range (a single-cell range would remove nothing).
+pub(super) fn remove_duplicates_range(app: &SheetApp, sel: &str) -> String {
+    let Some(d) = app.session.active() else { return sel.to_string() };
+    let Some(sh) = d.wb.active() else { return sel.to_string() };
+    if !d.selection.current().is_single() {
+        return sel.to_string();
+    }
+    let range = match sh.table_at(d.selection.active) {
+        Some(t) => t.data_range().map(|dr| gridcraft_engine::core::RangeRef::new(t.range.start, dr.end)).unwrap_or(t.range),
+        None => gridcraft_engine::selection::current_region(sh, d.selection.active),
+    };
+    range.a1()
+}
+
+pub(super) fn abs(r: &gridcraft_engine::core::RangeRef) -> String {
+    let a = |c: gridcraft_engine::core::CellRef| format!("${}${}", gridcraft_engine::core::col_to_letters(c.col), c.row + 1);
+    if r.is_single() { a(r.start) } else { format!("{}:{}", a(r.start), a(r.end)) }
+}
+
+/// The criterion controls in Excel's Settings tab depend on both Allow and Data.
+/// `formula1` is the sole source for a list or custom rule; `formula2` is a
+/// second bound only for Between and Not between.
+pub(super) fn data_validation_fields(kind: &str, operator: &str) -> Vec<Field> {
+    use Field::*;
+    let mut fields = vec![Choice {
+        key: "type",
+        label: "Allow",
+        options: vec![
+            ("any", "Any value"),
+            ("whole", "Whole number"),
+            ("decimal", "Decimal"),
+            ("list", "List"),
+            ("date", "Date"),
+            ("time", "Time"),
+            ("textLength", "Text length"),
+            ("custom", "Custom"),
+        ],
+    }];
+    let two_bounds = matches!(operator, "between" | "notBetween");
+    match kind {
+        "list" => {
+            fields.push(Text { key: "formula1", label: "Source:" });
+            fields.push(Check { key: "ignoreBlank", label: "Ignore blank" });
+            fields.push(Check { key: "dropdown", label: "In-cell dropdown" });
+        }
+        "custom" => {
+            fields.push(Text { key: "formula1", label: "Formula:" });
+            fields.push(Check { key: "ignoreBlank", label: "Ignore blank" });
+        }
+        "whole" | "decimal" | "date" | "time" | "textLength" => {
+            fields.push(Choice {
+                key: "operator",
+                label: "Data",
+                options: vec![
+                    ("between", "between"),
+                    ("notBetween", "not between"),
+                    ("equal", "equal to"),
+                    ("notEqual", "not equal to"),
+                    ("greater", "greater than"),
+                    ("less", "less than"),
+                    ("greaterOrEqual", "greater than or equal to"),
+                    ("lessOrEqual", "less than or equal to"),
+                ],
+            });
+            let lower = matches!(operator, "greater" | "greaterOrEqual");
+            let (first, second) = match kind {
+                "date" => (
+                    if two_bounds || lower {
+                        "Start date:"
+                    } else if matches!(operator, "less" | "lessOrEqual") {
+                        "End date:"
+                    } else {
+                        "Date:"
+                    },
+                    "End date:",
+                ),
+                "time" => (
+                    if two_bounds || lower {
+                        "Start time:"
+                    } else if matches!(operator, "less" | "lessOrEqual") {
+                        "End time:"
+                    } else {
+                        "Time:"
+                    },
+                    "End time:",
+                ),
+                _ => (
+                    if two_bounds || lower {
+                        "Minimum:"
+                    } else if matches!(operator, "less" | "lessOrEqual") {
+                        "Maximum:"
+                    } else {
+                        "Value:"
+                    },
+                    "Maximum:",
+                ),
+            };
+            fields.push(Text { key: "formula1", label: first });
+            if two_bounds {
+                fields.push(Text { key: "formula2", label: second });
+            }
+            fields.push(Check { key: "ignoreBlank", label: "Ignore blank" });
+        }
+        _ => {}
+    }
+    fields.push(Text { key: "inputMessage", label: "Input message:" });
+    fields.push(Choice {
+        key: "errorStyle",
+        label: "Error style",
+        options: vec![("stop", "Stop"), ("warning", "Warning"), ("information", "Information")],
+    });
+    fields.push(Text { key: "errorMessage", label: "Error message:" });
+    fields
+}
+
+pub(super) fn data_validation_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    let kind = d.values.get("type").and_then(Json::as_str).unwrap_or("any");
+    let operator = d.values.get("operator").and_then(Json::as_str).unwrap_or("between");
+    d.fields = data_validation_fields(kind, operator);
+    form_fields(ui, d);
+    ok_cancel(ui, confirm, open);
+}
+
+pub(super) fn advanced_filter_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    use Field::*;
+    let copy = d.values.get("action").and_then(Json::as_str) == Some("copy");
+    d.fields = vec![
+        Choice {
+            key: "action",
+            label: "Action",
+            options: vec![("inPlace", "Show matching rows in place"), ("copy", "Copy matching rows elsewhere")],
+        },
+        Text { key: "range", label: "List range:" },
+        Text { key: "criteria", label: "Criteria range (optional):" },
+    ];
+    if copy {
+        d.fields.push(Text { key: "copyTo", label: "Copy to:" });
+    }
+    d.fields.push(Check { key: "unique", label: "Unique rows only" });
+    form_fields(ui, d);
+    // Constrain the button row: the shared right-to-left layout otherwise
+    // consumes the window's remaining height instead of fitting the buttons.
+    ui.allocate_ui(vec2(ui.available_width(), ui.spacing().interact_size.y + 8.0), |ui| ok_cancel(ui, confirm, open));
+}
+
+/// Draws the sort-level editor: header toggle, column/by/order controls, add/remove level, and `data.sort` on confirmation.
+pub(super) fn sort(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
+    let lang = app.ui.language;
+    let mut header = d.values.get("header").and_then(Json::as_bool).unwrap_or(true);
+    ui.checkbox(&mut header, "My list has headers");
+    d.values.insert("header".into(), json!(header));
+    let mut levels: Vec<Json> = d.values.get("levels").and_then(Json::as_array).cloned().unwrap_or_default();
+    // Columns of the region around the active cell, labelled with their header (or first value).
+    let columns: Vec<(String, String)> = app
+        .session
+        .active()
+        .and_then(|d| {
+            let sh = d.wb.active()?;
+            let region = gridcraft_engine::selection::current_region(sh, d.selection.active);
+            Some(
+                (region.start.col..=region.end.col)
+                    .map(|c| {
+                        let letter = gridcraft_engine::core::col_to_letters(c);
+                        // The region starts at the header row when one is present, so the
+                        // label always comes from start.row: header text with headers on,
+                        // first data value with them off.
+                        let label_row = region.start.row;
+                        let text = gridcraft_engine::display::cell_text(&d.wb, sh, gridcraft_engine::core::CellRef::new(label_row, c));
+                        let text: String = text.chars().take(24).collect();
+                        (letter.clone(), if text.is_empty() { letter } else { format!("{letter}: {text}") })
+                    })
+                    .collect(),
+            )
+        })
+        .unwrap_or_default();
+    let mut remove = None;
+    for (i, lv) in levels.iter_mut().enumerate() {
+        ui.horizontal(|ui| {
+            let label = ui.label(lang.tr(if i == 0 { "Sort by" } else { "Then by" }));
+            let mut col = lv["column"].as_str().unwrap_or("A").to_string();
+            if columns.is_empty() {
+                ui.add(egui::TextEdit::singleline(&mut col).desired_width(50.0)).labelled_by(label.id);
+            } else {
+                egui::ComboBox::from_id_salt(("sort_col", i))
+                    .selected_text(col.clone())
+                    .show_ui(ui, |ui| {
+                        for (letter, label) in &columns {
+                            ui.selectable_value(&mut col, letter.clone(), label.as_str());
+                        }
+                    })
+                    .response
+                    .labelled_by(label.id);
+            }
+            lv["column"] = json!(col.to_ascii_uppercase());
+            let mut by = lv["by"].as_str().unwrap_or("values").to_string();
+            egui::ComboBox::from_id_salt(("by", i))
+                .selected_text(match by.as_str() {
+                    "cellColor" => "Cell Color",
+                    "fontColor" => "Font Color",
+                    _ => "Cell Values",
+                })
+                .show_ui(ui, |ui| {
+                    ui.selectable_value(&mut by, "values".into(), "Cell Values");
+                    ui.selectable_value(&mut by, "cellColor".into(), "Cell Color");
+                    ui.selectable_value(&mut by, "fontColor".into(), "Font Color");
+                })
+                .response
+                .accessible_name(lang.tr("Sort On"));
+            lv["by"] = json!(by);
+            let mut desc = lv["order"].as_str() == Some("desc");
+            ui.radio_value(&mut desc, false, "A to Z");
+            ui.radio_value(&mut desc, true, "Z to A");
+            lv["order"] = json!(if desc { "desc" } else { "asc" });
+            if crate::widgets::icon_button(ui, Icon::Close, crate::theme::Tokens::get(ui.ctx()).text_dim, "Remove level", vec2(18.0, 18.0)).clicked()
+            {
+                remove = Some(i);
+            }
+        });
+    }
+    if let Some(i) = remove
+        && levels.len() > 1
+    {
+        levels.remove(i);
+    }
+    if ui.button("+ Add Level").clicked() {
+        let used: Vec<String> = levels.iter().filter_map(|l| l.get("column").and_then(Json::as_str).map(str::to_string)).collect();
+        let next = columns
+            .iter()
+            .map(|(l, _)| l)
+            .find(|l| !used.contains(l))
+            .cloned()
+            .or_else(|| columns.last().map(|(l, _)| l.clone()))
+            .unwrap_or_else(|| "B".into());
+        levels.push(json!({"column": next, "order": "asc"}));
+    }
+    d.values.insert("levels".into(), Json::Array(levels.clone()));
+    let mut open = true;
+    ok_cancel(ui, confirm, &mut open);
+    if *confirm {
+        app.run_or_alert("data.sort", json!({"header": header, "keys": levels}));
+    }
+    if !open {
+        *confirm = true;
+    }
+}
+
+#[cfg(test)]
+mod data_validation_tests {
+    use super::*;
+
+    #[test]
+    fn list_uses_one_source_and_does_not_submit_a_second_list() {
+        let fields = data_validation_fields("list", "between");
+        assert!(fields.iter().any(|f| matches!(f, Field::Text { key: "formula1", label: "Source:" })));
+        assert!(!fields.iter().any(|f| matches!(f, Field::Text { key: "formula2", .. } | Field::Choice { key: "operator", .. })));
+
+        let dialog = Dialog::form(
+            "dataValidation",
+            "Data Validation",
+            "data.validation",
+            fields,
+            json!({"type": "list", "operator": "between", "formula1": "ABC,DEF", "formula2": "GHI,JKL", "dropdown": true}),
+        );
+        let params = build_params(&dialog);
+        assert_eq!(params["formula1"], "ABC,DEF");
+        assert!(params.get("formula2").is_none());
+        assert!(params.get("operator").is_none());
+    }
+
+    #[test]
+    fn only_between_operators_show_and_submit_two_bounds() {
+        let two = data_validation_fields("whole", "between");
+        assert!(two.iter().any(|f| matches!(f, Field::Text { key: "formula2", label: "Maximum:" })));
+        let one = data_validation_fields("date", "lessOrEqual");
+        assert!(one.iter().any(|f| matches!(f, Field::Text { key: "formula1", label: "End date:" })));
+        assert!(!one.iter().any(|f| matches!(f, Field::Text { key: "formula2", .. })));
+
+        let dialog = Dialog::form(
+            "dataValidation",
+            "Data Validation",
+            "data.validation",
+            one,
+            json!({"type": "date", "operator": "lessOrEqual", "formula1": "2026-10-12", "formula2": "2030-01-01"}),
+        );
+        let params = build_params(&dialog);
+        assert_eq!(params["operator"], "lessOrEqual");
+        assert_eq!(params["formula1"], "2026-10-12");
+        assert!(params.get("formula2").is_none());
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/find.rs b/crates/ui-egui/src/dialogs/find.rs
new file mode 100644
index 000000000..27bd3687e
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/find.rs
@@ -0,0 +1,151 @@
+use super::show::ok_cancel;
+use super::*;
+
+/// Draws the Find/Replace form with case, whole-cell and workbook options, requests field focus once, and runs find/replace with the current parameters.
+pub(super) fn find(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) {
+    ui.horizontal(|ui| {
+        for tab in ["Find", "Replace"] {
+            if ui.selectable_label(d.tab == tab, tab).clicked() {
+                d.tab = tab.into();
+            }
+        }
+    });
+    let mut what = d.values.get("what").and_then(Json::as_str).unwrap_or("").to_string();
+    let mut with = d.values.get("with").and_then(Json::as_str).unwrap_or("").to_string();
+    ui.horizontal(|ui| {
+        let label = ui.label("Find what:");
+        let r = ui.add(egui::TextEdit::singleline(&mut what).desired_width(260.0)).labelled_by(label.id);
+        // Like Excel, the cursor starts in "Find what" - asked for once, so clicking another field still works.
+        if !d.values.contains_key("focused") {
+            r.request_focus();
+            d.values.insert("focused".into(), json!(true));
+        }
+    });
+    if d.tab == "Replace" {
+        ui.horizontal(|ui| {
+            let label = ui.label("Replace with:");
+            ui.add(egui::TextEdit::singleline(&mut with).desired_width(244.0)).labelled_by(label.id);
+        });
+    }
+    let mut case = d.values.get("matchCase").and_then(Json::as_bool).unwrap_or(false);
+    let mut whole = d.values.get("wholeCell").and_then(Json::as_bool).unwrap_or(false);
+    let mut wb = d.values.get("within").and_then(Json::as_str) == Some("workbook");
+    ui.horizontal(|ui| {
+        ui.checkbox(&mut case, "Match case");
+        ui.checkbox(&mut whole, "Match entire cell contents");
+        ui.checkbox(&mut wb, "Within workbook");
+    });
+    d.values.insert("what".into(), json!(what));
+    d.values.insert("with".into(), json!(with));
+    d.values.insert("matchCase".into(), json!(case));
+    d.values.insert("wholeCell".into(), json!(whole));
+    d.values.insert("within".into(), json!(if wb { "workbook" } else { "sheet" }));
+    let base = json!({"what": what, "matchCase": case, "wholeCell": whole, "within": if wb { "workbook" } else { "sheet" }});
+    ui.horizontal(|ui| {
+        if d.tab == "Replace" {
+            if ui.button("Replace All").clicked() {
+                let mut p = base.clone();
+                p["with"] = json!(with);
+                p["all"] = json!(true);
+                match app.run("edit.replace", p) {
+                    Ok(r) => app.toast = Some((format!("All done. We made {} replacements.", r["replaced"]), crate::now_ms())),
+                    Err(e) => app.message = Some(("Find and Replace".into(), crate::clean_error(&e))),
+                }
+            }
+            if ui.button("Replace").clicked() {
+                let mut p = base.clone();
+                p["with"] = json!(with);
+                p["all"] = json!(false);
+                let _ = app.run("edit.replace", p);
+                let _ = app.run("edit.find", base.clone());
+            }
+        }
+        if ui.button("Find All").clicked() {
+            let mut p = base.clone();
+            p["all"] = json!(true);
+            d.result = app.run("edit.find", p).ok();
+        }
+        if ui.button("Find Next").clicked() || ui.input(|i| i.key_pressed(Key::Enter)) {
+            if let Err(e) = app.run("edit.find", base.clone()) {
+                app.message = Some(("Find and Replace".into(), crate::clean_error(&e)));
+            }
+            app.grid.ensure_visible = true;
+        }
+    });
+    if let Some(r) = &d.result
+        && let Some(list) = r["results"].as_array()
+    {
+        ui.separator();
+        ui.label(format!("{} cell(s) found", list.len()));
+        egui::ScrollArea::vertical().max_height(180.0).show(ui, |ui| {
+            for item in list {
+                let label = format!(
+                    "{}  {}  {}",
+                    item["sheet"].as_str().unwrap_or(""),
+                    item["cell"].as_str().unwrap_or(""),
+                    item["value"].as_str().unwrap_or("")
+                );
+                if ui.selectable_label(false, label).clicked() {
+                    if let Some(s) = item["sheet"].as_str() {
+                        let _ = app.run("sheet.activate", json!({"sheet": s}));
+                    }
+                    let _ = app.run("selection.set", json!({"cell": item["cell"]}));
+                    app.grid.ensure_visible = true;
+                }
+            }
+        });
+    }
+}
+
+/// What the Go To dialog lists: the named ranges of every sheet, then the references gone to
+/// before, newest first.
+pub(super) fn go_to_entries(app: &SheetApp) -> Vec<String> {
+    app.session
+        .active()
+        .map(|doc| {
+            let mut v = gridcraft_engine::cmd::edit::go_to_names(&doc.wb, doc.wb.active_sheet());
+            v.extend(doc.go_to_recent.iter().cloned());
+            v
+        })
+        .unwrap_or_default()
+}
+
+/// Draws a virtualized name/reference list and editable reference field, links to Go To Special, and confirms with `edit.goTo`.
+pub(super) fn go_to(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
+    let lang = app.ui.language;
+    let entries: Vec<String> =
+        d.result.as_ref().and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_str).map(str::to_owned).collect()).unwrap_or_default();
+    let current = d.values.get("reference").and_then(Json::as_str).unwrap_or("").to_string();
+    // A workbook can hold thousands of names: only the rows in view are laid out.
+    let row_height = ui.text_style_height(&egui::TextStyle::Button) + 2.0 * ui.spacing().button_padding.y;
+    egui::ScrollArea::vertical().max_height(160.0).auto_shrink([false, true]).show_rows(ui, row_height, entries.len(), |ui, rows| {
+        for n in entries.get(rows).unwrap_or_default() {
+            let resp = ui.selectable_label(current == *n, n);
+            if resp.clicked() || resp.double_clicked() {
+                d.values.insert("reference".into(), json!(n));
+            }
+            if resp.double_clicked() {
+                *confirm = true;
+            }
+        }
+    });
+    let mut r = d.values.get("reference").and_then(Json::as_str).unwrap_or("").to_string();
+    ui.horizontal(|ui| {
+        let label = ui.label(lang.tr("Reference:"));
+        ui.text_edit_singleline(&mut r).labelled_by(label.id).request_focus();
+    });
+    d.values.insert("reference".into(), json!(r.clone()));
+    if ui.button("Special…").clicked() {
+        app.open_dialog("goToSpecial", json!({}));
+        return;
+    }
+    let mut open = true;
+    ok_cancel(ui, confirm, &mut open);
+    if *confirm {
+        app.run_or_alert("edit.goTo", json!({"reference": r, "record": true}));
+        app.grid.ensure_visible = true;
+    }
+    if !open {
+        *confirm = true;
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/format_cells.rs b/crates/ui-egui/src/dialogs/format_cells.rs
new file mode 100644
index 000000000..f28c1de1b
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/format_cells.rs
@@ -0,0 +1,227 @@
+use super::show::ok_cancel;
+use super::*;
+
+/// Draws the six-tab Format Cells editor (number, alignment, font, border, fill, protection); the Number tab shows a sample preview, and the style draft updates.
+pub(super) fn format_cells(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
+    // `d.tab` stays the English name (it is what `open_dialog` and tests pass); only the drawn
+    // labels are translated. The Fill tab is keyed by context: the Alignment tab's "Fill" is a
+    // different word in some languages.
+    let lang = app.ui.language;
+    ui.horizontal(|ui| {
+        for (tab, key) in [
+            ("Number", "Number"),
+            ("Alignment", "Alignment"),
+            ("Font", "Font"),
+            ("Border", "Border"),
+            ("Fill", "Format Cells|Fill"),
+            ("Protection", "Protection"),
+        ] {
+            if ui.selectable_label(d.tab == tab, lang.tr(key)).clicked() {
+                d.tab = tab.to_string();
+            }
+        }
+    });
+    ui.separator();
+    let mut st: gridcraft_engine::model::Style = d.values.get("style").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or_default();
+    let sample = app.session.active().and_then(|doc| doc.wb.active().map(|s| s.value(doc.selection.active))).unwrap_or_default();
+    match d.tab.as_str() {
+        "Number" => {
+            let mut code = st.num_fmt.as_str().to_string();
+            ui.columns(2, |cols| {
+                cols[0].label(egui::RichText::new(lang.tr("Category:")).strong());
+                for name in
+                    ["General", "Number", "Currency", "Accounting", "Short Date", "Long Date", "Time", "Percentage", "Fraction", "Scientific", "Text"]
+                {
+                    let c = gridcraft_engine::cmd::format::format_code_for(name).to_string();
+                    if cols[0].selectable_label(code == c, lang.tr(name)).clicked() {
+                        code = c;
+                    }
+                }
+                cols[1].label(egui::RichText::new(lang.tr("Sample")).strong());
+                let preview = app.session.active().map(|doc| gridcraft_engine::display::format(&sample, &code, &doc.wb).text).unwrap_or_default();
+                cols[1].label(egui::RichText::new(preview).font(theme::ui_font(15.0)));
+                cols[1].add_space(8.0);
+                let label = cols[1].label(lang.tr("Type (custom format code):"));
+                cols[1].text_edit_singleline(&mut code).labelled_by(label.id);
+                for c in [
+                    "0",
+                    "0.00",
+                    "#,##0",
+                    "#,##0.00",
+                    "#,##0;[Red]-#,##0",
+                    "0%",
+                    "0.00%",
+                    "0.00E+00",
+                    "# ?/?",
+                    "m/d/yyyy",
+                    "d-mmm-yy",
+                    "mmmm d, yyyy",
+                    "h:mm AM/PM",
+                    "h:mm:ss",
+                    "[h]:mm:ss",
+                    "@",
+                ] {
+                    if cols[1].small_button(c).clicked() {
+                        code = c.to_string();
+                    }
+                }
+            });
+            st.num_fmt = gridcraft_engine::model::NumFmt::new(&code);
+        }
+        "Alignment" => {
+            use gridcraft_engine::model::{HAlign, VAlign};
+            ui.label(egui::RichText::new(lang.tr("Horizontal")).strong());
+            ui.horizontal_wrapped(|ui| {
+                for (h, n) in [
+                    (HAlign::General, "General"),
+                    (HAlign::Left, "Left"),
+                    (HAlign::Center, "Center"),
+                    (HAlign::Right, "Right"),
+                    (HAlign::Fill, "Fill"),
+                    (HAlign::Justify, "Justify"),
+                    (HAlign::CenterAcross, "Center Across Selection"),
+                    (HAlign::Distributed, "Distributed"),
+                ] {
+                    ui.radio_value(&mut st.align.h, h, lang.tr(n));
+                }
+            });
+            ui.label(egui::RichText::new(lang.tr("Vertical")).strong());
+            ui.horizontal_wrapped(|ui| {
+                for (v, n) in [
+                    (VAlign::Top, "Top"),
+                    (VAlign::Center, "Center"),
+                    (VAlign::Bottom, "Bottom"),
+                    (VAlign::Justify, "Justify"),
+                    (VAlign::Distributed, "Distributed"),
+                ] {
+                    ui.radio_value(&mut st.align.v, v, lang.tr(n));
+                }
+            });
+            let mut indent = st.align.indent as f32;
+            ui.add(egui::Slider::new(&mut indent, 0.0..=15.0).text(lang.tr("Indent")));
+            st.align.indent = indent as u8;
+            let mut rot = if st.align.rotation == 255 { 0.0 } else { st.align.rotation as f32 };
+            ui.add(egui::Slider::new(&mut rot, -90.0..=90.0).text(lang.tr("Orientation (degrees)")));
+            st.align.rotation = rot as i16;
+            ui.checkbox(&mut st.align.wrap, lang.tr("Wrap text"));
+            ui.checkbox(&mut st.align.shrink, lang.tr("Shrink to fit"));
+        }
+        "Font" => {
+            egui::ComboBox::from_label(lang.tr("Font")).selected_text(st.font.name.clone()).show_ui(ui, |ui| {
+                for f in crate::fonts::families() {
+                    ui.selectable_value(&mut st.font.name, f.clone(), f.clone());
+                }
+            });
+            ui.add(egui::Slider::new(&mut st.font.size, 6.0..=72.0).text(lang.tr("Size")));
+            ui.horizontal(|ui| {
+                ui.checkbox(&mut st.font.bold, lang.tr("Bold"));
+                ui.checkbox(&mut st.font.italic, lang.tr("Italic"));
+                ui.checkbox(&mut st.font.strike, lang.tr("Strikethrough"));
+            });
+            use gridcraft_engine::model::{Underline, VertAlign};
+            ui.horizontal(|ui| {
+                for (u, n) in [
+                    (Underline::None, "None"),
+                    (Underline::Single, "Single"),
+                    (Underline::Double, "Double"),
+                    (Underline::SingleAccounting, "Single Accounting"),
+                    (Underline::DoubleAccounting, "Double Accounting"),
+                ] {
+                    ui.radio_value(&mut st.font.underline, u, lang.tr(n));
+                }
+            });
+            ui.horizontal(|ui| {
+                ui.radio_value(&mut st.font.vert, VertAlign::Baseline, lang.tr("Normal"));
+                ui.radio_value(&mut st.font.vert, VertAlign::Superscript, lang.tr("Superscript"));
+                ui.radio_value(&mut st.font.vert, VertAlign::Subscript, lang.tr("Subscript"));
+            });
+            ui.label(lang.tr("Color:"));
+            let colors = app.session.active().map(|doc| doc.wb.theme.colors).unwrap_or_default();
+            if let Some(c) = crate::widgets::color_palette(ui, &colors, lang.tr("Automatic")) {
+                st.font.color =
+                    if c == "none" { gridcraft_engine::model::Color::Auto } else { gridcraft_engine::model::Color::from_hex(&c).unwrap_or_default() };
+            }
+        }
+        "Border" => {
+            use gridcraft_engine::model::{BorderLine, BorderStyle};
+            let line = BorderLine { style: BorderStyle::Thin, color: gridcraft_engine::model::Color::Auto };
+            ui.horizontal(|ui| {
+                if ui.button(lang.tr("None")).clicked() {
+                    st.borders = Default::default();
+                }
+                if ui.button(lang.tr("Outline")).clicked() {
+                    st.borders.top = line;
+                    st.borders.bottom = line;
+                    st.borders.left = line;
+                    st.borders.right = line;
+                }
+            });
+            for (n, slot) in [
+                ("Top", &mut st.borders.top),
+                ("Bottom", &mut st.borders.bottom),
+                ("Left", &mut st.borders.left),
+                ("Right", &mut st.borders.right),
+                ("Diagonal ↘", &mut st.borders.diag_down),
+                ("Diagonal ↗", &mut st.borders.diag_up),
+            ] {
+                let n = lang.tr(n);
+                ui.horizontal(|ui| {
+                    ui.label(format!("{n}:"));
+                    for (s, label) in [
+                        (BorderStyle::None, "none"),
+                        (BorderStyle::Thin, "thin"),
+                        (BorderStyle::Medium, "medium"),
+                        (BorderStyle::Thick, "thick"),
+                        (BorderStyle::Dashed, "dashed"),
+                        (BorderStyle::Dotted, "dotted"),
+                        (BorderStyle::Double, "double"),
+                    ] {
+                        let label = lang.tr(label);
+                        let response = ui.selectable_label(slot.style == s, label);
+                        let selected = slot.style == s;
+                        response.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), selected, format!("{n} {label}")));
+                        if response.clicked() {
+                            slot.style = s;
+                        }
+                    }
+                });
+            }
+            let theme = app.session.active().map(|doc| &doc.wb.theme).cloned().unwrap_or_default();
+            crate::border_preview::sample(ui, &st.borders, &theme);
+        }
+        "Fill" => {
+            let colors = app.session.active().map(|doc| doc.wb.theme.colors).unwrap_or_default();
+            ui.label(lang.tr("Background Color:"));
+            if let Some(c) = crate::widgets::color_palette(ui, &colors, lang.tr("No Color")) {
+                st.fill = if c == "none" {
+                    Default::default()
+                } else {
+                    gridcraft_engine::model::Fill::solid(gridcraft_engine::model::Color::from_hex(&c).unwrap_or_default())
+                };
+            }
+        }
+        "Protection" => {
+            ui.checkbox(&mut st.protection.locked, lang.tr("Locked"));
+            ui.checkbox(&mut st.protection.hidden, lang.tr("Hidden"));
+            ui.label(
+                egui::RichText::new(
+                    lang.tr("Locking cells or hiding formulas has no effect until you protect the worksheet (Review › Protect Sheet)."),
+                )
+                .small(),
+            );
+        }
+        _ => {}
+    }
+    if let Ok(v) = serde_json::to_value(&st) {
+        d.values.insert("style".into(), v);
+    }
+    let mut open = true;
+    ok_cancel(ui, confirm, &mut open);
+    if *confirm && let Some(style) = d.values.get("style").cloned() {
+        app.run_or_alert("home.formatCells", json!({"style": style}));
+    }
+    if !open {
+        app.dialog = None;
+        *confirm = true; // closes
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/insert_function.rs b/crates/ui-egui/src/dialogs/insert_function.rs
new file mode 100644
index 000000000..2a240b1af
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/insert_function.rs
@@ -0,0 +1,72 @@
+use super::show::ok_cancel;
+use super::*;
+
+/// Insert Function: searches names (as the formula language spells them) and descriptions, shows
+/// each hit's category and description, and starts editing `=NAME(` (or appends to the formula).
+pub(super) fn insert_function(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) {
+    let language = app.ui.language;
+    ui.horizontal(|ui| {
+        ui.label(language.tr("Search:"));
+        let r = ui.add(egui::TextEdit::singleline(&mut d.search).desired_width(300.0).hint_text(language.tr("e.g. lookup, average, date")));
+        r.request_focus();
+    });
+    let locale = language.formula_locale();
+    let list = gridcraft_engine::cmd::formulas::function_list();
+    // The names and descriptions searched are the ones shown, so in the interface language.
+    let q = d.search.to_lowercase();
+    let hits: Vec<&Json> = list
+        .iter()
+        .filter(|f| {
+            q.is_empty()
+                || f["name"].as_str().is_some_and(|n| locale.function_name(n).to_lowercase().contains(&q))
+                || f["description"].as_str().is_some_and(|n| language.function_description(n).unwrap_or(n).to_lowercase().contains(&q))
+        })
+        .take(300)
+        .collect();
+    egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
+        for (i, f) in hits.iter().enumerate() {
+            let name = locale.function_name(f["name"].as_str().unwrap_or(""));
+            let category = language.tr(function_category_label(f["category"].as_str().unwrap_or("")));
+            let r = ui.add(egui::Button::selectable(i == d.list_index, format!("{name:<18} {category}")).min_size(vec2(480.0, 20.0)));
+            if r.clicked() {
+                d.list_index = i;
+            }
+            if r.double_clicked() {
+                d.list_index = i;
+                *confirm = true;
+            }
+        }
+    });
+    if let Some(f) = hits.get(d.list_index) {
+        let name = f["name"].as_str().unwrap_or("");
+        ui.separator();
+        ui.label(egui::RichText::new(crate::formula_locale::signature(name, locale, language).unwrap_or_default()).strong());
+        ui.label(crate::formula_locale::description(name, locale, language).unwrap_or_default());
+    }
+    let mut open = true;
+    ok_cancel(ui, confirm, &mut open);
+    if *confirm && let Some(n) = hits.get(d.list_index).and_then(|f| f["name"].as_str()) {
+        let n = app.session.active().map(|doc| crate::formula_locale::completion_name(n, locale, &doc.wb, doc.wb.active_sheet())).unwrap_or(n);
+        let cur = app.editor.as_ref().map(|e| e.text.clone());
+        let text = match cur {
+            Some(t) if t.starts_with('=') => format!("{t}{n}("),
+            _ => format!("={n}("),
+        };
+        app.begin_edit(Some(text), false);
+    }
+    if !open {
+        *confirm = true;
+    }
+}
+
+/// Excel's name for a function category, given the catalog's id (`MathTrig`).
+fn function_category_label(id: &str) -> &str {
+    match id {
+        "DateTime" => "Date & Time",
+        "Lookup" => "Lookup & Reference",
+        "MathTrig" => "Math & Trig",
+        "AddIn" => "Add-in and Automation",
+        // Financial, Logical, Text, Statistical, Engineering, Database, Information, …
+        other => other,
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/macros.rs b/crates/ui-egui/src/dialogs/macros.rs
new file mode 100644
index 000000000..269643f8d
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/macros.rs
@@ -0,0 +1,40 @@
+use super::*;
+
+/// The Macros dialog: lists GridCraft's own recorded scripts and (if the file carries one) the
+/// preserved VBA project. Mirrors Excel's Developer ▸ Macros list, but is honest that VBA is
+/// preserved and not executed.
+pub(super) fn macros(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) {
+    ui.label("Automation in this workbook. GridCraft runs its own scripts; a file's VBA project is preserved but not executed.");
+    ui.add_space(6.0);
+    let items: Vec<Json> = d.result.as_ref().and_then(Json::as_array).cloned().unwrap_or_default();
+    if items.is_empty() {
+        ui.weak("This workbook has no scripts or macros.");
+        return;
+    }
+    // Scripts that came with a file stay disabled until the user trusts the workbook (#2178).
+    if items.iter().any(|it| it.get("trusted").and_then(Json::as_bool) == Some(false)) {
+        ui.horizontal(|ui| {
+            ui.weak("Scripts in this workbook came from a file and are disabled.");
+            if ui.button("Trust Scripts").on_hover_text("Let this workbook's scripts run for the rest of this session").clicked() {
+                let _ = app.run("automate.trustScripts", json!({"trusted": true}));
+                d.result = app.session.run("view.macros", json!({})).ok();
+            }
+        });
+        ui.add_space(6.0);
+    }
+    egui::ScrollArea::vertical().max_height(300.0).show(ui, |ui| {
+        for it in &items {
+            let name = it.get("name").and_then(Json::as_str).unwrap_or("(unnamed)");
+            let is_vba = it.get("kind").and_then(Json::as_str) == Some("vba");
+            ui.horizontal(|ui| {
+                ui.label(egui::RichText::new(name).strong());
+                if is_vba {
+                    ui.weak("— VBA project (preserved, not run)");
+                } else {
+                    let steps = it.get("steps").and_then(Json::as_u64).unwrap_or(0);
+                    ui.weak(format!("— {steps} step{}", if steps == 1 { "" } else { "s" }));
+                }
+            });
+        }
+    });
+}
diff --git a/crates/ui-egui/src/dialogs/names.rs b/crates/ui-egui/src/dialogs/names.rs
new file mode 100644
index 000000000..f12374dae
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/names.rs
@@ -0,0 +1,134 @@
+use super::show::ok_cancel;
+use super::*;
+
+pub(super) fn name_manager(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, open: &mut bool) {
+    let list = app.session.run("formulas.nameManager", json!({})).unwrap_or(Json::Null);
+    let names = list.as_array().cloned().unwrap_or_default();
+    let selected = names.get(d.list_index).cloned();
+    let field = |n: &Json, k: &str| n.get(k).and_then(Json::as_str).unwrap_or("").to_string();
+    ui.horizontal(|ui| {
+        if ui.button("New…").clicked() {
+            app.open_dialog("defineName", json!({}));
+        }
+        if ui.add_enabled(selected.is_some(), egui::Button::new("Edit…")).clicked()
+            && let Some(n) = &selected
+        {
+            app.open_dialog(
+                "defineName",
+                json!({
+                    "name": field(n, "name"), "scope": field(n, "scope"), "comment": field(n, "comment"),
+                    "refersTo": field(n, "refersTo"), "oldName": field(n, "name"), "oldScope": field(n, "scope"),
+                }),
+            );
+        }
+        if ui.add_enabled(selected.is_some(), egui::Button::new("Delete")).clicked()
+            && let Some(n) = &selected
+        {
+            app.run_or_alert("formulas.deleteName", json!({"name": field(n, "name"), "scope": field(n, "scope")}));
+        }
+    });
+    ui.add_space(4.0);
+    egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
+        egui::Grid::new("names").striped(true).num_columns(4).show(ui, |ui| {
+            ui.strong("Name");
+            ui.strong("Value");
+            ui.strong("Refers To");
+            ui.strong("Scope");
+            ui.end_row();
+            if names.is_empty() {
+                ui.label(egui::RichText::new("No names defined").italics());
+                ui.end_row();
+            }
+            for (i, n) in names.iter().enumerate() {
+                if ui.selectable_label(i == d.list_index, field(n, "name")).clicked() {
+                    d.list_index = i;
+                }
+                ui.label(n.get("value").map(|v| v.to_string()).unwrap_or_default().chars().take(30).collect::<String>());
+                ui.label(field(n, "refersTo"));
+                ui.label(field(n, "scope"));
+                ui.end_row();
+            }
+        });
+    });
+    ui.add_space(8.0);
+    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+        if ui.button(" Close ").clicked() {
+            *open = false;
+        }
+    });
+}
+
+/// The names Paste Names offers in the active workbook.
+pub(super) fn pasteable_names(app: &SheetApp) -> Vec<String> {
+    app.session
+        .active()
+        .map(|doc| gridcraft_engine::cmd::formulas::pasteable_names(&doc.wb).into_iter().map(|(n, _)| n).collect())
+        .unwrap_or_default()
+}
+
+/// Puts a defined name into the formula being edited, at the caret. Without an edit under way it
+/// starts one in the active cell with `=` and the name.
+pub(crate) fn insert_name(app: &mut SheetApp, name: &str) {
+    match app.editor.as_mut() {
+        Some(ed) => ed.insert_at_caret(name),
+        None => app.begin_edit(Some(format!("={name}")), false),
+    }
+}
+
+/// Paste Name (F3, Formulas › Use in Formula › Paste Names…): OK, or a double-click, inserts the
+/// selected name (`formulas.pasteName` with `name`); Paste List writes every name and what it
+/// refers to from the active cell.
+pub(super) fn paste_name(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    let names: Vec<String> =
+        d.result.as_ref().and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_str).map(str::to_owned).collect()).unwrap_or_default();
+    // The `name` value is the selection, so `ui.dialog.set` can choose one too.
+    if let Some(i) = d.values.get("name").and_then(Json::as_str).and_then(|n| names.iter().position(|x| x == n)) {
+        d.list_index = i;
+    }
+    let (down, up) = ui.input_mut(|i| (i.consume_key(egui::Modifiers::NONE, Key::ArrowDown), i.consume_key(egui::Modifiers::NONE, Key::ArrowUp)));
+    let last = names.len().saturating_sub(1);
+    if down {
+        d.list_index = (d.list_index + 1).min(last);
+    }
+    if up {
+        d.list_index = d.list_index.saturating_sub(1);
+    }
+    d.list_index = d.list_index.min(last);
+    ui.label(app.ui.language.tr("Paste name"));
+    if names.is_empty() {
+        ui.label(egui::RichText::new(app.ui.language.tr("No names defined")).italics());
+    }
+    // A workbook can hold thousands of names: only the rows in view are laid out.
+    let row_height = ui.text_style_height(&egui::TextStyle::Button) + 2.0 * ui.spacing().button_padding.y;
+    let step = row_height + ui.spacing().item_spacing.y;
+    egui::ScrollArea::vertical().max_height(220.0).auto_shrink([false, true]).show_rows(ui, row_height, names.len(), |ui, rows| {
+        let top = ui.cursor().top() - rows.start as f32 * step;
+        for (i, n) in names.iter().enumerate().skip(rows.start).take(rows.len()) {
+            let r = ui.selectable_label(i == d.list_index, n);
+            if r.clicked() {
+                d.list_index = i;
+            }
+            if r.double_clicked() {
+                *confirm = true;
+            }
+        }
+        // The arrow keys can move the selection onto a row that isn't laid out.
+        if down || up {
+            let rect = egui::Rect::from_min_size(egui::pos2(ui.min_rect().left(), top + d.list_index as f32 * step), egui::vec2(1.0, row_height));
+            if !ui.clip_rect().contains_rect(rect) {
+                ui.scroll_to_rect(rect, Some(if down { egui::Align::Max } else { egui::Align::Min }));
+            }
+        }
+    });
+    ui.add_space(4.0);
+    // Paste List is disabled while a cell is being edited.
+    if ui.add_enabled(!names.is_empty() && app.editor.is_none(), egui::Button::new(app.ui.language.tr("Paste List"))).clicked() {
+        app.run_or_alert("formulas.pasteName", json!({"list": true}));
+        *open = false;
+        return;
+    }
+    if let Some(n) = names.get(d.list_index) {
+        d.values.insert("name".into(), json!(n));
+    }
+    ok_cancel(ui, confirm, open);
+}
diff --git a/crates/ui-egui/src/dialogs/paste.rs b/crates/ui-egui/src/dialogs/paste.rs
new file mode 100644
index 000000000..bc01a7da2
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/paste.rs
@@ -0,0 +1,139 @@
+use super::*;
+
+/// Paste Special as Excel lays it out: Paste and Operation each in two columns of options, Skip
+/// blanks and Transpose side by side, and Paste Link as a button that pastes at once. The options
+/// come from the dialog's `fields`, so the letter shortcuts and the control channel see the same.
+pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    let lang = app.ui.language;
+    let t = theme::Tokens::get(ui.ctx());
+    let choices: Vec<(&'static str, &'static str, Vec<(&'static str, &'static str)>)> = d
+        .fields
+        .iter()
+        .filter_map(|f| match f {
+            Field::Choice { key, label, options } => Some((*key, *label, options.clone())),
+            _ => None,
+        })
+        .collect();
+    for (key, label, options) in choices {
+        ui.add_space(4.0);
+        ui.label(egui::RichText::new(lang.tr(label)).strong());
+        egui::Frame::new().stroke(Stroke::new(1.0, t.separator)).corner_radius(4.0).inner_margin(egui::Margin::symmetric(10, 6)).show(ui, |ui| {
+            ui.set_min_width(ui.available_width());
+            let cur = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
+            // Column by column, as Excel fills them.
+            let rows = options.len().div_ceil(2);
+            egui::Grid::new(("paste_special", key)).num_columns(2).min_col_width(200.0).spacing(vec2(16.0, 4.0)).show(ui, |ui| {
+                for r in 0..rows {
+                    for c in 0..2 {
+                        if let Some((value, text)) = options.get(c * rows + r) {
+                            if ui.radio(cur == *value, lang.tr(text)).clicked() {
+                                d.set_value(key, json!(value));
+                            }
+                        } else {
+                            ui.label("");
+                        }
+                    }
+                    ui.end_row();
+                }
+            });
+        });
+    }
+    ui.add_space(8.0);
+    // In the same columns as the options above.
+    egui::Frame::new().inner_margin(egui::Margin::symmetric(11, 0)).show(ui, |ui| {
+        egui::Grid::new("paste_special_checks").num_columns(2).min_col_width(200.0).spacing(vec2(16.0, 4.0)).show(ui, |ui| {
+            for (key, label) in [("skipBlanks", "Skip blanks"), ("transpose", "Transpose (E)")] {
+                let mut b = d.values.get(key).and_then(Json::as_bool).unwrap_or(false);
+                if ui.checkbox(&mut b, lang.tr(label)).changed() {
+                    d.values.insert(key.into(), json!(b));
+                }
+            }
+            ui.end_row();
+        });
+    });
+    ui.add_space(8.0);
+    ui.separator();
+    ui.horizontal(|ui| {
+        // Excel's Paste Link pastes references to the copied cells straight away.
+        if ui.button(lang.tr("Paste Link")).on_hover_text(lang.tr("Paste formulas that refer to the copied cells")).clicked() {
+            d.values.insert("what".into(), json!("all"));
+            d.values.insert("operation".into(), json!("none"));
+            d.values.insert("link".into(), json!(true));
+            *confirm = true;
+        }
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            let ok = ui.add(egui::Button::new(egui::RichText::new(format!("   {}   ", lang.tr("OK"))).color(t.on_accent)).fill(t.accent));
+            if ok.clicked() || ui.input(|i| i.key_pressed(Key::Enter)) {
+                *confirm = true;
+            }
+            if ui.button(format!(" {} ", lang.tr("Cancel"))).clicked() {
+                *open = false;
+            }
+        });
+    });
+}
+
+/// Paste Special's legacy mnemonics select options; Enter still performs the paste.
+pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) {
+    if ctx.text_edit_focused() {
+        return;
+    }
+    let right_alt = ctx.input(|i| {
+        i.key_down(Key::AltRight)
+            || i.events.iter().any(|event| {
+                matches!(event, egui::Event::Key { key: Key::AltRight, .. })
+                    || matches!(event, egui::Event::Key { physical_key: Some(Key::AltRight), .. })
+            })
+    });
+    let mac = ctx.os() == egui::os::OperatingSystem::Mac;
+    let allowed = |m: egui::Modifiers| !m.ctrl && !m.command && !m.mac_cmd && !(m.alt && (mac || right_alt));
+    let mnemonic = |key| match key {
+        Key::T => Some('t'),
+        Key::V => Some('v'),
+        Key::F => Some('f'),
+        Key::C => Some('c'),
+        Key::E => Some('e'),
+        _ => None,
+    };
+    let mut text_to_consume = Vec::new();
+    for event in ctx.input(|i| i.events.clone()) {
+        let egui::Event::Key { key, pressed: true, repeat, modifiers, .. } = event else { continue };
+        if !allowed(modifiers) {
+            continue;
+        }
+        let Some(letter) = mnemonic(key) else { continue };
+        text_to_consume.push(letter);
+        if repeat {
+            continue;
+        }
+        if key == Key::E {
+            let transpose = d.values.get("transpose").and_then(Json::as_bool).unwrap_or(false);
+            d.values.insert("transpose".into(), json!(!transpose));
+        } else {
+            let what = match key {
+                Key::T => "formats",
+                Key::V => "values",
+                Key::F => "formulas",
+                _ => "comments",
+            };
+            d.values.insert("what".into(), json!(what));
+        }
+    }
+    // Browsers can deliver Text before or after Key. Act only on Key, then remove
+    // its matching text so one physical press cannot toggle Transpose twice.
+    ctx.input_mut(|i| {
+        i.events.retain(|event| match event {
+            egui::Event::Key { key, modifiers, .. } => !(allowed(*modifiers) && mnemonic(*key).is_some()),
+            egui::Event::Text(text) if text.len() == 1 => {
+                let letter = text.chars().next().unwrap_or_default().to_ascii_lowercase();
+                if let Some(index) = text_to_consume.iter().position(|&c| c == letter) {
+                    text_to_consume.remove(index);
+                    false
+                } else {
+                    true
+                }
+            }
+            _ => true,
+        });
+    });
+}
diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs
new file mode 100644
index 000000000..d6bc92daa
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/show.rs
@@ -0,0 +1,577 @@
+use super::about::about;
+use super::analysis::{analysis_toolpak, goal_seek, solver, solver_results};
+use super::charts::{recommended_charts, select_data};
+use super::command_search::command_search;
+use super::cond_format_rules::manage_rules;
+use super::data::{advanced_filter_form, data_validation_form, sort};
+use super::find::{find, go_to};
+use super::format_cells::format_cells;
+use super::insert_function::insert_function;
+use super::macros::macros;
+use super::names::{name_manager, paste_name};
+use super::paste::{paste_special, paste_special_shortcuts};
+use super::spelling::spelling;
+use super::zoom::zoom;
+use super::*;
+
+/// Builds the command params from form values for dialogs that need translation.
+/// The parameters OK sends to the dialog's command: its field values, reshaped per dialog.
+pub(crate) fn build_params(d: &Dialog) -> Json {
+    let mut v = Json::Object(d.values.clone());
+    match d.name.as_str() {
+        "advancedFilter" => {
+            if let Some(m) = v.as_object_mut() {
+                m.remove("action");
+                if d.values.get("action").and_then(Json::as_str) != Some("copy") {
+                    m.remove("copyTo");
+                }
+                if m.get("criteria").and_then(Json::as_str).is_some_and(|s| s.trim().is_empty()) {
+                    m.remove("criteria");
+                }
+            }
+        }
+        "dataValidation" => {
+            let kind = d.values.get("type").and_then(Json::as_str).unwrap_or("any");
+            let operator = d.values.get("operator").and_then(Json::as_str).unwrap_or("between");
+            if let Some(m) = v.as_object_mut() {
+                if !matches!(operator, "between" | "notBetween") || matches!(kind, "any" | "list" | "custom") {
+                    m.remove("formula2");
+                }
+                if matches!(kind, "any" | "list" | "custom") {
+                    m.remove("operator");
+                }
+                if kind == "any" {
+                    m.remove("formula1");
+                }
+                if kind != "list" {
+                    m.remove("dropdown");
+                }
+            }
+        }
+        "textToColumns" => {
+            let mut delims = Vec::new();
+            for (k, c) in [("tab", "\t"), ("semicolon", ";"), ("comma", ","), ("space", " ")] {
+                if d.values.get(k).and_then(Json::as_bool) == Some(true) {
+                    delims.push(json!(c));
+                }
+            }
+            v["delimiters"] = Json::Array(delims);
+        }
+        "removeDuplicates" | "subtotal" => {
+            if let Some(t) = d.values.get("columnsText").and_then(Json::as_str).filter(|t| !t.trim().is_empty()) {
+                v["columns"] = Json::Array(t.split(',').map(|c| json!(c.trim().to_ascii_uppercase())).collect());
+            }
+        }
+        "allowEditRanges" => {
+            if let Some(m) = v.as_object_mut() {
+                // Blank fields mean "unchanged"; the check box clears a password.
+                m.retain(|_, x| x.as_str().is_none_or(|s| !s.trim().is_empty()));
+                if m.remove("removePassword").and_then(|x| x.as_bool()) == Some(true) {
+                    m.insert("password".into(), json!(""));
+                }
+            }
+        }
+        "cfQuick" => {
+            let mut rule = Map::new();
+            for (k, val) in &d.values {
+                rule.insert(k.clone(), val.clone());
+            }
+            v = json!({"rule": Json::Object(rule)});
+            if let Some(pick) = d.pick.as_ref().filter(|pick| !pick.applies_to.is_empty() && !pick.sheet.is_empty()) {
+                v["sheet"] = json!(pick.sheet.as_str());
+                v["range"] = json!(pick.applies_to);
+            }
+        }
+        "series" => {
+            if let Some(s) = d.values.get("stop").and_then(Json::as_str).and_then(|s| s.parse::<f64>().ok()) {
+                v["stop"] = json!(s);
+            } else if let Some(m) = v.as_object_mut() {
+                m.remove("stop");
+            }
+        }
+        "defineName" => {
+            if let Some(m) = v.as_object_mut() {
+                for key in ["scope", "oldScope"] {
+                    if m.get(key).and_then(Json::as_str) == Some("Workbook") {
+                        m.remove(key);
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    v
+}
+
+/// Takes and draws the active dialog, dispatches its body by name, consumes picture-inbox results, runs OK/confirm commands, handles Esc/close and restores the back-dialog stack.
+pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
+    let Some(mut d) = app.dialog.take() else { return };
+    let home = app.ui_window();
+    if d.name == "pasteSpecial" {
+        paste_special_shortcuts(&mut d, ctx);
+    }
+    let mut open = true;
+    let mut win_open = true;
+    let mut confirm = false;
+    let width = match d.name.as_str() {
+        "formatCells" => 560.0,
+        "about" => 660.0,
+        "insertFunction" | "commandSearch" | "nameManager" | "manageRules" | "journal" | "agents" | "macros" => 520.0,
+        "recommendedCharts" => 600.0,
+        "analysisToolPak" => 420.0,
+        "solver" => 460.0,
+        "zoom" => 220.0,
+        "pasteSpecial" => 480.0,
+        _ => 380.0,
+    };
+    let window = egui::Window::new(app.ui.language.tr(&d.title))
+        .id(egui::Id::unique("dialog").with(&d.name))
+        .collapsible(false)
+        .resizable(false)
+        .default_width(width)
+        // A default position, not an anchor: egui anchors can't be dragged, and dialogs move by their title bar.
+        .pivot(egui::Align2::CENTER_CENTER)
+        .default_pos(ctx.content_rect().center() + vec2(0.0, -40.0))
+        .open(&mut win_open);
+    let window = match d.name.as_str() {
+        "insertPicture" => window.default_height(240.0),
+        "advancedFilter" => window.default_height(0.0),
+        _ => window,
+    };
+    window.show(ctx, |ui| {
+            ui.set_min_width(width - 20.0);
+            match d.name.as_str() {
+                "formatCells" => format_cells(app, ui, &mut d, &mut confirm),
+                "dataValidation" => data_validation_form(ui, &mut d, &mut confirm, &mut open),
+                "advancedFilter" => advanced_filter_form(ui, &mut d, &mut confirm, &mut open),
+                "insertFunction" => insert_function(app, ui, &mut d, &mut confirm),
+                "find" => find(app, ui, &mut d),
+                "goTo" => go_to(app, ui, &mut d, &mut confirm),
+                "zoom" => zoom(ui, &mut d, &mut confirm, &mut open),
+                "sort" => sort(app, ui, &mut d, &mut confirm),
+                "nameManager" => name_manager(app, ui, &mut d, &mut open),
+                "pasteName" => paste_name(app, ui, &mut d, &mut confirm, &mut open),
+                "manageRules" => manage_rules(app, ui),
+                "recommendedCharts" => recommended_charts(app, ui, &mut d, &mut confirm, &mut open),
+                "selectData" => select_data(app, ui, &mut d, &mut confirm, &mut open),
+                "commandSearch" => command_search(app, ui, &mut d, &mut confirm),
+                "goalSeek" => goal_seek(app, ui, &mut d, &mut confirm),
+                "pasteSpecial" => paste_special(app, ui, &mut d, &mut confirm, &mut open),
+                "analysisToolPak" => analysis_toolpak(app, ui, &mut d, &mut confirm, &mut open),
+                "solver" => solver(ui, &mut d, &mut confirm, &mut open),
+                "solverResults" => solver_results(app, ui, &mut d, &mut open),
+                "spelling" => spelling(app, ui, &mut d, &mut open),
+                "agents" => {
+                    ui.label("GridCraft is fully drivable by agents. Every menu item, button and gesture is a command:");
+                    ui.add_space(4.0);
+                    ui.monospace("gridcraft --control 7979        # JSON-lines control channel\ngridcraft-cli mcp --connect 7979   # MCP bridged to this window\ngridcraft-cli mcp                   # headless MCP server");
+                    ui.add_space(4.0);
+                    ui.label(format!("{} engine commands are available. See docs/mcp.md and docs/control-protocol.md.", gridcraft_engine::command_specs().len()));
+                }
+                "about" => about(ui, &mut d),
+                "journal" => {
+                    egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
+                        for (id, p) in app.session.journal.iter().rev().take(500) {
+                            ui.monospace(format!("{id} {p}"));
+                        }
+                    });
+                }
+                "macros" => macros(app, ui, &mut d),
+                "statistics" | "accessibility" | "errorChecking" | "evaluateFormula" | "comments" => {
+                    let r = if d.name == "comments" {
+                        app.session.active().and_then(|doc| doc.wb.active().map(|s| json!(s.comments.iter().map(|(c, m)| json!({"cell": c.a1(), "author": m.author, "text": m.text})).collect::<Vec<_>>())))
+                    } else {
+                        d.result.clone()
+                    };
+                    egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
+                        ui.monospace(serde_json::to_string_pretty(&r.unwrap_or(Json::Null)).unwrap_or_default());
+                    });
+                }
+                "insertPicture" => {
+                    // A private inbox dies with this dialog; late browser results
+                    // cannot affect a later picture choice or another workbook.
+                    let arrived = d.picture_inbox.as_ref().and_then(|inbox| {
+                        inbox.lock().unwrap_or_else(std::sync::PoisonError::into_inner).pop()
+                    });
+                    if let Some((name, bytes)) = arrived {
+                        d.picture_inbox = None;
+                        if bytes.len() > 16 * 1024 * 1024 {
+                            app.message = Some((d.title.clone(), "Choose a PNG or JPEG no larger than 16 MB.".into()));
+                        } else {
+                            d.values.remove("path");
+                            d.values.insert("alt".into(), json!(name));
+                            d.values.insert("base64".into(), json!(gridcraft_engine::io::base64_encode(&bytes)));
+                        }
+                    }
+                    if app.services.pick_picture_async.is_some() {
+                        let name = d.values.get("alt").and_then(Json::as_str).unwrap_or("No picture selected");
+                        ui.label(name);
+                    } else {
+                        ui.label("Picture file path (PNG or JPEG):");
+                        let mut path = d.values.get("path").and_then(Json::as_str).unwrap_or("").to_string();
+                        if ui.text_edit_singleline(&mut path).changed() {
+                            d.values.remove("base64");
+                            d.values.insert("path".into(), json!(path));
+                        }
+                    }
+                    if (app.services.pick_picture.is_some() || app.services.pick_picture_async.is_some()) && ui.button("Browse…").clicked() {
+                        if let Some(start) = &app.services.pick_picture_async {
+                            let inbox = crate::Inbox::default();
+                            start(inbox.clone());
+                            d.picture_inbox = Some(inbox);
+                        } else if let Some(pick) = &app.services.pick_picture
+                            && let Some(path) = pick()
+                        {
+                            d.values.remove("base64");
+                            let alt = std::path::Path::new(&path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("");
+                            d.values.insert("alt".into(), json!(alt));
+                            d.values.insert("path".into(), json!(path));
+                        }
+                    }
+                    ui.label("Description (optional):");
+                    let mut alt = d.values.get("alt").and_then(Json::as_str).unwrap_or("").to_string();
+                    if ui.text_edit_singleline(&mut alt).changed() {
+                        d.values.insert("alt".into(), json!(alt));
+                    }
+                    if d.values.get("placement").and_then(Json::as_str) == Some("cell") {
+                        ui.label(egui::RichText::new("Fits inside the selected cell and moves with its content.").small());
+                    }
+                    ok_cancel(ui, &mut confirm, &mut open);
+                }
+                "pickList" => {
+                    let items: Vec<String> = app
+                        .session
+                        .active()
+                        .and_then(|doc| {
+                            let sh = doc.wb.active()?;
+                            let a = doc.selection.active;
+                            let mut seen = std::collections::BTreeSet::new();
+                            let mut r = a.row;
+                            while r > 0 && !sh.value(gridcraft_engine::core::CellRef::new(r - 1, a.col)).is_empty() {
+                                r -= 1;
+                                seen.insert(sh.value(gridcraft_engine::core::CellRef::new(r, a.col)).display());
+                            }
+                            Some(seen.into_iter().collect())
+                        })
+                        .unwrap_or_default();
+                    for it in items {
+                        if ui.button(&it).clicked() {
+                            app.run_or_alert("cell.set", json!({"input": it}));
+                            open = false;
+                        }
+                    }
+                }
+                "saveCopy" => {
+                    let fmt = d.values.get("format").and_then(Json::as_str).unwrap_or("xlsx").to_string();
+                    ui.label(format!("Save a copy as .{fmt}"));
+                    let mut path = d.values.get("path").and_then(Json::as_str).unwrap_or("").to_string();
+                    ui.text_edit_singleline(&mut path);
+                    d.values.insert("path".into(), json!(path.clone()));
+                    ok_cancel(ui, &mut confirm, &mut open);
+                    if confirm {
+                        // A bare name has no folder: written as typed it would land in the
+                        // process's working directory (`/` from the Finder, the install folder on
+                        // Windows), never where the user looks. The picker chooses the folder.
+                        let pick = app.services.pick_save.as_ref();
+                        let target = if path.is_empty() {
+                            pick.and_then(|f| f(&format!("Copy.{fmt}")))
+                        } else if let Some(f) = pick.filter(|_| std::path::Path::new(&path).is_relative()) {
+                            f(&if path.ends_with(&format!(".{fmt}")) { path } else { format!("{path}.{fmt}") })
+                        } else {
+                            Some(path)
+                        };
+                        if let Some(t) = target {
+                            let id = match fmt.as_str() {
+                                "csv" => "file.exportCsv",
+                                "html" => "file.exportHtml",
+                                _ => "file.saveAs",
+                            };
+                            app.run_or_alert(id, json!({"path": t}));
+                        }
+                    }
+                }
+                "saveChanges" => {
+                    ui.label(format!("Do you want to save the changes you made to {}?", d.values.get("title").and_then(Json::as_str).unwrap_or("this workbook")));
+                    let quitting = d.values.get("quit").and_then(Json::as_bool) == Some(true);
+                    ui.horizontal(|ui| {
+                        for (label, answer) in
+                            [("Don't Save", crate::SaveAnswer::DontSave), ("Cancel", crate::SaveAnswer::Cancel), ("Save", crate::SaveAnswer::Save)]
+                        {
+                            if ui.button(label).clicked() && app.answer_save_changes(answer, quitting, ui.ctx()) {
+                                open = false;
+                            }
+                        }
+                    });
+                }
+                "start" => {
+                    ui.heading("Start a new workbook");
+                    ui.horizontal_wrapped(|ui| {
+                        if ui.button("Blank workbook").clicked() {
+                            app.run_or_alert("file.new", json!({}));
+                            open = false;
+                        }
+                        for (n, t) in gridcraft_engine::sample::SAMPLES {
+                            if ui.button(*t).clicked() {
+                                app.run_or_alert("file.new", json!({"sample": n}));
+                                open = false;
+                            }
+                        }
+                    });
+                    ui.separator();
+                    ui.label(egui::RichText::new("Recent").strong());
+                    for path in app.ui.recent.clone() {
+                        if ui.link(&path).clicked() {
+                            app.open_path(&path);
+                            open = false;
+                        }
+                    }
+                    if ui.button("Open…").clicked() {
+                        app.open_dialog("open", json!({}));
+                        open = false;
+                    }
+                }
+                _ => form(ui, &mut d, &mut confirm, &mut open),
+            }
+        });
+    // Hyperlinks inside dialogs (About ▸ Contributors) open through the host's `open_url`, since
+    // the native shell has no browser integration of its own.
+    if let Some(open_url) = &app.services.open_url {
+        let urls: Vec<String> = ctx.output_mut(|o| {
+            let mut urls = vec![];
+            o.commands.retain(|c| match c {
+                egui::OutputCommand::OpenUrl(u) => {
+                    urls.push(u.url.clone());
+                    false
+                }
+                _ => true,
+            });
+            urls
+        });
+        for u in urls {
+            open_url(&u);
+        }
+    }
+    if ctx.input(|i| i.key_pressed(Key::Escape)) || !win_open {
+        open = false;
+    }
+    if confirm && d.name == "insertPicture" && d.picture_target != app.view_key() {
+        app.message = Some((d.title.clone(), "Return to the original worksheet to insert this picture, or cancel and choose another cell.".into()));
+        confirm = false;
+    }
+    if confirm && let Some(cmd) = d.command {
+        let params = build_params(&d);
+        match app.run(cmd, params) {
+            Ok(r) => {
+                open = false;
+                if d.name == "solver" {
+                    app.open_dialog("solverResults", r);
+                } else if d.name == "openPassword" {
+                    let path = d.values.get("path").and_then(Json::as_str).map(str::to_string);
+                    app.after_open(path.as_deref(), &r);
+                }
+            }
+            // Data Analysis asks before replacing data in its output range.
+            Err(e) if d.name == "analysisToolPak" && e.contains(gridcraft_engine::cmd::analysis::OVERWRITE_ERROR) => {
+                d.values.insert("askOverwrite".into(), json!(true));
+            }
+            // A wrong password: say so, clear the field and stay open for another try.
+            Err(e) if d.name == "openPassword" => {
+                d.values.insert("password".into(), json!(""));
+                app.message = Some((d.title.clone(), crate::clean_error(&e)));
+            }
+            Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))),
+        }
+    } else if confirm {
+        open = false;
+    }
+    if app.ui_window() != home {
+        // A command run from the dialog switched windows: whatever it opened shows in the new
+        // window, and this dialog (or the one it returns to) stays in its own.
+        let keep = if open { Some(d) } else { d.back.take().map(|b| *b) };
+        if let Some(keep) = keep {
+            app.return_dialog(home, keep);
+        }
+        return;
+    }
+    if let Some(child) = app.dialog.as_mut() {
+        // The body opened another dialog (Name Manager › New…). It takes over; this one waits
+        // behind it and comes back when it closes, as Excel returns to the Name Manager. Go To
+        // hands over to Go To Special for good, as in Excel.
+        if open && d.name != "goTo" {
+            child.back = Some(Box::new(d));
+        } else if child.back.is_none() {
+            child.back = d.back.take();
+        }
+        return;
+    }
+    if open {
+        app.dialog = Some(d);
+    } else if let Some(back) = d.back.take() {
+        app.dialog = Some(*back);
+    }
+}
+
+pub(super) fn ok_cancel(ui: &mut egui::Ui, confirm: &mut bool, open: &mut bool) {
+    ui.add_space(8.0);
+    // A row as tall as the buttons: a right-to-left layout straight in the window takes all the
+    // height it is offered, which stretched every form dialog to the screen's height.
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            let lang = crate::i18n::current(ui.ctx());
+            let t = crate::theme::Tokens::get(ui.ctx());
+            let ok = ui.add(egui::Button::new(egui::RichText::new(format!("   {}   ", lang.tr("OK"))).color(t.on_accent)).fill(t.accent));
+            if ok.clicked() || ui.input(|i| i.key_pressed(Key::Enter)) {
+                *confirm = true;
+            }
+            if ui.button(format!(" {} ", lang.tr("Cancel"))).clicked() {
+                *open = false;
+            }
+        })
+    });
+}
+
+fn form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    form_fields(ui, d);
+    ok_cancel(ui, confirm, open);
+}
+
+/// Gives keyboard focus to the first text or number field the first time a form is drawn. A
+/// focused number field is in typing mode with its value selected, so Alt+H, O, W then 12 and
+/// Enter sets the width, as in Excel.
+/// Keeps asking until the field really has focus: a new window's first frame is an invisible
+/// sizing pass where a focus request is ignored.
+fn take_first_focus(d: &mut Dialog, r: &egui::Response) {
+    if !d.focus_first_field {
+        return;
+    }
+    if !r.has_focus() {
+        r.request_focus();
+        return;
+    }
+    // Focus has landed, and the field is now a text box: select its whole value so typing
+    // replaces it (the field's own select-on-focus fired before it was a text box).
+    let mut state = egui::text_edit::TextEditState::load(&r.ctx, r.id).unwrap_or_default();
+    let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(usize::MAX / 2));
+    state.cursor.set_char_range(Some(all));
+    state.store(&r.ctx, r.id);
+    d.focus_first_field = false;
+}
+
+/// Keeps a picking formula box's caret, and gives it the keyboard back after a grid click put a
+/// reference in it (the click took the focus), its caret after the reference.
+fn track_pick(pick: &mut RefPick, r: &egui::Response, typed: bool) {
+    if typed {
+        pick.point = None;
+    }
+    if pick.refocus {
+        let mut state = egui::text_edit::TextEditState::load(&r.ctx, r.id).unwrap_or_default();
+        state.cursor.set_char_range(Some(egui::text::CCursorRange::one(egui::text::CCursor::new(pick.caret))));
+        state.store(&r.ctx, r.id);
+        r.request_focus();
+        pick.refocus = false;
+    } else if r.has_focus()
+        && let Some(range) = egui::text_edit::TextEditState::load(&r.ctx, r.id).and_then(|state| state.cursor.char_range())
+    {
+        pick.caret = range.primary.index.into();
+    }
+}
+
+/// Draws a dialog's `fields`, editing its values.
+pub(super) fn form_fields(ui: &mut egui::Ui, d: &mut Dialog) {
+    // Field labels, choices and notes are English source strings, translated as they are drawn.
+    let lang = crate::i18n::current(ui.ctx());
+    egui::Grid::new("form").num_columns(1).spacing(vec2(8.0, 6.0)).show(ui, |ui| {
+        for f in d.fields.clone() {
+            match f {
+                Field::Text { key, label } => {
+                    ui.vertical(|ui| {
+                        let label = ui.label(lang.tr(label));
+                        let mut s = d
+                            .values
+                            .get(key)
+                            .map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| if v.is_null() { String::new() } else { v.to_string() }))
+                            .unwrap_or_default();
+                        let multiline = key == "text";
+                        let r = if multiline {
+                            ui.add(egui::TextEdit::multiline(&mut s).desired_rows(4).desired_width(320.0)).labelled_by(label.id)
+                        } else {
+                            ui.add(egui::TextEdit::singleline(&mut s).desired_width(320.0)).labelled_by(label.id)
+                        };
+                        take_first_focus(d, &r);
+                        if r.changed() {
+                            d.values.insert(key.into(), json!(s));
+                        }
+                        if let Some(pick) = d.pick.as_mut().filter(|pick| pick.key == key) {
+                            track_pick(pick, &r, r.changed());
+                        }
+                    });
+                }
+                Field::Password { key, label } => {
+                    // Masked as typed (Excel shows dots); "Show password" reveals it on purpose.
+                    ui.vertical(|ui| {
+                        let label = ui.label(lang.tr(label));
+                        let mut s = d.values.get(key).and_then(Json::as_str).unwrap_or_default().to_string();
+                        if ui.add(egui::TextEdit::singleline(&mut s).password(!d.show_password).desired_width(320.0)).labelled_by(label.id).changed()
+                        {
+                            d.values.insert(key.into(), json!(s));
+                        }
+                        ui.checkbox(&mut d.show_password, lang.tr("Show password"));
+                    });
+                }
+                Field::Number { key, label } => {
+                    ui.horizontal(|ui| {
+                        let label = ui.label(lang.tr(label));
+                        let mut n = d.values.get(key).and_then(Json::as_f64).unwrap_or(0.0);
+                        // Typed values count straight away: otherwise Enter or OK in the same frame
+                        // confirms the old value, because a number field only commits when it loses focus.
+                        let r = ui.add(egui::DragValue::new(&mut n).speed(0.5).update_while_editing(true)).labelled_by(label.id);
+                        take_first_focus(d, &r);
+                        if r.changed() {
+                            d.values.insert(key.into(), json!(n));
+                        }
+                    });
+                }
+                Field::Choice { key, label, options } => {
+                    ui.vertical(|ui| {
+                        let field_label = ui.label(egui::RichText::new(lang.tr(label)).strong());
+                        let cur = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
+                        if d.name == "dataValidation" {
+                            let selected = options.iter().find(|(val, _)| *val == cur).map(|(_, text)| lang.tr(text)).unwrap_or("");
+                            egui::ComboBox::from_id_salt(("dataValidation", key))
+                                .selected_text(selected)
+                                .width(300.0)
+                                .show_ui(ui, |ui| {
+                                    for (val, text) in options {
+                                        if ui.selectable_label(cur == val, lang.tr(text)).clicked() {
+                                            d.set_value(key, json!(val));
+                                        }
+                                    }
+                                })
+                                .response
+                                .labelled_by(field_label.id);
+                        } else {
+                            for (val, text) in options {
+                                if ui.radio(cur == val, lang.tr(text)).clicked() {
+                                    d.set_value(key, json!(val));
+                                }
+                            }
+                        }
+                    });
+                }
+                Field::Check { key, label } => {
+                    let mut b = d.values.get(key).and_then(Json::as_bool).unwrap_or(false);
+                    if ui.checkbox(&mut b, lang.tr(label)).changed() {
+                        d.values.insert(key.into(), json!(b));
+                    }
+                }
+                Field::Note(t) => {
+                    // A note can carry user data (a URL, a file or sheet name); `tr` reads a `|` as a
+                    // context separator, so such a note is shown as it is.
+                    let text = if t.contains('|') { t.as_str() } else { lang.tr(&t) };
+                    ui.label(egui::RichText::new(text).small());
+                }
+            }
+            ui.end_row();
+        }
+    });
+}
diff --git a/crates/ui-egui/src/dialogs/spelling.rs b/crates/ui-egui/src/dialogs/spelling.rs
new file mode 100644
index 000000000..2a53b6d8a
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/spelling.rs
@@ -0,0 +1,54 @@
+use super::*;
+
+pub(super) fn spelling(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, open: &mut bool) {
+    let r = d.result.clone().unwrap_or(Json::Null);
+    if let Some(e) = r.get("error").and_then(Json::as_str) {
+        ui.label(app.ui.language.tr_error(e));
+        return;
+    }
+    let issues = r["issues"].as_array().cloned().unwrap_or_default();
+    let Some(it) = issues.get(d.list_index) else {
+        ui.label("The spelling check is complete for the entire sheet.");
+        if ui.button("OK").clicked() {
+            *open = false;
+        }
+        return;
+    };
+    let word = it["word"].as_str().unwrap_or("").to_string();
+    let cell = it["cell"].as_str().unwrap_or("").to_string();
+    ui.label(format!("Not in Dictionary ({cell}):"));
+    ui.label(egui::RichText::new(&word).strong().color(crate::theme::Tokens::get(ui.ctx()).danger));
+    let sugg: Vec<String> =
+        it["suggestions"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default();
+    ui.label("Suggestions:");
+    let mut pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
+    for s in &sugg {
+        if ui.selectable_label(pick == *s, s).clicked() {
+            pick = s.clone();
+        }
+    }
+    if sugg.is_empty() {
+        ui.label(egui::RichText::new("(No suggestions)").italics());
+    }
+    d.values.insert("pick".into(), json!(pick.clone()));
+    let _ = app.session.run("selection.set", json!({"cell": cell}));
+    ui.horizontal(|ui| {
+        if ui.button("Ignore Once").clicked() {
+            d.list_index += 1;
+        }
+        if ui.button("Add to Dictionary").clicked() {
+            let _ = app.session.run("review.addToDictionary", json!({"word": word}));
+            d.list_index += 1;
+        }
+        if !pick.is_empty() {
+            if ui.button("Change").clicked() {
+                app.run_or_alert("review.changeSpelling", json!({"cell": cell, "word": word, "to": pick}));
+                d.list_index += 1;
+            }
+            if ui.button("Change All").clicked() {
+                app.run_or_alert("review.changeSpelling", json!({"word": word, "to": pick, "all": true}));
+                d.list_index += 1;
+            }
+        }
+    });
+}
diff --git a/crates/ui-egui/src/dialogs/zoom.rs b/crates/ui-egui/src/dialogs/zoom.rs
new file mode 100644
index 000000000..a81b03b35
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/zoom.rs
@@ -0,0 +1,39 @@
+use super::show::ok_cancel;
+use super::*;
+
+/// Zoom's Magnification presets, as `preset` values and labels, in Excel's order.
+const ZOOM_PRESETS: [(&str, &str); 5] = [("200", "200%"), ("100", "100%"), ("75", "75%"), ("50", "50%"), ("25", "25%")];
+
+/// The `preset` that shows a zoom percentage: its Magnification entry, or Custom.
+pub(super) fn zoom_preset(percent: f64) -> &'static str {
+    ZOOM_PRESETS.iter().map(|(val, _)| *val).find(|val| val.parse::<f64>().ok() == Some(percent)).unwrap_or("custom")
+}
+
+/// View › Zoom, laid out as Excel's: one Magnification column of 200% to 25%, Fit selection and
+/// Custom with its percentage box. The current zoom is pre-selected; typing a percentage
+/// selects Custom; Fit selection zooms so the selected cells fill the grid.
+pub(super) fn zoom(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
+    let lang = crate::i18n::current(ui.ctx());
+    let cur = d.values.get("preset").and_then(Json::as_str).unwrap_or("custom").to_string();
+    ui.label(egui::RichText::new(lang.tr("Magnification")).strong());
+    for (val, text) in ZOOM_PRESETS {
+        if ui.radio(cur == val, text).clicked() {
+            d.set_value("preset", json!(val));
+        }
+    }
+    if ui.radio(cur == "fit", lang.tr("Fit selection")).clicked() {
+        d.set_value("preset", json!("fit"));
+    }
+    ui.horizontal(|ui| {
+        if ui.radio(cur == "custom", format!("{}:", lang.tr("Custom"))).clicked() {
+            d.set_value("preset", json!("custom"));
+        }
+        // Whole percentages, as Excel shows them; the engine clamps to 10..400 as well.
+        let mut percent = d.values.get("percent").and_then(Json::as_f64).unwrap_or(100.0).round() as i64;
+        if ui.add(egui::DragValue::new(&mut percent).range(10..=400).speed(1.0)).changed() {
+            d.set_value("percent", json!(percent));
+        }
+        ui.label("%");
+    });
+    ok_cancel(ui, confirm, open);
+}

From 0069d91e90cc9f437147bbf13ec340d7c159a640 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:18:14 +0000
Subject: [PATCH 49/76] refactor(engine): move cmd/edit.rs items to cmd/edit/

---
 crates/engine/src/cmd/edit.rs               | 1568 +------------------
 crates/engine/src/cmd/edit/cell.rs          |  287 ++++
 crates/engine/src/cmd/edit/clipboard.rs     |  269 ++++
 crates/engine/src/cmd/edit/fill.rs          |   96 ++
 crates/engine/src/cmd/edit/find.rs          |  184 +++
 crates/engine/src/cmd/edit/go_to.rs         |  199 +++
 crates/engine/src/cmd/edit/paste_special.rs |  351 +++++
 crates/engine/src/cmd/edit/selection.rs     |  171 ++
 8 files changed, 1584 insertions(+), 1541 deletions(-)
 create mode 100644 crates/engine/src/cmd/edit/cell.rs
 create mode 100644 crates/engine/src/cmd/edit/clipboard.rs
 create mode 100644 crates/engine/src/cmd/edit/fill.rs
 create mode 100644 crates/engine/src/cmd/edit/find.rs
 create mode 100644 crates/engine/src/cmd/edit/go_to.rs
 create mode 100644 crates/engine/src/cmd/edit/paste_special.rs
 create mode 100644 crates/engine/src/cmd/edit/selection.rs

diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 32164fb24..e48fe8838 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -8,6 +8,33 @@ use super::*;
 use crate::selection::{current_region, jump};
 use crate::{Clipboard, Session};
 
+mod cell;
+mod clipboard;
+mod fill;
+mod find;
+mod go_to;
+mod paste_special;
+mod selection;
+
+use cell::{cell_set, range_fill, range_set_values};
+pub(crate) use cell::{check_arg_counts, input_to_cell, json_to_input, parse_typed_formula};
+#[cfg(test)]
+pub(crate) use clipboard::parse_tsv;
+use clipboard::{clear_clipboard, copy, cut, paste};
+use fill::{auto_fill, fill_dir, fill_series, flash_fill};
+#[cfg(test)]
+use find::replace_ci;
+pub(crate) use find::wildcard;
+use find::{find, replace};
+pub(super) use go_to::go_to;
+pub use go_to::go_to_names;
+use go_to::go_to_special;
+#[cfg(test)]
+use go_to::{GO_TO_MAX_AREAS, GO_TO_RECENT, reference_parts};
+use paste_special::paste_special;
+pub(crate) use paste_special::rewrite_all_formulas;
+use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_set};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!("cell.set", "Enter Cell", [], None, "{cell?: \"B2\", input: \"text, number or =formula\", sheet?, array?: bool}", has_doc, cell_set),
@@ -116,657 +143,6 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-// ---------------------------------------------------------------- entry
-
-/// What typing `input` into a cell produces (constant or formula, plus an automatic number
-/// format). Inherits the destination's cell, row or column style, including its number
-/// format, before parsing. Errors when the formula can't be parsed.
-pub(crate) fn input_to_cell(input: &str, sheet: usize, at: CellRef, wb: &mut gridcraft_model::Workbook) -> Result<Option<Cell>> {
-    let style = wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
-    if input.is_empty() {
-        let c = Cell { value: Value::Empty, formula: None, style };
-        return Ok(if c.is_blank() { None } else { Some(c) });
-    }
-    let fmt_is_text = wb.styles.get(style).num_fmt.as_str() == "@";
-    if fmt_is_text {
-        return Ok(Some(Cell { value: Value::text(input), formula: None, style }));
-    }
-    let is_formula = input.starts_with('=')
-        || (input.len() > 1
-            && (input.starts_with('+') || input.starts_with('-'))
-            && gridcraft_core::parse::parse_number_text(input).is_none()
-            && input.chars().nth(1).is_some_and(|c| c.is_ascii_alphabetic() || c == '('));
-    if is_formula {
-        let body = input.strip_prefix('=').unwrap_or(input);
-        let expr = wb.name_call_case(parse_typed_formula(body)?);
-        check_arg_counts(&expr)?;
-        let mut cell = Cell::formula(Formula::from_expr(expr));
-        cell.style = style;
-        // Formulas whose result is a date/time get a format from functions like TODAY().
-        if wb.styles.get(style).num_fmt.as_str() == "General" {
-            let f = cell.formula.as_ref().map(|f| f.text.to_ascii_uppercase()).unwrap_or_default();
-            let auto = if f.starts_with("TODAY(")
-                || f.starts_with("DATE(")
-                || f.starts_with("EDATE(")
-                || f.starts_with("EOMONTH(")
-                || f.starts_with("WORKDAY(")
-            {
-                Some("m/d/yyyy")
-            } else if f.starts_with("NOW(") {
-                Some("m/d/yyyy h:mm")
-            } else if f.starts_with("TIME(") {
-                Some("h:mm AM/PM")
-            } else {
-                None
-            };
-            if let Some(code) = auto {
-                cell.style = wb.styles.derive(style, |s| s.num_fmt = gridcraft_model::NumFmt::new(code));
-            }
-        }
-        return Ok(Some(cell));
-    }
-    let mut parsed = gridcraft_core::parse::parse_input(input, wb.date_system);
-    // Like Excel's automatic percent entry: a bare number of 1 or more typed into a cell already
-    // formatted as a percentage is a percent (3 -> 3%); smaller numbers are taken as fractions.
-    if parsed.format.is_none()
-        && !input.contains('%')
-        && wb.styles.get(style).num_fmt.as_str().ends_with('%')
-        && let Value::Number(n) = parsed.value
-        && n.abs() >= 1.0
-    {
-        parsed.value = Value::Number(n / 100.0);
-    }
-    let mut style = style;
-    if let Some(code) = parsed.format {
-        let cur = wb.styles.get(style).num_fmt.as_str().to_string();
-        if cur == "General" {
-            style = wb.styles.derive(style, |s| s.num_fmt = gridcraft_model::NumFmt::new(code));
-        }
-    }
-    // Wrap text automatically when the input has line breaks (Alt+Enter).
-    if input.contains('\n') && !wb.styles.get(style).align.wrap {
-        style = wb.styles.derive(style, |s| s.align.wrap = true);
-    }
-    Ok(Some(Cell { value: parsed.value, formula: None, style }))
-}
-
-/// Parses a formula as it is typed (without the `=`). Excel closes missing parentheses for you,
-/// and refuses a formula that still doesn't parse.
-pub(crate) fn parse_typed_formula(body: &str) -> Result<gridcraft_formula::Expr> {
-    // Excel closes missing parentheses for you.
-    let parsed = gridcraft_formula::parse_closing_parens(body, gridcraft_formula::parse);
-    parsed.map_err(|e| EngineError::Other(format!("There's a problem with this formula: {e}")))
-}
-
-/// Like Excel, a formula that calls a built-in function with too few or too many arguments is
-/// refused when it's entered, rather than stored to show `#VALUE!`. Functions the registry doesn't
-/// hold (special forms like LET, LAMBDA, OFFSET, INDIRECT, SUBTOTAL), defined LAMBDA names and
-/// unknown functions are skipped.
-pub(crate) fn check_arg_counts(expr: &gridcraft_formula::Expr) -> Result<()> {
-    let mut bad = None;
-    expr.walk(&mut |e| {
-        if bad.is_none()
-            && let gridcraft_formula::Expr::Call(name, args) = e
-            && let Some(spec) = gridcraft_functions::lookup(name)
-            && !spec.accepts(args.len())
-        {
-            let few = args.len() < spec.min_args;
-            bad = Some(format!("{} has too {} arguments. Use {}", spec.name, if few { "few" } else { "many" }, spec.signature));
-        }
-    });
-    match bad {
-        Some(msg) => Err(EngineError::Other(msg)),
-        None => Ok(()),
-    }
-}
-
-fn cell_set(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = match cell_param_on(s, p, "cell", sheet)? {
-        Some(c) => c,
-        None => s.doc()?.selection.active,
-    };
-    // Both spellings take a string, number or boolean, as typed (#697).
-    let input = p.get("input").or_else(|| p.get("value")).map(json_to_input).ok_or_else(|| bad("cell.set", "missing `input` (or `value`)"))?;
-    let array = bool_param(p, "array").unwrap_or(false);
-    let d = s.doc()?;
-    if let Some(sh) = d.wb.sheet(sheet)
-        && sh.is_protected()
-        && d.wb.styles.get(sh.style_id(at)).protection.locked
-        && let Some(m) = locked_cell_error(sh, at, &d.unlocked_ranges)
-    {
-        return Err(EngineError::Other(m));
-    }
-    let active_sheet = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        if array {
-            // Legacy Ctrl+Shift+Enter array formula over the selection, when the selection holds
-            // the cell; a cell elsewhere (or on another sheet) gets a one-cell array.
-            let selected = cx.sel.current();
-            let range = if sheet == active_sheet && selected.contains(at) { selected } else { RangeRef::cell(at) };
-            // A table header can't hold an array's value, and a table resizes under it.
-            if !range.is_single() && cx.wb.sheet(sheet).is_some_and(|sh| sh.tables.iter().any(|t| t.range.intersects(&range))) {
-                return Err(EngineError::Other("Multi-cell array formulas aren't allowed in tables.".into()));
-            }
-            let mut cell = input_to_cell(&input, sheet, range.start, &mut cx.wb)?.unwrap_or_default();
-            if let Some(f) = cell.formula.as_mut() {
-                std::sync::Arc::make_mut(f).array = Some(range);
-            }
-            let sh = cx.sheet_mut(sheet)?;
-            // The array takes the whole range: other cells in it lose their contents.
-            for c in range.iter().skip(1).take(1_000_000) {
-                if let Some(old) = sh.cells.get(c).filter(|x| !x.value.is_empty() || x.formula.is_some()) {
-                    let style = old.style;
-                    sh.set_cell(c, Cell { style, ..Cell::default() });
-                }
-            }
-            sh.set_cell(range.start, cell);
-            cx.touch(sheet, range.start);
-            return Ok(Json::Null);
-        }
-        let cell = input_to_cell(&input, sheet, at, &mut cx.wb)?;
-        let sh = cx.sheet_mut(sheet)?;
-        match cell {
-            Some(c) => sh.set_cell(at, c),
-            None => {
-                sh.remove_cell(at);
-            }
-        }
-        super::data::grow_autofilter(sh, at);
-        cx.touch(sheet, at);
-        Ok(Json::Null)
-    })?;
-    let v = s.doc()?.wb.sheet(sheet).map(|sh| sh.value(at)).unwrap_or_default();
-    Ok(json!({"cell": at.a1(), "value": v.display()}))
-}
-
-pub(crate) fn json_to_input(v: &Json) -> String {
-    match v {
-        Json::Null => String::new(),
-        Json::Bool(b) => {
-            if *b {
-                "TRUE".into()
-            } else {
-                "FALSE".into()
-            }
-        }
-        Json::Number(n) => n.to_string(),
-        Json::String(s) => s.clone(),
-        other => other.to_string(),
-    }
-}
-
-fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let start = target_range(s, p)?.start;
-    let Some(rows) = p.get("values").and_then(Json::as_array) else { return Err(bad("range.setValues", "missing `values` (array of rows)")) };
-    // A string is run through typed input by default, which reads it with en-US rules: a caller
-    // sending "05.04.2026" from a dd.mm.yyyy export got 4 May, and "2.500" became 2.5, in silence
-    // (#2255). `parse: false` stores a string as the text it is; numbers, booleans and formulas
-    // are unaffected either way.
-    let parse = match p.get("parse") {
-        None | Some(Json::Null) => true,
-        Some(Json::Bool(b)) => *b,
-        Some(other) => return Err(bad("range.setValues", format!("parse {other}: true or false"))),
-    };
-    if rows.len() > MAX_ROWS as usize {
-        return Err(bad("range.setValues", "too many rows"));
-    }
-    let mut count = 0;
-    edit(s, |cx| {
-        for (ri, row) in rows.iter().enumerate() {
-            let cols: Vec<&Json> = match row.as_array() {
-                Some(a) => a.iter().collect(),
-                None => vec![row],
-            };
-            for (ci, v) in cols.iter().enumerate() {
-                let Some(at) = start.offset(ri as i64, ci as i64) else { continue };
-                let input = json_to_input(v);
-                let cell = match v {
-                    Json::Number(n) => Some(Cell {
-                        value: Value::number(n.as_f64().unwrap_or(0.0)),
-                        formula: None,
-                        style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(),
-                    }),
-                    Json::Bool(b) => {
-                        Some(Cell { value: Value::Bool(*b), formula: None, style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default() })
-                    }
-                    // Text as given: no date or number reading, and a leading `'` is part of the
-                    // text rather than the marker that makes it text. A formula is still a
-                    // formula, which is what the ticket asks for and what `=` means in a cell.
-                    Json::String(text) if !parse && !text.starts_with('=') => {
-                        let mut style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
-                        // Line breaks still turn on Wrap Text, as typed input does.
-                        if text.contains('\n') && !cx.wb.styles.get(style).align.wrap {
-                            style = cx.wb.styles.derive(style, |s| s.align.wrap = true);
-                        }
-                        Some(Cell { value: Value::Text(text.as_str().into()), formula: None, style })
-                    }
-                    _ => input_to_cell(&input, sheet, at, &mut cx.wb)?,
-                };
-                let sh = cx.sheet_mut(sheet)?;
-                match cell {
-                    Some(c) => sh.set_cell(at, c),
-                    None => {
-                        sh.remove_cell(at);
-                    }
-                }
-                super::data::grow_autofilter(sh, at);
-                cx.touch(sheet, at);
-                count += 1;
-            }
-        }
-        Ok(())
-    })?;
-    Ok(json!({"cells": count}))
-}
-
-fn range_fill(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let ranges = target_ranges(s, p)?;
-    let input = str_param(p, "input").unwrap_or("").to_string();
-    let origin = s.doc()?.selection.active;
-    edit(s, |cx| {
-        // Each cell gets what typing the input there gives: the automatic number format where
-        // it's General, its own format otherwise, text where it's Text. That depends only on
-        // the cell's style, so the input is parsed once per style.
-        let mut by_style: std::collections::HashMap<StyleId, Option<Cell>> = std::collections::HashMap::new();
-        for r in &ranges {
-            if r.count() > 2_000_000 {
-                return Err(bad("range.fill", "range too large"));
-            }
-            for at in r.iter() {
-                let style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
-                let base = match by_style.get(&style) {
-                    Some(c) => c.clone(),
-                    None => {
-                        let c = input_to_cell(&input, sheet, at, &mut cx.wb)?;
-                        by_style.insert(style, c.clone());
-                        c
-                    }
-                };
-                let mut cell = base.unwrap_or_default();
-                if let Some(f) = &cell.formula
-                    && let Some(e) = f.expr()
-                {
-                    let shifted = gridcraft_formula::adjust::shift_relative(e, at.row as i64 - origin.row as i64, at.col as i64 - origin.col as i64);
-                    cell.formula = Some(std::sync::Arc::new(Formula::from_expr(shifted)));
-                }
-                let sh = cx.sheet_mut(sheet)?;
-                sh.set_cell(at, cell);
-                super::data::grow_autofilter(sh, at);
-                cx.touch(sheet, at);
-            }
-        }
-        Ok(Json::Null)
-    })
-}
-
-// ---------------------------------------------------------------- selection
-
-/// Whether the cell may be selected: a protected sheet can forbid selecting locked and/or unlocked cells.
-fn cell_selectable(wb: &gridcraft_model::Workbook, sheet: &gridcraft_model::Sheet, c: CellRef) -> bool {
-    let Some(p) = sheet.protection.as_ref() else { return true };
-    if wb.styles.get(sheet.style_id(c)).protection.locked { p.select_locked } else { p.select_unlocked }
-}
-
-fn selection_set(s: &mut Session, p: &Json) -> Result<Json> {
-    if p.get("sheet").is_some() {
-        let i = target_sheet(s, p)?;
-        s.doc_mut()?.wb_switch_sheet(i);
-    } else if let Some(r) = str_param(p, "range").or_else(|| str_param(p, "cell"))
-        && let (Some(_), _) = split_sheet(r)
-    {
-        let i = target_sheet(s, p)?;
-        s.doc_mut()?.wb_switch_sheet(i);
-    }
-    let ranges = target_ranges(s, p)?;
-    let active = cell_param(s, p, "active")?;
-    let d = s.doc_mut()?;
-    let active = active.or_else(|| ranges.last().map(|r| r.start)).unwrap_or_default();
-    let mut sel = crate::Selection { active, anchor: ranges.last().map(|r| r.start).unwrap_or(active), ranges };
-    if let Some(sh) = d.wb.active() {
-        sel.expand_merges(sh);
-        if !cell_selectable(&d.wb, sh, sel.active) {
-            return Err(EngineError::Other("The cell you are trying to change is on a protected sheet that does not allow selecting it.".into()));
-        }
-    }
-    d.selection = sel;
-    Ok(json!({"selection": d.selection.a1(), "active": d.selection.active.a1()}))
-}
-
-impl crate::DocState {
-    /// Switches the active sheet, remembering each sheet's selection.
-    pub fn wb_switch_sheet(&mut self, i: usize) {
-        if i >= self.wb.sheets.len() || i == self.wb.active_sheet() {
-            return;
-        }
-        let cur = self.wb.active_sheet();
-        if self.sheet_selections.len() < self.wb.sheets.len() {
-            self.sheet_selections.resize(self.wb.sheets.len(), crate::Selection::default());
-        }
-        if let Some(slot) = self.sheet_selections.get_mut(cur) {
-            *slot = self.selection.clone();
-        }
-        // View state: set in place, so the workbook is neither copied nor made dirty.
-        self.wb.set_active_sheet(i);
-        self.selection = self.sheet_selections.get(i).cloned().unwrap_or_default();
-    }
-}
-
-fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
-    let dr = p.get("dr").and_then(Json::as_i64).unwrap_or(0);
-    let dc = p.get("dc").and_then(Json::as_i64).unwrap_or(0);
-    let extend = bool_param(p, "extend").unwrap_or(false);
-    let jmp = bool_param(p, "jump").unwrap_or(false);
-    let d = s.doc_mut()?;
-    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
-    let sel = &mut d.selection;
-    // Extension moves the far corner, not the active cell.
-    let from = if extend { sel.moving_end() } else { sel.active };
-    // Skip hidden rows/columns and step over merged areas.
-    let mut to = if jmp {
-        jump(sheet, from, dr.signum(), dc.signum())
-    } else {
-        let mut t = from.offset_clamped(dr, dc);
-        let mut guard = 0;
-        while (sheet.is_row_hidden(t.row) || sheet.is_col_hidden(t.col)) && guard < 100_000 {
-            let n = t.offset_clamped(dr.signum(), dc.signum());
-            if n == t {
-                break;
-            }
-            t = n;
-            guard += 1;
-        }
-        if !extend && let Some(m) = sheet.merge_at(from) {
-            // Leaving a merged cell moves from its edge.
-            if dr > 0 {
-                t = CellRef::new(m.end.offset_clamped(dr, 0).row, from.col);
-            } else if dc > 0 {
-                t = CellRef::new(from.row, m.end.offset_clamped(0, dc).col);
-            }
-        }
-        t
-    };
-    if let Some(m) = sheet.merge_at(to)
-        && !extend
-    {
-        to = m.start;
-    }
-    if !extend && !cell_selectable(&d.wb, sheet, to) {
-        // Step on to the next selectable cell in the same direction; stay put if there is none.
-        let (sr, sc) = (dr.signum(), dc.signum());
-        let mut t = to;
-        let mut found = false;
-        if !jmp && (sr, sc) != (0, 0) {
-            for _ in 0..10_000 {
-                let n = t.offset_clamped(sr, sc);
-                if n == t {
-                    break;
-                }
-                t = n;
-                if !sheet.is_row_hidden(t.row) && !sheet.is_col_hidden(t.col) && cell_selectable(&d.wb, sheet, t) {
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if !found {
-            return Ok(json!({"selection": sel.a1(), "active": sel.active.a1()}));
-        }
-        to = t;
-    }
-    if extend {
-        sel.extend_to(to);
-        sel.expand_merges(sheet);
-    } else {
-        *sel = crate::Selection::at(to);
-        if let Some(m) = sheet.merge_at(to) {
-            sel.ranges = vec![m];
-        }
-    }
-    Ok(json!({"selection": sel.a1(), "active": sel.active.a1()}))
-}
-
-fn selection_next(s: &mut Session, p: &Json) -> Result<Json> {
-    let fwd = bool_param(p, "forward").unwrap_or(true);
-    let by_row = bool_param(p, "byRow").unwrap_or(false);
-    let d = s.doc_mut()?;
-    d.selection.cycle(fwd, by_row);
-    Ok(json!({"active": d.selection.active.a1()}))
-}
-
-fn select_all(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc_mut()?;
-    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
-    let region = current_region(sheet, d.selection.active);
-    let all = RangeRef::all();
-    let r = if region.is_single() || d.selection.current() == region { all } else { region };
-    let active = d.selection.active;
-    d.selection = crate::Selection { active, anchor: r.start, ranges: vec![r] };
-    Ok(json!({"selection": d.selection.a1()}))
-}
-
-fn select_region(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc_mut()?;
-    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
-    let r = current_region(sheet, d.selection.active);
-    let active = d.selection.active;
-    d.selection = crate::Selection { active, anchor: r.start, ranges: vec![r] };
-    Ok(json!({"selection": d.selection.a1()}))
-}
-
-fn select_row(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc_mut()?;
-    let r = d.selection.current();
-    let active = d.selection.active;
-    d.selection = crate::Selection { active, anchor: CellRef::new(r.start.row, 0), ranges: vec![RangeRef::rows(r.start.row, r.end.row)] };
-    Ok(json!({"selection": d.selection.a1()}))
-}
-
-fn select_col(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc_mut()?;
-    let r = d.selection.current();
-    let active = d.selection.active;
-    d.selection = crate::Selection { active, anchor: CellRef::new(0, r.start.col), ranges: vec![RangeRef::cols(r.start.col, r.end.col)] };
-    Ok(json!({"selection": d.selection.a1()}))
-}
-
-/// How many references the Go To dialog keeps for going back to.
-const GO_TO_RECENT: usize = 10;
-/// The most areas one Go To selects.
-const GO_TO_MAX_AREAS: usize = 2000;
-/// How deep a name that refers to other names is followed.
-const GO_TO_NAME_DEPTH: usize = 8;
-
-pub(super) fn go_to(s: &mut Session, p: &Json) -> Result<Json> {
-    if bool_param(p, "list") == Some(true) {
-        let d = s.doc()?;
-        return Ok(json!({"names": go_to_names(&d.wb, d.wb.active_sheet()), "recent": d.go_to_recent}));
-    }
-    let Some(reference) = str_param(p, "reference").or_else(|| str_param(p, "range")) else { return Err(bad("edit.goTo", "missing `reference`")) };
-    let d = s.doc()?;
-    let mut target: Option<usize> = None;
-    let mut areas: Vec<RangeRef> = Vec::new();
-    let mut named = false;
-    for part in reference_parts(reference) {
-        let Some((sheet, found, by_name)) = go_to_target(&d.wb, d.wb.active_sheet(), part, 0) else {
-            return Err(EngineError::Other("Reference isn't valid.".into()));
-        };
-        // One selection holds the areas of one sheet.
-        if target.is_some_and(|t| t != sheet) {
-            return Err(EngineError::Other("Reference isn't valid.".into()));
-        }
-        target = Some(sheet);
-        named |= by_name;
-        areas.extend(found);
-        if areas.len() > GO_TO_MAX_AREAS {
-            return Err(EngineError::Other(format!("Go To selects at most {GO_TO_MAX_AREAS} areas.")));
-        }
-    }
-    let Some(sheet) = target else { return Err(EngineError::Other("Reference isn't valid.".into())) };
-    let range = areas.iter().map(RangeRef::a1).collect::<Vec<_>>().join(",");
-    let out = selection_set(s, &json!({"sheet": sheet, "range": range}))?;
-    if bool_param(p, "record") == Some(true) && !named {
-        let d = s.doc_mut()?;
-        let prefix = gridcraft_core::quote_sheet(&d.wb.sheet(sheet).map(|sh| sh.name.clone()).unwrap_or_default());
-        let entry = areas.iter().map(|r| format!("{prefix}!{}", r.a1())).collect::<Vec<_>>().join(",");
-        d.go_to_recent.retain(|r| !r.eq_ignore_ascii_case(&entry));
-        d.go_to_recent.insert(0, entry);
-        d.go_to_recent.truncate(GO_TO_RECENT);
-    }
-    Ok(out)
-}
-
-/// The parts of a Go To reference, split at the commas outside quoted sheet names and
-/// parentheses: `Price, Type` or `B14:C22,F19:G30`. The parts are read one at a time, so a caller
-/// that stops at an invalid part or at `GO_TO_MAX_AREAS` does not split the rest of the text.
-fn reference_parts(text: &str) -> impl Iterator<Item = &str> {
-    let (mut depth, mut quoted, mut start, mut done) = (0usize, false, 0, false);
-    let mut chars = text.char_indices();
-    std::iter::from_fn(move || {
-        if done {
-            return None;
-        }
-        for (i, c) in chars.by_ref() {
-            match c {
-                '\'' => quoted = !quoted,
-                '(' if !quoted => depth += 1,
-                ')' if !quoted => depth = depth.saturating_sub(1),
-                ',' if !quoted && depth == 0 => {
-                    let part = text.get(start..i).unwrap_or("").trim();
-                    start = i + 1;
-                    return Some(part);
-                }
-                _ => {}
-            }
-        }
-        done = true;
-        Some(text.get(start..).unwrap_or("").trim())
-    })
-}
-
-/// Where one part of a Go To reference points, seen from sheet `sheet`: the sheet, its areas,
-/// and whether a defined name or a table gave them. `Sheet2!Name` is the name scoped to Sheet2.
-/// A name counts when what it refers to is a reference; a constant or a formula is not one.
-fn go_to_target(wb: &gridcraft_model::Workbook, sheet: usize, part: &str, depth: usize) -> Option<(usize, Vec<RangeRef>, bool)> {
-    if part.is_empty() || depth > GO_TO_NAME_DEPTH {
-        return None;
-    }
-    let (prefix, body) = split_sheet(part);
-    let on = match &prefix {
-        Some(n) => wb.sheet_index(n)?,
-        None => sheet,
-    };
-    if let Some(r) = RangeRef::parse(&body.replace('$', "")) {
-        return Some((on, vec![r], false));
-    }
-    let name = match prefix {
-        Some(_) => wb.names.iter().find(|n| n.scope == Some(on) && gridcraft_formula::same_name(&n.name, body)),
-        None => wb.name(body, sheet),
-    };
-    if let Some(n) = name {
-        return name_areas(wb, n, sheet, depth).map(|(t, areas)| (t, areas, true));
-    }
-    if prefix.is_none()
-        && let Some((si, ti)) = wb.table(body)
-    {
-        // As in Excel, a table's name stands for its data, without the header and totals rows.
-        let t = wb.sheet(si)?.tables.get(ti)?;
-        return Some((si, vec![t.data_range().unwrap_or(t.range)], true));
-    }
-    None
-}
-
-/// The sheet and areas defined name `n` refers to, seen from sheet `sheet`, when that is a
-/// reference.
-fn name_areas(wb: &gridcraft_model::Workbook, n: &gridcraft_model::DefinedName, sheet: usize, depth: usize) -> Option<(usize, Vec<RangeRef>)> {
-    let from = n.scope.unwrap_or(sheet);
-    let formula = n.formula.trim().trim_start_matches('=');
-    let mut target: Option<usize> = None;
-    let mut areas = Vec::new();
-    for p in reference_parts(formula) {
-        let (s, found, _) = go_to_target(wb, from, p, depth + 1)?;
-        if target.is_some_and(|t| t != s) {
-            return None;
-        }
-        target = Some(s);
-        areas.extend(found);
-        if areas.len() > GO_TO_MAX_AREAS {
-            return None;
-        }
-    }
-    target.map(|t| (t, areas))
-}
-
-/// The names the Go To dialog lists, seen from sheet `sheet`: the named ranges of the workbook and
-/// of every sheet, in alphabetical order. A name scoped to another sheet is written `Sheet2!Name`,
-/// and the active sheet's own name hides the workbook name it shares. Hidden names and names that
-/// do not refer to a range are left out.
-pub fn go_to_names(wb: &gridcraft_model::Workbook, sheet: usize) -> Vec<String> {
-    let own: std::collections::HashSet<String> =
-        wb.names.iter().filter(|n| n.scope == Some(sheet)).map(|n| gridcraft_formula::fold_name(&n.name)).collect();
-    let mut out: Vec<String> = wb
-        .names
-        .iter()
-        .filter(|n| !n.hidden && name_areas(wb, n, sheet, 0).is_some())
-        .filter_map(|n| match n.scope {
-            None if own.contains(&gridcraft_formula::fold_name(&n.name)) => None,
-            None => Some(n.name.clone()),
-            Some(s) if s == sheet => Some(n.name.clone()),
-            Some(s) => Some(format!("{}!{}", gridcraft_core::quote_sheet(&wb.sheet(s)?.name), n.name)),
-        })
-        .collect();
-    out.sort_by_cached_key(|n| gridcraft_formula::fold_name(n));
-    out.dedup_by(|a, b| gridcraft_formula::same_name(a, b));
-    out
-}
-
-fn go_to_special(s: &mut Session, p: &Json) -> Result<Json> {
-    let kind = str_param(p, "kind").unwrap_or("blanks");
-    let d = s.doc()?;
-    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
-    let scope = if d.selection.is_single_cell() { sheet.used_range().unwrap_or(RangeRef::cell(d.selection.active)) } else { d.selection.bounds() };
-    if kind == "lastCell" {
-        let c = sheet.used_range().map(|r| r.end).unwrap_or_default();
-        return selection_set(s, &json!({"cell": c.a1()}));
-    }
-    if kind == "currentRegion" {
-        return select_region(s, &json!({}));
-    }
-    let mut hits: Vec<CellRef> = Vec::new();
-    if scope.count() > 4_000_000 {
-        return Err(bad("edit.goToSpecial", "range too large"));
-    }
-    for c in scope.iter() {
-        let cell = sheet.cell(c);
-        let v = sheet.value(c);
-        let ok = match kind {
-            "blanks" => v.is_empty(),
-            "constants" => cell.is_some_and(|x| x.formula.is_none() && !x.value.is_empty()),
-            "formulas" => cell.is_some_and(|x| x.formula.is_some()),
-            "comments" | "notes" => sheet.comments.contains_key(&c),
-            "errors" => v.is_error(),
-            "numbers" => v.is_number(),
-            "text" => v.is_text(),
-            "visible" => !sheet.is_row_hidden(c.row) && !sheet.is_col_hidden(c.col),
-            "conditionalFormats" => sheet.cond_formats.iter().any(|cf| cf.ranges.iter().any(|r| r.contains(c))),
-            "dataValidation" => sheet.validations.iter().any(|dv| dv.ranges.iter().any(|r| r.contains(c))),
-            _ => return Err(bad("edit.goToSpecial", format!("unknown kind `{kind}`"))),
-        };
-        if ok {
-            hits.push(c);
-        }
-    }
-    if hits.is_empty() {
-        return Err(EngineError::Other("No cells were found.".into()));
-    }
-    let ranges = coalesce(&hits);
-    let d = s.doc_mut()?;
-    d.selection = crate::Selection { active: hits[0], anchor: hits[0], ranges };
-    Ok(json!({"selection": d.selection.a1(), "count": hits.len()}))
-}
-
 /// Merges cells into vertical runs per column (a compact multi-area selection).
 fn coalesce(cells: &[CellRef]) -> Vec<RangeRef> {
     let mut sorted = cells.to_vec();
@@ -832,619 +208,6 @@ fn redo(s: &mut Session, p: &Json) -> Result<Json> {
     Ok(json!({"redone": label}))
 }
 
-// ---------------------------------------------------------------- clipboard
-
-fn copy_impl(s: &mut Session, p: &Json, cut: bool) -> Result<Json> {
-    let multiple = || EngineError::Other("This action won't work on multiple selections.".into());
-    let sheet = target_sheet(s, p)?;
-    let ranges = target_ranges(s, p)?;
-    if ranges.len() > 1 && cut {
-        return Err(multiple());
-    }
-    // The selection as made (untrimmed), for Insert Copied Cells.
-    let selected = ranges.first().copied().unwrap_or_default();
-    let d = s.doc()?;
-    let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
-    let trim = |range: RangeRef| {
-        if range.is_full_cols() || range.is_full_rows() {
-            let used = sh.used_range().unwrap_or(RangeRef::cell(range.start));
-            range.intersection(&used.union(&RangeRef::cell(range.start))).unwrap_or(range)
-        } else {
-            range
-        }
-    };
-    let (wb, range, areas) = if ranges.len() > 1 {
-        let areas: Vec<RangeRef> = ranges.iter().map(|r| trim(*r)).collect();
-        let (wb, block) = slide_together(&d.wb, sheet, &areas).ok_or_else(multiple)?;
-        (std::sync::Arc::new(wb), block, areas)
-    } else {
-        (d.wb.clone(), trim(ranges.first().copied().unwrap_or_default()), Vec::new())
-    };
-    let text = crate::display::range_text(&wb, sheet, range);
-    // The HTML rendering is for the host clipboard (UI); it can reach 4 MB, so agents and
-    // scripts get it only when they ask for it.
-    let html = if p.get("html").and_then(Json::as_bool) == Some(true) { crate::io::range_html(&wb, sheet, range, &text) } else { None };
-    let clip = Clipboard { wb, sheet, range, cut, doc_uid: d.uid, text: text.clone(), areas, selected, trust: d.trust };
-    s.clipboard = Some(clip);
-    let mut result = json!({"range": range.a1(), "text": text});
-    if let Some(html) = html {
-        result["html"] = Json::String(html);
-    }
-    Ok(result)
-}
-
-/// Excel copies a multi-area selection only when the areas line up: all cover the same rows (they
-/// slide together side by side, left to right) or all cover the same columns (stacked, top to
-/// bottom), without overlapping. Returns a copy of the workbook whose sheet holds the areas packed
-/// into one block at the first area's place, and that block. Formulas travel as their values, as
-/// in Excel. `None` when the areas don't line up.
-fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRef]) -> Option<(gridcraft_model::Workbook, RangeRef)> {
-    let first = *areas.first()?;
-    let across = areas.iter().all(|a| a.start.row == first.start.row && a.end.row == first.end.row);
-    let down = areas.iter().all(|a| a.start.col == first.start.col && a.end.col == first.end.col);
-    let mut sorted = areas.to_vec();
-    if across {
-        sorted.sort_by_key(|a| a.start.col);
-    } else if down {
-        sorted.sort_by_key(|a| a.start.row);
-    } else {
-        return None;
-    }
-    if sorted.windows(2).any(|w| matches!(w, [a, b] if a.intersects(b))) {
-        return None;
-    }
-    let anchor = sorted.first()?.start;
-    let (h, w) = if across {
-        (first.height(), sorted.iter().map(RangeRef::width).fold(0u32, u32::saturating_add))
-    } else {
-        (sorted.iter().map(RangeRef::height).fold(0u32, u32::saturating_add), first.width())
-    };
-    let block = RangeRef::new(anchor, anchor.offset(i64::from(h) - 1, i64::from(w) - 1)?);
-    let src = wb.sheet(sheet)?;
-    let mut out = wb.clone();
-    let dst = out.sheet_mut(sheet)?;
-    dst.take_cells(block);
-    dst.spill.retain(|c, _| !block.contains(*c));
-    dst.spill_ranges.retain(|c, _| !block.contains(*c));
-    dst.comments.retain(|c, _| !block.contains(*c));
-    dst.merges.retain(|m| !m.intersects(&block));
-    if across {
-        dst.cols.retain(|c, _| !(block.start.col..=block.end.col).contains(c));
-    } else {
-        dst.rows.retain(|r, _| !(block.start.row..=block.end.row).contains(r));
-    }
-    let mut next = if across { anchor.col } else { anchor.row };
-    for a in &sorted {
-        let (dr, dc) = if across { (0, i64::from(next) - i64::from(a.start.col)) } else { (i64::from(next) - i64::from(a.start.row), 0) };
-        let cells = src.cells.iter_range(*a).map(|(c, _)| c).chain(src.spill.keys().copied().filter(|c| a.contains(*c)));
-        for c in cells {
-            let Some(to) = c.offset(dr, dc) else { continue };
-            let style = src.cell(c).map(|x| x.style).unwrap_or_default();
-            dst.set_cell(to, Cell { value: src.value(c), formula: None, style });
-            if let Some(picture) = src.cell_pictures.get(&c) {
-                dst.cell_pictures.insert(to, picture.clone());
-            }
-        }
-        for (c, comment) in src.comments.iter().filter(|(c, _)| a.contains(**c)) {
-            if let Some(to) = c.offset(dr, dc) {
-                dst.comments.insert(to, comment.clone());
-            }
-        }
-        for m in src.merges.iter().filter(|m| a.contains_range(m)) {
-            if let (Some(s), Some(e)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
-                dst.merges.push(RangeRef::new(s, e));
-            }
-        }
-        // Column widths (side by side) or row heights and hidden rows (stacked) follow their cells.
-        if across {
-            for (c, info) in src.cols.range(a.start.col..=a.end.col) {
-                dst.cols.insert(next.saturating_add(c.saturating_sub(a.start.col)), *info);
-            }
-        } else {
-            for (r, info) in src.rows.range(a.start.row..=a.end.row) {
-                dst.rows.insert(next.saturating_add(r.saturating_sub(a.start.row)), *info);
-            }
-        }
-        next = next.saturating_add(if across { a.width() } else { a.height() });
-    }
-    Some((out, block))
-}
-
-fn copy(s: &mut Session, p: &Json) -> Result<Json> {
-    copy_impl(s, p, false)
-}
-fn cut(s: &mut Session, p: &Json) -> Result<Json> {
-    copy_impl(s, p, true)
-}
-fn clear_clipboard(s: &mut Session, _: &Json) -> Result<Json> {
-    s.clipboard = None;
-    s.format_painter = None;
-    ok()
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum What {
-    All,
-    Formulas,
-    Values,
-    Formats,
-    Comments,
-    Validation,
-    AllExceptBorders,
-    ColumnWidths,
-    FormulasAndNumberFormats,
-    ValuesAndNumberFormats,
-}
-
-fn paste(s: &mut Session, p: &Json) -> Result<Json> {
-    // External text (from the system clipboard) when it differs from ours.
-    if let Some(text) = str_param(p, "text")
-        && s.clipboard.as_ref().is_none_or(|c| c.text.trim_end_matches(['\r', '\n']) != text.trim_end_matches(['\r', '\n']))
-    {
-        return paste_text(s, p, text);
-    }
-    if s.clipboard.is_none() {
-        return Err(EngineError::Other("Nothing to paste.".into()));
-    }
-    paste_special(s, &json!({"what": "all", "at": p.get("at").cloned().unwrap_or(Json::Null)}))
-}
-
-fn paste_text(s: &mut Session, p: &Json, text: &str) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let at = cell_param_on(s, p, "at", sheet)?.unwrap_or(s.doc()?.selection.current().start);
-    let rows: Vec<Vec<String>> = parse_tsv(text);
-    let h = rows.len();
-    let w = rows.iter().map(Vec::len).max().unwrap_or(0);
-    // The HTML flavour, when the host passed it: the number behind each cell's shown text. Read
-    // only as far as the text's own shape, so spans in the markup can't expand without bound.
-    let html = str_param(p, "html").map(|html| crate::clip_html::table_cells(html, h, w)).unwrap_or_default();
-    edit(s, |cx| {
-        for (ri, row) in rows.iter().enumerate() {
-            for (ci, v) in row.iter().enumerate() {
-                let Some(c) = at.offset(ri as i64, ci as i64) else { continue };
-                let mut cell = input_to_cell(v, sheet, c, &mut cx.wb).unwrap_or_else(|_| Some(Cell::value(Value::text(v.as_str()))));
-                if let Some(cl) = cell.as_mut() {
-                    numeric_from_html(cl, v, html.get(ri).and_then(|r| r.get(ci)), &mut cx.wb);
-                }
-                let sh = cx.sheet_mut(sheet)?;
-                match cell {
-                    Some(cell) => sh.set_cell(c, cell),
-                    None => {
-                        sh.remove_cell(c);
-                    }
-                }
-                cx.touch(sheet, c);
-            }
-        }
-        if h > 0 && w > 0 {
-            let end = at.offset_clamped(h as i64 - 1, w as i64 - 1);
-            *cx.sel = crate::Selection { active: at, anchor: at, ranges: vec![RangeRef::new(at, end)] };
-        }
-        Ok(())
-    })?;
-    Ok(json!({"rows": h, "cols": w}))
-}
-
-/// A pasted cell that came out as text ("Rp10,000.00" isn't en-US input) becomes the number the
-/// source recorded for it in its HTML, with a format that shows the same text when one can be
-/// inferred and the cell has none. The HTML cell must show the same text as the tab-separated
-/// field, so HTML that belongs to another copy (or a table laid out differently) changes nothing.
-fn numeric_from_html(cell: &mut Cell, field: &str, html: Option<&crate::clip_html::HtmlCell>, wb: &mut gridcraft_model::Workbook) {
-    let Some(hc) = html else { return };
-    let Some(n) = hc.num else { return };
-    if cell.formula.is_some() || !matches!(cell.value, Value::Text(_)) || wb.styles.get(cell.style).num_fmt.as_str() == "@" {
-        return;
-    }
-    if crate::clip_html::normalized(&hc.text) != crate::clip_html::normalized(field) {
-        return;
-    }
-    cell.value = Value::number(n);
-    if wb.styles.get(cell.style).num_fmt.as_str() == "General"
-        && let Some(code) = crate::clip_html::format_for(field, n)
-    {
-        cell.style = wb.styles.derive(cell.style, |s| s.num_fmt = gridcraft_model::NumFmt::new(&code));
-    }
-}
-
-/// Tab-separated text with Excel-style quoting.
-pub(crate) fn parse_tsv(text: &str) -> Vec<Vec<String>> {
-    let mut rows = Vec::new();
-    let mut row = Vec::new();
-    let mut field = String::new();
-    let mut chars = text.chars().peekable();
-    let mut quoted = false;
-    let mut at_start = true;
-    while let Some(c) = chars.next() {
-        if quoted {
-            if c == '"' {
-                if chars.peek() == Some(&'"') {
-                    field.push('"');
-                    chars.next();
-                } else {
-                    quoted = false;
-                }
-            } else {
-                field.push(c);
-            }
-            continue;
-        }
-        match c {
-            '"' if at_start => {
-                quoted = true;
-                at_start = false;
-            }
-            '\t' => {
-                row.push(std::mem::take(&mut field));
-                at_start = true;
-            }
-            '\r' => {}
-            '\n' => {
-                row.push(std::mem::take(&mut field));
-                rows.push(std::mem::take(&mut row));
-                at_start = true;
-            }
-            _ => {
-                field.push(c);
-                at_start = false;
-            }
-        }
-    }
-    if !field.is_empty() || !row.is_empty() {
-        row.push(field);
-        rows.push(row);
-    }
-    rows
-}
-
-fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
-    let Some(clip) = s.clipboard.clone() else { return Err(EngineError::Other("Nothing to paste.".into())) };
-    let what = match str_param(p, "what").unwrap_or("all") {
-        "all" => What::All,
-        "formulas" => What::Formulas,
-        "values" => What::Values,
-        "formats" => What::Formats,
-        "comments" | "notes" => What::Comments,
-        "validation" => What::Validation,
-        "allExceptBorders" => What::AllExceptBorders,
-        "columnWidths" => What::ColumnWidths,
-        "formulasAndNumberFormats" => What::FormulasAndNumberFormats,
-        "valuesAndNumberFormats" => What::ValuesAndNumberFormats,
-        other => return Err(bad("edit.pasteSpecial", format!("unknown `what`: {other}"))),
-    };
-    let op = str_param(p, "operation").unwrap_or("none").to_string();
-    let skip_blanks = bool_param(p, "skipBlanks").unwrap_or(false);
-    let transpose = bool_param(p, "transpose").unwrap_or(false);
-    let link = bool_param(p, "link").unwrap_or(false);
-    if link && !clip.areas.is_empty() {
-        return Err(EngineError::Other("This action won't work on multiple selections.".into()));
-    }
-    let dest_sheet = target_sheet(s, p)?;
-    let sel = s.doc()?.selection.current();
-    let at = cell_param_on(s, p, "at", dest_sheet)?.unwrap_or(sel.start);
-    let src = clip.range;
-    let (h, w) = if transpose { (src.width(), src.height()) } else { (src.height(), src.width()) };
-    // Tile the copy over a larger destination that is a multiple of its size.
-    let tile = sel.height() % h == 0
-        && sel.width() % w == 0
-        && !sel.is_single()
-        && cell_param_on(s, p, "at", dest_sheet)?.is_none()
-        && !sel.is_full_cols()
-        && !sel.is_full_rows()
-        && sel.count() <= 4_000_000;
-    let (tiles_r, tiles_c) = if tile { (sel.height() / h, sel.width() / w) } else { (1, 1) };
-    let same_doc = s.doc()?.uid == clip.doc_uid;
-    let cut_move = clip.cut && same_doc && what == What::All;
-    let src_wb = clip.wb.clone();
-    let Some(src_sheet) = src_wb.sheet(clip.sheet) else { return Err(EngineError::Other("The copied sheet no longer exists.".into())) };
-    let src_sheet_name = src_sheet.name.clone();
-    if cut_move && at.offset((tiles_r * h).saturating_sub(1) as i64, (tiles_c * w).saturating_sub(1) as i64).is_none() {
-        // Check the whole footprint before the source is emptied, so a move that overflows the grid loses nothing.
-        return Err(EngineError::Other("The cut area doesn't fit at this position; nothing was moved.".into()));
-    }
-    edit(s, |cx| {
-        // Styles from another workbook must be re-interned.
-        let mut style_map = std::collections::HashMap::new();
-        let mut map_style = |id: StyleId, wb: &mut gridcraft_model::Workbook| -> StyleId {
-            if same_doc {
-                return id;
-            }
-            *style_map.entry(id).or_insert_with(|| wb.styles.intern(src_wb.styles.get(id).clone()))
-        };
-        let mut moved_formulas = Vec::new();
-        let mut moved_pictures = std::collections::BTreeMap::new();
-        if cut_move {
-            // Remove the source first (contents and formats), and fix references to it.
-            let source = cx.sheet_mut(clip.sheet)?;
-            moved_pictures = source.cell_pictures.iter().filter(|(c, _)| src.contains(**c)).map(|(c, p)| (*c, p.clone())).collect();
-            let taken = source.take_cells(src);
-            // Notes, hyperlinks and merged areas sit beside the cells, and a cut takes them
-            // with the block: the destination is written from the clipboard snapshot taken
-            // before the cut, so removing them here loses nothing and leaves the old place
-            // clean instead of leaving one merged block and one note behind.
-            source.comments.retain(|c, _| !src.contains(*c));
-            source.hyperlinks.retain(|c, _| !src.contains(*c));
-            source.merges.retain(|m| !src.contains_range(m));
-            for (c, _) in &taken {
-                cx.touch(clip.sheet, *c);
-            }
-            moved_formulas = taken;
-        }
-        for tr in 0..tiles_r {
-            for tc in 0..tiles_c {
-                for r in 0..src.height() {
-                    for c in 0..src.width() {
-                        let sc = CellRef::new(src.start.row + r, src.start.col + c);
-                        let (dr, dc) = if transpose { (c, r) } else { (r, c) };
-                        let Some(dest) = at.offset((tr * h + dr) as i64, (tc * w + dc) as i64) else { continue };
-                        let src_cell = if cut_move {
-                            moved_formulas.iter().find(|(k, _)| *k == sc).map(|(_, v)| v.clone())
-                        } else {
-                            src_sheet.cell(sc).cloned()
-                        };
-                        let src_val = src_sheet.value(sc);
-                        let src_picture = if cut_move { moved_pictures.get(&sc) } else { src_sheet.cell_pictures.get(&sc) }.cloned();
-                        if skip_blanks && src_picture.is_none() && src_val.is_empty() && src_cell.as_ref().is_none_or(|x| x.formula.is_none()) {
-                            continue;
-                        }
-                        let old = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell(dest)).cloned().unwrap_or_default();
-                        let old_picture = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell_pictures.get(&dest)).cloned();
-                        let mut new_picture = old_picture.clone();
-                        let mut new = old.clone();
-                        let shift = |cell: &Cell| -> Option<std::sync::Arc<Formula>> {
-                            let f = cell.formula.as_ref()?;
-                            let e = f.expr()?;
-                            if cut_move {
-                                // A moved formula still reads cells on its original sheet. Qualify
-                                // those references before the workbook-wide move adjustment below.
-                                let e = if dest_sheet != clip.sheet {
-                                    e.map(&mut |x| match x {
-                                        gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
-                                            r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
-                                            gridcraft_formula::Expr::Ref(r)
-                                        }
-                                        other => other,
-                                    })
-                                } else {
-                                    e
-                                };
-                                let mut moved = Formula::from_expr(e);
-                                // The array range moves with its formula.
-                                let (dr, dc) = (dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
-                                moved.array = f.array.and_then(|a| Some(RangeRef::new(a.start.offset(dr, dc)?, a.end.offset(dr, dc)?)));
-                                moved.dynamic = f.dynamic;
-                                return Some(std::sync::Arc::new(moved));
-                            }
-                            let moved =
-                                gridcraft_formula::adjust::shift_relative(e, dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
-                            Some(std::sync::Arc::new(Formula { dynamic: f.dynamic, ..Formula::from_expr(moved) }))
-                        };
-                        if link {
-                            let sheet_prefix = if dest_sheet == clip.sheet && same_doc {
-                                String::new()
-                            } else {
-                                format!("{}!", gridcraft_formula::quote_sheet(&src_sheet_name))
-                            };
-                            new.formula = Some(std::sync::Arc::new(Formula::new(&format!("={sheet_prefix}{}", sc.a1()))));
-                            new.value = Value::Empty;
-                            new_picture = None;
-                        } else {
-                            let sc_cell = src_cell.clone().unwrap_or_default();
-                            match what {
-                                What::All | What::AllExceptBorders => {
-                                    new_picture = src_picture.clone();
-                                    new.formula = shift(&sc_cell);
-                                    new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
-                                    let st = map_style(sc_cell.style, &mut cx.wb);
-                                    new.style = if what == What::AllExceptBorders {
-                                        let borders = cx.wb.styles.get(old.style).borders;
-                                        cx.wb.styles.derive(st, |s| s.borders = borders)
-                                    } else {
-                                        st
-                                    };
-                                }
-                                What::Formulas | What::FormulasAndNumberFormats => {
-                                    new_picture = src_picture.clone();
-                                    new.formula = shift(&sc_cell);
-                                    new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
-                                    if what == What::FormulasAndNumberFormats {
-                                        let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
-                                        new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
-                                    }
-                                }
-                                What::Values | What::ValuesAndNumberFormats => {
-                                    new_picture = src_picture.clone();
-                                    new.formula = None;
-                                    new.value = src_val.clone();
-                                    if what == What::ValuesAndNumberFormats {
-                                        let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
-                                        new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
-                                    }
-                                }
-                                What::Formats => new.style = map_style(sc_cell.style, &mut cx.wb),
-                                What::Comments | What::Validation | What::ColumnWidths => {}
-                            }
-                            // Operations combine numbers with what is already there.
-                            if op != "none"
-                                && matches!(what, What::All | What::Values | What::ValuesAndNumberFormats | What::Formulas)
-                                && new.formula.is_none()
-                            {
-                                if old_picture.is_some() || new_picture.is_some() {
-                                    new_picture = None;
-                                    new.value = Value::Error(gridcraft_core::CellError::Value);
-                                }
-                                let a = old.value.clone();
-                                let b = new.value.clone();
-                                // Numbers stored as text take part (multiplying by 1 turns them into
-                                // numbers); other text and errors stay as they are.
-                                if let (Ok(x), Ok(y)) = (a.to_number(), b.to_number())
-                                    && (a.is_number() || a.is_empty() || a.is_text())
-                                    && (b.is_number() || b.is_empty())
-                                {
-                                    new.value = match op.as_str() {
-                                        "add" => Value::number(x + y),
-                                        "subtract" => Value::number(x - y),
-                                        "multiply" => Value::number(x * y),
-                                        "divide" => {
-                                            if y == 0.0 {
-                                                Value::Error(gridcraft_core::CellError::Div0)
-                                            } else {
-                                                Value::number(x / y)
-                                            }
-                                        }
-                                        _ => b.clone(),
-                                    };
-                                } else if (a.is_text() || a.is_error()) && (b.is_number() || b.is_empty()) {
-                                    new.value = a;
-                                }
-                                // A formula already there is kept and combined with the pasted number.
-                                if let Some(f) = &old.formula
-                                    && let Ok(y) = b.to_number()
-                                    && (b.is_number() || b.is_empty())
-                                    && let Some(sym) = match op.as_str() {
-                                        "add" => Some('+'),
-                                        "subtract" => Some('-'),
-                                        "multiply" => Some('*'),
-                                        "divide" => Some('/'),
-                                        _ => None,
-                                    }
-                                {
-                                    let text = format!("=({}){sym}{}", f.text, gridcraft_core::number_to_text(y));
-                                    new.formula = Some(std::sync::Arc::new(Formula::new(&text)));
-                                    new.value = Value::Empty;
-                                }
-                            }
-                        }
-                        // The copied cell's validation rule replaces whatever rule the destination had.
-                        if !link && matches!(what, What::All | What::AllExceptBorders | What::Validation) {
-                            let rule = src_sheet.validations.iter().find(|dv| dv.ranges.iter().any(|r| r.contains(sc))).cloned();
-                            let sh = cx.sheet_mut(dest_sheet)?;
-                            super::data::remove_validation_cells(&mut sh.validations, &[RangeRef::new(dest, dest)]);
-                            if let Some(mut dv) = rule {
-                                // Relative references move with the rule, as pasted formulas do.
-                                let first = dv.ranges.first().map_or(sc, |r| r.start);
-                                dv.f1 = super::data::move_rule_formula(&dv.f1, first, dest);
-                                dv.f2 = dv.f2.map(|f| super::data::move_rule_formula(&f, first, dest));
-                                dv.ranges = vec![RangeRef::new(dest, dest)];
-                                sh.validations.push(dv);
-                            }
-                        }
-                        match what {
-                            What::Comments => {
-                                if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
-                                    cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
-                                }
-                            }
-                            What::ColumnWidths => {
-                                if let Some(info) = src_sheet.cols.get(&sc.col).copied() {
-                                    cx.sheet_mut(dest_sheet)?.cols.insert(dest.col, info);
-                                }
-                            }
-                            What::All => {
-                                if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
-                                    cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
-                                }
-                                if let Some(h) = src_sheet.hyperlinks.get(&sc).cloned() {
-                                    cx.sheet_mut(dest_sheet)?.hyperlinks.insert(dest, h);
-                                }
-                                cx.sheet_mut(dest_sheet)?.set_cell(dest, new);
-                            }
-                            _ => cx.sheet_mut(dest_sheet)?.set_cell(dest, new),
-                        }
-                        if let Some(picture) = new_picture {
-                            cx.sheet_mut(dest_sheet)?.cell_pictures.insert(dest, picture);
-                        }
-                        cx.touch(dest_sheet, dest);
-                    }
-                }
-            }
-        }
-        // Merged areas inside the copied block travel with it.
-        if matches!(what, What::All | What::Formats) && !transpose {
-            let merges: Vec<RangeRef> = src_sheet.merges.iter().filter(|m| src.contains_range(m)).copied().collect();
-            for m in merges {
-                let dr = at.row as i64 - src.start.row as i64;
-                let dc = at.col as i64 - src.start.col as i64;
-                if let (Some(a), Some(b)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
-                    let nm = RangeRef::new(a, b);
-                    let sh = cx.sheet_mut(dest_sheet)?;
-                    sh.merges.retain(|x| !x.intersects(&nm));
-                    sh.merges.push(nm);
-                }
-            }
-        }
-        if cut_move {
-            // References elsewhere to the moved block now point to its new place.
-            let dest_name = cx.wb.sheet(dest_sheet).map(|s| s.name.clone()).unwrap_or_default();
-            let e = if dest_sheet == clip.sheet {
-                gridcraft_formula::adjust::Edit::Move { from: src, to_row: at.row, to_col: at.col }
-            } else {
-                gridcraft_formula::adjust::Edit::MoveToSheet { from: src, to_sheet: dest_name, to_row: at.row, to_col: at.col }
-            };
-            rewrite_all_formulas(&mut cx.wb, &src_sheet_name, &e);
-            cx.structural = true;
-        }
-        let end = at.offset_clamped((tiles_r * h) as i64 - 1, (tiles_c * w) as i64 - 1);
-        *cx.sel = crate::Selection { active: at, anchor: at, ranges: vec![RangeRef::new(at, end)] };
-        Ok(())
-    })?;
-    // Formulas and validation from an untrusted file leave the destination untrusted; plain values,
-    // formats (cell styles and merged areas, no conditional formats), column widths and notes
-    // carry nothing active. A linked paste writes a formula into every cell whatever `what` says,
-    // except for column widths and notes, which write no cells at all.
-    let passive =
-        matches!(what, What::ColumnWidths | What::Comments) || (!link && matches!(what, What::Formats | What::Values | What::ValuesAndNumberFormats));
-    if !same_doc && !passive {
-        let d = s.doc_mut()?;
-        d.trust = d.trust.receive(clip.trust);
-    }
-    if cut_move {
-        s.clipboard = None;
-    }
-    Ok(json!({"pasted": s.doc()?.selection.a1()}))
-}
-
-/// Applies a reference adjustment to every cell formula and defined name in the workbook.
-pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &str, e: &gridcraft_formula::adjust::Edit) {
-    use gridcraft_formula::adjust::Edit;
-    // Rows and columns inserted or deleted on the target sheet move its legacy array ranges too
-    // (a cut moves its arrays itself).
-    let moves_arrays = matches!(e, Edit::Insert { .. } | Edit::Delete { .. } | Edit::InsertCells { .. } | Edit::DeleteCells { .. });
-    for si in 0..wb.sheets.len() {
-        let host = wb.sheets.get(si).map(|s| s.name.clone()).unwrap_or_default();
-        let keys: Vec<(CellRef, std::sync::Arc<Formula>)> =
-            wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, cell)| cell.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
-        if keys.is_empty() {
-            continue;
-        }
-        let on_target = moves_arrays && host.eq_ignore_ascii_case(target);
-        let Some(sheet) = wb.sheet_mut(si) else { continue };
-        for (c, f) in keys {
-            let Some(expr) = f.expr() else { continue };
-            let new = gridcraft_formula::adjust::adjust(expr, &host, target, e);
-            let text = gridcraft_formula::print(&new);
-            let array = match f.array {
-                Some(a) if on_target => super::sheet::map_range(a, e),
-                a => a,
-            };
-            if (text != f.text || array != f.array)
-                && let Some(cell) = sheet.cells.get_mut(c)
-            {
-                let mut nf = Formula::from_expr(new);
-                nf.array = array;
-                nf.dynamic = f.dynamic;
-                cell.formula = Some(std::sync::Arc::new(nf));
-            }
-        }
-    }
-    for n in wb.names.iter_mut() {
-        if let Ok(expr) = gridcraft_formula::parse_name(&n.formula) {
-            // Names are workbook-level: unqualified refs don't occur; qualified ones adjust.
-            let new = gridcraft_formula::adjust::adjust(expr, "\u{0}", target, e);
-            n.formula = gridcraft_formula::print(&new);
-        }
-    }
-}
-
 // ---------------------------------------------------------------- clear
 
 fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
@@ -1538,283 +301,6 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
     })
 }
 
-// ---------------------------------------------------------------- fill
-
-fn fill_dir(s: &mut Session, p: &Json, dr: i64, dc: i64) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let mut r = target_range(s, p)?;
-    // Whole rows or columns fill only where the sheet has content (nothing on an empty sheet).
-    if r.is_full_cols() || r.is_full_rows() {
-        match s.doc()?.wb.sheet(sheet).and_then(|sh| sh.used_range()).and_then(|u| r.intersection(&u)) {
-            Some(u) => r = u,
-            None => return Ok(Json::Null),
-        }
-    }
-    if r.count() > crate::fill::MAX_FILL_CELLS {
-        return Err(bad("edit.fill", "range too large"));
-    }
-    // With one row selected, Fill Down copies from the row above (Excel behaviour).
-    if dr == 1 && r.height() == 1 {
-        r.start.row = r.start.row.saturating_sub(1);
-    }
-    if dc == 1 && r.width() == 1 {
-        r.start.col = r.start.col.saturating_sub(1);
-    }
-    let src = if dr == 1 {
-        RangeRef::new(r.start, CellRef::new(r.start.row, r.end.col))
-    } else if dr == -1 {
-        RangeRef::new(CellRef::new(r.end.row, r.start.col), r.end)
-    } else if dc == 1 {
-        RangeRef::new(r.start, CellRef::new(r.end.row, r.start.col))
-    } else {
-        RangeRef::new(CellRef::new(r.start.row, r.end.col), r.end)
-    };
-    edit(s, |cx| {
-        crate::fill::fill(cx, sheet, src, r, crate::fill::FillMode::Copy)?;
-        Ok(Json::Null)
-    })
-}
-
-fn auto_fill(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let src = str_param(p, "source").and_then(RangeRef::parse).map_or_else(|| target_range(s, p), Ok)?;
-    let Some(target) = str_param(p, "target").and_then(RangeRef::parse) else { return Err(bad("edit.autoFill", "missing `target`")) };
-    let mode = match str_param(p, "mode").unwrap_or("series") {
-        "copy" => crate::fill::FillMode::Copy,
-        "alternate" => crate::fill::FillMode::Alternate,
-        "formats" => crate::fill::FillMode::Formats,
-        "values" => crate::fill::FillMode::ValuesOnly,
-        "extend" => crate::fill::FillMode::Extend,
-        "days" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Day),
-        "weekdays" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Weekday),
-        "months" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Month),
-        "years" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Year),
-        _ => crate::fill::FillMode::Series,
-    };
-    if target.count() > crate::fill::MAX_FILL_CELLS || src.count() > crate::fill::MAX_FILL_CELLS {
-        return Err(bad("edit.autoFill", "range too large"));
-    }
-    // Excel refuses a target that doesn't hold the source in a corner. Such targets used to fill
-    // every source lane across the whole target extent: billions of cells for whole rows (`2:3`)
-    // into whole columns (`A:A`).
-    if !crate::fill::holds_source_in_corner(src, target) {
-        return Err(bad("edit.autoFill", "the target must contain the source in one of its corners"));
-    }
-    edit(s, |cx| {
-        crate::fill::fill(cx, sheet, src, target, mode)?;
-        *cx.sel = crate::Selection { active: src.start, anchor: src.start, ranges: vec![target.union(&src)] };
-        Ok(Json::Null)
-    })
-}
-
-fn fill_series(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let r = target_range(s, p)?;
-    let rows = str_param(p, "direction").map(|d| d == "rows").unwrap_or(r.width() > r.height());
-    let kind = str_param(p, "type").unwrap_or("linear").to_string();
-    let step = f64_param(p, "step").unwrap_or(1.0);
-    let stop = f64_param(p, "stop");
-    let unit = str_param(p, "dateUnit").unwrap_or("day").to_string();
-    edit(s, |cx| {
-        crate::fill::series(cx, sheet, r, rows, &kind, step, stop, &unit)?;
-        Ok(Json::Null)
-    })
-}
-
-fn flash_fill(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let r = target_range(s, p)?;
-    let n = edit(s, |cx| crate::fill::flash_fill(cx, sheet, r.start))?;
-    if n == 0 {
-        return Err(EngineError::Other(
-            "We looked at all the data next to your selection and didn't see a pattern for filling in values for you.".into(),
-        ));
-    }
-    Ok(json!({"filled": n}))
-}
-
-// ---------------------------------------------------------------- find & replace
-
-fn matches(hay: &str, what: &str, case: bool, whole: bool) -> bool {
-    let (h, w) = if case { (hay.to_string(), what.to_string()) } else { (hay.to_lowercase(), what.to_lowercase()) };
-    let has_wild = w.contains(['*', '?']);
-    if has_wild {
-        let pat = if whole { w } else { format!("*{w}*") };
-        return wildcard(&h, &pat);
-    }
-    if whole { h == w } else { h.contains(&w) }
-}
-
-/// `*`/`?` wildcard match with `~` escapes.
-pub(crate) fn wildcard(text: &str, pat: &str) -> bool {
-    let t: Vec<char> = text.chars().collect();
-    let mut p: Vec<(char, bool)> = Vec::new();
-    let mut it = pat.chars();
-    while let Some(c) = it.next() {
-        if c == '~' {
-            if let Some(n) = it.next() {
-                p.push((n, true));
-            }
-        } else {
-            p.push((c, false));
-        }
-    }
-    let (mut ti, mut pi) = (0usize, 0usize);
-    let (mut star, mut mark) = (None, 0usize);
-    while ti < t.len() {
-        if pi < p.len() && (p[pi] == ('?', false) || (p[pi].0 == t[ti] && p[pi] != ('*', false))) {
-            ti += 1;
-            pi += 1;
-        } else if pi < p.len() && p[pi] == ('*', false) {
-            star = Some(pi);
-            mark = ti;
-            pi += 1;
-        } else if let Some(sp) = star {
-            pi = sp + 1;
-            mark += 1;
-            ti = mark;
-        } else {
-            return false;
-        }
-    }
-    while pi < p.len() && p[pi] == ('*', false) {
-        pi += 1;
-    }
-    pi == p.len()
-}
-
-fn find(s: &mut Session, p: &Json) -> Result<Json> {
-    let what = str_param(p, "what").unwrap_or("").to_string();
-    if what.is_empty() {
-        return Err(bad("edit.find", "missing `what`"));
-    }
-    let case = bool_param(p, "matchCase").unwrap_or(false);
-    let whole = bool_param(p, "wholeCell").unwrap_or(false);
-    let values = str_param(p, "lookIn") == Some("values");
-    let by_cols = bool_param(p, "byColumns").unwrap_or(false);
-    let all = bool_param(p, "all").unwrap_or(false);
-    let workbook = str_param(p, "within") == Some("workbook");
-    s.last_find = Some(p.clone());
-    let d = s.doc()?;
-    let sheets: Vec<usize> = if workbook { (0..d.wb.sheets.len()).collect() } else { vec![d.wb.active_sheet()] };
-    let mut hits: Vec<(usize, CellRef, String)> = Vec::new();
-    for si in sheets {
-        let Some(sh) = d.wb.sheet(si) else { continue };
-        let mut cells: Vec<(CellRef, String)> = sh
-            .cells
-            .iter()
-            .filter_map(|(c, cell)| {
-                let text = if values || cell.formula.is_none() || crate::display::formula_hidden(&d.wb, sh, c) {
-                    crate::display::cell_text(&d.wb, sh, c)
-                } else {
-                    cell.input_text()
-                };
-                matches(&text, &what, case, whole).then_some((c, text))
-            })
-            .collect();
-        if by_cols {
-            cells.sort_by_key(|(c, _)| (c.col, c.row));
-        }
-        hits.extend(cells.into_iter().map(|(c, t)| (si, c, t)));
-    }
-    if hits.is_empty() {
-        return Err(EngineError::Other(format!("We couldn't find what you were looking for: {what}")));
-    }
-    if all {
-        let list: Vec<Json> =
-            hits.iter().map(|(si, c, t)| json!({"sheet": d.wb.sheet(*si).map(|s| s.name.clone()), "cell": c.a1(), "value": t})).collect();
-        return Ok(json!({"count": list.len(), "results": list}));
-    }
-    // Next hit after the active cell.
-    let cur = (d.wb.active_sheet(), d.selection.active);
-    let key = |si: usize, c: CellRef| if by_cols { (si, c.col, c.row) } else { (si, c.row, c.col) };
-    let next = hits.iter().find(|(si, c, _)| key(*si, *c) > key(cur.0, cur.1)).or_else(|| hits.first()).cloned();
-    let Some((si, c, t)) = next else { return Err(EngineError::Other("not found".into())) };
-    let dd = s.doc_mut()?;
-    dd.wb_switch_sheet(si);
-    dd.selection = crate::Selection::at(c);
-    Ok(json!({"cell": c.a1(), "sheet": si, "value": t, "count": hits.len()}))
-}
-
-fn replace(s: &mut Session, p: &Json) -> Result<Json> {
-    let what = str_param(p, "what").unwrap_or("").to_string();
-    let with = str_param(p, "with").unwrap_or("").to_string();
-    if what.is_empty() {
-        return Err(bad("edit.replace", "missing `what`"));
-    }
-    let case = bool_param(p, "matchCase").unwrap_or(false);
-    let whole = bool_param(p, "wholeCell").unwrap_or(false);
-    let all = bool_param(p, "all").unwrap_or(true);
-    let workbook = str_param(p, "within") == Some("workbook");
-    let active = s.doc()?.selection.active;
-    let n = edit(s, |cx| {
-        let sheets: Vec<usize> = if workbook { (0..cx.wb.sheets.len()).collect() } else { vec![cx.wb.active_sheet()] };
-        let mut n = 0;
-        for si in sheets {
-            let cells: Vec<(CellRef, String)> =
-                cx.wb.sheet(si).map(|sh| sh.cells.iter().map(|(c, _)| (c, sh.input_text(c))).collect()).unwrap_or_default();
-            for (c, text) in cells {
-                if !all && c != active {
-                    continue;
-                }
-                if !matches(&text, &what, case, whole) {
-                    continue;
-                }
-                let new = if whole {
-                    with.clone()
-                } else if case {
-                    text.replace(&what, &with)
-                } else {
-                    replace_ci(&text, &what, &with)
-                };
-                let cell = input_to_cell(&new, si, c, &mut cx.wb).unwrap_or_else(|_| Some(Cell::value(Value::text(new.as_str()))));
-                let sh = cx.sheet_mut(si)?;
-                match cell {
-                    Some(cell) => sh.set_cell(c, cell),
-                    None => {
-                        sh.remove_cell(c);
-                    }
-                }
-                cx.touch(si, c);
-                n += 1;
-            }
-        }
-        Ok(n)
-    })?;
-    Ok(json!({"replaced": n}))
-}
-
-/// Whether case-folding `s` maps every char to exactly one char of the same UTF-8 length, so
-/// byte positions in the folded text still line up with the original's character boundaries.
-fn folds_in_place(s: &str) -> bool {
-    s.chars().all(|c| {
-        let mut folded = c.to_lowercase();
-        let first = folded.next();
-        folded.next().is_none() && first.is_some_and(|l| l.len_utf8() == c.len_utf8())
-    })
-}
-
-fn replace_ci(text: &str, what: &str, with: &str) -> String {
-    let lower = text.to_lowercase();
-    let w = what.to_lowercase();
-    // Slicing `text` at positions found in `lower` is only sound when folding kept every byte
-    // boundary: a length check alone misses foldings that keep the total length while shifting
-    // boundaries (U+212A KELVIN SIGN shrinks 3→1 bytes, U+0130 grows 2→3), where the tail used
-    // to be dropped. Those fall back to the case-sensitive replace, as length changes already do.
-    if lower.len() != text.len() || w.is_empty() || !folds_in_place(text) || !folds_in_place(what) {
-        return text.replace(what, with);
-    }
-    let mut out = String::new();
-    let mut i = 0;
-    while let Some(pos) = lower.get(i..).and_then(|s| s.find(&w)) {
-        out.push_str(text.get(i..i + pos).unwrap_or(""));
-        out.push_str(with);
-        i += pos + w.len();
-    }
-    out.push_str(text.get(i..).unwrap_or(""));
-    out
-}
-
 // ---------------------------------------------------------------- format painter
 
 fn format_painter(s: &mut Session, p: &Json) -> Result<Json> {
diff --git a/crates/engine/src/cmd/edit/cell.rs b/crates/engine/src/cmd/edit/cell.rs
new file mode 100644
index 000000000..62a6b38bd
--- /dev/null
+++ b/crates/engine/src/cmd/edit/cell.rs
@@ -0,0 +1,287 @@
+use super::*;
+
+// ---------------------------------------------------------------- entry
+
+/// What typing `input` into a cell produces (constant or formula, plus an automatic number
+/// format). Inherits the destination's cell, row or column style, including its number
+/// format, before parsing. Errors when the formula can't be parsed.
+pub(crate) fn input_to_cell(input: &str, sheet: usize, at: CellRef, wb: &mut gridcraft_model::Workbook) -> Result<Option<Cell>> {
+    let style = wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
+    if input.is_empty() {
+        let c = Cell { value: Value::Empty, formula: None, style };
+        return Ok(if c.is_blank() { None } else { Some(c) });
+    }
+    let fmt_is_text = wb.styles.get(style).num_fmt.as_str() == "@";
+    if fmt_is_text {
+        return Ok(Some(Cell { value: Value::text(input), formula: None, style }));
+    }
+    let is_formula = input.starts_with('=')
+        || (input.len() > 1
+            && (input.starts_with('+') || input.starts_with('-'))
+            && gridcraft_core::parse::parse_number_text(input).is_none()
+            && input.chars().nth(1).is_some_and(|c| c.is_ascii_alphabetic() || c == '('));
+    if is_formula {
+        let body = input.strip_prefix('=').unwrap_or(input);
+        let expr = wb.name_call_case(parse_typed_formula(body)?);
+        check_arg_counts(&expr)?;
+        let mut cell = Cell::formula(Formula::from_expr(expr));
+        cell.style = style;
+        // Formulas whose result is a date/time get a format from functions like TODAY().
+        if wb.styles.get(style).num_fmt.as_str() == "General" {
+            let f = cell.formula.as_ref().map(|f| f.text.to_ascii_uppercase()).unwrap_or_default();
+            let auto = if f.starts_with("TODAY(")
+                || f.starts_with("DATE(")
+                || f.starts_with("EDATE(")
+                || f.starts_with("EOMONTH(")
+                || f.starts_with("WORKDAY(")
+            {
+                Some("m/d/yyyy")
+            } else if f.starts_with("NOW(") {
+                Some("m/d/yyyy h:mm")
+            } else if f.starts_with("TIME(") {
+                Some("h:mm AM/PM")
+            } else {
+                None
+            };
+            if let Some(code) = auto {
+                cell.style = wb.styles.derive(style, |s| s.num_fmt = gridcraft_model::NumFmt::new(code));
+            }
+        }
+        return Ok(Some(cell));
+    }
+    let mut parsed = gridcraft_core::parse::parse_input(input, wb.date_system);
+    // Like Excel's automatic percent entry: a bare number of 1 or more typed into a cell already
+    // formatted as a percentage is a percent (3 -> 3%); smaller numbers are taken as fractions.
+    if parsed.format.is_none()
+        && !input.contains('%')
+        && wb.styles.get(style).num_fmt.as_str().ends_with('%')
+        && let Value::Number(n) = parsed.value
+        && n.abs() >= 1.0
+    {
+        parsed.value = Value::Number(n / 100.0);
+    }
+    let mut style = style;
+    if let Some(code) = parsed.format {
+        let cur = wb.styles.get(style).num_fmt.as_str().to_string();
+        if cur == "General" {
+            style = wb.styles.derive(style, |s| s.num_fmt = gridcraft_model::NumFmt::new(code));
+        }
+    }
+    // Wrap text automatically when the input has line breaks (Alt+Enter).
+    if input.contains('\n') && !wb.styles.get(style).align.wrap {
+        style = wb.styles.derive(style, |s| s.align.wrap = true);
+    }
+    Ok(Some(Cell { value: parsed.value, formula: None, style }))
+}
+
+/// Parses a formula as it is typed (without the `=`). Excel closes missing parentheses for you,
+/// and refuses a formula that still doesn't parse.
+pub(crate) fn parse_typed_formula(body: &str) -> Result<gridcraft_formula::Expr> {
+    // Excel closes missing parentheses for you.
+    let parsed = gridcraft_formula::parse_closing_parens(body, gridcraft_formula::parse);
+    parsed.map_err(|e| EngineError::Other(format!("There's a problem with this formula: {e}")))
+}
+
+/// Like Excel, a formula that calls a built-in function with too few or too many arguments is
+/// refused when it's entered, rather than stored to show `#VALUE!`. Functions the registry doesn't
+/// hold (special forms like LET, LAMBDA, OFFSET, INDIRECT, SUBTOTAL), defined LAMBDA names and
+/// unknown functions are skipped.
+pub(crate) fn check_arg_counts(expr: &gridcraft_formula::Expr) -> Result<()> {
+    let mut bad = None;
+    expr.walk(&mut |e| {
+        if bad.is_none()
+            && let gridcraft_formula::Expr::Call(name, args) = e
+            && let Some(spec) = gridcraft_functions::lookup(name)
+            && !spec.accepts(args.len())
+        {
+            let few = args.len() < spec.min_args;
+            bad = Some(format!("{} has too {} arguments. Use {}", spec.name, if few { "few" } else { "many" }, spec.signature));
+        }
+    });
+    match bad {
+        Some(msg) => Err(EngineError::Other(msg)),
+        None => Ok(()),
+    }
+}
+
+pub(super) fn cell_set(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = match cell_param_on(s, p, "cell", sheet)? {
+        Some(c) => c,
+        None => s.doc()?.selection.active,
+    };
+    // Both spellings take a string, number or boolean, as typed (#697).
+    let input = p.get("input").or_else(|| p.get("value")).map(json_to_input).ok_or_else(|| bad("cell.set", "missing `input` (or `value`)"))?;
+    let array = bool_param(p, "array").unwrap_or(false);
+    let d = s.doc()?;
+    if let Some(sh) = d.wb.sheet(sheet)
+        && sh.is_protected()
+        && d.wb.styles.get(sh.style_id(at)).protection.locked
+        && let Some(m) = locked_cell_error(sh, at, &d.unlocked_ranges)
+    {
+        return Err(EngineError::Other(m));
+    }
+    let active_sheet = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        if array {
+            // Legacy Ctrl+Shift+Enter array formula over the selection, when the selection holds
+            // the cell; a cell elsewhere (or on another sheet) gets a one-cell array.
+            let selected = cx.sel.current();
+            let range = if sheet == active_sheet && selected.contains(at) { selected } else { RangeRef::cell(at) };
+            // A table header can't hold an array's value, and a table resizes under it.
+            if !range.is_single() && cx.wb.sheet(sheet).is_some_and(|sh| sh.tables.iter().any(|t| t.range.intersects(&range))) {
+                return Err(EngineError::Other("Multi-cell array formulas aren't allowed in tables.".into()));
+            }
+            let mut cell = input_to_cell(&input, sheet, range.start, &mut cx.wb)?.unwrap_or_default();
+            if let Some(f) = cell.formula.as_mut() {
+                std::sync::Arc::make_mut(f).array = Some(range);
+            }
+            let sh = cx.sheet_mut(sheet)?;
+            // The array takes the whole range: other cells in it lose their contents.
+            for c in range.iter().skip(1).take(1_000_000) {
+                if let Some(old) = sh.cells.get(c).filter(|x| !x.value.is_empty() || x.formula.is_some()) {
+                    let style = old.style;
+                    sh.set_cell(c, Cell { style, ..Cell::default() });
+                }
+            }
+            sh.set_cell(range.start, cell);
+            cx.touch(sheet, range.start);
+            return Ok(Json::Null);
+        }
+        let cell = input_to_cell(&input, sheet, at, &mut cx.wb)?;
+        let sh = cx.sheet_mut(sheet)?;
+        match cell {
+            Some(c) => sh.set_cell(at, c),
+            None => {
+                sh.remove_cell(at);
+            }
+        }
+        crate::cmd::data::grow_autofilter(sh, at);
+        cx.touch(sheet, at);
+        Ok(Json::Null)
+    })?;
+    let v = s.doc()?.wb.sheet(sheet).map(|sh| sh.value(at)).unwrap_or_default();
+    Ok(json!({"cell": at.a1(), "value": v.display()}))
+}
+
+pub(crate) fn json_to_input(v: &Json) -> String {
+    match v {
+        Json::Null => String::new(),
+        Json::Bool(b) => {
+            if *b {
+                "TRUE".into()
+            } else {
+                "FALSE".into()
+            }
+        }
+        Json::Number(n) => n.to_string(),
+        Json::String(s) => s.clone(),
+        other => other.to_string(),
+    }
+}
+
+pub(super) fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let start = target_range(s, p)?.start;
+    let Some(rows) = p.get("values").and_then(Json::as_array) else { return Err(bad("range.setValues", "missing `values` (array of rows)")) };
+    // A string is run through typed input by default, which reads it with en-US rules: a caller
+    // sending "05.04.2026" from a dd.mm.yyyy export got 4 May, and "2.500" became 2.5, in silence
+    // (#2255). `parse: false` stores a string as the text it is; numbers, booleans and formulas
+    // are unaffected either way.
+    let parse = match p.get("parse") {
+        None | Some(Json::Null) => true,
+        Some(Json::Bool(b)) => *b,
+        Some(other) => return Err(bad("range.setValues", format!("parse {other}: true or false"))),
+    };
+    if rows.len() > MAX_ROWS as usize {
+        return Err(bad("range.setValues", "too many rows"));
+    }
+    let mut count = 0;
+    edit(s, |cx| {
+        for (ri, row) in rows.iter().enumerate() {
+            let cols: Vec<&Json> = match row.as_array() {
+                Some(a) => a.iter().collect(),
+                None => vec![row],
+            };
+            for (ci, v) in cols.iter().enumerate() {
+                let Some(at) = start.offset(ri as i64, ci as i64) else { continue };
+                let input = json_to_input(v);
+                let cell = match v {
+                    Json::Number(n) => Some(Cell {
+                        value: Value::number(n.as_f64().unwrap_or(0.0)),
+                        formula: None,
+                        style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(),
+                    }),
+                    Json::Bool(b) => {
+                        Some(Cell { value: Value::Bool(*b), formula: None, style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default() })
+                    }
+                    // Text as given: no date or number reading, and a leading `'` is part of the
+                    // text rather than the marker that makes it text. A formula is still a
+                    // formula, which is what the ticket asks for and what `=` means in a cell.
+                    Json::String(text) if !parse && !text.starts_with('=') => {
+                        let mut style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
+                        // Line breaks still turn on Wrap Text, as typed input does.
+                        if text.contains('\n') && !cx.wb.styles.get(style).align.wrap {
+                            style = cx.wb.styles.derive(style, |s| s.align.wrap = true);
+                        }
+                        Some(Cell { value: Value::Text(text.as_str().into()), formula: None, style })
+                    }
+                    _ => input_to_cell(&input, sheet, at, &mut cx.wb)?,
+                };
+                let sh = cx.sheet_mut(sheet)?;
+                match cell {
+                    Some(c) => sh.set_cell(at, c),
+                    None => {
+                        sh.remove_cell(at);
+                    }
+                }
+                crate::cmd::data::grow_autofilter(sh, at);
+                cx.touch(sheet, at);
+                count += 1;
+            }
+        }
+        Ok(())
+    })?;
+    Ok(json!({"cells": count}))
+}
+
+pub(super) fn range_fill(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let ranges = target_ranges(s, p)?;
+    let input = str_param(p, "input").unwrap_or("").to_string();
+    let origin = s.doc()?.selection.active;
+    edit(s, |cx| {
+        // Each cell gets what typing the input there gives: the automatic number format where
+        // it's General, its own format otherwise, text where it's Text. That depends only on
+        // the cell's style, so the input is parsed once per style.
+        let mut by_style: std::collections::HashMap<StyleId, Option<Cell>> = std::collections::HashMap::new();
+        for r in &ranges {
+            if r.count() > 2_000_000 {
+                return Err(bad("range.fill", "range too large"));
+            }
+            for at in r.iter() {
+                let style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
+                let base = match by_style.get(&style) {
+                    Some(c) => c.clone(),
+                    None => {
+                        let c = input_to_cell(&input, sheet, at, &mut cx.wb)?;
+                        by_style.insert(style, c.clone());
+                        c
+                    }
+                };
+                let mut cell = base.unwrap_or_default();
+                if let Some(f) = &cell.formula
+                    && let Some(e) = f.expr()
+                {
+                    let shifted = gridcraft_formula::adjust::shift_relative(e, at.row as i64 - origin.row as i64, at.col as i64 - origin.col as i64);
+                    cell.formula = Some(std::sync::Arc::new(Formula::from_expr(shifted)));
+                }
+                let sh = cx.sheet_mut(sheet)?;
+                sh.set_cell(at, cell);
+                crate::cmd::data::grow_autofilter(sh, at);
+                cx.touch(sheet, at);
+            }
+        }
+        Ok(Json::Null)
+    })
+}
diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs
new file mode 100644
index 000000000..60c05c687
--- /dev/null
+++ b/crates/engine/src/cmd/edit/clipboard.rs
@@ -0,0 +1,269 @@
+use super::cell::input_to_cell;
+use super::paste_special::paste_special;
+use super::*;
+
+// ---------------------------------------------------------------- clipboard
+
+fn copy_impl(s: &mut Session, p: &Json, cut: bool) -> Result<Json> {
+    let multiple = || EngineError::Other("This action won't work on multiple selections.".into());
+    let sheet = target_sheet(s, p)?;
+    let ranges = target_ranges(s, p)?;
+    if ranges.len() > 1 && cut {
+        return Err(multiple());
+    }
+    // The selection as made (untrimmed), for Insert Copied Cells.
+    let selected = ranges.first().copied().unwrap_or_default();
+    let d = s.doc()?;
+    let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
+    let trim = |range: RangeRef| {
+        if range.is_full_cols() || range.is_full_rows() {
+            let used = sh.used_range().unwrap_or(RangeRef::cell(range.start));
+            range.intersection(&used.union(&RangeRef::cell(range.start))).unwrap_or(range)
+        } else {
+            range
+        }
+    };
+    let (wb, range, areas) = if ranges.len() > 1 {
+        let areas: Vec<RangeRef> = ranges.iter().map(|r| trim(*r)).collect();
+        let (wb, block) = slide_together(&d.wb, sheet, &areas).ok_or_else(multiple)?;
+        (std::sync::Arc::new(wb), block, areas)
+    } else {
+        (d.wb.clone(), trim(ranges.first().copied().unwrap_or_default()), Vec::new())
+    };
+    let text = crate::display::range_text(&wb, sheet, range);
+    // The HTML rendering is for the host clipboard (UI); it can reach 4 MB, so agents and
+    // scripts get it only when they ask for it.
+    let html = if p.get("html").and_then(Json::as_bool) == Some(true) { crate::io::range_html(&wb, sheet, range, &text) } else { None };
+    let clip = Clipboard { wb, sheet, range, cut, doc_uid: d.uid, text: text.clone(), areas, selected, trust: d.trust };
+    s.clipboard = Some(clip);
+    let mut result = json!({"range": range.a1(), "text": text});
+    if let Some(html) = html {
+        result["html"] = Json::String(html);
+    }
+    Ok(result)
+}
+
+/// Excel copies a multi-area selection only when the areas line up: all cover the same rows (they
+/// slide together side by side, left to right) or all cover the same columns (stacked, top to
+/// bottom), without overlapping. Returns a copy of the workbook whose sheet holds the areas packed
+/// into one block at the first area's place, and that block. Formulas travel as their values, as
+/// in Excel. `None` when the areas don't line up.
+fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRef]) -> Option<(gridcraft_model::Workbook, RangeRef)> {
+    let first = *areas.first()?;
+    let across = areas.iter().all(|a| a.start.row == first.start.row && a.end.row == first.end.row);
+    let down = areas.iter().all(|a| a.start.col == first.start.col && a.end.col == first.end.col);
+    let mut sorted = areas.to_vec();
+    if across {
+        sorted.sort_by_key(|a| a.start.col);
+    } else if down {
+        sorted.sort_by_key(|a| a.start.row);
+    } else {
+        return None;
+    }
+    if sorted.windows(2).any(|w| matches!(w, [a, b] if a.intersects(b))) {
+        return None;
+    }
+    let anchor = sorted.first()?.start;
+    let (h, w) = if across {
+        (first.height(), sorted.iter().map(RangeRef::width).fold(0u32, u32::saturating_add))
+    } else {
+        (sorted.iter().map(RangeRef::height).fold(0u32, u32::saturating_add), first.width())
+    };
+    let block = RangeRef::new(anchor, anchor.offset(i64::from(h) - 1, i64::from(w) - 1)?);
+    let src = wb.sheet(sheet)?;
+    let mut out = wb.clone();
+    let dst = out.sheet_mut(sheet)?;
+    dst.take_cells(block);
+    dst.spill.retain(|c, _| !block.contains(*c));
+    dst.spill_ranges.retain(|c, _| !block.contains(*c));
+    dst.comments.retain(|c, _| !block.contains(*c));
+    dst.merges.retain(|m| !m.intersects(&block));
+    if across {
+        dst.cols.retain(|c, _| !(block.start.col..=block.end.col).contains(c));
+    } else {
+        dst.rows.retain(|r, _| !(block.start.row..=block.end.row).contains(r));
+    }
+    let mut next = if across { anchor.col } else { anchor.row };
+    for a in &sorted {
+        let (dr, dc) = if across { (0, i64::from(next) - i64::from(a.start.col)) } else { (i64::from(next) - i64::from(a.start.row), 0) };
+        let cells = src.cells.iter_range(*a).map(|(c, _)| c).chain(src.spill.keys().copied().filter(|c| a.contains(*c)));
+        for c in cells {
+            let Some(to) = c.offset(dr, dc) else { continue };
+            let style = src.cell(c).map(|x| x.style).unwrap_or_default();
+            dst.set_cell(to, Cell { value: src.value(c), formula: None, style });
+            if let Some(picture) = src.cell_pictures.get(&c) {
+                dst.cell_pictures.insert(to, picture.clone());
+            }
+        }
+        for (c, comment) in src.comments.iter().filter(|(c, _)| a.contains(**c)) {
+            if let Some(to) = c.offset(dr, dc) {
+                dst.comments.insert(to, comment.clone());
+            }
+        }
+        for m in src.merges.iter().filter(|m| a.contains_range(m)) {
+            if let (Some(s), Some(e)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
+                dst.merges.push(RangeRef::new(s, e));
+            }
+        }
+        // Column widths (side by side) or row heights and hidden rows (stacked) follow their cells.
+        if across {
+            for (c, info) in src.cols.range(a.start.col..=a.end.col) {
+                dst.cols.insert(next.saturating_add(c.saturating_sub(a.start.col)), *info);
+            }
+        } else {
+            for (r, info) in src.rows.range(a.start.row..=a.end.row) {
+                dst.rows.insert(next.saturating_add(r.saturating_sub(a.start.row)), *info);
+            }
+        }
+        next = next.saturating_add(if across { a.width() } else { a.height() });
+    }
+    Some((out, block))
+}
+
+pub(super) fn copy(s: &mut Session, p: &Json) -> Result<Json> {
+    copy_impl(s, p, false)
+}
+
+pub(super) fn cut(s: &mut Session, p: &Json) -> Result<Json> {
+    copy_impl(s, p, true)
+}
+
+pub(super) fn clear_clipboard(s: &mut Session, _: &Json) -> Result<Json> {
+    s.clipboard = None;
+    s.format_painter = None;
+    ok()
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum What {
+    All,
+    Formulas,
+    Values,
+    Formats,
+    Comments,
+    Validation,
+    AllExceptBorders,
+    ColumnWidths,
+    FormulasAndNumberFormats,
+    ValuesAndNumberFormats,
+}
+
+pub(super) fn paste(s: &mut Session, p: &Json) -> Result<Json> {
+    // External text (from the system clipboard) when it differs from ours.
+    if let Some(text) = str_param(p, "text")
+        && s.clipboard.as_ref().is_none_or(|c| c.text.trim_end_matches(['\r', '\n']) != text.trim_end_matches(['\r', '\n']))
+    {
+        return paste_text(s, p, text);
+    }
+    if s.clipboard.is_none() {
+        return Err(EngineError::Other("Nothing to paste.".into()));
+    }
+    paste_special(s, &json!({"what": "all", "at": p.get("at").cloned().unwrap_or(Json::Null)}))
+}
+
+fn paste_text(s: &mut Session, p: &Json, text: &str) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let at = cell_param_on(s, p, "at", sheet)?.unwrap_or(s.doc()?.selection.current().start);
+    let rows: Vec<Vec<String>> = parse_tsv(text);
+    let h = rows.len();
+    let w = rows.iter().map(Vec::len).max().unwrap_or(0);
+    // The HTML flavour, when the host passed it: the number behind each cell's shown text. Read
+    // only as far as the text's own shape, so spans in the markup can't expand without bound.
+    let html = str_param(p, "html").map(|html| crate::clip_html::table_cells(html, h, w)).unwrap_or_default();
+    edit(s, |cx| {
+        for (ri, row) in rows.iter().enumerate() {
+            for (ci, v) in row.iter().enumerate() {
+                let Some(c) = at.offset(ri as i64, ci as i64) else { continue };
+                let mut cell = input_to_cell(v, sheet, c, &mut cx.wb).unwrap_or_else(|_| Some(Cell::value(Value::text(v.as_str()))));
+                if let Some(cl) = cell.as_mut() {
+                    numeric_from_html(cl, v, html.get(ri).and_then(|r| r.get(ci)), &mut cx.wb);
+                }
+                let sh = cx.sheet_mut(sheet)?;
+                match cell {
+                    Some(cell) => sh.set_cell(c, cell),
+                    None => {
+                        sh.remove_cell(c);
+                    }
+                }
+                cx.touch(sheet, c);
+            }
+        }
+        if h > 0 && w > 0 {
+            let end = at.offset_clamped(h as i64 - 1, w as i64 - 1);
+            *cx.sel = crate::Selection { active: at, anchor: at, ranges: vec![RangeRef::new(at, end)] };
+        }
+        Ok(())
+    })?;
+    Ok(json!({"rows": h, "cols": w}))
+}
+
+/// A pasted cell that came out as text ("Rp10,000.00" isn't en-US input) becomes the number the
+/// source recorded for it in its HTML, with a format that shows the same text when one can be
+/// inferred and the cell has none. The HTML cell must show the same text as the tab-separated
+/// field, so HTML that belongs to another copy (or a table laid out differently) changes nothing.
+fn numeric_from_html(cell: &mut Cell, field: &str, html: Option<&crate::clip_html::HtmlCell>, wb: &mut gridcraft_model::Workbook) {
+    let Some(hc) = html else { return };
+    let Some(n) = hc.num else { return };
+    if cell.formula.is_some() || !matches!(cell.value, Value::Text(_)) || wb.styles.get(cell.style).num_fmt.as_str() == "@" {
+        return;
+    }
+    if crate::clip_html::normalized(&hc.text) != crate::clip_html::normalized(field) {
+        return;
+    }
+    cell.value = Value::number(n);
+    if wb.styles.get(cell.style).num_fmt.as_str() == "General"
+        && let Some(code) = crate::clip_html::format_for(field, n)
+    {
+        cell.style = wb.styles.derive(cell.style, |s| s.num_fmt = gridcraft_model::NumFmt::new(&code));
+    }
+}
+
+/// Tab-separated text with Excel-style quoting.
+pub(crate) fn parse_tsv(text: &str) -> Vec<Vec<String>> {
+    let mut rows = Vec::new();
+    let mut row = Vec::new();
+    let mut field = String::new();
+    let mut chars = text.chars().peekable();
+    let mut quoted = false;
+    let mut at_start = true;
+    while let Some(c) = chars.next() {
+        if quoted {
+            if c == '"' {
+                if chars.peek() == Some(&'"') {
+                    field.push('"');
+                    chars.next();
+                } else {
+                    quoted = false;
+                }
+            } else {
+                field.push(c);
+            }
+            continue;
+        }
+        match c {
+            '"' if at_start => {
+                quoted = true;
+                at_start = false;
+            }
+            '\t' => {
+                row.push(std::mem::take(&mut field));
+                at_start = true;
+            }
+            '\r' => {}
+            '\n' => {
+                row.push(std::mem::take(&mut field));
+                rows.push(std::mem::take(&mut row));
+                at_start = true;
+            }
+            _ => {
+                field.push(c);
+                at_start = false;
+            }
+        }
+    }
+    if !field.is_empty() || !row.is_empty() {
+        row.push(field);
+        rows.push(row);
+    }
+    rows
+}
diff --git a/crates/engine/src/cmd/edit/fill.rs b/crates/engine/src/cmd/edit/fill.rs
new file mode 100644
index 000000000..84f4cd6d3
--- /dev/null
+++ b/crates/engine/src/cmd/edit/fill.rs
@@ -0,0 +1,96 @@
+use super::*;
+
+// ---------------------------------------------------------------- fill
+
+pub(super) fn fill_dir(s: &mut Session, p: &Json, dr: i64, dc: i64) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let mut r = target_range(s, p)?;
+    // Whole rows or columns fill only where the sheet has content (nothing on an empty sheet).
+    if r.is_full_cols() || r.is_full_rows() {
+        match s.doc()?.wb.sheet(sheet).and_then(|sh| sh.used_range()).and_then(|u| r.intersection(&u)) {
+            Some(u) => r = u,
+            None => return Ok(Json::Null),
+        }
+    }
+    if r.count() > crate::fill::MAX_FILL_CELLS {
+        return Err(bad("edit.fill", "range too large"));
+    }
+    // With one row selected, Fill Down copies from the row above (Excel behaviour).
+    if dr == 1 && r.height() == 1 {
+        r.start.row = r.start.row.saturating_sub(1);
+    }
+    if dc == 1 && r.width() == 1 {
+        r.start.col = r.start.col.saturating_sub(1);
+    }
+    let src = if dr == 1 {
+        RangeRef::new(r.start, CellRef::new(r.start.row, r.end.col))
+    } else if dr == -1 {
+        RangeRef::new(CellRef::new(r.end.row, r.start.col), r.end)
+    } else if dc == 1 {
+        RangeRef::new(r.start, CellRef::new(r.end.row, r.start.col))
+    } else {
+        RangeRef::new(CellRef::new(r.start.row, r.end.col), r.end)
+    };
+    edit(s, |cx| {
+        crate::fill::fill(cx, sheet, src, r, crate::fill::FillMode::Copy)?;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn auto_fill(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let src = str_param(p, "source").and_then(RangeRef::parse).map_or_else(|| target_range(s, p), Ok)?;
+    let Some(target) = str_param(p, "target").and_then(RangeRef::parse) else { return Err(bad("edit.autoFill", "missing `target`")) };
+    let mode = match str_param(p, "mode").unwrap_or("series") {
+        "copy" => crate::fill::FillMode::Copy,
+        "alternate" => crate::fill::FillMode::Alternate,
+        "formats" => crate::fill::FillMode::Formats,
+        "values" => crate::fill::FillMode::ValuesOnly,
+        "extend" => crate::fill::FillMode::Extend,
+        "days" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Day),
+        "weekdays" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Weekday),
+        "months" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Month),
+        "years" => crate::fill::FillMode::Dates(crate::fill::DateUnit::Year),
+        _ => crate::fill::FillMode::Series,
+    };
+    if target.count() > crate::fill::MAX_FILL_CELLS || src.count() > crate::fill::MAX_FILL_CELLS {
+        return Err(bad("edit.autoFill", "range too large"));
+    }
+    // Excel refuses a target that doesn't hold the source in a corner. Such targets used to fill
+    // every source lane across the whole target extent: billions of cells for whole rows (`2:3`)
+    // into whole columns (`A:A`).
+    if !crate::fill::holds_source_in_corner(src, target) {
+        return Err(bad("edit.autoFill", "the target must contain the source in one of its corners"));
+    }
+    edit(s, |cx| {
+        crate::fill::fill(cx, sheet, src, target, mode)?;
+        *cx.sel = crate::Selection { active: src.start, anchor: src.start, ranges: vec![target.union(&src)] };
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn fill_series(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let r = target_range(s, p)?;
+    let rows = str_param(p, "direction").map(|d| d == "rows").unwrap_or(r.width() > r.height());
+    let kind = str_param(p, "type").unwrap_or("linear").to_string();
+    let step = f64_param(p, "step").unwrap_or(1.0);
+    let stop = f64_param(p, "stop");
+    let unit = str_param(p, "dateUnit").unwrap_or("day").to_string();
+    edit(s, |cx| {
+        crate::fill::series(cx, sheet, r, rows, &kind, step, stop, &unit)?;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn flash_fill(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = target_sheet(s, p)?;
+    let r = target_range(s, p)?;
+    let n = edit(s, |cx| crate::fill::flash_fill(cx, sheet, r.start))?;
+    if n == 0 {
+        return Err(EngineError::Other(
+            "We looked at all the data next to your selection and didn't see a pattern for filling in values for you.".into(),
+        ));
+    }
+    Ok(json!({"filled": n}))
+}
diff --git a/crates/engine/src/cmd/edit/find.rs b/crates/engine/src/cmd/edit/find.rs
new file mode 100644
index 000000000..2dcbfa886
--- /dev/null
+++ b/crates/engine/src/cmd/edit/find.rs
@@ -0,0 +1,184 @@
+use super::cell::input_to_cell;
+use super::*;
+
+// ---------------------------------------------------------------- find & replace
+
+fn matches(hay: &str, what: &str, case: bool, whole: bool) -> bool {
+    let (h, w) = if case { (hay.to_string(), what.to_string()) } else { (hay.to_lowercase(), what.to_lowercase()) };
+    let has_wild = w.contains(['*', '?']);
+    if has_wild {
+        let pat = if whole { w } else { format!("*{w}*") };
+        return wildcard(&h, &pat);
+    }
+    if whole { h == w } else { h.contains(&w) }
+}
+
+/// `*`/`?` wildcard match with `~` escapes.
+pub(crate) fn wildcard(text: &str, pat: &str) -> bool {
+    let t: Vec<char> = text.chars().collect();
+    let mut p: Vec<(char, bool)> = Vec::new();
+    let mut it = pat.chars();
+    while let Some(c) = it.next() {
+        if c == '~' {
+            if let Some(n) = it.next() {
+                p.push((n, true));
+            }
+        } else {
+            p.push((c, false));
+        }
+    }
+    let (mut ti, mut pi) = (0usize, 0usize);
+    let (mut star, mut mark) = (None, 0usize);
+    while ti < t.len() {
+        if pi < p.len() && (p[pi] == ('?', false) || (p[pi].0 == t[ti] && p[pi] != ('*', false))) {
+            ti += 1;
+            pi += 1;
+        } else if pi < p.len() && p[pi] == ('*', false) {
+            star = Some(pi);
+            mark = ti;
+            pi += 1;
+        } else if let Some(sp) = star {
+            pi = sp + 1;
+            mark += 1;
+            ti = mark;
+        } else {
+            return false;
+        }
+    }
+    while pi < p.len() && p[pi] == ('*', false) {
+        pi += 1;
+    }
+    pi == p.len()
+}
+
+pub(super) fn find(s: &mut Session, p: &Json) -> Result<Json> {
+    let what = str_param(p, "what").unwrap_or("").to_string();
+    if what.is_empty() {
+        return Err(bad("edit.find", "missing `what`"));
+    }
+    let case = bool_param(p, "matchCase").unwrap_or(false);
+    let whole = bool_param(p, "wholeCell").unwrap_or(false);
+    let values = str_param(p, "lookIn") == Some("values");
+    let by_cols = bool_param(p, "byColumns").unwrap_or(false);
+    let all = bool_param(p, "all").unwrap_or(false);
+    let workbook = str_param(p, "within") == Some("workbook");
+    s.last_find = Some(p.clone());
+    let d = s.doc()?;
+    let sheets: Vec<usize> = if workbook { (0..d.wb.sheets.len()).collect() } else { vec![d.wb.active_sheet()] };
+    let mut hits: Vec<(usize, CellRef, String)> = Vec::new();
+    for si in sheets {
+        let Some(sh) = d.wb.sheet(si) else { continue };
+        let mut cells: Vec<(CellRef, String)> = sh
+            .cells
+            .iter()
+            .filter_map(|(c, cell)| {
+                let text = if values || cell.formula.is_none() || crate::display::formula_hidden(&d.wb, sh, c) {
+                    crate::display::cell_text(&d.wb, sh, c)
+                } else {
+                    cell.input_text()
+                };
+                matches(&text, &what, case, whole).then_some((c, text))
+            })
+            .collect();
+        if by_cols {
+            cells.sort_by_key(|(c, _)| (c.col, c.row));
+        }
+        hits.extend(cells.into_iter().map(|(c, t)| (si, c, t)));
+    }
+    if hits.is_empty() {
+        return Err(EngineError::Other(format!("We couldn't find what you were looking for: {what}")));
+    }
+    if all {
+        let list: Vec<Json> =
+            hits.iter().map(|(si, c, t)| json!({"sheet": d.wb.sheet(*si).map(|s| s.name.clone()), "cell": c.a1(), "value": t})).collect();
+        return Ok(json!({"count": list.len(), "results": list}));
+    }
+    // Next hit after the active cell.
+    let cur = (d.wb.active_sheet(), d.selection.active);
+    let key = |si: usize, c: CellRef| if by_cols { (si, c.col, c.row) } else { (si, c.row, c.col) };
+    let next = hits.iter().find(|(si, c, _)| key(*si, *c) > key(cur.0, cur.1)).or_else(|| hits.first()).cloned();
+    let Some((si, c, t)) = next else { return Err(EngineError::Other("not found".into())) };
+    let dd = s.doc_mut()?;
+    dd.wb_switch_sheet(si);
+    dd.selection = crate::Selection::at(c);
+    Ok(json!({"cell": c.a1(), "sheet": si, "value": t, "count": hits.len()}))
+}
+
+pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
+    let what = str_param(p, "what").unwrap_or("").to_string();
+    let with = str_param(p, "with").unwrap_or("").to_string();
+    if what.is_empty() {
+        return Err(bad("edit.replace", "missing `what`"));
+    }
+    let case = bool_param(p, "matchCase").unwrap_or(false);
+    let whole = bool_param(p, "wholeCell").unwrap_or(false);
+    let all = bool_param(p, "all").unwrap_or(true);
+    let workbook = str_param(p, "within") == Some("workbook");
+    let active = s.doc()?.selection.active;
+    let n = edit(s, |cx| {
+        let sheets: Vec<usize> = if workbook { (0..cx.wb.sheets.len()).collect() } else { vec![cx.wb.active_sheet()] };
+        let mut n = 0;
+        for si in sheets {
+            let cells: Vec<(CellRef, String)> =
+                cx.wb.sheet(si).map(|sh| sh.cells.iter().map(|(c, _)| (c, sh.input_text(c))).collect()).unwrap_or_default();
+            for (c, text) in cells {
+                if !all && c != active {
+                    continue;
+                }
+                if !matches(&text, &what, case, whole) {
+                    continue;
+                }
+                let new = if whole {
+                    with.clone()
+                } else if case {
+                    text.replace(&what, &with)
+                } else {
+                    replace_ci(&text, &what, &with)
+                };
+                let cell = input_to_cell(&new, si, c, &mut cx.wb).unwrap_or_else(|_| Some(Cell::value(Value::text(new.as_str()))));
+                let sh = cx.sheet_mut(si)?;
+                match cell {
+                    Some(cell) => sh.set_cell(c, cell),
+                    None => {
+                        sh.remove_cell(c);
+                    }
+                }
+                cx.touch(si, c);
+                n += 1;
+            }
+        }
+        Ok(n)
+    })?;
+    Ok(json!({"replaced": n}))
+}
+
+/// Whether case-folding `s` maps every char to exactly one char of the same UTF-8 length, so
+/// byte positions in the folded text still line up with the original's character boundaries.
+fn folds_in_place(s: &str) -> bool {
+    s.chars().all(|c| {
+        let mut folded = c.to_lowercase();
+        let first = folded.next();
+        folded.next().is_none() && first.is_some_and(|l| l.len_utf8() == c.len_utf8())
+    })
+}
+
+pub(super) fn replace_ci(text: &str, what: &str, with: &str) -> String {
+    let lower = text.to_lowercase();
+    let w = what.to_lowercase();
+    // Slicing `text` at positions found in `lower` is only sound when folding kept every byte
+    // boundary: a length check alone misses foldings that keep the total length while shifting
+    // boundaries (U+212A KELVIN SIGN shrinks 3→1 bytes, U+0130 grows 2→3), where the tail used
+    // to be dropped. Those fall back to the case-sensitive replace, as length changes already do.
+    if lower.len() != text.len() || w.is_empty() || !folds_in_place(text) || !folds_in_place(what) {
+        return text.replace(what, with);
+    }
+    let mut out = String::new();
+    let mut i = 0;
+    while let Some(pos) = lower.get(i..).and_then(|s| s.find(&w)) {
+        out.push_str(text.get(i..i + pos).unwrap_or(""));
+        out.push_str(with);
+        i += pos + w.len();
+    }
+    out.push_str(text.get(i..).unwrap_or(""));
+    out
+}
diff --git a/crates/engine/src/cmd/edit/go_to.rs b/crates/engine/src/cmd/edit/go_to.rs
new file mode 100644
index 000000000..b94bcd221
--- /dev/null
+++ b/crates/engine/src/cmd/edit/go_to.rs
@@ -0,0 +1,199 @@
+use super::selection::{select_region, selection_set};
+use super::*;
+
+/// How many references the Go To dialog keeps for going back to.
+pub(super) const GO_TO_RECENT: usize = 10;
+
+/// The most areas one Go To selects.
+pub(super) const GO_TO_MAX_AREAS: usize = 2000;
+
+/// How deep a name that refers to other names is followed.
+const GO_TO_NAME_DEPTH: usize = 8;
+
+pub(in super::super) fn go_to(s: &mut Session, p: &Json) -> Result<Json> {
+    if bool_param(p, "list") == Some(true) {
+        let d = s.doc()?;
+        return Ok(json!({"names": go_to_names(&d.wb, d.wb.active_sheet()), "recent": d.go_to_recent}));
+    }
+    let Some(reference) = str_param(p, "reference").or_else(|| str_param(p, "range")) else { return Err(bad("edit.goTo", "missing `reference`")) };
+    let d = s.doc()?;
+    let mut target: Option<usize> = None;
+    let mut areas: Vec<RangeRef> = Vec::new();
+    let mut named = false;
+    for part in reference_parts(reference) {
+        let Some((sheet, found, by_name)) = go_to_target(&d.wb, d.wb.active_sheet(), part, 0) else {
+            return Err(EngineError::Other("Reference isn't valid.".into()));
+        };
+        // One selection holds the areas of one sheet.
+        if target.is_some_and(|t| t != sheet) {
+            return Err(EngineError::Other("Reference isn't valid.".into()));
+        }
+        target = Some(sheet);
+        named |= by_name;
+        areas.extend(found);
+        if areas.len() > GO_TO_MAX_AREAS {
+            return Err(EngineError::Other(format!("Go To selects at most {GO_TO_MAX_AREAS} areas.")));
+        }
+    }
+    let Some(sheet) = target else { return Err(EngineError::Other("Reference isn't valid.".into())) };
+    let range = areas.iter().map(RangeRef::a1).collect::<Vec<_>>().join(",");
+    let out = selection_set(s, &json!({"sheet": sheet, "range": range}))?;
+    if bool_param(p, "record") == Some(true) && !named {
+        let d = s.doc_mut()?;
+        let prefix = gridcraft_core::quote_sheet(&d.wb.sheet(sheet).map(|sh| sh.name.clone()).unwrap_or_default());
+        let entry = areas.iter().map(|r| format!("{prefix}!{}", r.a1())).collect::<Vec<_>>().join(",");
+        d.go_to_recent.retain(|r| !r.eq_ignore_ascii_case(&entry));
+        d.go_to_recent.insert(0, entry);
+        d.go_to_recent.truncate(GO_TO_RECENT);
+    }
+    Ok(out)
+}
+
+/// The parts of a Go To reference, split at the commas outside quoted sheet names and
+/// parentheses: `Price, Type` or `B14:C22,F19:G30`. The parts are read one at a time, so a caller
+/// that stops at an invalid part or at `GO_TO_MAX_AREAS` does not split the rest of the text.
+pub(super) fn reference_parts(text: &str) -> impl Iterator<Item = &str> {
+    let (mut depth, mut quoted, mut start, mut done) = (0usize, false, 0, false);
+    let mut chars = text.char_indices();
+    std::iter::from_fn(move || {
+        if done {
+            return None;
+        }
+        for (i, c) in chars.by_ref() {
+            match c {
+                '\'' => quoted = !quoted,
+                '(' if !quoted => depth += 1,
+                ')' if !quoted => depth = depth.saturating_sub(1),
+                ',' if !quoted && depth == 0 => {
+                    let part = text.get(start..i).unwrap_or("").trim();
+                    start = i + 1;
+                    return Some(part);
+                }
+                _ => {}
+            }
+        }
+        done = true;
+        Some(text.get(start..).unwrap_or("").trim())
+    })
+}
+
+/// Where one part of a Go To reference points, seen from sheet `sheet`: the sheet, its areas,
+/// and whether a defined name or a table gave them. `Sheet2!Name` is the name scoped to Sheet2.
+/// A name counts when what it refers to is a reference; a constant or a formula is not one.
+fn go_to_target(wb: &gridcraft_model::Workbook, sheet: usize, part: &str, depth: usize) -> Option<(usize, Vec<RangeRef>, bool)> {
+    if part.is_empty() || depth > GO_TO_NAME_DEPTH {
+        return None;
+    }
+    let (prefix, body) = split_sheet(part);
+    let on = match &prefix {
+        Some(n) => wb.sheet_index(n)?,
+        None => sheet,
+    };
+    if let Some(r) = RangeRef::parse(&body.replace('$', "")) {
+        return Some((on, vec![r], false));
+    }
+    let name = match prefix {
+        Some(_) => wb.names.iter().find(|n| n.scope == Some(on) && gridcraft_formula::same_name(&n.name, body)),
+        None => wb.name(body, sheet),
+    };
+    if let Some(n) = name {
+        return name_areas(wb, n, sheet, depth).map(|(t, areas)| (t, areas, true));
+    }
+    if prefix.is_none()
+        && let Some((si, ti)) = wb.table(body)
+    {
+        // As in Excel, a table's name stands for its data, without the header and totals rows.
+        let t = wb.sheet(si)?.tables.get(ti)?;
+        return Some((si, vec![t.data_range().unwrap_or(t.range)], true));
+    }
+    None
+}
+
+/// The sheet and areas defined name `n` refers to, seen from sheet `sheet`, when that is a
+/// reference.
+fn name_areas(wb: &gridcraft_model::Workbook, n: &gridcraft_model::DefinedName, sheet: usize, depth: usize) -> Option<(usize, Vec<RangeRef>)> {
+    let from = n.scope.unwrap_or(sheet);
+    let formula = n.formula.trim().trim_start_matches('=');
+    let mut target: Option<usize> = None;
+    let mut areas = Vec::new();
+    for p in reference_parts(formula) {
+        let (s, found, _) = go_to_target(wb, from, p, depth + 1)?;
+        if target.is_some_and(|t| t != s) {
+            return None;
+        }
+        target = Some(s);
+        areas.extend(found);
+        if areas.len() > GO_TO_MAX_AREAS {
+            return None;
+        }
+    }
+    target.map(|t| (t, areas))
+}
+
+/// The names the Go To dialog lists, seen from sheet `sheet`: the named ranges of the workbook and
+/// of every sheet, in alphabetical order. A name scoped to another sheet is written `Sheet2!Name`,
+/// and the active sheet's own name hides the workbook name it shares. Hidden names and names that
+/// do not refer to a range are left out.
+pub fn go_to_names(wb: &gridcraft_model::Workbook, sheet: usize) -> Vec<String> {
+    let own: std::collections::HashSet<String> =
+        wb.names.iter().filter(|n| n.scope == Some(sheet)).map(|n| gridcraft_formula::fold_name(&n.name)).collect();
+    let mut out: Vec<String> = wb
+        .names
+        .iter()
+        .filter(|n| !n.hidden && name_areas(wb, n, sheet, 0).is_some())
+        .filter_map(|n| match n.scope {
+            None if own.contains(&gridcraft_formula::fold_name(&n.name)) => None,
+            None => Some(n.name.clone()),
+            Some(s) if s == sheet => Some(n.name.clone()),
+            Some(s) => Some(format!("{}!{}", gridcraft_core::quote_sheet(&wb.sheet(s)?.name), n.name)),
+        })
+        .collect();
+    out.sort_by_cached_key(|n| gridcraft_formula::fold_name(n));
+    out.dedup_by(|a, b| gridcraft_formula::same_name(a, b));
+    out
+}
+
+pub(super) fn go_to_special(s: &mut Session, p: &Json) -> Result<Json> {
+    let kind = str_param(p, "kind").unwrap_or("blanks");
+    let d = s.doc()?;
+    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
+    let scope = if d.selection.is_single_cell() { sheet.used_range().unwrap_or(RangeRef::cell(d.selection.active)) } else { d.selection.bounds() };
+    if kind == "lastCell" {
+        let c = sheet.used_range().map(|r| r.end).unwrap_or_default();
+        return selection_set(s, &json!({"cell": c.a1()}));
+    }
+    if kind == "currentRegion" {
+        return select_region(s, &json!({}));
+    }
+    let mut hits: Vec<CellRef> = Vec::new();
+    if scope.count() > 4_000_000 {
+        return Err(bad("edit.goToSpecial", "range too large"));
+    }
+    for c in scope.iter() {
+        let cell = sheet.cell(c);
+        let v = sheet.value(c);
+        let ok = match kind {
+            "blanks" => v.is_empty(),
+            "constants" => cell.is_some_and(|x| x.formula.is_none() && !x.value.is_empty()),
+            "formulas" => cell.is_some_and(|x| x.formula.is_some()),
+            "comments" | "notes" => sheet.comments.contains_key(&c),
+            "errors" => v.is_error(),
+            "numbers" => v.is_number(),
+            "text" => v.is_text(),
+            "visible" => !sheet.is_row_hidden(c.row) && !sheet.is_col_hidden(c.col),
+            "conditionalFormats" => sheet.cond_formats.iter().any(|cf| cf.ranges.iter().any(|r| r.contains(c))),
+            "dataValidation" => sheet.validations.iter().any(|dv| dv.ranges.iter().any(|r| r.contains(c))),
+            _ => return Err(bad("edit.goToSpecial", format!("unknown kind `{kind}`"))),
+        };
+        if ok {
+            hits.push(c);
+        }
+    }
+    if hits.is_empty() {
+        return Err(EngineError::Other("No cells were found.".into()));
+    }
+    let ranges = coalesce(&hits);
+    let d = s.doc_mut()?;
+    d.selection = crate::Selection { active: hits[0], anchor: hits[0], ranges };
+    Ok(json!({"selection": d.selection.a1(), "count": hits.len()}))
+}
diff --git a/crates/engine/src/cmd/edit/paste_special.rs b/crates/engine/src/cmd/edit/paste_special.rs
new file mode 100644
index 000000000..eba1b429e
--- /dev/null
+++ b/crates/engine/src/cmd/edit/paste_special.rs
@@ -0,0 +1,351 @@
+use super::clipboard::What;
+use super::*;
+
+pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
+    let Some(clip) = s.clipboard.clone() else { return Err(EngineError::Other("Nothing to paste.".into())) };
+    let what = match str_param(p, "what").unwrap_or("all") {
+        "all" => What::All,
+        "formulas" => What::Formulas,
+        "values" => What::Values,
+        "formats" => What::Formats,
+        "comments" | "notes" => What::Comments,
+        "validation" => What::Validation,
+        "allExceptBorders" => What::AllExceptBorders,
+        "columnWidths" => What::ColumnWidths,
+        "formulasAndNumberFormats" => What::FormulasAndNumberFormats,
+        "valuesAndNumberFormats" => What::ValuesAndNumberFormats,
+        other => return Err(bad("edit.pasteSpecial", format!("unknown `what`: {other}"))),
+    };
+    let op = str_param(p, "operation").unwrap_or("none").to_string();
+    let skip_blanks = bool_param(p, "skipBlanks").unwrap_or(false);
+    let transpose = bool_param(p, "transpose").unwrap_or(false);
+    let link = bool_param(p, "link").unwrap_or(false);
+    if link && !clip.areas.is_empty() {
+        return Err(EngineError::Other("This action won't work on multiple selections.".into()));
+    }
+    let dest_sheet = target_sheet(s, p)?;
+    let sel = s.doc()?.selection.current();
+    let at = cell_param_on(s, p, "at", dest_sheet)?.unwrap_or(sel.start);
+    let src = clip.range;
+    let (h, w) = if transpose { (src.width(), src.height()) } else { (src.height(), src.width()) };
+    // Tile the copy over a larger destination that is a multiple of its size.
+    let tile = sel.height() % h == 0
+        && sel.width() % w == 0
+        && !sel.is_single()
+        && cell_param_on(s, p, "at", dest_sheet)?.is_none()
+        && !sel.is_full_cols()
+        && !sel.is_full_rows()
+        && sel.count() <= 4_000_000;
+    let (tiles_r, tiles_c) = if tile { (sel.height() / h, sel.width() / w) } else { (1, 1) };
+    let same_doc = s.doc()?.uid == clip.doc_uid;
+    let cut_move = clip.cut && same_doc && what == What::All;
+    let src_wb = clip.wb.clone();
+    let Some(src_sheet) = src_wb.sheet(clip.sheet) else { return Err(EngineError::Other("The copied sheet no longer exists.".into())) };
+    let src_sheet_name = src_sheet.name.clone();
+    if cut_move && at.offset((tiles_r * h).saturating_sub(1) as i64, (tiles_c * w).saturating_sub(1) as i64).is_none() {
+        // Check the whole footprint before the source is emptied, so a move that overflows the grid loses nothing.
+        return Err(EngineError::Other("The cut area doesn't fit at this position; nothing was moved.".into()));
+    }
+    edit(s, |cx| {
+        // Styles from another workbook must be re-interned.
+        let mut style_map = std::collections::HashMap::new();
+        let mut map_style = |id: StyleId, wb: &mut gridcraft_model::Workbook| -> StyleId {
+            if same_doc {
+                return id;
+            }
+            *style_map.entry(id).or_insert_with(|| wb.styles.intern(src_wb.styles.get(id).clone()))
+        };
+        let mut moved_formulas = Vec::new();
+        let mut moved_pictures = std::collections::BTreeMap::new();
+        if cut_move {
+            // Remove the source first (contents and formats), and fix references to it.
+            let source = cx.sheet_mut(clip.sheet)?;
+            moved_pictures = source.cell_pictures.iter().filter(|(c, _)| src.contains(**c)).map(|(c, p)| (*c, p.clone())).collect();
+            let taken = source.take_cells(src);
+            // Notes, hyperlinks and merged areas sit beside the cells, and a cut takes them
+            // with the block: the destination is written from the clipboard snapshot taken
+            // before the cut, so removing them here loses nothing and leaves the old place
+            // clean instead of leaving one merged block and one note behind.
+            source.comments.retain(|c, _| !src.contains(*c));
+            source.hyperlinks.retain(|c, _| !src.contains(*c));
+            source.merges.retain(|m| !src.contains_range(m));
+            for (c, _) in &taken {
+                cx.touch(clip.sheet, *c);
+            }
+            moved_formulas = taken;
+        }
+        for tr in 0..tiles_r {
+            for tc in 0..tiles_c {
+                for r in 0..src.height() {
+                    for c in 0..src.width() {
+                        let sc = CellRef::new(src.start.row + r, src.start.col + c);
+                        let (dr, dc) = if transpose { (c, r) } else { (r, c) };
+                        let Some(dest) = at.offset((tr * h + dr) as i64, (tc * w + dc) as i64) else { continue };
+                        let src_cell = if cut_move {
+                            moved_formulas.iter().find(|(k, _)| *k == sc).map(|(_, v)| v.clone())
+                        } else {
+                            src_sheet.cell(sc).cloned()
+                        };
+                        let src_val = src_sheet.value(sc);
+                        let src_picture = if cut_move { moved_pictures.get(&sc) } else { src_sheet.cell_pictures.get(&sc) }.cloned();
+                        if skip_blanks && src_picture.is_none() && src_val.is_empty() && src_cell.as_ref().is_none_or(|x| x.formula.is_none()) {
+                            continue;
+                        }
+                        let old = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell(dest)).cloned().unwrap_or_default();
+                        let old_picture = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell_pictures.get(&dest)).cloned();
+                        let mut new_picture = old_picture.clone();
+                        let mut new = old.clone();
+                        let shift = |cell: &Cell| -> Option<std::sync::Arc<Formula>> {
+                            let f = cell.formula.as_ref()?;
+                            let e = f.expr()?;
+                            if cut_move {
+                                // A moved formula still reads cells on its original sheet. Qualify
+                                // those references before the workbook-wide move adjustment below.
+                                let e = if dest_sheet != clip.sheet {
+                                    e.map(&mut |x| match x {
+                                        gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
+                                            r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
+                                            gridcraft_formula::Expr::Ref(r)
+                                        }
+                                        other => other,
+                                    })
+                                } else {
+                                    e
+                                };
+                                let mut moved = Formula::from_expr(e);
+                                // The array range moves with its formula.
+                                let (dr, dc) = (dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
+                                moved.array = f.array.and_then(|a| Some(RangeRef::new(a.start.offset(dr, dc)?, a.end.offset(dr, dc)?)));
+                                moved.dynamic = f.dynamic;
+                                return Some(std::sync::Arc::new(moved));
+                            }
+                            let moved =
+                                gridcraft_formula::adjust::shift_relative(e, dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
+                            Some(std::sync::Arc::new(Formula { dynamic: f.dynamic, ..Formula::from_expr(moved) }))
+                        };
+                        if link {
+                            let sheet_prefix = if dest_sheet == clip.sheet && same_doc {
+                                String::new()
+                            } else {
+                                format!("{}!", gridcraft_formula::quote_sheet(&src_sheet_name))
+                            };
+                            new.formula = Some(std::sync::Arc::new(Formula::new(&format!("={sheet_prefix}{}", sc.a1()))));
+                            new.value = Value::Empty;
+                            new_picture = None;
+                        } else {
+                            let sc_cell = src_cell.clone().unwrap_or_default();
+                            match what {
+                                What::All | What::AllExceptBorders => {
+                                    new_picture = src_picture.clone();
+                                    new.formula = shift(&sc_cell);
+                                    new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                                    let st = map_style(sc_cell.style, &mut cx.wb);
+                                    new.style = if what == What::AllExceptBorders {
+                                        let borders = cx.wb.styles.get(old.style).borders;
+                                        cx.wb.styles.derive(st, |s| s.borders = borders)
+                                    } else {
+                                        st
+                                    };
+                                }
+                                What::Formulas | What::FormulasAndNumberFormats => {
+                                    new_picture = src_picture.clone();
+                                    new.formula = shift(&sc_cell);
+                                    new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                                    if what == What::FormulasAndNumberFormats {
+                                        let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
+                                        new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
+                                    }
+                                }
+                                What::Values | What::ValuesAndNumberFormats => {
+                                    new_picture = src_picture.clone();
+                                    new.formula = None;
+                                    new.value = src_val.clone();
+                                    if what == What::ValuesAndNumberFormats {
+                                        let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
+                                        new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
+                                    }
+                                }
+                                What::Formats => new.style = map_style(sc_cell.style, &mut cx.wb),
+                                What::Comments | What::Validation | What::ColumnWidths => {}
+                            }
+                            // Operations combine numbers with what is already there.
+                            if op != "none"
+                                && matches!(what, What::All | What::Values | What::ValuesAndNumberFormats | What::Formulas)
+                                && new.formula.is_none()
+                            {
+                                if old_picture.is_some() || new_picture.is_some() {
+                                    new_picture = None;
+                                    new.value = Value::Error(gridcraft_core::CellError::Value);
+                                }
+                                let a = old.value.clone();
+                                let b = new.value.clone();
+                                // Numbers stored as text take part (multiplying by 1 turns them into
+                                // numbers); other text and errors stay as they are.
+                                if let (Ok(x), Ok(y)) = (a.to_number(), b.to_number())
+                                    && (a.is_number() || a.is_empty() || a.is_text())
+                                    && (b.is_number() || b.is_empty())
+                                {
+                                    new.value = match op.as_str() {
+                                        "add" => Value::number(x + y),
+                                        "subtract" => Value::number(x - y),
+                                        "multiply" => Value::number(x * y),
+                                        "divide" => {
+                                            if y == 0.0 {
+                                                Value::Error(gridcraft_core::CellError::Div0)
+                                            } else {
+                                                Value::number(x / y)
+                                            }
+                                        }
+                                        _ => b.clone(),
+                                    };
+                                } else if (a.is_text() || a.is_error()) && (b.is_number() || b.is_empty()) {
+                                    new.value = a;
+                                }
+                                // A formula already there is kept and combined with the pasted number.
+                                if let Some(f) = &old.formula
+                                    && let Ok(y) = b.to_number()
+                                    && (b.is_number() || b.is_empty())
+                                    && let Some(sym) = match op.as_str() {
+                                        "add" => Some('+'),
+                                        "subtract" => Some('-'),
+                                        "multiply" => Some('*'),
+                                        "divide" => Some('/'),
+                                        _ => None,
+                                    }
+                                {
+                                    let text = format!("=({}){sym}{}", f.text, gridcraft_core::number_to_text(y));
+                                    new.formula = Some(std::sync::Arc::new(Formula::new(&text)));
+                                    new.value = Value::Empty;
+                                }
+                            }
+                        }
+                        // The copied cell's validation rule replaces whatever rule the destination had.
+                        if !link && matches!(what, What::All | What::AllExceptBorders | What::Validation) {
+                            let rule = src_sheet.validations.iter().find(|dv| dv.ranges.iter().any(|r| r.contains(sc))).cloned();
+                            let sh = cx.sheet_mut(dest_sheet)?;
+                            crate::cmd::data::remove_validation_cells(&mut sh.validations, &[RangeRef::new(dest, dest)]);
+                            if let Some(mut dv) = rule {
+                                // Relative references move with the rule, as pasted formulas do.
+                                let first = dv.ranges.first().map_or(sc, |r| r.start);
+                                dv.f1 = crate::cmd::data::move_rule_formula(&dv.f1, first, dest);
+                                dv.f2 = dv.f2.map(|f| crate::cmd::data::move_rule_formula(&f, first, dest));
+                                dv.ranges = vec![RangeRef::new(dest, dest)];
+                                sh.validations.push(dv);
+                            }
+                        }
+                        match what {
+                            What::Comments => {
+                                if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
+                                    cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
+                                }
+                            }
+                            What::ColumnWidths => {
+                                if let Some(info) = src_sheet.cols.get(&sc.col).copied() {
+                                    cx.sheet_mut(dest_sheet)?.cols.insert(dest.col, info);
+                                }
+                            }
+                            What::All => {
+                                if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
+                                    cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
+                                }
+                                if let Some(h) = src_sheet.hyperlinks.get(&sc).cloned() {
+                                    cx.sheet_mut(dest_sheet)?.hyperlinks.insert(dest, h);
+                                }
+                                cx.sheet_mut(dest_sheet)?.set_cell(dest, new);
+                            }
+                            _ => cx.sheet_mut(dest_sheet)?.set_cell(dest, new),
+                        }
+                        if let Some(picture) = new_picture {
+                            cx.sheet_mut(dest_sheet)?.cell_pictures.insert(dest, picture);
+                        }
+                        cx.touch(dest_sheet, dest);
+                    }
+                }
+            }
+        }
+        // Merged areas inside the copied block travel with it.
+        if matches!(what, What::All | What::Formats) && !transpose {
+            let merges: Vec<RangeRef> = src_sheet.merges.iter().filter(|m| src.contains_range(m)).copied().collect();
+            for m in merges {
+                let dr = at.row as i64 - src.start.row as i64;
+                let dc = at.col as i64 - src.start.col as i64;
+                if let (Some(a), Some(b)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
+                    let nm = RangeRef::new(a, b);
+                    let sh = cx.sheet_mut(dest_sheet)?;
+                    sh.merges.retain(|x| !x.intersects(&nm));
+                    sh.merges.push(nm);
+                }
+            }
+        }
+        if cut_move {
+            // References elsewhere to the moved block now point to its new place.
+            let dest_name = cx.wb.sheet(dest_sheet).map(|s| s.name.clone()).unwrap_or_default();
+            let e = if dest_sheet == clip.sheet {
+                gridcraft_formula::adjust::Edit::Move { from: src, to_row: at.row, to_col: at.col }
+            } else {
+                gridcraft_formula::adjust::Edit::MoveToSheet { from: src, to_sheet: dest_name, to_row: at.row, to_col: at.col }
+            };
+            rewrite_all_formulas(&mut cx.wb, &src_sheet_name, &e);
+            cx.structural = true;
+        }
+        let end = at.offset_clamped((tiles_r * h) as i64 - 1, (tiles_c * w) as i64 - 1);
+        *cx.sel = crate::Selection { active: at, anchor: at, ranges: vec![RangeRef::new(at, end)] };
+        Ok(())
+    })?;
+    // Formulas and validation from an untrusted file leave the destination untrusted; plain values,
+    // formats (cell styles and merged areas, no conditional formats), column widths and notes
+    // carry nothing active. A linked paste writes a formula into every cell whatever `what` says,
+    // except for column widths and notes, which write no cells at all.
+    let passive =
+        matches!(what, What::ColumnWidths | What::Comments) || (!link && matches!(what, What::Formats | What::Values | What::ValuesAndNumberFormats));
+    if !same_doc && !passive {
+        let d = s.doc_mut()?;
+        d.trust = d.trust.receive(clip.trust);
+    }
+    if cut_move {
+        s.clipboard = None;
+    }
+    Ok(json!({"pasted": s.doc()?.selection.a1()}))
+}
+
+/// Applies a reference adjustment to every cell formula and defined name in the workbook.
+pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &str, e: &gridcraft_formula::adjust::Edit) {
+    use gridcraft_formula::adjust::Edit;
+    // Rows and columns inserted or deleted on the target sheet move its legacy array ranges too
+    // (a cut moves its arrays itself).
+    let moves_arrays = matches!(e, Edit::Insert { .. } | Edit::Delete { .. } | Edit::InsertCells { .. } | Edit::DeleteCells { .. });
+    for si in 0..wb.sheets.len() {
+        let host = wb.sheets.get(si).map(|s| s.name.clone()).unwrap_or_default();
+        let keys: Vec<(CellRef, std::sync::Arc<Formula>)> =
+            wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, cell)| cell.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
+        if keys.is_empty() {
+            continue;
+        }
+        let on_target = moves_arrays && host.eq_ignore_ascii_case(target);
+        let Some(sheet) = wb.sheet_mut(si) else { continue };
+        for (c, f) in keys {
+            let Some(expr) = f.expr() else { continue };
+            let new = gridcraft_formula::adjust::adjust(expr, &host, target, e);
+            let text = gridcraft_formula::print(&new);
+            let array = match f.array {
+                Some(a) if on_target => crate::cmd::sheet::map_range(a, e),
+                a => a,
+            };
+            if (text != f.text || array != f.array)
+                && let Some(cell) = sheet.cells.get_mut(c)
+            {
+                let mut nf = Formula::from_expr(new);
+                nf.array = array;
+                nf.dynamic = f.dynamic;
+                cell.formula = Some(std::sync::Arc::new(nf));
+            }
+        }
+    }
+    for n in wb.names.iter_mut() {
+        if let Ok(expr) = gridcraft_formula::parse_name(&n.formula) {
+            // Names are workbook-level: unqualified refs don't occur; qualified ones adjust.
+            let new = gridcraft_formula::adjust::adjust(expr, "\u{0}", target, e);
+            n.formula = gridcraft_formula::print(&new);
+        }
+    }
+}
diff --git a/crates/engine/src/cmd/edit/selection.rs b/crates/engine/src/cmd/edit/selection.rs
new file mode 100644
index 000000000..95793f338
--- /dev/null
+++ b/crates/engine/src/cmd/edit/selection.rs
@@ -0,0 +1,171 @@
+use super::*;
+
+// ---------------------------------------------------------------- selection
+
+/// Whether the cell may be selected: a protected sheet can forbid selecting locked and/or unlocked cells.
+fn cell_selectable(wb: &gridcraft_model::Workbook, sheet: &gridcraft_model::Sheet, c: CellRef) -> bool {
+    let Some(p) = sheet.protection.as_ref() else { return true };
+    if wb.styles.get(sheet.style_id(c)).protection.locked { p.select_locked } else { p.select_unlocked }
+}
+
+pub(super) fn selection_set(s: &mut Session, p: &Json) -> Result<Json> {
+    if p.get("sheet").is_some() {
+        let i = target_sheet(s, p)?;
+        s.doc_mut()?.wb_switch_sheet(i);
+    } else if let Some(r) = str_param(p, "range").or_else(|| str_param(p, "cell"))
+        && let (Some(_), _) = split_sheet(r)
+    {
+        let i = target_sheet(s, p)?;
+        s.doc_mut()?.wb_switch_sheet(i);
+    }
+    let ranges = target_ranges(s, p)?;
+    let active = cell_param(s, p, "active")?;
+    let d = s.doc_mut()?;
+    let active = active.or_else(|| ranges.last().map(|r| r.start)).unwrap_or_default();
+    let mut sel = crate::Selection { active, anchor: ranges.last().map(|r| r.start).unwrap_or(active), ranges };
+    if let Some(sh) = d.wb.active() {
+        sel.expand_merges(sh);
+        if !cell_selectable(&d.wb, sh, sel.active) {
+            return Err(EngineError::Other("The cell you are trying to change is on a protected sheet that does not allow selecting it.".into()));
+        }
+    }
+    d.selection = sel;
+    Ok(json!({"selection": d.selection.a1(), "active": d.selection.active.a1()}))
+}
+
+impl crate::DocState {
+    /// Switches the active sheet, remembering each sheet's selection.
+    pub fn wb_switch_sheet(&mut self, i: usize) {
+        if i >= self.wb.sheets.len() || i == self.wb.active_sheet() {
+            return;
+        }
+        let cur = self.wb.active_sheet();
+        if self.sheet_selections.len() < self.wb.sheets.len() {
+            self.sheet_selections.resize(self.wb.sheets.len(), crate::Selection::default());
+        }
+        if let Some(slot) = self.sheet_selections.get_mut(cur) {
+            *slot = self.selection.clone();
+        }
+        // View state: set in place, so the workbook is neither copied nor made dirty.
+        self.wb.set_active_sheet(i);
+        self.selection = self.sheet_selections.get(i).cloned().unwrap_or_default();
+    }
+}
+
+pub(super) fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
+    let dr = p.get("dr").and_then(Json::as_i64).unwrap_or(0);
+    let dc = p.get("dc").and_then(Json::as_i64).unwrap_or(0);
+    let extend = bool_param(p, "extend").unwrap_or(false);
+    let jmp = bool_param(p, "jump").unwrap_or(false);
+    let d = s.doc_mut()?;
+    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
+    let sel = &mut d.selection;
+    // Extension moves the far corner, not the active cell.
+    let from = if extend { sel.moving_end() } else { sel.active };
+    // Skip hidden rows/columns and step over merged areas.
+    let mut to = if jmp {
+        jump(sheet, from, dr.signum(), dc.signum())
+    } else {
+        let mut t = from.offset_clamped(dr, dc);
+        let mut guard = 0;
+        while (sheet.is_row_hidden(t.row) || sheet.is_col_hidden(t.col)) && guard < 100_000 {
+            let n = t.offset_clamped(dr.signum(), dc.signum());
+            if n == t {
+                break;
+            }
+            t = n;
+            guard += 1;
+        }
+        if !extend && let Some(m) = sheet.merge_at(from) {
+            // Leaving a merged cell moves from its edge.
+            if dr > 0 {
+                t = CellRef::new(m.end.offset_clamped(dr, 0).row, from.col);
+            } else if dc > 0 {
+                t = CellRef::new(from.row, m.end.offset_clamped(0, dc).col);
+            }
+        }
+        t
+    };
+    if let Some(m) = sheet.merge_at(to)
+        && !extend
+    {
+        to = m.start;
+    }
+    if !extend && !cell_selectable(&d.wb, sheet, to) {
+        // Step on to the next selectable cell in the same direction; stay put if there is none.
+        let (sr, sc) = (dr.signum(), dc.signum());
+        let mut t = to;
+        let mut found = false;
+        if !jmp && (sr, sc) != (0, 0) {
+            for _ in 0..10_000 {
+                let n = t.offset_clamped(sr, sc);
+                if n == t {
+                    break;
+                }
+                t = n;
+                if !sheet.is_row_hidden(t.row) && !sheet.is_col_hidden(t.col) && cell_selectable(&d.wb, sheet, t) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if !found {
+            return Ok(json!({"selection": sel.a1(), "active": sel.active.a1()}));
+        }
+        to = t;
+    }
+    if extend {
+        sel.extend_to(to);
+        sel.expand_merges(sheet);
+    } else {
+        *sel = crate::Selection::at(to);
+        if let Some(m) = sheet.merge_at(to) {
+            sel.ranges = vec![m];
+        }
+    }
+    Ok(json!({"selection": sel.a1(), "active": sel.active.a1()}))
+}
+
+pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result<Json> {
+    let fwd = bool_param(p, "forward").unwrap_or(true);
+    let by_row = bool_param(p, "byRow").unwrap_or(false);
+    let d = s.doc_mut()?;
+    d.selection.cycle(fwd, by_row);
+    Ok(json!({"active": d.selection.active.a1()}))
+}
+
+pub(super) fn select_all(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc_mut()?;
+    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
+    let region = current_region(sheet, d.selection.active);
+    let all = RangeRef::all();
+    let r = if region.is_single() || d.selection.current() == region { all } else { region };
+    let active = d.selection.active;
+    d.selection = crate::Selection { active, anchor: r.start, ranges: vec![r] };
+    Ok(json!({"selection": d.selection.a1()}))
+}
+
+pub(super) fn select_region(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc_mut()?;
+    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
+    let r = current_region(sheet, d.selection.active);
+    let active = d.selection.active;
+    d.selection = crate::Selection { active, anchor: r.start, ranges: vec![r] };
+    Ok(json!({"selection": d.selection.a1()}))
+}
+
+pub(super) fn select_row(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc_mut()?;
+    let r = d.selection.current();
+    let active = d.selection.active;
+    d.selection = crate::Selection { active, anchor: CellRef::new(r.start.row, 0), ranges: vec![RangeRef::rows(r.start.row, r.end.row)] };
+    Ok(json!({"selection": d.selection.a1()}))
+}
+
+pub(super) fn select_col(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc_mut()?;
+    let r = d.selection.current();
+    let active = d.selection.active;
+    d.selection = crate::Selection { active, anchor: CellRef::new(0, r.start.col), ranges: vec![RangeRef::cols(r.start.col, r.end.col)] };
+    Ok(json!({"selection": d.selection.a1()}))
+}

From 73c52d49b7659c2ceaa9991a26f4595e59571fd2 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:24:30 +0000
Subject: [PATCH 50/76] refactor(engine): move cmd/print.rs items to cmd/print/

---
 crates/engine/src/cmd/print.rs               | 1520 +-----------------
 crates/engine/src/cmd/print/draw.rs          |  467 ++++++
 crates/engine/src/cmd/print/header_footer.rs |  261 +++
 crates/engine/src/cmd/print/layout.rs        |  364 +++++
 crates/engine/src/cmd/print/objects.rs       |  177 ++
 crates/engine/src/cmd/print/text.rs          |  263 +++
 6 files changed, 1552 insertions(+), 1500 deletions(-)
 create mode 100644 crates/engine/src/cmd/print/draw.rs
 create mode 100644 crates/engine/src/cmd/print/header_footer.rs
 create mode 100644 crates/engine/src/cmd/print/layout.rs
 create mode 100644 crates/engine/src/cmd/print/objects.rs
 create mode 100644 crates/engine/src/cmd/print/text.rs

diff --git a/crates/engine/src/cmd/print.rs b/crates/engine/src/cmd/print.rs
index d55841f7b..3b6dcb0ec 100644
--- a/crates/engine/src/cmd/print.rs
+++ b/crates/engine/src/cmd/print.rs
@@ -16,6 +16,26 @@ use serde_json::{Value as Json, json};
 
 use super::*;
 
+mod draw;
+mod header_footer;
+mod layout;
+mod objects;
+mod text;
+
+use draw::{Block, PrintedBlock, draw_block, draw_block_links, draw_headings, make_block, printed_target};
+use header_footer::draw_header_footer;
+pub use header_footer::{
+    HF_FIELDS, HfContext, HfSection, codes_to_fields, expand_header_footer, fields_to_codes, hf_date_time, join_header_footer, split_header_footer,
+};
+#[cfg(test)]
+use layout::bands;
+pub(crate) use layout::split_bands;
+pub use layout::{PrintOptions, SheetLayout, layout_sheet, layouts, paper_size, print_range};
+use layout::{known_paper, seg_size, segments};
+use objects::draw_objects;
+#[cfg(test)]
+use text::{center_across_width, wrap_lines};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -61,1506 +81,6 @@ pub fn specs() -> Vec<CommandSpec> {
 pub(crate) const PX_TO_PT: f32 = 0.75;
 /// Most pages one export produces.
 pub const MAX_PAGES: usize = 2000;
-/// Cells in a page block above which only stored cells are visited (not every grid position).
-const DENSE_BLOCK: u64 = 60_000;
-
-// ---------------------------------------------------------------- paper
-
-/// Paper size in points (portrait) for a paper name; unknown names fall back to Letter.
-pub fn paper_size(name: &str) -> (f32, f32) {
-    known_paper(name).unwrap_or((612.0, 792.0))
-}
-
-/// Paper sizes in points, portrait. `B4`/`B5`/`B6` are the **JIS** sizes Japanese Excel and its
-/// e-mail attachments use (257×364, 182×257 and 128×182 mm); the ISO B series stays reachable as
-/// `B4 (ISO)`/`B5 (ISO)`/`B6 (ISO)`. The Japanese postcards and envelopes are the JIS ones too.
-fn known_paper(name: &str) -> Option<(f32, f32)> {
-    // Spaces, hyphens, underscores and parentheses don't matter: `B5 (JIS)`, `b5-jis` and `b5`
-    // are one name.
-    let n = name.trim().to_ascii_lowercase().replace([' ', '-', '_', '(', ')'], "");
-    Some(match n.as_str() {
-        "letter" | "usletter" => (612.0, 792.0),
-        "legal" | "uslegal" => (612.0, 1008.0),
-        "a4" => (595.28, 841.89),
-        "a3" => (841.89, 1190.55),
-        "a5" => (419.53, 595.28),
-        "a6" => (297.64, 419.53),
-        "tabloid" | "11x17" => (792.0, 1224.0),
-        "ledger" => (1224.0, 792.0),
-        "executive" => (522.0, 756.0),
-        "b4" | "b4jis" => (728.50, 1031.81),
-        "b5" | "b5jis" => (515.91, 728.50),
-        "b6" | "b6jis" => (362.83, 515.91),
-        "b4iso" => (708.66, 1000.63),
-        "b5iso" => (498.90, 708.66),
-        "b6iso" => (354.33, 498.90),
-        "japanesepostcard" | "postcard" => (283.46, 419.53),
-        "japanesedoublepostcard" | "doublepostcard" => (419.53, 566.93),
-        "japaneseenvelope#3" | "chou#3" => (340.16, 666.14),
-        // 長形4号 is 90×205 mm; 90×225 mm is 長形40号, a different envelope, so it stays out.
-        "japaneseenvelope#4" | "chou#4" => (255.12, 581.10),
-        "japaneseenvelopekaku#2" | "kaku#2" => (680.31, 941.10),
-        "japaneseenvelopekaku#3" | "kaku#3" => (612.28, 785.20),
-        _ => return None,
-    })
-}
-
-// ---------------------------------------------------------------- layout
-
-/// The pagination of one sheet.
-#[derive(Clone, Debug)]
-pub struct SheetLayout {
-    pub sheet: usize,
-    pub settings: PrintSettings,
-    pub page_w: f32,
-    pub page_h: f32,
-    /// Left, right, top, bottom, header, footer margins in points.
-    pub margins: [f32; 6],
-    pub scale: f32,
-    pub area: RangeRef,
-    pub row_bands: Vec<(u32, u32)>,
-    pub col_bands: Vec<(u32, u32)>,
-    /// Pages in print order: (row band, column band).
-    pub pages: Vec<(usize, usize)>,
-    pub title_rows: Option<(u32, u32)>,
-    pub title_cols: Option<(u32, u32)>,
-    /// Heading sizes in sheet pixels (0 when headings are off).
-    pub heading_w: f32,
-    pub heading_h: f32,
-    /// Manual page breaks apply (they don't when the sheet is fitted to pages).
-    pub manual_breaks: bool,
-}
-
-impl SheetLayout {
-    fn k(&self) -> f32 {
-        PX_TO_PT * self.scale
-    }
-    pub(crate) fn avail(&self) -> (f32, f32) {
-        let [l, r, t, b, ..] = self.margins;
-        ((self.page_w - l - r).max(36.0), (self.page_h - t - b).max(36.0))
-    }
-    /// Left and right margins, in points, that header and footer sections line up with: the
-    /// page's side margins with Align with Page Margins on, otherwise 0.7 inch on each side, at
-    /// most a quarter of the page width.
-    pub(crate) fn hf_sides(&self) -> (f32, f32) {
-        if self.settings.hf_align_with_margins {
-            (self.margins[0], self.margins[1])
-        } else {
-            let side = HF_FIXED_SIDE_MARGIN.min(self.page_w / 4.0);
-            (side, side)
-        }
-    }
-    /// Scale of header and footer text: the print scale with Scale with Document on, otherwise 1.
-    pub(crate) fn hf_text_scale(&self) -> f32 {
-        if self.settings.hf_scale_with_doc { self.scale } else { 1.0 }
-    }
-}
-
-/// Side margin of headers and footers, in points, when Align with Page Margins is off.
-const HF_FIXED_SIDE_MARGIN: f32 = 0.7 * 72.0;
-
-/// Options shared by the print commands.
-#[derive(Clone, Debug, Default)]
-pub struct PrintOptions {
-    pub all_sheets: bool,
-    pub range: Option<RangeRef>,
-    pub fit_to_page: Option<bool>,
-}
-
-impl PrintOptions {
-    fn from_params(p: &Json, cmd: &str) -> Result<PrintOptions> {
-        let all_sheets = match str_param(p, "sheets") {
-            None | Some("active") => false,
-            Some("all") | Some("workbook") => true,
-            Some(other) => return Err(bad(cmd, format!("`sheets` must be active or all, not `{other}`"))),
-        };
-        let range = match str_param(p, "range").map(str::trim).filter(|r| !r.is_empty()) {
-            Some(r) => Some(RangeRef::parse(split_sheet(r).1).ok_or_else(|| bad(cmd, format!("not a range: `{r}`")))?),
-            None => None,
-        };
-        Ok(PrintOptions { all_sheets, range, fit_to_page: bool_param(p, "fitToPage") })
-    }
-}
-
-/// The range a sheet prints: its print area, else the used range grown to cover drawing
-/// objects. `None` when there is nothing to print.
-pub fn print_range(sh: &Sheet) -> Option<RangeRef> {
-    if let Some(a) = sh.print.print_area {
-        return Some(trim_full(sh, a));
-    }
-    let mut r = sh.used_range();
-    let mut grow = |a: &Anchor| {
-        let x = sh.col_left(a.cell.col) + a.dx as f64;
-        let y = sh.row_top(a.cell.row) + a.dy as f64;
-        let end = CellRef::new(sh.row_at(y + a.height.max(0.0) as f64), sh.col_at(x + a.width.max(0.0) as f64));
-        let ar = RangeRef::new(a.cell, end);
-        r = Some(r.map_or(ar, |u| u.union(&ar)));
-    };
-    for c in &sh.charts {
-        grow(&c.anchor);
-    }
-    for i in &sh.images {
-        grow(&i.anchor);
-    }
-    for s in &sh.shapes {
-        grow(&s.anchor);
-    }
-    // Printing starts at A1 like Excel when the data starts nearby? Excel prints from the first
-    // used cell; keep the used range as is.
-    r
-}
-
-/// Whole rows/columns are trimmed to the used range.
-fn trim_full(sh: &Sheet, r: RangeRef) -> RangeRef {
-    if !(r.is_full_cols() || r.is_full_rows()) {
-        return r;
-    }
-    match sh.used_range() {
-        Some(u) => r.intersection(&RangeRef::new(CellRef::new(0, 0), u.end)).unwrap_or(RangeRef::cell(r.start)),
-        None => RangeRef::cell(r.start),
-    }
-}
-
-/// Splits `start..=end` into bands whose sizes fit `avail(band_start)`; `breaks` force a new
-/// band before a line. Stops after `cap` bands.
-fn bands(start: u32, end: u32, size: impl Fn(u32) -> f32, avail: impl Fn(u32) -> f32, breaks: &[u32], cap: usize) -> Vec<(u32, u32)> {
-    let mut out = Vec::new();
-    let mut cur = start;
-    let mut used = 0.0f32;
-    let mut room = avail(start);
-    let mut line = start;
-    loop {
-        let sz = size(line);
-        let manual = line > cur && breaks.binary_search(&line).is_ok();
-        if line > cur && (manual || used + sz > room + 0.01) {
-            out.push((cur, line - 1));
-            if out.len() >= cap {
-                return out;
-            }
-            cur = line;
-            used = 0.0;
-            room = avail(line);
-        }
-        used += sz;
-        if line >= end {
-            break;
-        }
-        line += 1;
-    }
-    out.push((cur, end));
-    out
-}
-
-fn title_span(t: Option<(u32, u32)>, max: u32) -> Option<(u32, u32)> {
-    let (a, b) = t?;
-    let (a, b) = (a.min(b), a.max(b));
-    if a >= max {
-        return None;
-    }
-    // Repeated titles are capped (Excel needs them to fit on a page anyway).
-    Some((a, b.min(max - 1).min(a.saturating_add(499))))
-}
-
-/// Paginates one sheet.
-pub fn layout_sheet(wb: &Workbook, si: usize, opts: &PrintOptions, range_override: Option<RangeRef>) -> Option<SheetLayout> {
-    let sh = wb.sheet(si)?;
-    let st = sh.print.clone();
-    let (mut pw, mut ph) = paper_size(&st.paper);
-    if st.orientation == Orientation::Landscape {
-        std::mem::swap(&mut pw, &mut ph);
-    }
-    let inch = |i: usize| st.margins.get(i).copied().filter(|v| v.is_finite()).unwrap_or(0.5).clamp(0.0, 20.0) * 72.0;
-    let mut margins = [inch(0), inch(1), inch(2), inch(3), inch(4), inch(5)];
-    // Keep at least an inch of printable space.
-    for (a, b, total) in [(0usize, 1usize, pw), (2, 3, ph)] {
-        let sum = margins[a] + margins[b];
-        if total - sum < 72.0 {
-            let f = ((total - 72.0).max(0.0)) / sum.max(1.0);
-            margins[a] *= f;
-            margins[b] *= f;
-        }
-    }
-    let area = match range_override {
-        Some(r) => trim_full(sh, r),
-        None => print_range(sh).unwrap_or(RangeRef::cell(CellRef::new(0, 0))),
-    };
-    let title_rows = title_span(st.title_rows, MAX_ROWS);
-    let title_cols = title_span(st.title_cols, MAX_COLS);
-    let digits = format!("{}", area.end.row + 1).len() as f32;
-    let (heading_w, heading_h) = if st.headings { (10.0 + 7.0 * digits, sh.default_row_height.clamp(10.0, 60.0)) } else { (0.0, 0.0) };
-    let fit = match opts.fit_to_page {
-        Some(true) => Some((1u16, 1u16)),
-        Some(false) => None,
-        None => st.fit_to.filter(|(w, h)| *w > 0 || *h > 0),
-    };
-    let mut lay = SheetLayout {
-        sheet: si,
-        settings: st.clone(),
-        page_w: pw,
-        page_h: ph,
-        margins,
-        scale: (st.scale.clamp(10, 400) as f32) / 100.0,
-        area,
-        row_bands: vec![],
-        col_bands: vec![],
-        pages: vec![],
-        title_rows,
-        title_cols,
-        heading_w,
-        heading_h,
-        manual_breaks: fit.is_none(),
-    };
-    let paginate = |lay: &mut SheetLayout, manual: bool| {
-        lay.manual_breaks = manual;
-        (lay.row_bands, lay.col_bands) = split_bands(sh, lay, MAX_PAGES);
-        lay.pages.clear();
-        'outer: for ci in 0..lay.col_bands.len() {
-            for ri in 0..lay.row_bands.len() {
-                if lay.pages.len() >= MAX_PAGES {
-                    break 'outer;
-                }
-                lay.pages.push((ri, ci));
-            }
-        }
-    };
-    match fit {
-        Some((fw, fh)) => {
-            let total_w: f32 = (area.start.col..=area.end.col).map(|c| sh.col_width(c)).sum::<f32>() + heading_w;
-            let total_h: f32 = if area.height() > 200_000 {
-                f32::INFINITY
-            } else {
-                (area.start.row..=area.end.row).map(|r| sh.row_height(r)).sum::<f32>() + heading_h
-            };
-            let (aw, ah) = lay.avail();
-            let sw = if fw > 0 { aw * fw as f32 / (total_w * PX_TO_PT).max(1.0) } else { f32::INFINITY };
-            let sh_ = if fh > 0 { ah * fh as f32 / (total_h * PX_TO_PT).max(1.0) } else { f32::INFINITY };
-            lay.scale = sw.min(sh_).min(1.0).clamp(0.1, 1.0);
-            for _ in 0..40 {
-                paginate(&mut lay, false);
-                let ok_w = fw == 0 || lay.col_bands.len() <= fw as usize;
-                let ok_h = fh == 0 || lay.row_bands.len() <= fh as usize;
-                if (ok_w && ok_h) || lay.scale <= 0.1 {
-                    break;
-                }
-                lay.scale = (lay.scale * 0.97).max(0.1);
-            }
-        }
-        None => paginate(&mut lay, true),
-    }
-    Some(lay)
-}
-
-/// Splits a layout's area into row and column bands that fit its pages (at most `cap` of each),
-/// honouring manual breaks (when `lay.manual_breaks`), print headings and repeated titles. The
-/// one pagination rule shared by printing, PDF export, Page Break Preview and Page Layout view.
-pub(crate) fn split_bands(sh: &Sheet, lay: &SheetLayout, cap: usize) -> (Vec<(u32, u32)>, Vec<(u32, u32)>) {
-    let k = lay.k();
-    let (aw, ah) = lay.avail();
-    let (aw, ah) = (aw / k, ah / k);
-    let st = &lay.settings;
-    let mut rb: Vec<u32> = if lay.manual_breaks { st.row_breaks.clone() } else { vec![] };
-    let mut cb: Vec<u32> = if lay.manual_breaks { st.col_breaks.clone() } else { vec![] };
-    rb.sort_unstable();
-    cb.sort_unstable();
-    let (title_rows, title_cols) = (lay.title_rows, lay.title_cols);
-    let title_h = |start: u32| -> f32 {
-        match title_rows {
-            Some((a, b)) if a < start => (a..=b.min(start - 1)).map(|r| sh.row_height(r)).sum(),
-            _ => 0.0,
-        }
-    };
-    let title_w = |start: u32| -> f32 {
-        match title_cols {
-            Some((a, b)) if a < start => (a..=b.min(start - 1)).map(|c| sh.col_width(c)).sum(),
-            _ => 0.0,
-        }
-    };
-    let area = lay.area;
-    let rows = bands(area.start.row, area.end.row, |r| sh.row_height(r), |start| (ah - lay.heading_h - title_h(start)).max(1.0), &rb, cap);
-    let cols = bands(area.start.col, area.end.col, |c| sh.col_width(c), |start| (aw - lay.heading_w - title_w(start)).max(1.0), &cb, cap);
-    (rows, cols)
-}
-
-/// Lays out every sheet a print command covers.
-pub fn layouts(wb: &Workbook, opts: &PrintOptions) -> Vec<SheetLayout> {
-    let mut out = Vec::new();
-    let mut pages = 0usize;
-    let sheets: Vec<usize> = if opts.all_sheets {
-        (0..wb.sheets.len()).filter(|i| wb.sheet(*i).is_some_and(|s| s.visibility == Visibility::Visible)).collect()
-    } else {
-        vec![wb.active_sheet()]
-    };
-    for si in sheets {
-        if pages >= MAX_PAGES {
-            break;
-        }
-        let ovr = if si == wb.active_sheet() { opts.range } else { None };
-        if opts.all_sheets && ovr.is_none() && wb.sheet(si).is_some_and(|s| print_range(s).is_none()) {
-            continue;
-        }
-        if let Some(mut l) = layout_sheet(wb, si, opts, ovr) {
-            l.pages.truncate(MAX_PAGES - pages);
-            pages += l.pages.len();
-            out.push(l);
-        }
-    }
-    if out.is_empty() && opts.all_sheets {
-        out.extend(layout_sheet(wb, wb.active_sheet(), opts, None));
-    }
-    out
-}
-
-// ---------------------------------------------------------------- header / footer
-
-/// Values for header/footer codes.
-#[derive(Clone, Debug, Default)]
-pub struct HfContext {
-    pub page: usize,
-    pub pages: usize,
-    pub sheet: String,
-    pub file: String,
-    pub path: String,
-    pub date: String,
-    pub time: String,
-}
-
-/// Today's date and the current time as headers and footers show them (`&D`, `&T`).
-pub fn hf_date_time(wb: &Workbook) -> (String, String) {
-    let now = gridcraft_core::date::serial_in_system(wb.date_system, gridcraft_calc::now_serial());
-    let date = crate::display::format(&Value::Number(now.floor()), "m/d/yyyy", wb).text;
-    let time = crate::display::format(&Value::Number(now), "h:mm AM/PM", wb).text;
-    (date, time)
-}
-
-/// Header/footer codes and the field names the Page Layout view shows for them while editing.
-pub const HF_FIELDS: [(char, &str); 8] = [
-    ('P', "&[Page]"),
-    ('N', "&[Pages]"),
-    ('D', "&[Date]"),
-    ('T', "&[Time]"),
-    ('Z', "&[Path]"),
-    ('F', "&[File]"),
-    ('A', "&[Tab]"),
-    ('G', "&[Picture]"),
-];
-
-/// Splits a header/footer string into its raw left, centre and right sections (codes kept).
-/// Text before the first `&L`/`&C`/`&R` belongs to the centre, as when printing.
-pub fn split_header_footer(spec: &str) -> [String; 3] {
-    let mut out: [String; 3] = Default::default();
-    let mut cur = 1usize;
-    let chars: Vec<char> = spec.chars().take(10_000).collect();
-    let mut i = 0;
-    while let Some(&c) = chars.get(i) {
-        let next = chars.get(i + 1).copied();
-        let sec = cur.min(2);
-        match (c, next) {
-            ('&', Some('L' | 'l')) => cur = 0,
-            ('&', Some('C' | 'c')) => cur = 1,
-            ('&', Some('R' | 'r')) => cur = 2,
-            ('&', Some('"')) => {
-                // &"Font,Style" is kept whole.
-                let end = chars[i + 2..].iter().position(|ch| *ch == '"').map_or(chars.len(), |p| i + 3 + p);
-                out[sec].extend(&chars[i..end.min(chars.len())]);
-                i = end;
-                continue;
-            }
-            ('&', Some(n)) => {
-                out[sec].push('&');
-                out[sec].push(n);
-            }
-            ('&', None) => {}
-            (ch, _) => {
-                out[sec].push(ch);
-                i += 1;
-                continue;
-            }
-        }
-        i += 2;
-    }
-    out
-}
-
-/// Joins raw left, centre and right sections into one header/footer string.
-pub fn join_header_footer(sections: &[String; 3]) -> String {
-    let mut s = String::new();
-    for (code, text) in ["&L", "&C", "&R"].iter().zip(sections) {
-        if !text.is_empty() {
-            s.push_str(code);
-            s.push_str(text);
-        }
-    }
-    s
-}
-
-/// A raw section as the user edits it: `&P` shows as `&[Page]`, `&N` as `&[Pages]`, and so on.
-pub fn codes_to_fields(raw: &str) -> String {
-    let mut out = String::new();
-    let mut it = raw.chars().peekable();
-    while let Some(c) = it.next() {
-        if c != '&' {
-            out.push(c);
-            continue;
-        }
-        // A dangling `&` at the end is dropped (printing ignores it too).
-        if let Some(n) = it.next() {
-            match HF_FIELDS.iter().find(|(code, _)| *code == n.to_ascii_uppercase()) {
-                Some((_, field)) => out.push_str(field),
-                None => {
-                    out.push('&');
-                    out.push(n);
-                }
-            }
-        }
-    }
-    out
-}
-
-/// The inverse of [`codes_to_fields`]: field names become codes again; a dangling `&` at the end
-/// becomes a literal ampersand so it can't swallow the next section's code.
-pub fn fields_to_codes(text: &str) -> String {
-    let chars: Vec<char> = text.chars().take(10_000).collect();
-    let mut out = String::new();
-    let mut i = 0;
-    while let Some(&c) = chars.get(i) {
-        if c != '&' {
-            out.push(c);
-            i += 1;
-            continue;
-        }
-        if chars.get(i + 1) == Some(&'&') {
-            out.push_str("&&");
-            i += 2;
-            continue;
-        }
-        let rest: String = chars[i..].iter().take(12).collect();
-        if let Some((code, field)) = HF_FIELDS.iter().find(|(_, f)| rest.starts_with(f)) {
-            out.push('&');
-            out.push(*code);
-            i += field.chars().count();
-            continue;
-        }
-        if i + 1 == chars.len() {
-            out.push_str("&&");
-        } else {
-            out.push('&');
-        }
-        i += 1;
-    }
-    out
-}
-
-/// One header/footer section: its text and whether `&B` made it bold.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct HfSection {
-    pub text: String,
-    pub bold: bool,
-    pub italic: bool,
-    pub size: Option<f32>,
-}
-
-/// Expands a header/footer string into its left, centre and right sections.
-pub fn expand_header_footer(spec: &str, cx: &HfContext) -> [HfSection; 3] {
-    let mut out: [HfSection; 3] = Default::default();
-    let mut cur = 1usize;
-    let chars: Vec<char> = spec.chars().take(10_000).collect();
-    let mut i = 0;
-    while i < chars.len() {
-        let c = chars[i];
-        if c != '&' {
-            if let Some(s) = out.get_mut(cur) {
-                s.text.push(c);
-            }
-            i += 1;
-            continue;
-        }
-        let Some(&code) = chars.get(i + 1) else { break };
-        i += 2;
-        let sec = &mut out[cur.min(2)];
-        match code {
-            'L' | 'l' => cur = 0,
-            'C' | 'c' => cur = 1,
-            'R' | 'r' => cur = 2,
-            'P' | 'p' => {
-                // &P, &P+n, &P-n
-                let mut n = cx.page as i64;
-                if let Some(&sign) = chars.get(i)
-                    && (sign == '+' || sign == '-')
-                {
-                    let digits: String = chars[i + 1..].iter().take_while(|d| d.is_ascii_digit()).take(6).collect();
-                    if let Ok(d) = digits.parse::<i64>() {
-                        n = if sign == '+' { n + d } else { n - d };
-                        i += 1 + digits.len();
-                    }
-                }
-                sec.text.push_str(&n.to_string());
-            }
-            'N' | 'n' => sec.text.push_str(&cx.pages.to_string()),
-            'D' | 'd' => sec.text.push_str(&cx.date),
-            'T' | 't' => sec.text.push_str(&cx.time),
-            'A' | 'a' => sec.text.push_str(&cx.sheet),
-            'F' | 'f' => sec.text.push_str(&cx.file),
-            'Z' | 'z' => sec.text.push_str(&cx.path),
-            '&' => sec.text.push('&'),
-            'B' | 'b' => sec.bold = !sec.bold,
-            'I' | 'i' => sec.italic = !sec.italic,
-            '"' => {
-                // &"Font,Style": skip the font name; honour Bold/Italic in the style.
-                let rest: String = chars[i..].iter().take_while(|c| **c != '"').collect();
-                let lower = rest.to_ascii_lowercase();
-                if lower.contains("bold") {
-                    sec.bold = true;
-                }
-                if lower.contains("italic") || lower.contains("oblique") {
-                    sec.italic = true;
-                }
-                i += rest.chars().count() + 1;
-            }
-            d if d.is_ascii_digit() => {
-                let digits: String = std::iter::once(d).chain(chars[i..].iter().copied().take_while(char::is_ascii_digit)).take(3).collect();
-                i += digits.len() - 1;
-                if let Ok(v) = digits.parse::<f32>() {
-                    sec.size = Some(v.clamp(1.0, 409.0));
-                }
-            }
-            // Underline, strike, super/subscript, colour, picture: not rendered.
-            'K' | 'k' => {
-                i = (i + 6).min(chars.len());
-            }
-            _ => {}
-        }
-    }
-    out
-}
-
-// ---------------------------------------------------------------- drawing
-
-fn rgb_of(c: Color, wb: &Workbook) -> Option<Rgb> {
-    c.resolve(&wb.theme)
-}
-
-fn blend(fg: [u8; 4]) -> Rgb {
-    let a = fg[3] as u16;
-    let mix = |c: u8| ((c as u16 * a + 255 * (255 - a)) / 255) as u8;
-    [mix(fg[0]), mix(fg[1]), mix(fg[2])]
-}
-
-/// The effective look of a cell: own style, table style, conditional formats.
-struct Look {
-    style: Style,
-    fill: Option<Rgb>,
-    cf: Option<crate::cf::CfLook>,
-}
-
-fn cell_look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut Option<crate::cf::CfCache>) -> Look {
-    let mut style = match sh.table_at(c) {
-        Some(t) => crate::tables::table_cell_style(wb, si, t, c),
-        None => wb.styles.get(sh.style_id(c)).clone(),
-    };
-    let cfl = cf.as_mut().and_then(|cache| cache.look(wb, si, c));
-    if let Some(st) = cfl.as_ref().and_then(|l| l.style.as_ref()) {
-        if st.fill.pattern != PatternType::None {
-            style.fill = st.fill;
-        }
-        if st.font.color != Color::Auto {
-            style.font.color = st.font.color;
-        }
-        style.font.bold |= st.font.bold;
-        style.font.italic |= st.font.italic;
-        style.font.strike |= st.font.strike;
-        if st.font.underline != Underline::None {
-            style.font.underline = st.font.underline;
-        }
-        // In a differential style General means "not set" (#1163).
-        if st.num_fmt.as_str() != "General" {
-            style.num_fmt = st.num_fmt.clone();
-        }
-        for (dst, src) in [
-            (&mut style.borders.left, st.borders.left),
-            (&mut style.borders.right, st.borders.right),
-            (&mut style.borders.top, st.borders.top),
-            (&mut style.borders.bottom, st.borders.bottom),
-        ] {
-            if !src.is_none() {
-                *dst = src;
-            }
-        }
-    }
-    let mut fill = match style.fill.pattern {
-        PatternType::None => None,
-        PatternType::Solid => rgb_of(style.fill.fg, wb),
-        _ => {
-            let fg = rgb_of(style.fill.fg, wb).unwrap_or([0, 0, 0]);
-            let bg = rgb_of(style.fill.bg, wb).unwrap_or([255, 255, 255]);
-            Some([0, 1, 2].map(|i| ((fg[i] as u16 + bg[i] as u16 * 3) / 4) as u8))
-        }
-    };
-    if let Some(rgb) = cfl.as_ref().and_then(|l| l.scale_fill) {
-        fill = Some(rgb);
-    }
-    Look { style, fill, cf: cfl }
-}
-
-/// PDF measurement for chart layout.
-struct PdfMeasure;
-
-impl gridcraft_chart::Measure for PdfMeasure {
-    fn text_width(&self, text: &str, size: f32, bold: bool) -> f32 {
-        gridcraft_pdf::text_width(if bold { Font::HelveticaBold } else { Font::Helvetica }, size, text)
-    }
-}
-
-/// Maps chart-space coordinates to the page.
-#[derive(Clone, Copy)]
-struct Xf {
-    ox: f32,
-    oy: f32,
-    k: f32,
-}
-
-impl Xf {
-    fn p(&self, x: f32, y: f32) -> (f32, f32) {
-        (self.ox + x * self.k, self.oy + y * self.k)
-    }
-    fn pts(&self, pts: &[[f32; 2]]) -> Vec<[f32; 2]> {
-        pts.iter().map(|q| [self.ox + q[0] * self.k, self.oy + q[1] * self.k]).collect()
-    }
-}
-
-/// Draws chart primitives onto a page.
-fn draw_prims(pg: &mut Page, prims: &[gridcraft_chart::Prim], xf: Xf) {
-    use gridcraft_chart::{HAlign as H, Prim, VAlign as V};
-    let k = xf.k;
-    for p in prims {
-        match p {
-            Prim::Rect { x, y, w, h, fill, stroke, .. } => {
-                let (px, py) = xf.p(*x, *y);
-                if let Some(f) = fill {
-                    pg.fill_rect(px, py, w * k, h * k, blend(*f));
-                }
-                if let Some((c, lw)) = stroke {
-                    pg.rect_stroke(px, py, w * k, h * k, (lw * k).max(0.1), blend(*c));
-                }
-            }
-            Prim::Line { pts, color, width, dash } => {
-                let d = if *dash { vec![3.0 * k, 2.0 * k] } else { vec![] };
-                pg.polyline(&xf.pts(pts), (width * k).max(0.1), blend(*color), &d);
-            }
-            Prim::Polygon { pts, fill, stroke } => {
-                pg.polygon(&xf.pts(pts), Some(blend(*fill)), stroke.map(|(c, w)| (blend(c), (w * k).max(0.1))));
-            }
-            Prim::Wedge { cx, cy, r_outer, r_inner, a0, a1, fill, stroke } => {
-                let span = (a1 - a0).abs().min(std::f32::consts::TAU);
-                let n = ((span / (std::f32::consts::PI / 36.0)).ceil() as usize).clamp(2, 400);
-                let at = |a: f32, r: f32| [cx + r * a.sin(), cy - r * a.cos()];
-                let mut pts: Vec<[f32; 2]> = (0..=n).map(|i| at(a0 + (a1 - a0) * i as f32 / n as f32, *r_outer)).collect();
-                if *r_inner > 0.0 {
-                    pts.extend((0..=n).rev().map(|i| at(a0 + (a1 - a0) * i as f32 / n as f32, *r_inner)));
-                } else {
-                    pts.push([*cx, *cy]);
-                }
-                pg.polygon(&xf.pts(&pts), Some(blend(*fill)), stroke.map(|(c, w)| (blend(c), (w * k).max(0.1))));
-            }
-            Prim::Circle { cx, cy, r, fill, stroke } => {
-                let (px, py) = xf.p(*cx, *cy);
-                pg.circle(px, py, r * k, fill.map(blend), stroke.map(|(c, w)| (blend(c), (w * k).max(0.1))));
-            }
-            Prim::Text { x, y, text, size, color, bold, align, valign, rotation } => {
-                let font = if *bold { Font::HelveticaBold } else { Font::Helvetica };
-                let size = size * k;
-                let w = gridcraft_pdf::text_width(font, size, text);
-                let dx = match align {
-                    H::Left => 0.0,
-                    H::Center => -w / 2.0,
-                    H::Right => -w,
-                };
-                let dy = match valign {
-                    V::Top => size * 0.78,
-                    V::Middle => size * 0.35,
-                    V::Bottom => -size * 0.21,
-                };
-                let (sn, cs) = if rotation.is_finite() { rotation.sin_cos() } else { (0.0, 1.0) };
-                let (ax, ay) = xf.p(*x, *y);
-                pg.text_rotated(ax + dx * cs - dy * sn, ay + dx * sn + dy * cs, size, font, blend(*color), text, *rotation);
-            }
-        }
-    }
-}
-
-const PAD_PX: f32 = 2.0;
-
-/// Word-wraps `text` to `width` points.
-fn wrap_lines(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
-    let mut out = Vec::new();
-    for para in text.split('\n') {
-        let mut line = String::new();
-        for word in para.split(' ') {
-            let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") };
-            if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width {
-                line = cand;
-            } else {
-                out.push(std::mem::take(&mut line));
-                line = word.to_string();
-            }
-            // Break a single over-long word by characters. The cut that fits is found by binary
-            // search (each try measures one candidate prefix), so an over-long word costs
-            // O(n log n) measurements instead of re-measuring the whole cut per character for
-            // every emitted line (`a` × 100k pasted text would be cubic worst case).
-            while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 {
-                let chars: Vec<char> = line.chars().collect();
-                let (mut lo, mut hi) = (1usize, chars.len());
-                while lo < hi {
-                    let mid = lo + (hi - lo).div_ceil(2);
-                    let cut: String = chars[..mid].iter().collect();
-                    if gridcraft_pdf::text_width(font, size, &cut) <= width {
-                        lo = mid;
-                    } else {
-                        hi = mid - 1;
-                    }
-                }
-                if lo == chars.len() {
-                    break;
-                }
-                out.push(chars[..lo].iter().collect());
-                line = chars[lo..].iter().collect();
-            }
-            if out.len() > 2000 {
-                return out;
-            }
-        }
-        out.push(line);
-    }
-    out
-}
-
-/// Everything needed to draw one page block (a run of rows × a run of columns).
-struct Block<'a> {
-    wb: &'a Workbook,
-    si: usize,
-    sh: &'a Sheet,
-    rows: (u32, u32),
-    cols: (u32, u32),
-    /// Page x of each column's left edge, plus the right edge of the last.
-    xs: Vec<f32>,
-    ys: Vec<f32>,
-    k: f32,
-    scale: f32,
-}
-
-impl Block<'_> {
-    fn x(&self, col: u32) -> f32 {
-        if col >= self.cols.0 && col <= self.cols.1 + 1 {
-            return self.xs.get((col - self.cols.0) as usize).copied().unwrap_or(0.0);
-        }
-        let x0 = self.xs.first().copied().unwrap_or(0.0);
-        x0 + ((self.sh.col_left(col) - self.sh.col_left(self.cols.0)) as f32) * self.k
-    }
-    fn y(&self, row: u32) -> f32 {
-        if row >= self.rows.0 && row <= self.rows.1 + 1 {
-            return self.ys.get((row - self.rows.0) as usize).copied().unwrap_or(0.0);
-        }
-        let y0 = self.ys.first().copied().unwrap_or(0.0);
-        y0 + ((self.sh.row_top(row) - self.sh.row_top(self.rows.0)) as f32) * self.k
-    }
-    fn rect(&self, r: RangeRef) -> (f32, f32, f32, f32) {
-        let (x0, y0) = (self.x(r.start.col), self.y(r.start.row));
-        (x0, y0, self.x(r.end.col.saturating_add(1)) - x0, self.y(r.end.row.saturating_add(1)) - y0)
-    }
-    fn range(&self) -> RangeRef {
-        RangeRef::new(CellRef::new(self.rows.0, self.cols.0), CellRef::new(self.rows.1, self.cols.1))
-    }
-}
-
-fn border_dash(style: BorderStyle, k: f32) -> Vec<f32> {
-    let u = k.max(0.2);
-    match style {
-        BorderStyle::Dashed | BorderStyle::MediumDashed => vec![4.0 * u, 2.0 * u],
-        BorderStyle::Dotted => vec![1.0 * u, 1.0 * u],
-        BorderStyle::Hair => vec![0.75 * u, 0.75 * u],
-        BorderStyle::DashDot | BorderStyle::MediumDashDot | BorderStyle::SlantDashDot => vec![4.0 * u, 1.5 * u, 1.0 * u, 1.5 * u],
-        BorderStyle::DashDotDot | BorderStyle::MediumDashDotDot => vec![4.0 * u, 1.5 * u, 1.0 * u, 1.5 * u, 1.0 * u, 1.5 * u],
-        _ => vec![],
-    }
-}
-
-fn draw_border(pg: &mut Page, b: &BorderLine, wb: &Workbook, x0: f32, y0: f32, x1: f32, y1: f32, k: f32) {
-    if b.is_none() {
-        return;
-    }
-    let color = rgb_of(b.color, wb).unwrap_or([0, 0, 0]);
-    if b.style == BorderStyle::Double {
-        let off = 1.0 * k;
-        let lw = (0.75 * k).max(0.2);
-        let (dx, dy) = if (y0 - y1).abs() < 0.001 { (0.0, off) } else { (off, 0.0) };
-        pg.stroke_line(x0 - dx, y0 - dy, x1 - dx, y1 - dy, lw, color);
-        pg.stroke_line(x0 + dx, y0 + dy, x1 + dx, y1 + dy, lw, color);
-        return;
-    }
-    let lw = (b.style.width() * k).clamp(0.25, 6.0);
-    pg.stroke_line_dashed(x0, y0, x1, y1, lw, color, &border_dash(b.style, k));
-}
-
-fn font_for(style: &Style) -> Font {
-    Font::styled(Font::family_for(&style.font.name), style.font.bold, style.font.italic)
-}
-
-/// Draws the cells of a block: fills, gridlines, data bars, borders and text.
-fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Option<crate::cf::CfCache>) {
-    let (bx, by) = (b.xs.first().copied().unwrap_or(0.0), b.ys.first().copied().unwrap_or(0.0));
-    let (bw, bh) = (b.xs.last().copied().unwrap_or(bx) - bx, b.ys.last().copied().unwrap_or(by) - by);
-    if bw <= 0.0 || bh <= 0.0 {
-        return;
-    }
-    let block = b.range();
-    let sh = b.sh;
-    let merges: Vec<RangeRef> = sh.merges.iter().filter(|m| m.intersects(&block)).copied().collect();
-    let covered = |c: CellRef| merges.iter().any(|m| m.contains(c));
-    // Cells worth visiting.
-    let cells: Vec<CellRef> = if block.count() <= DENSE_BLOCK {
-        block.iter().filter(|c| !covered(*c)).collect()
-    } else {
-        let mut set: Vec<CellRef> = sh.cells.iter_range(block).map(|(c, _)| c).collect();
-        set.extend(sh.spill.range(block.start..=block.end).map(|(c, _)| *c).filter(|c| block.contains(*c)));
-        set.sort_unstable();
-        set.dedup();
-        set.retain(|c| !covered(*c));
-        set
-    };
-    pg.save();
-    pg.clip_rect(bx, by, bw, bh);
-    if gridlines {
-        let grey = [0xB0, 0xB0, 0xB0];
-        let lw = (0.35 * b.scale).clamp(0.1, 0.5);
-        for x in &b.xs {
-            pg.stroke_line(*x, by, *x, by + bh, lw, grey);
-        }
-        for y in &b.ys {
-            pg.stroke_line(bx, *y, bx + bw, *y, lw, grey);
-        }
-    }
-    // Cheap pre-filter: blank, unstyled cells outside tables and conditional formats draw nothing.
-    let skip = |c: &CellRef| {
-        sh.cond_formats.is_empty()
-            && sh.value_ref(*c).is_none_or(|v| v.is_empty())
-            && sh.style_id(*c) == StyleId::DEFAULT
-            && (sh.tables.is_empty() || sh.table_at(*c).is_none())
-    };
-    let looks: Vec<(CellRef, Look)> = cells
-        .iter()
-        .filter(|c| !skip(c))
-        .chain(merges.iter().map(|m| &m.start))
-        .map(|c| (*c, cell_look(b.wb, b.si, sh, *c, cf)))
-        .filter(|(c, l)| {
-            l.fill.is_some()
-                || l.cf.is_some()
-                || merges.iter().any(|m| m.start == *c)
-                || !sh.value(*c).is_empty()
-                || l.style.borders != Borders::default()
-        })
-        .collect();
-    let rect_of = |c: CellRef| -> (f32, f32, f32, f32, bool) {
-        match merges.iter().find(|m| m.start == c) {
-            Some(m) => {
-                let (x, y, w, h) = b.rect(*m);
-                (x, y, w, h, true)
-            }
-            None => {
-                let (x, y, w, h) = b.rect(RangeRef::cell(c));
-                (x, y, w, h, false)
-            }
-        }
-    };
-    // Fills (merged blocks hide the gridlines inside them).
-    for (c, l) in &looks {
-        let (x, y, w, h, merged) = rect_of(*c);
-        if w <= 0.0 || h <= 0.0 {
-            continue;
-        }
-        if let Some(f) = l.fill {
-            pg.fill_rect(x, y, w, h, f);
-        } else if merged && gridlines {
-            pg.fill_rect(x, y, w, h, [255, 255, 255]);
-        }
-        if merged && gridlines {
-            pg.rect_stroke(x, y, w, h, (0.35 * b.scale).clamp(0.1, 0.5), [0xB0, 0xB0, 0xB0]);
-        }
-        if let Some((frac, rgb, _)) = l.cf.as_ref().and_then(|cf| cf.bar) {
-            let pad = 1.5 * b.k;
-            let bwid = ((w - 2.0 * pad) * frac.clamp(0.0, 1.0)).max(0.0);
-            pg.fill_rect(x + pad, y + pad, bwid, (h - 2.0 * pad).max(0.0), rgb);
-        }
-    }
-    // Borders.
-    for (c, l) in &looks {
-        let (x, y, w, h, merged) = rect_of(*c);
-        if w <= 0.0 || h <= 0.0 {
-            continue;
-        }
-        let bd = &l.style.borders;
-        let (right, bottom) = match merges.iter().find(|m| m.start == *c).filter(|_| merged) {
-            Some(m) => (
-                b.wb.styles.get(sh.style_id(CellRef::new(m.start.row, m.end.col))).borders.right,
-                b.wb.styles.get(sh.style_id(CellRef::new(m.end.row, m.start.col))).borders.bottom,
-            ),
-            None => (bd.right, bd.bottom),
-        };
-        draw_border(pg, &bd.top, b.wb, x, y, x + w, y, b.k);
-        draw_border(pg, &bottom, b.wb, x, y + h, x + w, y + h, b.k);
-        draw_border(pg, &bd.left, b.wb, x, y, x, y + h, b.k);
-        draw_border(pg, &right, b.wb, x + w, y, x + w, y + h, b.k);
-        draw_border(pg, &bd.diag_down, b.wb, x, y, x + w, y + h, b.k);
-        draw_border(pg, &bd.diag_up, b.wb, x, y + h, x + w, y, b.k);
-    }
-    // Text.
-    for (c, l) in &looks {
-        let (x, y, w, h, merged) = rect_of(*c);
-        if w <= 0.0 || h <= 0.0 {
-            continue;
-        }
-        if let Some(picture) = sh.cell_pictures.get(c) {
-            draw_cell_picture(pg, &picture.data, (x, y, w, h), b.k);
-        } else {
-            draw_text(pg, b, *c, l, (x, y, w, h), merged, &merges, (bx, bx + bw));
-        }
-    }
-    pg.restore();
-}
-
-struct PendingPdfLink {
-    page: usize,
-    sheet: usize,
-    rect: (f32, f32, f32, f32),
-    target: String,
-}
-
-struct PrintedBlock {
-    page: usize,
-    sheet: usize,
-    rows: (u32, u32),
-    cols: (u32, u32),
-    x: f32,
-    y: f32,
-    k: f32,
-}
-
-/// PDF annotations are not affected by graphics clipping, so intersect each cell with its page
-/// block before adding a clickable rectangle. A repeated print-title cell may appear on several
-/// pages and receives one annotation on each of them.
-fn draw_block_links(pg: &mut Page, b: &Block, page: usize, pending: &mut Vec<PendingPdfLink>) {
-    let range = b.range();
-    let (Some(&bx), Some(&by), Some(&right), Some(&bottom)) = (b.xs.first(), b.ys.first(), b.xs.last(), b.ys.last()) else { return };
-    for (cell, link) in b.sh.hyperlinks.range(range.start..=range.end) {
-        if !range.contains(*cell) {
-            continue;
-        }
-        let cell_range = b.sh.merges.iter().find(|m| m.start == *cell).copied().unwrap_or(RangeRef::cell(*cell));
-        let (x, y, w, h) = b.rect(cell_range);
-        let (x0, y0, x1, y1) = (x.max(bx), y.max(by), (x + w).min(right), (y + h).min(bottom));
-        if x1 <= x0 || y1 <= y0 {
-            continue;
-        }
-        let rect = (x0, y0, x1 - x0, y1 - y0);
-        match crate::links::classify(&link.target) {
-            crate::links::LinkKind::External(uri) => pg.link_uri(rect.0, rect.1, rect.2, rect.3, &uri),
-            crate::links::LinkKind::Internal(target) if !link.external => {
-                pending.push(PendingPdfLink { page, sheet: b.si, rect, target });
-            }
-            _ => {}
-        }
-    }
-}
-
-fn printed_target(wb: &Workbook, blocks: &[PrintedBlock], source_sheet: usize, target: &str) -> Option<(usize, f32, f32)> {
-    let target = target.trim().trim_start_matches('#').trim_start_matches('=');
-    let (sheet_name, range) = split_sheet(target);
-    let sheet = sheet_name.map_or(Some(source_sheet), |name| wb.sheet_index(&name))?;
-    let cell = RangeRef::parse(&range.replace('$', ""))?.start;
-    let sh = wb.sheet(sheet)?;
-    let block = blocks.iter().find(|b| b.sheet == sheet && (b.rows.0..=b.rows.1).contains(&cell.row) && (b.cols.0..=b.cols.1).contains(&cell.col))?;
-    let x = block.x + (sh.col_left(cell.col) - sh.col_left(block.cols.0)) as f32 * block.k;
-    let y = block.y + (sh.row_top(cell.row) - sh.row_top(block.rows.0)) as f32 * block.k;
-    Some((block.page, x, y))
-}
-
-/// Cell pictures fit the current cell (or merged-cell) rectangle without changing aspect ratio.
-fn draw_cell_picture(pg: &mut Page, data: &[u8], rect: (f32, f32, f32, f32), k: f32) {
-    let (x, y, w, h) = rect;
-    let pad = 2.0 * k;
-    let (w, h) = ((w - 2.0 * pad).max(0.0), (h - 2.0 * pad).max(0.0));
-    if w <= 0.0 || h <= 0.0 || data.len() > 16 * 1024 * 1024 {
-        return;
-    }
-    let Some((iw, ih)) = crate::io::image_size(data) else { return };
-    if iw == 0 || ih == 0 || iw > 8192 || ih > 8192 || u64::from(iw) * u64::from(ih) > 16_000_000 {
-        return;
-    }
-    let Ok(mut reader) = image::ImageReader::new(std::io::Cursor::new(data)).with_guessed_format() else { return };
-    let mut limits = image::Limits::default();
-    limits.max_image_width = Some(8192);
-    limits.max_image_height = Some(8192);
-    limits.max_alloc = Some(64 * 1024 * 1024);
-    reader.limits(limits);
-    let Ok(image) = reader.decode() else { return };
-    let image =
-        image.thumbnail(((w / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32, ((h / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32).to_rgba8();
-    let fit = (w / iw as f32).min(h / ih as f32);
-    let (pw, ph) = (iw as f32 * fit, ih as f32 * fit);
-    pg.image_rgba(x + pad + (w - pw) / 2.0, y + pad + (h - ph) / 2.0, pw, ph, image.as_raw(), image.width(), image.height());
-}
-
-/// Is a cell free for text to overflow into?
-fn empty_for_overflow(sh: &Sheet, c: CellRef, merges: &[RangeRef]) -> bool {
-    sh.value_ref(c).is_none_or(|v| v.is_empty()) && !merges.iter().any(|m| m.contains(c))
-}
-
-/// Unscaled width of the empty Center Across Selection cells right of `c`, which its text is centred over too.
-fn center_across_width(styles: &StyleTable, sh: &Sheet, c: CellRef, merges: &[RangeRef]) -> f32 {
-    let mut ext = 0.0;
-    let mut col = c.col + 1;
-    while col < MAX_COLS && ext < 20_000.0 {
-        let nc = CellRef::new(c.row, col);
-        if !empty_for_overflow(sh, nc, merges) || styles.get(sh.style_id(nc)).align.h != HAlign::CenterAcross {
-            break;
-        }
-        ext += sh.col_width(col);
-        col += 1;
-    }
-    ext
-}
-
-fn draw_text(pg: &mut Page, b: &Block, c: CellRef, l: &Look, rect: (f32, f32, f32, f32), merged: bool, merges: &[RangeRef], limits: (f32, f32)) {
-    let (x, y, w, h) = rect;
-    let sh = b.sh;
-    let wb = b.wb;
-    let v = sh.value(c);
-    if v.is_empty() || l.cf.as_ref().is_some_and(|cf| cf.hide_value) {
-        return;
-    }
-    if !sh.show_zeros && v.as_f64() == Some(0.0) {
-        return;
-    }
-    let st = &l.style;
-    let mut size = st.font.size.clamp(1.0, 409.0) * b.scale;
-    let font = font_for(st);
-    let pad = PAD_PX * b.k;
-    let indent = st.align.indent as f32 * 9.0 * b.k;
-    let avail = (w - 2.0 * pad - indent).max(0.0);
-    let code = st.num_fmt.as_str();
-    let formatted = crate::display::format(&v, code, wb);
-    let mut color = formatted.color.and_then(gridcraft_numfmt::FormatColor::rgb).or_else(|| rgb_of(st.font.color, wb)).unwrap_or([0, 0, 0]);
-    if l.cf.as_ref().and_then(|x| x.style.as_ref()).is_some_and(|s| s.font.color != Color::Auto) {
-        color = rgb_of(st.font.color, wb).unwrap_or(color);
-    }
-    let is_num = matches!(v, Value::Number(_));
-    let wrap = st.align.wrap;
-    let mut text = if sh.show_formulas {
-        crate::display::cell_text(wb, sh, c)
-    } else if code == "General"
-        && let Value::Number(n) = v
-    {
-        let digit = gridcraft_pdf::text_width(font, size, "0").max(0.1);
-        let max_chars = (avail / digit).floor().max(1.0) as usize;
-        gridcraft_numfmt::format_general_fit(n, max_chars.min(11)).unwrap_or_else(|| "#".repeat(max_chars.min(255)))
-    } else {
-        // The look's code, which a conditional format can override (#1163).
-        crate::display::value_text_as(wb, &v, code)
-    };
-    if !wrap {
-        text = text.replace(['\n', '\r'], " ");
-    }
-    if text.is_empty() {
-        return;
-    }
-    let mut tw = gridcraft_pdf::text_width(font, size, &text);
-    if st.align.shrink && !wrap && tw > avail && tw > 0.0 {
-        size = (size * avail / tw).max(1.0);
-        tw = gridcraft_pdf::text_width(font, size, &text);
-    }
-    if is_num && !wrap && tw > avail + 0.01 && !sh.show_formulas {
-        let hash = gridcraft_pdf::text_width(font, size, "#").max(0.1);
-        text = "#".repeat(((avail / hash).floor().max(1.0) as usize).min(255));
-        tw = gridcraft_pdf::text_width(font, size, &text);
-    }
-    let h_align = match st.align.h {
-        HAlign::General => {
-            if is_num {
-                HAlign::Right
-            } else if matches!(v, Value::Bool(_) | Value::Error(_)) {
-                HAlign::Center
-            } else {
-                HAlign::Left
-            }
-        }
-        HAlign::CenterAcross | HAlign::Distributed => HAlign::Center,
-        HAlign::Justify | HAlign::Fill => HAlign::Left,
-        other => other,
-    };
-    let rot = st.align.rotation;
-    let rotated = rot != 0 && rot != 255;
-    // Rotated text wraps along its own direction: upright (±90°) text to the row height.
-    let lines: Vec<String> = match (wrap, rotated) {
-        (true, false) => wrap_lines(&text, font, size, avail.max(size)),
-        (true, true) if rot.abs() == 90 => wrap_lines(&text, font, size, (h - 2.0 * pad).max(size)),
-        (true, true) => vec![text.lines().next().unwrap_or_default().to_string()],
-        (false, _) => vec![text],
-    };
-    let line_h = size * 1.2;
-    let n = lines.len().max(1) as f32;
-    let first_baseline = match st.align.v {
-        VAlign::Top => y + pad + size * 0.8,
-        VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - n * line_h) / 2.0 + line_h * 0.5 + size * 0.33,
-        VAlign::Bottom => y + h - pad - size * 0.22 - (n - 1.0) * line_h,
-    };
-    // Overflow into empty neighbours (single-line text, not merged).
-    // Center Across Selection spans the empty Center Across cells to its right; the text stays within that run.
-    let spans = st.align.h == HAlign::CenterAcross && !wrap && !merged && rot == 0;
-    let across = if spans { center_across_width(&wb.styles, sh, c, merges) * b.k } else { 0.0 };
-    let (mut clip_l, mut clip_r) = (x, x + w + across);
-    if !wrap && !merged && !is_num && rot.abs() != 90 && across <= 0.0 && tw + 2.0 * pad + indent > w {
-        let need = tw + 2.0 * pad + indent - w;
-        let grow = |dir: i64, mut need: f32| -> f32 {
-            let mut ext = 0.0;
-            let mut col = c.col as i64 + dir;
-            while need > 0.0 && col >= 0 && col < MAX_COLS as i64 {
-                let nc = CellRef::new(c.row, col as u32);
-                if !empty_for_overflow(sh, nc, merges) {
-                    break;
-                }
-                let cw = sh.col_width(nc.col) * b.k;
-                ext += cw;
-                need -= cw;
-                col += dir;
-                if ext > 20_000.0 {
-                    break;
-                }
-            }
-            ext
-        };
-        match h_align {
-            HAlign::Right => clip_l -= grow(-1, need),
-            HAlign::Center => {
-                clip_l -= grow(-1, need / 2.0);
-                clip_r += grow(1, need / 2.0);
-            }
-            _ => clip_r += grow(1, need),
-        }
-    }
-    let clip_l = clip_l.max(limits.0);
-    let clip_r = clip_r.min(limits.1);
-    pg.save();
-    pg.clip_rect(clip_l, y, (clip_r - clip_l).max(0.0), h);
-    if rotated {
-        // Rotated text: anchored at the bottom-left (upward) or top-left (downward) of the cell.
-        // Wrapped lines stack rightward for upward text and leftward for downward text, so
-        // downward text starts its first line far enough in for the last to end at the left pad.
-        let deg = (rot as f32).clamp(-90.0, 90.0);
-        let angle = -deg.to_radians();
-        let last = lines.len().saturating_sub(1) as f32;
-        for (i, t) in lines.iter().enumerate() {
-            let i = i as f32;
-            let (ox, oy) = if deg > 0.0 {
-                (x + pad + size * 0.8 * deg.to_radians().sin() + i * line_h, y + h - pad)
-            } else {
-                (x + pad + (last - i) * line_h, y + pad + size * 0.8)
-            };
-            pg.text_rotated(ox, oy, size, font, color, t, angle);
-        }
-        pg.restore();
-        return;
-    }
-    if rot == 255 {
-        // Vertical stacked text.
-        let chars: Vec<char> = lines.concat().chars().take(500).collect();
-        let mut yy = y + pad + size * 0.8;
-        for ch in chars {
-            let s = ch.to_string();
-            let cw = gridcraft_pdf::text_width(font, size, &s);
-            pg.text(x + (w - cw) / 2.0, yy, size, font, color, &s);
-            yy += line_h;
-            if yy > y + h + line_h {
-                break;
-            }
-        }
-        pg.restore();
-        return;
-    }
-    for (i, line) in lines.iter().enumerate() {
-        let lw = gridcraft_pdf::text_width(font, size, line);
-        let lx = match h_align {
-            HAlign::Right => x + w - pad - lw - indent,
-            HAlign::Center => x + (w + across - lw) / 2.0,
-            _ => x + pad + indent,
-        };
-        let ly = first_baseline + i as f32 * line_h;
-        if ly - size > y + h || ly < y - line_h {
-            continue;
-        }
-        pg.text(lx, ly, size, font, color, line);
-        if st.font.underline != Underline::None {
-            let uw = (size * 0.06).max(0.2);
-            pg.stroke_line(lx, ly + size * 0.12, lx + lw, ly + size * 0.12, uw, color);
-            if matches!(st.font.underline, Underline::Double | Underline::DoubleAccounting) {
-                pg.stroke_line(lx, ly + size * 0.24, lx + lw, ly + size * 0.24, uw, color);
-            }
-        }
-        if st.font.strike {
-            pg.stroke_line(lx, ly - size * 0.3, lx + lw, ly - size * 0.3, (size * 0.06).max(0.2), color);
-        }
-    }
-    pg.restore();
-}
-
-/// Sheet pixel rectangle of an anchor.
-fn anchor_rect(sh: &Sheet, a: &Anchor) -> (f64, f64, f64, f64) {
-    (sh.col_left(a.cell.col) + a.dx as f64, sh.row_top(a.cell.row) + a.dy as f64, a.width.max(0.0) as f64, a.height.max(0.0) as f64)
-}
-
-/// Decodes an embedded picture to RGBA, downscaled to at most `max_w`×`max_h` pixels.
-fn decode_image(data: &[u8], max_w: u32, max_h: u32) -> Option<(Vec<u8>, u32, u32)> {
-    let (w, h) = crate::io::image_size(data)?;
-    if w == 0 || h == 0 || w as u64 * h as u64 > 60_000_000 {
-        return None;
-    }
-    let img = image::load_from_memory(data).ok()?;
-    let img = if img.width() > max_w.max(1) || img.height() > max_h.max(1) { img.thumbnail(max_w.max(1), max_h.max(1)) } else { img };
-    let rgba = img.to_rgba8();
-    let (pw, ph) = (rgba.width(), rgba.height());
-    Some((rgba.into_raw(), pw, ph))
-}
-
-/// Draws charts, pictures, shapes and sparklines overlapping the body block of a page.
-/// `pics` memoizes decoded pictures for the whole render (one page at a time draws each
-/// picture again, but the decode happens once).
-fn draw_objects(
-    pg: &mut Page,
-    wb: &Workbook,
-    si: usize,
-    sh: &Sheet,
-    b: &Block,
-    pics: &mut std::collections::HashMap<(usize, usize), Option<(Vec<u8>, u32, u32)>>,
-) {
-    let block = b.range();
-    let (sx0, sy0) = (sh.col_left(block.start.col), sh.row_top(block.start.row));
-    let (sx1, sy1) = (sh.col_left(block.end.col.saturating_add(1)), sh.row_top(block.end.row.saturating_add(1)));
-    let (bx, by) = (b.xs.first().copied().unwrap_or(0.0), b.ys.first().copied().unwrap_or(0.0));
-    let (bw, bh) = (b.xs.last().copied().unwrap_or(bx) - bx, b.ys.last().copied().unwrap_or(by) - by);
-    let visible = |r: (f64, f64, f64, f64)| r.2 > 0.0 && r.3 > 0.0 && r.0 < sx1 && r.0 + r.2 > sx0 && r.1 < sy1 && r.1 + r.3 > sy0;
-    let place = |r: (f64, f64, f64, f64)| (bx + ((r.0 - sx0) as f32) * b.k, by + ((r.1 - sy0) as f32) * b.k, r.2 as f32 * b.k, r.3 as f32 * b.k);
-    pg.save();
-    pg.clip_rect(bx, by, bw, bh);
-    draw_sparklines(pg, wb, si, sh, b, block);
-    for (imi, im) in sh.images.iter().enumerate() {
-        let r = anchor_rect(sh, &im.anchor);
-        if !visible(r) {
-            continue;
-        }
-        let (x, y, w, h) = place(r);
-        // About 150 dpi is plenty for print.
-        let (mw, mh) = (((w / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32, ((h / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32);
-        let decoded = pics.entry((si, imi)).or_insert_with(|| decode_image(&im.data, mw, mh));
-        if let Some((px, pw, ph)) = decoded.as_ref() {
-            pg.image_rgba(x, y, w, h, px, *pw, *ph);
-        }
-    }
-    for shp in &sh.shapes {
-        let r = anchor_rect(sh, &shp.anchor);
-        if !visible(r) {
-            continue;
-        }
-        let (x, y, w, h) = place(r);
-        draw_shape(pg, wb, shp, b, (x, y, w, h));
-    }
-    for ch in &sh.charts {
-        let r = anchor_rect(sh, &ch.anchor);
-        if !visible(r) {
-            continue;
-        }
-        let (x, y, _, _) = place(r);
-        let data = gridcraft_chart::resolve(wb, si, ch);
-        let prims = gridcraft_chart::render(ch, &data, r.2 as f32, r.3 as f32, &PdfMeasure);
-        draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
-    }
-    pg.restore();
-}
-
-fn draw_sparklines(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet, b: &Block, block: RangeRef) {
-    for sp in &sh.sparklines {
-        if !block.contains(sp.cell) {
-            continue;
-        }
-        let vals: Vec<Option<f64>> = match gridcraft_calc::evaluate(wb, si, sp.cell, &sp.source) {
-            Value::Array(a) => a.iter().take(10_000).map(Value::as_f64).collect(),
-            v => vec![v.as_f64()],
-        };
-        let color = rgb_of(sp.color, wb).unwrap_or([0x15, 0x60, 0x82]);
-        let (x, y, w, h) = b.rect(RangeRef::cell(sp.cell));
-        let (wpx, hpx) = (w / b.k, h / b.k);
-        let prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [color[0], color[1], color[2], 255], sp.markers, wpx, hpx);
-        draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
-    }
-}
-
-fn draw_shape(pg: &mut Page, wb: &Workbook, shp: &gridcraft_model::Shape, b: &Block, (x, y, w, h): (f32, f32, f32, f32)) {
-    let fill = rgb_of(shp.fill, wb);
-    let line = rgb_of(shp.line, wb).filter(|_| !shp.format.no_line).map(|c| (c, (0.75 * b.k).max(0.25)));
-    match shp.kind {
-        ShapeKind::Ellipse => {
-            let pts: Vec<[f32; 2]> = (0..72)
-                .map(|i| {
-                    let a = i as f32 / 72.0 * std::f32::consts::TAU;
-                    [x + w / 2.0 + w / 2.0 * a.cos(), y + h / 2.0 + h / 2.0 * a.sin()]
-                })
-                .collect();
-            pg.polygon(&pts, fill, line);
-        }
-        ShapeKind::Triangle => pg.polygon(&[[x + w / 2.0, y], [x + w, y + h], [x, y + h]], fill, line),
-        ShapeKind::Line | ShapeKind::Arrow => {
-            let c = line.map(|l| l.0).or(fill).unwrap_or([0, 0, 0]);
-            pg.stroke_line(x, y, x + w, y + h, (1.0 * b.k).max(0.3), c);
-            if shp.kind == ShapeKind::Arrow {
-                let ang = h.atan2(w);
-                let al = 8.0 * b.k;
-                let p = |da: f32| [x + w - al * (ang + da).cos(), y + h - al * (ang + da).sin()];
-                pg.polygon(&[[x + w, y + h], p(0.4), p(-0.4)], Some(c), None);
-            }
-        }
-        _ => {
-            pg.polygon(&[[x, y], [x + w, y], [x + w, y + h], [x, y + h]], fill, line);
-        }
-    }
-    if shp.text.is_empty() {
-        return;
-    }
-    use gridcraft_model::{ShapeTextAlign, ShapeTextAnchor};
-    let fm = &shp.format;
-    let text_box = shp.kind == ShapeKind::TextBox;
-    let size = fm.font_size.unwrap_or(11.0).clamp(1.0, 4000.0) * b.scale;
-    let font = Font::styled(Font::family_for(fm.font.as_deref().unwrap_or("")), fm.bold, fm.italic);
-    let color = fm.text_color.and_then(|c| rgb_of(c, wb)).unwrap_or([0, 0, 0]);
-    let align = fm.align.unwrap_or(if text_box { ShapeTextAlign::Left } else { ShapeTextAlign::Center });
-    let anchor = fm.anchor.unwrap_or(if text_box { ShapeTextAnchor::Top } else { ShapeTextAnchor::Middle });
-    let lines = wrap_lines(&shp.text, font, size, (w - 4.0 * b.k).max(size));
-    let block_h = lines.len().min(500) as f32 * size * 1.2;
-    let mut yy = match anchor {
-        ShapeTextAnchor::Top => y + 2.0 * b.k,
-        ShapeTextAnchor::Middle => y + (h - block_h) / 2.0,
-        ShapeTextAnchor::Bottom => y + h - 2.0 * b.k - block_h,
-    } + size * 0.8;
-    for l in lines.iter().take(500) {
-        let lw = gridcraft_pdf::text_width(font, size, l);
-        let lx = match align {
-            ShapeTextAlign::Left => x + 2.0 * b.k,
-            ShapeTextAlign::Center => x + (w - lw) / 2.0,
-            ShapeTextAlign::Right => x + w - 2.0 * b.k - lw,
-        };
-        pg.text(lx, yy, size, font, color, l);
-        yy += size * 1.2;
-    }
-}
-
-fn draw_headings(pg: &mut Page, b: &Block, col_heads: bool, row_heads: bool, at: (f32, f32), size: (f32, f32)) {
-    let fill = [0xF2, 0xF2, 0xF2];
-    let line = [0xA0, 0xA0, 0xA0];
-    let fsize = 9.0 * b.scale.max(0.1);
-    let lw = (0.35 * b.scale).clamp(0.1, 0.5);
-    if col_heads {
-        let y = at.1;
-        for col in b.cols.0..=b.cols.1 {
-            let (x0, x1) = (b.x(col), b.x(col + 1));
-            if x1 - x0 <= 0.0 {
-                continue;
-            }
-            pg.fill_rect(x0, y, x1 - x0, size.1, fill);
-            pg.rect_stroke(x0, y, x1 - x0, size.1, lw, line);
-            let t = gridcraft_core::col_to_letters(col);
-            let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
-            pg.text(x0 + (x1 - x0 - tw) / 2.0, y + size.1 / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
-        }
-    }
-    if row_heads {
-        let x = at.0;
-        for row in b.rows.0..=b.rows.1 {
-            let (y0, y1) = (b.y(row), b.y(row + 1));
-            if y1 - y0 <= 0.0 {
-                continue;
-            }
-            pg.fill_rect(x, y0, size.0, y1 - y0, fill);
-            pg.rect_stroke(x, y0, size.0, y1 - y0, lw, line);
-            let t = (row + 1).to_string();
-            let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
-            pg.text(x + (size.0 - tw) / 2.0, y0 + (y1 - y0) / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
-        }
-    }
-}
-
-fn draw_header_footer(pg: &mut Page, lay: &SheetLayout, which: gridcraft_model::HfPage, cx: &HfContext) {
-    let [_, _, _, _, hm, fm] = lay.margins;
-    let (l, r) = lay.hf_sides();
-    let text_scale = lay.hf_text_scale();
-    let pw = lay.page_w;
-    let ph = lay.page_h;
-    for (spec, header) in [(lay.settings.hf(which, false), true), (lay.settings.hf(which, true), false)] {
-        if spec.is_empty() {
-            continue;
-        }
-        let secs = expand_header_footer(spec, cx);
-        for (i, sec) in secs.iter().enumerate() {
-            if sec.text.trim().is_empty() {
-                continue;
-            }
-            let size = sec.size.unwrap_or(10.0).clamp(1.0, 72.0) * text_scale;
-            let font = Font::styled(gridcraft_pdf::Family::Sans, sec.bold, sec.italic);
-            let lines: Vec<&str> = sec.text.split('\n').take(20).collect();
-            let n = lines.len() as f32;
-            for (j, line) in lines.iter().enumerate() {
-                let lw = gridcraft_pdf::text_width(font, size, line);
-                let x = match i {
-                    0 => l,
-                    1 => (pw - lw) / 2.0,
-                    _ => pw - r - lw,
-                };
-                let y = if header { hm + size * 0.8 + j as f32 * size * 1.2 } else { ph - fm - size * 0.22 - (n - 1.0 - j as f32) * size * 1.2 };
-                pg.text(x, y, size, font, [0, 0, 0], line);
-            }
-        }
-    }
-}
-
-/// Builds a block for rows × cols positioned at (x, y) on the page.
-fn make_block<'a>(wb: &'a Workbook, si: usize, sh: &'a Sheet, rows: (u32, u32), cols: (u32, u32), x: f32, y: f32, lay: &SheetLayout) -> Block<'a> {
-    let k = lay.k();
-    let mut xs = Vec::with_capacity((cols.1 - cols.0 + 2) as usize);
-    let mut acc = x;
-    xs.push(acc);
-    for c in cols.0..=cols.1 {
-        acc += sh.col_width(c) * k;
-        xs.push(acc);
-    }
-    let mut ys = Vec::with_capacity((rows.1 - rows.0 + 2) as usize);
-    let mut acc = y;
-    ys.push(acc);
-    for r in rows.0..=rows.1 {
-        acc += sh.row_height(r) * k;
-        ys.push(acc);
-    }
-    Block { wb, si, sh, rows, cols, xs, ys, k, scale: lay.scale }
-}
-
-/// Segments of a page along one axis: repeated titles (before the band) then the band.
-fn segments(titles: Option<(u32, u32)>, band: (u32, u32)) -> Vec<(u32, u32)> {
-    let mut v = Vec::new();
-    if let Some((a, b)) = titles
-        && a < band.0
-    {
-        v.push((a, b.min(band.0 - 1)));
-    }
-    v.push(band);
-    v
-}
-
-fn seg_size(sh: &Sheet, seg: (u32, u32), rows: bool) -> f32 {
-    if rows { (seg.0..=seg.1).map(|r| sh.row_height(r)).sum() } else { (seg.0..=seg.1).map(|c| sh.col_width(c)).sum() }
-}
 
 /// Renders laid-out sheets to a PDF.
 pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str) -> (Vec<u8>, usize) {
diff --git a/crates/engine/src/cmd/print/draw.rs b/crates/engine/src/cmd/print/draw.rs
new file mode 100644
index 000000000..4f67f1449
--- /dev/null
+++ b/crates/engine/src/cmd/print/draw.rs
@@ -0,0 +1,467 @@
+use super::layout::{DENSE_BLOCK, SheetLayout};
+use super::objects::draw_cell_picture;
+use super::text::draw_text;
+use super::*;
+
+// ---------------------------------------------------------------- drawing
+
+pub(super) fn rgb_of(c: Color, wb: &Workbook) -> Option<Rgb> {
+    c.resolve(&wb.theme)
+}
+
+fn blend(fg: [u8; 4]) -> Rgb {
+    let a = fg[3] as u16;
+    let mix = |c: u8| ((c as u16 * a + 255 * (255 - a)) / 255) as u8;
+    [mix(fg[0]), mix(fg[1]), mix(fg[2])]
+}
+
+/// The effective look of a cell: own style, table style, conditional formats.
+pub(super) struct Look {
+    pub(super) style: Style,
+    fill: Option<Rgb>,
+    pub(super) cf: Option<crate::cf::CfLook>,
+}
+
+fn cell_look(wb: &Workbook, si: usize, sh: &Sheet, c: CellRef, cf: &mut Option<crate::cf::CfCache>) -> Look {
+    let mut style = match sh.table_at(c) {
+        Some(t) => crate::tables::table_cell_style(wb, si, t, c),
+        None => wb.styles.get(sh.style_id(c)).clone(),
+    };
+    let cfl = cf.as_mut().and_then(|cache| cache.look(wb, si, c));
+    if let Some(st) = cfl.as_ref().and_then(|l| l.style.as_ref()) {
+        if st.fill.pattern != PatternType::None {
+            style.fill = st.fill;
+        }
+        if st.font.color != Color::Auto {
+            style.font.color = st.font.color;
+        }
+        style.font.bold |= st.font.bold;
+        style.font.italic |= st.font.italic;
+        style.font.strike |= st.font.strike;
+        if st.font.underline != Underline::None {
+            style.font.underline = st.font.underline;
+        }
+        // In a differential style General means "not set" (#1163).
+        if st.num_fmt.as_str() != "General" {
+            style.num_fmt = st.num_fmt.clone();
+        }
+        for (dst, src) in [
+            (&mut style.borders.left, st.borders.left),
+            (&mut style.borders.right, st.borders.right),
+            (&mut style.borders.top, st.borders.top),
+            (&mut style.borders.bottom, st.borders.bottom),
+        ] {
+            if !src.is_none() {
+                *dst = src;
+            }
+        }
+    }
+    let mut fill = match style.fill.pattern {
+        PatternType::None => None,
+        PatternType::Solid => rgb_of(style.fill.fg, wb),
+        _ => {
+            let fg = rgb_of(style.fill.fg, wb).unwrap_or([0, 0, 0]);
+            let bg = rgb_of(style.fill.bg, wb).unwrap_or([255, 255, 255]);
+            Some([0, 1, 2].map(|i| ((fg[i] as u16 + bg[i] as u16 * 3) / 4) as u8))
+        }
+    };
+    if let Some(rgb) = cfl.as_ref().and_then(|l| l.scale_fill) {
+        fill = Some(rgb);
+    }
+    Look { style, fill, cf: cfl }
+}
+
+/// PDF measurement for chart layout.
+pub(super) struct PdfMeasure;
+
+impl gridcraft_chart::Measure for PdfMeasure {
+    fn text_width(&self, text: &str, size: f32, bold: bool) -> f32 {
+        gridcraft_pdf::text_width(if bold { Font::HelveticaBold } else { Font::Helvetica }, size, text)
+    }
+}
+
+/// Maps chart-space coordinates to the page.
+#[derive(Clone, Copy)]
+pub(super) struct Xf {
+    pub(super) ox: f32,
+    pub(super) oy: f32,
+    pub(super) k: f32,
+}
+
+impl Xf {
+    fn p(&self, x: f32, y: f32) -> (f32, f32) {
+        (self.ox + x * self.k, self.oy + y * self.k)
+    }
+    fn pts(&self, pts: &[[f32; 2]]) -> Vec<[f32; 2]> {
+        pts.iter().map(|q| [self.ox + q[0] * self.k, self.oy + q[1] * self.k]).collect()
+    }
+}
+
+/// Draws chart primitives onto a page.
+pub(super) fn draw_prims(pg: &mut Page, prims: &[gridcraft_chart::Prim], xf: Xf) {
+    use gridcraft_chart::{HAlign as H, Prim, VAlign as V};
+    let k = xf.k;
+    for p in prims {
+        match p {
+            Prim::Rect { x, y, w, h, fill, stroke, .. } => {
+                let (px, py) = xf.p(*x, *y);
+                if let Some(f) = fill {
+                    pg.fill_rect(px, py, w * k, h * k, blend(*f));
+                }
+                if let Some((c, lw)) = stroke {
+                    pg.rect_stroke(px, py, w * k, h * k, (lw * k).max(0.1), blend(*c));
+                }
+            }
+            Prim::Line { pts, color, width, dash } => {
+                let d = if *dash { vec![3.0 * k, 2.0 * k] } else { vec![] };
+                pg.polyline(&xf.pts(pts), (width * k).max(0.1), blend(*color), &d);
+            }
+            Prim::Polygon { pts, fill, stroke } => {
+                pg.polygon(&xf.pts(pts), Some(blend(*fill)), stroke.map(|(c, w)| (blend(c), (w * k).max(0.1))));
+            }
+            Prim::Wedge { cx, cy, r_outer, r_inner, a0, a1, fill, stroke } => {
+                let span = (a1 - a0).abs().min(std::f32::consts::TAU);
+                let n = ((span / (std::f32::consts::PI / 36.0)).ceil() as usize).clamp(2, 400);
+                let at = |a: f32, r: f32| [cx + r * a.sin(), cy - r * a.cos()];
+                let mut pts: Vec<[f32; 2]> = (0..=n).map(|i| at(a0 + (a1 - a0) * i as f32 / n as f32, *r_outer)).collect();
+                if *r_inner > 0.0 {
+                    pts.extend((0..=n).rev().map(|i| at(a0 + (a1 - a0) * i as f32 / n as f32, *r_inner)));
+                } else {
+                    pts.push([*cx, *cy]);
+                }
+                pg.polygon(&xf.pts(&pts), Some(blend(*fill)), stroke.map(|(c, w)| (blend(c), (w * k).max(0.1))));
+            }
+            Prim::Circle { cx, cy, r, fill, stroke } => {
+                let (px, py) = xf.p(*cx, *cy);
+                pg.circle(px, py, r * k, fill.map(blend), stroke.map(|(c, w)| (blend(c), (w * k).max(0.1))));
+            }
+            Prim::Text { x, y, text, size, color, bold, align, valign, rotation } => {
+                let font = if *bold { Font::HelveticaBold } else { Font::Helvetica };
+                let size = size * k;
+                let w = gridcraft_pdf::text_width(font, size, text);
+                let dx = match align {
+                    H::Left => 0.0,
+                    H::Center => -w / 2.0,
+                    H::Right => -w,
+                };
+                let dy = match valign {
+                    V::Top => size * 0.78,
+                    V::Middle => size * 0.35,
+                    V::Bottom => -size * 0.21,
+                };
+                let (sn, cs) = if rotation.is_finite() { rotation.sin_cos() } else { (0.0, 1.0) };
+                let (ax, ay) = xf.p(*x, *y);
+                pg.text_rotated(ax + dx * cs - dy * sn, ay + dx * sn + dy * cs, size, font, blend(*color), text, *rotation);
+            }
+        }
+    }
+}
+
+/// Everything needed to draw one page block (a run of rows × a run of columns).
+pub(super) struct Block<'a> {
+    pub(super) wb: &'a Workbook,
+    si: usize,
+    pub(super) sh: &'a Sheet,
+    rows: (u32, u32),
+    cols: (u32, u32),
+    /// Page x of each column's left edge, plus the right edge of the last.
+    pub(super) xs: Vec<f32>,
+    pub(super) ys: Vec<f32>,
+    pub(super) k: f32,
+    pub(super) scale: f32,
+}
+
+impl Block<'_> {
+    fn x(&self, col: u32) -> f32 {
+        if col >= self.cols.0 && col <= self.cols.1 + 1 {
+            return self.xs.get((col - self.cols.0) as usize).copied().unwrap_or(0.0);
+        }
+        let x0 = self.xs.first().copied().unwrap_or(0.0);
+        x0 + ((self.sh.col_left(col) - self.sh.col_left(self.cols.0)) as f32) * self.k
+    }
+    fn y(&self, row: u32) -> f32 {
+        if row >= self.rows.0 && row <= self.rows.1 + 1 {
+            return self.ys.get((row - self.rows.0) as usize).copied().unwrap_or(0.0);
+        }
+        let y0 = self.ys.first().copied().unwrap_or(0.0);
+        y0 + ((self.sh.row_top(row) - self.sh.row_top(self.rows.0)) as f32) * self.k
+    }
+    pub(super) fn rect(&self, r: RangeRef) -> (f32, f32, f32, f32) {
+        let (x0, y0) = (self.x(r.start.col), self.y(r.start.row));
+        (x0, y0, self.x(r.end.col.saturating_add(1)) - x0, self.y(r.end.row.saturating_add(1)) - y0)
+    }
+    pub(super) fn range(&self) -> RangeRef {
+        RangeRef::new(CellRef::new(self.rows.0, self.cols.0), CellRef::new(self.rows.1, self.cols.1))
+    }
+}
+
+fn border_dash(style: BorderStyle, k: f32) -> Vec<f32> {
+    let u = k.max(0.2);
+    match style {
+        BorderStyle::Dashed | BorderStyle::MediumDashed => vec![4.0 * u, 2.0 * u],
+        BorderStyle::Dotted => vec![1.0 * u, 1.0 * u],
+        BorderStyle::Hair => vec![0.75 * u, 0.75 * u],
+        BorderStyle::DashDot | BorderStyle::MediumDashDot | BorderStyle::SlantDashDot => vec![4.0 * u, 1.5 * u, 1.0 * u, 1.5 * u],
+        BorderStyle::DashDotDot | BorderStyle::MediumDashDotDot => vec![4.0 * u, 1.5 * u, 1.0 * u, 1.5 * u, 1.0 * u, 1.5 * u],
+        _ => vec![],
+    }
+}
+
+fn draw_border(pg: &mut Page, b: &BorderLine, wb: &Workbook, x0: f32, y0: f32, x1: f32, y1: f32, k: f32) {
+    if b.is_none() {
+        return;
+    }
+    let color = rgb_of(b.color, wb).unwrap_or([0, 0, 0]);
+    if b.style == BorderStyle::Double {
+        let off = 1.0 * k;
+        let lw = (0.75 * k).max(0.2);
+        let (dx, dy) = if (y0 - y1).abs() < 0.001 { (0.0, off) } else { (off, 0.0) };
+        pg.stroke_line(x0 - dx, y0 - dy, x1 - dx, y1 - dy, lw, color);
+        pg.stroke_line(x0 + dx, y0 + dy, x1 + dx, y1 + dy, lw, color);
+        return;
+    }
+    let lw = (b.style.width() * k).clamp(0.25, 6.0);
+    pg.stroke_line_dashed(x0, y0, x1, y1, lw, color, &border_dash(b.style, k));
+}
+
+/// Draws the cells of a block: fills, gridlines, data bars, borders and text.
+pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Option<crate::cf::CfCache>) {
+    let (bx, by) = (b.xs.first().copied().unwrap_or(0.0), b.ys.first().copied().unwrap_or(0.0));
+    let (bw, bh) = (b.xs.last().copied().unwrap_or(bx) - bx, b.ys.last().copied().unwrap_or(by) - by);
+    if bw <= 0.0 || bh <= 0.0 {
+        return;
+    }
+    let block = b.range();
+    let sh = b.sh;
+    let merges: Vec<RangeRef> = sh.merges.iter().filter(|m| m.intersects(&block)).copied().collect();
+    let covered = |c: CellRef| merges.iter().any(|m| m.contains(c));
+    // Cells worth visiting.
+    let cells: Vec<CellRef> = if block.count() <= DENSE_BLOCK {
+        block.iter().filter(|c| !covered(*c)).collect()
+    } else {
+        let mut set: Vec<CellRef> = sh.cells.iter_range(block).map(|(c, _)| c).collect();
+        set.extend(sh.spill.range(block.start..=block.end).map(|(c, _)| *c).filter(|c| block.contains(*c)));
+        set.sort_unstable();
+        set.dedup();
+        set.retain(|c| !covered(*c));
+        set
+    };
+    pg.save();
+    pg.clip_rect(bx, by, bw, bh);
+    if gridlines {
+        let grey = [0xB0, 0xB0, 0xB0];
+        let lw = (0.35 * b.scale).clamp(0.1, 0.5);
+        for x in &b.xs {
+            pg.stroke_line(*x, by, *x, by + bh, lw, grey);
+        }
+        for y in &b.ys {
+            pg.stroke_line(bx, *y, bx + bw, *y, lw, grey);
+        }
+    }
+    // Cheap pre-filter: blank, unstyled cells outside tables and conditional formats draw nothing.
+    let skip = |c: &CellRef| {
+        sh.cond_formats.is_empty()
+            && sh.value_ref(*c).is_none_or(|v| v.is_empty())
+            && sh.style_id(*c) == StyleId::DEFAULT
+            && (sh.tables.is_empty() || sh.table_at(*c).is_none())
+    };
+    let looks: Vec<(CellRef, Look)> = cells
+        .iter()
+        .filter(|c| !skip(c))
+        .chain(merges.iter().map(|m| &m.start))
+        .map(|c| (*c, cell_look(b.wb, b.si, sh, *c, cf)))
+        .filter(|(c, l)| {
+            l.fill.is_some()
+                || l.cf.is_some()
+                || merges.iter().any(|m| m.start == *c)
+                || !sh.value(*c).is_empty()
+                || l.style.borders != Borders::default()
+        })
+        .collect();
+    let rect_of = |c: CellRef| -> (f32, f32, f32, f32, bool) {
+        match merges.iter().find(|m| m.start == c) {
+            Some(m) => {
+                let (x, y, w, h) = b.rect(*m);
+                (x, y, w, h, true)
+            }
+            None => {
+                let (x, y, w, h) = b.rect(RangeRef::cell(c));
+                (x, y, w, h, false)
+            }
+        }
+    };
+    // Fills (merged blocks hide the gridlines inside them).
+    for (c, l) in &looks {
+        let (x, y, w, h, merged) = rect_of(*c);
+        if w <= 0.0 || h <= 0.0 {
+            continue;
+        }
+        if let Some(f) = l.fill {
+            pg.fill_rect(x, y, w, h, f);
+        } else if merged && gridlines {
+            pg.fill_rect(x, y, w, h, [255, 255, 255]);
+        }
+        if merged && gridlines {
+            pg.rect_stroke(x, y, w, h, (0.35 * b.scale).clamp(0.1, 0.5), [0xB0, 0xB0, 0xB0]);
+        }
+        if let Some((frac, rgb, _)) = l.cf.as_ref().and_then(|cf| cf.bar) {
+            let pad = 1.5 * b.k;
+            let bwid = ((w - 2.0 * pad) * frac.clamp(0.0, 1.0)).max(0.0);
+            pg.fill_rect(x + pad, y + pad, bwid, (h - 2.0 * pad).max(0.0), rgb);
+        }
+    }
+    // Borders.
+    for (c, l) in &looks {
+        let (x, y, w, h, merged) = rect_of(*c);
+        if w <= 0.0 || h <= 0.0 {
+            continue;
+        }
+        let bd = &l.style.borders;
+        let (right, bottom) = match merges.iter().find(|m| m.start == *c).filter(|_| merged) {
+            Some(m) => (
+                b.wb.styles.get(sh.style_id(CellRef::new(m.start.row, m.end.col))).borders.right,
+                b.wb.styles.get(sh.style_id(CellRef::new(m.end.row, m.start.col))).borders.bottom,
+            ),
+            None => (bd.right, bd.bottom),
+        };
+        draw_border(pg, &bd.top, b.wb, x, y, x + w, y, b.k);
+        draw_border(pg, &bottom, b.wb, x, y + h, x + w, y + h, b.k);
+        draw_border(pg, &bd.left, b.wb, x, y, x, y + h, b.k);
+        draw_border(pg, &right, b.wb, x + w, y, x + w, y + h, b.k);
+        draw_border(pg, &bd.diag_down, b.wb, x, y, x + w, y + h, b.k);
+        draw_border(pg, &bd.diag_up, b.wb, x, y + h, x + w, y, b.k);
+    }
+    // Text.
+    for (c, l) in &looks {
+        let (x, y, w, h, merged) = rect_of(*c);
+        if w <= 0.0 || h <= 0.0 {
+            continue;
+        }
+        if let Some(picture) = sh.cell_pictures.get(c) {
+            draw_cell_picture(pg, &picture.data, (x, y, w, h), b.k);
+        } else {
+            draw_text(pg, b, *c, l, (x, y, w, h), merged, &merges, (bx, bx + bw));
+        }
+    }
+    pg.restore();
+}
+
+pub(super) struct PendingPdfLink {
+    pub(super) page: usize,
+    pub(super) sheet: usize,
+    pub(super) rect: (f32, f32, f32, f32),
+    pub(super) target: String,
+}
+
+pub(super) struct PrintedBlock {
+    pub(super) page: usize,
+    pub(super) sheet: usize,
+    pub(super) rows: (u32, u32),
+    pub(super) cols: (u32, u32),
+    pub(super) x: f32,
+    pub(super) y: f32,
+    pub(super) k: f32,
+}
+
+/// PDF annotations are not affected by graphics clipping, so intersect each cell with its page
+/// block before adding a clickable rectangle. A repeated print-title cell may appear on several
+/// pages and receives one annotation on each of them.
+pub(super) fn draw_block_links(pg: &mut Page, b: &Block, page: usize, pending: &mut Vec<PendingPdfLink>) {
+    let range = b.range();
+    let (Some(&bx), Some(&by), Some(&right), Some(&bottom)) = (b.xs.first(), b.ys.first(), b.xs.last(), b.ys.last()) else { return };
+    for (cell, link) in b.sh.hyperlinks.range(range.start..=range.end) {
+        if !range.contains(*cell) {
+            continue;
+        }
+        let cell_range = b.sh.merges.iter().find(|m| m.start == *cell).copied().unwrap_or(RangeRef::cell(*cell));
+        let (x, y, w, h) = b.rect(cell_range);
+        let (x0, y0, x1, y1) = (x.max(bx), y.max(by), (x + w).min(right), (y + h).min(bottom));
+        if x1 <= x0 || y1 <= y0 {
+            continue;
+        }
+        let rect = (x0, y0, x1 - x0, y1 - y0);
+        match crate::links::classify(&link.target) {
+            crate::links::LinkKind::External(uri) => pg.link_uri(rect.0, rect.1, rect.2, rect.3, &uri),
+            crate::links::LinkKind::Internal(target) if !link.external => {
+                pending.push(PendingPdfLink { page, sheet: b.si, rect, target });
+            }
+            _ => {}
+        }
+    }
+}
+
+pub(super) fn printed_target(wb: &Workbook, blocks: &[PrintedBlock], source_sheet: usize, target: &str) -> Option<(usize, f32, f32)> {
+    let target = target.trim().trim_start_matches('#').trim_start_matches('=');
+    let (sheet_name, range) = split_sheet(target);
+    let sheet = sheet_name.map_or(Some(source_sheet), |name| wb.sheet_index(&name))?;
+    let cell = RangeRef::parse(&range.replace('$', ""))?.start;
+    let sh = wb.sheet(sheet)?;
+    let block = blocks.iter().find(|b| b.sheet == sheet && (b.rows.0..=b.rows.1).contains(&cell.row) && (b.cols.0..=b.cols.1).contains(&cell.col))?;
+    let x = block.x + (sh.col_left(cell.col) - sh.col_left(block.cols.0)) as f32 * block.k;
+    let y = block.y + (sh.row_top(cell.row) - sh.row_top(block.rows.0)) as f32 * block.k;
+    Some((block.page, x, y))
+}
+
+pub(super) fn draw_headings(pg: &mut Page, b: &Block, col_heads: bool, row_heads: bool, at: (f32, f32), size: (f32, f32)) {
+    let fill = [0xF2, 0xF2, 0xF2];
+    let line = [0xA0, 0xA0, 0xA0];
+    let fsize = 9.0 * b.scale.max(0.1);
+    let lw = (0.35 * b.scale).clamp(0.1, 0.5);
+    if col_heads {
+        let y = at.1;
+        for col in b.cols.0..=b.cols.1 {
+            let (x0, x1) = (b.x(col), b.x(col + 1));
+            if x1 - x0 <= 0.0 {
+                continue;
+            }
+            pg.fill_rect(x0, y, x1 - x0, size.1, fill);
+            pg.rect_stroke(x0, y, x1 - x0, size.1, lw, line);
+            let t = gridcraft_core::col_to_letters(col);
+            let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
+            pg.text(x0 + (x1 - x0 - tw) / 2.0, y + size.1 / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
+        }
+    }
+    if row_heads {
+        let x = at.0;
+        for row in b.rows.0..=b.rows.1 {
+            let (y0, y1) = (b.y(row), b.y(row + 1));
+            if y1 - y0 <= 0.0 {
+                continue;
+            }
+            pg.fill_rect(x, y0, size.0, y1 - y0, fill);
+            pg.rect_stroke(x, y0, size.0, y1 - y0, lw, line);
+            let t = (row + 1).to_string();
+            let tw = gridcraft_pdf::text_width(Font::Helvetica, fsize, &t);
+            pg.text(x + (size.0 - tw) / 2.0, y0 + (y1 - y0) / 2.0 + fsize * 0.35, fsize, Font::Helvetica, [0x40, 0x40, 0x40], &t);
+        }
+    }
+}
+
+/// Builds a block for rows × cols positioned at (x, y) on the page.
+pub(super) fn make_block<'a>(
+    wb: &'a Workbook,
+    si: usize,
+    sh: &'a Sheet,
+    rows: (u32, u32),
+    cols: (u32, u32),
+    x: f32,
+    y: f32,
+    lay: &SheetLayout,
+) -> Block<'a> {
+    let k = lay.k();
+    let mut xs = Vec::with_capacity((cols.1 - cols.0 + 2) as usize);
+    let mut acc = x;
+    xs.push(acc);
+    for c in cols.0..=cols.1 {
+        acc += sh.col_width(c) * k;
+        xs.push(acc);
+    }
+    let mut ys = Vec::with_capacity((rows.1 - rows.0 + 2) as usize);
+    let mut acc = y;
+    ys.push(acc);
+    for r in rows.0..=rows.1 {
+        acc += sh.row_height(r) * k;
+        ys.push(acc);
+    }
+    Block { wb, si, sh, rows, cols, xs, ys, k, scale: lay.scale }
+}
diff --git a/crates/engine/src/cmd/print/header_footer.rs b/crates/engine/src/cmd/print/header_footer.rs
new file mode 100644
index 000000000..769e3b3ad
--- /dev/null
+++ b/crates/engine/src/cmd/print/header_footer.rs
@@ -0,0 +1,261 @@
+use super::layout::SheetLayout;
+use super::*;
+
+/// Side margin of headers and footers, in points, when Align with Page Margins is off.
+pub(super) const HF_FIXED_SIDE_MARGIN: f32 = 0.7 * 72.0;
+
+// ---------------------------------------------------------------- header / footer
+
+/// Values for header/footer codes.
+#[derive(Clone, Debug, Default)]
+pub struct HfContext {
+    pub page: usize,
+    pub pages: usize,
+    pub sheet: String,
+    pub file: String,
+    pub path: String,
+    pub date: String,
+    pub time: String,
+}
+
+/// Today's date and the current time as headers and footers show them (`&D`, `&T`).
+pub fn hf_date_time(wb: &Workbook) -> (String, String) {
+    let now = gridcraft_core::date::serial_in_system(wb.date_system, gridcraft_calc::now_serial());
+    let date = crate::display::format(&Value::Number(now.floor()), "m/d/yyyy", wb).text;
+    let time = crate::display::format(&Value::Number(now), "h:mm AM/PM", wb).text;
+    (date, time)
+}
+
+/// Header/footer codes and the field names the Page Layout view shows for them while editing.
+pub const HF_FIELDS: [(char, &str); 8] = [
+    ('P', "&[Page]"),
+    ('N', "&[Pages]"),
+    ('D', "&[Date]"),
+    ('T', "&[Time]"),
+    ('Z', "&[Path]"),
+    ('F', "&[File]"),
+    ('A', "&[Tab]"),
+    ('G', "&[Picture]"),
+];
+
+/// Splits a header/footer string into its raw left, centre and right sections (codes kept).
+/// Text before the first `&L`/`&C`/`&R` belongs to the centre, as when printing.
+pub fn split_header_footer(spec: &str) -> [String; 3] {
+    let mut out: [String; 3] = Default::default();
+    let mut cur = 1usize;
+    let chars: Vec<char> = spec.chars().take(10_000).collect();
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        let next = chars.get(i + 1).copied();
+        let sec = cur.min(2);
+        match (c, next) {
+            ('&', Some('L' | 'l')) => cur = 0,
+            ('&', Some('C' | 'c')) => cur = 1,
+            ('&', Some('R' | 'r')) => cur = 2,
+            ('&', Some('"')) => {
+                // &"Font,Style" is kept whole.
+                let end = chars[i + 2..].iter().position(|ch| *ch == '"').map_or(chars.len(), |p| i + 3 + p);
+                out[sec].extend(&chars[i..end.min(chars.len())]);
+                i = end;
+                continue;
+            }
+            ('&', Some(n)) => {
+                out[sec].push('&');
+                out[sec].push(n);
+            }
+            ('&', None) => {}
+            (ch, _) => {
+                out[sec].push(ch);
+                i += 1;
+                continue;
+            }
+        }
+        i += 2;
+    }
+    out
+}
+
+/// Joins raw left, centre and right sections into one header/footer string.
+pub fn join_header_footer(sections: &[String; 3]) -> String {
+    let mut s = String::new();
+    for (code, text) in ["&L", "&C", "&R"].iter().zip(sections) {
+        if !text.is_empty() {
+            s.push_str(code);
+            s.push_str(text);
+        }
+    }
+    s
+}
+
+/// A raw section as the user edits it: `&P` shows as `&[Page]`, `&N` as `&[Pages]`, and so on.
+pub fn codes_to_fields(raw: &str) -> String {
+    let mut out = String::new();
+    let mut it = raw.chars().peekable();
+    while let Some(c) = it.next() {
+        if c != '&' {
+            out.push(c);
+            continue;
+        }
+        // A dangling `&` at the end is dropped (printing ignores it too).
+        if let Some(n) = it.next() {
+            match HF_FIELDS.iter().find(|(code, _)| *code == n.to_ascii_uppercase()) {
+                Some((_, field)) => out.push_str(field),
+                None => {
+                    out.push('&');
+                    out.push(n);
+                }
+            }
+        }
+    }
+    out
+}
+
+/// The inverse of [`codes_to_fields`]: field names become codes again; a dangling `&` at the end
+/// becomes a literal ampersand so it can't swallow the next section's code.
+pub fn fields_to_codes(text: &str) -> String {
+    let chars: Vec<char> = text.chars().take(10_000).collect();
+    let mut out = String::new();
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        if c != '&' {
+            out.push(c);
+            i += 1;
+            continue;
+        }
+        if chars.get(i + 1) == Some(&'&') {
+            out.push_str("&&");
+            i += 2;
+            continue;
+        }
+        let rest: String = chars[i..].iter().take(12).collect();
+        if let Some((code, field)) = HF_FIELDS.iter().find(|(_, f)| rest.starts_with(f)) {
+            out.push('&');
+            out.push(*code);
+            i += field.chars().count();
+            continue;
+        }
+        if i + 1 == chars.len() {
+            out.push_str("&&");
+        } else {
+            out.push('&');
+        }
+        i += 1;
+    }
+    out
+}
+
+/// One header/footer section: its text and whether `&B` made it bold.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct HfSection {
+    pub text: String,
+    pub bold: bool,
+    pub italic: bool,
+    pub size: Option<f32>,
+}
+
+/// Expands a header/footer string into its left, centre and right sections.
+pub fn expand_header_footer(spec: &str, cx: &HfContext) -> [HfSection; 3] {
+    let mut out: [HfSection; 3] = Default::default();
+    let mut cur = 1usize;
+    let chars: Vec<char> = spec.chars().take(10_000).collect();
+    let mut i = 0;
+    while i < chars.len() {
+        let c = chars[i];
+        if c != '&' {
+            if let Some(s) = out.get_mut(cur) {
+                s.text.push(c);
+            }
+            i += 1;
+            continue;
+        }
+        let Some(&code) = chars.get(i + 1) else { break };
+        i += 2;
+        let sec = &mut out[cur.min(2)];
+        match code {
+            'L' | 'l' => cur = 0,
+            'C' | 'c' => cur = 1,
+            'R' | 'r' => cur = 2,
+            'P' | 'p' => {
+                // &P, &P+n, &P-n
+                let mut n = cx.page as i64;
+                if let Some(&sign) = chars.get(i)
+                    && (sign == '+' || sign == '-')
+                {
+                    let digits: String = chars[i + 1..].iter().take_while(|d| d.is_ascii_digit()).take(6).collect();
+                    if let Ok(d) = digits.parse::<i64>() {
+                        n = if sign == '+' { n + d } else { n - d };
+                        i += 1 + digits.len();
+                    }
+                }
+                sec.text.push_str(&n.to_string());
+            }
+            'N' | 'n' => sec.text.push_str(&cx.pages.to_string()),
+            'D' | 'd' => sec.text.push_str(&cx.date),
+            'T' | 't' => sec.text.push_str(&cx.time),
+            'A' | 'a' => sec.text.push_str(&cx.sheet),
+            'F' | 'f' => sec.text.push_str(&cx.file),
+            'Z' | 'z' => sec.text.push_str(&cx.path),
+            '&' => sec.text.push('&'),
+            'B' | 'b' => sec.bold = !sec.bold,
+            'I' | 'i' => sec.italic = !sec.italic,
+            '"' => {
+                // &"Font,Style": skip the font name; honour Bold/Italic in the style.
+                let rest: String = chars[i..].iter().take_while(|c| **c != '"').collect();
+                let lower = rest.to_ascii_lowercase();
+                if lower.contains("bold") {
+                    sec.bold = true;
+                }
+                if lower.contains("italic") || lower.contains("oblique") {
+                    sec.italic = true;
+                }
+                i += rest.chars().count() + 1;
+            }
+            d if d.is_ascii_digit() => {
+                let digits: String = std::iter::once(d).chain(chars[i..].iter().copied().take_while(char::is_ascii_digit)).take(3).collect();
+                i += digits.len() - 1;
+                if let Ok(v) = digits.parse::<f32>() {
+                    sec.size = Some(v.clamp(1.0, 409.0));
+                }
+            }
+            // Underline, strike, super/subscript, colour, picture: not rendered.
+            'K' | 'k' => {
+                i = (i + 6).min(chars.len());
+            }
+            _ => {}
+        }
+    }
+    out
+}
+
+pub(super) fn draw_header_footer(pg: &mut Page, lay: &SheetLayout, which: gridcraft_model::HfPage, cx: &HfContext) {
+    let [_, _, _, _, hm, fm] = lay.margins;
+    let (l, r) = lay.hf_sides();
+    let text_scale = lay.hf_text_scale();
+    let pw = lay.page_w;
+    let ph = lay.page_h;
+    for (spec, header) in [(lay.settings.hf(which, false), true), (lay.settings.hf(which, true), false)] {
+        if spec.is_empty() {
+            continue;
+        }
+        let secs = expand_header_footer(spec, cx);
+        for (i, sec) in secs.iter().enumerate() {
+            if sec.text.trim().is_empty() {
+                continue;
+            }
+            let size = sec.size.unwrap_or(10.0).clamp(1.0, 72.0) * text_scale;
+            let font = Font::styled(gridcraft_pdf::Family::Sans, sec.bold, sec.italic);
+            let lines: Vec<&str> = sec.text.split('\n').take(20).collect();
+            let n = lines.len() as f32;
+            for (j, line) in lines.iter().enumerate() {
+                let lw = gridcraft_pdf::text_width(font, size, line);
+                let x = match i {
+                    0 => l,
+                    1 => (pw - lw) / 2.0,
+                    _ => pw - r - lw,
+                };
+                let y = if header { hm + size * 0.8 + j as f32 * size * 1.2 } else { ph - fm - size * 0.22 - (n - 1.0 - j as f32) * size * 1.2 };
+                pg.text(x, y, size, font, [0, 0, 0], line);
+            }
+        }
+    }
+}
diff --git a/crates/engine/src/cmd/print/layout.rs b/crates/engine/src/cmd/print/layout.rs
new file mode 100644
index 000000000..55e874de7
--- /dev/null
+++ b/crates/engine/src/cmd/print/layout.rs
@@ -0,0 +1,364 @@
+use super::header_footer::HF_FIXED_SIDE_MARGIN;
+use super::*;
+
+/// Cells in a page block above which only stored cells are visited (not every grid position).
+pub(super) const DENSE_BLOCK: u64 = 60_000;
+
+// ---------------------------------------------------------------- paper
+
+/// Paper size in points (portrait) for a paper name; unknown names fall back to Letter.
+pub fn paper_size(name: &str) -> (f32, f32) {
+    known_paper(name).unwrap_or((612.0, 792.0))
+}
+
+/// Paper sizes in points, portrait. `B4`/`B5`/`B6` are the **JIS** sizes Japanese Excel and its
+/// e-mail attachments use (257×364, 182×257 and 128×182 mm); the ISO B series stays reachable as
+/// `B4 (ISO)`/`B5 (ISO)`/`B6 (ISO)`. The Japanese postcards and envelopes are the JIS ones too.
+pub(super) fn known_paper(name: &str) -> Option<(f32, f32)> {
+    // Spaces, hyphens, underscores and parentheses don't matter: `B5 (JIS)`, `b5-jis` and `b5`
+    // are one name.
+    let n = name.trim().to_ascii_lowercase().replace([' ', '-', '_', '(', ')'], "");
+    Some(match n.as_str() {
+        "letter" | "usletter" => (612.0, 792.0),
+        "legal" | "uslegal" => (612.0, 1008.0),
+        "a4" => (595.28, 841.89),
+        "a3" => (841.89, 1190.55),
+        "a5" => (419.53, 595.28),
+        "a6" => (297.64, 419.53),
+        "tabloid" | "11x17" => (792.0, 1224.0),
+        "ledger" => (1224.0, 792.0),
+        "executive" => (522.0, 756.0),
+        "b4" | "b4jis" => (728.50, 1031.81),
+        "b5" | "b5jis" => (515.91, 728.50),
+        "b6" | "b6jis" => (362.83, 515.91),
+        "b4iso" => (708.66, 1000.63),
+        "b5iso" => (498.90, 708.66),
+        "b6iso" => (354.33, 498.90),
+        "japanesepostcard" | "postcard" => (283.46, 419.53),
+        "japanesedoublepostcard" | "doublepostcard" => (419.53, 566.93),
+        "japaneseenvelope#3" | "chou#3" => (340.16, 666.14),
+        // 長形4号 is 90×205 mm; 90×225 mm is 長形40号, a different envelope, so it stays out.
+        "japaneseenvelope#4" | "chou#4" => (255.12, 581.10),
+        "japaneseenvelopekaku#2" | "kaku#2" => (680.31, 941.10),
+        "japaneseenvelopekaku#3" | "kaku#3" => (612.28, 785.20),
+        _ => return None,
+    })
+}
+
+// ---------------------------------------------------------------- layout
+
+/// The pagination of one sheet.
+#[derive(Clone, Debug)]
+pub struct SheetLayout {
+    pub sheet: usize,
+    pub settings: PrintSettings,
+    pub page_w: f32,
+    pub page_h: f32,
+    /// Left, right, top, bottom, header, footer margins in points.
+    pub margins: [f32; 6],
+    pub scale: f32,
+    pub area: RangeRef,
+    pub row_bands: Vec<(u32, u32)>,
+    pub col_bands: Vec<(u32, u32)>,
+    /// Pages in print order: (row band, column band).
+    pub pages: Vec<(usize, usize)>,
+    pub title_rows: Option<(u32, u32)>,
+    pub title_cols: Option<(u32, u32)>,
+    /// Heading sizes in sheet pixels (0 when headings are off).
+    pub heading_w: f32,
+    pub heading_h: f32,
+    /// Manual page breaks apply (they don't when the sheet is fitted to pages).
+    pub manual_breaks: bool,
+}
+
+impl SheetLayout {
+    pub(super) fn k(&self) -> f32 {
+        PX_TO_PT * self.scale
+    }
+    pub(crate) fn avail(&self) -> (f32, f32) {
+        let [l, r, t, b, ..] = self.margins;
+        ((self.page_w - l - r).max(36.0), (self.page_h - t - b).max(36.0))
+    }
+    /// Left and right margins, in points, that header and footer sections line up with: the
+    /// page's side margins with Align with Page Margins on, otherwise 0.7 inch on each side, at
+    /// most a quarter of the page width.
+    pub(crate) fn hf_sides(&self) -> (f32, f32) {
+        if self.settings.hf_align_with_margins {
+            (self.margins[0], self.margins[1])
+        } else {
+            let side = HF_FIXED_SIDE_MARGIN.min(self.page_w / 4.0);
+            (side, side)
+        }
+    }
+    /// Scale of header and footer text: the print scale with Scale with Document on, otherwise 1.
+    pub(crate) fn hf_text_scale(&self) -> f32 {
+        if self.settings.hf_scale_with_doc { self.scale } else { 1.0 }
+    }
+}
+
+/// Options shared by the print commands.
+#[derive(Clone, Debug, Default)]
+pub struct PrintOptions {
+    pub all_sheets: bool,
+    pub range: Option<RangeRef>,
+    pub fit_to_page: Option<bool>,
+}
+
+impl PrintOptions {
+    pub(super) fn from_params(p: &Json, cmd: &str) -> Result<PrintOptions> {
+        let all_sheets = match str_param(p, "sheets") {
+            None | Some("active") => false,
+            Some("all") | Some("workbook") => true,
+            Some(other) => return Err(bad(cmd, format!("`sheets` must be active or all, not `{other}`"))),
+        };
+        let range = match str_param(p, "range").map(str::trim).filter(|r| !r.is_empty()) {
+            Some(r) => Some(RangeRef::parse(split_sheet(r).1).ok_or_else(|| bad(cmd, format!("not a range: `{r}`")))?),
+            None => None,
+        };
+        Ok(PrintOptions { all_sheets, range, fit_to_page: bool_param(p, "fitToPage") })
+    }
+}
+
+/// The range a sheet prints: its print area, else the used range grown to cover drawing
+/// objects. `None` when there is nothing to print.
+pub fn print_range(sh: &Sheet) -> Option<RangeRef> {
+    if let Some(a) = sh.print.print_area {
+        return Some(trim_full(sh, a));
+    }
+    let mut r = sh.used_range();
+    let mut grow = |a: &Anchor| {
+        let x = sh.col_left(a.cell.col) + a.dx as f64;
+        let y = sh.row_top(a.cell.row) + a.dy as f64;
+        let end = CellRef::new(sh.row_at(y + a.height.max(0.0) as f64), sh.col_at(x + a.width.max(0.0) as f64));
+        let ar = RangeRef::new(a.cell, end);
+        r = Some(r.map_or(ar, |u| u.union(&ar)));
+    };
+    for c in &sh.charts {
+        grow(&c.anchor);
+    }
+    for i in &sh.images {
+        grow(&i.anchor);
+    }
+    for s in &sh.shapes {
+        grow(&s.anchor);
+    }
+    // Printing starts at A1 like Excel when the data starts nearby? Excel prints from the first
+    // used cell; keep the used range as is.
+    r
+}
+
+/// Whole rows/columns are trimmed to the used range.
+fn trim_full(sh: &Sheet, r: RangeRef) -> RangeRef {
+    if !(r.is_full_cols() || r.is_full_rows()) {
+        return r;
+    }
+    match sh.used_range() {
+        Some(u) => r.intersection(&RangeRef::new(CellRef::new(0, 0), u.end)).unwrap_or(RangeRef::cell(r.start)),
+        None => RangeRef::cell(r.start),
+    }
+}
+
+/// Splits `start..=end` into bands whose sizes fit `avail(band_start)`; `breaks` force a new
+/// band before a line. Stops after `cap` bands.
+pub(super) fn bands(start: u32, end: u32, size: impl Fn(u32) -> f32, avail: impl Fn(u32) -> f32, breaks: &[u32], cap: usize) -> Vec<(u32, u32)> {
+    let mut out = Vec::new();
+    let mut cur = start;
+    let mut used = 0.0f32;
+    let mut room = avail(start);
+    let mut line = start;
+    loop {
+        let sz = size(line);
+        let manual = line > cur && breaks.binary_search(&line).is_ok();
+        if line > cur && (manual || used + sz > room + 0.01) {
+            out.push((cur, line - 1));
+            if out.len() >= cap {
+                return out;
+            }
+            cur = line;
+            used = 0.0;
+            room = avail(line);
+        }
+        used += sz;
+        if line >= end {
+            break;
+        }
+        line += 1;
+    }
+    out.push((cur, end));
+    out
+}
+
+fn title_span(t: Option<(u32, u32)>, max: u32) -> Option<(u32, u32)> {
+    let (a, b) = t?;
+    let (a, b) = (a.min(b), a.max(b));
+    if a >= max {
+        return None;
+    }
+    // Repeated titles are capped (Excel needs them to fit on a page anyway).
+    Some((a, b.min(max - 1).min(a.saturating_add(499))))
+}
+
+/// Paginates one sheet.
+pub fn layout_sheet(wb: &Workbook, si: usize, opts: &PrintOptions, range_override: Option<RangeRef>) -> Option<SheetLayout> {
+    let sh = wb.sheet(si)?;
+    let st = sh.print.clone();
+    let (mut pw, mut ph) = paper_size(&st.paper);
+    if st.orientation == Orientation::Landscape {
+        std::mem::swap(&mut pw, &mut ph);
+    }
+    let inch = |i: usize| st.margins.get(i).copied().filter(|v| v.is_finite()).unwrap_or(0.5).clamp(0.0, 20.0) * 72.0;
+    let mut margins = [inch(0), inch(1), inch(2), inch(3), inch(4), inch(5)];
+    // Keep at least an inch of printable space.
+    for (a, b, total) in [(0usize, 1usize, pw), (2, 3, ph)] {
+        let sum = margins[a] + margins[b];
+        if total - sum < 72.0 {
+            let f = ((total - 72.0).max(0.0)) / sum.max(1.0);
+            margins[a] *= f;
+            margins[b] *= f;
+        }
+    }
+    let area = match range_override {
+        Some(r) => trim_full(sh, r),
+        None => print_range(sh).unwrap_or(RangeRef::cell(CellRef::new(0, 0))),
+    };
+    let title_rows = title_span(st.title_rows, MAX_ROWS);
+    let title_cols = title_span(st.title_cols, MAX_COLS);
+    let digits = format!("{}", area.end.row + 1).len() as f32;
+    let (heading_w, heading_h) = if st.headings { (10.0 + 7.0 * digits, sh.default_row_height.clamp(10.0, 60.0)) } else { (0.0, 0.0) };
+    let fit = match opts.fit_to_page {
+        Some(true) => Some((1u16, 1u16)),
+        Some(false) => None,
+        None => st.fit_to.filter(|(w, h)| *w > 0 || *h > 0),
+    };
+    let mut lay = SheetLayout {
+        sheet: si,
+        settings: st.clone(),
+        page_w: pw,
+        page_h: ph,
+        margins,
+        scale: (st.scale.clamp(10, 400) as f32) / 100.0,
+        area,
+        row_bands: vec![],
+        col_bands: vec![],
+        pages: vec![],
+        title_rows,
+        title_cols,
+        heading_w,
+        heading_h,
+        manual_breaks: fit.is_none(),
+    };
+    let paginate = |lay: &mut SheetLayout, manual: bool| {
+        lay.manual_breaks = manual;
+        (lay.row_bands, lay.col_bands) = split_bands(sh, lay, MAX_PAGES);
+        lay.pages.clear();
+        'outer: for ci in 0..lay.col_bands.len() {
+            for ri in 0..lay.row_bands.len() {
+                if lay.pages.len() >= MAX_PAGES {
+                    break 'outer;
+                }
+                lay.pages.push((ri, ci));
+            }
+        }
+    };
+    match fit {
+        Some((fw, fh)) => {
+            let total_w: f32 = (area.start.col..=area.end.col).map(|c| sh.col_width(c)).sum::<f32>() + heading_w;
+            let total_h: f32 = if area.height() > 200_000 {
+                f32::INFINITY
+            } else {
+                (area.start.row..=area.end.row).map(|r| sh.row_height(r)).sum::<f32>() + heading_h
+            };
+            let (aw, ah) = lay.avail();
+            let sw = if fw > 0 { aw * fw as f32 / (total_w * PX_TO_PT).max(1.0) } else { f32::INFINITY };
+            let sh_ = if fh > 0 { ah * fh as f32 / (total_h * PX_TO_PT).max(1.0) } else { f32::INFINITY };
+            lay.scale = sw.min(sh_).min(1.0).clamp(0.1, 1.0);
+            for _ in 0..40 {
+                paginate(&mut lay, false);
+                let ok_w = fw == 0 || lay.col_bands.len() <= fw as usize;
+                let ok_h = fh == 0 || lay.row_bands.len() <= fh as usize;
+                if (ok_w && ok_h) || lay.scale <= 0.1 {
+                    break;
+                }
+                lay.scale = (lay.scale * 0.97).max(0.1);
+            }
+        }
+        None => paginate(&mut lay, true),
+    }
+    Some(lay)
+}
+
+/// Splits a layout's area into row and column bands that fit its pages (at most `cap` of each),
+/// honouring manual breaks (when `lay.manual_breaks`), print headings and repeated titles. The
+/// one pagination rule shared by printing, PDF export, Page Break Preview and Page Layout view.
+pub(crate) fn split_bands(sh: &Sheet, lay: &SheetLayout, cap: usize) -> (Vec<(u32, u32)>, Vec<(u32, u32)>) {
+    let k = lay.k();
+    let (aw, ah) = lay.avail();
+    let (aw, ah) = (aw / k, ah / k);
+    let st = &lay.settings;
+    let mut rb: Vec<u32> = if lay.manual_breaks { st.row_breaks.clone() } else { vec![] };
+    let mut cb: Vec<u32> = if lay.manual_breaks { st.col_breaks.clone() } else { vec![] };
+    rb.sort_unstable();
+    cb.sort_unstable();
+    let (title_rows, title_cols) = (lay.title_rows, lay.title_cols);
+    let title_h = |start: u32| -> f32 {
+        match title_rows {
+            Some((a, b)) if a < start => (a..=b.min(start - 1)).map(|r| sh.row_height(r)).sum(),
+            _ => 0.0,
+        }
+    };
+    let title_w = |start: u32| -> f32 {
+        match title_cols {
+            Some((a, b)) if a < start => (a..=b.min(start - 1)).map(|c| sh.col_width(c)).sum(),
+            _ => 0.0,
+        }
+    };
+    let area = lay.area;
+    let rows = bands(area.start.row, area.end.row, |r| sh.row_height(r), |start| (ah - lay.heading_h - title_h(start)).max(1.0), &rb, cap);
+    let cols = bands(area.start.col, area.end.col, |c| sh.col_width(c), |start| (aw - lay.heading_w - title_w(start)).max(1.0), &cb, cap);
+    (rows, cols)
+}
+
+/// Lays out every sheet a print command covers.
+pub fn layouts(wb: &Workbook, opts: &PrintOptions) -> Vec<SheetLayout> {
+    let mut out = Vec::new();
+    let mut pages = 0usize;
+    let sheets: Vec<usize> = if opts.all_sheets {
+        (0..wb.sheets.len()).filter(|i| wb.sheet(*i).is_some_and(|s| s.visibility == Visibility::Visible)).collect()
+    } else {
+        vec![wb.active_sheet()]
+    };
+    for si in sheets {
+        if pages >= MAX_PAGES {
+            break;
+        }
+        let ovr = if si == wb.active_sheet() { opts.range } else { None };
+        if opts.all_sheets && ovr.is_none() && wb.sheet(si).is_some_and(|s| print_range(s).is_none()) {
+            continue;
+        }
+        if let Some(mut l) = layout_sheet(wb, si, opts, ovr) {
+            l.pages.truncate(MAX_PAGES - pages);
+            pages += l.pages.len();
+            out.push(l);
+        }
+    }
+    if out.is_empty() && opts.all_sheets {
+        out.extend(layout_sheet(wb, wb.active_sheet(), opts, None));
+    }
+    out
+}
+
+/// Segments of a page along one axis: repeated titles (before the band) then the band.
+pub(super) fn segments(titles: Option<(u32, u32)>, band: (u32, u32)) -> Vec<(u32, u32)> {
+    let mut v = Vec::new();
+    if let Some((a, b)) = titles
+        && a < band.0
+    {
+        v.push((a, b.min(band.0 - 1)));
+    }
+    v.push(band);
+    v
+}
+
+pub(super) fn seg_size(sh: &Sheet, seg: (u32, u32), rows: bool) -> f32 {
+    if rows { (seg.0..=seg.1).map(|r| sh.row_height(r)).sum() } else { (seg.0..=seg.1).map(|c| sh.col_width(c)).sum() }
+}
diff --git a/crates/engine/src/cmd/print/objects.rs b/crates/engine/src/cmd/print/objects.rs
new file mode 100644
index 000000000..83044836e
--- /dev/null
+++ b/crates/engine/src/cmd/print/objects.rs
@@ -0,0 +1,177 @@
+use super::draw::{Block, PdfMeasure, Xf, draw_prims, rgb_of};
+use super::text::wrap_lines;
+use super::*;
+
+/// Cell pictures fit the current cell (or merged-cell) rectangle without changing aspect ratio.
+pub(super) fn draw_cell_picture(pg: &mut Page, data: &[u8], rect: (f32, f32, f32, f32), k: f32) {
+    let (x, y, w, h) = rect;
+    let pad = 2.0 * k;
+    let (w, h) = ((w - 2.0 * pad).max(0.0), (h - 2.0 * pad).max(0.0));
+    if w <= 0.0 || h <= 0.0 || data.len() > 16 * 1024 * 1024 {
+        return;
+    }
+    let Some((iw, ih)) = crate::io::image_size(data) else { return };
+    if iw == 0 || ih == 0 || iw > 8192 || ih > 8192 || u64::from(iw) * u64::from(ih) > 16_000_000 {
+        return;
+    }
+    let Ok(mut reader) = image::ImageReader::new(std::io::Cursor::new(data)).with_guessed_format() else { return };
+    let mut limits = image::Limits::default();
+    limits.max_image_width = Some(8192);
+    limits.max_image_height = Some(8192);
+    limits.max_alloc = Some(64 * 1024 * 1024);
+    reader.limits(limits);
+    let Ok(image) = reader.decode() else { return };
+    let image =
+        image.thumbnail(((w / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32, ((h / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32).to_rgba8();
+    let fit = (w / iw as f32).min(h / ih as f32);
+    let (pw, ph) = (iw as f32 * fit, ih as f32 * fit);
+    pg.image_rgba(x + pad + (w - pw) / 2.0, y + pad + (h - ph) / 2.0, pw, ph, image.as_raw(), image.width(), image.height());
+}
+
+/// Sheet pixel rectangle of an anchor.
+fn anchor_rect(sh: &Sheet, a: &Anchor) -> (f64, f64, f64, f64) {
+    (sh.col_left(a.cell.col) + a.dx as f64, sh.row_top(a.cell.row) + a.dy as f64, a.width.max(0.0) as f64, a.height.max(0.0) as f64)
+}
+
+/// Decodes an embedded picture to RGBA, downscaled to at most `max_w`×`max_h` pixels.
+fn decode_image(data: &[u8], max_w: u32, max_h: u32) -> Option<(Vec<u8>, u32, u32)> {
+    let (w, h) = crate::io::image_size(data)?;
+    if w == 0 || h == 0 || w as u64 * h as u64 > 60_000_000 {
+        return None;
+    }
+    let img = image::load_from_memory(data).ok()?;
+    let img = if img.width() > max_w.max(1) || img.height() > max_h.max(1) { img.thumbnail(max_w.max(1), max_h.max(1)) } else { img };
+    let rgba = img.to_rgba8();
+    let (pw, ph) = (rgba.width(), rgba.height());
+    Some((rgba.into_raw(), pw, ph))
+}
+
+/// Draws charts, pictures, shapes and sparklines overlapping the body block of a page.
+/// `pics` memoizes decoded pictures for the whole render (one page at a time draws each
+/// picture again, but the decode happens once).
+pub(super) fn draw_objects(
+    pg: &mut Page,
+    wb: &Workbook,
+    si: usize,
+    sh: &Sheet,
+    b: &Block,
+    pics: &mut std::collections::HashMap<(usize, usize), Option<(Vec<u8>, u32, u32)>>,
+) {
+    let block = b.range();
+    let (sx0, sy0) = (sh.col_left(block.start.col), sh.row_top(block.start.row));
+    let (sx1, sy1) = (sh.col_left(block.end.col.saturating_add(1)), sh.row_top(block.end.row.saturating_add(1)));
+    let (bx, by) = (b.xs.first().copied().unwrap_or(0.0), b.ys.first().copied().unwrap_or(0.0));
+    let (bw, bh) = (b.xs.last().copied().unwrap_or(bx) - bx, b.ys.last().copied().unwrap_or(by) - by);
+    let visible = |r: (f64, f64, f64, f64)| r.2 > 0.0 && r.3 > 0.0 && r.0 < sx1 && r.0 + r.2 > sx0 && r.1 < sy1 && r.1 + r.3 > sy0;
+    let place = |r: (f64, f64, f64, f64)| (bx + ((r.0 - sx0) as f32) * b.k, by + ((r.1 - sy0) as f32) * b.k, r.2 as f32 * b.k, r.3 as f32 * b.k);
+    pg.save();
+    pg.clip_rect(bx, by, bw, bh);
+    draw_sparklines(pg, wb, si, sh, b, block);
+    for (imi, im) in sh.images.iter().enumerate() {
+        let r = anchor_rect(sh, &im.anchor);
+        if !visible(r) {
+            continue;
+        }
+        let (x, y, w, h) = place(r);
+        // About 150 dpi is plenty for print.
+        let (mw, mh) = (((w / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32, ((h / 72.0) * 150.0).ceil().clamp(1.0, 4000.0) as u32);
+        let decoded = pics.entry((si, imi)).or_insert_with(|| decode_image(&im.data, mw, mh));
+        if let Some((px, pw, ph)) = decoded.as_ref() {
+            pg.image_rgba(x, y, w, h, px, *pw, *ph);
+        }
+    }
+    for shp in &sh.shapes {
+        let r = anchor_rect(sh, &shp.anchor);
+        if !visible(r) {
+            continue;
+        }
+        let (x, y, w, h) = place(r);
+        draw_shape(pg, wb, shp, b, (x, y, w, h));
+    }
+    for ch in &sh.charts {
+        let r = anchor_rect(sh, &ch.anchor);
+        if !visible(r) {
+            continue;
+        }
+        let (x, y, _, _) = place(r);
+        let data = gridcraft_chart::resolve(wb, si, ch);
+        let prims = gridcraft_chart::render(ch, &data, r.2 as f32, r.3 as f32, &PdfMeasure);
+        draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
+    }
+    pg.restore();
+}
+
+fn draw_sparklines(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet, b: &Block, block: RangeRef) {
+    for sp in &sh.sparklines {
+        if !block.contains(sp.cell) {
+            continue;
+        }
+        let vals: Vec<Option<f64>> = match gridcraft_calc::evaluate(wb, si, sp.cell, &sp.source) {
+            Value::Array(a) => a.iter().take(10_000).map(Value::as_f64).collect(),
+            v => vec![v.as_f64()],
+        };
+        let color = rgb_of(sp.color, wb).unwrap_or([0x15, 0x60, 0x82]);
+        let (x, y, w, h) = b.rect(RangeRef::cell(sp.cell));
+        let (wpx, hpx) = (w / b.k, h / b.k);
+        let prims = gridcraft_chart::render_sparkline(sp.kind, &vals, [color[0], color[1], color[2], 255], sp.markers, wpx, hpx);
+        draw_prims(pg, &prims, Xf { ox: x, oy: y, k: b.k });
+    }
+}
+
+fn draw_shape(pg: &mut Page, wb: &Workbook, shp: &gridcraft_model::Shape, b: &Block, (x, y, w, h): (f32, f32, f32, f32)) {
+    let fill = rgb_of(shp.fill, wb);
+    let line = rgb_of(shp.line, wb).filter(|_| !shp.format.no_line).map(|c| (c, (0.75 * b.k).max(0.25)));
+    match shp.kind {
+        ShapeKind::Ellipse => {
+            let pts: Vec<[f32; 2]> = (0..72)
+                .map(|i| {
+                    let a = i as f32 / 72.0 * std::f32::consts::TAU;
+                    [x + w / 2.0 + w / 2.0 * a.cos(), y + h / 2.0 + h / 2.0 * a.sin()]
+                })
+                .collect();
+            pg.polygon(&pts, fill, line);
+        }
+        ShapeKind::Triangle => pg.polygon(&[[x + w / 2.0, y], [x + w, y + h], [x, y + h]], fill, line),
+        ShapeKind::Line | ShapeKind::Arrow => {
+            let c = line.map(|l| l.0).or(fill).unwrap_or([0, 0, 0]);
+            pg.stroke_line(x, y, x + w, y + h, (1.0 * b.k).max(0.3), c);
+            if shp.kind == ShapeKind::Arrow {
+                let ang = h.atan2(w);
+                let al = 8.0 * b.k;
+                let p = |da: f32| [x + w - al * (ang + da).cos(), y + h - al * (ang + da).sin()];
+                pg.polygon(&[[x + w, y + h], p(0.4), p(-0.4)], Some(c), None);
+            }
+        }
+        _ => {
+            pg.polygon(&[[x, y], [x + w, y], [x + w, y + h], [x, y + h]], fill, line);
+        }
+    }
+    if shp.text.is_empty() {
+        return;
+    }
+    use gridcraft_model::{ShapeTextAlign, ShapeTextAnchor};
+    let fm = &shp.format;
+    let text_box = shp.kind == ShapeKind::TextBox;
+    let size = fm.font_size.unwrap_or(11.0).clamp(1.0, 4000.0) * b.scale;
+    let font = Font::styled(Font::family_for(fm.font.as_deref().unwrap_or("")), fm.bold, fm.italic);
+    let color = fm.text_color.and_then(|c| rgb_of(c, wb)).unwrap_or([0, 0, 0]);
+    let align = fm.align.unwrap_or(if text_box { ShapeTextAlign::Left } else { ShapeTextAlign::Center });
+    let anchor = fm.anchor.unwrap_or(if text_box { ShapeTextAnchor::Top } else { ShapeTextAnchor::Middle });
+    let lines = wrap_lines(&shp.text, font, size, (w - 4.0 * b.k).max(size));
+    let block_h = lines.len().min(500) as f32 * size * 1.2;
+    let mut yy = match anchor {
+        ShapeTextAnchor::Top => y + 2.0 * b.k,
+        ShapeTextAnchor::Middle => y + (h - block_h) / 2.0,
+        ShapeTextAnchor::Bottom => y + h - 2.0 * b.k - block_h,
+    } + size * 0.8;
+    for l in lines.iter().take(500) {
+        let lw = gridcraft_pdf::text_width(font, size, l);
+        let lx = match align {
+            ShapeTextAlign::Left => x + 2.0 * b.k,
+            ShapeTextAlign::Center => x + (w - lw) / 2.0,
+            ShapeTextAlign::Right => x + w - 2.0 * b.k - lw,
+        };
+        pg.text(lx, yy, size, font, color, l);
+        yy += size * 1.2;
+    }
+}
diff --git a/crates/engine/src/cmd/print/text.rs b/crates/engine/src/cmd/print/text.rs
new file mode 100644
index 000000000..2e1029b48
--- /dev/null
+++ b/crates/engine/src/cmd/print/text.rs
@@ -0,0 +1,263 @@
+use super::draw::{Block, Look, rgb_of};
+use super::*;
+
+const PAD_PX: f32 = 2.0;
+
+/// Word-wraps `text` to `width` points.
+pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
+    let mut out = Vec::new();
+    for para in text.split('\n') {
+        let mut line = String::new();
+        for word in para.split(' ') {
+            let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") };
+            if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width {
+                line = cand;
+            } else {
+                out.push(std::mem::take(&mut line));
+                line = word.to_string();
+            }
+            // Break a single over-long word by characters. The cut that fits is found by binary
+            // search (each try measures one candidate prefix), so an over-long word costs
+            // O(n log n) measurements instead of re-measuring the whole cut per character for
+            // every emitted line (`a` × 100k pasted text would be cubic worst case).
+            while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 {
+                let chars: Vec<char> = line.chars().collect();
+                let (mut lo, mut hi) = (1usize, chars.len());
+                while lo < hi {
+                    let mid = lo + (hi - lo).div_ceil(2);
+                    let cut: String = chars[..mid].iter().collect();
+                    if gridcraft_pdf::text_width(font, size, &cut) <= width {
+                        lo = mid;
+                    } else {
+                        hi = mid - 1;
+                    }
+                }
+                if lo == chars.len() {
+                    break;
+                }
+                out.push(chars[..lo].iter().collect());
+                line = chars[lo..].iter().collect();
+            }
+            if out.len() > 2000 {
+                return out;
+            }
+        }
+        out.push(line);
+    }
+    out
+}
+
+fn font_for(style: &Style) -> Font {
+    Font::styled(Font::family_for(&style.font.name), style.font.bold, style.font.italic)
+}
+
+/// Is a cell free for text to overflow into?
+fn empty_for_overflow(sh: &Sheet, c: CellRef, merges: &[RangeRef]) -> bool {
+    sh.value_ref(c).is_none_or(|v| v.is_empty()) && !merges.iter().any(|m| m.contains(c))
+}
+
+/// Unscaled width of the empty Center Across Selection cells right of `c`, which its text is centred over too.
+pub(super) fn center_across_width(styles: &StyleTable, sh: &Sheet, c: CellRef, merges: &[RangeRef]) -> f32 {
+    let mut ext = 0.0;
+    let mut col = c.col + 1;
+    while col < MAX_COLS && ext < 20_000.0 {
+        let nc = CellRef::new(c.row, col);
+        if !empty_for_overflow(sh, nc, merges) || styles.get(sh.style_id(nc)).align.h != HAlign::CenterAcross {
+            break;
+        }
+        ext += sh.col_width(col);
+        col += 1;
+    }
+    ext
+}
+
+pub(super) fn draw_text(
+    pg: &mut Page,
+    b: &Block,
+    c: CellRef,
+    l: &Look,
+    rect: (f32, f32, f32, f32),
+    merged: bool,
+    merges: &[RangeRef],
+    limits: (f32, f32),
+) {
+    let (x, y, w, h) = rect;
+    let sh = b.sh;
+    let wb = b.wb;
+    let v = sh.value(c);
+    if v.is_empty() || l.cf.as_ref().is_some_and(|cf| cf.hide_value) {
+        return;
+    }
+    if !sh.show_zeros && v.as_f64() == Some(0.0) {
+        return;
+    }
+    let st = &l.style;
+    let mut size = st.font.size.clamp(1.0, 409.0) * b.scale;
+    let font = font_for(st);
+    let pad = PAD_PX * b.k;
+    let indent = st.align.indent as f32 * 9.0 * b.k;
+    let avail = (w - 2.0 * pad - indent).max(0.0);
+    let code = st.num_fmt.as_str();
+    let formatted = crate::display::format(&v, code, wb);
+    let mut color = formatted.color.and_then(gridcraft_numfmt::FormatColor::rgb).or_else(|| rgb_of(st.font.color, wb)).unwrap_or([0, 0, 0]);
+    if l.cf.as_ref().and_then(|x| x.style.as_ref()).is_some_and(|s| s.font.color != Color::Auto) {
+        color = rgb_of(st.font.color, wb).unwrap_or(color);
+    }
+    let is_num = matches!(v, Value::Number(_));
+    let wrap = st.align.wrap;
+    let mut text = if sh.show_formulas {
+        crate::display::cell_text(wb, sh, c)
+    } else if code == "General"
+        && let Value::Number(n) = v
+    {
+        let digit = gridcraft_pdf::text_width(font, size, "0").max(0.1);
+        let max_chars = (avail / digit).floor().max(1.0) as usize;
+        gridcraft_numfmt::format_general_fit(n, max_chars.min(11)).unwrap_or_else(|| "#".repeat(max_chars.min(255)))
+    } else {
+        // The look's code, which a conditional format can override (#1163).
+        crate::display::value_text_as(wb, &v, code)
+    };
+    if !wrap {
+        text = text.replace(['\n', '\r'], " ");
+    }
+    if text.is_empty() {
+        return;
+    }
+    let mut tw = gridcraft_pdf::text_width(font, size, &text);
+    if st.align.shrink && !wrap && tw > avail && tw > 0.0 {
+        size = (size * avail / tw).max(1.0);
+        tw = gridcraft_pdf::text_width(font, size, &text);
+    }
+    if is_num && !wrap && tw > avail + 0.01 && !sh.show_formulas {
+        let hash = gridcraft_pdf::text_width(font, size, "#").max(0.1);
+        text = "#".repeat(((avail / hash).floor().max(1.0) as usize).min(255));
+        tw = gridcraft_pdf::text_width(font, size, &text);
+    }
+    let h_align = match st.align.h {
+        HAlign::General => {
+            if is_num {
+                HAlign::Right
+            } else if matches!(v, Value::Bool(_) | Value::Error(_)) {
+                HAlign::Center
+            } else {
+                HAlign::Left
+            }
+        }
+        HAlign::CenterAcross | HAlign::Distributed => HAlign::Center,
+        HAlign::Justify | HAlign::Fill => HAlign::Left,
+        other => other,
+    };
+    let rot = st.align.rotation;
+    let rotated = rot != 0 && rot != 255;
+    // Rotated text wraps along its own direction: upright (±90°) text to the row height.
+    let lines: Vec<String> = match (wrap, rotated) {
+        (true, false) => wrap_lines(&text, font, size, avail.max(size)),
+        (true, true) if rot.abs() == 90 => wrap_lines(&text, font, size, (h - 2.0 * pad).max(size)),
+        (true, true) => vec![text.lines().next().unwrap_or_default().to_string()],
+        (false, _) => vec![text],
+    };
+    let line_h = size * 1.2;
+    let n = lines.len().max(1) as f32;
+    let first_baseline = match st.align.v {
+        VAlign::Top => y + pad + size * 0.8,
+        VAlign::Center | VAlign::Justify | VAlign::Distributed => y + (h - n * line_h) / 2.0 + line_h * 0.5 + size * 0.33,
+        VAlign::Bottom => y + h - pad - size * 0.22 - (n - 1.0) * line_h,
+    };
+    // Overflow into empty neighbours (single-line text, not merged).
+    // Center Across Selection spans the empty Center Across cells to its right; the text stays within that run.
+    let spans = st.align.h == HAlign::CenterAcross && !wrap && !merged && rot == 0;
+    let across = if spans { center_across_width(&wb.styles, sh, c, merges) * b.k } else { 0.0 };
+    let (mut clip_l, mut clip_r) = (x, x + w + across);
+    if !wrap && !merged && !is_num && rot.abs() != 90 && across <= 0.0 && tw + 2.0 * pad + indent > w {
+        let need = tw + 2.0 * pad + indent - w;
+        let grow = |dir: i64, mut need: f32| -> f32 {
+            let mut ext = 0.0;
+            let mut col = c.col as i64 + dir;
+            while need > 0.0 && col >= 0 && col < MAX_COLS as i64 {
+                let nc = CellRef::new(c.row, col as u32);
+                if !empty_for_overflow(sh, nc, merges) {
+                    break;
+                }
+                let cw = sh.col_width(nc.col) * b.k;
+                ext += cw;
+                need -= cw;
+                col += dir;
+                if ext > 20_000.0 {
+                    break;
+                }
+            }
+            ext
+        };
+        match h_align {
+            HAlign::Right => clip_l -= grow(-1, need),
+            HAlign::Center => {
+                clip_l -= grow(-1, need / 2.0);
+                clip_r += grow(1, need / 2.0);
+            }
+            _ => clip_r += grow(1, need),
+        }
+    }
+    let clip_l = clip_l.max(limits.0);
+    let clip_r = clip_r.min(limits.1);
+    pg.save();
+    pg.clip_rect(clip_l, y, (clip_r - clip_l).max(0.0), h);
+    if rotated {
+        // Rotated text: anchored at the bottom-left (upward) or top-left (downward) of the cell.
+        // Wrapped lines stack rightward for upward text and leftward for downward text, so
+        // downward text starts its first line far enough in for the last to end at the left pad.
+        let deg = (rot as f32).clamp(-90.0, 90.0);
+        let angle = -deg.to_radians();
+        let last = lines.len().saturating_sub(1) as f32;
+        for (i, t) in lines.iter().enumerate() {
+            let i = i as f32;
+            let (ox, oy) = if deg > 0.0 {
+                (x + pad + size * 0.8 * deg.to_radians().sin() + i * line_h, y + h - pad)
+            } else {
+                (x + pad + (last - i) * line_h, y + pad + size * 0.8)
+            };
+            pg.text_rotated(ox, oy, size, font, color, t, angle);
+        }
+        pg.restore();
+        return;
+    }
+    if rot == 255 {
+        // Vertical stacked text.
+        let chars: Vec<char> = lines.concat().chars().take(500).collect();
+        let mut yy = y + pad + size * 0.8;
+        for ch in chars {
+            let s = ch.to_string();
+            let cw = gridcraft_pdf::text_width(font, size, &s);
+            pg.text(x + (w - cw) / 2.0, yy, size, font, color, &s);
+            yy += line_h;
+            if yy > y + h + line_h {
+                break;
+            }
+        }
+        pg.restore();
+        return;
+    }
+    for (i, line) in lines.iter().enumerate() {
+        let lw = gridcraft_pdf::text_width(font, size, line);
+        let lx = match h_align {
+            HAlign::Right => x + w - pad - lw - indent,
+            HAlign::Center => x + (w + across - lw) / 2.0,
+            _ => x + pad + indent,
+        };
+        let ly = first_baseline + i as f32 * line_h;
+        if ly - size > y + h || ly < y - line_h {
+            continue;
+        }
+        pg.text(lx, ly, size, font, color, line);
+        if st.font.underline != Underline::None {
+            let uw = (size * 0.06).max(0.2);
+            pg.stroke_line(lx, ly + size * 0.12, lx + lw, ly + size * 0.12, uw, color);
+            if matches!(st.font.underline, Underline::Double | Underline::DoubleAccounting) {
+                pg.stroke_line(lx, ly + size * 0.24, lx + lw, ly + size * 0.24, uw, color);
+            }
+        }
+        if st.font.strike {
+            pg.stroke_line(lx, ly - size * 0.3, lx + lw, ly - size * 0.3, (size * 0.06).max(0.2), color);
+        }
+    }
+    pg.restore();
+}

From 99f0be5f2972d12da21dbd4047f4b9171c5e585a Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:29:52 +0000
Subject: [PATCH 51/76] refactor(engine): move cmd/pivot.rs items to cmd/pivot/

---
 crates/engine/src/cmd/pivot.rs        | 1453 +------------------------
 crates/engine/src/cmd/pivot/charts.rs |  174 +++
 crates/engine/src/cmd/pivot/create.rs |  340 ++++++
 crates/engine/src/cmd/pivot/fields.rs |  541 +++++++++
 crates/engine/src/cmd/pivot/layout.rs |  289 +++++
 crates/engine/src/cmd/pivot/params.rs |  111 ++
 6 files changed, 1466 insertions(+), 1442 deletions(-)
 create mode 100644 crates/engine/src/cmd/pivot/charts.rs
 create mode 100644 crates/engine/src/cmd/pivot/create.rs
 create mode 100644 crates/engine/src/cmd/pivot/fields.rs
 create mode 100644 crates/engine/src/cmd/pivot/layout.rs
 create mode 100644 crates/engine/src/cmd/pivot/params.rs

diff --git a/crates/engine/src/cmd/pivot.rs b/crates/engine/src/cmd/pivot.rs
index feb548702..bbc66fa0c 100644
--- a/crates/engine/src/cmd/pivot.rs
+++ b/crates/engine/src/cmd/pivot.rs
@@ -14,6 +14,17 @@ use super::*;
 use crate::pivot as pv;
 use crate::selection::current_region;
 
+mod charts;
+mod create;
+mod fields;
+mod layout;
+mod params;
+
+use charts::{insert_pivot_chart, recommended};
+use create::{insert_pivot, options, show_details, summarize_table};
+use fields::{add_field, calculated_field, fields, list, move_field, remove_field, value_settings};
+use layout::{change_source, collapse, delete, filter, grand_totals, group, layout, refresh, refresh_all, sort};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -252,1447 +263,5 @@ fn find_pivot(s: &Session, p: &Json) -> Result<(usize, usize)> {
     Err(EngineError::Disabled("pivot".into(), "select a cell in a PivotTable (or pass `pivot`)".into()))
 }
 
-fn area_param(cmd: &str, v: Option<&str>) -> Result<&'static str> {
-    match v.map(str::to_ascii_lowercase) {
-        Some(a) if a == "rows" || a == "row" => Ok("rows"),
-        Some(a) if a == "columns" || a == "column" || a == "cols" => Ok("columns"),
-        Some(a) if a == "values" || a == "value" || a == "data" => Ok("values"),
-        Some(a) if a == "filters" || a == "filter" => Ok("filters"),
-        Some(a) => Err(bad(cmd, format!("unknown area `{a}` (rows|columns|values|filters)"))),
-        None => Err(bad(cmd, "missing `area` (rows|columns|values|filters)")),
-    }
-}
-
-fn func_param(v: Option<&str>) -> Option<PivotFunc> {
-    Some(match v?.to_ascii_lowercase().as_str() {
-        "sum" => PivotFunc::Sum,
-        "count" | "counta" => PivotFunc::Count,
-        "average" | "avg" | "mean" => PivotFunc::Average,
-        "max" => PivotFunc::Max,
-        "min" => PivotFunc::Min,
-        "product" => PivotFunc::Product,
-        "countnumbers" | "countnums" | "count numbers" => PivotFunc::CountNumbers,
-        "stddev" => PivotFunc::StdDev,
-        "stddevp" => PivotFunc::StdDevP,
-        "var" => PivotFunc::Var,
-        "varp" => PivotFunc::VarP,
-        _ => return None,
-    })
-}
-
-fn func_name(f: PivotFunc) -> &'static str {
-    match f {
-        PivotFunc::Sum => "sum",
-        PivotFunc::Count => "count",
-        PivotFunc::Average => "average",
-        PivotFunc::Max => "max",
-        PivotFunc::Min => "min",
-        PivotFunc::Product => "product",
-        PivotFunc::CountNumbers => "countNumbers",
-        PivotFunc::StdDev => "stdDev",
-        PivotFunc::StdDevP => "stdDevP",
-        PivotFunc::Var => "var",
-        PivotFunc::VarP => "varP",
-    }
-}
-
-fn show_as_param(v: &str) -> Option<PivotShowAs> {
-    Some(match v.to_ascii_lowercase().as_str() {
-        "normal" | "none" => PivotShowAs::Normal,
-        "percentofgrandtotal" => PivotShowAs::PercentOfGrandTotal,
-        "percentofcolumntotal" => PivotShowAs::PercentOfColumnTotal,
-        "percentofrowtotal" => PivotShowAs::PercentOfRowTotal,
-        "runningtotal" => PivotShowAs::RunningTotal,
-        "rank" => PivotShowAs::Rank,
-        _ => return None,
-    })
-}
-
-fn show_as_name(v: PivotShowAs) -> &'static str {
-    match v {
-        PivotShowAs::Normal => "normal",
-        PivotShowAs::PercentOfGrandTotal => "percentOfGrandTotal",
-        PivotShowAs::PercentOfColumnTotal => "percentOfColumnTotal",
-        PivotShowAs::PercentOfRowTotal => "percentOfRowTotal",
-        PivotShowAs::RunningTotal => "runningTotal",
-        PivotShowAs::Rank => "rank",
-    }
-}
-
-fn layout_name(l: PivotLayout) -> &'static str {
-    match l {
-        PivotLayout::Compact => "compact",
-        PivotLayout::Outline => "outline",
-        PivotLayout::Tabular => "tabular",
-    }
-}
-
-fn group_name(g: PivotDateGroup) -> &'static str {
-    match g {
-        PivotDateGroup::None => "none",
-        PivotDateGroup::Years => "years",
-        PivotDateGroup::Quarters => "quarters",
-        PivotDateGroup::Months => "months",
-        PivotDateGroup::Days => "days",
-    }
-}
-
-fn sort_name(o: PivotSort) -> &'static str {
-    match o {
-        PivotSort::Asc => "asc",
-        PivotSort::Desc => "desc",
-        PivotSort::None => "none",
-    }
-}
-
-// ---------------------------------------------------------------- layout editing (pure)
-
-fn in_axes(pt: &PivotTable, field: &str) -> bool {
-    pt.rows.iter().chain(pt.columns.iter()).any(|f| f.source_col.eq_ignore_ascii_case(field))
-}
-
-/// Name of the Σ Values pseudo-field (where the value fields sit when there are two or more).
-const VALUES_FIELD: &str = "Σ Values";
-
-/// Whether `field` names Σ Values: `Σ Values`, or `Values` unless a source field has that name.
-fn is_values_field(src: &pv::Source, field: &str) -> bool {
-    let f = field.trim();
-    f == VALUES_FIELD || (f.eq_ignore_ascii_case("values") && src.col(f).is_none())
-}
-
-/// Keeps Σ Values in place after a field left (`inserted` false) or arrived at index `i` of
-/// Rows (`rows`) or Columns.
-fn shift_values(pt: &mut PivotTable, rows: bool, i: usize, inserted: bool) {
-    if pt.values_on_rows != rows {
-        return;
-    }
-    let Some(p) = pt.values_position else { return };
-    // Σ Values stays just ahead of the field it preceded.
-    let p = match inserted {
-        true if i <= p => p + 1,
-        false if i < p => p - 1,
-        _ => p,
-    };
-    let n = if rows { pt.rows.len() } else { pt.columns.len() };
-    pt.values_position = (p < n).then_some(p);
-}
-
-/// Takes `field` out of Rows and Columns (Σ Values keeps its place); returns its first entry.
-fn take_from_axes(pt: &mut PivotTable, field: &str) -> Option<PivotField> {
-    let mut first = None;
-    for rows in [true, false] {
-        loop {
-            let list = if rows { &mut pt.rows } else { &mut pt.columns };
-            let Some(i) = list.iter().position(|f| f.source_col.eq_ignore_ascii_case(field)) else { break };
-            let f = list.remove(i);
-            shift_values(pt, rows, i, false);
-            first.get_or_insert(f);
-        }
-    }
-    first
-}
-
-/// Inserts `f` into Rows (`rows`) or Columns at `position` (default: the end).
-fn insert_axis_field(pt: &mut PivotTable, rows: bool, f: PivotField, position: Option<usize>) {
-    let list = if rows { &mut pt.rows } else { &mut pt.columns };
-    let at = position.unwrap_or(list.len()).min(list.len());
-    list.insert(at, f);
-    shift_values(pt, rows, at, true);
-}
-
-/// Moves Σ Values between Rows and Columns, or within Rows, to `position` (default: the end).
-/// In Columns it always comes after the last column field: the column layout doesn't place it
-/// anywhere else yet.
-fn move_values_field(cmd: &str, pt: &mut PivotTable, from: &str, to: &str, position: Option<usize>) -> Result<Json> {
-    let current = if pt.values_on_rows { "rows" } else { "columns" };
-    if from != current {
-        return Err(bad(cmd, format!("`{VALUES_FIELD}` isn't in the {from} area")));
-    }
-    if !matches!(to, "rows" | "columns") {
-        return Err(other("The field you are moving cannot be placed in that PivotTable area."));
-    }
-    pt.values_on_rows = to == "rows";
-    pt.values_position = position.filter(|p| pt.values_on_rows && *p < pt.rows.len());
-    Ok(json!({"field": VALUES_FIELD, "to": to}))
-}
-
-/// The canonical source field name for `field`.
-fn canonical(cmd: &str, src: &pv::Source, field: &str) -> Result<String> {
-    src.col(field).and_then(|c| src.headers.get(c).cloned()).ok_or_else(|| bad(cmd, format!("no field `{field}` in the source data")))
-}
-
-/// The calculated field named `field`, if any.
-fn calc_field<'a>(pt: &'a PivotTable, field: &str) -> Option<&'a PivotCalcField> {
-    pt.calculated_fields.iter().find(|c| c.name.eq_ignore_ascii_case(field.trim()))
-}
-
-/// The canonical name of a source or calculated field.
-fn canonical_any(cmd: &str, pt: &PivotTable, src: &pv::Source, field: &str) -> Result<String> {
-    match calc_field(pt, field) {
-        Some(c) if src.col(field).is_none() => Ok(c.name.clone()),
-        _ => canonical(cmd, src, field),
-    }
-}
-
-fn unique_value_name(pt: &PivotTable, base: &str, except: Option<usize>) -> String {
-    let taken = |n: &str| pt.values.iter().enumerate().any(|(i, v)| Some(i) != except && v.name.eq_ignore_ascii_case(n));
-    if !taken(base) {
-        return base.to_string();
-    }
-    (2..10_000).map(|k| format!("{base}{k}")).find(|n| !taken(n)).unwrap_or_else(|| base.to_string())
-}
-
-fn auto_name(f: PivotFunc, field: &str) -> String {
-    format!("{} of {field}", pv::func_caption(f))
-}
-
-/// Adds `field` to an area (moving it out of the other axis areas).
-fn add_to_area(
-    cmd: &str,
-    pt: &mut PivotTable,
-    src: &pv::Source,
-    field: &str,
-    area: &str,
-    func: Option<PivotFunc>,
-    name: Option<&str>,
-    position: Option<usize>,
-) -> Result<()> {
-    let is_calc = src.col(field).is_none() && calc_field(pt, field).is_some();
-    if is_calc && area != "values" {
-        return Err(other("A calculated field can only be placed in the Values area."));
-    }
-    let field = canonical_any(cmd, pt, src, field)?;
-    match area {
-        "rows" | "columns" => {
-            if pt.rows.len() + pt.columns.len() >= pv::MAX_AXIS_FIELDS && !in_axes(pt, &field) {
-                return Err(other(format!("A PivotTable can have at most {} row and column fields.", pv::MAX_AXIS_FIELDS)));
-            }
-            let existing = take_from_axes(pt, &field).unwrap_or_else(|| PivotField { source_col: field.clone(), ..Default::default() });
-            // A report filter that selects nothing in particular goes away; a selection stays
-            // as the field's hidden items.
-            pt.filters.retain(|f| !(f.source_col.eq_ignore_ascii_case(&field) && f.selected.is_none()));
-            insert_axis_field(pt, area == "rows", existing, position);
-        }
-        "values" => {
-            if pt.values.len() >= pv::MAX_VALUE_FIELDS {
-                return Err(other(format!("A PivotTable can have at most {} value fields.", pv::MAX_VALUE_FIELDS)));
-            }
-            let numeric = is_calc || src.col(&field).and_then(|c| src.numeric.get(c).copied()).unwrap_or(false);
-            let f = func.unwrap_or(if numeric { PivotFunc::Sum } else { PivotFunc::Count });
-            let base = match name {
-                Some(n) if !n.trim().is_empty() => {
-                    if src.col(n).is_some() {
-                        return Err(other("PivotTable field name already exists."));
-                    }
-                    n.to_string()
-                }
-                _ => auto_name(f, &field),
-            };
-            let nm = unique_value_name(pt, &base, None);
-            let v = PivotValue { source_col: field, func: f, name: nm, show_as: PivotShowAs::Normal, number_format: None };
-            let at = position.unwrap_or(pt.values.len()).min(pt.values.len());
-            pt.values.insert(at, v);
-        }
-        _ => {
-            take_from_axes(pt, &field);
-            let existing = pt.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(&field));
-            let entry = match existing {
-                Some(i) => pt.filters.remove(i),
-                None => PivotFilter { source_col: field, selected: None },
-            };
-            let at = position.unwrap_or(pt.filters.len()).min(pt.filters.len());
-            pt.filters.insert(at, entry);
-        }
-    }
-    Ok(())
-}
-
-/// Removes `field` from an area; returns the source field it referred to.
-fn remove_from_area(cmd: &str, pt: &mut PivotTable, field: &str, area: &str) -> Result<String> {
-    match area {
-        "rows" | "columns" => {
-            let rows = area == "rows";
-            let list = if rows { &mut pt.rows } else { &mut pt.columns };
-            let i = list
-                .iter()
-                .position(|f| f.source_col.eq_ignore_ascii_case(field))
-                .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the {area} area")))?;
-            let f = list.remove(i);
-            shift_values(pt, rows, i, false);
-            pt.filters.retain(|x| !x.source_col.eq_ignore_ascii_case(&f.source_col));
-            Ok(f.source_col)
-        }
-        "values" => {
-            let i = pt
-                .values
-                .iter()
-                .position(|v| v.name.eq_ignore_ascii_case(field))
-                .or_else(|| pt.values.iter().position(|v| v.source_col.eq_ignore_ascii_case(field)))
-                .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the values area")))?;
-            Ok(pt.values.remove(i).source_col)
-        }
-        _ => {
-            let i = pt
-                .filters
-                .iter()
-                .position(|f| f.source_col.eq_ignore_ascii_case(field) && !in_axes(pt, &f.source_col))
-                .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the filters area")))?;
-            Ok(pt.filters.remove(i).source_col)
-        }
-    }
-}
-
-// ---------------------------------------------------------------- shared update
-
-/// Applies `f` to the targeted pivot and re-renders it, as one undo step.
-fn update(s: &mut Session, p: &Json, f: impl FnOnce(&mut PivotTable, &pv::Source, &Workbook) -> Result<Json>) -> Result<Json> {
-    let (si, pi) = find_pivot(s, p)?;
-    let replace = bool_param(p, "replace").unwrap_or(false);
-    edit(s, |cx| {
-        let pt = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).cloned().ok_or_else(|| other("There's no such PivotTable."))?;
-        let src = pv::read_source(&cx.wb, &pt.source, si).map_err(other)?;
-        let mut new = pt.clone();
-        let mut out = f(&mut new, &src, &cx.wb)?;
-        if let Some(slot) = cx.sheet_mut(si)?.pivots.get_mut(pi) {
-            *slot = new;
-        }
-        let area = pv::refresh(&mut cx.wb, si, pi, replace).map_err(other)?;
-        cx.structural = true;
-        if out.is_null() {
-            out = json!({});
-        }
-        if let Some(m) = out.as_object_mut() {
-            m.insert("range".into(), json!(area.a1()));
-        }
-        Ok(out)
-    })
-}
-
-// ---------------------------------------------------------------- insert
-
-/// The default source: the table at the selection, else the selected block / current region.
-fn default_source(s: &Session) -> Result<String> {
-    let d = s.doc()?;
-    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-    if let Some(t) = sh.table_at(d.selection.active) {
-        return Ok(t.name.clone());
-    }
-    let sel = d.selection.current();
-    let r = if sel.is_single() {
-        current_region(sh, d.selection.active)
-    } else {
-        let used = sh.used_range().unwrap_or(sel);
-        sel.intersection(&used).unwrap_or(sel)
-    };
-    if r.is_single() && sh.value(r.start).is_empty() {
-        return Err(other("The reference isn't valid. Select a cell in a range with labeled columns, or pass `source`."));
-    }
-    Ok(pv::range_text(&sh.name, r))
-}
-
-fn source_param(s: &Session, p: &Json) -> Result<String> {
-    match str_param(p, "source").or_else(|| str_param(p, "range")) {
-        Some(t) if !t.trim().is_empty() => {
-            // Bare ranges are on the active sheet; store them with the sheet name.
-            let d = s.doc()?;
-            let t = t.trim().trim_start_matches('=');
-            if !t.contains('!')
-                && RangeRef::parse(t).is_some()
-                && let Some(sh) = d.wb.active()
-                && let Some(r) = RangeRef::parse(t)
-            {
-                return Ok(pv::range_text(&sh.name, r));
-            }
-            Ok(t.to_string())
-        }
-        _ => default_source(s),
-    }
-}
-
-fn next_pivot_name(wb: &Workbook) -> String {
-    (1..)
-        .map(|n| format!("PivotTable{n}"))
-        .find(|n| !wb.sheets.iter().any(|s| s.pivots.iter().any(|p| p.name.eq_ignore_ascii_case(n))))
-        .unwrap_or_default()
-}
-
-fn next_pivot_id(wb: &Workbook) -> u32 {
-    let m = wb.sheets.iter().flat_map(|s| s.pivots.iter().map(|p| p.id)).max().unwrap_or(0);
-    wb.next_object_id().max(m.saturating_add(1))
-}
-
-fn field_list(v: Option<&Json>) -> Vec<Json> {
-    match v {
-        Some(Json::Array(a)) => a.iter().take(512).cloned().collect(),
-        Some(Json::String(s)) => vec![Json::String(s.clone())],
-        _ => vec![],
-    }
-}
-
-fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
-    if s.doc()?.wb.protected_structure && matches!(str_param(p, "destination"), None | Some("new")) {
-        return Err(other("The workbook is protected and cannot be changed."));
-    }
-    let source = source_param(s, p)?;
-    let active = s.doc()?.wb.active_sheet();
-    // Validate the source now (header names, size).
-    let src = pv::read_source(&s.doc()?.wb, &source, active).map_err(other)?;
-    let name = match str_param(p, "name") {
-        Some(n) if !n.trim().is_empty() => {
-            let n = n.trim().to_string();
-            if s.doc()?.wb.sheets.iter().any(|sh| sh.pivots.iter().any(|x| x.name.eq_ignore_ascii_case(&n))) {
-                return Err(other("A PivotTable with that name already exists."));
-            }
-            n
-        }
-        _ => next_pivot_name(&s.doc()?.wb),
-    };
-    let dest = str_param(p, "destination").or_else(|| str_param(p, "location")).unwrap_or("new").trim().to_string();
-    // Existing sheet destination: (sheet index, anchor).
-    let target: Option<(usize, CellRef)> = if dest.eq_ignore_ascii_case("new") || dest.is_empty() {
-        None
-    } else {
-        let d = s.doc()?;
-        let (sh, body) = super::split_sheet(&dest);
-        let si = match sh {
-            Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("insert.pivotTable", format!("no sheet named `{n}`")))?,
-            None => active,
-        };
-        let at = RangeRef::parse(body).map(|r| r.start).ok_or_else(|| bad("insert.pivotTable", format!("not a cell: `{dest}`")))?;
-        Some((si, at))
-    };
-    let replace = bool_param(p, "replace").unwrap_or(false);
-    let rows = field_list(p.get("rows"));
-    let columns = field_list(p.get("columns"));
-    let values = field_list(p.get("values"));
-    let filters = field_list(p.get("filters"));
-    let mut new_sheet_at: Option<usize> = None;
-    let res = edit(s, |cx| {
-        let id = next_pivot_id(&cx.wb);
-        let (si, anchor) = match target {
-            Some(t) => t,
-            None => {
-                let at = insert_sheet_before_active(cx);
-                new_sheet_at = Some(at);
-                (at, CellRef::new(2, 0))
-            }
-        };
-        let mut pt = PivotTable { id, name: name.clone(), source: source.clone(), anchor, ..Default::default() };
-        let add = |pt: &mut PivotTable, list: &[Json], area: &str| -> Result<()> {
-            for f in list {
-                match f {
-                    Json::String(n) => add_to_area("insert.pivotTable", pt, &src, n, area, None, None, None)?,
-                    Json::Object(_) => {
-                        let n = str_param(f, "field").ok_or_else(|| bad("insert.pivotTable", "a field object needs `field`"))?;
-                        let func = match str_param(f, "func") {
-                            Some(fname) => {
-                                Some(func_param(Some(fname)).ok_or_else(|| bad("insert.pivotTable", format!("unknown function `{fname}`")))?)
-                            }
-                            None => None,
-                        };
-                        add_to_area("insert.pivotTable", pt, &src, n, area, func, str_param(f, "name"), None)?;
-                        let by = group_param(str_param(f, "group"));
-                        if let Some(by) = by.filter(|b| *b != PivotDateGroup::None)
-                            && matches!(area, "rows" | "columns")
-                            && src.col(n).and_then(|c| src.numeric.get(c).copied()).unwrap_or(false)
-                            && let Some(af) = pt.rows.iter_mut().chain(pt.columns.iter_mut()).find(|x| x.source_col.eq_ignore_ascii_case(n))
-                        {
-                            af.date_group = by;
-                        }
-                    }
-                    _ => return Err(bad("insert.pivotTable", "fields are names or {field, func?, name?}")),
-                }
-            }
-            Ok(())
-        };
-        add(&mut pt, &rows, "rows")?;
-        add(&mut pt, &columns, "columns")?;
-        add(&mut pt, &values, "values")?;
-        add(&mut pt, &filters, "filters")?;
-        let sh = cx.sheet_mut(si)?;
-        sh.pivots.push(pt);
-        let pi = sh.pivots.len() - 1;
-        let area = pv::refresh(&mut cx.wb, si, pi, replace).map_err(other)?;
-        cx.wb.set_active_sheet(si);
-        *cx.sel = crate::Selection::at(anchor);
-        cx.structural = true;
-        let sheet_name = cx.wb.sheet(si).map(|s| s.name.clone()).unwrap_or_default();
-        Ok(json!({
-            "id": id,
-            "name": name,
-            "sheet": sheet_name,
-            "anchor": anchor.a1(),
-            "range": area.a1(),
-            "source": source,
-            "fields": src.headers,
-        }))
-    })?;
-    if let Some(at) = new_sheet_at
-        && let Ok(d) = s.doc_mut()
-    {
-        d.sheet_selections.insert(at.min(d.sheet_selections.len()), crate::Selection::default());
-    }
-    Ok(res)
-}
-
-/// Inserts a new, empty sheet before the active one (Excel's place for a new PivotTable or a
-/// Show Details sheet); returns its index.
-fn insert_sheet_before_active(cx: &mut Ctx) -> usize {
-    let at = cx.wb.active_sheet().min(cx.wb.sheets.len());
-    let nm = cx.wb.next_sheet_name();
-    cx.wb.sheets.insert(at, Arc::new(Sheet::new(nm)));
-    for n in cx.wb.names.iter_mut() {
-        if let Some(sc) = n.scope.as_mut()
-            && *sc >= at
-        {
-            *sc += 1;
-        }
-    }
-    at
-}
-
-/// Show Details (double-click a value cell): the source records behind it, as values with their
-/// column's number format, under the source headers on a new sheet.
-fn show_details(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
-    let active = d.wb.active_sheet();
-    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-    let pt = sh
-        .pivots
-        .iter()
-        .find(|pt| pt.last_range.is_some_and(|r| r.contains(at)))
-        .ok_or_else(|| EngineError::Disabled("pivot.showDetails".into(), pv::NOT_A_VALUE_CELL.into()))?;
-    let origin = pt.last_range.map(|r| r.start).unwrap_or_default();
-    let found = pv::detail_records(&d.wb, pt, active, at.row.saturating_sub(origin.row), at.col.saturating_sub(origin.col));
-    // With the option off, a report that is out of date or a source that cannot be read is
-    // reported as the option; only a cell that is not a value cell keeps its own message.
-    if !pt.enable_show_details && !matches!(found, Ok(None)) {
-        return Err(other(SHOW_DETAILS_OFF));
-    }
-    let (src, records) = found.map_err(other)?.ok_or_else(|| EngineError::Disabled("pivot.showDetails".into(), pv::NOT_A_VALUE_CELL.into()))?;
-    if d.wb.protected_structure {
-        return Err(other("The workbook is protected and cannot be changed."));
-    }
-    let count = records.len();
-    let mut new_sheet_at: Option<usize> = None;
-    let res = edit(s, |cx| {
-        let si = insert_sheet_before_active(cx);
-        new_sheet_at = Some(si);
-        let base = cx.wb.styles.get(StyleId::default()).clone();
-        let fmts: Vec<StyleId> = src
-            .formats
-            .iter()
-            .map(|f| {
-                let mut st = base.clone();
-                st.num_fmt = NumFmt::new(f);
-                cx.wb.styles.intern(st)
-            })
-            .collect();
-        // Columns wide enough for their text, as the PivotTable report's are (dates would show
-        // as ####); the first rows are enough to judge a column.
-        let font = base.font.clone();
-        let widths: Vec<f32> = src
-            .headers
-            .iter()
-            .enumerate()
-            .map(|(c, h)| {
-                let fmt = src.formats.get(c).map(String::as_str).unwrap_or("General");
-                let texts = records.iter().take(1_000).filter_map(|i| src.rows.get(*i).and_then(|r| r.get(c)));
-                let widest = texts
-                    .map(|v| crate::cmd::format::approx_text_width(&crate::display::format(v, fmt, &cx.wb).text, font.size, false))
-                    .fold(crate::cmd::format::approx_text_width(h, font.size, false), f32::max);
-                (widest + 14.0).min(320.0)
-            })
-            .collect();
-        let sh = cx.sheet_mut(si)?;
-        for (c, w) in widths.into_iter().enumerate() {
-            if w > sh.col_width(c as u32) {
-                sh.cols.entry(c as u32).or_default().size = Some(w);
-            }
-        }
-        for (c, h) in src.headers.iter().enumerate() {
-            sh.set_cell(CellRef::new(0, c as u32), Cell { value: gridcraft_core::Value::text(h.as_str()), formula: None, style: StyleId::default() });
-        }
-        for (r, i) in records.iter().enumerate() {
-            let Some(rec) = src.rows.get(*i) else { continue };
-            for (c, v) in rec.iter().enumerate() {
-                let style = fmts.get(c).copied().unwrap_or_default();
-                if v.is_empty() && style == StyleId::default() {
-                    continue;
-                }
-                sh.set_cell(CellRef::new(r as u32 + 1, c as u32), Cell { value: v.clone(), formula: None, style });
-            }
-        }
-        let name = sh.name.clone();
-        cx.wb.set_active_sheet(si);
-        *cx.sel = crate::Selection::at(CellRef::new(0, 0));
-        cx.structural = true;
-        Ok(json!({"sheet": name, "records": count}))
-    })?;
-    if let Some(at) = new_sheet_at
-        && let Ok(d) = s.doc_mut()
-    {
-        d.sheet_selections.insert(at.min(d.sheet_selections.len()), crate::Selection::default());
-    }
-    Ok(res)
-}
-
-/// The message Show Details gives while Enable show details is off.
-const SHOW_DETAILS_OFF: &str = "Show Details is turned off for this PivotTable.";
-
-/// PivotTable Options: Enable show details (Data). Changes only the option; the report is not
-/// refreshed. Without params it returns the current setting.
-fn options(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, pi) = find_pivot(s, p)?;
-    let enable = bool_param(p, "enableShowDetails");
-    if p.get("enableShowDetails").is_some_and(|v| !v.is_null()) && enable.is_none() {
-        return Err(bad("pivot.options", "`enableShowDetails` must be true or false"));
-    }
-    let current = |s: &Session| -> Result<Json> {
-        let pt = s.doc()?.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).ok_or_else(|| other("There's no such PivotTable."))?;
-        Ok(json!({"enableShowDetails": pt.enable_show_details}))
-    };
-    let Some(on) = enable else { return current(s) };
-    if current(s)?["enableShowDetails"] == json!(on) {
-        return current(s);
-    }
-    edit(s, |cx| {
-        let pt = cx.sheet_mut(si)?.pivots.get_mut(pi).ok_or_else(|| other("There's no such PivotTable."))?;
-        pt.enable_show_details = on;
-        Ok(json!({"enableShowDetails": on}))
-    })
-}
-
-fn summarize_table(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let name = match str_param(p, "table") {
-        Some(n) => d.wb.table(n).and_then(|(si, ti)| d.wb.sheet(si).and_then(|sh| sh.tables.get(ti))).map(|t| t.name.clone()),
-        None => d.wb.active().and_then(|sh| sh.table_at(d.selection.active)).map(|t| t.name.clone()),
-    }
-    .ok_or_else(|| EngineError::Disabled("table.summarizePivot".into(), "select a cell in a table".into()))?;
-    let mut q = with(p, "source", json!(name));
-    if let Some(m) = q.as_object_mut() {
-        m.remove("table");
-    }
-    insert_pivot(s, &q)
-}
-
-// ---------------------------------------------------------------- queries
-
-fn pivot_json(wb: &Workbook, si: usize, pt: &PivotTable) -> Json {
-    json!({
-        "id": pt.id,
-        "name": pt.name,
-        "sheet": wb.sheet(si).map(|s| s.name.clone()).unwrap_or_default(),
-        "anchor": pt.anchor.a1(),
-        "range": pt.last_range.map(|r| r.a1()),
-        "source": pt.source,
-        "rows": pt.rows.iter().map(|f| json!({"field": f.source_col, "sort": sort_name(f.sort), "group": group_name(f.date_group), "collapsed": f.collapsed_items})).collect::<Vec<_>>(),
-        "columns": pt.columns.iter().map(|f| json!({"field": f.source_col, "sort": sort_name(f.sort), "group": group_name(f.date_group), "collapsed": f.collapsed_items})).collect::<Vec<_>>(),
-        "values": pt.values.iter().map(|v| json!({"field": v.source_col, "func": func_name(v.func), "name": v.name, "showAs": show_as_name(v.show_as), "numberFormat": v.number_format})).collect::<Vec<_>>(),
-        "filters": pt.filters.iter().map(|f| json!({"field": f.source_col, "selected": f.selected, "report": !in_axes(pt, &f.source_col)})).collect::<Vec<_>>(),
-        "layout": layout_name(pt.layout),
-        "grandTotalsRows": pt.grand_totals_rows,
-        "grandTotalsCols": pt.grand_totals_cols,
-        "subtotals": if !pt.subtotals { "none" } else if pt.subtotals_top { "top" } else { "bottom" },
-        "style": pt.style,
-        "showHeaders": pt.show_headers,
-        "calculatedFields": pt.calculated_fields.iter().map(|c| json!({"name": c.name, "formula": c.formula})).collect::<Vec<_>>(),
-        "valuesOnRows": pt.values_on_rows,
-        "valuesPosition": pt.values_position,
-        "enableShowDetails": pt.enable_show_details,
-    })
-}
-
-fn fields(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, pi) = find_pivot(s, p)?;
-    let d = s.doc()?;
-    let pt = d.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).ok_or_else(|| other("There's no such PivotTable."))?;
-    let mut out = pivot_json(&d.wb, si, pt);
-    let src = pv::read_source(&d.wb, &pt.source, si);
-    let list: Vec<Json> = match &src {
-        Ok(src) => src
-            .headers
-            .iter()
-            .enumerate()
-            .map(|(c, h)| {
-                let mut areas = vec![];
-                if pt.rows.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
-                    areas.push("rows");
-                }
-                if pt.columns.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
-                    areas.push("columns");
-                }
-                if pt.values.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
-                    areas.push("values");
-                }
-                if pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) && !in_axes(pt, h) {
-                    areas.push("filters");
-                }
-                json!({
-                    "name": h,
-                    "numeric": src.numeric.get(c).copied().unwrap_or(false),
-                    "date": src.dates.get(c).copied().unwrap_or(false),
-                    "samples": pv::distinct_labels(&d.wb, src, c, PivotDateGroup::None, 5),
-                    "areas": areas,
-                })
-            })
-            .collect(),
-        Err(_) => vec![],
-    };
-    let mut list = list;
-    for c in &pt.calculated_fields {
-        let areas: Vec<&str> = if pt.values.iter().any(|v| v.source_col.eq_ignore_ascii_case(&c.name)) { vec!["values"] } else { vec![] };
-        list.push(json!({"name": c.name, "numeric": true, "date": false, "samples": [], "areas": areas, "calculated": true, "formula": c.formula}));
-    }
-    if let Some(m) = out.as_object_mut() {
-        m.insert("fields".into(), Json::Array(list));
-        if let Ok(src) = &src {
-            m.insert("records".into(), json!(src.rows.len()));
-        }
-        if let Err(e) = src {
-            m.insert("error".into(), json!(e));
-        }
-    }
-    Ok(out)
-}
-
-fn list(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let mut v = vec![];
-    for (si, sh) in d.wb.sheets.iter().enumerate() {
-        for pt in &sh.pivots {
-            v.push(pivot_json(&d.wb, si, pt));
-        }
-    }
-    Ok(Json::Array(v))
-}
-
-// ---------------------------------------------------------------- field commands
-
-fn position_param(p: &Json) -> Option<usize> {
-    u32_param(p, "position").map(|v| v as usize)
-}
-
-fn add_field(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.addField";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let area = area_param(C, str_param(p, "area"))?;
-    let func = match str_param(p, "func") {
-        Some(f) => Some(func_param(Some(f)).ok_or_else(|| bad(C, format!("unknown function `{f}`")))?),
-        None => None,
-    };
-    let name = str_param(p, "name").map(str::to_string);
-    let pos = position_param(p);
-    update(s, p, |pt, src, _| {
-        add_to_area(C, pt, src, &field, area, func, name.as_deref(), pos)?;
-        Ok(json!({"field": canonical_any(C, pt, src, &field)?, "area": area}))
-    })
-}
-
-fn calculated_field(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.calculatedField";
-    let Some(name) = str_param(p, "name").map(|n| n.trim().to_string()) else {
-        // Menu-style call: the Insert Calculated Field dialog.
-        let (si, pi) = find_pivot(s, p)?;
-        let d = s.doc()?;
-        let pt = d.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).ok_or_else(|| other("There's no such PivotTable."))?;
-        let n = (1..).map(|k| format!("Field{k}")).find(|n| calc_field(pt, n).is_none()).unwrap_or_else(|| "Field1".into());
-        let pivot = pt.name.clone();
-        s.ui_requests.push(crate::UiRequest::Dialog("pivotCalculatedField".into(), json!({"pivot": pivot, "name": n, "formula": "= 0"})));
-        return ok();
-    };
-    if name.is_empty() || name.chars().count() > 255 {
-        return Err(bad(C, "`name` must be 1 to 255 characters"));
-    }
-    let delete = bool_param(p, "delete").unwrap_or(false);
-    let formula = str_param(p, "formula").map(|f| {
-        let f = f.trim();
-        if f.starts_with('=') { f.to_string() } else { format!("={f}") }
-    });
-    let to_values = bool_param(p, "values").unwrap_or(true);
-    if !delete && formula.is_none() {
-        return Err(bad(C, "missing `formula`"));
-    }
-    update(s, p, |pt, src, _| {
-        let existing = pt.calculated_fields.iter().position(|c| c.name.eq_ignore_ascii_case(&name));
-        if delete {
-            let i = existing.ok_or_else(|| bad(C, format!("no calculated field `{name}`")))?;
-            let gone = pt.calculated_fields.remove(i);
-            pt.values.retain(|v| !v.source_col.eq_ignore_ascii_case(&gone.name));
-            return Ok(json!({"name": gone.name, "deleted": true}));
-        }
-        let formula = formula.clone().unwrap_or_default();
-        if src.col(&name).is_some() {
-            return Err(other("PivotTable field name already exists."));
-        }
-        let canon = match existing {
-            Some(i) => {
-                let c = pt.calculated_fields.get_mut(i).ok_or_else(|| other("There's no such calculated field."))?;
-                c.formula = formula.clone();
-                c.name.clone()
-            }
-            None => {
-                if pt.calculated_fields.len() >= crate::pivot_calc::MAX_CALC_FIELDS {
-                    return Err(other(format!("A PivotTable can have at most {} calculated fields.", crate::pivot_calc::MAX_CALC_FIELDS)));
-                }
-                pt.calculated_fields.push(PivotCalcField { name: name.clone(), formula: formula.clone() });
-                name.clone()
-            }
-        };
-        let set = crate::pivot_calc::CalcSet::new(pt, &src.headers);
-        let i = set.index(&canon).ok_or_else(|| other("There's no such calculated field."))?;
-        if let Some(e) = set.error(i) {
-            return Err(bad(C, e.to_string()));
-        }
-        if set.is_cyclic(i) {
-            return Err(bad(C, format!("`{canon}` refers to itself through its formula")));
-        }
-        if existing.is_none() && to_values && !pt.values.iter().any(|v| v.source_col.eq_ignore_ascii_case(&canon)) {
-            add_to_area(C, pt, src, &canon, "values", Some(PivotFunc::Sum), None, None)?;
-        }
-        Ok(json!({
-            "name": canon,
-            "formula": formula,
-            "calculatedFields": pt.calculated_fields.iter().map(|c| json!({"name": c.name, "formula": c.formula})).collect::<Vec<_>>(),
-        }))
-    })
-}
-
-fn remove_field(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.removeField";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let area = match str_param(p, "area") {
-        Some(a) => Some(area_param(C, Some(a))?),
-        None => None,
-    };
-    update(s, p, |pt, _, _| {
-        match area {
-            Some(a) => {
-                remove_from_area(C, pt, &field, a)?;
-            }
-            None => {
-                let mut any = false;
-                for a in ["rows", "columns", "values", "filters"] {
-                    any |= remove_from_area(C, pt, &field, a).is_ok();
-                }
-                if !any {
-                    return Err(bad(C, format!("`{field}` isn't in the PivotTable")));
-                }
-            }
-        }
-        Ok(json!({}))
-    })
-}
-
-fn move_field(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.moveField";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let from = area_param(C, str_param(p, "from"))?;
-    let to = area_param(C, str_param(p, "to"))?;
-    let pos = position_param(p);
-    update(s, p, |pt, src, _| {
-        if is_values_field(src, &field) {
-            return move_values_field(C, pt, from, to, pos);
-        }
-        if from == to {
-            // Reorder within the area.
-            match from {
-                "rows" | "columns" => {
-                    let rows = from == "rows";
-                    let list = if rows { &mut pt.rows } else { &mut pt.columns };
-                    let i = list
-                        .iter()
-                        .position(|f| f.source_col.eq_ignore_ascii_case(&field))
-                        .ok_or_else(|| bad(C, format!("`{field}` isn't in the {from} area")))?;
-                    let f = list.remove(i);
-                    shift_values(pt, rows, i, false);
-                    insert_axis_field(pt, rows, f, pos);
-                }
-                "values" => {
-                    let i = pt
-                        .values
-                        .iter()
-                        .position(|v| v.name.eq_ignore_ascii_case(&field))
-                        .or_else(|| pt.values.iter().position(|v| v.source_col.eq_ignore_ascii_case(&field)))
-                        .ok_or_else(|| bad(C, format!("`{field}` isn't in the values area")))?;
-                    let v = pt.values.remove(i);
-                    let at = pos.unwrap_or(pt.values.len()).min(pt.values.len());
-                    pt.values.insert(at, v);
-                }
-                _ => {
-                    let i = pt
-                        .filters
-                        .iter()
-                        .position(|f| f.source_col.eq_ignore_ascii_case(&field))
-                        .ok_or_else(|| bad(C, format!("`{field}` isn't in the filters area")))?;
-                    let f = pt.filters.remove(i);
-                    let at = pos.unwrap_or(pt.filters.len()).min(pt.filters.len());
-                    pt.filters.insert(at, f);
-                }
-            }
-            return Ok(json!({}));
-        }
-        // Keep axis settings (sort, grouping) when moving between rows and columns.
-        let kept = pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(&field)).cloned();
-        let hidden = pt.filters.iter().find(|f| f.source_col.eq_ignore_ascii_case(&field)).cloned();
-        let src_field = remove_from_area(C, pt, &field, from)?;
-        add_to_area(C, pt, src, &src_field, to, None, None, pos)?;
-        if matches!(to, "rows" | "columns") {
-            let list = if to == "rows" { &mut pt.rows } else { &mut pt.columns };
-            if let (Some(k), Some(slot)) = (kept, list.iter_mut().find(|f| f.source_col.eq_ignore_ascii_case(&src_field))) {
-                *slot = k;
-            }
-            if let Some(h) = hidden.filter(|h| h.selected.is_some())
-                && !pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(&src_field))
-            {
-                pt.filters.push(h);
-            }
-        }
-        Ok(json!({"field": src_field, "to": to}))
-    })
-}
-
-fn value_settings(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.valueSettings";
-    let field = str_param(p, "field").map(str::to_string);
-    let index = u32_param(p, "index").map(|v| v as usize);
-    let func = match str_param(p, "func") {
-        Some(f) => Some(func_param(Some(f)).ok_or_else(|| bad(C, format!("unknown function `{f}`")))?),
-        None => None,
-    };
-    let show = match str_param(p, "showAs") {
-        Some(v) => Some(show_as_param(v).ok_or_else(|| bad(C, format!("unknown showAs `{v}`")))?),
-        None => None,
-    };
-    let name = str_param(p, "name").map(str::to_string);
-    let fmt = p.get("numberFormat").cloned();
-    update(s, p, |pt, src, _| {
-        let i = match (index, &field) {
-            (Some(i), _) => i,
-            (None, Some(f)) => pt
-                .values
-                .iter()
-                .position(|v| v.name.eq_ignore_ascii_case(f))
-                .or_else(|| pt.values.iter().position(|v| v.source_col.eq_ignore_ascii_case(f)))
-                .ok_or_else(|| bad(C, format!("`{f}` isn't in the values area")))?,
-            (None, None) => {
-                if pt.values.len() == 1 {
-                    0
-                } else {
-                    return Err(bad(C, "pass `field` or `index`"));
-                }
-            }
-        };
-        let cur = pt.values.get(i).cloned().ok_or_else(|| bad(C, "no value field at that index"))?;
-        let mut v = cur.clone();
-        if let Some(f) = func {
-            v.func = f;
-            // An automatic caption follows the function.
-            let auto = auto_name(cur.func, &cur.source_col);
-            if cur.name.eq_ignore_ascii_case(&auto) || cur.name.strip_prefix(auto.as_str()).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit())) {
-                v.name = unique_value_name(pt, &auto_name(f, &cur.source_col), Some(i));
-            }
-        }
-        if let Some(n) = &name {
-            let n = n.trim();
-            if n.is_empty() {
-                return Err(other("The name isn't valid."));
-            }
-            if src.col(n).is_some() {
-                return Err(other("PivotTable field name already exists."));
-            }
-            if pt.values.iter().enumerate().any(|(j, x)| j != i && x.name.eq_ignore_ascii_case(n)) {
-                return Err(other("PivotTable field name already exists."));
-            }
-            v.name = n.to_string();
-        }
-        if let Some(sa) = show {
-            v.show_as = sa;
-        }
-        match &fmt {
-            Some(Json::String(f)) if !f.is_empty() && f.len() <= 255 => v.number_format = Some(f.clone()),
-            Some(Json::Null) => v.number_format = None,
-            Some(Json::String(f)) if f.is_empty() => v.number_format = None,
-            Some(_) => return Err(bad(C, "`numberFormat` is a format code or null")),
-            None => {}
-        }
-        let name = v.name.clone();
-        if let Some(slot) = pt.values.get_mut(i) {
-            *slot = v;
-        }
-        Ok(json!({"name": name}))
-    })
-}
-
-fn filter(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.filter";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let selected: Option<Vec<String>> = match p.get("selected") {
-        None | Some(Json::Null) => None,
-        Some(Json::Array(a)) => {
-            if a.len() > 100_000 {
-                return Err(bad(C, "too many items"));
-            }
-            let v: Vec<String> = a
-                .iter()
-                .map(|x| match x {
-                    Json::String(s) => s.clone(),
-                    Json::Null => "(blank)".into(),
-                    other => other.to_string(),
-                })
-                .collect();
-            if v.is_empty() {
-                return Err(other("You must select at least one item."));
-            }
-            Some(v)
-        }
-        Some(Json::String(s)) => Some(vec![s.clone()]),
-        Some(_) => return Err(bad(C, "`selected` is a list of item labels or null")),
-    };
-    update(s, p, |pt, src, _| {
-        let field = canonical(C, src, &field)?;
-        let i = pt.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(&field));
-        match (i, selected) {
-            (Some(i), None) => {
-                if in_axes(pt, &field) {
-                    pt.filters.remove(i);
-                } else if let Some(f) = pt.filters.get_mut(i) {
-                    f.selected = None;
-                }
-            }
-            (Some(i), Some(sel)) => {
-                if let Some(f) = pt.filters.get_mut(i) {
-                    f.selected = Some(sel);
-                }
-            }
-            (None, Some(sel)) => pt.filters.push(PivotFilter { source_col: field.clone(), selected: Some(sel) }),
-            (None, None) => {}
-        }
-        Ok(json!({"field": field}))
-    })
-}
-
-fn axis_field<'a>(cmd: &str, pt: &'a mut PivotTable, field: &str) -> Result<&'a mut PivotField> {
-    pt.rows
-        .iter_mut()
-        .chain(pt.columns.iter_mut())
-        .find(|f| f.source_col.eq_ignore_ascii_case(field))
-        .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the rows or columns area")))
-}
-
-fn sort(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.sort";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let order = match str_param(p, "order").unwrap_or("asc").to_ascii_lowercase().as_str() {
-        "asc" | "ascending" | "a-z" => PivotSort::Asc,
-        "desc" | "descending" | "z-a" => PivotSort::Desc,
-        "none" | "manual" | "source" => PivotSort::None,
-        o => return Err(bad(C, format!("unknown order `{o}` (asc|desc|none)"))),
-    };
-    update(s, p, |pt, _, _| {
-        axis_field(C, pt, &field)?.sort = order;
-        Ok(json!({}))
-    })
-}
-
-fn group_param(v: Option<&str>) -> Option<PivotDateGroup> {
-    Some(match v?.to_ascii_lowercase().as_str() {
-        "years" | "year" => PivotDateGroup::Years,
-        "quarters" | "quarter" => PivotDateGroup::Quarters,
-        "months" | "month" => PivotDateGroup::Months,
-        "days" | "day" => PivotDateGroup::Days,
-        "none" | "ungroup" => PivotDateGroup::None,
-        _ => return None,
-    })
-}
-
-fn group(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.group";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let raw = str_param(p, "by").unwrap_or("months");
-    let by = group_param(Some(raw)).ok_or_else(|| bad(C, format!("unknown grouping `{raw}` (years|quarters|months|days|none)")))?;
-    update(s, p, |pt, src, _| {
-        if by != PivotDateGroup::None {
-            let c = src.col(&field).ok_or_else(|| bad(C, format!("no field `{field}` in the source data")))?;
-            if !src.numeric.get(c).copied().unwrap_or(false) {
-                return Err(other("Cannot group that selection."));
-            }
-        }
-        let f = axis_field(C, pt, &field)?;
-        f.date_group = by;
-        f.collapsed_items.clear();
-        Ok(json!({}))
-    })
-}
-
-fn collapse(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.collapse";
-    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
-    let on = bool_param(p, "collapse").unwrap_or(true);
-    let items: Option<Vec<String>> =
-        p.get("items").and_then(Json::as_array).map(|a| a.iter().take(100_000).filter_map(|x| x.as_str().map(str::to_string)).collect());
-    update(s, p, |pt, src, wb| {
-        let all = match &items {
-            Some(v) => v.clone(),
-            None => {
-                let f = pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(&field));
-                let g = f.map(|f| f.date_group).unwrap_or_default();
-                match src.col(&field) {
-                    Some(c) => pv::distinct_labels(wb, src, c, g, 100_000),
-                    None => vec![],
-                }
-            }
-        };
-        let f = axis_field(C, pt, &field)?;
-        if on {
-            for it in all {
-                if !f.collapsed_items.iter().any(|x| x.eq_ignore_ascii_case(&it)) {
-                    f.collapsed_items.push(it);
-                }
-            }
-        } else if items.is_none() {
-            f.collapsed_items.clear();
-        } else {
-            f.collapsed_items.retain(|x| !all.iter().any(|a| a.eq_ignore_ascii_case(x)));
-        }
-        Ok(json!({"collapsed": f.collapsed_items}))
-    })
-}
-
-fn layout(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.layout";
-    let lay = match str_param(p, "layout").map(|x| x.to_ascii_lowercase()) {
-        Some(l) if l == "compact" => Some(PivotLayout::Compact),
-        Some(l) if l == "outline" => Some(PivotLayout::Outline),
-        Some(l) if l == "tabular" => Some(PivotLayout::Tabular),
-        Some(l) => return Err(bad(C, format!("unknown layout `{l}` (compact|outline|tabular)"))),
-        None => None,
-    };
-    let subtotals: Option<(bool, Option<bool>)> = match p.get("subtotals") {
-        Some(Json::Bool(b)) => Some((*b, None)),
-        Some(Json::String(m)) => match m.to_ascii_lowercase().as_str() {
-            "top" => Some((true, Some(true))),
-            "bottom" => Some((true, Some(false))),
-            "none" | "off" => Some((false, None)),
-            o => return Err(bad(C, format!("unknown subtotals `{o}` (top|bottom|none)"))),
-        },
-        _ => None,
-    };
-    let style = str_param(p, "style").map(str::to_string);
-    if style.as_ref().is_some_and(|s| s.len() > 64) {
-        return Err(bad(C, "style name too long"));
-    }
-    let gr = bool_param(p, "grandTotalsRows");
-    let gc = bool_param(p, "grandTotalsCols");
-    let hd = bool_param(p, "showHeaders");
-    update(s, p, |pt, _, _| {
-        if let Some(l) = lay {
-            pt.layout = l;
-            if l == PivotLayout::Tabular {
-                pt.subtotals_top = false;
-            }
-        }
-        if let Some((on, top)) = subtotals {
-            pt.subtotals = on;
-            if let Some(t) = top {
-                pt.subtotals_top = t;
-            }
-        }
-        if let Some(st) = &style {
-            pt.style = st.clone();
-        }
-        if let Some(v) = gr {
-            pt.grand_totals_rows = v;
-        }
-        if let Some(v) = gc {
-            pt.grand_totals_cols = v;
-        }
-        if let Some(v) = hd {
-            pt.show_headers = v;
-        }
-        Ok(json!({"layout": layout_name(pt.layout)}))
-    })
-}
-
-fn grand_totals(s: &mut Session, p: &Json) -> Result<Json> {
-    let (r, c) = match str_param(p, "mode").map(|m| m.to_ascii_lowercase()) {
-        Some(m) if m == "off" => (Some(false), Some(false)),
-        Some(m) if m == "on" => (Some(true), Some(true)),
-        Some(m) if m == "rows" => (Some(true), Some(false)),
-        Some(m) if m == "columns" || m == "cols" => (Some(false), Some(true)),
-        Some(m) => return Err(bad("pivot.grandTotals", format!("unknown mode `{m}` (off|on|rows|columns)"))),
-        None => (bool_param(p, "rows"), bool_param(p, "cols")),
-    };
-    let mut q = p.as_object().cloned().unwrap_or_default();
-    if let Some(v) = r {
-        q.insert("grandTotalsRows".into(), json!(v));
-    }
-    if let Some(v) = c {
-        q.insert("grandTotalsCols".into(), json!(v));
-    }
-    layout(s, &Json::Object(q))
-}
-
-fn refresh(s: &mut Session, p: &Json) -> Result<Json> {
-    update(s, p, |_, src, _| Ok(json!({"records": src.rows.len()})))
-}
-
-fn refresh_all(s: &mut Session, p: &Json) -> Result<Json> {
-    let replace = bool_param(p, "replace").unwrap_or(false);
-    edit(s, |cx| {
-        let mut n = 0;
-        let mut errors = vec![];
-        for si in 0..cx.wb.sheets.len() {
-            let count = cx.wb.sheet(si).map(|sh| sh.pivots.len()).unwrap_or(0);
-            for pi in 0..count {
-                let name = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).map(|p| p.name.clone()).unwrap_or_default();
-                match pv::refresh(&mut cx.wb, si, pi, replace) {
-                    Ok(_) => n += 1,
-                    Err(e) => errors.push(json!({"pivot": name, "error": e})),
-                }
-            }
-        }
-        cx.structural = n > 0;
-        Ok(json!({"refreshed": n, "errors": errors}))
-    })
-}
-
-fn change_source(s: &mut Session, p: &Json) -> Result<Json> {
-    const C: &str = "pivot.changeSource";
-    if str_param(p, "source").or_else(|| str_param(p, "range")).is_none() {
-        return Err(bad(C, "missing `source`"));
-    }
-    let source = source_param(s, p)?;
-    let (si, _) = find_pivot(s, p)?;
-    let src = pv::read_source(&s.doc()?.wb, &source, si).map_err(other)?;
-    update(s, p, move |pt, _, _| {
-        pt.source = source.clone();
-        let mut dropped: Vec<String> = vec![];
-        let keep = |name: &str, dropped: &mut Vec<String>| {
-            let ok = src.col(name).is_some();
-            if !ok {
-                dropped.push(name.to_string());
-            }
-            ok
-        };
-        // Axis fields leave one by one so Σ Values keeps its place among the rest.
-        for rows in [true, false] {
-            let mut i = 0;
-            loop {
-                let list = if rows { &mut pt.rows } else { &mut pt.columns };
-                let Some(f) = list.get(i) else { break };
-                if keep(&f.source_col, &mut dropped) {
-                    i += 1;
-                } else {
-                    list.remove(i);
-                    shift_values(pt, rows, i, false);
-                }
-            }
-        }
-        pt.values.retain(|f| keep(&f.source_col, &mut dropped));
-        pt.filters.retain(|f| keep(&f.source_col, &mut dropped));
-        Ok(json!({"source": source, "dropped": dropped}))
-    })
-}
-
-fn delete(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, pi) = find_pivot(s, p)?;
-    edit(s, |cx| {
-        // Its PivotCharts become ordinary charts.
-        let link = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi).map(|pt| (sh.name.clone(), pt.name.clone())));
-        if let Some((sheet, name)) = link {
-            for i in 0..cx.wb.sheets.len() {
-                let linked = |c: &Chart| c.pivot.as_deref().is_some_and(|l| pv::links_to(l, &sheet, &name));
-                if cx.wb.sheet(i).is_some_and(|sh| sh.charts.iter().any(linked)) {
-                    for c in cx.sheet_mut(i)?.charts.iter_mut().filter(|c| linked(c)) {
-                        c.pivot = None;
-                    }
-                }
-            }
-        }
-        pv::clear_output(&mut cx.wb, si, pi);
-        let sh = cx.sheet_mut(si)?;
-        if pi < sh.pivots.len() {
-            sh.pivots.remove(pi);
-        }
-        cx.structural = true;
-        Ok(json!({}))
-    })
-}
-
-// ---------------------------------------------------------------- PivotChart
-
-/// The PivotTable a PivotChart call targets: `pivot` may also be a cell of its report.
-fn chart_pivot(s: &Session, p: &Json) -> Result<(usize, usize)> {
-    if let Some(t) = str_param(p, "pivot") {
-        let d = s.doc()?;
-        let (sheet, addr) = match t.rsplit_once('!') {
-            Some((sh, a)) => {
-                let sh = sh.trim();
-                let sh = gridcraft_core::unquote_sheet(sh);
-                (d.wb.sheet_index(&sh), a)
-            }
-            None => (Some(d.wb.active_sheet()), t),
-        };
-        if let (Some(si), Some(c)) = (sheet, CellRef::parse(addr.trim().replace('$', "").as_str())) {
-            let hit = d.wb.sheet(si).and_then(|sh| sh.pivots.iter().position(|pt| pt.last_range.is_some_and(|r| r.contains(c)) || pt.anchor == c));
-            return hit.map(|pi| (si, pi)).ok_or_else(|| bad("insert.pivotChart", format!("{t} is not in a PivotTable")));
-        }
-    }
-    find_pivot(s, p)
-}
-
-fn insert_pivot_chart(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, pi) = chart_pivot(s, p)?;
-    let d = s.doc()?;
-    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
-    let pt = sh.pivots.get(pi).ok_or_else(|| other("There's no such PivotTable."))?;
-    let area = pt.last_range.ok_or_else(|| other("Refresh the PivotTable before adding a PivotChart."))?;
-    let out = pv::compute(&d.wb, pt, si).map_err(other)?;
-    if out.chart_rows.is_empty() || out.chart_cols.is_empty() {
-        return Err(other("Add a field to the Values area and one to Rows or Columns before creating a PivotChart."));
-    }
-    let series = pv::chart_series(&sh.name, area.start, &out);
-    let t = str_param(p, "type").unwrap_or("column");
-    let kind = super::insert::chart_kind(t, str_param(p, "subtype").unwrap_or(""));
-    let at =
-        cell_param(s, p, "at")?.unwrap_or_else(|| CellRef::new(area.start.row, area.end.col.saturating_add(2).min(gridcraft_core::MAX_COLS - 1)));
-    let title = match p.get("title") {
-        Some(Json::String(t)) => Some(t.clone()),
-        Some(Json::Null) => None,
-        _ => Some(if series.len() == 1 { "Total".to_string() } else { "Chart Title".to_string() }),
-    };
-    let id = d.wb.next_object_id();
-    let link = pv::chart_link(&sh.name, &pt.name);
-    let pivot_name = pt.name.clone();
-    let n = series.len();
-    let chart = Chart {
-        id,
-        kind,
-        anchor: Anchor {
-            cell: at,
-            dx: 0.0,
-            dy: 0.0,
-            width: f64_param(p, "width").unwrap_or(480.0).clamp(10.0, 10_000.0) as f32,
-            height: f64_param(p, "height").unwrap_or(288.0).clamp(10.0, 10_000.0) as f32,
-            mode: anchor_mode_param(p).unwrap_or_default(),
-        },
-        title,
-        series,
-        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
-        data_labels: false,
-        gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
-        style: 1,
-        x_title: None,
-        y_title: None,
-        source: None,
-        by_rows: false,
-        pivot: Some(link),
-    };
-    edit(s, |cx| {
-        cx.sheet_mut(si)?.charts.push(chart);
-        Ok(json!({"chart": id, "pivot": pivot_name, "series": n}))
-    })
-}
-
-// ---------------------------------------------------------------- recommended
-
-fn suggestions(wb: &Workbook, src: &pv::Source) -> Vec<Json> {
-    let n = src.headers.len();
-    let h = |i: usize| src.headers.get(i).cloned().unwrap_or_default();
-    let distinct = |i: usize| pv::distinct_labels(wb, src, i, PivotDateGroup::None, 1001).len();
-    let records = src.rows.len().max(1);
-    let is_num = |i: usize| src.numeric.get(i).copied().unwrap_or(false);
-    let is_date = |i: usize| src.dates.get(i).copied().unwrap_or(false);
-    // Category columns: text with repeats.
-    let cats: Vec<usize> = (0..n)
-        .filter(|&i| {
-            !is_num(i) && {
-                let d = distinct(i);
-                d >= 1 && (d < records || records <= 2) && d <= 1000
-            }
-        })
-        .collect();
-    let nums: Vec<usize> = (0..n).filter(|&i| is_num(i) && !is_date(i)).collect();
-    let dates: Vec<usize> = (0..n).filter(|&i| is_date(i)).collect();
-    let mut out = vec![];
-    let mut push = |title: String, rows: Vec<Json>, cols: Vec<Json>, vals: Vec<Json>| {
-        if out.len() < 5 {
-            let idx = out.len();
-            out.push(json!({"index": idx, "title": title, "rows": rows, "columns": cols, "values": vals}));
-        }
-    };
-    if let (Some(&c), Some(&v)) = (cats.first(), nums.first()) {
-        push(format!("Sum of {} by {}", h(v), h(c)), vec![json!(h(c))], vec![], vec![json!({"field": h(v), "func": "sum"})]);
-    }
-    if let (Some(&c), Some(&c2), Some(&v)) = (cats.first(), cats.get(1), nums.first()) {
-        push(
-            format!("Sum of {} by {} and {}", h(v), h(c), h(c2)),
-            vec![json!(h(c))],
-            vec![json!(h(c2))],
-            vec![json!({"field": h(v), "func": "sum"})],
-        );
-    }
-    if let (Some(&d), Some(&v)) = (dates.first(), nums.first()) {
-        push(
-            format!("Sum of {} by {} (quarters)", h(v), h(d)),
-            vec![json!({"field": h(d), "group": "quarters"})],
-            vec![],
-            vec![json!({"field": h(v), "func": "sum"})],
-        );
-    }
-    if let (Some(&c), Some(&v), Some(&v2)) = (cats.first(), nums.first(), nums.get(1)) {
-        push(
-            format!("Sum of {} and {} by {}", h(v), h(v2), h(c)),
-            vec![json!(h(c))],
-            vec![],
-            vec![json!({"field": h(v), "func": "sum"}), json!({"field": h(v2), "func": "sum"})],
-        );
-    }
-    if let Some(&c) = cats.first() {
-        push(format!("Count of {} by {}", h(c), h(c)), vec![json!(h(c))], vec![], vec![json!({"field": h(c), "func": "count"})]);
-    }
-    if let (Some(&c), Some(&v)) = (cats.get(1), nums.first()) {
-        push(format!("Average of {} by {}", h(v), h(c)), vec![json!(h(c))], vec![], vec![json!({"field": h(v), "func": "average"})]);
-    }
-    if cats.is_empty()
-        && dates.is_empty()
-        && let Some(&v) = nums.first()
-    {
-        push(format!("Sum of {}", h(v)), vec![], vec![], vec![json!({"field": h(v), "func": "sum"})]);
-    }
-    out
-}
-
-fn recommended(s: &mut Session, p: &Json) -> Result<Json> {
-    let source = source_param(s, p)?;
-    let active = s.doc()?.wb.active_sheet();
-    let src = pv::read_source(&s.doc()?.wb, &source, active).map_err(other)?;
-    let list = suggestions(&s.doc()?.wb, &src);
-    let Some(apply) = p.get("apply").and_then(Json::as_u64) else {
-        return Ok(json!({"source": source, "suggestions": list}));
-    };
-    let pick = list.get(apply as usize).cloned().ok_or_else(|| bad("insert.recommendedPivotTables", "no suggestion with that index"))?;
-    let mut q = json!({
-        "source": source,
-        "rows": pick.get("rows").cloned().unwrap_or(json!([])),
-        "columns": pick.get("columns").cloned().unwrap_or(json!([])),
-        "values": pick.get("values").cloned().unwrap_or(json!([])),
-    });
-    if let (Some(m), Some(d)) = (q.as_object_mut(), p.get("destination")) {
-        m.insert("destination".into(), d.clone());
-    }
-    if let (Some(m), Some(r)) = (q.as_object_mut(), p.get("replace")) {
-        m.insert("replace".into(), r.clone());
-    }
-    let mut res = insert_pivot(s, &q)?;
-    if let Some(m) = res.as_object_mut() {
-        m.insert("suggestion".into(), pick);
-    }
-    Ok(res)
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/crates/engine/src/cmd/pivot/charts.rs b/crates/engine/src/cmd/pivot/charts.rs
new file mode 100644
index 000000000..0a0d72ed4
--- /dev/null
+++ b/crates/engine/src/cmd/pivot/charts.rs
@@ -0,0 +1,174 @@
+use super::create::{insert_pivot, source_param};
+use super::*;
+
+// ---------------------------------------------------------------- PivotChart
+
+/// The PivotTable a PivotChart call targets: `pivot` may also be a cell of its report.
+fn chart_pivot(s: &Session, p: &Json) -> Result<(usize, usize)> {
+    if let Some(t) = str_param(p, "pivot") {
+        let d = s.doc()?;
+        let (sheet, addr) = match t.rsplit_once('!') {
+            Some((sh, a)) => {
+                let sh = sh.trim();
+                let sh = gridcraft_core::unquote_sheet(sh);
+                (d.wb.sheet_index(&sh), a)
+            }
+            None => (Some(d.wb.active_sheet()), t),
+        };
+        if let (Some(si), Some(c)) = (sheet, CellRef::parse(addr.trim().replace('$', "").as_str())) {
+            let hit = d.wb.sheet(si).and_then(|sh| sh.pivots.iter().position(|pt| pt.last_range.is_some_and(|r| r.contains(c)) || pt.anchor == c));
+            return hit.map(|pi| (si, pi)).ok_or_else(|| bad("insert.pivotChart", format!("{t} is not in a PivotTable")));
+        }
+    }
+    find_pivot(s, p)
+}
+
+pub(super) fn insert_pivot_chart(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, pi) = chart_pivot(s, p)?;
+    let d = s.doc()?;
+    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
+    let pt = sh.pivots.get(pi).ok_or_else(|| other("There's no such PivotTable."))?;
+    let area = pt.last_range.ok_or_else(|| other("Refresh the PivotTable before adding a PivotChart."))?;
+    let out = pv::compute(&d.wb, pt, si).map_err(other)?;
+    if out.chart_rows.is_empty() || out.chart_cols.is_empty() {
+        return Err(other("Add a field to the Values area and one to Rows or Columns before creating a PivotChart."));
+    }
+    let series = pv::chart_series(&sh.name, area.start, &out);
+    let t = str_param(p, "type").unwrap_or("column");
+    let kind = crate::cmd::insert::chart_kind(t, str_param(p, "subtype").unwrap_or(""));
+    let at =
+        cell_param(s, p, "at")?.unwrap_or_else(|| CellRef::new(area.start.row, area.end.col.saturating_add(2).min(gridcraft_core::MAX_COLS - 1)));
+    let title = match p.get("title") {
+        Some(Json::String(t)) => Some(t.clone()),
+        Some(Json::Null) => None,
+        _ => Some(if series.len() == 1 { "Total".to_string() } else { "Chart Title".to_string() }),
+    };
+    let id = d.wb.next_object_id();
+    let link = pv::chart_link(&sh.name, &pt.name);
+    let pivot_name = pt.name.clone();
+    let n = series.len();
+    let chart = Chart {
+        id,
+        kind,
+        anchor: Anchor {
+            cell: at,
+            dx: 0.0,
+            dy: 0.0,
+            width: f64_param(p, "width").unwrap_or(480.0).clamp(10.0, 10_000.0) as f32,
+            height: f64_param(p, "height").unwrap_or(288.0).clamp(10.0, 10_000.0) as f32,
+            mode: anchor_mode_param(p).unwrap_or_default(),
+        },
+        title,
+        series,
+        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
+        data_labels: false,
+        gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
+        style: 1,
+        x_title: None,
+        y_title: None,
+        source: None,
+        by_rows: false,
+        pivot: Some(link),
+    };
+    edit(s, |cx| {
+        cx.sheet_mut(si)?.charts.push(chart);
+        Ok(json!({"chart": id, "pivot": pivot_name, "series": n}))
+    })
+}
+
+// ---------------------------------------------------------------- recommended
+
+fn suggestions(wb: &Workbook, src: &pv::Source) -> Vec<Json> {
+    let n = src.headers.len();
+    let h = |i: usize| src.headers.get(i).cloned().unwrap_or_default();
+    let distinct = |i: usize| pv::distinct_labels(wb, src, i, PivotDateGroup::None, 1001).len();
+    let records = src.rows.len().max(1);
+    let is_num = |i: usize| src.numeric.get(i).copied().unwrap_or(false);
+    let is_date = |i: usize| src.dates.get(i).copied().unwrap_or(false);
+    // Category columns: text with repeats.
+    let cats: Vec<usize> = (0..n)
+        .filter(|&i| {
+            !is_num(i) && {
+                let d = distinct(i);
+                d >= 1 && (d < records || records <= 2) && d <= 1000
+            }
+        })
+        .collect();
+    let nums: Vec<usize> = (0..n).filter(|&i| is_num(i) && !is_date(i)).collect();
+    let dates: Vec<usize> = (0..n).filter(|&i| is_date(i)).collect();
+    let mut out = vec![];
+    let mut push = |title: String, rows: Vec<Json>, cols: Vec<Json>, vals: Vec<Json>| {
+        if out.len() < 5 {
+            let idx = out.len();
+            out.push(json!({"index": idx, "title": title, "rows": rows, "columns": cols, "values": vals}));
+        }
+    };
+    if let (Some(&c), Some(&v)) = (cats.first(), nums.first()) {
+        push(format!("Sum of {} by {}", h(v), h(c)), vec![json!(h(c))], vec![], vec![json!({"field": h(v), "func": "sum"})]);
+    }
+    if let (Some(&c), Some(&c2), Some(&v)) = (cats.first(), cats.get(1), nums.first()) {
+        push(
+            format!("Sum of {} by {} and {}", h(v), h(c), h(c2)),
+            vec![json!(h(c))],
+            vec![json!(h(c2))],
+            vec![json!({"field": h(v), "func": "sum"})],
+        );
+    }
+    if let (Some(&d), Some(&v)) = (dates.first(), nums.first()) {
+        push(
+            format!("Sum of {} by {} (quarters)", h(v), h(d)),
+            vec![json!({"field": h(d), "group": "quarters"})],
+            vec![],
+            vec![json!({"field": h(v), "func": "sum"})],
+        );
+    }
+    if let (Some(&c), Some(&v), Some(&v2)) = (cats.first(), nums.first(), nums.get(1)) {
+        push(
+            format!("Sum of {} and {} by {}", h(v), h(v2), h(c)),
+            vec![json!(h(c))],
+            vec![],
+            vec![json!({"field": h(v), "func": "sum"}), json!({"field": h(v2), "func": "sum"})],
+        );
+    }
+    if let Some(&c) = cats.first() {
+        push(format!("Count of {} by {}", h(c), h(c)), vec![json!(h(c))], vec![], vec![json!({"field": h(c), "func": "count"})]);
+    }
+    if let (Some(&c), Some(&v)) = (cats.get(1), nums.first()) {
+        push(format!("Average of {} by {}", h(v), h(c)), vec![json!(h(c))], vec![], vec![json!({"field": h(v), "func": "average"})]);
+    }
+    if cats.is_empty()
+        && dates.is_empty()
+        && let Some(&v) = nums.first()
+    {
+        push(format!("Sum of {}", h(v)), vec![], vec![], vec![json!({"field": h(v), "func": "sum"})]);
+    }
+    out
+}
+
+pub(super) fn recommended(s: &mut Session, p: &Json) -> Result<Json> {
+    let source = source_param(s, p)?;
+    let active = s.doc()?.wb.active_sheet();
+    let src = pv::read_source(&s.doc()?.wb, &source, active).map_err(other)?;
+    let list = suggestions(&s.doc()?.wb, &src);
+    let Some(apply) = p.get("apply").and_then(Json::as_u64) else {
+        return Ok(json!({"source": source, "suggestions": list}));
+    };
+    let pick = list.get(apply as usize).cloned().ok_or_else(|| bad("insert.recommendedPivotTables", "no suggestion with that index"))?;
+    let mut q = json!({
+        "source": source,
+        "rows": pick.get("rows").cloned().unwrap_or(json!([])),
+        "columns": pick.get("columns").cloned().unwrap_or(json!([])),
+        "values": pick.get("values").cloned().unwrap_or(json!([])),
+    });
+    if let (Some(m), Some(d)) = (q.as_object_mut(), p.get("destination")) {
+        m.insert("destination".into(), d.clone());
+    }
+    if let (Some(m), Some(r)) = (q.as_object_mut(), p.get("replace")) {
+        m.insert("replace".into(), r.clone());
+    }
+    let mut res = insert_pivot(s, &q)?;
+    if let Some(m) = res.as_object_mut() {
+        m.insert("suggestion".into(), pick);
+    }
+    Ok(res)
+}
diff --git a/crates/engine/src/cmd/pivot/create.rs b/crates/engine/src/cmd/pivot/create.rs
new file mode 100644
index 000000000..48770f3a0
--- /dev/null
+++ b/crates/engine/src/cmd/pivot/create.rs
@@ -0,0 +1,340 @@
+use super::fields::{add_to_area, in_axes};
+use super::params::{func_name, func_param, group_name, group_param, layout_name, show_as_name, sort_name};
+use super::*;
+
+// ---------------------------------------------------------------- insert
+
+/// The default source: the table at the selection, else the selected block / current region.
+fn default_source(s: &Session) -> Result<String> {
+    let d = s.doc()?;
+    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+    if let Some(t) = sh.table_at(d.selection.active) {
+        return Ok(t.name.clone());
+    }
+    let sel = d.selection.current();
+    let r = if sel.is_single() {
+        current_region(sh, d.selection.active)
+    } else {
+        let used = sh.used_range().unwrap_or(sel);
+        sel.intersection(&used).unwrap_or(sel)
+    };
+    if r.is_single() && sh.value(r.start).is_empty() {
+        return Err(other("The reference isn't valid. Select a cell in a range with labeled columns, or pass `source`."));
+    }
+    Ok(pv::range_text(&sh.name, r))
+}
+
+pub(super) fn source_param(s: &Session, p: &Json) -> Result<String> {
+    match str_param(p, "source").or_else(|| str_param(p, "range")) {
+        Some(t) if !t.trim().is_empty() => {
+            // Bare ranges are on the active sheet; store them with the sheet name.
+            let d = s.doc()?;
+            let t = t.trim().trim_start_matches('=');
+            if !t.contains('!')
+                && RangeRef::parse(t).is_some()
+                && let Some(sh) = d.wb.active()
+                && let Some(r) = RangeRef::parse(t)
+            {
+                return Ok(pv::range_text(&sh.name, r));
+            }
+            Ok(t.to_string())
+        }
+        _ => default_source(s),
+    }
+}
+
+fn next_pivot_name(wb: &Workbook) -> String {
+    (1..)
+        .map(|n| format!("PivotTable{n}"))
+        .find(|n| !wb.sheets.iter().any(|s| s.pivots.iter().any(|p| p.name.eq_ignore_ascii_case(n))))
+        .unwrap_or_default()
+}
+
+fn next_pivot_id(wb: &Workbook) -> u32 {
+    let m = wb.sheets.iter().flat_map(|s| s.pivots.iter().map(|p| p.id)).max().unwrap_or(0);
+    wb.next_object_id().max(m.saturating_add(1))
+}
+
+fn field_list(v: Option<&Json>) -> Vec<Json> {
+    match v {
+        Some(Json::Array(a)) => a.iter().take(512).cloned().collect(),
+        Some(Json::String(s)) => vec![Json::String(s.clone())],
+        _ => vec![],
+    }
+}
+
+pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure && matches!(str_param(p, "destination"), None | Some("new")) {
+        return Err(other("The workbook is protected and cannot be changed."));
+    }
+    let source = source_param(s, p)?;
+    let active = s.doc()?.wb.active_sheet();
+    // Validate the source now (header names, size).
+    let src = pv::read_source(&s.doc()?.wb, &source, active).map_err(other)?;
+    let name = match str_param(p, "name") {
+        Some(n) if !n.trim().is_empty() => {
+            let n = n.trim().to_string();
+            if s.doc()?.wb.sheets.iter().any(|sh| sh.pivots.iter().any(|x| x.name.eq_ignore_ascii_case(&n))) {
+                return Err(other("A PivotTable with that name already exists."));
+            }
+            n
+        }
+        _ => next_pivot_name(&s.doc()?.wb),
+    };
+    let dest = str_param(p, "destination").or_else(|| str_param(p, "location")).unwrap_or("new").trim().to_string();
+    // Existing sheet destination: (sheet index, anchor).
+    let target: Option<(usize, CellRef)> = if dest.eq_ignore_ascii_case("new") || dest.is_empty() {
+        None
+    } else {
+        let d = s.doc()?;
+        let (sh, body) = crate::cmd::split_sheet(&dest);
+        let si = match sh {
+            Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("insert.pivotTable", format!("no sheet named `{n}`")))?,
+            None => active,
+        };
+        let at = RangeRef::parse(body).map(|r| r.start).ok_or_else(|| bad("insert.pivotTable", format!("not a cell: `{dest}`")))?;
+        Some((si, at))
+    };
+    let replace = bool_param(p, "replace").unwrap_or(false);
+    let rows = field_list(p.get("rows"));
+    let columns = field_list(p.get("columns"));
+    let values = field_list(p.get("values"));
+    let filters = field_list(p.get("filters"));
+    let mut new_sheet_at: Option<usize> = None;
+    let res = edit(s, |cx| {
+        let id = next_pivot_id(&cx.wb);
+        let (si, anchor) = match target {
+            Some(t) => t,
+            None => {
+                let at = insert_sheet_before_active(cx);
+                new_sheet_at = Some(at);
+                (at, CellRef::new(2, 0))
+            }
+        };
+        let mut pt = PivotTable { id, name: name.clone(), source: source.clone(), anchor, ..Default::default() };
+        let add = |pt: &mut PivotTable, list: &[Json], area: &str| -> Result<()> {
+            for f in list {
+                match f {
+                    Json::String(n) => add_to_area("insert.pivotTable", pt, &src, n, area, None, None, None)?,
+                    Json::Object(_) => {
+                        let n = str_param(f, "field").ok_or_else(|| bad("insert.pivotTable", "a field object needs `field`"))?;
+                        let func = match str_param(f, "func") {
+                            Some(fname) => {
+                                Some(func_param(Some(fname)).ok_or_else(|| bad("insert.pivotTable", format!("unknown function `{fname}`")))?)
+                            }
+                            None => None,
+                        };
+                        add_to_area("insert.pivotTable", pt, &src, n, area, func, str_param(f, "name"), None)?;
+                        let by = group_param(str_param(f, "group"));
+                        if let Some(by) = by.filter(|b| *b != PivotDateGroup::None)
+                            && matches!(area, "rows" | "columns")
+                            && src.col(n).and_then(|c| src.numeric.get(c).copied()).unwrap_or(false)
+                            && let Some(af) = pt.rows.iter_mut().chain(pt.columns.iter_mut()).find(|x| x.source_col.eq_ignore_ascii_case(n))
+                        {
+                            af.date_group = by;
+                        }
+                    }
+                    _ => return Err(bad("insert.pivotTable", "fields are names or {field, func?, name?}")),
+                }
+            }
+            Ok(())
+        };
+        add(&mut pt, &rows, "rows")?;
+        add(&mut pt, &columns, "columns")?;
+        add(&mut pt, &values, "values")?;
+        add(&mut pt, &filters, "filters")?;
+        let sh = cx.sheet_mut(si)?;
+        sh.pivots.push(pt);
+        let pi = sh.pivots.len() - 1;
+        let area = pv::refresh(&mut cx.wb, si, pi, replace).map_err(other)?;
+        cx.wb.set_active_sheet(si);
+        *cx.sel = crate::Selection::at(anchor);
+        cx.structural = true;
+        let sheet_name = cx.wb.sheet(si).map(|s| s.name.clone()).unwrap_or_default();
+        Ok(json!({
+            "id": id,
+            "name": name,
+            "sheet": sheet_name,
+            "anchor": anchor.a1(),
+            "range": area.a1(),
+            "source": source,
+            "fields": src.headers,
+        }))
+    })?;
+    if let Some(at) = new_sheet_at
+        && let Ok(d) = s.doc_mut()
+    {
+        d.sheet_selections.insert(at.min(d.sheet_selections.len()), crate::Selection::default());
+    }
+    Ok(res)
+}
+
+/// Inserts a new, empty sheet before the active one (Excel's place for a new PivotTable or a
+/// Show Details sheet); returns its index.
+fn insert_sheet_before_active(cx: &mut Ctx) -> usize {
+    let at = cx.wb.active_sheet().min(cx.wb.sheets.len());
+    let nm = cx.wb.next_sheet_name();
+    cx.wb.sheets.insert(at, Arc::new(Sheet::new(nm)));
+    for n in cx.wb.names.iter_mut() {
+        if let Some(sc) = n.scope.as_mut()
+            && *sc >= at
+        {
+            *sc += 1;
+        }
+    }
+    at
+}
+
+/// Show Details (double-click a value cell): the source records behind it, as values with their
+/// column's number format, under the source headers on a new sheet.
+pub(super) fn show_details(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
+    let active = d.wb.active_sheet();
+    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+    let pt = sh
+        .pivots
+        .iter()
+        .find(|pt| pt.last_range.is_some_and(|r| r.contains(at)))
+        .ok_or_else(|| EngineError::Disabled("pivot.showDetails".into(), pv::NOT_A_VALUE_CELL.into()))?;
+    let origin = pt.last_range.map(|r| r.start).unwrap_or_default();
+    let found = pv::detail_records(&d.wb, pt, active, at.row.saturating_sub(origin.row), at.col.saturating_sub(origin.col));
+    // With the option off, a report that is out of date or a source that cannot be read is
+    // reported as the option; only a cell that is not a value cell keeps its own message.
+    if !pt.enable_show_details && !matches!(found, Ok(None)) {
+        return Err(other(SHOW_DETAILS_OFF));
+    }
+    let (src, records) = found.map_err(other)?.ok_or_else(|| EngineError::Disabled("pivot.showDetails".into(), pv::NOT_A_VALUE_CELL.into()))?;
+    if d.wb.protected_structure {
+        return Err(other("The workbook is protected and cannot be changed."));
+    }
+    let count = records.len();
+    let mut new_sheet_at: Option<usize> = None;
+    let res = edit(s, |cx| {
+        let si = insert_sheet_before_active(cx);
+        new_sheet_at = Some(si);
+        let base = cx.wb.styles.get(StyleId::default()).clone();
+        let fmts: Vec<StyleId> = src
+            .formats
+            .iter()
+            .map(|f| {
+                let mut st = base.clone();
+                st.num_fmt = NumFmt::new(f);
+                cx.wb.styles.intern(st)
+            })
+            .collect();
+        // Columns wide enough for their text, as the PivotTable report's are (dates would show
+        // as ####); the first rows are enough to judge a column.
+        let font = base.font.clone();
+        let widths: Vec<f32> = src
+            .headers
+            .iter()
+            .enumerate()
+            .map(|(c, h)| {
+                let fmt = src.formats.get(c).map(String::as_str).unwrap_or("General");
+                let texts = records.iter().take(1_000).filter_map(|i| src.rows.get(*i).and_then(|r| r.get(c)));
+                let widest = texts
+                    .map(|v| crate::cmd::format::approx_text_width(&crate::display::format(v, fmt, &cx.wb).text, font.size, false))
+                    .fold(crate::cmd::format::approx_text_width(h, font.size, false), f32::max);
+                (widest + 14.0).min(320.0)
+            })
+            .collect();
+        let sh = cx.sheet_mut(si)?;
+        for (c, w) in widths.into_iter().enumerate() {
+            if w > sh.col_width(c as u32) {
+                sh.cols.entry(c as u32).or_default().size = Some(w);
+            }
+        }
+        for (c, h) in src.headers.iter().enumerate() {
+            sh.set_cell(CellRef::new(0, c as u32), Cell { value: gridcraft_core::Value::text(h.as_str()), formula: None, style: StyleId::default() });
+        }
+        for (r, i) in records.iter().enumerate() {
+            let Some(rec) = src.rows.get(*i) else { continue };
+            for (c, v) in rec.iter().enumerate() {
+                let style = fmts.get(c).copied().unwrap_or_default();
+                if v.is_empty() && style == StyleId::default() {
+                    continue;
+                }
+                sh.set_cell(CellRef::new(r as u32 + 1, c as u32), Cell { value: v.clone(), formula: None, style });
+            }
+        }
+        let name = sh.name.clone();
+        cx.wb.set_active_sheet(si);
+        *cx.sel = crate::Selection::at(CellRef::new(0, 0));
+        cx.structural = true;
+        Ok(json!({"sheet": name, "records": count}))
+    })?;
+    if let Some(at) = new_sheet_at
+        && let Ok(d) = s.doc_mut()
+    {
+        d.sheet_selections.insert(at.min(d.sheet_selections.len()), crate::Selection::default());
+    }
+    Ok(res)
+}
+
+/// The message Show Details gives while Enable show details is off.
+const SHOW_DETAILS_OFF: &str = "Show Details is turned off for this PivotTable.";
+
+/// PivotTable Options: Enable show details (Data). Changes only the option; the report is not
+/// refreshed. Without params it returns the current setting.
+pub(super) fn options(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, pi) = find_pivot(s, p)?;
+    let enable = bool_param(p, "enableShowDetails");
+    if p.get("enableShowDetails").is_some_and(|v| !v.is_null()) && enable.is_none() {
+        return Err(bad("pivot.options", "`enableShowDetails` must be true or false"));
+    }
+    let current = |s: &Session| -> Result<Json> {
+        let pt = s.doc()?.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).ok_or_else(|| other("There's no such PivotTable."))?;
+        Ok(json!({"enableShowDetails": pt.enable_show_details}))
+    };
+    let Some(on) = enable else { return current(s) };
+    if current(s)?["enableShowDetails"] == json!(on) {
+        return current(s);
+    }
+    edit(s, |cx| {
+        let pt = cx.sheet_mut(si)?.pivots.get_mut(pi).ok_or_else(|| other("There's no such PivotTable."))?;
+        pt.enable_show_details = on;
+        Ok(json!({"enableShowDetails": on}))
+    })
+}
+
+pub(super) fn summarize_table(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let name = match str_param(p, "table") {
+        Some(n) => d.wb.table(n).and_then(|(si, ti)| d.wb.sheet(si).and_then(|sh| sh.tables.get(ti))).map(|t| t.name.clone()),
+        None => d.wb.active().and_then(|sh| sh.table_at(d.selection.active)).map(|t| t.name.clone()),
+    }
+    .ok_or_else(|| EngineError::Disabled("table.summarizePivot".into(), "select a cell in a table".into()))?;
+    let mut q = with(p, "source", json!(name));
+    if let Some(m) = q.as_object_mut() {
+        m.remove("table");
+    }
+    insert_pivot(s, &q)
+}
+
+// ---------------------------------------------------------------- queries
+
+pub(super) fn pivot_json(wb: &Workbook, si: usize, pt: &PivotTable) -> Json {
+    json!({
+        "id": pt.id,
+        "name": pt.name,
+        "sheet": wb.sheet(si).map(|s| s.name.clone()).unwrap_or_default(),
+        "anchor": pt.anchor.a1(),
+        "range": pt.last_range.map(|r| r.a1()),
+        "source": pt.source,
+        "rows": pt.rows.iter().map(|f| json!({"field": f.source_col, "sort": sort_name(f.sort), "group": group_name(f.date_group), "collapsed": f.collapsed_items})).collect::<Vec<_>>(),
+        "columns": pt.columns.iter().map(|f| json!({"field": f.source_col, "sort": sort_name(f.sort), "group": group_name(f.date_group), "collapsed": f.collapsed_items})).collect::<Vec<_>>(),
+        "values": pt.values.iter().map(|v| json!({"field": v.source_col, "func": func_name(v.func), "name": v.name, "showAs": show_as_name(v.show_as), "numberFormat": v.number_format})).collect::<Vec<_>>(),
+        "filters": pt.filters.iter().map(|f| json!({"field": f.source_col, "selected": f.selected, "report": !in_axes(pt, &f.source_col)})).collect::<Vec<_>>(),
+        "layout": layout_name(pt.layout),
+        "grandTotalsRows": pt.grand_totals_rows,
+        "grandTotalsCols": pt.grand_totals_cols,
+        "subtotals": if !pt.subtotals { "none" } else if pt.subtotals_top { "top" } else { "bottom" },
+        "style": pt.style,
+        "showHeaders": pt.show_headers,
+        "calculatedFields": pt.calculated_fields.iter().map(|c| json!({"name": c.name, "formula": c.formula})).collect::<Vec<_>>(),
+        "valuesOnRows": pt.values_on_rows,
+        "valuesPosition": pt.values_position,
+        "enableShowDetails": pt.enable_show_details,
+    })
+}
diff --git a/crates/engine/src/cmd/pivot/fields.rs b/crates/engine/src/cmd/pivot/fields.rs
new file mode 100644
index 000000000..344a60af3
--- /dev/null
+++ b/crates/engine/src/cmd/pivot/fields.rs
@@ -0,0 +1,541 @@
+use super::create::pivot_json;
+use super::params::{area_param, func_param, position_param, show_as_param};
+use super::*;
+
+// ---------------------------------------------------------------- layout editing (pure)
+
+pub(super) fn in_axes(pt: &PivotTable, field: &str) -> bool {
+    pt.rows.iter().chain(pt.columns.iter()).any(|f| f.source_col.eq_ignore_ascii_case(field))
+}
+
+/// Name of the Σ Values pseudo-field (where the value fields sit when there are two or more).
+const VALUES_FIELD: &str = "Σ Values";
+
+/// Whether `field` names Σ Values: `Σ Values`, or `Values` unless a source field has that name.
+fn is_values_field(src: &pv::Source, field: &str) -> bool {
+    let f = field.trim();
+    f == VALUES_FIELD || (f.eq_ignore_ascii_case("values") && src.col(f).is_none())
+}
+
+/// Keeps Σ Values in place after a field left (`inserted` false) or arrived at index `i` of
+/// Rows (`rows`) or Columns.
+pub(super) fn shift_values(pt: &mut PivotTable, rows: bool, i: usize, inserted: bool) {
+    if pt.values_on_rows != rows {
+        return;
+    }
+    let Some(p) = pt.values_position else { return };
+    // Σ Values stays just ahead of the field it preceded.
+    let p = match inserted {
+        true if i <= p => p + 1,
+        false if i < p => p - 1,
+        _ => p,
+    };
+    let n = if rows { pt.rows.len() } else { pt.columns.len() };
+    pt.values_position = (p < n).then_some(p);
+}
+
+/// Takes `field` out of Rows and Columns (Σ Values keeps its place); returns its first entry.
+fn take_from_axes(pt: &mut PivotTable, field: &str) -> Option<PivotField> {
+    let mut first = None;
+    for rows in [true, false] {
+        loop {
+            let list = if rows { &mut pt.rows } else { &mut pt.columns };
+            let Some(i) = list.iter().position(|f| f.source_col.eq_ignore_ascii_case(field)) else { break };
+            let f = list.remove(i);
+            shift_values(pt, rows, i, false);
+            first.get_or_insert(f);
+        }
+    }
+    first
+}
+
+/// Inserts `f` into Rows (`rows`) or Columns at `position` (default: the end).
+fn insert_axis_field(pt: &mut PivotTable, rows: bool, f: PivotField, position: Option<usize>) {
+    let list = if rows { &mut pt.rows } else { &mut pt.columns };
+    let at = position.unwrap_or(list.len()).min(list.len());
+    list.insert(at, f);
+    shift_values(pt, rows, at, true);
+}
+
+/// Moves Σ Values between Rows and Columns, or within Rows, to `position` (default: the end).
+/// In Columns it always comes after the last column field: the column layout doesn't place it
+/// anywhere else yet.
+fn move_values_field(cmd: &str, pt: &mut PivotTable, from: &str, to: &str, position: Option<usize>) -> Result<Json> {
+    let current = if pt.values_on_rows { "rows" } else { "columns" };
+    if from != current {
+        return Err(bad(cmd, format!("`{VALUES_FIELD}` isn't in the {from} area")));
+    }
+    if !matches!(to, "rows" | "columns") {
+        return Err(other("The field you are moving cannot be placed in that PivotTable area."));
+    }
+    pt.values_on_rows = to == "rows";
+    pt.values_position = position.filter(|p| pt.values_on_rows && *p < pt.rows.len());
+    Ok(json!({"field": VALUES_FIELD, "to": to}))
+}
+
+/// The canonical source field name for `field`.
+pub(super) fn canonical(cmd: &str, src: &pv::Source, field: &str) -> Result<String> {
+    src.col(field).and_then(|c| src.headers.get(c).cloned()).ok_or_else(|| bad(cmd, format!("no field `{field}` in the source data")))
+}
+
+/// The calculated field named `field`, if any.
+fn calc_field<'a>(pt: &'a PivotTable, field: &str) -> Option<&'a PivotCalcField> {
+    pt.calculated_fields.iter().find(|c| c.name.eq_ignore_ascii_case(field.trim()))
+}
+
+/// The canonical name of a source or calculated field.
+fn canonical_any(cmd: &str, pt: &PivotTable, src: &pv::Source, field: &str) -> Result<String> {
+    match calc_field(pt, field) {
+        Some(c) if src.col(field).is_none() => Ok(c.name.clone()),
+        _ => canonical(cmd, src, field),
+    }
+}
+
+fn unique_value_name(pt: &PivotTable, base: &str, except: Option<usize>) -> String {
+    let taken = |n: &str| pt.values.iter().enumerate().any(|(i, v)| Some(i) != except && v.name.eq_ignore_ascii_case(n));
+    if !taken(base) {
+        return base.to_string();
+    }
+    (2..10_000).map(|k| format!("{base}{k}")).find(|n| !taken(n)).unwrap_or_else(|| base.to_string())
+}
+
+fn auto_name(f: PivotFunc, field: &str) -> String {
+    format!("{} of {field}", pv::func_caption(f))
+}
+
+/// Adds `field` to an area (moving it out of the other axis areas).
+pub(super) fn add_to_area(
+    cmd: &str,
+    pt: &mut PivotTable,
+    src: &pv::Source,
+    field: &str,
+    area: &str,
+    func: Option<PivotFunc>,
+    name: Option<&str>,
+    position: Option<usize>,
+) -> Result<()> {
+    let is_calc = src.col(field).is_none() && calc_field(pt, field).is_some();
+    if is_calc && area != "values" {
+        return Err(other("A calculated field can only be placed in the Values area."));
+    }
+    let field = canonical_any(cmd, pt, src, field)?;
+    match area {
+        "rows" | "columns" => {
+            if pt.rows.len() + pt.columns.len() >= pv::MAX_AXIS_FIELDS && !in_axes(pt, &field) {
+                return Err(other(format!("A PivotTable can have at most {} row and column fields.", pv::MAX_AXIS_FIELDS)));
+            }
+            let existing = take_from_axes(pt, &field).unwrap_or_else(|| PivotField { source_col: field.clone(), ..Default::default() });
+            // A report filter that selects nothing in particular goes away; a selection stays
+            // as the field's hidden items.
+            pt.filters.retain(|f| !(f.source_col.eq_ignore_ascii_case(&field) && f.selected.is_none()));
+            insert_axis_field(pt, area == "rows", existing, position);
+        }
+        "values" => {
+            if pt.values.len() >= pv::MAX_VALUE_FIELDS {
+                return Err(other(format!("A PivotTable can have at most {} value fields.", pv::MAX_VALUE_FIELDS)));
+            }
+            let numeric = is_calc || src.col(&field).and_then(|c| src.numeric.get(c).copied()).unwrap_or(false);
+            let f = func.unwrap_or(if numeric { PivotFunc::Sum } else { PivotFunc::Count });
+            let base = match name {
+                Some(n) if !n.trim().is_empty() => {
+                    if src.col(n).is_some() {
+                        return Err(other("PivotTable field name already exists."));
+                    }
+                    n.to_string()
+                }
+                _ => auto_name(f, &field),
+            };
+            let nm = unique_value_name(pt, &base, None);
+            let v = PivotValue { source_col: field, func: f, name: nm, show_as: PivotShowAs::Normal, number_format: None };
+            let at = position.unwrap_or(pt.values.len()).min(pt.values.len());
+            pt.values.insert(at, v);
+        }
+        _ => {
+            take_from_axes(pt, &field);
+            let existing = pt.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(&field));
+            let entry = match existing {
+                Some(i) => pt.filters.remove(i),
+                None => PivotFilter { source_col: field, selected: None },
+            };
+            let at = position.unwrap_or(pt.filters.len()).min(pt.filters.len());
+            pt.filters.insert(at, entry);
+        }
+    }
+    Ok(())
+}
+
+/// Removes `field` from an area; returns the source field it referred to.
+fn remove_from_area(cmd: &str, pt: &mut PivotTable, field: &str, area: &str) -> Result<String> {
+    match area {
+        "rows" | "columns" => {
+            let rows = area == "rows";
+            let list = if rows { &mut pt.rows } else { &mut pt.columns };
+            let i = list
+                .iter()
+                .position(|f| f.source_col.eq_ignore_ascii_case(field))
+                .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the {area} area")))?;
+            let f = list.remove(i);
+            shift_values(pt, rows, i, false);
+            pt.filters.retain(|x| !x.source_col.eq_ignore_ascii_case(&f.source_col));
+            Ok(f.source_col)
+        }
+        "values" => {
+            let i = pt
+                .values
+                .iter()
+                .position(|v| v.name.eq_ignore_ascii_case(field))
+                .or_else(|| pt.values.iter().position(|v| v.source_col.eq_ignore_ascii_case(field)))
+                .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the values area")))?;
+            Ok(pt.values.remove(i).source_col)
+        }
+        _ => {
+            let i = pt
+                .filters
+                .iter()
+                .position(|f| f.source_col.eq_ignore_ascii_case(field) && !in_axes(pt, &f.source_col))
+                .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the filters area")))?;
+            Ok(pt.filters.remove(i).source_col)
+        }
+    }
+}
+
+// ---------------------------------------------------------------- shared update
+
+/// Applies `f` to the targeted pivot and re-renders it, as one undo step.
+pub(super) fn update(s: &mut Session, p: &Json, f: impl FnOnce(&mut PivotTable, &pv::Source, &Workbook) -> Result<Json>) -> Result<Json> {
+    let (si, pi) = find_pivot(s, p)?;
+    let replace = bool_param(p, "replace").unwrap_or(false);
+    edit(s, |cx| {
+        let pt = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).cloned().ok_or_else(|| other("There's no such PivotTable."))?;
+        let src = pv::read_source(&cx.wb, &pt.source, si).map_err(other)?;
+        let mut new = pt.clone();
+        let mut out = f(&mut new, &src, &cx.wb)?;
+        if let Some(slot) = cx.sheet_mut(si)?.pivots.get_mut(pi) {
+            *slot = new;
+        }
+        let area = pv::refresh(&mut cx.wb, si, pi, replace).map_err(other)?;
+        cx.structural = true;
+        if out.is_null() {
+            out = json!({});
+        }
+        if let Some(m) = out.as_object_mut() {
+            m.insert("range".into(), json!(area.a1()));
+        }
+        Ok(out)
+    })
+}
+
+pub(super) fn fields(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, pi) = find_pivot(s, p)?;
+    let d = s.doc()?;
+    let pt = d.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).ok_or_else(|| other("There's no such PivotTable."))?;
+    let mut out = pivot_json(&d.wb, si, pt);
+    let src = pv::read_source(&d.wb, &pt.source, si);
+    let list: Vec<Json> = match &src {
+        Ok(src) => src
+            .headers
+            .iter()
+            .enumerate()
+            .map(|(c, h)| {
+                let mut areas = vec![];
+                if pt.rows.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
+                    areas.push("rows");
+                }
+                if pt.columns.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
+                    areas.push("columns");
+                }
+                if pt.values.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
+                    areas.push("values");
+                }
+                if pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) && !in_axes(pt, h) {
+                    areas.push("filters");
+                }
+                json!({
+                    "name": h,
+                    "numeric": src.numeric.get(c).copied().unwrap_or(false),
+                    "date": src.dates.get(c).copied().unwrap_or(false),
+                    "samples": pv::distinct_labels(&d.wb, src, c, PivotDateGroup::None, 5),
+                    "areas": areas,
+                })
+            })
+            .collect(),
+        Err(_) => vec![],
+    };
+    let mut list = list;
+    for c in &pt.calculated_fields {
+        let areas: Vec<&str> = if pt.values.iter().any(|v| v.source_col.eq_ignore_ascii_case(&c.name)) { vec!["values"] } else { vec![] };
+        list.push(json!({"name": c.name, "numeric": true, "date": false, "samples": [], "areas": areas, "calculated": true, "formula": c.formula}));
+    }
+    if let Some(m) = out.as_object_mut() {
+        m.insert("fields".into(), Json::Array(list));
+        if let Ok(src) = &src {
+            m.insert("records".into(), json!(src.rows.len()));
+        }
+        if let Err(e) = src {
+            m.insert("error".into(), json!(e));
+        }
+    }
+    Ok(out)
+}
+
+pub(super) fn list(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let mut v = vec![];
+    for (si, sh) in d.wb.sheets.iter().enumerate() {
+        for pt in &sh.pivots {
+            v.push(pivot_json(&d.wb, si, pt));
+        }
+    }
+    Ok(Json::Array(v))
+}
+
+pub(super) fn add_field(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.addField";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let area = area_param(C, str_param(p, "area"))?;
+    let func = match str_param(p, "func") {
+        Some(f) => Some(func_param(Some(f)).ok_or_else(|| bad(C, format!("unknown function `{f}`")))?),
+        None => None,
+    };
+    let name = str_param(p, "name").map(str::to_string);
+    let pos = position_param(p);
+    update(s, p, |pt, src, _| {
+        add_to_area(C, pt, src, &field, area, func, name.as_deref(), pos)?;
+        Ok(json!({"field": canonical_any(C, pt, src, &field)?, "area": area}))
+    })
+}
+
+pub(super) fn calculated_field(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.calculatedField";
+    let Some(name) = str_param(p, "name").map(|n| n.trim().to_string()) else {
+        // Menu-style call: the Insert Calculated Field dialog.
+        let (si, pi) = find_pivot(s, p)?;
+        let d = s.doc()?;
+        let pt = d.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).ok_or_else(|| other("There's no such PivotTable."))?;
+        let n = (1..).map(|k| format!("Field{k}")).find(|n| calc_field(pt, n).is_none()).unwrap_or_else(|| "Field1".into());
+        let pivot = pt.name.clone();
+        s.ui_requests.push(crate::UiRequest::Dialog("pivotCalculatedField".into(), json!({"pivot": pivot, "name": n, "formula": "= 0"})));
+        return ok();
+    };
+    if name.is_empty() || name.chars().count() > 255 {
+        return Err(bad(C, "`name` must be 1 to 255 characters"));
+    }
+    let delete = bool_param(p, "delete").unwrap_or(false);
+    let formula = str_param(p, "formula").map(|f| {
+        let f = f.trim();
+        if f.starts_with('=') { f.to_string() } else { format!("={f}") }
+    });
+    let to_values = bool_param(p, "values").unwrap_or(true);
+    if !delete && formula.is_none() {
+        return Err(bad(C, "missing `formula`"));
+    }
+    update(s, p, |pt, src, _| {
+        let existing = pt.calculated_fields.iter().position(|c| c.name.eq_ignore_ascii_case(&name));
+        if delete {
+            let i = existing.ok_or_else(|| bad(C, format!("no calculated field `{name}`")))?;
+            let gone = pt.calculated_fields.remove(i);
+            pt.values.retain(|v| !v.source_col.eq_ignore_ascii_case(&gone.name));
+            return Ok(json!({"name": gone.name, "deleted": true}));
+        }
+        let formula = formula.clone().unwrap_or_default();
+        if src.col(&name).is_some() {
+            return Err(other("PivotTable field name already exists."));
+        }
+        let canon = match existing {
+            Some(i) => {
+                let c = pt.calculated_fields.get_mut(i).ok_or_else(|| other("There's no such calculated field."))?;
+                c.formula = formula.clone();
+                c.name.clone()
+            }
+            None => {
+                if pt.calculated_fields.len() >= crate::pivot_calc::MAX_CALC_FIELDS {
+                    return Err(other(format!("A PivotTable can have at most {} calculated fields.", crate::pivot_calc::MAX_CALC_FIELDS)));
+                }
+                pt.calculated_fields.push(PivotCalcField { name: name.clone(), formula: formula.clone() });
+                name.clone()
+            }
+        };
+        let set = crate::pivot_calc::CalcSet::new(pt, &src.headers);
+        let i = set.index(&canon).ok_or_else(|| other("There's no such calculated field."))?;
+        if let Some(e) = set.error(i) {
+            return Err(bad(C, e.to_string()));
+        }
+        if set.is_cyclic(i) {
+            return Err(bad(C, format!("`{canon}` refers to itself through its formula")));
+        }
+        if existing.is_none() && to_values && !pt.values.iter().any(|v| v.source_col.eq_ignore_ascii_case(&canon)) {
+            add_to_area(C, pt, src, &canon, "values", Some(PivotFunc::Sum), None, None)?;
+        }
+        Ok(json!({
+            "name": canon,
+            "formula": formula,
+            "calculatedFields": pt.calculated_fields.iter().map(|c| json!({"name": c.name, "formula": c.formula})).collect::<Vec<_>>(),
+        }))
+    })
+}
+
+pub(super) fn remove_field(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.removeField";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let area = match str_param(p, "area") {
+        Some(a) => Some(area_param(C, Some(a))?),
+        None => None,
+    };
+    update(s, p, |pt, _, _| {
+        match area {
+            Some(a) => {
+                remove_from_area(C, pt, &field, a)?;
+            }
+            None => {
+                let mut any = false;
+                for a in ["rows", "columns", "values", "filters"] {
+                    any |= remove_from_area(C, pt, &field, a).is_ok();
+                }
+                if !any {
+                    return Err(bad(C, format!("`{field}` isn't in the PivotTable")));
+                }
+            }
+        }
+        Ok(json!({}))
+    })
+}
+
+pub(super) fn move_field(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.moveField";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let from = area_param(C, str_param(p, "from"))?;
+    let to = area_param(C, str_param(p, "to"))?;
+    let pos = position_param(p);
+    update(s, p, |pt, src, _| {
+        if is_values_field(src, &field) {
+            return move_values_field(C, pt, from, to, pos);
+        }
+        if from == to {
+            // Reorder within the area.
+            match from {
+                "rows" | "columns" => {
+                    let rows = from == "rows";
+                    let list = if rows { &mut pt.rows } else { &mut pt.columns };
+                    let i = list
+                        .iter()
+                        .position(|f| f.source_col.eq_ignore_ascii_case(&field))
+                        .ok_or_else(|| bad(C, format!("`{field}` isn't in the {from} area")))?;
+                    let f = list.remove(i);
+                    shift_values(pt, rows, i, false);
+                    insert_axis_field(pt, rows, f, pos);
+                }
+                "values" => {
+                    let i = pt
+                        .values
+                        .iter()
+                        .position(|v| v.name.eq_ignore_ascii_case(&field))
+                        .or_else(|| pt.values.iter().position(|v| v.source_col.eq_ignore_ascii_case(&field)))
+                        .ok_or_else(|| bad(C, format!("`{field}` isn't in the values area")))?;
+                    let v = pt.values.remove(i);
+                    let at = pos.unwrap_or(pt.values.len()).min(pt.values.len());
+                    pt.values.insert(at, v);
+                }
+                _ => {
+                    let i = pt
+                        .filters
+                        .iter()
+                        .position(|f| f.source_col.eq_ignore_ascii_case(&field))
+                        .ok_or_else(|| bad(C, format!("`{field}` isn't in the filters area")))?;
+                    let f = pt.filters.remove(i);
+                    let at = pos.unwrap_or(pt.filters.len()).min(pt.filters.len());
+                    pt.filters.insert(at, f);
+                }
+            }
+            return Ok(json!({}));
+        }
+        // Keep axis settings (sort, grouping) when moving between rows and columns.
+        let kept = pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(&field)).cloned();
+        let hidden = pt.filters.iter().find(|f| f.source_col.eq_ignore_ascii_case(&field)).cloned();
+        let src_field = remove_from_area(C, pt, &field, from)?;
+        add_to_area(C, pt, src, &src_field, to, None, None, pos)?;
+        if matches!(to, "rows" | "columns") {
+            let list = if to == "rows" { &mut pt.rows } else { &mut pt.columns };
+            if let (Some(k), Some(slot)) = (kept, list.iter_mut().find(|f| f.source_col.eq_ignore_ascii_case(&src_field))) {
+                *slot = k;
+            }
+            if let Some(h) = hidden.filter(|h| h.selected.is_some())
+                && !pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(&src_field))
+            {
+                pt.filters.push(h);
+            }
+        }
+        Ok(json!({"field": src_field, "to": to}))
+    })
+}
+
+pub(super) fn value_settings(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.valueSettings";
+    let field = str_param(p, "field").map(str::to_string);
+    let index = u32_param(p, "index").map(|v| v as usize);
+    let func = match str_param(p, "func") {
+        Some(f) => Some(func_param(Some(f)).ok_or_else(|| bad(C, format!("unknown function `{f}`")))?),
+        None => None,
+    };
+    let show = match str_param(p, "showAs") {
+        Some(v) => Some(show_as_param(v).ok_or_else(|| bad(C, format!("unknown showAs `{v}`")))?),
+        None => None,
+    };
+    let name = str_param(p, "name").map(str::to_string);
+    let fmt = p.get("numberFormat").cloned();
+    update(s, p, |pt, src, _| {
+        let i = match (index, &field) {
+            (Some(i), _) => i,
+            (None, Some(f)) => pt
+                .values
+                .iter()
+                .position(|v| v.name.eq_ignore_ascii_case(f))
+                .or_else(|| pt.values.iter().position(|v| v.source_col.eq_ignore_ascii_case(f)))
+                .ok_or_else(|| bad(C, format!("`{f}` isn't in the values area")))?,
+            (None, None) => {
+                if pt.values.len() == 1 {
+                    0
+                } else {
+                    return Err(bad(C, "pass `field` or `index`"));
+                }
+            }
+        };
+        let cur = pt.values.get(i).cloned().ok_or_else(|| bad(C, "no value field at that index"))?;
+        let mut v = cur.clone();
+        if let Some(f) = func {
+            v.func = f;
+            // An automatic caption follows the function.
+            let auto = auto_name(cur.func, &cur.source_col);
+            if cur.name.eq_ignore_ascii_case(&auto) || cur.name.strip_prefix(auto.as_str()).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit())) {
+                v.name = unique_value_name(pt, &auto_name(f, &cur.source_col), Some(i));
+            }
+        }
+        if let Some(n) = &name {
+            let n = n.trim();
+            if n.is_empty() {
+                return Err(other("The name isn't valid."));
+            }
+            if src.col(n).is_some() {
+                return Err(other("PivotTable field name already exists."));
+            }
+            if pt.values.iter().enumerate().any(|(j, x)| j != i && x.name.eq_ignore_ascii_case(n)) {
+                return Err(other("PivotTable field name already exists."));
+            }
+            v.name = n.to_string();
+        }
+        if let Some(sa) = show {
+            v.show_as = sa;
+        }
+        match &fmt {
+            Some(Json::String(f)) if !f.is_empty() && f.len() <= 255 => v.number_format = Some(f.clone()),
+            Some(Json::Null) => v.number_format = None,
+            Some(Json::String(f)) if f.is_empty() => v.number_format = None,
+            Some(_) => return Err(bad(C, "`numberFormat` is a format code or null")),
+            None => {}
+        }
+        let name = v.name.clone();
+        if let Some(slot) = pt.values.get_mut(i) {
+            *slot = v;
+        }
+        Ok(json!({"name": name}))
+    })
+}
diff --git a/crates/engine/src/cmd/pivot/layout.rs b/crates/engine/src/cmd/pivot/layout.rs
new file mode 100644
index 000000000..b3582ea46
--- /dev/null
+++ b/crates/engine/src/cmd/pivot/layout.rs
@@ -0,0 +1,289 @@
+use super::create::source_param;
+use super::fields::{canonical, in_axes, shift_values, update};
+use super::params::{group_param, layout_name};
+use super::*;
+
+pub(super) fn filter(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.filter";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let selected: Option<Vec<String>> = match p.get("selected") {
+        None | Some(Json::Null) => None,
+        Some(Json::Array(a)) => {
+            if a.len() > 100_000 {
+                return Err(bad(C, "too many items"));
+            }
+            let v: Vec<String> = a
+                .iter()
+                .map(|x| match x {
+                    Json::String(s) => s.clone(),
+                    Json::Null => "(blank)".into(),
+                    other => other.to_string(),
+                })
+                .collect();
+            if v.is_empty() {
+                return Err(other("You must select at least one item."));
+            }
+            Some(v)
+        }
+        Some(Json::String(s)) => Some(vec![s.clone()]),
+        Some(_) => return Err(bad(C, "`selected` is a list of item labels or null")),
+    };
+    update(s, p, |pt, src, _| {
+        let field = canonical(C, src, &field)?;
+        let i = pt.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(&field));
+        match (i, selected) {
+            (Some(i), None) => {
+                if in_axes(pt, &field) {
+                    pt.filters.remove(i);
+                } else if let Some(f) = pt.filters.get_mut(i) {
+                    f.selected = None;
+                }
+            }
+            (Some(i), Some(sel)) => {
+                if let Some(f) = pt.filters.get_mut(i) {
+                    f.selected = Some(sel);
+                }
+            }
+            (None, Some(sel)) => pt.filters.push(PivotFilter { source_col: field.clone(), selected: Some(sel) }),
+            (None, None) => {}
+        }
+        Ok(json!({"field": field}))
+    })
+}
+
+fn axis_field<'a>(cmd: &str, pt: &'a mut PivotTable, field: &str) -> Result<&'a mut PivotField> {
+    pt.rows
+        .iter_mut()
+        .chain(pt.columns.iter_mut())
+        .find(|f| f.source_col.eq_ignore_ascii_case(field))
+        .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the rows or columns area")))
+}
+
+pub(super) fn sort(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.sort";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let order = match str_param(p, "order").unwrap_or("asc").to_ascii_lowercase().as_str() {
+        "asc" | "ascending" | "a-z" => PivotSort::Asc,
+        "desc" | "descending" | "z-a" => PivotSort::Desc,
+        "none" | "manual" | "source" => PivotSort::None,
+        o => return Err(bad(C, format!("unknown order `{o}` (asc|desc|none)"))),
+    };
+    update(s, p, |pt, _, _| {
+        axis_field(C, pt, &field)?.sort = order;
+        Ok(json!({}))
+    })
+}
+
+pub(super) fn group(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.group";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let raw = str_param(p, "by").unwrap_or("months");
+    let by = group_param(Some(raw)).ok_or_else(|| bad(C, format!("unknown grouping `{raw}` (years|quarters|months|days|none)")))?;
+    update(s, p, |pt, src, _| {
+        if by != PivotDateGroup::None {
+            let c = src.col(&field).ok_or_else(|| bad(C, format!("no field `{field}` in the source data")))?;
+            if !src.numeric.get(c).copied().unwrap_or(false) {
+                return Err(other("Cannot group that selection."));
+            }
+        }
+        let f = axis_field(C, pt, &field)?;
+        f.date_group = by;
+        f.collapsed_items.clear();
+        Ok(json!({}))
+    })
+}
+
+pub(super) fn collapse(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.collapse";
+    let field = str_param(p, "field").ok_or_else(|| bad(C, "missing `field`"))?.to_string();
+    let on = bool_param(p, "collapse").unwrap_or(true);
+    let items: Option<Vec<String>> =
+        p.get("items").and_then(Json::as_array).map(|a| a.iter().take(100_000).filter_map(|x| x.as_str().map(str::to_string)).collect());
+    update(s, p, |pt, src, wb| {
+        let all = match &items {
+            Some(v) => v.clone(),
+            None => {
+                let f = pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(&field));
+                let g = f.map(|f| f.date_group).unwrap_or_default();
+                match src.col(&field) {
+                    Some(c) => pv::distinct_labels(wb, src, c, g, 100_000),
+                    None => vec![],
+                }
+            }
+        };
+        let f = axis_field(C, pt, &field)?;
+        if on {
+            for it in all {
+                if !f.collapsed_items.iter().any(|x| x.eq_ignore_ascii_case(&it)) {
+                    f.collapsed_items.push(it);
+                }
+            }
+        } else if items.is_none() {
+            f.collapsed_items.clear();
+        } else {
+            f.collapsed_items.retain(|x| !all.iter().any(|a| a.eq_ignore_ascii_case(x)));
+        }
+        Ok(json!({"collapsed": f.collapsed_items}))
+    })
+}
+
+pub(super) fn layout(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.layout";
+    let lay = match str_param(p, "layout").map(|x| x.to_ascii_lowercase()) {
+        Some(l) if l == "compact" => Some(PivotLayout::Compact),
+        Some(l) if l == "outline" => Some(PivotLayout::Outline),
+        Some(l) if l == "tabular" => Some(PivotLayout::Tabular),
+        Some(l) => return Err(bad(C, format!("unknown layout `{l}` (compact|outline|tabular)"))),
+        None => None,
+    };
+    let subtotals: Option<(bool, Option<bool>)> = match p.get("subtotals") {
+        Some(Json::Bool(b)) => Some((*b, None)),
+        Some(Json::String(m)) => match m.to_ascii_lowercase().as_str() {
+            "top" => Some((true, Some(true))),
+            "bottom" => Some((true, Some(false))),
+            "none" | "off" => Some((false, None)),
+            o => return Err(bad(C, format!("unknown subtotals `{o}` (top|bottom|none)"))),
+        },
+        _ => None,
+    };
+    let style = str_param(p, "style").map(str::to_string);
+    if style.as_ref().is_some_and(|s| s.len() > 64) {
+        return Err(bad(C, "style name too long"));
+    }
+    let gr = bool_param(p, "grandTotalsRows");
+    let gc = bool_param(p, "grandTotalsCols");
+    let hd = bool_param(p, "showHeaders");
+    update(s, p, |pt, _, _| {
+        if let Some(l) = lay {
+            pt.layout = l;
+            if l == PivotLayout::Tabular {
+                pt.subtotals_top = false;
+            }
+        }
+        if let Some((on, top)) = subtotals {
+            pt.subtotals = on;
+            if let Some(t) = top {
+                pt.subtotals_top = t;
+            }
+        }
+        if let Some(st) = &style {
+            pt.style = st.clone();
+        }
+        if let Some(v) = gr {
+            pt.grand_totals_rows = v;
+        }
+        if let Some(v) = gc {
+            pt.grand_totals_cols = v;
+        }
+        if let Some(v) = hd {
+            pt.show_headers = v;
+        }
+        Ok(json!({"layout": layout_name(pt.layout)}))
+    })
+}
+
+pub(super) fn grand_totals(s: &mut Session, p: &Json) -> Result<Json> {
+    let (r, c) = match str_param(p, "mode").map(|m| m.to_ascii_lowercase()) {
+        Some(m) if m == "off" => (Some(false), Some(false)),
+        Some(m) if m == "on" => (Some(true), Some(true)),
+        Some(m) if m == "rows" => (Some(true), Some(false)),
+        Some(m) if m == "columns" || m == "cols" => (Some(false), Some(true)),
+        Some(m) => return Err(bad("pivot.grandTotals", format!("unknown mode `{m}` (off|on|rows|columns)"))),
+        None => (bool_param(p, "rows"), bool_param(p, "cols")),
+    };
+    let mut q = p.as_object().cloned().unwrap_or_default();
+    if let Some(v) = r {
+        q.insert("grandTotalsRows".into(), json!(v));
+    }
+    if let Some(v) = c {
+        q.insert("grandTotalsCols".into(), json!(v));
+    }
+    layout(s, &Json::Object(q))
+}
+
+pub(super) fn refresh(s: &mut Session, p: &Json) -> Result<Json> {
+    update(s, p, |_, src, _| Ok(json!({"records": src.rows.len()})))
+}
+
+pub(super) fn refresh_all(s: &mut Session, p: &Json) -> Result<Json> {
+    let replace = bool_param(p, "replace").unwrap_or(false);
+    edit(s, |cx| {
+        let mut n = 0;
+        let mut errors = vec![];
+        for si in 0..cx.wb.sheets.len() {
+            let count = cx.wb.sheet(si).map(|sh| sh.pivots.len()).unwrap_or(0);
+            for pi in 0..count {
+                let name = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).map(|p| p.name.clone()).unwrap_or_default();
+                match pv::refresh(&mut cx.wb, si, pi, replace) {
+                    Ok(_) => n += 1,
+                    Err(e) => errors.push(json!({"pivot": name, "error": e})),
+                }
+            }
+        }
+        cx.structural = n > 0;
+        Ok(json!({"refreshed": n, "errors": errors}))
+    })
+}
+
+pub(super) fn change_source(s: &mut Session, p: &Json) -> Result<Json> {
+    const C: &str = "pivot.changeSource";
+    if str_param(p, "source").or_else(|| str_param(p, "range")).is_none() {
+        return Err(bad(C, "missing `source`"));
+    }
+    let source = source_param(s, p)?;
+    let (si, _) = find_pivot(s, p)?;
+    let src = pv::read_source(&s.doc()?.wb, &source, si).map_err(other)?;
+    update(s, p, move |pt, _, _| {
+        pt.source = source.clone();
+        let mut dropped: Vec<String> = vec![];
+        let keep = |name: &str, dropped: &mut Vec<String>| {
+            let ok = src.col(name).is_some();
+            if !ok {
+                dropped.push(name.to_string());
+            }
+            ok
+        };
+        // Axis fields leave one by one so Σ Values keeps its place among the rest.
+        for rows in [true, false] {
+            let mut i = 0;
+            loop {
+                let list = if rows { &mut pt.rows } else { &mut pt.columns };
+                let Some(f) = list.get(i) else { break };
+                if keep(&f.source_col, &mut dropped) {
+                    i += 1;
+                } else {
+                    list.remove(i);
+                    shift_values(pt, rows, i, false);
+                }
+            }
+        }
+        pt.values.retain(|f| keep(&f.source_col, &mut dropped));
+        pt.filters.retain(|f| keep(&f.source_col, &mut dropped));
+        Ok(json!({"source": source, "dropped": dropped}))
+    })
+}
+
+pub(super) fn delete(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, pi) = find_pivot(s, p)?;
+    edit(s, |cx| {
+        // Its PivotCharts become ordinary charts.
+        let link = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi).map(|pt| (sh.name.clone(), pt.name.clone())));
+        if let Some((sheet, name)) = link {
+            for i in 0..cx.wb.sheets.len() {
+                let linked = |c: &Chart| c.pivot.as_deref().is_some_and(|l| pv::links_to(l, &sheet, &name));
+                if cx.wb.sheet(i).is_some_and(|sh| sh.charts.iter().any(linked)) {
+                    for c in cx.sheet_mut(i)?.charts.iter_mut().filter(|c| linked(c)) {
+                        c.pivot = None;
+                    }
+                }
+            }
+        }
+        pv::clear_output(&mut cx.wb, si, pi);
+        let sh = cx.sheet_mut(si)?;
+        if pi < sh.pivots.len() {
+            sh.pivots.remove(pi);
+        }
+        cx.structural = true;
+        Ok(json!({}))
+    })
+}
diff --git a/crates/engine/src/cmd/pivot/params.rs b/crates/engine/src/cmd/pivot/params.rs
new file mode 100644
index 000000000..8aa098479
--- /dev/null
+++ b/crates/engine/src/cmd/pivot/params.rs
@@ -0,0 +1,111 @@
+use super::*;
+
+pub(super) fn area_param(cmd: &str, v: Option<&str>) -> Result<&'static str> {
+    match v.map(str::to_ascii_lowercase) {
+        Some(a) if a == "rows" || a == "row" => Ok("rows"),
+        Some(a) if a == "columns" || a == "column" || a == "cols" => Ok("columns"),
+        Some(a) if a == "values" || a == "value" || a == "data" => Ok("values"),
+        Some(a) if a == "filters" || a == "filter" => Ok("filters"),
+        Some(a) => Err(bad(cmd, format!("unknown area `{a}` (rows|columns|values|filters)"))),
+        None => Err(bad(cmd, "missing `area` (rows|columns|values|filters)")),
+    }
+}
+
+pub(super) fn func_param(v: Option<&str>) -> Option<PivotFunc> {
+    Some(match v?.to_ascii_lowercase().as_str() {
+        "sum" => PivotFunc::Sum,
+        "count" | "counta" => PivotFunc::Count,
+        "average" | "avg" | "mean" => PivotFunc::Average,
+        "max" => PivotFunc::Max,
+        "min" => PivotFunc::Min,
+        "product" => PivotFunc::Product,
+        "countnumbers" | "countnums" | "count numbers" => PivotFunc::CountNumbers,
+        "stddev" => PivotFunc::StdDev,
+        "stddevp" => PivotFunc::StdDevP,
+        "var" => PivotFunc::Var,
+        "varp" => PivotFunc::VarP,
+        _ => return None,
+    })
+}
+
+pub(super) fn func_name(f: PivotFunc) -> &'static str {
+    match f {
+        PivotFunc::Sum => "sum",
+        PivotFunc::Count => "count",
+        PivotFunc::Average => "average",
+        PivotFunc::Max => "max",
+        PivotFunc::Min => "min",
+        PivotFunc::Product => "product",
+        PivotFunc::CountNumbers => "countNumbers",
+        PivotFunc::StdDev => "stdDev",
+        PivotFunc::StdDevP => "stdDevP",
+        PivotFunc::Var => "var",
+        PivotFunc::VarP => "varP",
+    }
+}
+
+pub(super) fn show_as_param(v: &str) -> Option<PivotShowAs> {
+    Some(match v.to_ascii_lowercase().as_str() {
+        "normal" | "none" => PivotShowAs::Normal,
+        "percentofgrandtotal" => PivotShowAs::PercentOfGrandTotal,
+        "percentofcolumntotal" => PivotShowAs::PercentOfColumnTotal,
+        "percentofrowtotal" => PivotShowAs::PercentOfRowTotal,
+        "runningtotal" => PivotShowAs::RunningTotal,
+        "rank" => PivotShowAs::Rank,
+        _ => return None,
+    })
+}
+
+pub(super) fn show_as_name(v: PivotShowAs) -> &'static str {
+    match v {
+        PivotShowAs::Normal => "normal",
+        PivotShowAs::PercentOfGrandTotal => "percentOfGrandTotal",
+        PivotShowAs::PercentOfColumnTotal => "percentOfColumnTotal",
+        PivotShowAs::PercentOfRowTotal => "percentOfRowTotal",
+        PivotShowAs::RunningTotal => "runningTotal",
+        PivotShowAs::Rank => "rank",
+    }
+}
+
+pub(super) fn layout_name(l: PivotLayout) -> &'static str {
+    match l {
+        PivotLayout::Compact => "compact",
+        PivotLayout::Outline => "outline",
+        PivotLayout::Tabular => "tabular",
+    }
+}
+
+pub(super) fn group_name(g: PivotDateGroup) -> &'static str {
+    match g {
+        PivotDateGroup::None => "none",
+        PivotDateGroup::Years => "years",
+        PivotDateGroup::Quarters => "quarters",
+        PivotDateGroup::Months => "months",
+        PivotDateGroup::Days => "days",
+    }
+}
+
+pub(super) fn sort_name(o: PivotSort) -> &'static str {
+    match o {
+        PivotSort::Asc => "asc",
+        PivotSort::Desc => "desc",
+        PivotSort::None => "none",
+    }
+}
+
+// ---------------------------------------------------------------- field commands
+
+pub(super) fn position_param(p: &Json) -> Option<usize> {
+    u32_param(p, "position").map(|v| v as usize)
+}
+
+pub(super) fn group_param(v: Option<&str>) -> Option<PivotDateGroup> {
+    Some(match v?.to_ascii_lowercase().as_str() {
+        "years" | "year" => PivotDateGroup::Years,
+        "quarters" | "quarter" => PivotDateGroup::Quarters,
+        "months" | "month" => PivotDateGroup::Months,
+        "days" | "day" => PivotDateGroup::Days,
+        "none" | "ungroup" => PivotDateGroup::None,
+        _ => return None,
+    })
+}

From 0e2335531d61609d55d84731c0c099fcd540eadf Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:44:34 +0000
Subject: [PATCH 52/76] refactor(engine): move cmd/data.rs items to cmd/data/

---
 crates/engine/src/cmd/data.rs            | 1395 +---------------------
 crates/engine/src/cmd/data/filter.rs     |  316 +++++
 crates/engine/src/cmd/data/grouping.rs   |  267 +++++
 crates/engine/src/cmd/data/sort.rs       |  322 +++++
 crates/engine/src/cmd/data/tools.rs      |  190 +++
 crates/engine/src/cmd/data/validation.rs |  290 +++++
 6 files changed, 1403 insertions(+), 1377 deletions(-)
 create mode 100644 crates/engine/src/cmd/data/filter.rs
 create mode 100644 crates/engine/src/cmd/data/grouping.rs
 create mode 100644 crates/engine/src/cmd/data/sort.rs
 create mode 100644 crates/engine/src/cmd/data/tools.rs
 create mode 100644 crates/engine/src/cmd/data/validation.rs

diff --git a/crates/engine/src/cmd/data.rs b/crates/engine/src/cmd/data.rs
index 646d44bd9..5fa076e64 100644
--- a/crates/engine/src/cmd/data.rs
+++ b/crates/engine/src/cmd/data.rs
@@ -11,6 +11,24 @@ use super::*;
 use crate::outline;
 use crate::selection::current_region;
 
+mod filter;
+mod grouping;
+mod sort;
+mod tools;
+mod validation;
+
+pub use filter::filter_values;
+pub(crate) use filter::{apply_filter, grow_autofilter};
+use filter::{clear_filter, filter_by, reapply, toggle_filter};
+use grouping::{detail, group, outline_settings, show_levels, subtotal};
+use sort::{quick_sort, sort};
+#[cfg(test)]
+use tools::split_delimited;
+use tools::{remove_duplicates, text_to_columns};
+pub use validation::{check_validation, list_items};
+use validation::{circle_invalid, validate_cmd, validation};
+pub(super) use validation::{move_rule_formula, remove_validation_cells};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!("data.sortAscending", "Sort A to Z", ["Data", "Sort & Filter"], None, "{range?, column?: \"B\"}", has_doc, |s, p| quick_sort(
@@ -200,1382 +218,5 @@ fn guess_header(wb: &Workbook, sh: &Sheet, r: RangeRef) -> bool {
     votes > 0
 }
 
-#[derive(Clone)]
-struct SortKey {
-    col: u32,
-    desc: bool,
-    by: String,
-    list: Option<Vec<String>>,
-}
-
-/// The sheet and range a sort works on: the sheet `sheet` or a `Sheet!` prefix on `range` names,
-/// else the active one. The selection belongs to the active sheet, so another sheet needs `range`.
-fn sort_target(s: &Session, p: &Json) -> Result<(usize, RangeRef)> {
-    let sheet = target_sheet(s, p)?;
-    let d = s.doc()?;
-    if let Some(t) = str_param(p, "range")
-        && let (Some(name), _) = split_sheet(t)
-        && d.wb.sheet_index(&name) != Some(sheet)
-    {
-        return Err(bad("data.sort", format!("`{t}` names a sheet other than `sheet`")));
-    }
-    if sheet != d.wb.active_sheet() && p.get("range").is_none() {
-        return Err(bad("data.sort", "missing `range`: the selection is on the active sheet"));
-    }
-    Ok((sheet, data_range(s, p)?))
-}
-
-fn quick_sort(s: &mut Session, p: &Json, asc: bool) -> Result<Json> {
-    let (sheet, r) = sort_target(s, p)?;
-    let col = col_param(p.get("column"), r.start.col).unwrap_or(s.doc()?.selection.active.col).clamp(r.start.col, r.end.col);
-    let d = s.doc()?;
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let header = guess_header(&d.wb, sh, r);
-    do_sort(s, sheet, r, header, vec![SortKey { col, desc: !asc, by: "values".into(), list: None }], false, false)
-}
-
-fn sort(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, r) = sort_target(s, p)?;
-    let d = s.doc()?;
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let header = bool_param(p, "header").unwrap_or_else(|| guess_header(&d.wb, sh, r));
-    let by_cols = str_param(p, "orientation") == Some("columns");
-    let case = bool_param(p, "matchCase").unwrap_or(false);
-    let mut keys: Vec<SortKey> = Vec::new();
-    for k in p.get("keys").and_then(Json::as_array).map(Vec::as_slice).unwrap_or_default() {
-        let col = if by_cols {
-            let row = match k.get("row").and_then(Json::as_u64) {
-                // Worksheet rows are 1-based; 0 (or a value past u32) has no coordinate.
-                Some(n) => {
-                    let row = u32::try_from(n).ok().and_then(|n| n.checked_sub(1));
-                    Some(row.ok_or_else(|| bad("data.sort", "sort key row must be 1 or greater"))?)
-                }
-                None => None,
-            };
-            row.or_else(|| col_param(k.get("column"), r.start.row))
-        } else {
-            col_param(k.get("column"), r.start.col)
-        };
-        let Some(col) = col else { continue };
-        keys.push(SortKey {
-            col,
-            desc: k.get("order").and_then(Json::as_str) == Some("desc"),
-            by: k.get("by").and_then(Json::as_str).unwrap_or("values").to_string(),
-            list: k.get("customList").and_then(Json::as_array).map(|l| l.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()),
-        });
-    }
-    if keys.is_empty() {
-        s.ui_requests.push(crate::UiRequest::Dialog("sort".into(), json!({"range": r.a1(), "header": header})));
-        return ok();
-    }
-    if keys.len() > 64 {
-        return Err(bad("data.sort", "too many sort levels (64 max)"));
-    }
-    do_sort(s, sheet, r, header, keys, by_cols, case)
-}
-
-fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec<SortKey>, by_cols: bool, case: bool) -> Result<Json> {
-    // Protect Sheet ▸ Sort. Both Sort… and the A-to-Z buttons come through here.
-    super::refuse_unless_allowed(s, sheet, "Sorting", |p| p.sort)?;
-    let body = if by_cols {
-        if header && r.width() > 1 { RangeRef::new(CellRef::new(r.start.row, r.start.col + 1), r.end) } else { r }
-    } else if header && r.height() > 1 {
-        RangeRef::new(CellRef::new(r.start.row + 1, r.start.col), r.end)
-    } else {
-        r
-    };
-    if body.count() > 20_000_000 {
-        return Err(bad("data.sort", "range too large"));
-    }
-    edit(s, |cx| {
-        let Some(sh) = cx.wb.sheet(sheet) else { return Ok(Json::Null) };
-        if sh.merges.iter().any(|m| m.intersects(&body) && !m.is_single()) {
-            return Err(EngineError::Other("To do this, all the merged cells need to be the same size.".into()));
-        }
-        let n = if by_cols { body.width() } else { body.height() };
-        let line = |i: u32, k: u32| if by_cols { CellRef::new(k, body.start.col + i) } else { CellRef::new(body.start.row + i, k) };
-        let theme = cx.wb.theme.clone();
-        let styles = &cx.wb.styles;
-        let key_val = |i: u32, k: &SortKey| -> (Value, u32) {
-            let c = line(i, k.col);
-            let v = sh.value(c);
-            let color = match k.by.as_str() {
-                "cellColor" => {
-                    styles.get(sh.style_id(c)).fill.fg.resolve(&theme).map(|[r, g, b]| u32::from_be_bytes([0, r, g, b])).unwrap_or(u32::MAX)
-                }
-                "fontColor" => {
-                    styles.get(sh.style_id(c)).font.color.resolve(&theme).map(|[r, g, b]| u32::from_be_bytes([0, r, g, b])).unwrap_or(u32::MAX)
-                }
-                _ => 0,
-            };
-            (v, color)
-        };
-        let mut order: Vec<u32> = (0..n).collect();
-        let keyed: Vec<Vec<(Value, u32)>> = (0..n).map(|i| keys.iter().map(|k| key_val(i, k)).collect()).collect();
-        order.sort_by(|&a, &b| {
-            for (ki, k) in keys.iter().enumerate() {
-                let (va, ca) = &keyed[a as usize][ki];
-                let (vb, cb) = &keyed[b as usize][ki];
-                let o = if k.by != "values" {
-                    ca.cmp(cb)
-                } else if let Some(list) = &k.list {
-                    let pos = |v: &Value| v.as_text().and_then(|t| list.iter().position(|x| x.eq_ignore_ascii_case(t))).unwrap_or(usize::MAX);
-                    pos(va).cmp(&pos(vb))
-                } else if case && va.is_text() && vb.is_text() {
-                    sort_compare(va, vb).then_with(|| case_order(va.as_text().unwrap_or(""), vb.as_text().unwrap_or("")))
-                } else {
-                    sort_compare(va, vb)
-                };
-                // Blanks always sort last, whatever the order.
-                let o = if k.desc && !(va.is_empty() || vb.is_empty()) { o.reverse() } else { o };
-                if o != Ordering::Equal {
-                    return o;
-                }
-            }
-            Ordering::Equal
-        });
-        if order.iter().enumerate().all(|(i, &o)| i as u32 == o) {
-            return Ok(Json::Null);
-        }
-        // Move whole lines (cells with formulas adjusted for relative references).
-        let lanes: Vec<u32> = if by_cols { (body.start.row..=body.end.row).collect() } else { (body.start.col..=body.end.col).collect() };
-        // Notes and hyperlinks hang off a cell, not a row, so they travel with the row they
-        // describe — the way cell pictures and row heights do. Collect them before inserting,
-        // so a swap can't resurrect one from a destination that is also a source.
-        let side: Vec<(CellRef, Comment)> = order
-            .iter()
-            .enumerate()
-            .flat_map(|(dst_i, &src_i)| lanes.iter().map(move |&k| (src_i, dst_i as u32, k)))
-            .filter_map(|(src_i, dst_i, k)| sh.comments.get(&line(src_i, k)).map(|cm| (line(dst_i, k), cm.clone())))
-            .collect();
-        let links: Vec<(CellRef, Hyperlink)> = order
-            .iter()
-            .enumerate()
-            .flat_map(|(dst_i, &src_i)| lanes.iter().map(move |&k| (src_i, dst_i as u32, k)))
-            .filter_map(|(src_i, dst_i, k)| sh.hyperlinks.get(&line(src_i, k)).map(|h| (line(dst_i, k), h.clone())))
-            .collect();
-        let mut moved: Vec<(CellRef, Option<Cell>)> = Vec::with_capacity(body.count() as usize);
-        let mut pictures = Vec::new();
-        for (dst_i, &src_i) in order.iter().enumerate() {
-            for &k in &lanes {
-                let src = line(src_i, k);
-                let dst = line(dst_i as u32, k);
-                let mut cell = sh.cell(src).cloned();
-                if let Some(c) = cell.as_mut()
-                    && let Some(f) = &c.formula
-                    && let Some(e) = f.expr()
-                {
-                    let shifted = gridcraft_formula::adjust::shift_relative(e, dst.row as i64 - src.row as i64, dst.col as i64 - src.col as i64);
-                    c.formula = Some(Arc::new(Formula::from_expr(shifted)));
-                }
-                if let Some(picture) = sh.cell_pictures.get(&src) {
-                    pictures.push((dst, picture.clone()));
-                }
-                moved.push((dst, cell));
-            }
-        }
-        // Row heights travel with rows.
-        let heights: Vec<Option<LineInfo>> =
-            if by_cols { vec![] } else { order.iter().map(|&i| sh.rows.get(&(body.start.row + i)).copied()).collect() };
-        // Floating objects anchored inside the sorted body travel with their lines, unless they
-        // are pinned absolutely ("Don't move or size with cells", `editAs="absolute"`). Reordering
-        // is the inverse of `order`: `dst_of[src] = dst`.
-        let dst_of: Vec<u32> = {
-            let mut v = vec![0u32; order.len()];
-            for (dst_i, &src_i) in order.iter().enumerate() {
-                if let Some(slot) = v.get_mut(src_i as usize) {
-                    *slot = dst_i as u32;
-                }
-            }
-            v
-        };
-        // The object's own geometry (its top-left anchor cell, offset and size) is read from the
-        // pre-sort `sh`; a two-cell object's bottom-right cell is derived from its size here so it
-        // can be re-fitted to the lines it spans after the sort.
-        let objs: Vec<Anchor> =
-            sh.images.iter().map(|o| o.anchor).chain(sh.charts.iter().map(|o| o.anchor)).chain(sh.shapes.iter().map(|o| o.anchor)).collect();
-        let descs: Vec<(u32, u32, f32, f32)> = objs
-            .iter()
-            .map(|a| {
-                let x2 = sh.col_left(a.cell.col) + a.dx as f64 + a.width.max(0.0) as f64;
-                let y2 = sh.row_top(a.cell.row) + a.dy as f64 + a.height.max(0.0) as f64;
-                let tc = sh.col_at(x2);
-                let tr = sh.row_at(y2);
-                (tc, tr, (x2 - sh.col_left(tc)) as f32, (y2 - sh.row_top(tr)) as f32)
-            })
-            .collect();
-        let shm = cx.sheet_mut(sheet)?;
-        for (c, cell) in &moved {
-            match cell {
-                Some(x) => shm.set_cell(*c, x.clone()),
-                None => {
-                    shm.remove_cell(*c);
-                }
-            }
-        }
-        // Every cell of the body is the destination of exactly one source cell, so clearing the
-        // body and inserting the permuted entries is the same permutation the cells went through.
-        for c in body.iter() {
-            shm.comments.remove(&c);
-            shm.hyperlinks.remove(&c);
-        }
-        for (at, cm) in side {
-            shm.comments.insert(at, cm);
-        }
-        for (at, h) in links {
-            shm.hyperlinks.insert(at, h);
-        }
-        shm.cell_pictures.extend(pictures);
-        for (i, h) in heights.into_iter().enumerate() {
-            let row = body.start.row + i as u32;
-            match h {
-                Some(info) => {
-                    shm.rows.insert(row, LineInfo { hidden: shm.rows.get(&row).is_some_and(|x| x.hidden), ..info });
-                }
-                None => {
-                    if let Some(e) = shm.rows.get_mut(&row) {
-                        e.size = None;
-                    }
-                }
-            }
-        }
-        // Re-anchor floating objects now that the row heights are final. `objs` was collected as
-        // images ++ charts ++ shapes, so the same index maps straight onto each vec.
-        // Only objects anchored inside the sorted block move: within its lines on the sort axis
-        // and within its span on the other axis (a picture beside the block stays put).
-        let (b0, b1) = if by_cols { (body.start.col, body.end.col) } else { (body.start.row, body.end.row) };
-        let (o0, o1) = if by_cols { (body.start.row, body.end.row) } else { (body.start.col, body.end.col) };
-        let ni = shm.images.len();
-        let nch = shm.charts.len();
-        for (i, (a, desc)) in objs.into_iter().zip(descs).enumerate() {
-            let other = if by_cols { a.cell.row } else { a.cell.col };
-            if other < o0 || other > o1 {
-                continue;
-            }
-            let na = sorted_anchor(shm, a, desc, by_cols, b0, b1, &dst_of);
-            if na != a {
-                if i < ni {
-                    if let Some(o) = shm.images.get_mut(i) {
-                        o.anchor = na;
-                    }
-                } else if i < ni + nch {
-                    if let Some(o) = shm.charts.get_mut(i - ni) {
-                        o.anchor = na;
-                    }
-                } else if let Some(o) = shm.shapes.get_mut(i - ni - nch) {
-                    o.anchor = na;
-                }
-            }
-        }
-        for (c, _) in moved {
-            cx.changed.push((sheet, c));
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })?;
-    Ok(json!({"sorted": body.a1()}))
-}
-
-/// Re-anchor one floating object for a sort. `bottom` is the object's bottom-right line and the
-/// offset of that corner inside it, measured before the sort. `map` (via `dst_of`) translates a
-/// line index on the moving axis and is the identity outside `b0..=b1`. `sh` is the post-sort
-/// grid (row heights already reordered), so re-fitting uses the heights the object lands on.
-/// Objects pinned absolutely ("Don't move or size with cells") never move; "move but don't size"
-/// keeps its size; "move and size" is re-fitted when its whole extent stays inside the body.
-fn sorted_anchor(sh: &Sheet, a: Anchor, bottom: (u32, u32, f32, f32), by_cols: bool, b0: u32, b1: u32, dst_of: &[u32]) -> Anchor {
-    if a.mode == AnchorMode::Absolute {
-        return a;
-    }
-    let (tc, tr, tdx, tdy) = bottom;
-    let map = |v: u32| -> u32 { if v >= b0 && v <= b1 { dst_of.get((v - b0) as usize).map_or(v, |&d| b0 + d) } else { v } };
-    let (axis_start, axis_end) = if by_cols { (a.cell.col, tc) } else { (a.cell.row, tr) };
-    if axis_start < b0 || axis_start > b1 {
-        return a;
-    }
-    let (nr, nc) = if by_cols { (a.cell.row, map(a.cell.col)) } else { (map(a.cell.row), a.cell.col) };
-    if a.mode == AnchorMode::MoveAndSize && axis_end >= b0 && axis_end <= b1 {
-        let (nbr, nbc) = if by_cols { (tr, map(tc)) } else { (map(tr), tc) };
-        let x1 = sh.col_left(nc) + a.dx as f64;
-        let y1 = sh.row_top(nr) + a.dy as f64;
-        let x2 = sh.col_left(nbc) + tdx as f64;
-        let y2 = sh.row_top(nbr) + tdy as f64;
-        Anchor { cell: CellRef::new(nr, nc), dx: a.dx, dy: a.dy, width: (x2 - x1).max(0.0) as f32, height: (y2 - y1).max(0.0) as f32, mode: a.mode }
-    } else {
-        Anchor { cell: CellRef::new(nr, nc), ..a }
-    }
-}
-
-// ---------------------------------------------------------------- filter
-
-fn toggle_filter(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, r) = data_target(s, p, "data.filter")?;
-    super::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
-    // The active cell belongs to the active sheet: on another sheet the table is the one at `range`.
-    let at = if sheet == s.doc()?.wb.active_sheet() { s.doc()?.selection.active } else { r.start };
-    let has = s.doc()?.wb.sheet(sheet).is_some_and(|sh| sh.autofilter.is_some());
-    let in_table = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.table_at(at).map(|t| t.name.clone()));
-    if let Some(name) = in_table {
-        return edit(s, |cx| {
-            let sh = cx.sheet_mut(sheet)?;
-            if let Some(t) = sh.tables.iter_mut().find(|t| t.name == name) {
-                t.filter_button = !t.filter_button;
-                if !t.filter_button {
-                    t.filter.clear();
-                }
-            }
-            Ok(Json::Null)
-        });
-    }
-    if has {
-        return edit(s, |cx| {
-            let sh = cx.sheet_mut(sheet)?;
-            // Reveal only rows the filter hid; rows hidden by hand or by a collapsed group stay hidden.
-            let filtered: Vec<u32> = sh.rows.keys().copied().filter(|r| sh.is_row_filtered(*r)).collect();
-            sh.autofilter = None;
-            for r in filtered {
-                if let Some(info) = sh.rows.get_mut(&r) {
-                    info.hidden = false;
-                }
-            }
-            cx.structural = true;
-            Ok(json!({"filter": false}))
-        });
-    }
-    install_filter(s, p)
-}
-
-/// Turn a sheet AutoFilter on over `p.range`, or over the data range of the selection.
-fn install_filter(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, mut r) = data_target(s, p, "data.filter")?;
-    // A selected header row filters the data below it (#201).
-    if p.get("range").is_none() && r.height() == 1 {
-        let d = s.doc()?;
-        let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-        let below = current_region(sh, r.start).end.row;
-        if below > r.end.row {
-            r = RangeRef::new(r.start, CellRef::new(below, r.end.col));
-        }
-    }
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.autofilter = Some(AutoFilter { range: r, criteria: vec![] });
-        Ok(json!({"filter": true, "range": r.a1()}))
-    })
-}
-
-fn filter_by(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet();
-    super::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
-    let Some(sh) = s.doc()?.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
-    let af = match &sh.autofilter {
-        Some(a) => a.clone(),
-        None => {
-            install_filter(s, &json!({}))?;
-            s.doc()?.wb.sheet(sheet).and_then(|sh| sh.autofilter.clone()).ok_or_else(|| EngineError::Other("no filter".into()))?
-        }
-    };
-    let col = match col_param(p.get("column"), af.range.start.col) {
-        Some(c) => c,
-        // A number too large to be a column is outside the filter range, not a missing parameter.
-        None if p.get("column").is_some_and(|v| v.as_u64().is_some()) => return Err(bad("data.filterBy", "column outside the filter range")),
-        None => return Err(bad("data.filterBy", "missing `column`")),
-    };
-    if col < af.range.start.col || col > af.range.end.col {
-        return Err(bad("data.filterBy", "column outside the filter range"));
-    }
-    let off = col - af.range.start.col;
-    let crit = if bool_param(p, "clear").unwrap_or(false) {
-        None
-    } else if let Some(vals) = p.get("values").and_then(Json::as_array) {
-        Some(FilterCriterion::Values {
-            values: vals.iter().map(super::edit::json_to_input).collect(),
-            blanks: bool_param(p, "blanks").unwrap_or(false),
-        })
-    } else if let Some(c) = p.get("custom") {
-        let a = (c.get("op").and_then(Json::as_str).unwrap_or("=").to_string(), c.get("value").map(super::edit::json_to_input).unwrap_or_default());
-        let b = c.get("op2").and_then(Json::as_str).map(|o| (o.to_string(), c.get("value2").map(super::edit::json_to_input).unwrap_or_default()));
-        Some(FilterCriterion::Custom { a, b, and: c.get("and").and_then(Json::as_bool).unwrap_or(true) })
-    } else if let Some(t) = p.get("top") {
-        Some(FilterCriterion::Top10 {
-            bottom: t.get("bottom").and_then(Json::as_bool).unwrap_or(false),
-            percent: t.get("percent").and_then(Json::as_bool).unwrap_or(false),
-            count: t.get("count").and_then(Json::as_u64).unwrap_or(10) as u32,
-        })
-    } else {
-        bool_param(p, "aboveAverage").map(FilterCriterion::AboveAverage)
-    };
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        if let Some(a) = sh.autofilter.as_mut() {
-            a.criteria.retain(|(o, _)| *o != off);
-            if let Some(c) = crit.clone() {
-                a.criteria.push((off, c));
-            }
-        }
-        apply_filter(&mut cx.wb, sheet);
-        cx.structural = true;
-        Ok(Json::Null)
-    })?;
-    let hidden = s.doc()?.wb.sheet(sheet).map(|sh| sh.rows.values().filter(|r| r.hidden).count()).unwrap_or(0);
-    Ok(json!({"hiddenRows": hidden}))
-}
-
-/// Does a value pass a custom comparison (`>`, `=*abc*`, `<>x`…)?
-fn custom_ok(v: &Value, text: &str, op: &str, crit: &str) -> bool {
-    let num = gridcraft_core::parse::parse_number_text(crit);
-    let cmp = match (v.as_f64(), num) {
-        (Some(a), Some(b)) => a.partial_cmp(&b),
-        // A numeric ordering comparison only matches numbers; blanks and text never do.
-        (None, Some(_)) if matches!(op, "<" | "<=" | ">" | ">=") => None,
-        _ => Some(gridcraft_core::compare_text(text, crit)),
-    };
-    let wild = || super::edit::wildcard(&text.to_lowercase(), &crit.to_lowercase());
-    match op {
-        "=" => {
-            if crit.contains(['*', '?']) {
-                wild()
-            } else {
-                cmp == Some(Ordering::Equal)
-            }
-        }
-        "<>" => {
-            if crit.contains(['*', '?']) {
-                !wild()
-            } else {
-                cmp != Some(Ordering::Equal)
-            }
-        }
-        ">" => cmp == Some(Ordering::Greater),
-        "<" => cmp == Some(Ordering::Less),
-        ">=" => matches!(cmp, Some(Ordering::Greater | Ordering::Equal)),
-        "<=" => matches!(cmp, Some(Ordering::Less | Ordering::Equal)),
-        "beginsWith" => text.to_lowercase().starts_with(&crit.to_lowercase()),
-        "endsWith" => text.to_lowercase().ends_with(&crit.to_lowercase()),
-        "contains" => text.to_lowercase().contains(&crit.to_lowercase()),
-        "notContains" => !text.to_lowercase().contains(&crit.to_lowercase()),
-        _ => true,
-    }
-}
-
-/// The filter's "(Blanks)" group: truly empty cells and zero-length text such as a `=""` result.
-fn filter_blank(v: &Value) -> bool {
-    v.is_empty() || matches!(v, Value::Text(t) if t.is_empty())
-}
-
-/// Excel grows an AutoFilter range when a value is entered in the row right below it, in one of its columns (#2342).
-/// A table's own filter is left to the table, and a row typed after a blank row does not count.
-/// A formula counts before it is calculated: this runs inside the edit, ahead of the recalc.
-pub(crate) fn grow_autofilter(sh: &mut Sheet, at: CellRef) {
-    if !sh.cells.get(at).is_some_and(|c| !filter_blank(&c.value) || c.formula.is_some()) {
-        return;
-    }
-    let Some(af) = sh.autofilter.as_ref() else { return };
-    let r = af.range;
-    if r.end.row.checked_add(1) != Some(at.row) || at.col < r.start.col || at.col > r.end.col || sh.tables.iter().any(|t| t.range == r) {
-        return;
-    }
-    let grown = RangeRef::new(r.start, CellRef::new(at.row, r.end.col));
-    if let Some(af) = sh.autofilter.as_mut() {
-        af.range = grown;
-    }
-}
-
-/// Hides rows of the autofilter range that fail any criterion.
-pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) {
-    let Some(sh) = wb.sheet(sheet) else { return };
-    let Some(af) = sh.autofilter.clone() else { return };
-    let r = af.range;
-    let mut hide = Vec::new();
-    // Precompute per-criterion top10 threshold and average once, not per row.
-    let mut col_stats: std::collections::HashMap<usize, (Option<f64>, f64)> = std::collections::HashMap::new();
-    for (i, (off, c)) in af.criteria.iter().enumerate() {
-        if matches!(c, FilterCriterion::Top10 { .. } | FilterCriterion::AboveAverage(_)) {
-            let col = r.start.col + off;
-            let mut nums: Vec<f64> = (r.start.row + 1..=r.end.row).filter_map(|row| sh.value(CellRef::new(row, col)).as_f64()).collect();
-            let avg = if nums.is_empty() { 0.0 } else { nums.iter().sum::<f64>() / nums.len() as f64 };
-            let thr = match c {
-                FilterCriterion::Top10 { bottom, percent, count } => {
-                    nums.sort_by(|a, b| if *bottom { a.partial_cmp(b) } else { b.partial_cmp(a) }.unwrap_or(Ordering::Equal));
-                    let k = if *percent { ((nums.len() as f64) * (*count as f64) / 100.0).ceil() as usize } else { *count as usize };
-                    let k = k.clamp(1, nums.len().max(1));
-                    nums.get(k - 1).copied()
-                }
-                _ => None,
-            };
-            col_stats.insert(i, (thr, avg));
-        }
-    }
-    for row in r.start.row + 1..=r.end.row {
-        let mut visible = true;
-        for (i, (off, crit)) in af.criteria.iter().enumerate() {
-            let c = CellRef::new(row, r.start.col + off);
-            let v = sh.value(c);
-            let text = crate::display::cell_text(wb, sh, c);
-            let ok = match crit {
-                FilterCriterion::Values { values, blanks } => {
-                    if filter_blank(&v) {
-                        *blanks
-                    } else {
-                        values.iter().any(|x| x.eq_ignore_ascii_case(&text) || x.eq_ignore_ascii_case(&v.display()))
-                    }
-                }
-                FilterCriterion::Custom { a, b, and } => {
-                    let x = custom_ok(&v, &text, &a.0, &a.1);
-                    match b {
-                        Some(b) => {
-                            let y = custom_ok(&v, &text, &b.0, &b.1);
-                            if *and { x && y } else { x || y }
-                        }
-                        None => x,
-                    }
-                }
-                FilterCriterion::Top10 { bottom, .. } => match (v.as_f64(), col_stats.get(&i)) {
-                    (Some(n), Some((thr, _))) => {
-                        let thr = thr.unwrap_or(n);
-                        if *bottom { n <= thr } else { n >= thr }
-                    }
-                    _ => false,
-                },
-                FilterCriterion::AboveAverage(above) => match (v.as_f64(), col_stats.get(&i)) {
-                    (Some(n), Some((_, avg))) => {
-                        if *above {
-                            n > *avg
-                        } else {
-                            n < *avg
-                        }
-                    }
-                    _ => false,
-                },
-                FilterCriterion::FillColor(col) => wb.styles.get(sh.style_id(c)).fill.fg == *col,
-                FilterCriterion::FontColor(col) => wb.styles.get(sh.style_id(c)).font.color == *col,
-                // Icons are not evaluated here: the row keeps its current visibility.
-                FilterCriterion::Icon { .. } => !sh.is_row_hidden(row),
-            };
-            if !ok {
-                visible = false;
-                break;
-            }
-        }
-        hide.push((row, !visible));
-    }
-    let Some(shm) = wb.sheet_mut(sheet) else { return };
-    for (row, h) in hide {
-        if h {
-            shm.rows.entry(row).or_default().hidden = true;
-        } else if let Some(e) = shm.rows.get_mut(&row) {
-            e.hidden = false;
-        }
-    }
-}
-
-fn clear_filter(s: &mut Session, _: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        if let Some(a) = sh.autofilter.as_mut() {
-            a.criteria.clear();
-        }
-        apply_filter(&mut cx.wb, sheet);
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-fn reapply(s: &mut Session, _: &Json) -> Result<Json> {
-    let sheet = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        apply_filter(&mut cx.wb, sheet);
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-/// Distinct display values of a filter column (for the dropdown list).
-pub fn filter_values(wb: &Workbook, sheet: usize, col: u32) -> Vec<(String, bool)> {
-    let Some(sh) = wb.sheet(sheet) else { return vec![] };
-    let Some(af) = &sh.autofilter else { return vec![] };
-    let off = col.saturating_sub(af.range.start.col);
-    let selected: Option<&FilterCriterion> = af.criteria.iter().find(|(o, _)| *o == off).map(|(_, c)| c);
-    let mut seen = std::collections::BTreeMap::new();
-    for row in af.range.start.row + 1..=af.range.end.row.min(af.range.start.row + 1_000_000) {
-        let c = CellRef::new(row, col);
-        let v = sh.value(c);
-        let blank = filter_blank(&v);
-        let t = if blank { "(Blanks)".to_string() } else { crate::display::cell_text(wb, sh, c) };
-        let on = match selected {
-            Some(FilterCriterion::Values { values, blanks }) => {
-                if blank {
-                    *blanks
-                } else {
-                    values.iter().any(|x| x.eq_ignore_ascii_case(&t))
-                }
-            }
-            _ => true,
-        };
-        let key = if blank { sort_key(&Value::Empty) } else { sort_key(&v) };
-        seen.entry((key, t)).or_insert(on);
-    }
-    seen.into_iter().map(|((_, t), on)| (t, on)).collect()
-}
-
-/// Case-sensitive tie-break for text that is equal ignoring case: as in Excel, lowercase sorts
-/// before uppercase at the first letter that differs in case.
-fn case_order(a: &str, b: &str) -> Ordering {
-    a.chars().zip(b.chars()).find(|(x, y)| x != y).map_or(Ordering::Equal, |(x, y)| y.is_lowercase().cmp(&x.is_lowercase()))
-}
-
-fn sort_key(v: &Value) -> (u8, i64, String) {
-    match v {
-        Value::Number(n) => (0, (n * 1e6) as i64, String::new()),
-        Value::Text(t) => (1, 0, t.to_lowercase()),
-        Value::Bool(b) => (2, *b as i64, String::new()),
-        Value::Empty => (9, 0, String::new()),
-        _ => (3, 0, v.display()),
-    }
-}
-
-// ---------------------------------------------------------------- tools
-
-fn remove_duplicates(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, r) = data_target(s, p, "data.removeDuplicates")?;
-    let d = s.doc()?;
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    // Rows and columns past the data are blank: only the part with data is compared (whole
-    // columns compared a million blank rows and reported them as removed duplicates).
-    let r = sh.used_range().and_then(|u| r.intersection(&u)).unwrap_or(RangeRef::cell(r.start));
-    let header = bool_param(p, "header").unwrap_or_else(|| guess_header(&d.wb, sh, r));
-    let cols: Vec<u32> = p
-        .get("columns")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().filter_map(|c| col_param(Some(c), r.start.col)).collect())
-        .unwrap_or_else(|| (r.start.col..=r.end.col).collect());
-    // With no column to compare, every row key is empty: the first row would survive and every
-    // other row would be deleted as a duplicate. A column outside the range compares data the
-    // user didn't select. Excel refuses both.
-    if cols.is_empty() || cols.iter().any(|c| !(r.start.col..=r.end.col).contains(c)) {
-        return Err(bad("data.removeDuplicates", "`columns` must name at least one column of the range"));
-    }
-    let start = r.start.row + header as u32;
-    let mut removed = 0;
-    edit(s, |cx| {
-        let Some(sh) = cx.wb.sheet(sheet) else { return Ok(()) };
-        let mut seen = std::collections::HashSet::new();
-        let mut keep: Vec<u32> = Vec::new();
-        // Cells are compared by the text they show, as in Excel: the same date in two formats
-        // isn't a duplicate, while 1.01 and 1.02 shown as 1.0 are.
-        let shown = |c: CellRef| crate::display::format(&sh.value(c), cx.wb.styles.get(sh.style_id(c)).num_fmt.as_str(), &cx.wb).text;
-        for row in start..=r.end.row {
-            let key: Vec<String> = cols.iter().map(|c| shown(CellRef::new(row, *c)).to_lowercase()).collect();
-            if seen.insert(key) {
-                keep.push(row);
-            } else {
-                removed += 1;
-            }
-        }
-        let pictures: Vec<_> = keep
-            .iter()
-            .enumerate()
-            .flat_map(|(i, row)| {
-                (r.start.col..=r.end.col)
-                    .filter_map(move |col| sh.cell_pictures.get(&CellRef::new(*row, col)).map(|p| (CellRef::new(start + i as u32, col), p.clone())))
-            })
-            .collect();
-        // Rows a filter keeps are compacted to `start + i`, so the notes and hyperlinks that
-        // describe them move with them; the ones on removed rows are dropped with the row.
-        let notes: Vec<_> = keep
-            .iter()
-            .enumerate()
-            .flat_map(|(i, row)| {
-                (r.start.col..=r.end.col)
-                    .filter_map(move |col| sh.comments.get(&CellRef::new(*row, col)).map(|cm| (CellRef::new(start + i as u32, col), cm.clone())))
-            })
-            .collect();
-        let links: Vec<_> = keep
-            .iter()
-            .enumerate()
-            .flat_map(|(i, row)| {
-                (r.start.col..=r.end.col)
-                    .filter_map(move |col| sh.hyperlinks.get(&CellRef::new(*row, col)).map(|h| (CellRef::new(start + i as u32, col), h.clone())))
-            })
-            .collect();
-        let rows: Vec<Vec<Option<Cell>>> =
-            keep.iter().map(|row| (r.start.col..=r.end.col).map(|c| sh.cell(CellRef::new(*row, c)).cloned()).collect()).collect();
-        let shm = cx.sheet_mut(sheet)?;
-        for row in start..=r.end.row {
-            for c in r.start.col..=r.end.col {
-                shm.remove_cell(CellRef::new(row, c));
-            }
-        }
-        for row in start..=r.end.row {
-            for c in r.start.col..=r.end.col {
-                let at = CellRef::new(row, c);
-                shm.comments.remove(&at);
-                shm.hyperlinks.remove(&at);
-            }
-        }
-        for (i, cells) in rows.into_iter().enumerate() {
-            for (j, cell) in cells.into_iter().enumerate() {
-                if let Some(cell) = cell {
-                    shm.set_cell(CellRef::new(start + i as u32, r.start.col + j as u32), cell);
-                }
-            }
-        }
-        shm.cell_pictures.extend(pictures);
-        for (at, cm) in notes {
-            shm.comments.insert(at, cm);
-        }
-        for (at, h) in links {
-            shm.hyperlinks.insert(at, h);
-        }
-        for c in RangeRef::new(CellRef::new(start, r.start.col), r.end).iter() {
-            cx.changed.push((sheet, c));
-        }
-        Ok(())
-    })?;
-    let remaining = (r.end.row + 1 - start) as usize - removed;
-    Ok(json!({"removed": removed, "remaining": remaining}))
-}
-
-fn text_to_columns(s: &mut Session, p: &Json) -> Result<Json> {
-    let r = target_range(s, p)?;
-    let sheet = target_sheet(s, p)?;
-    let mut delims: Vec<char> = p
-        .get("delimiters")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().filter_map(|d| d.as_str().and_then(|x| x.chars().next())).collect())
-        .unwrap_or_else(|| vec!['\t']);
-    if let Some(o) = str_param(p, "other").and_then(|o| o.chars().next()) {
-        delims.push(o);
-    }
-    let fixed: Option<Vec<usize>> =
-        p.get("fixedWidths").and_then(Json::as_array).map(|a| a.iter().filter_map(|x| x.as_u64().map(|v| v as usize)).collect());
-    let consecutive = bool_param(p, "treatConsecutive").unwrap_or(false);
-    let quote = str_param(p, "textQualifier").and_then(|q| q.chars().next()).unwrap_or('"');
-    let dest = cell_param_on(s, p, "destination", sheet)?.unwrap_or(r.start);
-    edit(s, |cx| {
-        let Some(sh) = cx.wb.sheet(sheet) else { return Ok(()) };
-        let mut out: Vec<(CellRef, String)> = Vec::new();
-        for (i, row) in (r.start.row..=r.end.row).enumerate() {
-            let text = sh.value(CellRef::new(row, r.start.col)).display();
-            let parts: Vec<String> = match &fixed {
-                Some(w) => {
-                    let chars: Vec<char> = text.chars().collect();
-                    let mut cuts = vec![0];
-                    let mut breaks: Vec<usize> = w.iter().copied().filter(|x| *x > 0 && *x < chars.len()).collect();
-                    breaks.sort_unstable();
-                    breaks.dedup();
-                    cuts.extend(breaks);
-                    cuts.push(chars.len());
-                    cuts.windows(2)
-                        .map(|p| chars.get(p[0]..p[1]).map(|s| s.iter().collect::<String>().trim().to_string()).unwrap_or_default())
-                        .collect()
-                }
-                None => split_delimited(&text, &delims, consecutive, quote),
-            };
-            for (j, part) in parts.into_iter().enumerate() {
-                out.push((CellRef::new(dest.row + i as u32, dest.col + j as u32), part));
-            }
-        }
-        for (c, t) in out {
-            let cell = super::edit::input_to_cell(&t, sheet, c, &mut cx.wb).unwrap_or(None);
-            let shm = cx.sheet_mut(sheet)?;
-            match cell {
-                Some(x) => shm.set_cell(c, x),
-                None => {
-                    shm.remove_cell(c);
-                }
-            }
-            cx.changed.push((sheet, c));
-        }
-        Ok(())
-    })?;
-    ok()
-}
-
-fn split_delimited(text: &str, delims: &[char], consecutive: bool, quote: char) -> Vec<String> {
-    let mut out = Vec::new();
-    let mut cur = String::new();
-    let mut in_q = false;
-    let mut last_delim = false;
-    let mut chars = text.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c == quote {
-            if in_q && chars.peek() == Some(&quote) {
-                cur.push(quote);
-                chars.next();
-            } else {
-                in_q = !in_q;
-            }
-            continue;
-        }
-        if !in_q && delims.contains(&c) {
-            if consecutive && last_delim {
-                continue;
-            }
-            out.push(std::mem::take(&mut cur));
-            last_delim = true;
-            continue;
-        }
-        last_delim = false;
-        cur.push(c);
-    }
-    out.push(cur);
-    out
-}
-
-// ---------------------------------------------------------------- validation
-
-fn op_param(s: Option<&str>) -> CfOperator {
-    match s.unwrap_or("between") {
-        "notBetween" => CfOperator::NotBetween,
-        "equal" => CfOperator::Equal,
-        "notEqual" => CfOperator::NotEqual,
-        "greater" | "greaterThan" => CfOperator::Greater,
-        "less" | "lessThan" => CfOperator::Less,
-        "greaterOrEqual" | "greaterThanOrEqual" => CfOperator::GreaterOrEqual,
-        "lessOrEqual" | "lessThanOrEqual" => CfOperator::LessOrEqual,
-        _ => CfOperator::Between,
-    }
-}
-
-/// `r` minus `cut`, as up to four non-overlapping rectangles.
-fn subtract_range(r: RangeRef, cut: &RangeRef) -> Vec<RangeRef> {
-    let Some(i) = r.intersection(cut) else { return vec![r] };
-    let mut out = Vec::new();
-    if i.start.row > r.start.row {
-        out.push(RangeRef::new(r.start, CellRef::new(i.start.row - 1, r.end.col)));
-    }
-    if i.end.row < r.end.row {
-        out.push(RangeRef::new(CellRef::new(i.end.row + 1, r.start.col), r.end));
-    }
-    if i.start.col > r.start.col {
-        out.push(RangeRef::new(CellRef::new(i.start.row, r.start.col), CellRef::new(i.end.row, i.start.col - 1)));
-    }
-    if i.end.col < r.end.col {
-        out.push(RangeRef::new(CellRef::new(i.start.row, i.end.col + 1), CellRef::new(i.end.row, r.end.col)));
-    }
-    out
-}
-
-/// Removes the cells of `cuts` from every validation, keeping the rest of each rule's ranges.
-pub(super) fn remove_validation_cells(validations: &mut Vec<Validation>, cuts: &[RangeRef]) {
-    for dv in validations.iter_mut() {
-        for cut in cuts {
-            dv.ranges = dv.ranges.iter().flat_map(|r| subtract_range(*r, cut)).collect();
-        }
-    }
-    validations.retain(|d| !d.ranges.is_empty());
-}
-
-fn validation(s: &mut Session, p: &Json) -> Result<Json> {
-    let ranges = target_ranges(s, p)?;
-    let sheet = target_sheet(s, p)?;
-    if bool_param(p, "clear").unwrap_or(false) {
-        return edit(s, |cx| {
-            let sh = cx.sheet_mut(sheet)?;
-            remove_validation_cells(&mut sh.validations, &ranges);
-            Ok(Json::Null)
-        });
-    }
-    let Some(kind) = str_param(p, "type") else {
-        s.ui_requests.push(crate::UiRequest::Dialog("dataValidation".into(), json!({})));
-        return ok();
-    };
-    let kind = match kind {
-        "whole" => ValidationKind::Whole,
-        "decimal" => ValidationKind::Decimal,
-        "list" => ValidationKind::List,
-        "date" => ValidationKind::Date,
-        "time" => ValidationKind::Time,
-        "textLength" => ValidationKind::TextLength,
-        "custom" => ValidationKind::Custom,
-        "any" => ValidationKind::Any,
-        // An unknown type used to give an "any value" rule, saved as `type="none"`: no validation.
-        other => return Err(bad("data.validation", format!("unknown type `{other}` (any, whole, decimal, list, date, time, textLength, custom)"))),
-    };
-    if kind == ValidationKind::List && str_param(p, "formula1").is_none_or(|f| f.trim().trim_start_matches('=').is_empty()) {
-        return Err(bad("data.validation", "a list validation needs `formula1`"));
-    }
-    const OPERATORS: [&str; 12] = [
-        "between",
-        "notBetween",
-        "equal",
-        "notEqual",
-        "greater",
-        "greaterThan",
-        "less",
-        "lessThan",
-        "greaterOrEqual",
-        "greaterThanOrEqual",
-        "lessOrEqual",
-        "lessThanOrEqual",
-    ];
-    if let Some(op) = str_param(p, "operator").filter(|op| !OPERATORS.contains(op)) {
-        return Err(bad("data.validation", format!("unknown operator `{op}` ({})", OPERATORS.join(", "))));
-    }
-    let error_style = match str_param(p, "errorStyle") {
-        None | Some("stop") => ErrorStyle::Stop,
-        Some("warning") => ErrorStyle::Warning,
-        Some("information") => ErrorStyle::Information,
-        Some(other) => return Err(bad("data.validation", format!("unknown errorStyle `{other}` (stop, warning, information)"))),
-    };
-    let f1 = str_param(p, "formula1").unwrap_or("");
-    let f1 = if kind == ValidationKind::List { list_source(f1) } else { f1.trim_start_matches('=').to_string() };
-    let dv = Validation {
-        ranges: ranges.clone(),
-        kind,
-        op: op_param(str_param(p, "operator")),
-        f1,
-        f2: str_param(p, "formula2").map(|f| f.trim_start_matches('=').to_string()),
-        allow_blank: bool_param(p, "ignoreBlank").unwrap_or(true),
-        in_cell_dropdown: bool_param(p, "dropdown").unwrap_or(true),
-        input_title: str_param(p, "inputTitle").unwrap_or("").into(),
-        input_message: str_param(p, "inputMessage").unwrap_or("").into(),
-        show_input: true,
-        error_title: str_param(p, "errorTitle").unwrap_or("").into(),
-        error_message: str_param(p, "errorMessage").unwrap_or("").into(),
-        error_style,
-        show_error: true,
-    };
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(sheet)?;
-        remove_validation_cells(&mut sh.validations, &ranges);
-        sh.validations.push(dv.clone());
-        Ok(Json::Null)
-    })
-}
-
-/// Whether a list rule's source is a literal list (`"a,b"`, or `a,b` typed without quotes) rather
-/// than a reference or a name to evaluate.
-fn is_literal_list(f: &str) -> bool {
-    f.starts_with('"')
-        || (!f.contains('!')
-            && gridcraft_formula::parse(f).map(|e| !matches!(e, gridcraft_formula::Expr::Ref(_) | gridcraft_formula::Expr::Name(_))).unwrap_or(true))
-}
-
-/// A list rule's source as a file stores it. A literal list typed without quotes, as in Excel's
-/// Source box (`Open,In progress,Closed`), becomes the quoted string Excel saves
-/// (`"Open,In progress,Closed"`, inner quotes doubled); unquoted, the file would read it as a
-/// formula. A formula (`=…`), a reference, a name or an already quoted list is kept as before.
-fn list_source(f: &str) -> String {
-    let t = f.trim();
-    if t.is_empty() || t.starts_with('=') || t.starts_with('"') || !is_literal_list(t) {
-        return f.trim_start_matches('=').to_string();
-    }
-    format!("\"{}\"", t.replace('"', "\"\""))
-}
-
-/// List entries of a list validation (literal or from a range).
-pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec<String> {
-    let f = dv.f1.trim();
-    if is_literal_list(f) {
-        // A quoted list is a string literal: `""` inside stands for one `"`.
-        let items = match f.strip_prefix('"').and_then(|x| x.strip_suffix('"')) {
-            Some(body) => body.replace("\"\"", "\""),
-            None => f.trim_matches('"').to_string(),
-        };
-        return items.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect();
-    }
-    let at = dv.ranges.first().map(|r| r.start).unwrap_or_default();
-    match gridcraft_calc::evaluate(wb, sheet, at, f) {
-        Value::Array(a) => a.data.iter().filter(|v| !v.is_empty()).map(Value::display).collect(),
-        v if !v.is_empty() && !v.is_error() => vec![v.display()],
-        _ => vec![],
-    }
-}
-
-/// Checks typed input against the validation of a cell. `Ok(None)` = valid.
-pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) -> Option<(Validation, String)> {
-    let sh = wb.sheet(sheet)?;
-    let dv = sh.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(at)))?;
-    if dv.kind == ValidationKind::Any || !dv.show_error {
-        return None;
-    }
-    if input.is_empty() && dv.allow_blank {
-        return None;
-    }
-    let v = gridcraft_core::parse::parse_input(input, wb.date_system).value;
-    // The formulas are written for the first cell of the range and see the value being entered,
-    // as in Excel (a custom `=A1>10` on A1:A9 checks A5's new value at A5).
-    let first = dv.ranges.first().map(|r| r.start).unwrap_or(at);
-    let entered;
-    let wb = if sh.value(at) == v {
-        wb
-    } else {
-        let mut w = wb.clone();
-        if let Some(sh) = w.sheet_mut(sheet) {
-            let style = sh.style_id(at);
-            sh.cells.set(at, Cell { value: v.clone(), style, ..Default::default() });
-        }
-        entered = w;
-        &entered
-    };
-    let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at));
-    let num = |f: &str| eval(f).to_number().ok();
-    let ok = match dv.kind {
-        ValidationKind::List => list_items(wb, sheet, dv).iter().any(|x| x.eq_ignore_ascii_case(input)),
-        ValidationKind::Custom => eval(&dv.f1).to_bool().unwrap_or(false),
-        ValidationKind::TextLength => {
-            let n = input.chars().count() as f64;
-            compare_op(dv.op, n, num(&dv.f1), dv.f2.as_deref().and_then(num))
-        }
-        _ => match v.as_f64() {
-            Some(n) => {
-                if dv.kind == ValidationKind::Whole && n.fract() != 0.0 {
-                    false
-                } else {
-                    compare_op(dv.op, n, num(&dv.f1), dv.f2.as_deref().and_then(num))
-                }
-            }
-            None => false,
-        },
-    };
-    if ok {
-        return None;
-    }
-    let msg = if dv.error_message.is_empty() {
-        "This value doesn't match the data validation restrictions defined for this cell.".to_string()
-    } else {
-        dv.error_message.clone()
-    };
-    Some((dv.clone(), msg))
-}
-
-/// A formula written for `first`, as seen from `at` (relative references shifted).
-fn formula_at(f: &str, first: CellRef, at: CellRef) -> String {
-    if first == at {
-        return f.to_string();
-    }
-    match gridcraft_formula::parse(f.trim_start_matches('=')) {
-        Ok(e) => gridcraft_formula::print(&gridcraft_formula::adjust::shift_relative(
-            e,
-            at.row as i64 - first.row as i64,
-            at.col as i64 - first.col as i64,
-        )),
-        Err(_) => f.to_string(),
-    }
-}
-
-/// Moves the relative references of a rule formula written for `first` so it reads the same cells from `to`
-/// (pasting a rule); text without relative references (constants, literal lists) stays as typed.
-pub(super) fn move_rule_formula(f: &str, first: CellRef, to: CellRef) -> String {
-    if first == to {
-        return f.to_string();
-    }
-    let moved = formula_at(f, first, to);
-    let has_relative = gridcraft_formula::parse(f.trim_start_matches('=')).is_ok_and(|e| gridcraft_formula::print(&e) != moved);
-    let eq = if f.starts_with('=') { "=" } else { "" };
-    if has_relative { format!("{eq}{moved}") } else { f.to_string() }
-}
-
-fn compare_op(op: CfOperator, n: f64, a: Option<f64>, b: Option<f64>) -> bool {
-    let Some(a) = a else { return false };
-    match op {
-        CfOperator::Between => b.is_some_and(|b| n >= a.min(b) && n <= a.max(b)),
-        CfOperator::NotBetween => b.is_some_and(|b| n < a.min(b) || n > a.max(b)),
-        CfOperator::Equal => n == a,
-        CfOperator::NotEqual => n != a,
-        CfOperator::Greater => n > a,
-        CfOperator::Less => n < a,
-        CfOperator::GreaterOrEqual => n >= a,
-        CfOperator::LessOrEqual => n <= a,
-    }
-}
-
-fn validate_cmd(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
-    let input = str_param(p, "input").unwrap_or("");
-    match check_validation(&d.wb, d.wb.active_sheet(), at, input) {
-        None => Ok(json!({"ok": true})),
-        Some((dv, msg)) => Ok(json!({"ok": false, "message": msg, "title": dv.error_title, "style": format!("{:?}", dv.error_style)})),
-    }
-}
-
-fn circle_invalid(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let sheet = d.wb.active_sheet();
-    let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
-    let mut bad_cells = Vec::new();
-    for dv in &sh.validations {
-        for r in &dv.ranges {
-            let r = sh.used_range().and_then(|u| r.intersection(&u));
-            let Some(r) = r else { continue };
-            for c in r.iter().take(100_000) {
-                let text = sh.input_text(c);
-                if !text.is_empty() && check_validation(&d.wb, sheet, c, &text).is_some() {
-                    bad_cells.push(c.a1());
-                }
-            }
-        }
-    }
-    Ok(json!({"invalid": bad_cells}))
-}
-
-// ---------------------------------------------------------------- outline
-
-fn outline_lines(s: &Session, p: &Json) -> Result<(bool, u32, u32)> {
-    if let Some(r) = str_param(p, "rows").and_then(parse_lines) {
-        return Ok((true, r.start.row, r.end.row));
-    }
-    if let Some(r) = str_param(p, "cols").and_then(parse_lines) {
-        return Ok((false, r.start.col, r.end.col));
-    }
-    let r = s.doc()?.selection.current();
-    match str_param(p, "by") {
-        Some("rows") => Ok((true, r.start.row, r.end.row)),
-        Some("cols" | "columns") => Ok((false, r.start.col, r.end.col)),
-        _ if r.is_full_cols() && !r.is_full_rows() => Ok((false, r.start.col, r.end.col)),
-        _ => Ok((true, r.start.row, r.end.row)),
-    }
-}
-
-fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
-    let si = target_sheet(s, p)?;
-    // The selection belongs to the active sheet, so another sheet needs its lines.
-    if si != s.doc()?.wb.active_sheet() && p.get("rows").is_none() && p.get("cols").is_none() {
-        return Err(bad(if on { "data.group" } else { "data.ungroup" }, "missing `rows` or `cols`: the selection is on the active sheet"));
-    }
-    let (rows, a, b) = outline_lines(s, p)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        let before = outline::summary_before(sh, rows);
-        let map = if rows { &mut sh.rows } else { &mut sh.cols };
-        let b = b.min(a.saturating_add(1_048_575));
-        for i in a..=b {
-            let e = map.entry(i).or_default();
-            e.outline = if on { (e.outline + 1).min(outline::MAX_LEVEL) } else { e.outline.saturating_sub(1) };
-            if !on && e.outline == 0 {
-                e.hidden = false;
-            }
-        }
-        // A summary line whose group is gone has nothing left to collapse.
-        let summary = if before { a.checked_sub(1) } else { b.checked_add(1) };
-        if !on
-            && !outline::groups_with(map, before).iter().any(|g| if before { g.start == a } else { g.end == b })
-            && let Some(e) = summary.and_then(|i| map.get_mut(&i))
-        {
-            e.collapsed = false;
-        }
-        cx.structural = true; // ungrouping reveals hidden rows: SUBTOTAL(10x) depends on it
-        Ok(Json::Null)
-    })
-}
-
-/// Hide Detail / Show Detail: the innermost group (or the one at `level`) that holds the lines, or
-/// failing that the one they are the summary of. Hiding marks the summary line collapsed (the
-/// + button, saved to XLSX); showing keeps inner groups that were collapsed on their own collapsed.
-fn detail(s: &mut Session, p: &Json, hide: bool) -> Result<Json> {
-    let (rows, a, b) = outline_lines(s, p)?;
-    let want = p.get("level").and_then(Json::as_u64).map(|l| l.min(outline::MAX_LEVEL as u64) as u8);
-    edit(s, |cx| {
-        let si = cx.sheet_index();
-        let sh = cx.sheet_mut(si)?;
-        let before = outline::summary_before(sh, rows);
-        let map = if rows { &mut sh.rows } else { &mut sh.cols };
-        let all = outline::groups_with(map, before);
-        let level_ok = |g: &outline::OutlineGroup| want.is_none_or(|l| g.level == l);
-        let pick = |hit: &dyn Fn(&outline::OutlineGroup) -> bool| -> Vec<outline::OutlineGroup> {
-            let hits: Vec<_> = all.iter().filter(|g| level_ok(g) && hit(g)).copied().collect();
-            let deepest = hits.iter().map(|g| g.level).max().unwrap_or(0);
-            hits.into_iter().filter(|g| g.level == deepest).collect()
-        };
-        let mut chosen = pick(&|g| g.start <= b && g.end >= a);
-        if chosen.is_empty() {
-            chosen = pick(&|g| g.has_summary() && g.summary() >= a && g.summary() <= b);
-        }
-        for g in chosen {
-            // Inner groups collapsed on their own (their summary marked), before this one changes.
-            let inner: Vec<outline::OutlineGroup> = all
-                .iter()
-                .filter(|o| o.level > g.level && o.start >= g.start && o.end <= g.end && o.has_summary() && o.summary() != g.summary())
-                .filter(|o| map.get(&o.summary()).is_some_and(|e| e.collapsed))
-                .copied()
-                .collect();
-            for i in g.start..=g.end {
-                if let Some(e) = map.get_mut(&i) {
-                    set_hidden(e, hide || inner.iter().any(|o| o.contains(i)));
-                }
-            }
-            if !g.has_summary() {
-                continue;
-            }
-            if hide {
-                map.entry(g.summary()).or_default().collapsed = true;
-            } else if let Some(e) = map.get_mut(&g.summary()) {
-                e.collapsed = false;
-            }
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-/// Hides or shows an outline line. A line shown with a zero size (files that hide columns as
-/// `width="0" hidden="1"`) gets the default size back, as Unhide does; otherwise + would mark the
-/// group expanded and leave it invisible (#1714).
-fn set_hidden(e: &mut LineInfo, hidden: bool) {
-    e.hidden = hidden;
-    if !hidden && e.size == Some(0.0) {
-        e.size = None;
-    }
-}
-
-/// The outline's level buttons: show rows / columns down to outline level `n` (1 = only the
-/// top-level summaries); deeper detail is hidden and its summary lines marked collapsed.
-fn show_levels(s: &mut Session, p: &Json) -> Result<Json> {
-    let level = |k: &str| p.get(k).and_then(Json::as_u64).map(|n| n.clamp(1, outline::MAX_LEVEL as u64 + 1) as u8);
-    let (rows, cols) = (level("rows"), level("cols"));
-    if rows.is_none() && cols.is_none() {
-        return Err(EngineError::BadParams {
-            cmd: "data.showLevels".into(),
-            msg: "give `rows` or `cols`: the outline level to show (1 = top-level summaries only)".into(),
-        });
-    }
-    edit(s, |cx| {
-        let si = cx.sheet_index();
-        let sh = cx.sheet_mut(si)?;
-        let before = (outline::summary_before(sh, true), outline::summary_before(sh, false));
-        for (map, n, before) in [(&mut sh.rows, rows, before.0), (&mut sh.cols, cols, before.1)] {
-            let Some(n) = n else { continue };
-            let groups = outline::groups_with(map, before);
-            for e in map.values_mut().filter(|e| e.outline > 0) {
-                set_hidden(e, e.outline >= n);
-            }
-            // Inner groups come first, so a summary line shared with the group around it ends up
-            // as that outer group says.
-            for g in groups.into_iter().filter(|g| g.has_summary()) {
-                map.entry(g.summary()).or_default().collapsed = g.level >= n;
-            }
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-/// Data ▸ Outline ▸ Settings: whether summary rows sit below their detail and summary columns
-/// right of it. A changed direction moves each collapsed group's mark (+) to its new summary line.
-/// Moves the collapsed marks of a line axis to the summary line on its new side (`on` is the new
-/// setting, `was_before` the old one). A line that nested groups share keeps its mark on the outermost
-/// group whose detail is all hidden, or the outermost when none is.
-fn move_marks(map: &mut std::collections::BTreeMap<u32, LineInfo>, was_before: bool, on: bool) {
-    let mut marked: Vec<outline::OutlineGroup> =
-        outline::groups_with(map, was_before).into_iter().filter(|g| g.has_summary() && map.get(&g.summary()).is_some_and(|e| e.collapsed)).collect();
-    // A mark on a line that nested groups share moves with the outermost of them whose
-    // detail is all hidden, or with the outermost when none is.
-    let mut owner: std::collections::BTreeMap<u32, (bool, u8)> = std::collections::BTreeMap::new();
-    for g in &marked {
-        let key = (!g.collapsed, g.level);
-        let best = owner.entry(g.summary()).or_insert(key);
-        *best = (*best).min(key);
-    }
-    marked.retain(|g| owner.get(&g.summary()) == Some(&(!g.collapsed, g.level)));
-    for g in &marked {
-        if let Some(e) = map.get_mut(&g.summary()) {
-            e.collapsed = false;
-        }
-    }
-    for g in marked {
-        let g = outline::OutlineGroup { summary_before: !on, ..g };
-        if g.has_summary() {
-            map.entry(g.summary()).or_default().collapsed = true;
-        }
-    }
-}
-
-fn outline_settings(s: &mut Session, p: &Json) -> Result<Json> {
-    let si = target_sheet(s, p)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        for (rows, key) in [(true, "summaryBelow"), (false, "summaryRight")] {
-            let Some(on) = bool_param(p, key) else { continue };
-            let was_before = outline::summary_before(sh, rows);
-            if rows {
-                sh.summary_below = on;
-            } else {
-                sh.summary_right = on;
-            }
-            if was_before != on {
-                continue;
-            }
-            move_marks(if rows { &mut sh.rows } else { &mut sh.cols }, was_before, on);
-        }
-        Ok(json!({"summaryBelow": sh.summary_below, "summaryRight": sh.summary_right}))
-    })
-}
-
-fn subtotal(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, r) = data_target(s, p, "data.subtotal")?;
-    let header = bool_param(p, "header").unwrap_or(true);
-    let group_col = col_param(p.get("groupBy"), r.start.col).unwrap_or(r.start.col);
-    let func = str_param(p, "function").unwrap_or("sum");
-    let code = match func {
-        "count" => 3,
-        "average" => 1,
-        "max" => 4,
-        "min" => 5,
-        "product" => 6,
-        _ => 9,
-    };
-    let cols: Vec<u32> = p
-        .get("columns")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().filter_map(|c| col_param(Some(c), r.start.col)).collect())
-        .unwrap_or_else(|| vec![r.end.col]);
-    let label = match func {
-        "count" => "Count",
-        "average" => "Average",
-        "max" => "Max",
-        "min" => "Min",
-        "product" => "Product",
-        _ => "Total",
-    };
-    // Group boundaries (header in the first row).
-    let d = s.doc()?;
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let mut groups: Vec<(u32, u32, String)> = Vec::new();
-    let first = r.start.row + u32::from(header);
-    let mut start = first;
-    for row in first..=r.end.row + 1 {
-        let cur = sh.value(CellRef::new(row, group_col)).display();
-        let prev = sh.value(CellRef::new(start, group_col)).display();
-        if row > r.end.row || cur != prev {
-            groups.push((start, row - 1, prev));
-            start = row;
-        }
-    }
-    // The totals go below each group, so the outline puts summary rows below their detail (the
-    // Subtotal dialog's "Summary below data"), in the same undo step.
-    if !sh.summary_below {
-        s.execute("data.outlineSettings", json!({"sheet": sheet, "summaryBelow": true}))?;
-    }
-    // Insert a total row after each group, bottom-up so indices stay valid.
-    let mut inserted = 0;
-    for (g0, g1, name) in groups.iter().rev() {
-        s.execute("home.insertRows", json!({"sheet": sheet, "rows": format!("{}:{}", g1 + 2, g1 + 2)}))?;
-        let row = g1 + 1;
-        let lbl = CellRef::new(row, group_col).a1();
-        s.execute("cell.set", json!({"sheet": sheet, "cell": lbl, "input": format!("{name} {label}")}))?;
-        for c in &cols {
-            let range = RangeRef::new(CellRef::new(*g0, *c), CellRef::new(*g1, *c)).a1();
-            s.execute("cell.set", json!({"sheet": sheet, "cell": CellRef::new(row, *c).a1(), "input": format!("=SUBTOTAL({code},{range})")}))?;
-        }
-        s.execute(
-            "home.bold",
-            json!({"sheet": sheet, "range": RangeRef::new(CellRef::new(row, r.start.col), CellRef::new(row, r.end.col)).a1(), "on": true}),
-        )?;
-        s.execute("data.group", json!({"sheet": sheet, "rows": format!("{}:{}", g0 + 1, g1 + 1)}))?;
-        inserted += 1;
-    }
-    let last = r.end.row + inserted + 1;
-    let lbl = CellRef::new(last, group_col).a1();
-    s.execute("home.insertRows", json!({"sheet": sheet, "rows": format!("{}:{}", last + 1, last + 1)}))?;
-    s.execute("cell.set", json!({"sheet": sheet, "cell": lbl, "input": format!("Grand {label}")}))?;
-    for c in &cols {
-        let range = RangeRef::new(CellRef::new(first, *c), CellRef::new(last - 1, *c)).a1();
-        s.execute("cell.set", json!({"sheet": sheet, "cell": CellRef::new(last, *c).a1(), "input": format!("=SUBTOTAL({code},{range})")}))?;
-    }
-    Ok(json!({"groups": inserted}))
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/crates/engine/src/cmd/data/filter.rs b/crates/engine/src/cmd/data/filter.rs
new file mode 100644
index 000000000..71aa698f4
--- /dev/null
+++ b/crates/engine/src/cmd/data/filter.rs
@@ -0,0 +1,316 @@
+use super::sort::sort_key;
+use super::*;
+
+// ---------------------------------------------------------------- filter
+
+pub(super) fn toggle_filter(s: &mut Session, p: &Json) -> Result<Json> {
+    let (sheet, r) = data_target(s, p, "data.filter")?;
+    crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
+    // The active cell belongs to the active sheet: on another sheet the table is the one at `range`.
+    let at = if sheet == s.doc()?.wb.active_sheet() { s.doc()?.selection.active } else { r.start };
+    let has = s.doc()?.wb.sheet(sheet).is_some_and(|sh| sh.autofilter.is_some());
+    let in_table = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.table_at(at).map(|t| t.name.clone()));
+    if let Some(name) = in_table {
+        return edit(s, |cx| {
+            let sh = cx.sheet_mut(sheet)?;
+            if let Some(t) = sh.tables.iter_mut().find(|t| t.name == name) {
+                t.filter_button = !t.filter_button;
+                if !t.filter_button {
+                    t.filter.clear();
+                }
+            }
+            Ok(Json::Null)
+        });
+    }
+    if has {
+        return edit(s, |cx| {
+            let sh = cx.sheet_mut(sheet)?;
+            // Reveal only rows the filter hid; rows hidden by hand or by a collapsed group stay hidden.
+            let filtered: Vec<u32> = sh.rows.keys().copied().filter(|r| sh.is_row_filtered(*r)).collect();
+            sh.autofilter = None;
+            for r in filtered {
+                if let Some(info) = sh.rows.get_mut(&r) {
+                    info.hidden = false;
+                }
+            }
+            cx.structural = true;
+            Ok(json!({"filter": false}))
+        });
+    }
+    install_filter(s, p)
+}
+
+/// Turn a sheet AutoFilter on over `p.range`, or over the data range of the selection.
+fn install_filter(s: &mut Session, p: &Json) -> Result<Json> {
+    let (sheet, mut r) = data_target(s, p, "data.filter")?;
+    // A selected header row filters the data below it (#201).
+    if p.get("range").is_none() && r.height() == 1 {
+        let d = s.doc()?;
+        let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+        let below = current_region(sh, r.start).end.row;
+        if below > r.end.row {
+            r = RangeRef::new(r.start, CellRef::new(below, r.end.col));
+        }
+    }
+    edit(s, |cx| {
+        cx.sheet_mut(sheet)?.autofilter = Some(AutoFilter { range: r, criteria: vec![] });
+        Ok(json!({"filter": true, "range": r.a1()}))
+    })
+}
+
+pub(super) fn filter_by(s: &mut Session, p: &Json) -> Result<Json> {
+    let sheet = s.doc()?.wb.active_sheet();
+    crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
+    let Some(sh) = s.doc()?.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
+    let af = match &sh.autofilter {
+        Some(a) => a.clone(),
+        None => {
+            install_filter(s, &json!({}))?;
+            s.doc()?.wb.sheet(sheet).and_then(|sh| sh.autofilter.clone()).ok_or_else(|| EngineError::Other("no filter".into()))?
+        }
+    };
+    let col = match col_param(p.get("column"), af.range.start.col) {
+        Some(c) => c,
+        // A number too large to be a column is outside the filter range, not a missing parameter.
+        None if p.get("column").is_some_and(|v| v.as_u64().is_some()) => return Err(bad("data.filterBy", "column outside the filter range")),
+        None => return Err(bad("data.filterBy", "missing `column`")),
+    };
+    if col < af.range.start.col || col > af.range.end.col {
+        return Err(bad("data.filterBy", "column outside the filter range"));
+    }
+    let off = col - af.range.start.col;
+    let crit = if bool_param(p, "clear").unwrap_or(false) {
+        None
+    } else if let Some(vals) = p.get("values").and_then(Json::as_array) {
+        Some(FilterCriterion::Values {
+            values: vals.iter().map(crate::cmd::edit::json_to_input).collect(),
+            blanks: bool_param(p, "blanks").unwrap_or(false),
+        })
+    } else if let Some(c) = p.get("custom") {
+        let a =
+            (c.get("op").and_then(Json::as_str).unwrap_or("=").to_string(), c.get("value").map(crate::cmd::edit::json_to_input).unwrap_or_default());
+        let b =
+            c.get("op2").and_then(Json::as_str).map(|o| (o.to_string(), c.get("value2").map(crate::cmd::edit::json_to_input).unwrap_or_default()));
+        Some(FilterCriterion::Custom { a, b, and: c.get("and").and_then(Json::as_bool).unwrap_or(true) })
+    } else if let Some(t) = p.get("top") {
+        Some(FilterCriterion::Top10 {
+            bottom: t.get("bottom").and_then(Json::as_bool).unwrap_or(false),
+            percent: t.get("percent").and_then(Json::as_bool).unwrap_or(false),
+            count: t.get("count").and_then(Json::as_u64).unwrap_or(10) as u32,
+        })
+    } else {
+        bool_param(p, "aboveAverage").map(FilterCriterion::AboveAverage)
+    };
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        if let Some(a) = sh.autofilter.as_mut() {
+            a.criteria.retain(|(o, _)| *o != off);
+            if let Some(c) = crit.clone() {
+                a.criteria.push((off, c));
+            }
+        }
+        apply_filter(&mut cx.wb, sheet);
+        cx.structural = true;
+        Ok(Json::Null)
+    })?;
+    let hidden = s.doc()?.wb.sheet(sheet).map(|sh| sh.rows.values().filter(|r| r.hidden).count()).unwrap_or(0);
+    Ok(json!({"hiddenRows": hidden}))
+}
+
+/// Does a value pass a custom comparison (`>`, `=*abc*`, `<>x`…)?
+fn custom_ok(v: &Value, text: &str, op: &str, crit: &str) -> bool {
+    let num = gridcraft_core::parse::parse_number_text(crit);
+    let cmp = match (v.as_f64(), num) {
+        (Some(a), Some(b)) => a.partial_cmp(&b),
+        // A numeric ordering comparison only matches numbers; blanks and text never do.
+        (None, Some(_)) if matches!(op, "<" | "<=" | ">" | ">=") => None,
+        _ => Some(gridcraft_core::compare_text(text, crit)),
+    };
+    let wild = || crate::cmd::edit::wildcard(&text.to_lowercase(), &crit.to_lowercase());
+    match op {
+        "=" => {
+            if crit.contains(['*', '?']) {
+                wild()
+            } else {
+                cmp == Some(Ordering::Equal)
+            }
+        }
+        "<>" => {
+            if crit.contains(['*', '?']) {
+                !wild()
+            } else {
+                cmp != Some(Ordering::Equal)
+            }
+        }
+        ">" => cmp == Some(Ordering::Greater),
+        "<" => cmp == Some(Ordering::Less),
+        ">=" => matches!(cmp, Some(Ordering::Greater | Ordering::Equal)),
+        "<=" => matches!(cmp, Some(Ordering::Less | Ordering::Equal)),
+        "beginsWith" => text.to_lowercase().starts_with(&crit.to_lowercase()),
+        "endsWith" => text.to_lowercase().ends_with(&crit.to_lowercase()),
+        "contains" => text.to_lowercase().contains(&crit.to_lowercase()),
+        "notContains" => !text.to_lowercase().contains(&crit.to_lowercase()),
+        _ => true,
+    }
+}
+
+/// The filter's "(Blanks)" group: truly empty cells and zero-length text such as a `=""` result.
+fn filter_blank(v: &Value) -> bool {
+    v.is_empty() || matches!(v, Value::Text(t) if t.is_empty())
+}
+
+/// Excel grows an AutoFilter range when a value is entered in the row right below it, in one of its columns (#2342).
+/// A table's own filter is left to the table, and a row typed after a blank row does not count.
+/// A formula counts before it is calculated: this runs inside the edit, ahead of the recalc.
+pub(crate) fn grow_autofilter(sh: &mut Sheet, at: CellRef) {
+    if !sh.cells.get(at).is_some_and(|c| !filter_blank(&c.value) || c.formula.is_some()) {
+        return;
+    }
+    let Some(af) = sh.autofilter.as_ref() else { return };
+    let r = af.range;
+    if r.end.row.checked_add(1) != Some(at.row) || at.col < r.start.col || at.col > r.end.col || sh.tables.iter().any(|t| t.range == r) {
+        return;
+    }
+    let grown = RangeRef::new(r.start, CellRef::new(at.row, r.end.col));
+    if let Some(af) = sh.autofilter.as_mut() {
+        af.range = grown;
+    }
+}
+
+/// Hides rows of the autofilter range that fail any criterion.
+pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) {
+    let Some(sh) = wb.sheet(sheet) else { return };
+    let Some(af) = sh.autofilter.clone() else { return };
+    let r = af.range;
+    let mut hide = Vec::new();
+    // Precompute per-criterion top10 threshold and average once, not per row.
+    let mut col_stats: std::collections::HashMap<usize, (Option<f64>, f64)> = std::collections::HashMap::new();
+    for (i, (off, c)) in af.criteria.iter().enumerate() {
+        if matches!(c, FilterCriterion::Top10 { .. } | FilterCriterion::AboveAverage(_)) {
+            let col = r.start.col + off;
+            let mut nums: Vec<f64> = (r.start.row + 1..=r.end.row).filter_map(|row| sh.value(CellRef::new(row, col)).as_f64()).collect();
+            let avg = if nums.is_empty() { 0.0 } else { nums.iter().sum::<f64>() / nums.len() as f64 };
+            let thr = match c {
+                FilterCriterion::Top10 { bottom, percent, count } => {
+                    nums.sort_by(|a, b| if *bottom { a.partial_cmp(b) } else { b.partial_cmp(a) }.unwrap_or(Ordering::Equal));
+                    let k = if *percent { ((nums.len() as f64) * (*count as f64) / 100.0).ceil() as usize } else { *count as usize };
+                    let k = k.clamp(1, nums.len().max(1));
+                    nums.get(k - 1).copied()
+                }
+                _ => None,
+            };
+            col_stats.insert(i, (thr, avg));
+        }
+    }
+    for row in r.start.row + 1..=r.end.row {
+        let mut visible = true;
+        for (i, (off, crit)) in af.criteria.iter().enumerate() {
+            let c = CellRef::new(row, r.start.col + off);
+            let v = sh.value(c);
+            let text = crate::display::cell_text(wb, sh, c);
+            let ok = match crit {
+                FilterCriterion::Values { values, blanks } => {
+                    if filter_blank(&v) {
+                        *blanks
+                    } else {
+                        values.iter().any(|x| x.eq_ignore_ascii_case(&text) || x.eq_ignore_ascii_case(&v.display()))
+                    }
+                }
+                FilterCriterion::Custom { a, b, and } => {
+                    let x = custom_ok(&v, &text, &a.0, &a.1);
+                    match b {
+                        Some(b) => {
+                            let y = custom_ok(&v, &text, &b.0, &b.1);
+                            if *and { x && y } else { x || y }
+                        }
+                        None => x,
+                    }
+                }
+                FilterCriterion::Top10 { bottom, .. } => match (v.as_f64(), col_stats.get(&i)) {
+                    (Some(n), Some((thr, _))) => {
+                        let thr = thr.unwrap_or(n);
+                        if *bottom { n <= thr } else { n >= thr }
+                    }
+                    _ => false,
+                },
+                FilterCriterion::AboveAverage(above) => match (v.as_f64(), col_stats.get(&i)) {
+                    (Some(n), Some((_, avg))) => {
+                        if *above {
+                            n > *avg
+                        } else {
+                            n < *avg
+                        }
+                    }
+                    _ => false,
+                },
+                FilterCriterion::FillColor(col) => wb.styles.get(sh.style_id(c)).fill.fg == *col,
+                FilterCriterion::FontColor(col) => wb.styles.get(sh.style_id(c)).font.color == *col,
+                // Icons are not evaluated here: the row keeps its current visibility.
+                FilterCriterion::Icon { .. } => !sh.is_row_hidden(row),
+            };
+            if !ok {
+                visible = false;
+                break;
+            }
+        }
+        hide.push((row, !visible));
+    }
+    let Some(shm) = wb.sheet_mut(sheet) else { return };
+    for (row, h) in hide {
+        if h {
+            shm.rows.entry(row).or_default().hidden = true;
+        } else if let Some(e) = shm.rows.get_mut(&row) {
+            e.hidden = false;
+        }
+    }
+}
+
+pub(super) fn clear_filter(s: &mut Session, _: &Json) -> Result<Json> {
+    let sheet = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        if let Some(a) = sh.autofilter.as_mut() {
+            a.criteria.clear();
+        }
+        apply_filter(&mut cx.wb, sheet);
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn reapply(s: &mut Session, _: &Json) -> Result<Json> {
+    let sheet = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        apply_filter(&mut cx.wb, sheet);
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+/// Distinct display values of a filter column (for the dropdown list).
+pub fn filter_values(wb: &Workbook, sheet: usize, col: u32) -> Vec<(String, bool)> {
+    let Some(sh) = wb.sheet(sheet) else { return vec![] };
+    let Some(af) = &sh.autofilter else { return vec![] };
+    let off = col.saturating_sub(af.range.start.col);
+    let selected: Option<&FilterCriterion> = af.criteria.iter().find(|(o, _)| *o == off).map(|(_, c)| c);
+    let mut seen = std::collections::BTreeMap::new();
+    for row in af.range.start.row + 1..=af.range.end.row.min(af.range.start.row + 1_000_000) {
+        let c = CellRef::new(row, col);
+        let v = sh.value(c);
+        let blank = filter_blank(&v);
+        let t = if blank { "(Blanks)".to_string() } else { crate::display::cell_text(wb, sh, c) };
+        let on = match selected {
+            Some(FilterCriterion::Values { values, blanks }) => {
+                if blank {
+                    *blanks
+                } else {
+                    values.iter().any(|x| x.eq_ignore_ascii_case(&t))
+                }
+            }
+            _ => true,
+        };
+        let key = if blank { sort_key(&Value::Empty) } else { sort_key(&v) };
+        seen.entry((key, t)).or_insert(on);
+    }
+    seen.into_iter().map(|((_, t), on)| (t, on)).collect()
+}
diff --git a/crates/engine/src/cmd/data/grouping.rs b/crates/engine/src/cmd/data/grouping.rs
new file mode 100644
index 000000000..7b5a2254c
--- /dev/null
+++ b/crates/engine/src/cmd/data/grouping.rs
@@ -0,0 +1,267 @@
+use super::*;
+
+// ---------------------------------------------------------------- outline
+
+fn outline_lines(s: &Session, p: &Json) -> Result<(bool, u32, u32)> {
+    if let Some(r) = str_param(p, "rows").and_then(parse_lines) {
+        return Ok((true, r.start.row, r.end.row));
+    }
+    if let Some(r) = str_param(p, "cols").and_then(parse_lines) {
+        return Ok((false, r.start.col, r.end.col));
+    }
+    let r = s.doc()?.selection.current();
+    match str_param(p, "by") {
+        Some("rows") => Ok((true, r.start.row, r.end.row)),
+        Some("cols" | "columns") => Ok((false, r.start.col, r.end.col)),
+        _ if r.is_full_cols() && !r.is_full_rows() => Ok((false, r.start.col, r.end.col)),
+        _ => Ok((true, r.start.row, r.end.row)),
+    }
+}
+
+pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
+    let si = target_sheet(s, p)?;
+    // The selection belongs to the active sheet, so another sheet needs its lines.
+    if si != s.doc()?.wb.active_sheet() && p.get("rows").is_none() && p.get("cols").is_none() {
+        return Err(bad(if on { "data.group" } else { "data.ungroup" }, "missing `rows` or `cols`: the selection is on the active sheet"));
+    }
+    let (rows, a, b) = outline_lines(s, p)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        let before = outline::summary_before(sh, rows);
+        let map = if rows { &mut sh.rows } else { &mut sh.cols };
+        let b = b.min(a.saturating_add(1_048_575));
+        for i in a..=b {
+            let e = map.entry(i).or_default();
+            e.outline = if on { (e.outline + 1).min(outline::MAX_LEVEL) } else { e.outline.saturating_sub(1) };
+            if !on && e.outline == 0 {
+                e.hidden = false;
+            }
+        }
+        // A summary line whose group is gone has nothing left to collapse.
+        let summary = if before { a.checked_sub(1) } else { b.checked_add(1) };
+        if !on
+            && !outline::groups_with(map, before).iter().any(|g| if before { g.start == a } else { g.end == b })
+            && let Some(e) = summary.and_then(|i| map.get_mut(&i))
+        {
+            e.collapsed = false;
+        }
+        cx.structural = true; // ungrouping reveals hidden rows: SUBTOTAL(10x) depends on it
+        Ok(Json::Null)
+    })
+}
+
+/// Hide Detail / Show Detail: the innermost group (or the one at `level`) that holds the lines, or
+/// failing that the one they are the summary of. Hiding marks the summary line collapsed (the
+/// + button, saved to XLSX); showing keeps inner groups that were collapsed on their own collapsed.
+pub(super) fn detail(s: &mut Session, p: &Json, hide: bool) -> Result<Json> {
+    let (rows, a, b) = outline_lines(s, p)?;
+    let want = p.get("level").and_then(Json::as_u64).map(|l| l.min(outline::MAX_LEVEL as u64) as u8);
+    edit(s, |cx| {
+        let si = cx.sheet_index();
+        let sh = cx.sheet_mut(si)?;
+        let before = outline::summary_before(sh, rows);
+        let map = if rows { &mut sh.rows } else { &mut sh.cols };
+        let all = outline::groups_with(map, before);
+        let level_ok = |g: &outline::OutlineGroup| want.is_none_or(|l| g.level == l);
+        let pick = |hit: &dyn Fn(&outline::OutlineGroup) -> bool| -> Vec<outline::OutlineGroup> {
+            let hits: Vec<_> = all.iter().filter(|g| level_ok(g) && hit(g)).copied().collect();
+            let deepest = hits.iter().map(|g| g.level).max().unwrap_or(0);
+            hits.into_iter().filter(|g| g.level == deepest).collect()
+        };
+        let mut chosen = pick(&|g| g.start <= b && g.end >= a);
+        if chosen.is_empty() {
+            chosen = pick(&|g| g.has_summary() && g.summary() >= a && g.summary() <= b);
+        }
+        for g in chosen {
+            // Inner groups collapsed on their own (their summary marked), before this one changes.
+            let inner: Vec<outline::OutlineGroup> = all
+                .iter()
+                .filter(|o| o.level > g.level && o.start >= g.start && o.end <= g.end && o.has_summary() && o.summary() != g.summary())
+                .filter(|o| map.get(&o.summary()).is_some_and(|e| e.collapsed))
+                .copied()
+                .collect();
+            for i in g.start..=g.end {
+                if let Some(e) = map.get_mut(&i) {
+                    set_hidden(e, hide || inner.iter().any(|o| o.contains(i)));
+                }
+            }
+            if !g.has_summary() {
+                continue;
+            }
+            if hide {
+                map.entry(g.summary()).or_default().collapsed = true;
+            } else if let Some(e) = map.get_mut(&g.summary()) {
+                e.collapsed = false;
+            }
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+/// Hides or shows an outline line. A line shown with a zero size (files that hide columns as
+/// `width="0" hidden="1"`) gets the default size back, as Unhide does; otherwise + would mark the
+/// group expanded and leave it invisible (#1714).
+fn set_hidden(e: &mut LineInfo, hidden: bool) {
+    e.hidden = hidden;
+    if !hidden && e.size == Some(0.0) {
+        e.size = None;
+    }
+}
+
+/// The outline's level buttons: show rows / columns down to outline level `n` (1 = only the
+/// top-level summaries); deeper detail is hidden and its summary lines marked collapsed.
+pub(super) fn show_levels(s: &mut Session, p: &Json) -> Result<Json> {
+    let level = |k: &str| p.get(k).and_then(Json::as_u64).map(|n| n.clamp(1, outline::MAX_LEVEL as u64 + 1) as u8);
+    let (rows, cols) = (level("rows"), level("cols"));
+    if rows.is_none() && cols.is_none() {
+        return Err(EngineError::BadParams {
+            cmd: "data.showLevels".into(),
+            msg: "give `rows` or `cols`: the outline level to show (1 = top-level summaries only)".into(),
+        });
+    }
+    edit(s, |cx| {
+        let si = cx.sheet_index();
+        let sh = cx.sheet_mut(si)?;
+        let before = (outline::summary_before(sh, true), outline::summary_before(sh, false));
+        for (map, n, before) in [(&mut sh.rows, rows, before.0), (&mut sh.cols, cols, before.1)] {
+            let Some(n) = n else { continue };
+            let groups = outline::groups_with(map, before);
+            for e in map.values_mut().filter(|e| e.outline > 0) {
+                set_hidden(e, e.outline >= n);
+            }
+            // Inner groups come first, so a summary line shared with the group around it ends up
+            // as that outer group says.
+            for g in groups.into_iter().filter(|g| g.has_summary()) {
+                map.entry(g.summary()).or_default().collapsed = g.level >= n;
+            }
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+/// Data ▸ Outline ▸ Settings: whether summary rows sit below their detail and summary columns
+/// right of it. A changed direction moves each collapsed group's mark (+) to its new summary line.
+/// Moves the collapsed marks of a line axis to the summary line on its new side (`on` is the new
+/// setting, `was_before` the old one). A line that nested groups share keeps its mark on the outermost
+/// group whose detail is all hidden, or the outermost when none is.
+fn move_marks(map: &mut std::collections::BTreeMap<u32, LineInfo>, was_before: bool, on: bool) {
+    let mut marked: Vec<outline::OutlineGroup> =
+        outline::groups_with(map, was_before).into_iter().filter(|g| g.has_summary() && map.get(&g.summary()).is_some_and(|e| e.collapsed)).collect();
+    // A mark on a line that nested groups share moves with the outermost of them whose
+    // detail is all hidden, or with the outermost when none is.
+    let mut owner: std::collections::BTreeMap<u32, (bool, u8)> = std::collections::BTreeMap::new();
+    for g in &marked {
+        let key = (!g.collapsed, g.level);
+        let best = owner.entry(g.summary()).or_insert(key);
+        *best = (*best).min(key);
+    }
+    marked.retain(|g| owner.get(&g.summary()) == Some(&(!g.collapsed, g.level)));
+    for g in &marked {
+        if let Some(e) = map.get_mut(&g.summary()) {
+            e.collapsed = false;
+        }
+    }
+    for g in marked {
+        let g = outline::OutlineGroup { summary_before: !on, ..g };
+        if g.has_summary() {
+            map.entry(g.summary()).or_default().collapsed = true;
+        }
+    }
+}
+
+pub(super) fn outline_settings(s: &mut Session, p: &Json) -> Result<Json> {
+    let si = target_sheet(s, p)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        for (rows, key) in [(true, "summaryBelow"), (false, "summaryRight")] {
+            let Some(on) = bool_param(p, key) else { continue };
+            let was_before = outline::summary_before(sh, rows);
+            if rows {
+                sh.summary_below = on;
+            } else {
+                sh.summary_right = on;
+            }
+            if was_before != on {
+                continue;
+            }
+            move_marks(if rows { &mut sh.rows } else { &mut sh.cols }, was_before, on);
+        }
+        Ok(json!({"summaryBelow": sh.summary_below, "summaryRight": sh.summary_right}))
+    })
+}
+
+pub(super) fn subtotal(s: &mut Session, p: &Json) -> Result<Json> {
+    let (sheet, r) = data_target(s, p, "data.subtotal")?;
+    let header = bool_param(p, "header").unwrap_or(true);
+    let group_col = col_param(p.get("groupBy"), r.start.col).unwrap_or(r.start.col);
+    let func = str_param(p, "function").unwrap_or("sum");
+    let code = match func {
+        "count" => 3,
+        "average" => 1,
+        "max" => 4,
+        "min" => 5,
+        "product" => 6,
+        _ => 9,
+    };
+    let cols: Vec<u32> = p
+        .get("columns")
+        .and_then(Json::as_array)
+        .map(|a| a.iter().filter_map(|c| col_param(Some(c), r.start.col)).collect())
+        .unwrap_or_else(|| vec![r.end.col]);
+    let label = match func {
+        "count" => "Count",
+        "average" => "Average",
+        "max" => "Max",
+        "min" => "Min",
+        "product" => "Product",
+        _ => "Total",
+    };
+    // Group boundaries (header in the first row).
+    let d = s.doc()?;
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let mut groups: Vec<(u32, u32, String)> = Vec::new();
+    let first = r.start.row + u32::from(header);
+    let mut start = first;
+    for row in first..=r.end.row + 1 {
+        let cur = sh.value(CellRef::new(row, group_col)).display();
+        let prev = sh.value(CellRef::new(start, group_col)).display();
+        if row > r.end.row || cur != prev {
+            groups.push((start, row - 1, prev));
+            start = row;
+        }
+    }
+    // The totals go below each group, so the outline puts summary rows below their detail (the
+    // Subtotal dialog's "Summary below data"), in the same undo step.
+    if !sh.summary_below {
+        s.execute("data.outlineSettings", json!({"sheet": sheet, "summaryBelow": true}))?;
+    }
+    // Insert a total row after each group, bottom-up so indices stay valid.
+    let mut inserted = 0;
+    for (g0, g1, name) in groups.iter().rev() {
+        s.execute("home.insertRows", json!({"sheet": sheet, "rows": format!("{}:{}", g1 + 2, g1 + 2)}))?;
+        let row = g1 + 1;
+        let lbl = CellRef::new(row, group_col).a1();
+        s.execute("cell.set", json!({"sheet": sheet, "cell": lbl, "input": format!("{name} {label}")}))?;
+        for c in &cols {
+            let range = RangeRef::new(CellRef::new(*g0, *c), CellRef::new(*g1, *c)).a1();
+            s.execute("cell.set", json!({"sheet": sheet, "cell": CellRef::new(row, *c).a1(), "input": format!("=SUBTOTAL({code},{range})")}))?;
+        }
+        s.execute(
+            "home.bold",
+            json!({"sheet": sheet, "range": RangeRef::new(CellRef::new(row, r.start.col), CellRef::new(row, r.end.col)).a1(), "on": true}),
+        )?;
+        s.execute("data.group", json!({"sheet": sheet, "rows": format!("{}:{}", g0 + 1, g1 + 1)}))?;
+        inserted += 1;
+    }
+    let last = r.end.row + inserted + 1;
+    let lbl = CellRef::new(last, group_col).a1();
+    s.execute("home.insertRows", json!({"sheet": sheet, "rows": format!("{}:{}", last + 1, last + 1)}))?;
+    s.execute("cell.set", json!({"sheet": sheet, "cell": lbl, "input": format!("Grand {label}")}))?;
+    for c in &cols {
+        let range = RangeRef::new(CellRef::new(first, *c), CellRef::new(last - 1, *c)).a1();
+        s.execute("cell.set", json!({"sheet": sheet, "cell": CellRef::new(last, *c).a1(), "input": format!("=SUBTOTAL({code},{range})")}))?;
+    }
+    Ok(json!({"groups": inserted}))
+}
diff --git a/crates/engine/src/cmd/data/sort.rs b/crates/engine/src/cmd/data/sort.rs
new file mode 100644
index 000000000..919de1734
--- /dev/null
+++ b/crates/engine/src/cmd/data/sort.rs
@@ -0,0 +1,322 @@
+use super::*;
+
+#[derive(Clone)]
+struct SortKey {
+    col: u32,
+    desc: bool,
+    by: String,
+    list: Option<Vec<String>>,
+}
+
+/// The sheet and range a sort works on: the sheet `sheet` or a `Sheet!` prefix on `range` names,
+/// else the active one. The selection belongs to the active sheet, so another sheet needs `range`.
+fn sort_target(s: &Session, p: &Json) -> Result<(usize, RangeRef)> {
+    let sheet = target_sheet(s, p)?;
+    let d = s.doc()?;
+    if let Some(t) = str_param(p, "range")
+        && let (Some(name), _) = split_sheet(t)
+        && d.wb.sheet_index(&name) != Some(sheet)
+    {
+        return Err(bad("data.sort", format!("`{t}` names a sheet other than `sheet`")));
+    }
+    if sheet != d.wb.active_sheet() && p.get("range").is_none() {
+        return Err(bad("data.sort", "missing `range`: the selection is on the active sheet"));
+    }
+    Ok((sheet, data_range(s, p)?))
+}
+
+pub(super) fn quick_sort(s: &mut Session, p: &Json, asc: bool) -> Result<Json> {
+    let (sheet, r) = sort_target(s, p)?;
+    let col = col_param(p.get("column"), r.start.col).unwrap_or(s.doc()?.selection.active.col).clamp(r.start.col, r.end.col);
+    let d = s.doc()?;
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let header = guess_header(&d.wb, sh, r);
+    do_sort(s, sheet, r, header, vec![SortKey { col, desc: !asc, by: "values".into(), list: None }], false, false)
+}
+
+pub(super) fn sort(s: &mut Session, p: &Json) -> Result<Json> {
+    let (sheet, r) = sort_target(s, p)?;
+    let d = s.doc()?;
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    let header = bool_param(p, "header").unwrap_or_else(|| guess_header(&d.wb, sh, r));
+    let by_cols = str_param(p, "orientation") == Some("columns");
+    let case = bool_param(p, "matchCase").unwrap_or(false);
+    let mut keys: Vec<SortKey> = Vec::new();
+    for k in p.get("keys").and_then(Json::as_array).map(Vec::as_slice).unwrap_or_default() {
+        let col = if by_cols {
+            let row = match k.get("row").and_then(Json::as_u64) {
+                // Worksheet rows are 1-based; 0 (or a value past u32) has no coordinate.
+                Some(n) => {
+                    let row = u32::try_from(n).ok().and_then(|n| n.checked_sub(1));
+                    Some(row.ok_or_else(|| bad("data.sort", "sort key row must be 1 or greater"))?)
+                }
+                None => None,
+            };
+            row.or_else(|| col_param(k.get("column"), r.start.row))
+        } else {
+            col_param(k.get("column"), r.start.col)
+        };
+        let Some(col) = col else { continue };
+        keys.push(SortKey {
+            col,
+            desc: k.get("order").and_then(Json::as_str) == Some("desc"),
+            by: k.get("by").and_then(Json::as_str).unwrap_or("values").to_string(),
+            list: k.get("customList").and_then(Json::as_array).map(|l| l.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()),
+        });
+    }
+    if keys.is_empty() {
+        s.ui_requests.push(crate::UiRequest::Dialog("sort".into(), json!({"range": r.a1(), "header": header})));
+        return ok();
+    }
+    if keys.len() > 64 {
+        return Err(bad("data.sort", "too many sort levels (64 max)"));
+    }
+    do_sort(s, sheet, r, header, keys, by_cols, case)
+}
+
+fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec<SortKey>, by_cols: bool, case: bool) -> Result<Json> {
+    // Protect Sheet ▸ Sort. Both Sort… and the A-to-Z buttons come through here.
+    crate::cmd::refuse_unless_allowed(s, sheet, "Sorting", |p| p.sort)?;
+    let body = if by_cols {
+        if header && r.width() > 1 { RangeRef::new(CellRef::new(r.start.row, r.start.col + 1), r.end) } else { r }
+    } else if header && r.height() > 1 {
+        RangeRef::new(CellRef::new(r.start.row + 1, r.start.col), r.end)
+    } else {
+        r
+    };
+    if body.count() > 20_000_000 {
+        return Err(bad("data.sort", "range too large"));
+    }
+    edit(s, |cx| {
+        let Some(sh) = cx.wb.sheet(sheet) else { return Ok(Json::Null) };
+        if sh.merges.iter().any(|m| m.intersects(&body) && !m.is_single()) {
+            return Err(EngineError::Other("To do this, all the merged cells need to be the same size.".into()));
+        }
+        let n = if by_cols { body.width() } else { body.height() };
+        let line = |i: u32, k: u32| if by_cols { CellRef::new(k, body.start.col + i) } else { CellRef::new(body.start.row + i, k) };
+        let theme = cx.wb.theme.clone();
+        let styles = &cx.wb.styles;
+        let key_val = |i: u32, k: &SortKey| -> (Value, u32) {
+            let c = line(i, k.col);
+            let v = sh.value(c);
+            let color = match k.by.as_str() {
+                "cellColor" => {
+                    styles.get(sh.style_id(c)).fill.fg.resolve(&theme).map(|[r, g, b]| u32::from_be_bytes([0, r, g, b])).unwrap_or(u32::MAX)
+                }
+                "fontColor" => {
+                    styles.get(sh.style_id(c)).font.color.resolve(&theme).map(|[r, g, b]| u32::from_be_bytes([0, r, g, b])).unwrap_or(u32::MAX)
+                }
+                _ => 0,
+            };
+            (v, color)
+        };
+        let mut order: Vec<u32> = (0..n).collect();
+        let keyed: Vec<Vec<(Value, u32)>> = (0..n).map(|i| keys.iter().map(|k| key_val(i, k)).collect()).collect();
+        order.sort_by(|&a, &b| {
+            for (ki, k) in keys.iter().enumerate() {
+                let (va, ca) = &keyed[a as usize][ki];
+                let (vb, cb) = &keyed[b as usize][ki];
+                let o = if k.by != "values" {
+                    ca.cmp(cb)
+                } else if let Some(list) = &k.list {
+                    let pos = |v: &Value| v.as_text().and_then(|t| list.iter().position(|x| x.eq_ignore_ascii_case(t))).unwrap_or(usize::MAX);
+                    pos(va).cmp(&pos(vb))
+                } else if case && va.is_text() && vb.is_text() {
+                    sort_compare(va, vb).then_with(|| case_order(va.as_text().unwrap_or(""), vb.as_text().unwrap_or("")))
+                } else {
+                    sort_compare(va, vb)
+                };
+                // Blanks always sort last, whatever the order.
+                let o = if k.desc && !(va.is_empty() || vb.is_empty()) { o.reverse() } else { o };
+                if o != Ordering::Equal {
+                    return o;
+                }
+            }
+            Ordering::Equal
+        });
+        if order.iter().enumerate().all(|(i, &o)| i as u32 == o) {
+            return Ok(Json::Null);
+        }
+        // Move whole lines (cells with formulas adjusted for relative references).
+        let lanes: Vec<u32> = if by_cols { (body.start.row..=body.end.row).collect() } else { (body.start.col..=body.end.col).collect() };
+        // Notes and hyperlinks hang off a cell, not a row, so they travel with the row they
+        // describe — the way cell pictures and row heights do. Collect them before inserting,
+        // so a swap can't resurrect one from a destination that is also a source.
+        let side: Vec<(CellRef, Comment)> = order
+            .iter()
+            .enumerate()
+            .flat_map(|(dst_i, &src_i)| lanes.iter().map(move |&k| (src_i, dst_i as u32, k)))
+            .filter_map(|(src_i, dst_i, k)| sh.comments.get(&line(src_i, k)).map(|cm| (line(dst_i, k), cm.clone())))
+            .collect();
+        let links: Vec<(CellRef, Hyperlink)> = order
+            .iter()
+            .enumerate()
+            .flat_map(|(dst_i, &src_i)| lanes.iter().map(move |&k| (src_i, dst_i as u32, k)))
+            .filter_map(|(src_i, dst_i, k)| sh.hyperlinks.get(&line(src_i, k)).map(|h| (line(dst_i, k), h.clone())))
+            .collect();
+        let mut moved: Vec<(CellRef, Option<Cell>)> = Vec::with_capacity(body.count() as usize);
+        let mut pictures = Vec::new();
+        for (dst_i, &src_i) in order.iter().enumerate() {
+            for &k in &lanes {
+                let src = line(src_i, k);
+                let dst = line(dst_i as u32, k);
+                let mut cell = sh.cell(src).cloned();
+                if let Some(c) = cell.as_mut()
+                    && let Some(f) = &c.formula
+                    && let Some(e) = f.expr()
+                {
+                    let shifted = gridcraft_formula::adjust::shift_relative(e, dst.row as i64 - src.row as i64, dst.col as i64 - src.col as i64);
+                    c.formula = Some(Arc::new(Formula::from_expr(shifted)));
+                }
+                if let Some(picture) = sh.cell_pictures.get(&src) {
+                    pictures.push((dst, picture.clone()));
+                }
+                moved.push((dst, cell));
+            }
+        }
+        // Row heights travel with rows.
+        let heights: Vec<Option<LineInfo>> =
+            if by_cols { vec![] } else { order.iter().map(|&i| sh.rows.get(&(body.start.row + i)).copied()).collect() };
+        // Floating objects anchored inside the sorted body travel with their lines, unless they
+        // are pinned absolutely ("Don't move or size with cells", `editAs="absolute"`). Reordering
+        // is the inverse of `order`: `dst_of[src] = dst`.
+        let dst_of: Vec<u32> = {
+            let mut v = vec![0u32; order.len()];
+            for (dst_i, &src_i) in order.iter().enumerate() {
+                if let Some(slot) = v.get_mut(src_i as usize) {
+                    *slot = dst_i as u32;
+                }
+            }
+            v
+        };
+        // The object's own geometry (its top-left anchor cell, offset and size) is read from the
+        // pre-sort `sh`; a two-cell object's bottom-right cell is derived from its size here so it
+        // can be re-fitted to the lines it spans after the sort.
+        let objs: Vec<Anchor> =
+            sh.images.iter().map(|o| o.anchor).chain(sh.charts.iter().map(|o| o.anchor)).chain(sh.shapes.iter().map(|o| o.anchor)).collect();
+        let descs: Vec<(u32, u32, f32, f32)> = objs
+            .iter()
+            .map(|a| {
+                let x2 = sh.col_left(a.cell.col) + a.dx as f64 + a.width.max(0.0) as f64;
+                let y2 = sh.row_top(a.cell.row) + a.dy as f64 + a.height.max(0.0) as f64;
+                let tc = sh.col_at(x2);
+                let tr = sh.row_at(y2);
+                (tc, tr, (x2 - sh.col_left(tc)) as f32, (y2 - sh.row_top(tr)) as f32)
+            })
+            .collect();
+        let shm = cx.sheet_mut(sheet)?;
+        for (c, cell) in &moved {
+            match cell {
+                Some(x) => shm.set_cell(*c, x.clone()),
+                None => {
+                    shm.remove_cell(*c);
+                }
+            }
+        }
+        // Every cell of the body is the destination of exactly one source cell, so clearing the
+        // body and inserting the permuted entries is the same permutation the cells went through.
+        for c in body.iter() {
+            shm.comments.remove(&c);
+            shm.hyperlinks.remove(&c);
+        }
+        for (at, cm) in side {
+            shm.comments.insert(at, cm);
+        }
+        for (at, h) in links {
+            shm.hyperlinks.insert(at, h);
+        }
+        shm.cell_pictures.extend(pictures);
+        for (i, h) in heights.into_iter().enumerate() {
+            let row = body.start.row + i as u32;
+            match h {
+                Some(info) => {
+                    shm.rows.insert(row, LineInfo { hidden: shm.rows.get(&row).is_some_and(|x| x.hidden), ..info });
+                }
+                None => {
+                    if let Some(e) = shm.rows.get_mut(&row) {
+                        e.size = None;
+                    }
+                }
+            }
+        }
+        // Re-anchor floating objects now that the row heights are final. `objs` was collected as
+        // images ++ charts ++ shapes, so the same index maps straight onto each vec.
+        // Only objects anchored inside the sorted block move: within its lines on the sort axis
+        // and within its span on the other axis (a picture beside the block stays put).
+        let (b0, b1) = if by_cols { (body.start.col, body.end.col) } else { (body.start.row, body.end.row) };
+        let (o0, o1) = if by_cols { (body.start.row, body.end.row) } else { (body.start.col, body.end.col) };
+        let ni = shm.images.len();
+        let nch = shm.charts.len();
+        for (i, (a, desc)) in objs.into_iter().zip(descs).enumerate() {
+            let other = if by_cols { a.cell.row } else { a.cell.col };
+            if other < o0 || other > o1 {
+                continue;
+            }
+            let na = sorted_anchor(shm, a, desc, by_cols, b0, b1, &dst_of);
+            if na != a {
+                if i < ni {
+                    if let Some(o) = shm.images.get_mut(i) {
+                        o.anchor = na;
+                    }
+                } else if i < ni + nch {
+                    if let Some(o) = shm.charts.get_mut(i - ni) {
+                        o.anchor = na;
+                    }
+                } else if let Some(o) = shm.shapes.get_mut(i - ni - nch) {
+                    o.anchor = na;
+                }
+            }
+        }
+        for (c, _) in moved {
+            cx.changed.push((sheet, c));
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })?;
+    Ok(json!({"sorted": body.a1()}))
+}
+
+/// Re-anchor one floating object for a sort. `bottom` is the object's bottom-right line and the
+/// offset of that corner inside it, measured before the sort. `map` (via `dst_of`) translates a
+/// line index on the moving axis and is the identity outside `b0..=b1`. `sh` is the post-sort
+/// grid (row heights already reordered), so re-fitting uses the heights the object lands on.
+/// Objects pinned absolutely ("Don't move or size with cells") never move; "move but don't size"
+/// keeps its size; "move and size" is re-fitted when its whole extent stays inside the body.
+fn sorted_anchor(sh: &Sheet, a: Anchor, bottom: (u32, u32, f32, f32), by_cols: bool, b0: u32, b1: u32, dst_of: &[u32]) -> Anchor {
+    if a.mode == AnchorMode::Absolute {
+        return a;
+    }
+    let (tc, tr, tdx, tdy) = bottom;
+    let map = |v: u32| -> u32 { if v >= b0 && v <= b1 { dst_of.get((v - b0) as usize).map_or(v, |&d| b0 + d) } else { v } };
+    let (axis_start, axis_end) = if by_cols { (a.cell.col, tc) } else { (a.cell.row, tr) };
+    if axis_start < b0 || axis_start > b1 {
+        return a;
+    }
+    let (nr, nc) = if by_cols { (a.cell.row, map(a.cell.col)) } else { (map(a.cell.row), a.cell.col) };
+    if a.mode == AnchorMode::MoveAndSize && axis_end >= b0 && axis_end <= b1 {
+        let (nbr, nbc) = if by_cols { (tr, map(tc)) } else { (map(tr), tc) };
+        let x1 = sh.col_left(nc) + a.dx as f64;
+        let y1 = sh.row_top(nr) + a.dy as f64;
+        let x2 = sh.col_left(nbc) + tdx as f64;
+        let y2 = sh.row_top(nbr) + tdy as f64;
+        Anchor { cell: CellRef::new(nr, nc), dx: a.dx, dy: a.dy, width: (x2 - x1).max(0.0) as f32, height: (y2 - y1).max(0.0) as f32, mode: a.mode }
+    } else {
+        Anchor { cell: CellRef::new(nr, nc), ..a }
+    }
+}
+
+/// Case-sensitive tie-break for text that is equal ignoring case: as in Excel, lowercase sorts
+/// before uppercase at the first letter that differs in case.
+fn case_order(a: &str, b: &str) -> Ordering {
+    a.chars().zip(b.chars()).find(|(x, y)| x != y).map_or(Ordering::Equal, |(x, y)| y.is_lowercase().cmp(&x.is_lowercase()))
+}
+
+pub(super) fn sort_key(v: &Value) -> (u8, i64, String) {
+    match v {
+        Value::Number(n) => (0, (n * 1e6) as i64, String::new()),
+        Value::Text(t) => (1, 0, t.to_lowercase()),
+        Value::Bool(b) => (2, *b as i64, String::new()),
+        Value::Empty => (9, 0, String::new()),
+        _ => (3, 0, v.display()),
+    }
+}
diff --git a/crates/engine/src/cmd/data/tools.rs b/crates/engine/src/cmd/data/tools.rs
new file mode 100644
index 000000000..1603b2cb4
--- /dev/null
+++ b/crates/engine/src/cmd/data/tools.rs
@@ -0,0 +1,190 @@
+use super::*;
+
+// ---------------------------------------------------------------- tools
+
+pub(super) fn remove_duplicates(s: &mut Session, p: &Json) -> Result<Json> {
+    let (sheet, r) = data_target(s, p, "data.removeDuplicates")?;
+    let d = s.doc()?;
+    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
+    // Rows and columns past the data are blank: only the part with data is compared (whole
+    // columns compared a million blank rows and reported them as removed duplicates).
+    let r = sh.used_range().and_then(|u| r.intersection(&u)).unwrap_or(RangeRef::cell(r.start));
+    let header = bool_param(p, "header").unwrap_or_else(|| guess_header(&d.wb, sh, r));
+    let cols: Vec<u32> = p
+        .get("columns")
+        .and_then(Json::as_array)
+        .map(|a| a.iter().filter_map(|c| col_param(Some(c), r.start.col)).collect())
+        .unwrap_or_else(|| (r.start.col..=r.end.col).collect());
+    // With no column to compare, every row key is empty: the first row would survive and every
+    // other row would be deleted as a duplicate. A column outside the range compares data the
+    // user didn't select. Excel refuses both.
+    if cols.is_empty() || cols.iter().any(|c| !(r.start.col..=r.end.col).contains(c)) {
+        return Err(bad("data.removeDuplicates", "`columns` must name at least one column of the range"));
+    }
+    let start = r.start.row + header as u32;
+    let mut removed = 0;
+    edit(s, |cx| {
+        let Some(sh) = cx.wb.sheet(sheet) else { return Ok(()) };
+        let mut seen = std::collections::HashSet::new();
+        let mut keep: Vec<u32> = Vec::new();
+        // Cells are compared by the text they show, as in Excel: the same date in two formats
+        // isn't a duplicate, while 1.01 and 1.02 shown as 1.0 are.
+        let shown = |c: CellRef| crate::display::format(&sh.value(c), cx.wb.styles.get(sh.style_id(c)).num_fmt.as_str(), &cx.wb).text;
+        for row in start..=r.end.row {
+            let key: Vec<String> = cols.iter().map(|c| shown(CellRef::new(row, *c)).to_lowercase()).collect();
+            if seen.insert(key) {
+                keep.push(row);
+            } else {
+                removed += 1;
+            }
+        }
+        let pictures: Vec<_> = keep
+            .iter()
+            .enumerate()
+            .flat_map(|(i, row)| {
+                (r.start.col..=r.end.col)
+                    .filter_map(move |col| sh.cell_pictures.get(&CellRef::new(*row, col)).map(|p| (CellRef::new(start + i as u32, col), p.clone())))
+            })
+            .collect();
+        // Rows a filter keeps are compacted to `start + i`, so the notes and hyperlinks that
+        // describe them move with them; the ones on removed rows are dropped with the row.
+        let notes: Vec<_> = keep
+            .iter()
+            .enumerate()
+            .flat_map(|(i, row)| {
+                (r.start.col..=r.end.col)
+                    .filter_map(move |col| sh.comments.get(&CellRef::new(*row, col)).map(|cm| (CellRef::new(start + i as u32, col), cm.clone())))
+            })
+            .collect();
+        let links: Vec<_> = keep
+            .iter()
+            .enumerate()
+            .flat_map(|(i, row)| {
+                (r.start.col..=r.end.col)
+                    .filter_map(move |col| sh.hyperlinks.get(&CellRef::new(*row, col)).map(|h| (CellRef::new(start + i as u32, col), h.clone())))
+            })
+            .collect();
+        let rows: Vec<Vec<Option<Cell>>> =
+            keep.iter().map(|row| (r.start.col..=r.end.col).map(|c| sh.cell(CellRef::new(*row, c)).cloned()).collect()).collect();
+        let shm = cx.sheet_mut(sheet)?;
+        for row in start..=r.end.row {
+            for c in r.start.col..=r.end.col {
+                shm.remove_cell(CellRef::new(row, c));
+            }
+        }
+        for row in start..=r.end.row {
+            for c in r.start.col..=r.end.col {
+                let at = CellRef::new(row, c);
+                shm.comments.remove(&at);
+                shm.hyperlinks.remove(&at);
+            }
+        }
+        for (i, cells) in rows.into_iter().enumerate() {
+            for (j, cell) in cells.into_iter().enumerate() {
+                if let Some(cell) = cell {
+                    shm.set_cell(CellRef::new(start + i as u32, r.start.col + j as u32), cell);
+                }
+            }
+        }
+        shm.cell_pictures.extend(pictures);
+        for (at, cm) in notes {
+            shm.comments.insert(at, cm);
+        }
+        for (at, h) in links {
+            shm.hyperlinks.insert(at, h);
+        }
+        for c in RangeRef::new(CellRef::new(start, r.start.col), r.end).iter() {
+            cx.changed.push((sheet, c));
+        }
+        Ok(())
+    })?;
+    let remaining = (r.end.row + 1 - start) as usize - removed;
+    Ok(json!({"removed": removed, "remaining": remaining}))
+}
+
+pub(super) fn text_to_columns(s: &mut Session, p: &Json) -> Result<Json> {
+    let r = target_range(s, p)?;
+    let sheet = target_sheet(s, p)?;
+    let mut delims: Vec<char> = p
+        .get("delimiters")
+        .and_then(Json::as_array)
+        .map(|a| a.iter().filter_map(|d| d.as_str().and_then(|x| x.chars().next())).collect())
+        .unwrap_or_else(|| vec!['\t']);
+    if let Some(o) = str_param(p, "other").and_then(|o| o.chars().next()) {
+        delims.push(o);
+    }
+    let fixed: Option<Vec<usize>> =
+        p.get("fixedWidths").and_then(Json::as_array).map(|a| a.iter().filter_map(|x| x.as_u64().map(|v| v as usize)).collect());
+    let consecutive = bool_param(p, "treatConsecutive").unwrap_or(false);
+    let quote = str_param(p, "textQualifier").and_then(|q| q.chars().next()).unwrap_or('"');
+    let dest = cell_param_on(s, p, "destination", sheet)?.unwrap_or(r.start);
+    edit(s, |cx| {
+        let Some(sh) = cx.wb.sheet(sheet) else { return Ok(()) };
+        let mut out: Vec<(CellRef, String)> = Vec::new();
+        for (i, row) in (r.start.row..=r.end.row).enumerate() {
+            let text = sh.value(CellRef::new(row, r.start.col)).display();
+            let parts: Vec<String> = match &fixed {
+                Some(w) => {
+                    let chars: Vec<char> = text.chars().collect();
+                    let mut cuts = vec![0];
+                    let mut breaks: Vec<usize> = w.iter().copied().filter(|x| *x > 0 && *x < chars.len()).collect();
+                    breaks.sort_unstable();
+                    breaks.dedup();
+                    cuts.extend(breaks);
+                    cuts.push(chars.len());
+                    cuts.windows(2)
+                        .map(|p| chars.get(p[0]..p[1]).map(|s| s.iter().collect::<String>().trim().to_string()).unwrap_or_default())
+                        .collect()
+                }
+                None => split_delimited(&text, &delims, consecutive, quote),
+            };
+            for (j, part) in parts.into_iter().enumerate() {
+                out.push((CellRef::new(dest.row + i as u32, dest.col + j as u32), part));
+            }
+        }
+        for (c, t) in out {
+            let cell = crate::cmd::edit::input_to_cell(&t, sheet, c, &mut cx.wb).unwrap_or(None);
+            let shm = cx.sheet_mut(sheet)?;
+            match cell {
+                Some(x) => shm.set_cell(c, x),
+                None => {
+                    shm.remove_cell(c);
+                }
+            }
+            cx.changed.push((sheet, c));
+        }
+        Ok(())
+    })?;
+    ok()
+}
+
+pub(super) fn split_delimited(text: &str, delims: &[char], consecutive: bool, quote: char) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut cur = String::new();
+    let mut in_q = false;
+    let mut last_delim = false;
+    let mut chars = text.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == quote {
+            if in_q && chars.peek() == Some(&quote) {
+                cur.push(quote);
+                chars.next();
+            } else {
+                in_q = !in_q;
+            }
+            continue;
+        }
+        if !in_q && delims.contains(&c) {
+            if consecutive && last_delim {
+                continue;
+            }
+            out.push(std::mem::take(&mut cur));
+            last_delim = true;
+            continue;
+        }
+        last_delim = false;
+        cur.push(c);
+    }
+    out.push(cur);
+    out
+}
diff --git a/crates/engine/src/cmd/data/validation.rs b/crates/engine/src/cmd/data/validation.rs
new file mode 100644
index 000000000..6d4ae73cf
--- /dev/null
+++ b/crates/engine/src/cmd/data/validation.rs
@@ -0,0 +1,290 @@
+use super::*;
+
+// ---------------------------------------------------------------- validation
+
+fn op_param(s: Option<&str>) -> CfOperator {
+    match s.unwrap_or("between") {
+        "notBetween" => CfOperator::NotBetween,
+        "equal" => CfOperator::Equal,
+        "notEqual" => CfOperator::NotEqual,
+        "greater" | "greaterThan" => CfOperator::Greater,
+        "less" | "lessThan" => CfOperator::Less,
+        "greaterOrEqual" | "greaterThanOrEqual" => CfOperator::GreaterOrEqual,
+        "lessOrEqual" | "lessThanOrEqual" => CfOperator::LessOrEqual,
+        _ => CfOperator::Between,
+    }
+}
+
+/// `r` minus `cut`, as up to four non-overlapping rectangles.
+fn subtract_range(r: RangeRef, cut: &RangeRef) -> Vec<RangeRef> {
+    let Some(i) = r.intersection(cut) else { return vec![r] };
+    let mut out = Vec::new();
+    if i.start.row > r.start.row {
+        out.push(RangeRef::new(r.start, CellRef::new(i.start.row - 1, r.end.col)));
+    }
+    if i.end.row < r.end.row {
+        out.push(RangeRef::new(CellRef::new(i.end.row + 1, r.start.col), r.end));
+    }
+    if i.start.col > r.start.col {
+        out.push(RangeRef::new(CellRef::new(i.start.row, r.start.col), CellRef::new(i.end.row, i.start.col - 1)));
+    }
+    if i.end.col < r.end.col {
+        out.push(RangeRef::new(CellRef::new(i.start.row, i.end.col + 1), CellRef::new(i.end.row, r.end.col)));
+    }
+    out
+}
+
+/// Removes the cells of `cuts` from every validation, keeping the rest of each rule's ranges.
+pub(in super::super) fn remove_validation_cells(validations: &mut Vec<Validation>, cuts: &[RangeRef]) {
+    for dv in validations.iter_mut() {
+        for cut in cuts {
+            dv.ranges = dv.ranges.iter().flat_map(|r| subtract_range(*r, cut)).collect();
+        }
+    }
+    validations.retain(|d| !d.ranges.is_empty());
+}
+
+pub(super) fn validation(s: &mut Session, p: &Json) -> Result<Json> {
+    let ranges = target_ranges(s, p)?;
+    let sheet = target_sheet(s, p)?;
+    if bool_param(p, "clear").unwrap_or(false) {
+        return edit(s, |cx| {
+            let sh = cx.sheet_mut(sheet)?;
+            remove_validation_cells(&mut sh.validations, &ranges);
+            Ok(Json::Null)
+        });
+    }
+    let Some(kind) = str_param(p, "type") else {
+        s.ui_requests.push(crate::UiRequest::Dialog("dataValidation".into(), json!({})));
+        return ok();
+    };
+    let kind = match kind {
+        "whole" => ValidationKind::Whole,
+        "decimal" => ValidationKind::Decimal,
+        "list" => ValidationKind::List,
+        "date" => ValidationKind::Date,
+        "time" => ValidationKind::Time,
+        "textLength" => ValidationKind::TextLength,
+        "custom" => ValidationKind::Custom,
+        "any" => ValidationKind::Any,
+        // An unknown type used to give an "any value" rule, saved as `type="none"`: no validation.
+        other => return Err(bad("data.validation", format!("unknown type `{other}` (any, whole, decimal, list, date, time, textLength, custom)"))),
+    };
+    if kind == ValidationKind::List && str_param(p, "formula1").is_none_or(|f| f.trim().trim_start_matches('=').is_empty()) {
+        return Err(bad("data.validation", "a list validation needs `formula1`"));
+    }
+    const OPERATORS: [&str; 12] = [
+        "between",
+        "notBetween",
+        "equal",
+        "notEqual",
+        "greater",
+        "greaterThan",
+        "less",
+        "lessThan",
+        "greaterOrEqual",
+        "greaterThanOrEqual",
+        "lessOrEqual",
+        "lessThanOrEqual",
+    ];
+    if let Some(op) = str_param(p, "operator").filter(|op| !OPERATORS.contains(op)) {
+        return Err(bad("data.validation", format!("unknown operator `{op}` ({})", OPERATORS.join(", "))));
+    }
+    let error_style = match str_param(p, "errorStyle") {
+        None | Some("stop") => ErrorStyle::Stop,
+        Some("warning") => ErrorStyle::Warning,
+        Some("information") => ErrorStyle::Information,
+        Some(other) => return Err(bad("data.validation", format!("unknown errorStyle `{other}` (stop, warning, information)"))),
+    };
+    let f1 = str_param(p, "formula1").unwrap_or("");
+    let f1 = if kind == ValidationKind::List { list_source(f1) } else { f1.trim_start_matches('=').to_string() };
+    let dv = Validation {
+        ranges: ranges.clone(),
+        kind,
+        op: op_param(str_param(p, "operator")),
+        f1,
+        f2: str_param(p, "formula2").map(|f| f.trim_start_matches('=').to_string()),
+        allow_blank: bool_param(p, "ignoreBlank").unwrap_or(true),
+        in_cell_dropdown: bool_param(p, "dropdown").unwrap_or(true),
+        input_title: str_param(p, "inputTitle").unwrap_or("").into(),
+        input_message: str_param(p, "inputMessage").unwrap_or("").into(),
+        show_input: true,
+        error_title: str_param(p, "errorTitle").unwrap_or("").into(),
+        error_message: str_param(p, "errorMessage").unwrap_or("").into(),
+        error_style,
+        show_error: true,
+    };
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(sheet)?;
+        remove_validation_cells(&mut sh.validations, &ranges);
+        sh.validations.push(dv.clone());
+        Ok(Json::Null)
+    })
+}
+
+/// Whether a list rule's source is a literal list (`"a,b"`, or `a,b` typed without quotes) rather
+/// than a reference or a name to evaluate.
+fn is_literal_list(f: &str) -> bool {
+    f.starts_with('"')
+        || (!f.contains('!')
+            && gridcraft_formula::parse(f).map(|e| !matches!(e, gridcraft_formula::Expr::Ref(_) | gridcraft_formula::Expr::Name(_))).unwrap_or(true))
+}
+
+/// A list rule's source as a file stores it. A literal list typed without quotes, as in Excel's
+/// Source box (`Open,In progress,Closed`), becomes the quoted string Excel saves
+/// (`"Open,In progress,Closed"`, inner quotes doubled); unquoted, the file would read it as a
+/// formula. A formula (`=…`), a reference, a name or an already quoted list is kept as before.
+fn list_source(f: &str) -> String {
+    let t = f.trim();
+    if t.is_empty() || t.starts_with('=') || t.starts_with('"') || !is_literal_list(t) {
+        return f.trim_start_matches('=').to_string();
+    }
+    format!("\"{}\"", t.replace('"', "\"\""))
+}
+
+/// List entries of a list validation (literal or from a range).
+pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec<String> {
+    let f = dv.f1.trim();
+    if is_literal_list(f) {
+        // A quoted list is a string literal: `""` inside stands for one `"`.
+        let items = match f.strip_prefix('"').and_then(|x| x.strip_suffix('"')) {
+            Some(body) => body.replace("\"\"", "\""),
+            None => f.trim_matches('"').to_string(),
+        };
+        return items.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect();
+    }
+    let at = dv.ranges.first().map(|r| r.start).unwrap_or_default();
+    match gridcraft_calc::evaluate(wb, sheet, at, f) {
+        Value::Array(a) => a.data.iter().filter(|v| !v.is_empty()).map(Value::display).collect(),
+        v if !v.is_empty() && !v.is_error() => vec![v.display()],
+        _ => vec![],
+    }
+}
+
+/// Checks typed input against the validation of a cell. `Ok(None)` = valid.
+pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) -> Option<(Validation, String)> {
+    let sh = wb.sheet(sheet)?;
+    let dv = sh.validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(at)))?;
+    if dv.kind == ValidationKind::Any || !dv.show_error {
+        return None;
+    }
+    if input.is_empty() && dv.allow_blank {
+        return None;
+    }
+    let v = gridcraft_core::parse::parse_input(input, wb.date_system).value;
+    // The formulas are written for the first cell of the range and see the value being entered,
+    // as in Excel (a custom `=A1>10` on A1:A9 checks A5's new value at A5).
+    let first = dv.ranges.first().map(|r| r.start).unwrap_or(at);
+    let entered;
+    let wb = if sh.value(at) == v {
+        wb
+    } else {
+        let mut w = wb.clone();
+        if let Some(sh) = w.sheet_mut(sheet) {
+            let style = sh.style_id(at);
+            sh.cells.set(at, Cell { value: v.clone(), style, ..Default::default() });
+        }
+        entered = w;
+        &entered
+    };
+    let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at));
+    let num = |f: &str| eval(f).to_number().ok();
+    let ok = match dv.kind {
+        ValidationKind::List => list_items(wb, sheet, dv).iter().any(|x| x.eq_ignore_ascii_case(input)),
+        ValidationKind::Custom => eval(&dv.f1).to_bool().unwrap_or(false),
+        ValidationKind::TextLength => {
+            let n = input.chars().count() as f64;
+            compare_op(dv.op, n, num(&dv.f1), dv.f2.as_deref().and_then(num))
+        }
+        _ => match v.as_f64() {
+            Some(n) => {
+                if dv.kind == ValidationKind::Whole && n.fract() != 0.0 {
+                    false
+                } else {
+                    compare_op(dv.op, n, num(&dv.f1), dv.f2.as_deref().and_then(num))
+                }
+            }
+            None => false,
+        },
+    };
+    if ok {
+        return None;
+    }
+    let msg = if dv.error_message.is_empty() {
+        "This value doesn't match the data validation restrictions defined for this cell.".to_string()
+    } else {
+        dv.error_message.clone()
+    };
+    Some((dv.clone(), msg))
+}
+
+/// A formula written for `first`, as seen from `at` (relative references shifted).
+fn formula_at(f: &str, first: CellRef, at: CellRef) -> String {
+    if first == at {
+        return f.to_string();
+    }
+    match gridcraft_formula::parse(f.trim_start_matches('=')) {
+        Ok(e) => gridcraft_formula::print(&gridcraft_formula::adjust::shift_relative(
+            e,
+            at.row as i64 - first.row as i64,
+            at.col as i64 - first.col as i64,
+        )),
+        Err(_) => f.to_string(),
+    }
+}
+
+/// Moves the relative references of a rule formula written for `first` so it reads the same cells from `to`
+/// (pasting a rule); text without relative references (constants, literal lists) stays as typed.
+pub(in super::super) fn move_rule_formula(f: &str, first: CellRef, to: CellRef) -> String {
+    if first == to {
+        return f.to_string();
+    }
+    let moved = formula_at(f, first, to);
+    let has_relative = gridcraft_formula::parse(f.trim_start_matches('=')).is_ok_and(|e| gridcraft_formula::print(&e) != moved);
+    let eq = if f.starts_with('=') { "=" } else { "" };
+    if has_relative { format!("{eq}{moved}") } else { f.to_string() }
+}
+
+fn compare_op(op: CfOperator, n: f64, a: Option<f64>, b: Option<f64>) -> bool {
+    let Some(a) = a else { return false };
+    match op {
+        CfOperator::Between => b.is_some_and(|b| n >= a.min(b) && n <= a.max(b)),
+        CfOperator::NotBetween => b.is_some_and(|b| n < a.min(b) || n > a.max(b)),
+        CfOperator::Equal => n == a,
+        CfOperator::NotEqual => n != a,
+        CfOperator::Greater => n > a,
+        CfOperator::Less => n < a,
+        CfOperator::GreaterOrEqual => n >= a,
+        CfOperator::LessOrEqual => n <= a,
+    }
+}
+
+pub(super) fn validate_cmd(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
+    let input = str_param(p, "input").unwrap_or("");
+    match check_validation(&d.wb, d.wb.active_sheet(), at, input) {
+        None => Ok(json!({"ok": true})),
+        Some((dv, msg)) => Ok(json!({"ok": false, "message": msg, "title": dv.error_title, "style": format!("{:?}", dv.error_style)})),
+    }
+}
+
+pub(super) fn circle_invalid(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let sheet = d.wb.active_sheet();
+    let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
+    let mut bad_cells = Vec::new();
+    for dv in &sh.validations {
+        for r in &dv.ranges {
+            let r = sh.used_range().and_then(|u| r.intersection(&u));
+            let Some(r) = r else { continue };
+            for c in r.iter().take(100_000) {
+                let text = sh.input_text(c);
+                if !text.is_empty() && check_validation(&d.wb, sheet, c, &text).is_some() {
+                    bad_cells.push(c.a1());
+                }
+            }
+        }
+    }
+    Ok(json!({"invalid": bad_cells}))
+}

From bbff147bf1c2fbba18537e84b5c6add16a65ad46 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:47:27 +0000
Subject: [PATCH 53/76] refactor(engine): move cmd/extra.rs items to cmd/extra/

---
 crates/engine/src/cmd/extra.rs         | 1023 +-----------------------
 crates/engine/src/cmd/extra/cells.rs   |  147 ++++
 crates/engine/src/cmd/extra/chart.rs   |  259 ++++++
 crates/engine/src/cmd/extra/data.rs    |  131 +++
 crates/engine/src/cmd/extra/objects.rs |  146 ++++
 crates/engine/src/cmd/extra/scripts.rs |  146 ++++
 crates/engine/src/cmd/extra/window.rs  |  184 +++++
 7 files changed, 1030 insertions(+), 1006 deletions(-)
 create mode 100644 crates/engine/src/cmd/extra/cells.rs
 create mode 100644 crates/engine/src/cmd/extra/chart.rs
 create mode 100644 crates/engine/src/cmd/extra/data.rs
 create mode 100644 crates/engine/src/cmd/extra/objects.rs
 create mode 100644 crates/engine/src/cmd/extra/scripts.rs
 create mode 100644 crates/engine/src/cmd/extra/window.rs

diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index 60ffa102b..bf21433ab 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -7,6 +7,23 @@ use serde_json::{Value as Json, json};
 
 use super::*;
 
+mod cells;
+mod chart;
+mod data;
+mod objects;
+mod scripts;
+mod window;
+
+pub(crate) use cells::is_checkbox_cell;
+use cells::{background, checkbox, draw_border, new_cell_style, recently_used, theme_colors, theme_fonts, toggle_checkbox, use_in_formula};
+use chart::{add_element, change_colors, format_series, move_chart, quick_layout, select_data};
+use data::{from_csv, from_table_range, queries, table_resize};
+use objects::{align, arrange, rotate, selection_pane, shape_fill, shape_outline};
+pub(crate) use scripts::has_scripts;
+use scripts::{all_scripts, delete_script, new_script, record, run_script, stop_action, trust_scripts};
+use window::{arrange_all, custom_views, hide_window, new_window, ruler, set_view, split, switch_windows, unhide_window, watch_window};
+pub(crate) use window::{keep_watch_list, window_param};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         // Chart Design / Format
@@ -308,430 +325,6 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
-    let d = s.doc()?;
-    let si = d.wb.active_sheet();
-    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
-    let idx = match u32_param(p, "chart") {
-        Some(id) => sh.charts.iter().position(|c| c.id == id),
-        None => sh.charts.len().checked_sub(1),
-    };
-    idx.map(|i| (si, i)).ok_or_else(|| bad("chart", "no chart on this sheet"))
-}
-
-fn with_chart(s: &mut Session, p: &Json, f: impl FnOnce(&mut Chart) -> Result<()>) -> Result<Json> {
-    let (si, ci) = find_chart(s, p)?;
-    edit(s, |cx| {
-        let c = cx.sheet_mut(si)?.charts.get_mut(ci).ok_or_else(|| bad("chart", "no such chart"))?;
-        f(c)?;
-        Ok(json!({"chart": c.id}))
-    })
-}
-
-fn add_element(s: &mut Session, p: &Json) -> Result<Json> {
-    let el = str_param(p, "element").unwrap_or("title").to_string();
-    let on = bool_param(p, "on").unwrap_or(true);
-    let pos = str_param(p, "position").map(str::to_string);
-    with_chart(s, p, |c| {
-        match el.as_str() {
-            "title" => c.title = if on { c.title.clone().filter(|t| !t.is_empty()).or(Some("Chart Title".into())) } else { Some(String::new()) },
-            "legend" => {
-                c.legend = if !on {
-                    LegendPos::None
-                } else {
-                    match pos.as_deref() {
-                        Some("top") => LegendPos::Top,
-                        Some("left") => LegendPos::Left,
-                        Some("right") => LegendPos::Right,
-                        _ => LegendPos::Bottom,
-                    }
-                }
-            }
-            "dataLabels" => c.data_labels = on,
-            "gridlines" => c.gridlines = on,
-            "axisTitles" => {
-                c.x_title = on.then(|| c.x_title.clone().unwrap_or_else(|| "Axis Title".into()));
-                c.y_title = on.then(|| c.y_title.clone().unwrap_or_else(|| "Axis Title".into()));
-            }
-            "smooth" => {
-                for s in &mut c.series {
-                    s.smooth = on;
-                }
-            }
-            "trendline" => {
-                let only = u32_param(p, "series").map(|i| i as usize);
-                if only.is_some_and(|i| i >= c.series.len()) {
-                    return Err(bad("chart.addElement", "no such series"));
-                }
-                let targets: Vec<usize> = (0..c.series.len()).filter(|i| only.is_none_or(|o| o == *i)).collect();
-                if !on {
-                    for i in targets {
-                        if let Some(se) = c.series.get_mut(i) {
-                            se.trendlines.clear();
-                        }
-                    }
-                    return Ok(());
-                }
-                let t = trendline_param(p)?;
-                let eligible: Vec<usize> =
-                    targets.into_iter().filter(|i| gridcraft_chart::supports_trendline(gridcraft_chart::series_plot_kind(c, *i))).collect();
-                if eligible.is_empty() {
-                    return Err(bad("chart.addElement", "trendlines need a 2-D column, bar, line, area, scatter or bubble series"));
-                }
-                for i in eligible {
-                    if let Some(se) = c.series.get_mut(i) {
-                        se.trendlines.push(t.clone());
-                    }
-                }
-            }
-            other => return Err(bad("chart.addElement", format!("unknown element `{other}`"))),
-        }
-        Ok(())
-    })
-}
-
-/// The trendline described by `chart.addElement`'s trendline parameters (Excel's Add Chart
-/// Element ▸ Trendline choices, plus the Format Trendline options).
-fn trendline_param(p: &Json) -> Result<Trendline> {
-    let num = |k: &str| Trendline::clamp_forecast(f64_param(p, k).unwrap_or(0.0));
-    let mut t = Trendline {
-        forward: num("forward"),
-        backward: num("backward"),
-        display_equation: bool_param(p, "displayEquation").unwrap_or(false),
-        display_r_squared: bool_param(p, "displayRSquared").unwrap_or(false),
-        ..Trendline::default()
-    };
-    t.kind = match str_param(p, "type").unwrap_or("linear") {
-        "linear" => TrendlineKind::Linear,
-        // Excel's Linear Forecast: a linear trendline projected two periods ahead.
-        "linearForecast" => {
-            if t.forward == 0.0 {
-                t.forward = 2.0;
-            }
-            TrendlineKind::Linear
-        }
-        "exponential" => TrendlineKind::Exponential,
-        "logarithmic" => TrendlineKind::Logarithmic,
-        "power" => TrendlineKind::Power,
-        "polynomial" => TrendlineKind::Polynomial(u32_param(p, "order").unwrap_or(2).clamp(2, 6) as u8),
-        "movingAverage" => TrendlineKind::MovingAverage(u32_param(p, "period").unwrap_or(2).clamp(2, 255)),
-        other => return Err(bad("chart.addElement", format!("unknown trendline type `{other}`"))),
-    };
-    Ok(t)
-}
-
-fn quick_layout(s: &mut Session, p: &Json) -> Result<Json> {
-    let n = u32_param(p, "layout").unwrap_or(1);
-    with_chart(s, p, |c| {
-        let (legend, labels, grid, axes) = match n {
-            2 => (LegendPos::Top, true, false, false),
-            3 => (LegendPos::Bottom, false, true, false),
-            4 => (LegendPos::Bottom, true, false, false),
-            5 => (LegendPos::None, false, true, true),
-            6 => (LegendPos::Right, false, true, true),
-            _ => (LegendPos::Right, false, true, false),
-        };
-        c.legend = legend;
-        c.data_labels = labels;
-        c.gridlines = grid;
-        if axes {
-            c.x_title.get_or_insert_with(|| "Axis Title".into());
-            c.y_title.get_or_insert_with(|| "Axis Title".into());
-        } else {
-            c.x_title = None;
-            c.y_title = None;
-        }
-        Ok(())
-    })
-}
-
-fn change_colors(s: &mut Session, p: &Json) -> Result<Json> {
-    let explicit: Option<Vec<Color>> =
-        p.get("colors").and_then(Json::as_array).map(|a| a.iter().filter_map(|c| c.as_str().and_then(Color::from_hex)).collect());
-    let palette = str_param(p, "palette").unwrap_or("colorful").to_string();
-    with_chart(s, p, |c| {
-        for (i, se) in c.series.iter_mut().enumerate() {
-            se.color = match &explicit {
-                Some(cols) if !cols.is_empty() => cols.get(i % cols.len()).copied(),
-                _ => match palette.as_str() {
-                    "monochrome" => Some(Color::Theme(4, (-400 + (i as i16 * 200)).clamp(-800, 800))),
-                    p if p.starts_with("accent") => {
-                        let k: u8 = p.trim_start_matches("accent").parse().unwrap_or(1);
-                        Some(Color::Theme(3 + k.clamp(1, 6), (-500 + i as i16 * 250).clamp(-800, 800)))
-                    }
-                    _ => None,
-                },
-            };
-        }
-        Ok(())
-    })
-}
-
-fn select_data(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    // A new data range rebuilds the series, as in Excel's Select Data › Chart data range.
-    let rebuilt = match str_param(p, "range") {
-        Some(range) => {
-            let range = range.trim_start_matches('=');
-            let (sheet_name, body) = split_sheet(range);
-            let src_si = match sheet_name {
-                Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("chart.selectData", "no such sheet"))?,
-                None => d.wb.active_sheet(),
-            };
-            let r = RangeRef::parse(body).ok_or_else(|| bad("chart.selectData", "not a range"))?;
-            if r.count() > 1_000_000 {
-                return Err(bad("chart.selectData", "range too large for a chart"));
-            }
-            let src = d.wb.sheet(src_si).ok_or(EngineError::NoDocument)?;
-            let by_rows = bool_param(p, "byRows").unwrap_or(r.width() > r.height() + 1);
-            let series = super::insert::series_from_range(src, r, by_rows);
-            Some((series, format!("{}!{}", gridcraft_formula::quote_sheet(&src.name), r.a1()), by_rows))
-        }
-        None => None,
-    };
-    // Horizontal (Category) Axis Labels › Edit: one labels range for every series ("" clears).
-    let categories = match str_param(p, "categories") {
-        None => None,
-        Some(t) if t.trim().trim_start_matches('=').is_empty() => Some(None),
-        Some(t) => {
-            let t = t.trim().trim_start_matches('=');
-            let (sheet_name, body) = split_sheet(t);
-            let si = match sheet_name {
-                Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("chart.selectData", "no such sheet"))?,
-                None => d.wb.active_sheet(),
-            };
-            let r = RangeRef::parse(body).ok_or_else(|| bad("chart.selectData", "`categories` is not a range"))?;
-            let name = d.wb.sheet(si).map(|sh| sh.name.clone()).ok_or(EngineError::NoDocument)?;
-            let abs = |c: CellRef| format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1);
-            Some(Some(format!("{}!{}:{}", gridcraft_formula::quote_sheet(&name), abs(r.start), abs(r.end))))
-        }
-    };
-    let mut remove: Vec<usize> = p
-        .get("removeSeries")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().filter_map(Json::as_u64).filter_map(|i| usize::try_from(i).ok()).collect())
-        .unwrap_or_default();
-    remove.sort_unstable();
-    remove.dedup();
-    if rebuilt.is_none() && categories.is_none() && remove.is_empty() {
-        return Err(bad("chart.selectData", "missing `range`, `categories` or `removeSeries`"));
-    }
-    with_chart(s, p, move |c| {
-        if let Some((series, source, by_rows)) = rebuilt {
-            c.series = series;
-            super::insert::scatter_x_from_first(c.kind, &mut c.series);
-            c.source = Some(source);
-            c.by_rows = by_rows;
-        }
-        for i in remove.iter().rev() {
-            if *i < c.series.len() && c.series.len() > 1 {
-                c.series.remove(*i);
-            }
-        }
-        if let Some(cats) = categories {
-            for se in &mut c.series {
-                se.categories = cats.clone();
-            }
-        }
-        Ok(())
-    })
-}
-
-fn move_chart(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, ci) = find_chart(s, p)?;
-    let target = match p.get("sheet").and_then(Json::as_str) {
-        Some(n) => Some(s.doc()?.wb.sheet_index(n).ok_or_else(|| bad("chart.move", "no such sheet"))?),
-        None => None,
-    };
-    let at = cell_param_on(s, p, "at", target.unwrap_or(si))?;
-    edit(s, |cx| {
-        let mut chart = cx.sheet_mut(si)?.charts.remove(ci);
-        if let Some(a) = at {
-            chart.anchor.cell = a;
-        }
-        let dest = target.unwrap_or(si);
-        cx.sheet_mut(dest)?.charts.push(chart);
-        Ok(Json::Null)
-    })
-}
-
-fn format_series(s: &mut Session, p: &Json) -> Result<Json> {
-    let idx = u32_param(p, "series").unwrap_or(0) as usize;
-    let color = str_param(p, "color").and_then(Color::from_hex);
-    with_chart(s, p, |c| {
-        if let Some(se) = c.series.get_mut(idx) {
-            se.color = color;
-        }
-        Ok(())
-    })
-}
-
-fn shape_fill(s: &mut Session, p: &Json) -> Result<Json> {
-    if str_param(p, "kind") == Some("shape") {
-        let color = str_param(p, "color").and_then(Color::from_hex).unwrap_or_default();
-        return with_shape(s, p, |sh| sh.fill = color);
-    }
-    format_series(s, p)
-}
-
-fn shape_outline(s: &mut Session, p: &Json) -> Result<Json> {
-    let color = str_param(p, "color").and_then(Color::from_hex).unwrap_or_default();
-    with_shape(s, p, |sh| sh.line = color)
-}
-
-fn with_shape(s: &mut Session, p: &Json, f: impl FnOnce(&mut Shape)) -> Result<Json> {
-    let si = s.doc()?.wb.active_sheet();
-    let id = u32_param(p, "id");
-    edit(s, |cx| {
-        let shapes = &mut cx.sheet_mut(si)?.shapes;
-        let sh = match id {
-            Some(id) => shapes.iter_mut().find(|x| x.id == id),
-            None => shapes.last_mut(),
-        }
-        .ok_or_else(|| bad("shape", "no such shape"))?;
-        f(sh);
-        Ok(Json::Null)
-    })
-}
-
-fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json> {
-    let id = u32_param(p, "id").ok_or_else(|| bad("arrange", "missing `id`"))?;
-    let kind = str_param(p, "kind").unwrap_or("shape").to_string();
-    let extreme = bool_param(p, "toFront").or(bool_param(p, "toBack")).unwrap_or(false);
-    let si = s.doc()?.wb.active_sheet();
-    fn reorder<T>(v: &mut Vec<T>, i: usize, forward: bool, extreme: bool) {
-        if i >= v.len() {
-            return;
-        }
-        let item = v.remove(i);
-        let j = match (forward, extreme) {
-            (true, true) => v.len(),
-            (false, true) => 0,
-            (true, false) => (i + 1).min(v.len()),
-            (false, false) => i.saturating_sub(1),
-        };
-        v.insert(j, item);
-    }
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        match kind.as_str() {
-            "chart" => {
-                if let Some(i) = sh.charts.iter().position(|c| c.id == id) {
-                    reorder(&mut sh.charts, i, forward, extreme);
-                }
-            }
-            "image" => {
-                if let Some(i) = sh.images.iter().position(|c| c.id == id) {
-                    reorder(&mut sh.images, i, forward, extreme);
-                }
-            }
-            _ => {
-                if let Some(i) = sh.shapes.iter().position(|c| c.id == id) {
-                    reorder(&mut sh.shapes, i, forward, extreme);
-                }
-            }
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn selection_pane(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-    let mut v = Vec::new();
-    for c in &sh.shapes {
-        v.push(json!({"kind": "shape", "id": c.id, "name": format!("{:?} {}", c.kind, c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
-    }
-    for c in &sh.images {
-        v.push(json!({"kind": "image", "id": c.id, "name": format!("Picture {}", c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
-    }
-    for c in &sh.charts {
-        v.push(json!({"kind": "chart", "id": c.id, "name": format!("Chart {}", c.id), "title": c.title, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
-    }
-    Ok(Json::Array(v))
-}
-
-fn anchors_of<'a>(sh: &'a mut Sheet, kind: &str) -> Vec<(u32, &'a mut Anchor)> {
-    match kind {
-        "chart" => sh.charts.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
-        "image" => sh.images.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
-        _ => sh.shapes.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
-    }
-}
-
-fn align(s: &mut Session, p: &Json) -> Result<Json> {
-    let kind = str_param(p, "kind").unwrap_or("shape").to_string();
-    let ids: Vec<u32> =
-        p.get("ids").and_then(Json::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(|x| x as u32)).collect()).unwrap_or_default();
-    let how = str_param(p, "align").unwrap_or("left").to_string();
-    let si = s.doc()?.wb.active_sheet();
-    edit(s, |cx| {
-        let sheet = cx.sheet_mut(si)?;
-        let geo: Vec<(u32, f64, f64, f32, f32)> = {
-            let shc = sheet.clone();
-            anchors_of(sheet, &kind)
-                .into_iter()
-                .filter(|(id, _)| ids.contains(id))
-                .map(|(id, a)| (id, shc.col_left(a.cell.col) + a.dx as f64, shc.row_top(a.cell.row) + a.dy as f64, a.width, a.height))
-                .collect()
-        };
-        if geo.len() < 2 {
-            return Ok(Json::Null);
-        }
-        let left = geo.iter().map(|g| g.1).fold(f64::INFINITY, f64::min);
-        let right = geo.iter().map(|g| g.1 + g.3 as f64).fold(f64::NEG_INFINITY, f64::max);
-        let top = geo.iter().map(|g| g.2).fold(f64::INFINITY, f64::min);
-        let bottom = geo.iter().map(|g| g.2 + g.4 as f64).fold(f64::NEG_INFINITY, f64::max);
-        let shc = sheet.clone();
-        for (id, a) in anchors_of(sheet, &kind) {
-            let Some(g) = geo.iter().find(|g| g.0 == id) else { continue };
-            let (mut x, mut y) = (g.1, g.2);
-            match how.as_str() {
-                "left" => x = left,
-                "right" => x = right - g.3 as f64,
-                "center" => x = (left + right) / 2.0 - g.3 as f64 / 2.0,
-                "top" => y = top,
-                "bottom" => y = bottom - g.4 as f64,
-                _ => y = (top + bottom) / 2.0 - g.4 as f64 / 2.0,
-            }
-            let c = CellRef::new(shc.row_at(y), shc.col_at(x));
-            a.cell = c;
-            a.dx = (x - shc.col_left(c.col)) as f32;
-            a.dy = (y - shc.row_top(c.row)) as f32;
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn rotate(s: &mut Session, p: &Json) -> Result<Json> {
-    if p.get("flip").is_some_and(|f| !f.is_null()) {
-        return Err(bad("arrange.rotate", "`flip` is not supported: shapes have no flip state"));
-    }
-    with_shape(s, p, |sh| std::mem::swap(&mut sh.anchor.width, &mut sh.anchor.height))
-}
-
-/// Switches a sheet's view. Like zoom, the view is saved with the file but is not an edit: it
-/// neither records an undo step nor marks a clean workbook as changed.
-fn set_view(s: &mut Session, p: &Json, mode: SheetViewMode) -> Result<Json> {
-    let si = target_sheet(s, p)?;
-    let d = s.doc_mut()?;
-    let dirty = d.is_dirty();
-    let wb = std::sync::Arc::make_mut(&mut d.wb);
-    if let Some(sh) = wb.sheet_mut(si) {
-        sh.view = mode;
-    }
-    if !dirty {
-        d.saved = d.wb.clone();
-    }
-    Ok(json!({"view": mode.as_str()}))
-}
-
-fn ruler(s: &mut Session, p: &Json) -> Result<Json> {
-    let on = bool_param(p, "on").unwrap_or(s.hide_ruler);
-    s.hide_ruler = !on;
-    Ok(json!({"on": on}))
-}
-
 const VIEWS_NAME: &str = "_sc_custom_views";
 const SCRIPTS_NAME: &str = "_sc_scripts";
 const WATCH_NAME: &str = "_sc_watch";
@@ -759,592 +352,10 @@ fn stash_set(wb: &mut Workbook, key: &str, v: &Json) {
     wb.names.push(DefinedName { name: key.into(), scope: None, formula, comment: String::new(), hidden: true });
 }
 
-/// The Watch Window list isn't an edit (Excel doesn't undo it): undo and redo keep the current
-/// list when they swap in another snapshot of the workbook.
-pub(crate) fn keep_watch_list(from: &Workbook, to: &mut std::sync::Arc<Workbook>) {
-    let find = |wb: &Workbook| wb.names.iter().find(|n| n.name == WATCH_NAME).cloned();
-    let keep = find(from);
-    if keep == find(to) {
-        return;
-    }
-    let wb = std::sync::Arc::make_mut(to);
-    wb.names.retain(|n| n.name != WATCH_NAME);
-    wb.names.extend(keep);
-}
-
-fn custom_views(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let mut views = stash_map(&d.wb, VIEWS_NAME);
-    if let Some(name) = str_param(p, "save") {
-        let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-        views[name] = json!({"sheet": d.wb.active_sheet(), "selection": d.selection.a1(), "zoom": sh.zoom, "freeze": sh.freeze});
-        let v = views.clone();
-        edit(s, |cx| {
-            stash_set(&mut cx.wb, VIEWS_NAME, &v);
-            Ok(())
-        })?;
-    } else if let Some(name) = str_param(p, "show") {
-        let v = views.get(name).cloned().ok_or_else(|| bad("view.customViews", "no such view"))?;
-        if let Some(si) = v["sheet"].as_u64() {
-            s.execute("sheet.activate", json!({"sheet": si}))?;
-        }
-        if let Some(sel) = v["selection"].as_str() {
-            s.execute("selection.set", json!({"range": sel}))?;
-        }
-        if let Some(z) = v["zoom"].as_u64() {
-            s.execute("view.zoom", json!({"percent": z}))?;
-        }
-        if let Some(f) = v.get("freeze") {
-            let freeze = match (f[0].as_u64(), f[1].as_u64()) {
-                (Some(r), Some(c)) => u32::try_from(r).ok().zip(u32::try_from(c).ok()),
-                _ => None,
-            };
-            edit(s, |cx| {
-                let si = cx.sheet_index();
-                cx.sheet_mut(si)?.freeze = freeze;
-                Ok(())
-            })?;
-        }
-    } else if let Some(name) = str_param(p, "delete") {
-        if let Some(o) = views.as_object_mut() {
-            o.remove(name);
-        }
-        let v = views.clone();
-        edit(s, |cx| {
-            stash_set(&mut cx.wb, VIEWS_NAME, &v);
-            Ok(())
-        })?;
-    }
-    Ok(stash_get(&s.doc()?.wb, VIEWS_NAME))
-}
-
-fn split(s: &mut Session, _: &Json) -> Result<Json> {
-    let has = s.doc()?.wb.active().is_some_and(|sh| sh.freeze.is_some());
-    if has { s.execute("view.unfreezePanes", json!({})) } else { s.execute("view.freezePanes", json!({})) }
-}
-
-fn new_window(s: &mut Session, _: &Json) -> Result<Json> {
-    let id = s.new_window()?;
-    let doc = s.window(id).map(|w| w.doc_uid);
-    Ok(json!({"window": id, "doc": doc, "title": s.window_title(id)}))
-}
-
-/// The window a window command names: `window` (an id), else `doc` (a workbook id: its most
-/// recent window), else the active window.
-pub(crate) fn window_param(s: &Session, cmd: &str, p: &Json) -> Result<u64> {
-    let t = crate::Target::from_json(p).map_err(|e| bad(cmd, e.to_string()))?;
-    s.target_window(t).map_err(|e| bad(cmd, e.to_string()))
-}
-
-/// View › Arrange All. The engine has no window geometry: it picks the windows and the layout,
-/// and the interface moves its native windows ([`Session::window_list`] order, active first).
-fn arrange_all(s: &mut Session, p: &Json) -> Result<Json> {
-    let arrange = match str_param(p, "arrange").unwrap_or("tiled") {
-        a @ ("tiled" | "horizontal" | "vertical" | "cascade") => a,
-        other => return Err(bad("view.arrangeAll", format!("`arrange` must be tiled, horizontal, vertical or cascade, not `{other}`"))),
-    };
-    let active = s.active_window();
-    let doc = active.and_then(|w| s.window(w)).map(|w| w.doc_uid);
-    let only_active = p.get("activeWorkbook").and_then(Json::as_bool).unwrap_or(false);
-    let mut windows: Vec<u64> = s.windows().iter().filter(|w| !w.hidden && (!only_active || Some(w.doc_uid) == doc)).map(|w| w.id).collect();
-    if let Some(at) = windows.iter().position(|w| Some(*w) == active)
-        && let Some(first) = windows.get_mut(..=at)
-    {
-        first.rotate_right(1);
-    }
-    Ok(json!({"arrange": arrange, "windows": windows}))
-}
-
-fn hide_window(s: &mut Session, p: &Json) -> Result<Json> {
-    let id = window_param(s, "view.hideWindow", p)?;
-    s.hide_window(id);
-    ok()
-}
-
-fn unhide_window(s: &mut Session, p: &Json) -> Result<Json> {
-    let id = if p.get("window").is_some_and(|v| !v.is_null()) || p.get("doc").is_some_and(|v| !v.is_null()) {
-        Some(window_param(s, "view.unhideWindow", p)?)
-    } else if let Some(i) = u32_param(p, "index") {
-        // A workbook's position in the document list.
-        let uid = s.documents().get(i as usize).map(|d| d.uid).ok_or_else(|| bad("view.unhideWindow", "no such window"))?;
-        s.windows().iter().filter(|w| w.doc_uid == uid && w.hidden).map(|w| w.id).next_back().or_else(|| s.doc_window(uid))
-    } else {
-        s.last_hidden_window()
-    };
-    if let Some(id) = id {
-        s.unhide_window(id);
-    }
-    ok()
-}
-
-fn switch_windows(s: &mut Session, p: &Json) -> Result<Json> {
-    if p.get("window").is_some_and(|v| !v.is_null()) || p.get("doc").is_some_and(|v| !v.is_null()) {
-        let id = window_param(s, "view.switchWindows", p)?;
-        s.unhide_window(id);
-    }
-    Ok(s.window_list())
-}
-
-fn table_resize(s: &mut Session, p: &Json) -> Result<Json> {
-    let r = str_param(p, "range").and_then(RangeRef::parse).ok_or_else(|| bad("table.resize", "missing `range`"))?;
-    let d = s.doc()?;
-    let si = d.wb.active_sheet();
-    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
-    let ti = match str_param(p, "table") {
-        Some(n) => sh.tables.iter().position(|t| t.name.eq_ignore_ascii_case(n)),
-        None => sh.tables.iter().position(|t| t.range.contains(d.selection.active)),
-    }
-    .ok_or_else(|| bad("table.resize", "select a cell in a table"))?;
-    edit(s, |cx| {
-        let sheet = cx.sheet_mut(si)?;
-        let headers: Vec<String> = (r.start.col..=r.end.col).map(|c| sheet.value(CellRef::new(r.start.row, c)).display()).collect();
-        if sheet.tables.iter().enumerate().any(|(i, o)| i != ti && o.range.intersects(&r)) {
-            return Err(EngineError::Other("A table can't overlap another table.".into()));
-        }
-        let t = sheet.tables.get_mut(ti).ok_or_else(|| bad("table", "gone"))?;
-        if r.start.row != t.range.start.row || !r.intersects(&t.range) {
-            return Err(EngineError::Other(
-                "The headers must remain in the same row, and the resulting table range must overlap the original table range.".into(),
-            ));
-        }
-        let mut cols = Vec::new();
-        for (i, h) in headers.iter().enumerate() {
-            let name = if h.is_empty() { format!("Column{}", i + 1) } else { h.clone() };
-            let existing = t.columns.iter().find(|c| c.name.eq_ignore_ascii_case(&name)).cloned();
-            cols.push(existing.unwrap_or(TableColumn {
-                name,
-                totals: TotalsFn::None,
-                totals_label: None,
-                formula: None,
-                unique_name: None,
-                xml: None,
-            }));
-        }
-        t.columns = cols;
-        t.range = r;
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-fn from_csv(s: &mut Session, p: &Json) -> Result<Json> {
-    let bytes = if let Some(t) = str_param(p, "text") {
-        t.as_bytes().to_vec()
-    } else if let Some(path) = str_param(p, "path") {
-        crate::io::read_file(path)?
-    } else {
-        s.ui_requests.push(crate::UiRequest::Dialog("open".into(), json!({})));
-        return ok();
-    };
-    let text = String::from_utf8_lossy(&bytes);
-    // JSON array of objects → rows.
-    let rows: Vec<Vec<Json>> =
-        if text.trim_start().starts_with('[') {
-            let arr: Vec<Json> = serde_json::from_str(&text).map_err(|e| bad("data.getData", e.to_string()))?;
-            let mut keys: Vec<String> = Vec::new();
-            for o in &arr {
-                if let Some(m) = o.as_object() {
-                    for k in m.keys() {
-                        if !keys.contains(k) {
-                            keys.push(k.clone());
-                        }
-                    }
-                }
-            }
-            let mut out = vec![keys.iter().map(|k| json!(k)).collect::<Vec<_>>()];
-            for o in &arr {
-                out.push(keys.iter().map(|k| o.get(k).cloned().unwrap_or(Json::Null)).collect());
-            }
-            out
-        } else {
-            let delim = str_param(p, "delimiter")
-                .and_then(|d| d.chars().next())
-                .unwrap_or(if text.lines().next().is_some_and(|l| l.contains('\t')) { '\t' } else { ',' });
-            let opts = gridcraft_xlsx::CsvOptions { delimiter: delim as u8, ..Default::default() };
-            let wb = gridcraft_xlsx::read_csv(&bytes, &opts).map_err(|e| EngineError::Other(e.to_string()))?;
-            let sh = wb.sheet(0).ok_or(EngineError::NoDocument)?;
-            let Some(u) = sh.used_range() else { return Err(EngineError::Other("The file is empty.".into())) };
-            (u.start.row..=u.end.row)
-                .map(|r| {
-                    (u.start.col..=u.end.col)
-                        .map(|c| match sh.value(CellRef::new(r, c)) {
-                            Value::Number(n) => json!(n),
-                            Value::Bool(b) => json!(b),
-                            Value::Empty => Json::Null,
-                            v => json!(v.display()),
-                        })
-                        .collect()
-                })
-                .collect()
-        };
-    if rows.is_empty() || rows.len() > 1_048_576 {
-        return Err(EngineError::Other("Nothing to import.".into()));
-    }
-    let name = str_param(p, "sheet").map(str::to_string).or_else(|| {
-        str_param(p, "path").and_then(|x| std::path::Path::new(x).file_stem().and_then(std::ffi::OsStr::to_str).map(|f| f.chars().take(31).collect()))
-    });
-    let r = s.execute("home.insertSheet", json!({"name": name})).or_else(|_| s.execute("home.insertSheet", json!({})))?;
-    let w = rows.iter().map(Vec::len).max().unwrap_or(1).max(1);
-    s.execute("range.setValues", json!({"range": "A1", "values": rows}))?;
-    let range = RangeRef::new(CellRef::new(0, 0), CellRef::new(rows.len() as u32 - 1, w as u32 - 1));
-    let _ = s.execute("insert.table", json!({"range": range.a1(), "header": true}));
-    let _ = s.execute("home.autofitColumnWidth", json!({"cols": RangeRef::cols(0, w as u32 - 1).a1()}));
-    Ok(json!({"sheet": r["name"], "rows": rows.len(), "cols": w}))
-}
-
-fn from_table_range(s: &mut Session, p: &Json) -> Result<Json> {
-    let r = target_range(s, p)?;
-    let d = s.doc()?;
-    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-    let r = if r.is_single() { crate::selection::current_region(sh, r.start) } else { r };
-    let text = crate::display::range_text(&d.wb, d.wb.active_sheet(), r);
-    from_csv(s, &json!({"text": text, "delimiter": "\t", "sheet": format!("{} (2)", sh.name).chars().take(31).collect::<String>()}))
-}
-
-fn queries(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    Ok(Json::Array(
-        d.wb.sheets
-            .iter()
-            .flat_map(|sh| {
-                sh.tables
-                    .iter()
-                    .map(move |t| json!({"name": t.name, "sheet": sh.name, "range": t.range.a1(), "rows": t.range.height().saturating_sub(1)}))
-            })
-            .collect(),
-    ))
-}
-
-fn record(s: &mut Session, p: &Json) -> Result<Json> {
-    if bool_param(p, "stop").unwrap_or(false) || s.recording.is_some() {
-        let Some(start) = s.recording.take() else { return Ok(json!({"recording": false})) };
-        let cmds: Vec<Json> =
-            s.journal.iter().skip(start).filter(|(id, _)| !id.starts_with("automate.")).map(|(id, p)| json!({"command": id, "params": p})).collect();
-        let name = str_param(p, "name").map(str::to_string).unwrap_or_else(|| format!("Script {}", start));
-        s.execute("automate.newScript", json!({"name": name, "commands": cmds}))?;
-        return Ok(json!({"recording": false, "saved": name, "steps": cmds.len()}));
-    }
-    s.recording = Some(s.journal.len());
-    Ok(json!({"recording": true}))
-}
-
-fn new_script(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").ok_or_else(|| bad("automate.newScript", "missing `name`"))?.to_string();
-    let cmds = p.get("commands").cloned().unwrap_or(json!([]));
-    if !cmds.is_array() {
-        return Err(bad("automate.newScript", "`commands` must be an array"));
-    }
-    edit(s, |cx| {
-        let mut all = stash_map(&cx.wb, SCRIPTS_NAME);
-        all[name.as_str()] = cmds.clone();
-        stash_set(&mut cx.wb, SCRIPTS_NAME, &all);
-        Ok(json!({"name": name}))
-    })
-}
-
-fn all_scripts(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let (wb, trusted) = (&d.wb, d.scripts_trusted);
-    let all = stash_get(wb, SCRIPTS_NAME);
-    let mut list: Vec<Json> = all
-        .as_object()
-        .map(|o| o.iter().map(|(k, v)| json!({"name": k, "steps": v.as_array().map_or(0, Vec::len), "trusted": trusted})).collect())
-        .unwrap_or_default();
-    // A preserved VBA project is reported alongside GridCraft's own scripts; it is carried on
-    // save but never executed here, so it has no step count.
-    if let Some(bytes) = &wb.vba_project {
-        list.push(json!({"name": "(VBA)", "steps": 0, "kind": "vba", "size": bytes.len(), "executed": false}));
-    }
-    Ok(Json::Array(list))
-}
-
-/// Whether `wb` carries GridCraft scripts (a workbook opened with them starts untrusted).
-pub(crate) fn has_scripts(wb: &Workbook) -> bool {
-    stash_map(wb, SCRIPTS_NAME).as_object().is_some_and(|o| !o.is_empty())
-}
-
-/// Why a script step is refused, whatever the workbook's trust: scripts stay inside the
-/// workbook. Anything that reads or writes files (`file.*`, or any `path` parameter: Get Data,
-/// From Text/CSV, Insert Picture) or leaves the app (`link.*` opens URLs) is the caller's to run
-/// directly, not a stored script's. (Nested `automate.*` steps are skipped.) This check goes by
-/// command id and parameter name, so it is only the up-front refusal: the steps also run inside
-/// an [`crate::io::ScriptSandbox`] (file access refused whatever the parameter is called) and
-/// [`run_script`] drops any `OpenUrl` request a step raises.
-fn denied_script_step(id: &str, params: &Json) -> Option<String> {
-    if id.starts_with("file.") || id.starts_with("link.") {
-        return Some(format!("scripts can't run `{id}`: it reaches outside the workbook"));
-    }
-    // Scripts are scoped to their workbook: a step that switches the active window would
-    // point every later step at another open document, so those are refused too.
-    if id.starts_with("window.") || matches!(id, "view.switchWindows" | "view.newWindow" | "view.hideWindow" | "view.unhideWindow") {
-        return Some(format!("scripts can't run `{id}`: it reaches outside the workbook"));
-    }
-    if params.get("path").is_some() {
-        return Some(format!("scripts can't pass a file `path` to `{id}`"));
-    }
-    None
-}
-
-fn trust_scripts(s: &mut Session, p: &Json) -> Result<Json> {
-    // Only a missing `trusted` means "trust"; `"false"`, `0` or `null` are mistakes, not consent.
-    let trusted = match p.get("trusted") {
-        None => true,
-        Some(Json::Bool(b)) => *b,
-        Some(_) => return Err(bad("automate.trustScripts", "`trusted` must be true or false")),
-    };
-    s.doc_mut()?.scripts_trusted = trusted;
-    Ok(json!({"trusted": trusted}))
-}
-
-/// Runs a stored script. Scripts in a workbook opened from a file run only once the workbook is
-/// trusted for this session (`automate.trustScripts`, or `trusted: true` on this call); steps that
-/// reach outside the workbook ([`denied_script_step`]) are refused before any step runs.
-fn run_script(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").ok_or_else(|| bad("automate.runScript", "missing `name`"))?;
-    let d = s.doc()?;
-    let all = stash_get(&d.wb, SCRIPTS_NAME);
-    let steps = all.get(name).and_then(Json::as_array).cloned().ok_or_else(|| bad("automate.runScript", "no such script"))?;
-    if !d.scripts_trusted && !bool_param(p, "trusted").unwrap_or(false) {
-        return Err(bad(
-            "automate.runScript",
-            "scripts in this workbook came from a file and are disabled; trust the workbook first (Trust Scripts in View › Macros, Alt+F8; `automate.trustScripts`; or `trusted: true`)",
-        ));
-    }
-    let steps: Vec<Json> = steps.into_iter().take(100_000).collect();
-    for st in &steps {
-        let id = st["command"].as_str().unwrap_or("");
-        if let Some(why) = denied_script_step(id, &st["params"]) {
-            return Err(bad("automate.runScript", why));
-        }
-    }
-    let _sandbox = crate::io::ScriptSandbox::enter();
-    let mut n = 0;
-    for st in &steps {
-        let id = st["command"].as_str().unwrap_or("");
-        if id.starts_with("automate.") {
-            continue;
-        }
-        let before = s.ui_requests.len();
-        let ran = s.execute(id, st["params"].clone());
-        // A step that asks the host to open a URL leaves the app: drop the request and stop.
-        if s.ui_requests.get(before..).is_some_and(|new| new.iter().any(|r| matches!(r, crate::UiRequest::OpenUrl(_)))) {
-            let mut i = 0;
-            s.ui_requests.retain(|r| {
-                i += 1;
-                i <= before || !matches!(r, crate::UiRequest::OpenUrl(_))
-            });
-            return Err(bad("automate.runScript", format!("scripts can't open links (`{id}`)")));
-        }
-        ran?;
-        n += 1;
-    }
-    Ok(json!({"ran": n}))
-}
-
-/// Automate › Stop Action: rolls back the undo groups open on the active workbook, so Undo and
-/// Redo work there again.
-fn stop_action(s: &mut Session, _: &Json) -> Result<Json> {
-    let uid = s.doc()?.uid;
-    Ok(json!({"stopped": s.abort_groups(uid)}))
-}
-
-fn delete_script(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").ok_or_else(|| bad("automate.deleteScript", "missing `name`"))?.to_string();
-    edit(s, |cx| {
-        let mut all = stash_map(&cx.wb, SCRIPTS_NAME);
-        if let Some(o) = all.as_object_mut() {
-            o.remove(&name);
-        }
-        stash_set(&mut cx.wb, SCRIPTS_NAME, &all);
-        Ok(Json::Null)
-    })
-}
-
 /// Number format that marks checkbox cells (TRUE/FALSE values drawn as boxes).
 pub const CHECKBOX_FORMAT: &str = "\"☐\";\"☐\";\"☐\";[=1]\"☑\"";
 
-/// Whether `c` has checkbox formatting.
-pub(crate) fn is_checkbox_cell(wb: &gridcraft_model::Workbook, sh: &gridcraft_model::Sheet, c: CellRef) -> bool {
-    wb.styles.get(sh.style_id(c)).num_fmt.as_str() == "checkbox"
-}
-
-fn checkbox(s: &mut Session, p: &Json) -> Result<Json> {
-    let ranges = target_ranges(s, p)?;
-    let si = target_sheet(s, p)?;
-    edit(s, |cx| {
-        for r in &ranges {
-            if r.count() > 100_000 {
-                return Err(bad("insert.checkbox", "range too large"));
-            }
-            for c in r.iter() {
-                let st = cx.wb.sheet(si).map(|sh| sh.style_id(c)).unwrap_or_default();
-                let new = cx.wb.styles.derive(st, |s| {
-                    s.num_fmt = NumFmt::new("checkbox");
-                    s.align.h = HAlign::Center;
-                });
-                let sh = cx.sheet_mut(si)?;
-                // Values and formulas already there stay (only TRUE/FALSE draw as a box); an empty
-                // cell starts unchecked.
-                let mut cell = sh.cell(c).cloned().unwrap_or_default();
-                if cell.value.is_empty() && cell.formula.is_none() {
-                    cell.value = Value::Bool(false);
-                }
-                cell.style = new;
-                sh.set_cell(c, cell);
-                cx.touch(si, c);
-            }
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn toggle_checkbox(s: &mut Session, p: &Json) -> Result<Json> {
-    let si = target_sheet(s, p)?;
-    let d = s.doc()?;
-    let cells: Vec<CellRef> = match cell_param_on(s, p, "cell", si)? {
-        Some(c) => vec![c],
-        None => d.selection.ranges.iter().flat_map(|r| r.iter().take(100_000).collect::<Vec<_>>()).collect(),
-    };
-    edit(s, |cx| {
-        for c in cells {
-            let checkbox = cx.wb.sheet(si).is_some_and(|sh| is_checkbox_cell(&cx.wb, sh, c));
-            let sh = cx.sheet_mut(si)?;
-            if let Some(cell) = sh.cells.get_mut(c)
-                && cell.formula.is_none()
-            {
-                // An empty checkbox cell counts as FALSE.
-                let next = match cell.value {
-                    Value::Bool(b) if checkbox => Value::Bool(!b),
-                    Value::Empty if checkbox => Value::Bool(true),
-                    _ => continue,
-                };
-                cell.value = next;
-                cx.changed.push((si, c));
-            }
-        }
-        Ok(Json::Null)
-    })
-}
-
 /// Copy of the params that is always a JSON object, so keys can be assigned; any other JSON value counts as no params (like null).
 fn object_params(p: &Json) -> Json {
     Json::Object(p.as_object().cloned().unwrap_or_default())
 }
-
-fn theme_colors(s: &mut Session, p: &Json) -> Result<Json> {
-    let mut params = object_params(p);
-    if params.get("name").is_none() {
-        params["name"] = json!(s.doc()?.wb.theme.name.clone());
-    }
-    s.execute("pageLayout.theme", params)
-}
-
-fn theme_fonts(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = s.doc()?.wb.theme.name.clone();
-    let colors: Vec<String> = s.doc()?.wb.theme.colors.iter().map(|c| format!("#{c:06X}")).collect();
-    s.execute("pageLayout.theme", json!({"name": name, "colors": colors, "majorFont": p.get("major"), "minorFont": p.get("minor")}))
-}
-
-fn background(s: &mut Session, p: &Json) -> Result<Json> {
-    if bool_param(p, "clear").unwrap_or(false) {
-        let si = s.doc()?.wb.active_sheet();
-        return edit(s, |cx| {
-            cx.sheet_mut(si)?.images.retain(|i| i.alt != "Sheet background");
-            Ok(Json::Null)
-        });
-    }
-    let mut params = object_params(p);
-    params["alt"] = json!("Sheet background");
-    params["at"] = json!("A1");
-    s.execute("insert.picture", params)
-}
-
-fn draw_border(s: &mut Session, p: &Json) -> Result<Json> {
-    let edge = str_param(p, "edge").unwrap_or("grid");
-    let preset = match edge {
-        "top" => "top",
-        "bottom" => "bottom",
-        "left" => "left",
-        "right" => "right",
-        "outline" => "outside",
-        _ => "all",
-    };
-    let mut params = object_params(p);
-    params["preset"] = json!(preset);
-    s.execute("home.borders", params)
-}
-
-fn new_cell_style(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").ok_or_else(|| bad("home.newCellStyle", "missing `name`"))?.to_string();
-    let d = s.doc()?;
-    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-    let c = cell_param(s, p, "fromCell")?.unwrap_or(d.selection.active);
-    let style = d.wb.styles.get(sh.style_id(c)).clone();
-    edit(s, |cx| {
-        cx.wb.cell_styles.retain(|(n, _)| !n.eq_ignore_ascii_case(&name));
-        cx.wb.cell_styles.push((name.clone(), style.clone()));
-        Ok(json!({"name": name}))
-    })
-}
-
-fn recently_used(s: &mut Session, _: &Json) -> Result<Json> {
-    let mut seen: Vec<String> = Vec::new();
-    for (id, p) in s.journal.iter().rev() {
-        if id != "cell.set" {
-            continue;
-        }
-        let input = p.get("input").and_then(Json::as_str).unwrap_or("");
-        if let Ok(e) = gridcraft_formula::parse(input.trim_start_matches('=')) {
-            for f in e.functions() {
-                if !seen.iter().any(|x| x == f) {
-                    seen.push(f.to_string());
-                }
-            }
-        }
-        if seen.len() >= 10 {
-            break;
-        }
-    }
-    Ok(json!(seen))
-}
-
-fn use_in_formula(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").ok_or_else(|| bad("formulas.useInFormula", "missing `name`"))?;
-    s.ui_requests.push(crate::UiRequest::InsertName(name.to_string()));
-    ok()
-}
-
-fn watch_window(s: &mut Session, p: &Json) -> Result<Json> {
-    let mut list: Vec<String> =
-        stash_get(&s.doc()?.wb, WATCH_NAME).as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default();
-    let mut changed = false;
-    if let Some(a) = str_param(p, "add") {
-        if !list.iter().any(|x| x == a) {
-            list.push(a.to_string());
-        }
-        changed = true;
-    }
-    if let Some(r) = str_param(p, "remove") {
-        list.retain(|x| x != r);
-        changed = true;
-    }
-    if changed {
-        let v = json!(list.clone());
-        let d = s.doc_mut()?;
-        // The watch list is view state: don't add an undo step.
-        let wb = std::sync::Arc::make_mut(&mut d.wb);
-        stash_set(wb, WATCH_NAME, &v);
-    }
-    let d = s.doc()?;
-    let rows: Vec<Json> = list
-        .iter()
-        .map(|w| {
-            let (sheet, body) = split_sheet(w);
-            let si = sheet.and_then(|n| d.wb.sheet_index(&n)).unwrap_or(d.wb.active_sheet());
-            let c = CellRef::parse(body).unwrap_or_default();
-            let sh = d.wb.sheet(si);
-            json!({"cell": w, "value": sh.map(|s| s.value(c).display()), "formula": sh.and_then(|s| s.cell(c)).and_then(|x| x.formula.as_ref()).map(|f| format!("={}", f.text))})
-        })
-        .collect();
-    Ok(Json::Array(rows))
-}
diff --git a/crates/engine/src/cmd/extra/cells.rs b/crates/engine/src/cmd/extra/cells.rs
new file mode 100644
index 000000000..5cddf0982
--- /dev/null
+++ b/crates/engine/src/cmd/extra/cells.rs
@@ -0,0 +1,147 @@
+use super::*;
+
+/// Whether `c` has checkbox formatting.
+pub(crate) fn is_checkbox_cell(wb: &gridcraft_model::Workbook, sh: &gridcraft_model::Sheet, c: CellRef) -> bool {
+    wb.styles.get(sh.style_id(c)).num_fmt.as_str() == "checkbox"
+}
+
+pub(super) fn checkbox(s: &mut Session, p: &Json) -> Result<Json> {
+    let ranges = target_ranges(s, p)?;
+    let si = target_sheet(s, p)?;
+    edit(s, |cx| {
+        for r in &ranges {
+            if r.count() > 100_000 {
+                return Err(bad("insert.checkbox", "range too large"));
+            }
+            for c in r.iter() {
+                let st = cx.wb.sheet(si).map(|sh| sh.style_id(c)).unwrap_or_default();
+                let new = cx.wb.styles.derive(st, |s| {
+                    s.num_fmt = NumFmt::new("checkbox");
+                    s.align.h = HAlign::Center;
+                });
+                let sh = cx.sheet_mut(si)?;
+                // Values and formulas already there stay (only TRUE/FALSE draw as a box); an empty
+                // cell starts unchecked.
+                let mut cell = sh.cell(c).cloned().unwrap_or_default();
+                if cell.value.is_empty() && cell.formula.is_none() {
+                    cell.value = Value::Bool(false);
+                }
+                cell.style = new;
+                sh.set_cell(c, cell);
+                cx.touch(si, c);
+            }
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn toggle_checkbox(s: &mut Session, p: &Json) -> Result<Json> {
+    let si = target_sheet(s, p)?;
+    let d = s.doc()?;
+    let cells: Vec<CellRef> = match cell_param_on(s, p, "cell", si)? {
+        Some(c) => vec![c],
+        None => d.selection.ranges.iter().flat_map(|r| r.iter().take(100_000).collect::<Vec<_>>()).collect(),
+    };
+    edit(s, |cx| {
+        for c in cells {
+            let checkbox = cx.wb.sheet(si).is_some_and(|sh| is_checkbox_cell(&cx.wb, sh, c));
+            let sh = cx.sheet_mut(si)?;
+            if let Some(cell) = sh.cells.get_mut(c)
+                && cell.formula.is_none()
+            {
+                // An empty checkbox cell counts as FALSE.
+                let next = match cell.value {
+                    Value::Bool(b) if checkbox => Value::Bool(!b),
+                    Value::Empty if checkbox => Value::Bool(true),
+                    _ => continue,
+                };
+                cell.value = next;
+                cx.changed.push((si, c));
+            }
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn theme_colors(s: &mut Session, p: &Json) -> Result<Json> {
+    let mut params = object_params(p);
+    if params.get("name").is_none() {
+        params["name"] = json!(s.doc()?.wb.theme.name.clone());
+    }
+    s.execute("pageLayout.theme", params)
+}
+
+pub(super) fn theme_fonts(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = s.doc()?.wb.theme.name.clone();
+    let colors: Vec<String> = s.doc()?.wb.theme.colors.iter().map(|c| format!("#{c:06X}")).collect();
+    s.execute("pageLayout.theme", json!({"name": name, "colors": colors, "majorFont": p.get("major"), "minorFont": p.get("minor")}))
+}
+
+pub(super) fn background(s: &mut Session, p: &Json) -> Result<Json> {
+    if bool_param(p, "clear").unwrap_or(false) {
+        let si = s.doc()?.wb.active_sheet();
+        return edit(s, |cx| {
+            cx.sheet_mut(si)?.images.retain(|i| i.alt != "Sheet background");
+            Ok(Json::Null)
+        });
+    }
+    let mut params = object_params(p);
+    params["alt"] = json!("Sheet background");
+    params["at"] = json!("A1");
+    s.execute("insert.picture", params)
+}
+
+pub(super) fn draw_border(s: &mut Session, p: &Json) -> Result<Json> {
+    let edge = str_param(p, "edge").unwrap_or("grid");
+    let preset = match edge {
+        "top" => "top",
+        "bottom" => "bottom",
+        "left" => "left",
+        "right" => "right",
+        "outline" => "outside",
+        _ => "all",
+    };
+    let mut params = object_params(p);
+    params["preset"] = json!(preset);
+    s.execute("home.borders", params)
+}
+
+pub(super) fn new_cell_style(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").ok_or_else(|| bad("home.newCellStyle", "missing `name`"))?.to_string();
+    let d = s.doc()?;
+    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+    let c = cell_param(s, p, "fromCell")?.unwrap_or(d.selection.active);
+    let style = d.wb.styles.get(sh.style_id(c)).clone();
+    edit(s, |cx| {
+        cx.wb.cell_styles.retain(|(n, _)| !n.eq_ignore_ascii_case(&name));
+        cx.wb.cell_styles.push((name.clone(), style.clone()));
+        Ok(json!({"name": name}))
+    })
+}
+
+pub(super) fn recently_used(s: &mut Session, _: &Json) -> Result<Json> {
+    let mut seen: Vec<String> = Vec::new();
+    for (id, p) in s.journal.iter().rev() {
+        if id != "cell.set" {
+            continue;
+        }
+        let input = p.get("input").and_then(Json::as_str).unwrap_or("");
+        if let Ok(e) = gridcraft_formula::parse(input.trim_start_matches('=')) {
+            for f in e.functions() {
+                if !seen.iter().any(|x| x == f) {
+                    seen.push(f.to_string());
+                }
+            }
+        }
+        if seen.len() >= 10 {
+            break;
+        }
+    }
+    Ok(json!(seen))
+}
+
+pub(super) fn use_in_formula(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").ok_or_else(|| bad("formulas.useInFormula", "missing `name`"))?;
+    s.ui_requests.push(crate::UiRequest::InsertName(name.to_string()));
+    ok()
+}
diff --git a/crates/engine/src/cmd/extra/chart.rs b/crates/engine/src/cmd/extra/chart.rs
new file mode 100644
index 000000000..2e16befa6
--- /dev/null
+++ b/crates/engine/src/cmd/extra/chart.rs
@@ -0,0 +1,259 @@
+use super::*;
+
+fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
+    let d = s.doc()?;
+    let si = d.wb.active_sheet();
+    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
+    let idx = match u32_param(p, "chart") {
+        Some(id) => sh.charts.iter().position(|c| c.id == id),
+        None => sh.charts.len().checked_sub(1),
+    };
+    idx.map(|i| (si, i)).ok_or_else(|| bad("chart", "no chart on this sheet"))
+}
+
+fn with_chart(s: &mut Session, p: &Json, f: impl FnOnce(&mut Chart) -> Result<()>) -> Result<Json> {
+    let (si, ci) = find_chart(s, p)?;
+    edit(s, |cx| {
+        let c = cx.sheet_mut(si)?.charts.get_mut(ci).ok_or_else(|| bad("chart", "no such chart"))?;
+        f(c)?;
+        Ok(json!({"chart": c.id}))
+    })
+}
+
+pub(super) fn add_element(s: &mut Session, p: &Json) -> Result<Json> {
+    let el = str_param(p, "element").unwrap_or("title").to_string();
+    let on = bool_param(p, "on").unwrap_or(true);
+    let pos = str_param(p, "position").map(str::to_string);
+    with_chart(s, p, |c| {
+        match el.as_str() {
+            "title" => c.title = if on { c.title.clone().filter(|t| !t.is_empty()).or(Some("Chart Title".into())) } else { Some(String::new()) },
+            "legend" => {
+                c.legend = if !on {
+                    LegendPos::None
+                } else {
+                    match pos.as_deref() {
+                        Some("top") => LegendPos::Top,
+                        Some("left") => LegendPos::Left,
+                        Some("right") => LegendPos::Right,
+                        _ => LegendPos::Bottom,
+                    }
+                }
+            }
+            "dataLabels" => c.data_labels = on,
+            "gridlines" => c.gridlines = on,
+            "axisTitles" => {
+                c.x_title = on.then(|| c.x_title.clone().unwrap_or_else(|| "Axis Title".into()));
+                c.y_title = on.then(|| c.y_title.clone().unwrap_or_else(|| "Axis Title".into()));
+            }
+            "smooth" => {
+                for s in &mut c.series {
+                    s.smooth = on;
+                }
+            }
+            "trendline" => {
+                let only = u32_param(p, "series").map(|i| i as usize);
+                if only.is_some_and(|i| i >= c.series.len()) {
+                    return Err(bad("chart.addElement", "no such series"));
+                }
+                let targets: Vec<usize> = (0..c.series.len()).filter(|i| only.is_none_or(|o| o == *i)).collect();
+                if !on {
+                    for i in targets {
+                        if let Some(se) = c.series.get_mut(i) {
+                            se.trendlines.clear();
+                        }
+                    }
+                    return Ok(());
+                }
+                let t = trendline_param(p)?;
+                let eligible: Vec<usize> =
+                    targets.into_iter().filter(|i| gridcraft_chart::supports_trendline(gridcraft_chart::series_plot_kind(c, *i))).collect();
+                if eligible.is_empty() {
+                    return Err(bad("chart.addElement", "trendlines need a 2-D column, bar, line, area, scatter or bubble series"));
+                }
+                for i in eligible {
+                    if let Some(se) = c.series.get_mut(i) {
+                        se.trendlines.push(t.clone());
+                    }
+                }
+            }
+            other => return Err(bad("chart.addElement", format!("unknown element `{other}`"))),
+        }
+        Ok(())
+    })
+}
+
+/// The trendline described by `chart.addElement`'s trendline parameters (Excel's Add Chart
+/// Element ▸ Trendline choices, plus the Format Trendline options).
+fn trendline_param(p: &Json) -> Result<Trendline> {
+    let num = |k: &str| Trendline::clamp_forecast(f64_param(p, k).unwrap_or(0.0));
+    let mut t = Trendline {
+        forward: num("forward"),
+        backward: num("backward"),
+        display_equation: bool_param(p, "displayEquation").unwrap_or(false),
+        display_r_squared: bool_param(p, "displayRSquared").unwrap_or(false),
+        ..Trendline::default()
+    };
+    t.kind = match str_param(p, "type").unwrap_or("linear") {
+        "linear" => TrendlineKind::Linear,
+        // Excel's Linear Forecast: a linear trendline projected two periods ahead.
+        "linearForecast" => {
+            if t.forward == 0.0 {
+                t.forward = 2.0;
+            }
+            TrendlineKind::Linear
+        }
+        "exponential" => TrendlineKind::Exponential,
+        "logarithmic" => TrendlineKind::Logarithmic,
+        "power" => TrendlineKind::Power,
+        "polynomial" => TrendlineKind::Polynomial(u32_param(p, "order").unwrap_or(2).clamp(2, 6) as u8),
+        "movingAverage" => TrendlineKind::MovingAverage(u32_param(p, "period").unwrap_or(2).clamp(2, 255)),
+        other => return Err(bad("chart.addElement", format!("unknown trendline type `{other}`"))),
+    };
+    Ok(t)
+}
+
+pub(super) fn quick_layout(s: &mut Session, p: &Json) -> Result<Json> {
+    let n = u32_param(p, "layout").unwrap_or(1);
+    with_chart(s, p, |c| {
+        let (legend, labels, grid, axes) = match n {
+            2 => (LegendPos::Top, true, false, false),
+            3 => (LegendPos::Bottom, false, true, false),
+            4 => (LegendPos::Bottom, true, false, false),
+            5 => (LegendPos::None, false, true, true),
+            6 => (LegendPos::Right, false, true, true),
+            _ => (LegendPos::Right, false, true, false),
+        };
+        c.legend = legend;
+        c.data_labels = labels;
+        c.gridlines = grid;
+        if axes {
+            c.x_title.get_or_insert_with(|| "Axis Title".into());
+            c.y_title.get_or_insert_with(|| "Axis Title".into());
+        } else {
+            c.x_title = None;
+            c.y_title = None;
+        }
+        Ok(())
+    })
+}
+
+pub(super) fn change_colors(s: &mut Session, p: &Json) -> Result<Json> {
+    let explicit: Option<Vec<Color>> =
+        p.get("colors").and_then(Json::as_array).map(|a| a.iter().filter_map(|c| c.as_str().and_then(Color::from_hex)).collect());
+    let palette = str_param(p, "palette").unwrap_or("colorful").to_string();
+    with_chart(s, p, |c| {
+        for (i, se) in c.series.iter_mut().enumerate() {
+            se.color = match &explicit {
+                Some(cols) if !cols.is_empty() => cols.get(i % cols.len()).copied(),
+                _ => match palette.as_str() {
+                    "monochrome" => Some(Color::Theme(4, (-400 + (i as i16 * 200)).clamp(-800, 800))),
+                    p if p.starts_with("accent") => {
+                        let k: u8 = p.trim_start_matches("accent").parse().unwrap_or(1);
+                        Some(Color::Theme(3 + k.clamp(1, 6), (-500 + i as i16 * 250).clamp(-800, 800)))
+                    }
+                    _ => None,
+                },
+            };
+        }
+        Ok(())
+    })
+}
+
+pub(super) fn select_data(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    // A new data range rebuilds the series, as in Excel's Select Data › Chart data range.
+    let rebuilt = match str_param(p, "range") {
+        Some(range) => {
+            let range = range.trim_start_matches('=');
+            let (sheet_name, body) = split_sheet(range);
+            let src_si = match sheet_name {
+                Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("chart.selectData", "no such sheet"))?,
+                None => d.wb.active_sheet(),
+            };
+            let r = RangeRef::parse(body).ok_or_else(|| bad("chart.selectData", "not a range"))?;
+            if r.count() > 1_000_000 {
+                return Err(bad("chart.selectData", "range too large for a chart"));
+            }
+            let src = d.wb.sheet(src_si).ok_or(EngineError::NoDocument)?;
+            let by_rows = bool_param(p, "byRows").unwrap_or(r.width() > r.height() + 1);
+            let series = crate::cmd::insert::series_from_range(src, r, by_rows);
+            Some((series, format!("{}!{}", gridcraft_formula::quote_sheet(&src.name), r.a1()), by_rows))
+        }
+        None => None,
+    };
+    // Horizontal (Category) Axis Labels › Edit: one labels range for every series ("" clears).
+    let categories = match str_param(p, "categories") {
+        None => None,
+        Some(t) if t.trim().trim_start_matches('=').is_empty() => Some(None),
+        Some(t) => {
+            let t = t.trim().trim_start_matches('=');
+            let (sheet_name, body) = split_sheet(t);
+            let si = match sheet_name {
+                Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("chart.selectData", "no such sheet"))?,
+                None => d.wb.active_sheet(),
+            };
+            let r = RangeRef::parse(body).ok_or_else(|| bad("chart.selectData", "`categories` is not a range"))?;
+            let name = d.wb.sheet(si).map(|sh| sh.name.clone()).ok_or(EngineError::NoDocument)?;
+            let abs = |c: CellRef| format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1);
+            Some(Some(format!("{}!{}:{}", gridcraft_formula::quote_sheet(&name), abs(r.start), abs(r.end))))
+        }
+    };
+    let mut remove: Vec<usize> = p
+        .get("removeSeries")
+        .and_then(Json::as_array)
+        .map(|a| a.iter().filter_map(Json::as_u64).filter_map(|i| usize::try_from(i).ok()).collect())
+        .unwrap_or_default();
+    remove.sort_unstable();
+    remove.dedup();
+    if rebuilt.is_none() && categories.is_none() && remove.is_empty() {
+        return Err(bad("chart.selectData", "missing `range`, `categories` or `removeSeries`"));
+    }
+    with_chart(s, p, move |c| {
+        if let Some((series, source, by_rows)) = rebuilt {
+            c.series = series;
+            crate::cmd::insert::scatter_x_from_first(c.kind, &mut c.series);
+            c.source = Some(source);
+            c.by_rows = by_rows;
+        }
+        for i in remove.iter().rev() {
+            if *i < c.series.len() && c.series.len() > 1 {
+                c.series.remove(*i);
+            }
+        }
+        if let Some(cats) = categories {
+            for se in &mut c.series {
+                se.categories = cats.clone();
+            }
+        }
+        Ok(())
+    })
+}
+
+pub(super) fn move_chart(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, ci) = find_chart(s, p)?;
+    let target = match p.get("sheet").and_then(Json::as_str) {
+        Some(n) => Some(s.doc()?.wb.sheet_index(n).ok_or_else(|| bad("chart.move", "no such sheet"))?),
+        None => None,
+    };
+    let at = cell_param_on(s, p, "at", target.unwrap_or(si))?;
+    edit(s, |cx| {
+        let mut chart = cx.sheet_mut(si)?.charts.remove(ci);
+        if let Some(a) = at {
+            chart.anchor.cell = a;
+        }
+        let dest = target.unwrap_or(si);
+        cx.sheet_mut(dest)?.charts.push(chart);
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn format_series(s: &mut Session, p: &Json) -> Result<Json> {
+    let idx = u32_param(p, "series").unwrap_or(0) as usize;
+    let color = str_param(p, "color").and_then(Color::from_hex);
+    with_chart(s, p, |c| {
+        if let Some(se) = c.series.get_mut(idx) {
+            se.color = color;
+        }
+        Ok(())
+    })
+}
diff --git a/crates/engine/src/cmd/extra/data.rs b/crates/engine/src/cmd/extra/data.rs
new file mode 100644
index 000000000..cef840f21
--- /dev/null
+++ b/crates/engine/src/cmd/extra/data.rs
@@ -0,0 +1,131 @@
+use super::*;
+
+pub(super) fn table_resize(s: &mut Session, p: &Json) -> Result<Json> {
+    let r = str_param(p, "range").and_then(RangeRef::parse).ok_or_else(|| bad("table.resize", "missing `range`"))?;
+    let d = s.doc()?;
+    let si = d.wb.active_sheet();
+    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
+    let ti = match str_param(p, "table") {
+        Some(n) => sh.tables.iter().position(|t| t.name.eq_ignore_ascii_case(n)),
+        None => sh.tables.iter().position(|t| t.range.contains(d.selection.active)),
+    }
+    .ok_or_else(|| bad("table.resize", "select a cell in a table"))?;
+    edit(s, |cx| {
+        let sheet = cx.sheet_mut(si)?;
+        let headers: Vec<String> = (r.start.col..=r.end.col).map(|c| sheet.value(CellRef::new(r.start.row, c)).display()).collect();
+        if sheet.tables.iter().enumerate().any(|(i, o)| i != ti && o.range.intersects(&r)) {
+            return Err(EngineError::Other("A table can't overlap another table.".into()));
+        }
+        let t = sheet.tables.get_mut(ti).ok_or_else(|| bad("table", "gone"))?;
+        if r.start.row != t.range.start.row || !r.intersects(&t.range) {
+            return Err(EngineError::Other(
+                "The headers must remain in the same row, and the resulting table range must overlap the original table range.".into(),
+            ));
+        }
+        let mut cols = Vec::new();
+        for (i, h) in headers.iter().enumerate() {
+            let name = if h.is_empty() { format!("Column{}", i + 1) } else { h.clone() };
+            let existing = t.columns.iter().find(|c| c.name.eq_ignore_ascii_case(&name)).cloned();
+            cols.push(existing.unwrap_or(TableColumn {
+                name,
+                totals: TotalsFn::None,
+                totals_label: None,
+                formula: None,
+                unique_name: None,
+                xml: None,
+            }));
+        }
+        t.columns = cols;
+        t.range = r;
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn from_csv(s: &mut Session, p: &Json) -> Result<Json> {
+    let bytes = if let Some(t) = str_param(p, "text") {
+        t.as_bytes().to_vec()
+    } else if let Some(path) = str_param(p, "path") {
+        crate::io::read_file(path)?
+    } else {
+        s.ui_requests.push(crate::UiRequest::Dialog("open".into(), json!({})));
+        return ok();
+    };
+    let text = String::from_utf8_lossy(&bytes);
+    // JSON array of objects → rows.
+    let rows: Vec<Vec<Json>> =
+        if text.trim_start().starts_with('[') {
+            let arr: Vec<Json> = serde_json::from_str(&text).map_err(|e| bad("data.getData", e.to_string()))?;
+            let mut keys: Vec<String> = Vec::new();
+            for o in &arr {
+                if let Some(m) = o.as_object() {
+                    for k in m.keys() {
+                        if !keys.contains(k) {
+                            keys.push(k.clone());
+                        }
+                    }
+                }
+            }
+            let mut out = vec![keys.iter().map(|k| json!(k)).collect::<Vec<_>>()];
+            for o in &arr {
+                out.push(keys.iter().map(|k| o.get(k).cloned().unwrap_or(Json::Null)).collect());
+            }
+            out
+        } else {
+            let delim = str_param(p, "delimiter")
+                .and_then(|d| d.chars().next())
+                .unwrap_or(if text.lines().next().is_some_and(|l| l.contains('\t')) { '\t' } else { ',' });
+            let opts = gridcraft_xlsx::CsvOptions { delimiter: delim as u8, ..Default::default() };
+            let wb = gridcraft_xlsx::read_csv(&bytes, &opts).map_err(|e| EngineError::Other(e.to_string()))?;
+            let sh = wb.sheet(0).ok_or(EngineError::NoDocument)?;
+            let Some(u) = sh.used_range() else { return Err(EngineError::Other("The file is empty.".into())) };
+            (u.start.row..=u.end.row)
+                .map(|r| {
+                    (u.start.col..=u.end.col)
+                        .map(|c| match sh.value(CellRef::new(r, c)) {
+                            Value::Number(n) => json!(n),
+                            Value::Bool(b) => json!(b),
+                            Value::Empty => Json::Null,
+                            v => json!(v.display()),
+                        })
+                        .collect()
+                })
+                .collect()
+        };
+    if rows.is_empty() || rows.len() > 1_048_576 {
+        return Err(EngineError::Other("Nothing to import.".into()));
+    }
+    let name = str_param(p, "sheet").map(str::to_string).or_else(|| {
+        str_param(p, "path").and_then(|x| std::path::Path::new(x).file_stem().and_then(std::ffi::OsStr::to_str).map(|f| f.chars().take(31).collect()))
+    });
+    let r = s.execute("home.insertSheet", json!({"name": name})).or_else(|_| s.execute("home.insertSheet", json!({})))?;
+    let w = rows.iter().map(Vec::len).max().unwrap_or(1).max(1);
+    s.execute("range.setValues", json!({"range": "A1", "values": rows}))?;
+    let range = RangeRef::new(CellRef::new(0, 0), CellRef::new(rows.len() as u32 - 1, w as u32 - 1));
+    let _ = s.execute("insert.table", json!({"range": range.a1(), "header": true}));
+    let _ = s.execute("home.autofitColumnWidth", json!({"cols": RangeRef::cols(0, w as u32 - 1).a1()}));
+    Ok(json!({"sheet": r["name"], "rows": rows.len(), "cols": w}))
+}
+
+pub(super) fn from_table_range(s: &mut Session, p: &Json) -> Result<Json> {
+    let r = target_range(s, p)?;
+    let d = s.doc()?;
+    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+    let r = if r.is_single() { crate::selection::current_region(sh, r.start) } else { r };
+    let text = crate::display::range_text(&d.wb, d.wb.active_sheet(), r);
+    from_csv(s, &json!({"text": text, "delimiter": "\t", "sheet": format!("{} (2)", sh.name).chars().take(31).collect::<String>()}))
+}
+
+pub(super) fn queries(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    Ok(Json::Array(
+        d.wb.sheets
+            .iter()
+            .flat_map(|sh| {
+                sh.tables
+                    .iter()
+                    .map(move |t| json!({"name": t.name, "sheet": sh.name, "range": t.range.a1(), "rows": t.range.height().saturating_sub(1)}))
+            })
+            .collect(),
+    ))
+}
diff --git a/crates/engine/src/cmd/extra/objects.rs b/crates/engine/src/cmd/extra/objects.rs
new file mode 100644
index 000000000..59ab8447a
--- /dev/null
+++ b/crates/engine/src/cmd/extra/objects.rs
@@ -0,0 +1,146 @@
+use super::chart::format_series;
+use super::*;
+
+pub(super) fn shape_fill(s: &mut Session, p: &Json) -> Result<Json> {
+    if str_param(p, "kind") == Some("shape") {
+        let color = str_param(p, "color").and_then(Color::from_hex).unwrap_or_default();
+        return with_shape(s, p, |sh| sh.fill = color);
+    }
+    format_series(s, p)
+}
+
+pub(super) fn shape_outline(s: &mut Session, p: &Json) -> Result<Json> {
+    let color = str_param(p, "color").and_then(Color::from_hex).unwrap_or_default();
+    with_shape(s, p, |sh| sh.line = color)
+}
+
+fn with_shape(s: &mut Session, p: &Json, f: impl FnOnce(&mut Shape)) -> Result<Json> {
+    let si = s.doc()?.wb.active_sheet();
+    let id = u32_param(p, "id");
+    edit(s, |cx| {
+        let shapes = &mut cx.sheet_mut(si)?.shapes;
+        let sh = match id {
+            Some(id) => shapes.iter_mut().find(|x| x.id == id),
+            None => shapes.last_mut(),
+        }
+        .ok_or_else(|| bad("shape", "no such shape"))?;
+        f(sh);
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json> {
+    let id = u32_param(p, "id").ok_or_else(|| bad("arrange", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("shape").to_string();
+    let extreme = bool_param(p, "toFront").or(bool_param(p, "toBack")).unwrap_or(false);
+    let si = s.doc()?.wb.active_sheet();
+    fn reorder<T>(v: &mut Vec<T>, i: usize, forward: bool, extreme: bool) {
+        if i >= v.len() {
+            return;
+        }
+        let item = v.remove(i);
+        let j = match (forward, extreme) {
+            (true, true) => v.len(),
+            (false, true) => 0,
+            (true, false) => (i + 1).min(v.len()),
+            (false, false) => i.saturating_sub(1),
+        };
+        v.insert(j, item);
+    }
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        match kind.as_str() {
+            "chart" => {
+                if let Some(i) = sh.charts.iter().position(|c| c.id == id) {
+                    reorder(&mut sh.charts, i, forward, extreme);
+                }
+            }
+            "image" => {
+                if let Some(i) = sh.images.iter().position(|c| c.id == id) {
+                    reorder(&mut sh.images, i, forward, extreme);
+                }
+            }
+            _ => {
+                if let Some(i) = sh.shapes.iter().position(|c| c.id == id) {
+                    reorder(&mut sh.shapes, i, forward, extreme);
+                }
+            }
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn selection_pane(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+    let mut v = Vec::new();
+    for c in &sh.shapes {
+        v.push(json!({"kind": "shape", "id": c.id, "name": format!("{:?} {}", c.kind, c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
+    }
+    for c in &sh.images {
+        v.push(json!({"kind": "image", "id": c.id, "name": format!("Picture {}", c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
+    }
+    for c in &sh.charts {
+        v.push(json!({"kind": "chart", "id": c.id, "name": format!("Chart {}", c.id), "title": c.title, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
+    }
+    Ok(Json::Array(v))
+}
+
+fn anchors_of<'a>(sh: &'a mut Sheet, kind: &str) -> Vec<(u32, &'a mut Anchor)> {
+    match kind {
+        "chart" => sh.charts.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
+        "image" => sh.images.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
+        _ => sh.shapes.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
+    }
+}
+
+pub(super) fn align(s: &mut Session, p: &Json) -> Result<Json> {
+    let kind = str_param(p, "kind").unwrap_or("shape").to_string();
+    let ids: Vec<u32> =
+        p.get("ids").and_then(Json::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(|x| x as u32)).collect()).unwrap_or_default();
+    let how = str_param(p, "align").unwrap_or("left").to_string();
+    let si = s.doc()?.wb.active_sheet();
+    edit(s, |cx| {
+        let sheet = cx.sheet_mut(si)?;
+        let geo: Vec<(u32, f64, f64, f32, f32)> = {
+            let shc = sheet.clone();
+            anchors_of(sheet, &kind)
+                .into_iter()
+                .filter(|(id, _)| ids.contains(id))
+                .map(|(id, a)| (id, shc.col_left(a.cell.col) + a.dx as f64, shc.row_top(a.cell.row) + a.dy as f64, a.width, a.height))
+                .collect()
+        };
+        if geo.len() < 2 {
+            return Ok(Json::Null);
+        }
+        let left = geo.iter().map(|g| g.1).fold(f64::INFINITY, f64::min);
+        let right = geo.iter().map(|g| g.1 + g.3 as f64).fold(f64::NEG_INFINITY, f64::max);
+        let top = geo.iter().map(|g| g.2).fold(f64::INFINITY, f64::min);
+        let bottom = geo.iter().map(|g| g.2 + g.4 as f64).fold(f64::NEG_INFINITY, f64::max);
+        let shc = sheet.clone();
+        for (id, a) in anchors_of(sheet, &kind) {
+            let Some(g) = geo.iter().find(|g| g.0 == id) else { continue };
+            let (mut x, mut y) = (g.1, g.2);
+            match how.as_str() {
+                "left" => x = left,
+                "right" => x = right - g.3 as f64,
+                "center" => x = (left + right) / 2.0 - g.3 as f64 / 2.0,
+                "top" => y = top,
+                "bottom" => y = bottom - g.4 as f64,
+                _ => y = (top + bottom) / 2.0 - g.4 as f64 / 2.0,
+            }
+            let c = CellRef::new(shc.row_at(y), shc.col_at(x));
+            a.cell = c;
+            a.dx = (x - shc.col_left(c.col)) as f32;
+            a.dy = (y - shc.row_top(c.row)) as f32;
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn rotate(s: &mut Session, p: &Json) -> Result<Json> {
+    if p.get("flip").is_some_and(|f| !f.is_null()) {
+        return Err(bad("arrange.rotate", "`flip` is not supported: shapes have no flip state"));
+    }
+    with_shape(s, p, |sh| std::mem::swap(&mut sh.anchor.width, &mut sh.anchor.height))
+}
diff --git a/crates/engine/src/cmd/extra/scripts.rs b/crates/engine/src/cmd/extra/scripts.rs
new file mode 100644
index 000000000..9f86837ab
--- /dev/null
+++ b/crates/engine/src/cmd/extra/scripts.rs
@@ -0,0 +1,146 @@
+use super::*;
+
+pub(super) fn record(s: &mut Session, p: &Json) -> Result<Json> {
+    if bool_param(p, "stop").unwrap_or(false) || s.recording.is_some() {
+        let Some(start) = s.recording.take() else { return Ok(json!({"recording": false})) };
+        let cmds: Vec<Json> =
+            s.journal.iter().skip(start).filter(|(id, _)| !id.starts_with("automate.")).map(|(id, p)| json!({"command": id, "params": p})).collect();
+        let name = str_param(p, "name").map(str::to_string).unwrap_or_else(|| format!("Script {}", start));
+        s.execute("automate.newScript", json!({"name": name, "commands": cmds}))?;
+        return Ok(json!({"recording": false, "saved": name, "steps": cmds.len()}));
+    }
+    s.recording = Some(s.journal.len());
+    Ok(json!({"recording": true}))
+}
+
+pub(super) fn new_script(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").ok_or_else(|| bad("automate.newScript", "missing `name`"))?.to_string();
+    let cmds = p.get("commands").cloned().unwrap_or(json!([]));
+    if !cmds.is_array() {
+        return Err(bad("automate.newScript", "`commands` must be an array"));
+    }
+    edit(s, |cx| {
+        let mut all = stash_map(&cx.wb, SCRIPTS_NAME);
+        all[name.as_str()] = cmds.clone();
+        stash_set(&mut cx.wb, SCRIPTS_NAME, &all);
+        Ok(json!({"name": name}))
+    })
+}
+
+pub(super) fn all_scripts(s: &mut Session, _: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let (wb, trusted) = (&d.wb, d.scripts_trusted);
+    let all = stash_get(wb, SCRIPTS_NAME);
+    let mut list: Vec<Json> = all
+        .as_object()
+        .map(|o| o.iter().map(|(k, v)| json!({"name": k, "steps": v.as_array().map_or(0, Vec::len), "trusted": trusted})).collect())
+        .unwrap_or_default();
+    // A preserved VBA project is reported alongside GridCraft's own scripts; it is carried on
+    // save but never executed here, so it has no step count.
+    if let Some(bytes) = &wb.vba_project {
+        list.push(json!({"name": "(VBA)", "steps": 0, "kind": "vba", "size": bytes.len(), "executed": false}));
+    }
+    Ok(Json::Array(list))
+}
+
+/// Whether `wb` carries GridCraft scripts (a workbook opened with them starts untrusted).
+pub(crate) fn has_scripts(wb: &Workbook) -> bool {
+    stash_map(wb, SCRIPTS_NAME).as_object().is_some_and(|o| !o.is_empty())
+}
+
+/// Why a script step is refused, whatever the workbook's trust: scripts stay inside the
+/// workbook. Anything that reads or writes files (`file.*`, or any `path` parameter: Get Data,
+/// From Text/CSV, Insert Picture) or leaves the app (`link.*` opens URLs) is the caller's to run
+/// directly, not a stored script's. (Nested `automate.*` steps are skipped.) This check goes by
+/// command id and parameter name, so it is only the up-front refusal: the steps also run inside
+/// an [`crate::io::ScriptSandbox`] (file access refused whatever the parameter is called) and
+/// [`run_script`] drops any `OpenUrl` request a step raises.
+fn denied_script_step(id: &str, params: &Json) -> Option<String> {
+    if id.starts_with("file.") || id.starts_with("link.") {
+        return Some(format!("scripts can't run `{id}`: it reaches outside the workbook"));
+    }
+    // Scripts are scoped to their workbook: a step that switches the active window would
+    // point every later step at another open document, so those are refused too.
+    if id.starts_with("window.") || matches!(id, "view.switchWindows" | "view.newWindow" | "view.hideWindow" | "view.unhideWindow") {
+        return Some(format!("scripts can't run `{id}`: it reaches outside the workbook"));
+    }
+    if params.get("path").is_some() {
+        return Some(format!("scripts can't pass a file `path` to `{id}`"));
+    }
+    None
+}
+
+pub(super) fn trust_scripts(s: &mut Session, p: &Json) -> Result<Json> {
+    // Only a missing `trusted` means "trust"; `"false"`, `0` or `null` are mistakes, not consent.
+    let trusted = match p.get("trusted") {
+        None => true,
+        Some(Json::Bool(b)) => *b,
+        Some(_) => return Err(bad("automate.trustScripts", "`trusted` must be true or false")),
+    };
+    s.doc_mut()?.scripts_trusted = trusted;
+    Ok(json!({"trusted": trusted}))
+}
+
+/// Runs a stored script. Scripts in a workbook opened from a file run only once the workbook is
+/// trusted for this session (`automate.trustScripts`, or `trusted: true` on this call); steps that
+/// reach outside the workbook ([`denied_script_step`]) are refused before any step runs.
+pub(super) fn run_script(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").ok_or_else(|| bad("automate.runScript", "missing `name`"))?;
+    let d = s.doc()?;
+    let all = stash_get(&d.wb, SCRIPTS_NAME);
+    let steps = all.get(name).and_then(Json::as_array).cloned().ok_or_else(|| bad("automate.runScript", "no such script"))?;
+    if !d.scripts_trusted && !bool_param(p, "trusted").unwrap_or(false) {
+        return Err(bad(
+            "automate.runScript",
+            "scripts in this workbook came from a file and are disabled; trust the workbook first (Trust Scripts in View › Macros, Alt+F8; `automate.trustScripts`; or `trusted: true`)",
+        ));
+    }
+    let steps: Vec<Json> = steps.into_iter().take(100_000).collect();
+    for st in &steps {
+        let id = st["command"].as_str().unwrap_or("");
+        if let Some(why) = denied_script_step(id, &st["params"]) {
+            return Err(bad("automate.runScript", why));
+        }
+    }
+    let _sandbox = crate::io::ScriptSandbox::enter();
+    let mut n = 0;
+    for st in &steps {
+        let id = st["command"].as_str().unwrap_or("");
+        if id.starts_with("automate.") {
+            continue;
+        }
+        let before = s.ui_requests.len();
+        let ran = s.execute(id, st["params"].clone());
+        // A step that asks the host to open a URL leaves the app: drop the request and stop.
+        if s.ui_requests.get(before..).is_some_and(|new| new.iter().any(|r| matches!(r, crate::UiRequest::OpenUrl(_)))) {
+            let mut i = 0;
+            s.ui_requests.retain(|r| {
+                i += 1;
+                i <= before || !matches!(r, crate::UiRequest::OpenUrl(_))
+            });
+            return Err(bad("automate.runScript", format!("scripts can't open links (`{id}`)")));
+        }
+        ran?;
+        n += 1;
+    }
+    Ok(json!({"ran": n}))
+}
+
+/// Automate › Stop Action: rolls back the undo groups open on the active workbook, so Undo and
+/// Redo work there again.
+pub(super) fn stop_action(s: &mut Session, _: &Json) -> Result<Json> {
+    let uid = s.doc()?.uid;
+    Ok(json!({"stopped": s.abort_groups(uid)}))
+}
+
+pub(super) fn delete_script(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").ok_or_else(|| bad("automate.deleteScript", "missing `name`"))?.to_string();
+    edit(s, |cx| {
+        let mut all = stash_map(&cx.wb, SCRIPTS_NAME);
+        if let Some(o) = all.as_object_mut() {
+            o.remove(&name);
+        }
+        stash_set(&mut cx.wb, SCRIPTS_NAME, &all);
+        Ok(Json::Null)
+    })
+}
diff --git a/crates/engine/src/cmd/extra/window.rs b/crates/engine/src/cmd/extra/window.rs
new file mode 100644
index 000000000..19e92743f
--- /dev/null
+++ b/crates/engine/src/cmd/extra/window.rs
@@ -0,0 +1,184 @@
+use super::*;
+
+/// Switches a sheet's view. Like zoom, the view is saved with the file but is not an edit: it
+/// neither records an undo step nor marks a clean workbook as changed.
+pub(super) fn set_view(s: &mut Session, p: &Json, mode: SheetViewMode) -> Result<Json> {
+    let si = target_sheet(s, p)?;
+    let d = s.doc_mut()?;
+    let dirty = d.is_dirty();
+    let wb = std::sync::Arc::make_mut(&mut d.wb);
+    if let Some(sh) = wb.sheet_mut(si) {
+        sh.view = mode;
+    }
+    if !dirty {
+        d.saved = d.wb.clone();
+    }
+    Ok(json!({"view": mode.as_str()}))
+}
+
+pub(super) fn ruler(s: &mut Session, p: &Json) -> Result<Json> {
+    let on = bool_param(p, "on").unwrap_or(s.hide_ruler);
+    s.hide_ruler = !on;
+    Ok(json!({"on": on}))
+}
+
+/// The Watch Window list isn't an edit (Excel doesn't undo it): undo and redo keep the current
+/// list when they swap in another snapshot of the workbook.
+pub(crate) fn keep_watch_list(from: &Workbook, to: &mut std::sync::Arc<Workbook>) {
+    let find = |wb: &Workbook| wb.names.iter().find(|n| n.name == WATCH_NAME).cloned();
+    let keep = find(from);
+    if keep == find(to) {
+        return;
+    }
+    let wb = std::sync::Arc::make_mut(to);
+    wb.names.retain(|n| n.name != WATCH_NAME);
+    wb.names.extend(keep);
+}
+
+pub(super) fn custom_views(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let mut views = stash_map(&d.wb, VIEWS_NAME);
+    if let Some(name) = str_param(p, "save") {
+        let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+        views[name] = json!({"sheet": d.wb.active_sheet(), "selection": d.selection.a1(), "zoom": sh.zoom, "freeze": sh.freeze});
+        let v = views.clone();
+        edit(s, |cx| {
+            stash_set(&mut cx.wb, VIEWS_NAME, &v);
+            Ok(())
+        })?;
+    } else if let Some(name) = str_param(p, "show") {
+        let v = views.get(name).cloned().ok_or_else(|| bad("view.customViews", "no such view"))?;
+        if let Some(si) = v["sheet"].as_u64() {
+            s.execute("sheet.activate", json!({"sheet": si}))?;
+        }
+        if let Some(sel) = v["selection"].as_str() {
+            s.execute("selection.set", json!({"range": sel}))?;
+        }
+        if let Some(z) = v["zoom"].as_u64() {
+            s.execute("view.zoom", json!({"percent": z}))?;
+        }
+        if let Some(f) = v.get("freeze") {
+            let freeze = match (f[0].as_u64(), f[1].as_u64()) {
+                (Some(r), Some(c)) => u32::try_from(r).ok().zip(u32::try_from(c).ok()),
+                _ => None,
+            };
+            edit(s, |cx| {
+                let si = cx.sheet_index();
+                cx.sheet_mut(si)?.freeze = freeze;
+                Ok(())
+            })?;
+        }
+    } else if let Some(name) = str_param(p, "delete") {
+        if let Some(o) = views.as_object_mut() {
+            o.remove(name);
+        }
+        let v = views.clone();
+        edit(s, |cx| {
+            stash_set(&mut cx.wb, VIEWS_NAME, &v);
+            Ok(())
+        })?;
+    }
+    Ok(stash_get(&s.doc()?.wb, VIEWS_NAME))
+}
+
+pub(super) fn split(s: &mut Session, _: &Json) -> Result<Json> {
+    let has = s.doc()?.wb.active().is_some_and(|sh| sh.freeze.is_some());
+    if has { s.execute("view.unfreezePanes", json!({})) } else { s.execute("view.freezePanes", json!({})) }
+}
+
+pub(super) fn new_window(s: &mut Session, _: &Json) -> Result<Json> {
+    let id = s.new_window()?;
+    let doc = s.window(id).map(|w| w.doc_uid);
+    Ok(json!({"window": id, "doc": doc, "title": s.window_title(id)}))
+}
+
+/// The window a window command names: `window` (an id), else `doc` (a workbook id: its most
+/// recent window), else the active window.
+pub(crate) fn window_param(s: &Session, cmd: &str, p: &Json) -> Result<u64> {
+    let t = crate::Target::from_json(p).map_err(|e| bad(cmd, e.to_string()))?;
+    s.target_window(t).map_err(|e| bad(cmd, e.to_string()))
+}
+
+/// View › Arrange All. The engine has no window geometry: it picks the windows and the layout,
+/// and the interface moves its native windows ([`Session::window_list`] order, active first).
+pub(super) fn arrange_all(s: &mut Session, p: &Json) -> Result<Json> {
+    let arrange = match str_param(p, "arrange").unwrap_or("tiled") {
+        a @ ("tiled" | "horizontal" | "vertical" | "cascade") => a,
+        other => return Err(bad("view.arrangeAll", format!("`arrange` must be tiled, horizontal, vertical or cascade, not `{other}`"))),
+    };
+    let active = s.active_window();
+    let doc = active.and_then(|w| s.window(w)).map(|w| w.doc_uid);
+    let only_active = p.get("activeWorkbook").and_then(Json::as_bool).unwrap_or(false);
+    let mut windows: Vec<u64> = s.windows().iter().filter(|w| !w.hidden && (!only_active || Some(w.doc_uid) == doc)).map(|w| w.id).collect();
+    if let Some(at) = windows.iter().position(|w| Some(*w) == active)
+        && let Some(first) = windows.get_mut(..=at)
+    {
+        first.rotate_right(1);
+    }
+    Ok(json!({"arrange": arrange, "windows": windows}))
+}
+
+pub(super) fn hide_window(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = window_param(s, "view.hideWindow", p)?;
+    s.hide_window(id);
+    ok()
+}
+
+pub(super) fn unhide_window(s: &mut Session, p: &Json) -> Result<Json> {
+    let id = if p.get("window").is_some_and(|v| !v.is_null()) || p.get("doc").is_some_and(|v| !v.is_null()) {
+        Some(window_param(s, "view.unhideWindow", p)?)
+    } else if let Some(i) = u32_param(p, "index") {
+        // A workbook's position in the document list.
+        let uid = s.documents().get(i as usize).map(|d| d.uid).ok_or_else(|| bad("view.unhideWindow", "no such window"))?;
+        s.windows().iter().filter(|w| w.doc_uid == uid && w.hidden).map(|w| w.id).next_back().or_else(|| s.doc_window(uid))
+    } else {
+        s.last_hidden_window()
+    };
+    if let Some(id) = id {
+        s.unhide_window(id);
+    }
+    ok()
+}
+
+pub(super) fn switch_windows(s: &mut Session, p: &Json) -> Result<Json> {
+    if p.get("window").is_some_and(|v| !v.is_null()) || p.get("doc").is_some_and(|v| !v.is_null()) {
+        let id = window_param(s, "view.switchWindows", p)?;
+        s.unhide_window(id);
+    }
+    Ok(s.window_list())
+}
+
+pub(super) fn watch_window(s: &mut Session, p: &Json) -> Result<Json> {
+    let mut list: Vec<String> =
+        stash_get(&s.doc()?.wb, WATCH_NAME).as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default();
+    let mut changed = false;
+    if let Some(a) = str_param(p, "add") {
+        if !list.iter().any(|x| x == a) {
+            list.push(a.to_string());
+        }
+        changed = true;
+    }
+    if let Some(r) = str_param(p, "remove") {
+        list.retain(|x| x != r);
+        changed = true;
+    }
+    if changed {
+        let v = json!(list.clone());
+        let d = s.doc_mut()?;
+        // The watch list is view state: don't add an undo step.
+        let wb = std::sync::Arc::make_mut(&mut d.wb);
+        stash_set(wb, WATCH_NAME, &v);
+    }
+    let d = s.doc()?;
+    let rows: Vec<Json> = list
+        .iter()
+        .map(|w| {
+            let (sheet, body) = split_sheet(w);
+            let si = sheet.and_then(|n| d.wb.sheet_index(&n)).unwrap_or(d.wb.active_sheet());
+            let c = CellRef::parse(body).unwrap_or_default();
+            let sh = d.wb.sheet(si);
+            json!({"cell": w, "value": sh.map(|s| s.value(c).display()), "formula": sh.and_then(|s| s.cell(c)).and_then(|x| x.formula.as_ref()).map(|f| format!("={}", f.text))})
+        })
+        .collect();
+    Ok(Json::Array(rows))
+}

From 1a1726bb9d3f67a39a16a9578d8ccdd8b12184b5 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:53:29 +0000
Subject: [PATCH 54/76] refactor(engine): move cmd/format.rs items to
 cmd/format/

---
 crates/engine/src/cmd/format.rs             | 442 +-------------------
 crates/engine/src/cmd/format/cell_styles.rs | 197 +++++++++
 crates/engine/src/cmd/format/sizes.rs       | 243 +++++++++++
 3 files changed, 446 insertions(+), 436 deletions(-)
 create mode 100644 crates/engine/src/cmd/format/cell_styles.rs
 create mode 100644 crates/engine/src/cmd/format/sizes.rs

diff --git a/crates/engine/src/cmd/format.rs b/crates/engine/src/cmd/format.rs
index 10dd2989d..744b6d136 100644
--- a/crates/engine/src/cmd/format.rs
+++ b/crates/engine/src/cmd/format.rs
@@ -802,445 +802,15 @@ fn decimals(s: &mut Session, p: &Json, delta: i32) -> Result<Json> {
     set_fmt(s, p, &new)
 }
 
-/// Built-in cell styles (our own palette).
-pub fn builtin_cell_style(name: &str, theme: &Theme) -> Option<Style> {
-    let _ = theme;
-    let mut s = Style::default();
-    let accent = |i: u8, tint: i16| Color::Theme(i, tint);
-    match name {
-        "Normal" => {}
-        "Good" => {
-            s.fill = Fill::solid(Color::rgb(0xC6, 0xEF, 0xCE));
-            s.font.color = Color::rgb(0x00, 0x61, 0x00);
-        }
-        "Bad" => {
-            s.fill = Fill::solid(Color::rgb(0xFF, 0xC7, 0xCE));
-            s.font.color = Color::rgb(0x9C, 0x00, 0x06);
-        }
-        "Neutral" => {
-            s.fill = Fill::solid(Color::rgb(0xFF, 0xEB, 0x9C));
-            s.font.color = Color::rgb(0x9C, 0x57, 0x00);
-        }
-        "Calculation" => {
-            s.fill = Fill::solid(Color::rgb(0xF2, 0xF2, 0xF2));
-            s.font.color = Color::rgb(0xFA, 0x7D, 0x00);
-            s.font.bold = true;
-            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0x7F, 0x7F, 0x7F) };
-            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
-        }
-        "Check Cell" => {
-            s.fill = Fill::solid(Color::rgb(0xA5, 0xA5, 0xA5));
-            s.font.color = Color::rgb(0xFF, 0xFF, 0xFF);
-            s.font.bold = true;
-            let l = BorderLine { style: BorderStyle::Double, color: Color::rgb(0x3F, 0x3F, 0x3F) };
-            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
-        }
-        "Explanatory Text" => {
-            s.font.italic = true;
-            s.font.color = Color::rgb(0x7F, 0x7F, 0x7F);
-        }
-        "Input" => {
-            s.fill = Fill::solid(Color::rgb(0xFF, 0xCC, 0x99));
-            s.font.color = Color::rgb(0x3F, 0x3F, 0x76);
-            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0x7F, 0x7F, 0x7F) };
-            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
-        }
-        "Linked Cell" => {
-            s.font.color = Color::rgb(0xFA, 0x7D, 0x00);
-            s.borders.bottom = BorderLine { style: BorderStyle::Double, color: Color::rgb(0xFF, 0x80, 0x01) };
-        }
-        "Note" => {
-            s.fill = Fill::solid(Color::rgb(0xFF, 0xFF, 0xCC));
-            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0xB2, 0xB2, 0xB2) };
-            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
-        }
-        "Output" => {
-            s.fill = Fill::solid(Color::rgb(0xF2, 0xF2, 0xF2));
-            s.font.color = Color::rgb(0x3F, 0x3F, 0x3F);
-            s.font.bold = true;
-            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0x3F, 0x3F, 0x3F) };
-            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
-        }
-        "Warning Text" => s.font.color = Color::rgb(0xFF, 0x00, 0x00),
-        "Title" => {
-            s.font.size = 18.0;
-            s.font.color = Color::Theme(3, 0);
-            s.font.name = theme.major_font.clone();
-        }
-        "Heading 1" => {
-            s.font.size = 15.0;
-            s.font.bold = true;
-            s.font.color = Color::Theme(3, 0);
-            s.borders.bottom = BorderLine { style: BorderStyle::Thick, color: accent(4, 0) };
-        }
-        "Heading 2" => {
-            s.font.size = 13.0;
-            s.font.bold = true;
-            s.font.color = Color::Theme(3, 0);
-            s.borders.bottom = BorderLine { style: BorderStyle::Thick, color: accent(4, 500) };
-        }
-        "Heading 3" => {
-            s.font.bold = true;
-            s.font.color = Color::Theme(3, 0);
-            s.borders.bottom = BorderLine { style: BorderStyle::Medium, color: accent(4, 400) };
-        }
-        "Heading 4" => {
-            s.font.bold = true;
-            s.font.color = Color::Theme(3, 0);
-        }
-        "Total" => {
-            s.font.bold = true;
-            s.borders.top = BorderLine { style: BorderStyle::Thin, color: accent(4, 0) };
-            s.borders.bottom = BorderLine { style: BorderStyle::Double, color: accent(4, 0) };
-        }
-        "Currency" => s.num_fmt = NumFmt::new(ACCOUNTING),
-        "Comma" => s.num_fmt = NumFmt::new(COMMA),
-        "Percent" => s.num_fmt = NumFmt::new("0%"),
-        "Currency [0]" => s.num_fmt = NumFmt::new("_(\"$\"* #,##0_);_(\"$\"* \\(#,##0\\);_(\"$\"* \"-\"_);_(@_)"),
-        "Comma [0]" => s.num_fmt = NumFmt::new("_(* #,##0_);_(* \\(#,##0\\);_(* \"-\"_);_(@_)"),
-        n => {
-            // AccentN, 20%/40%/60% - AccentN
-            let (pct, rest) = match n.split_once("% - ") {
-                Some((p, r)) => (p.parse::<i16>().ok(), r),
-                None => (None, n),
-            };
-            let i: u8 = rest.strip_prefix("Accent")?.parse().ok()?;
-            if !(1..=6).contains(&i) {
-                return None;
-            }
-            match pct {
-                None => {
-                    s.fill = Fill::solid(accent(3 + i, 0));
-                    s.font.color = Color::Theme(0, 0);
-                }
-                Some(p) => {
-                    s.fill = Fill::solid(accent(3 + i, (1000 - p * 10).clamp(0, 1000)));
-                    s.font.color = if p >= 60 { Color::Theme(0, 0) } else { Color::Theme(1, 0) };
-                }
-            }
-        }
-    }
-    Some(s)
-}
-
-pub const CELL_STYLE_NAMES: &[&str] = &[
-    "Normal",
-    "Bad",
-    "Good",
-    "Neutral",
-    "Calculation",
-    "Check Cell",
-    "Explanatory Text",
-    "Input",
-    "Linked Cell",
-    "Note",
-    "Output",
-    "Warning Text",
-    "Heading 1",
-    "Heading 2",
-    "Heading 3",
-    "Heading 4",
-    "Title",
-    "Total",
-    "20% - Accent1",
-    "20% - Accent2",
-    "20% - Accent3",
-    "20% - Accent4",
-    "20% - Accent5",
-    "20% - Accent6",
-    "40% - Accent1",
-    "40% - Accent2",
-    "40% - Accent3",
-    "40% - Accent4",
-    "40% - Accent5",
-    "40% - Accent6",
-    "60% - Accent1",
-    "60% - Accent2",
-    "60% - Accent3",
-    "60% - Accent4",
-    "60% - Accent5",
-    "60% - Accent6",
-    "Accent1",
-    "Accent2",
-    "Accent3",
-    "Accent4",
-    "Accent5",
-    "Accent6",
-    "Comma",
-    "Comma [0]",
-    "Currency",
-    "Currency [0]",
-    "Percent",
-];
-
-fn cell_style(s: &mut Session, p: &Json) -> Result<Json> {
-    let name = str_param(p, "name").unwrap_or("Normal").to_string();
-    let d = s.doc()?;
-    let style =
-        d.wb.cell_styles
-            .iter()
-            .find(|(n, _)| n.eq_ignore_ascii_case(&name))
-            .map(|(_, s)| s.clone())
-            .or_else(|| builtin_cell_style(&name, &d.wb.theme));
-    let Some(style) = style else { return Err(bad("home.cellStyle", format!("unknown cell style `{name}`"))) };
-    // Number-format styles only change the number format.
-    let only_fmt = matches!(name.as_str(), "Comma" | "Comma [0]" | "Currency" | "Currency [0]" | "Percent");
-    apply_style(s, p, move |st| {
-        if only_fmt {
-            st.num_fmt = style.num_fmt.clone();
-        } else {
-            let keep_fmt = st.num_fmt.clone();
-            *st = style.clone();
-            if style.num_fmt.as_str() == "General" {
-                st.num_fmt = keep_fmt;
-            }
-        }
-    })
-}
-
-// ---------------------------------------------------------------- sizes
-
-/// The sheet and the row (or column) spans a size or visibility command works on. The lines are
-/// `rows`/`cols` (`"2:5"`, `"B:B,D:F"`, optionally `Sheet!`-prefixed), else the selection's; the
-/// sheet is `sheet`, else the prefix, else the active one. The selection belongs to the active
-/// sheet, so another sheet needs explicit lines.
-fn line_targets(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> {
-    let key = if rows { "rows" } else { "cols" };
-    let mut sheet = target_sheet(s, p)?;
-    if let Some(t) = str_param(p, key) {
-        let (prefix, body) = split_sheet(t);
-        if let Some(name) = prefix {
-            let named = s.doc()?.wb.sheet_index(&name).ok_or_else(|| bad(key, format!("no sheet named `{name}`")))?;
-            if p.get("sheet").is_some_and(|v| !v.is_null()) && named != sheet {
-                return Err(bad(key, format!("`{t}` names a sheet other than `sheet`")));
-            }
-            sheet = named;
-        }
-        // A comma-separated list ("B:B,D:F") targets several areas, like a multi-area selection.
-        let lines = body
-            .split(',')
-            .map(|part| {
-                let r = parse_lines(part).ok_or_else(|| bad(key, format!("not a range: {part}")))?;
-                Ok(if rows { (r.start.row, r.end.row) } else { (r.start.col, r.end.col) })
-            })
-            .collect::<Result<Vec<_>>>()?;
-        return Ok((sheet, lines));
-    }
-    let d = s.doc()?;
-    if sheet != d.wb.active_sheet() {
-        return Err(bad(key, format!("missing `{key}`: the selection is on the active sheet")));
-    }
-    Ok((sheet, d.selection.ranges.iter().map(|r| if rows { (r.start.row, r.end.row) } else { (r.start.col, r.end.col) }).collect()))
-}
-
-/// Sizes are pixels at 96 dpi, the model's unit (header drags send pixels). `points` (row height)
-/// and `chars` (column width) take Excel's units, those of its Row Height and Column Width dialogs
-/// and of the file (`ht` is in points).
-fn row_height(s: &mut Session, p: &Json) -> Result<Json> {
-    let h = match (f64_param(p, "height"), f64_param(p, "points")) {
-        (Some(h), _) => {
-            if !(0.0..=546.0).contains(&h) {
-                return Err(EngineError::Other("Row height must be between 0 and 546 pixels (409.5 points).".into()));
-            }
-            h
-        }
-        (None, Some(pt)) => {
-            if !(0.0..=409.5).contains(&pt) {
-                return Err(EngineError::Other("Row height must be between 0 and 409.5 points.".into()));
-            }
-            pt * 4.0 / 3.0
-        }
-        _ => return Err(bad("home.rowHeight", "missing `height` (pixels) or `points`")),
-    };
-    let (si, lines) = line_targets(s, p, true)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        for (a, b) in lines {
-            for r in a..=b.min(a.saturating_add(1_048_575)) {
-                let e = sh.rows.entry(r).or_default();
-                e.size = Some(h as f32);
-                e.hidden = h == 0.0;
-                e.custom = true;
-            }
-        }
-        cx.structural = true; // setting a height shows or hides rows: SUBTOTAL(10x) depends on it
-        Ok(Json::Null)
-    })
-}
-
-fn col_width(s: &mut Session, p: &Json) -> Result<Json> {
-    let w = match (f64_param(p, "width"), f64_param(p, "chars")) {
-        (Some(w), _) => {
-            if !(0.0..=1800.0).contains(&w) {
-                return Err(EngineError::Other("Column width must be between 0 and 1800 pixels.".into()));
-            }
-            w
-        }
-        (None, Some(c)) => {
-            if !(0.0..=255.0).contains(&c) {
-                return Err(EngineError::Other("Column width must be between 0 and 255 characters.".into()));
-            }
-            chars_to_points(c)
-        }
-        _ => return Err(bad("home.columnWidth", "missing `width` (pixels) or `chars`")),
-    };
-    let (si, lines) = line_targets(s, p, false)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        for (a, b) in lines {
-            for c in a..=b {
-                let e = sh.cols.entry(c).or_default();
-                e.size = Some(w as f32);
-                e.hidden = w == 0.0;
-            }
-        }
-        Ok(Json::Null)
-    })
-}
-
-/// Excel column width in characters (of the default font's digit width, 7 px) → pixels.
-pub fn chars_to_points(c: f64) -> f64 {
-    if c <= 0.0 {
-        0.0
-    } else if c < 1.0 {
-        (c * 12.0).round()
-    } else {
-        (c * 7.0 + 5.0).round()
-    }
-}
-
 pub use gridcraft_model::points_to_chars;
 
-/// Approximate text width in points for autofit (no font metrics in the engine: average glyph
-/// widths for the default font; a front end with fonts measures instead, see `Session::text_width`).
-pub fn approx_text_width(text: &str, size: f32, bold: bool) -> f32 {
-    let mut w = 0.0;
-    for c in text.chars() {
-        w += match c {
-            'i' | 'l' | 'j' | '\'' | '.' | ',' | ':' | ';' | '!' | '|' => 0.28,
-            'f' | 't' | 'r' | 'I' | ' ' | '(' | ')' | '-' => 0.38,
-            'm' | 'w' | 'M' | 'W' => 0.85,
-            c if c.is_ascii_uppercase() => 0.65,
-            c if c.is_ascii_digit() => 0.56,
-            c if c.is_ascii() => 0.52,
-            _ => 1.0,
-        };
-    }
-    w * size * if bold { 1.07 } else { 1.0 } * 96.0 / 72.0
-}
+mod cell_styles;
+mod sizes;
 
-/// Distinct texts AutoFit measures exactly; past this many, `Session::text_width` is asked for a
-/// quick measure so a huge column doesn't lay out every value.
-const EXACT_TEXT_WIDTHS: usize = 2_000;
-
-fn autofit_cols(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, lines) = line_targets(s, p, false)?;
-    let measure = s.text_width.clone();
-    edit(s, |cx| {
-        let Some(sh) = cx.wb.sheet(si) else { return Ok(Json::Null) };
-        let mut widths = Vec::new();
-        let mut measured: std::collections::HashMap<StyleId, std::collections::HashMap<String, f32>> = Default::default();
-        let mut distinct = 0usize;
-        let used = sh.used_range();
-        for (a, b) in lines {
-            for c in a..=b.min(a + 16383) {
-                let Some(u) = used else { continue };
-                let col = RangeRef::new(CellRef::new(u.start.row, c), CellRef::new(u.end.row, c));
-                let mut max: f32 = 0.0;
-                for (cell, _) in sh.cells.iter_range(col) {
-                    if sh.merge_at(cell).is_some_and(|m| !m.is_single()) {
-                        continue;
-                    }
-                    let id = sh.style_id(cell);
-                    let st = cx.wb.styles.get(id);
-                    let text = crate::display::cell_text(&cx.wb, sh, cell);
-                    for line in text.lines() {
-                        let w = match &measure {
-                            Some(m) => {
-                                let known = measured.entry(id).or_default();
-                                match known.get(line) {
-                                    Some(w) => *w,
-                                    None => {
-                                        let w = m(line, &st.font, distinct < EXACT_TEXT_WIDTHS);
-                                        known.insert(line.to_owned(), w);
-                                        distinct += 1;
-                                        w
-                                    }
-                                }
-                            }
-                            None => approx_text_width(line, st.font.size, st.font.bold),
-                        };
-                        max = max.max(w + 6.0 + st.align.indent as f32 * 9.0 + sh.filter_button_space(cell));
-                    }
-                }
-                if max > 0.0 {
-                    widths.push((c, max.clamp(8.0, 1785.0)));
-                }
-            }
-        }
-        let sh = cx.sheet_mut(si)?;
-        for (c, w) in widths {
-            let e = sh.cols.entry(c).or_default();
-            e.size = Some(w.ceil());
-            e.hidden = false;
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn autofit_rows(s: &mut Session, p: &Json) -> Result<Json> {
-    let (si, lines) = line_targets(s, p, true)?;
-    edit(s, |cx| {
-        for (a, b) in lines {
-            let b = b.min(a + 100_000);
-            if let Some(sh) = cx.wb.sheet_mut(si) {
-                for r in a..=b {
-                    if let Some(e) = sh.rows.get_mut(&r) {
-                        e.custom = false;
-                        e.hidden = false;
-                    }
-                }
-            }
-            cx.fit_rows.extend((a..=b).map(|r| (si, r)));
-        }
-        cx.structural = true; // autofit reveals hidden rows: SUBTOTAL(10x) depends on it
-        Ok(Json::Null)
-    })
-}
-
-fn default_width(s: &mut Session, p: &Json) -> Result<Json> {
-    let w = f64_param(p, "width").ok_or_else(|| bad("home.defaultWidth", "missing `width`"))?;
-    let si = target_sheet(s, p)?;
-    edit(s, |cx| {
-        cx.sheet_mut(si)?.default_col_width = w.clamp(0.0, 1800.0) as f32;
-        Ok(Json::Null)
-    })
-}
-
-fn hide(s: &mut Session, p: &Json, rows: bool, on: bool) -> Result<Json> {
-    let (si, lines) = line_targets(s, p, rows)?;
-    edit(s, |cx| {
-        let sh = cx.sheet_mut(si)?;
-        for (a, b) in lines {
-            // Unhiding a single selected line also reveals hidden neighbours (Excel needs the
-            // lines on both sides selected; we're forgiving).
-            let (a, b) = if !on && a == b { (a.saturating_sub(1), b + 1) } else { (a, b) };
-            for i in a..=b.min(a.saturating_add(1_048_575)) {
-                let map = if rows { &mut sh.rows } else { &mut sh.cols };
-                if on {
-                    map.entry(i).or_default().hidden = true;
-                } else if let Some(e) = map.get_mut(&i) {
-                    e.hidden = false;
-                    if e.size == Some(0.0) {
-                        e.size = None;
-                    }
-                }
-            }
-        }
-        cx.structural = true; // SUBTOTAL(10x) depends on hidden rows
-        Ok(Json::Null)
-    })
-}
+use cell_styles::cell_style;
+pub use cell_styles::{CELL_STYLE_NAMES, builtin_cell_style};
+pub use sizes::{approx_text_width, chars_to_points};
+use sizes::{autofit_cols, autofit_rows, col_width, default_width, hide, row_height};
 
 #[cfg(test)]
 mod tests {
diff --git a/crates/engine/src/cmd/format/cell_styles.rs b/crates/engine/src/cmd/format/cell_styles.rs
new file mode 100644
index 000000000..53d378202
--- /dev/null
+++ b/crates/engine/src/cmd/format/cell_styles.rs
@@ -0,0 +1,197 @@
+use super::*;
+
+/// Built-in cell styles (our own palette).
+pub fn builtin_cell_style(name: &str, theme: &Theme) -> Option<Style> {
+    let _ = theme;
+    let mut s = Style::default();
+    let accent = |i: u8, tint: i16| Color::Theme(i, tint);
+    match name {
+        "Normal" => {}
+        "Good" => {
+            s.fill = Fill::solid(Color::rgb(0xC6, 0xEF, 0xCE));
+            s.font.color = Color::rgb(0x00, 0x61, 0x00);
+        }
+        "Bad" => {
+            s.fill = Fill::solid(Color::rgb(0xFF, 0xC7, 0xCE));
+            s.font.color = Color::rgb(0x9C, 0x00, 0x06);
+        }
+        "Neutral" => {
+            s.fill = Fill::solid(Color::rgb(0xFF, 0xEB, 0x9C));
+            s.font.color = Color::rgb(0x9C, 0x57, 0x00);
+        }
+        "Calculation" => {
+            s.fill = Fill::solid(Color::rgb(0xF2, 0xF2, 0xF2));
+            s.font.color = Color::rgb(0xFA, 0x7D, 0x00);
+            s.font.bold = true;
+            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0x7F, 0x7F, 0x7F) };
+            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
+        }
+        "Check Cell" => {
+            s.fill = Fill::solid(Color::rgb(0xA5, 0xA5, 0xA5));
+            s.font.color = Color::rgb(0xFF, 0xFF, 0xFF);
+            s.font.bold = true;
+            let l = BorderLine { style: BorderStyle::Double, color: Color::rgb(0x3F, 0x3F, 0x3F) };
+            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
+        }
+        "Explanatory Text" => {
+            s.font.italic = true;
+            s.font.color = Color::rgb(0x7F, 0x7F, 0x7F);
+        }
+        "Input" => {
+            s.fill = Fill::solid(Color::rgb(0xFF, 0xCC, 0x99));
+            s.font.color = Color::rgb(0x3F, 0x3F, 0x76);
+            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0x7F, 0x7F, 0x7F) };
+            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
+        }
+        "Linked Cell" => {
+            s.font.color = Color::rgb(0xFA, 0x7D, 0x00);
+            s.borders.bottom = BorderLine { style: BorderStyle::Double, color: Color::rgb(0xFF, 0x80, 0x01) };
+        }
+        "Note" => {
+            s.fill = Fill::solid(Color::rgb(0xFF, 0xFF, 0xCC));
+            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0xB2, 0xB2, 0xB2) };
+            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
+        }
+        "Output" => {
+            s.fill = Fill::solid(Color::rgb(0xF2, 0xF2, 0xF2));
+            s.font.color = Color::rgb(0x3F, 0x3F, 0x3F);
+            s.font.bold = true;
+            let l = BorderLine { style: BorderStyle::Thin, color: Color::rgb(0x3F, 0x3F, 0x3F) };
+            s.borders = Borders { left: l, right: l, top: l, bottom: l, ..Default::default() };
+        }
+        "Warning Text" => s.font.color = Color::rgb(0xFF, 0x00, 0x00),
+        "Title" => {
+            s.font.size = 18.0;
+            s.font.color = Color::Theme(3, 0);
+            s.font.name = theme.major_font.clone();
+        }
+        "Heading 1" => {
+            s.font.size = 15.0;
+            s.font.bold = true;
+            s.font.color = Color::Theme(3, 0);
+            s.borders.bottom = BorderLine { style: BorderStyle::Thick, color: accent(4, 0) };
+        }
+        "Heading 2" => {
+            s.font.size = 13.0;
+            s.font.bold = true;
+            s.font.color = Color::Theme(3, 0);
+            s.borders.bottom = BorderLine { style: BorderStyle::Thick, color: accent(4, 500) };
+        }
+        "Heading 3" => {
+            s.font.bold = true;
+            s.font.color = Color::Theme(3, 0);
+            s.borders.bottom = BorderLine { style: BorderStyle::Medium, color: accent(4, 400) };
+        }
+        "Heading 4" => {
+            s.font.bold = true;
+            s.font.color = Color::Theme(3, 0);
+        }
+        "Total" => {
+            s.font.bold = true;
+            s.borders.top = BorderLine { style: BorderStyle::Thin, color: accent(4, 0) };
+            s.borders.bottom = BorderLine { style: BorderStyle::Double, color: accent(4, 0) };
+        }
+        "Currency" => s.num_fmt = NumFmt::new(ACCOUNTING),
+        "Comma" => s.num_fmt = NumFmt::new(COMMA),
+        "Percent" => s.num_fmt = NumFmt::new("0%"),
+        "Currency [0]" => s.num_fmt = NumFmt::new("_(\"$\"* #,##0_);_(\"$\"* \\(#,##0\\);_(\"$\"* \"-\"_);_(@_)"),
+        "Comma [0]" => s.num_fmt = NumFmt::new("_(* #,##0_);_(* \\(#,##0\\);_(* \"-\"_);_(@_)"),
+        n => {
+            // AccentN, 20%/40%/60% - AccentN
+            let (pct, rest) = match n.split_once("% - ") {
+                Some((p, r)) => (p.parse::<i16>().ok(), r),
+                None => (None, n),
+            };
+            let i: u8 = rest.strip_prefix("Accent")?.parse().ok()?;
+            if !(1..=6).contains(&i) {
+                return None;
+            }
+            match pct {
+                None => {
+                    s.fill = Fill::solid(accent(3 + i, 0));
+                    s.font.color = Color::Theme(0, 0);
+                }
+                Some(p) => {
+                    s.fill = Fill::solid(accent(3 + i, (1000 - p * 10).clamp(0, 1000)));
+                    s.font.color = if p >= 60 { Color::Theme(0, 0) } else { Color::Theme(1, 0) };
+                }
+            }
+        }
+    }
+    Some(s)
+}
+
+pub const CELL_STYLE_NAMES: &[&str] = &[
+    "Normal",
+    "Bad",
+    "Good",
+    "Neutral",
+    "Calculation",
+    "Check Cell",
+    "Explanatory Text",
+    "Input",
+    "Linked Cell",
+    "Note",
+    "Output",
+    "Warning Text",
+    "Heading 1",
+    "Heading 2",
+    "Heading 3",
+    "Heading 4",
+    "Title",
+    "Total",
+    "20% - Accent1",
+    "20% - Accent2",
+    "20% - Accent3",
+    "20% - Accent4",
+    "20% - Accent5",
+    "20% - Accent6",
+    "40% - Accent1",
+    "40% - Accent2",
+    "40% - Accent3",
+    "40% - Accent4",
+    "40% - Accent5",
+    "40% - Accent6",
+    "60% - Accent1",
+    "60% - Accent2",
+    "60% - Accent3",
+    "60% - Accent4",
+    "60% - Accent5",
+    "60% - Accent6",
+    "Accent1",
+    "Accent2",
+    "Accent3",
+    "Accent4",
+    "Accent5",
+    "Accent6",
+    "Comma",
+    "Comma [0]",
+    "Currency",
+    "Currency [0]",
+    "Percent",
+];
+
+pub(super) fn cell_style(s: &mut Session, p: &Json) -> Result<Json> {
+    let name = str_param(p, "name").unwrap_or("Normal").to_string();
+    let d = s.doc()?;
+    let style =
+        d.wb.cell_styles
+            .iter()
+            .find(|(n, _)| n.eq_ignore_ascii_case(&name))
+            .map(|(_, s)| s.clone())
+            .or_else(|| builtin_cell_style(&name, &d.wb.theme));
+    let Some(style) = style else { return Err(bad("home.cellStyle", format!("unknown cell style `{name}`"))) };
+    // Number-format styles only change the number format.
+    let only_fmt = matches!(name.as_str(), "Comma" | "Comma [0]" | "Currency" | "Currency [0]" | "Percent");
+    apply_style(s, p, move |st| {
+        if only_fmt {
+            st.num_fmt = style.num_fmt.clone();
+        } else {
+            let keep_fmt = st.num_fmt.clone();
+            *st = style.clone();
+            if style.num_fmt.as_str() == "General" {
+                st.num_fmt = keep_fmt;
+            }
+        }
+    })
+}
diff --git a/crates/engine/src/cmd/format/sizes.rs b/crates/engine/src/cmd/format/sizes.rs
new file mode 100644
index 000000000..9d82f40c0
--- /dev/null
+++ b/crates/engine/src/cmd/format/sizes.rs
@@ -0,0 +1,243 @@
+use super::*;
+
+// ---------------------------------------------------------------- sizes
+
+/// The sheet and the row (or column) spans a size or visibility command works on. The lines are
+/// `rows`/`cols` (`"2:5"`, `"B:B,D:F"`, optionally `Sheet!`-prefixed), else the selection's; the
+/// sheet is `sheet`, else the prefix, else the active one. The selection belongs to the active
+/// sheet, so another sheet needs explicit lines.
+fn line_targets(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> {
+    let key = if rows { "rows" } else { "cols" };
+    let mut sheet = target_sheet(s, p)?;
+    if let Some(t) = str_param(p, key) {
+        let (prefix, body) = split_sheet(t);
+        if let Some(name) = prefix {
+            let named = s.doc()?.wb.sheet_index(&name).ok_or_else(|| bad(key, format!("no sheet named `{name}`")))?;
+            if p.get("sheet").is_some_and(|v| !v.is_null()) && named != sheet {
+                return Err(bad(key, format!("`{t}` names a sheet other than `sheet`")));
+            }
+            sheet = named;
+        }
+        // A comma-separated list ("B:B,D:F") targets several areas, like a multi-area selection.
+        let lines = body
+            .split(',')
+            .map(|part| {
+                let r = parse_lines(part).ok_or_else(|| bad(key, format!("not a range: {part}")))?;
+                Ok(if rows { (r.start.row, r.end.row) } else { (r.start.col, r.end.col) })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        return Ok((sheet, lines));
+    }
+    let d = s.doc()?;
+    if sheet != d.wb.active_sheet() {
+        return Err(bad(key, format!("missing `{key}`: the selection is on the active sheet")));
+    }
+    Ok((sheet, d.selection.ranges.iter().map(|r| if rows { (r.start.row, r.end.row) } else { (r.start.col, r.end.col) }).collect()))
+}
+
+/// Sizes are pixels at 96 dpi, the model's unit (header drags send pixels). `points` (row height)
+/// and `chars` (column width) take Excel's units, those of its Row Height and Column Width dialogs
+/// and of the file (`ht` is in points).
+pub(super) fn row_height(s: &mut Session, p: &Json) -> Result<Json> {
+    let h = match (f64_param(p, "height"), f64_param(p, "points")) {
+        (Some(h), _) => {
+            if !(0.0..=546.0).contains(&h) {
+                return Err(EngineError::Other("Row height must be between 0 and 546 pixels (409.5 points).".into()));
+            }
+            h
+        }
+        (None, Some(pt)) => {
+            if !(0.0..=409.5).contains(&pt) {
+                return Err(EngineError::Other("Row height must be between 0 and 409.5 points.".into()));
+            }
+            pt * 4.0 / 3.0
+        }
+        _ => return Err(bad("home.rowHeight", "missing `height` (pixels) or `points`")),
+    };
+    let (si, lines) = line_targets(s, p, true)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        for (a, b) in lines {
+            for r in a..=b.min(a.saturating_add(1_048_575)) {
+                let e = sh.rows.entry(r).or_default();
+                e.size = Some(h as f32);
+                e.hidden = h == 0.0;
+                e.custom = true;
+            }
+        }
+        cx.structural = true; // setting a height shows or hides rows: SUBTOTAL(10x) depends on it
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn col_width(s: &mut Session, p: &Json) -> Result<Json> {
+    let w = match (f64_param(p, "width"), f64_param(p, "chars")) {
+        (Some(w), _) => {
+            if !(0.0..=1800.0).contains(&w) {
+                return Err(EngineError::Other("Column width must be between 0 and 1800 pixels.".into()));
+            }
+            w
+        }
+        (None, Some(c)) => {
+            if !(0.0..=255.0).contains(&c) {
+                return Err(EngineError::Other("Column width must be between 0 and 255 characters.".into()));
+            }
+            chars_to_points(c)
+        }
+        _ => return Err(bad("home.columnWidth", "missing `width` (pixels) or `chars`")),
+    };
+    let (si, lines) = line_targets(s, p, false)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        for (a, b) in lines {
+            for c in a..=b {
+                let e = sh.cols.entry(c).or_default();
+                e.size = Some(w as f32);
+                e.hidden = w == 0.0;
+            }
+        }
+        Ok(Json::Null)
+    })
+}
+
+/// Excel column width in characters (of the default font's digit width, 7 px) → pixels.
+pub fn chars_to_points(c: f64) -> f64 {
+    if c <= 0.0 {
+        0.0
+    } else if c < 1.0 {
+        (c * 12.0).round()
+    } else {
+        (c * 7.0 + 5.0).round()
+    }
+}
+
+/// Approximate text width in points for autofit (no font metrics in the engine: average glyph
+/// widths for the default font; a front end with fonts measures instead, see `Session::text_width`).
+pub fn approx_text_width(text: &str, size: f32, bold: bool) -> f32 {
+    let mut w = 0.0;
+    for c in text.chars() {
+        w += match c {
+            'i' | 'l' | 'j' | '\'' | '.' | ',' | ':' | ';' | '!' | '|' => 0.28,
+            'f' | 't' | 'r' | 'I' | ' ' | '(' | ')' | '-' => 0.38,
+            'm' | 'w' | 'M' | 'W' => 0.85,
+            c if c.is_ascii_uppercase() => 0.65,
+            c if c.is_ascii_digit() => 0.56,
+            c if c.is_ascii() => 0.52,
+            _ => 1.0,
+        };
+    }
+    w * size * if bold { 1.07 } else { 1.0 } * 96.0 / 72.0
+}
+
+/// Distinct texts AutoFit measures exactly; past this many, `Session::text_width` is asked for a
+/// quick measure so a huge column doesn't lay out every value.
+const EXACT_TEXT_WIDTHS: usize = 2_000;
+
+pub(super) fn autofit_cols(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, lines) = line_targets(s, p, false)?;
+    let measure = s.text_width.clone();
+    edit(s, |cx| {
+        let Some(sh) = cx.wb.sheet(si) else { return Ok(Json::Null) };
+        let mut widths = Vec::new();
+        let mut measured: std::collections::HashMap<StyleId, std::collections::HashMap<String, f32>> = Default::default();
+        let mut distinct = 0usize;
+        let used = sh.used_range();
+        for (a, b) in lines {
+            for c in a..=b.min(a + 16383) {
+                let Some(u) = used else { continue };
+                let col = RangeRef::new(CellRef::new(u.start.row, c), CellRef::new(u.end.row, c));
+                let mut max: f32 = 0.0;
+                for (cell, _) in sh.cells.iter_range(col) {
+                    if sh.merge_at(cell).is_some_and(|m| !m.is_single()) {
+                        continue;
+                    }
+                    let id = sh.style_id(cell);
+                    let st = cx.wb.styles.get(id);
+                    let text = crate::display::cell_text(&cx.wb, sh, cell);
+                    for line in text.lines() {
+                        let w = match &measure {
+                            Some(m) => {
+                                let known = measured.entry(id).or_default();
+                                match known.get(line) {
+                                    Some(w) => *w,
+                                    None => {
+                                        let w = m(line, &st.font, distinct < EXACT_TEXT_WIDTHS);
+                                        known.insert(line.to_owned(), w);
+                                        distinct += 1;
+                                        w
+                                    }
+                                }
+                            }
+                            None => approx_text_width(line, st.font.size, st.font.bold),
+                        };
+                        max = max.max(w + 6.0 + st.align.indent as f32 * 9.0 + sh.filter_button_space(cell));
+                    }
+                }
+                if max > 0.0 {
+                    widths.push((c, max.clamp(8.0, 1785.0)));
+                }
+            }
+        }
+        let sh = cx.sheet_mut(si)?;
+        for (c, w) in widths {
+            let e = sh.cols.entry(c).or_default();
+            e.size = Some(w.ceil());
+            e.hidden = false;
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn autofit_rows(s: &mut Session, p: &Json) -> Result<Json> {
+    let (si, lines) = line_targets(s, p, true)?;
+    edit(s, |cx| {
+        for (a, b) in lines {
+            let b = b.min(a + 100_000);
+            if let Some(sh) = cx.wb.sheet_mut(si) {
+                for r in a..=b {
+                    if let Some(e) = sh.rows.get_mut(&r) {
+                        e.custom = false;
+                        e.hidden = false;
+                    }
+                }
+            }
+            cx.fit_rows.extend((a..=b).map(|r| (si, r)));
+        }
+        cx.structural = true; // autofit reveals hidden rows: SUBTOTAL(10x) depends on it
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn default_width(s: &mut Session, p: &Json) -> Result<Json> {
+    let w = f64_param(p, "width").ok_or_else(|| bad("home.defaultWidth", "missing `width`"))?;
+    let si = target_sheet(s, p)?;
+    edit(s, |cx| {
+        cx.sheet_mut(si)?.default_col_width = w.clamp(0.0, 1800.0) as f32;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn hide(s: &mut Session, p: &Json, rows: bool, on: bool) -> Result<Json> {
+    let (si, lines) = line_targets(s, p, rows)?;
+    edit(s, |cx| {
+        let sh = cx.sheet_mut(si)?;
+        for (a, b) in lines {
+            // Unhiding a single selected line also reveals hidden neighbours (Excel needs the
+            // lines on both sides selected; we're forgiving).
+            let (a, b) = if !on && a == b { (a.saturating_sub(1), b + 1) } else { (a, b) };
+            for i in a..=b.min(a.saturating_add(1_048_575)) {
+                let map = if rows { &mut sh.rows } else { &mut sh.cols };
+                if on {
+                    map.entry(i).or_default().hidden = true;
+                } else if let Some(e) = map.get_mut(&i) {
+                    e.hidden = false;
+                    if e.size == Some(0.0) {
+                        e.size = None;
+                    }
+                }
+            }
+        }
+        cx.structural = true; // SUBTOTAL(10x) depends on hidden rows
+        Ok(Json::Null)
+    })
+}

From 506bc8a0f20a3f02711a3a81d79f8036d5caaffb Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:56:06 +0000
Subject: [PATCH 55/76] refactor(engine): move cmd/sheet.rs items to cmd/sheet/

---
 crates/engine/src/cmd/sheet.rs      | 288 +---------------------------
 crates/engine/src/cmd/sheet/tabs.rs | 285 +++++++++++++++++++++++++++
 2 files changed, 289 insertions(+), 284 deletions(-)
 create mode 100644 crates/engine/src/cmd/sheet/tabs.rs

diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rs
index ea615cb83..276d14f13 100644
--- a/crates/engine/src/cmd/sheet.rs
+++ b/crates/engine/src/cmd/sheet.rs
@@ -12,6 +12,10 @@ use super::{
     str_param, target_range, target_sheet, u32_param,
 };
 
+mod tabs;
+
+use tabs::{activate, delete_sheet, hide_sheet, insert_sheet, move_sheet, rename_sheet, step_sheet, tab_color, unhide_sheet};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -694,42 +698,6 @@ fn insert_copied_steps(s: &mut Session, clip: &crate::Clipboard, sheet: usize, a
     Ok((moved, out))
 }
 
-fn insert_sheet(s: &mut Session, p: &Json) -> Result<Json> {
-    if s.doc()?.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    let name = match str_param(p, "name") {
-        Some(n) => n.to_string(),
-        None => s.doc()?.wb.next_sheet_name(),
-    };
-    s.doc()?.wb.check_sheet_name(&name, None).map_err(EngineError::Other)?;
-    let d = s.doc_mut()?;
-    let before = p.get("before").and_then(Json::as_u64).map(|v| v as usize);
-    let idx = edit_doc(d, |cx| {
-        // Excel inserts before the active sheet; the "+" button appends after it.
-        let at = before.unwrap_or(cx.wb.active_sheet() + 1).min(cx.wb.sheets.len());
-        cx.wb.sheets.insert(at, Arc::new(Sheet::new(name.clone())));
-        // Names scoped to later sheets shift.
-        for n in cx.wb.names.iter_mut() {
-            if let Some(sc) = n.scope.as_mut()
-                && *sc >= at
-            {
-                *sc += 1;
-            }
-        }
-        cx.wb.set_active_sheet(at);
-        *cx.sel = crate::Selection::default();
-        cx.structural = true;
-        Ok(at)
-    })?;
-    d.sheet_selections.insert(idx.min(d.sheet_selections.len()), crate::Selection::default());
-    Ok(json!({"index": idx, "name": name}))
-}
-
-fn edit_doc<R>(d: &mut crate::DocState, f: impl FnOnce(&mut Ctx) -> Result<R>) -> Result<R> {
-    super::commit(d, f)
-}
-
 /// Sheet protection for inserting or deleting rows/columns: the protection must allow it, and
 /// deleted lines must not hold locked cells.
 fn check_lines_protection(s: &Session, p: &Json, axis: Axis, at: u32, count: u32, insert: bool) -> Result<()> {
@@ -763,254 +731,6 @@ fn check_lines_protection(s: &Session, p: &Json, axis: Axis, at: u32, count: u32
     Ok(())
 }
 
-fn delete_sheet(s: &mut Session, p: &Json) -> Result<Json> {
-    let i = target_sheet(s, p)?;
-    let d = s.doc()?;
-    if d.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    if d.wb.sheets.iter().filter(|s| s.visibility == Visibility::Visible).count() <= 1 {
-        return Err(EngineError::Other("A workbook must contain at least one visible worksheet.".into()));
-    }
-    let name = d.wb.sheet(i).map(|s| s.name.clone()).unwrap_or_default();
-    let order: Vec<String> = d.wb.sheets.iter().map(|s| s.name.clone()).collect();
-    let d = s.doc_mut()?;
-    edit_doc(d, |cx| {
-        cx.wb.sheets.remove(i);
-        for si in 0..cx.wb.sheets.len() {
-            let keys: Vec<(CellRef, Arc<gridcraft_model::Formula>)> =
-                cx.wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
-            let Some(sh) = cx.wb.sheet_mut(si) else { continue };
-            for (c, f) in keys {
-                if let Some(e) = f.expr() {
-                    let ne = gridcraft_formula::adjust::delete_sheet(e, &name, &order);
-                    if let Some(cell) = sh.cells.get_mut(c) {
-                        cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
-                    }
-                }
-            }
-        }
-        cx.wb.names.retain(|n| n.scope != Some(i));
-        for n in cx.wb.names.iter_mut() {
-            if let Some(sc) = n.scope.as_mut()
-                && *sc > i
-            {
-                *sc -= 1;
-            }
-            // Names referring to the sheet become #REF!.
-            if let Ok(e) = gridcraft_formula::parse_name(&n.formula) {
-                let ne = gridcraft_formula::adjust::delete_sheet(e.clone(), &name, &order);
-                if ne != e {
-                    n.formula = gridcraft_formula::print(&ne);
-                }
-            }
-        }
-        if cx.wb.active_sheet() >= cx.wb.sheets.len() || cx.wb.active_sheet() > i {
-            cx.wb.set_active_sheet(cx.wb.active_sheet().saturating_sub(1).min(cx.wb.sheets.len().saturating_sub(1)));
-        }
-        *cx.sel = crate::Selection::default();
-        cx.structural = true;
-        Ok(())
-    })?;
-    if i < d.sheet_selections.len() {
-        d.sheet_selections.remove(i);
-    }
-    ok()
-}
-
-fn rename_sheet(s: &mut Session, p: &Json) -> Result<Json> {
-    if s.doc()?.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    let i = target_sheet(s, p)?;
-    let Some(name) = str_param(p, "name").map(|n| n.trim().to_string()) else { return Err(bad("sheet.rename", "missing `name`")) };
-    s.doc()?.wb.check_sheet_name(&name, Some(i)).map_err(EngineError::Other)?;
-    edit(s, |cx| {
-        let old = cx.wb.sheet(i).map(|s| s.name.clone()).unwrap_or_default();
-        cx.sheet_mut(i)?.name = name.clone();
-        for si in 0..cx.wb.sheets.len() {
-            let keys: Vec<(CellRef, Arc<gridcraft_model::Formula>)> =
-                cx.wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
-            let Some(sh) = cx.wb.sheet_mut(si) else { continue };
-            for (c, f) in keys {
-                if let Some(e) = f.expr() {
-                    let ne = gridcraft_formula::adjust::rename_sheet(e, &old, &name);
-                    let text = gridcraft_formula::print(&ne);
-                    if text != f.text
-                        && let Some(cell) = sh.cells.get_mut(c)
-                    {
-                        cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
-                    }
-                }
-            }
-            let fix = |t: &str| {
-                gridcraft_formula::parse(t)
-                    .map(|e| gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name)))
-                    .unwrap_or_else(|_| t.to_string())
-            };
-            for ch in sh.charts.iter_mut() {
-                for se in ch.series.iter_mut() {
-                    se.values = fix(&se.values);
-                    se.categories = se.categories.as_deref().map(fix);
-                    se.name = se.name.as_deref().map(fix);
-                }
-                // A PivotChart follows its PivotTable's sheet.
-                if let Some((sheet, pivot)) = ch.pivot.as_deref().and_then(crate::pivot::parse_chart_link)
-                    && sheet.eq_ignore_ascii_case(&old)
-                {
-                    ch.pivot = Some(crate::pivot::chart_link(&name, &pivot));
-                }
-            }
-        }
-        for n in cx.wb.names.iter_mut() {
-            if let Ok(e) = gridcraft_formula::parse_name(&n.formula) {
-                n.formula = gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name));
-            }
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-fn move_sheet(s: &mut Session, p: &Json) -> Result<Json> {
-    if s.doc()?.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    let i = target_sheet(s, p)?;
-    let copy = bool_param(p, "copy").unwrap_or(false);
-    let to = p.get("to").and_then(Json::as_u64).map(|v| v as usize).ok_or_else(|| bad("sheet.move", "missing `to`"))?;
-    edit(s, |cx| {
-        let n = cx.wb.sheets.len();
-        let Some(src) = cx.wb.sheets.get(i).cloned() else { return Err(bad("sheet.move", "no such sheet")) };
-        if copy {
-            let mut sh = (*src).clone();
-            let base = sh.name.clone();
-            // `Name (2)`: the name is shortened so the suffix fits in Excel's 31 characters.
-            let name = (2..)
-                .map(|k| {
-                    let suffix = format!(" ({k})");
-                    let keep = 31usize.saturating_sub(suffix.chars().count());
-                    format!("{}{suffix}", base.chars().take(keep).collect::<String>().trim_end())
-                })
-                .find(|nm| cx.wb.sheet_index(nm).is_none())
-                .unwrap_or(base.clone());
-            sh.name = name;
-            sh.tables.clear(); // table names must be unique
-            sh.preserved = None; // kept file content (form controls, OLE objects…) stays with the original
-            let at = to.min(n);
-            // The copy gets its own copies of the sheet's names, referring to the copy.
-            let copies: Vec<gridcraft_model::DefinedName> = cx
-                .wb
-                .names
-                .iter()
-                .filter(|nm| nm.scope == Some(i))
-                .map(|nm| {
-                    let formula = gridcraft_formula::parse_name(&nm.formula)
-                        .map(|e| gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &base, &sh.name)))
-                        .unwrap_or_else(|_| nm.formula.clone());
-                    gridcraft_model::DefinedName { scope: Some(at), formula, ..nm.clone() }
-                })
-                .collect();
-            for nm in cx.wb.names.iter_mut() {
-                if let Some(sc) = nm.scope.as_mut()
-                    && *sc >= at
-                {
-                    *sc += 1;
-                }
-            }
-            cx.wb.names.extend(copies);
-            cx.wb.sheets.insert(at, Arc::new(sh));
-            cx.wb.set_active_sheet(at);
-        } else {
-            let sh = cx.wb.sheets.remove(i);
-            let at = to.min(n - 1);
-            cx.wb.sheets.insert(at, sh);
-            cx.wb.set_active_sheet(at);
-            // Sheet-level names follow their sheet.
-            for nm in cx.wb.names.iter_mut() {
-                if let Some(sc) = nm.scope.as_mut() {
-                    *sc = match *sc {
-                        x if x == i => at,
-                        x if i < x && x <= at => x - 1,
-                        x if at <= x && x < i => x + 1,
-                        x => x,
-                    };
-                }
-            }
-        }
-        cx.structural = true;
-        Ok(Json::Null)
-    })
-}
-
-fn tab_color(s: &mut Session, p: &Json) -> Result<Json> {
-    let i = target_sheet(s, p)?;
-    let c = super::format::color_param(p.get("color"));
-    edit(s, |cx| {
-        cx.sheet_mut(i)?.tab_color = c.filter(|c| *c != gridcraft_model::Color::Auto);
-        Ok(Json::Null)
-    })
-}
-
-fn hide_sheet(s: &mut Session, p: &Json) -> Result<Json> {
-    if s.doc()?.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    let i = target_sheet(s, p)?;
-    if s.doc()?.wb.sheets.iter().filter(|s| s.visibility == Visibility::Visible).count() <= 1 {
-        return Err(EngineError::Other("A workbook must contain at least one visible worksheet.".into()));
-    }
-    edit(s, |cx| {
-        cx.sheet_mut(i)?.visibility = Visibility::Hidden;
-        if cx.wb.active_sheet() == i {
-            cx.wb.set_active_sheet(cx.wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0));
-        }
-        Ok(Json::Null)
-    })
-}
-
-fn unhide_sheet(s: &mut Session, p: &Json) -> Result<Json> {
-    if s.doc()?.wb.protected_structure {
-        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
-    }
-    if p.get("sheet").is_none() {
-        let hidden: Vec<String> = s.doc()?.wb.sheets.iter().filter(|s| s.visibility != Visibility::Visible).map(|s| s.name.clone()).collect();
-        if hidden.is_empty() {
-            return Err(EngineError::Other("No sheets are hidden.".into()));
-        }
-        s.ui_requests.push(crate::UiRequest::Dialog("unhideSheet".into(), json!({"sheets": hidden})));
-        return ok();
-    }
-    let i = target_sheet(s, p)?;
-    edit(s, |cx| {
-        cx.sheet_mut(i)?.visibility = Visibility::Visible;
-        cx.wb.set_active_sheet(i);
-        Ok(Json::Null)
-    })
-}
-
-fn activate(s: &mut Session, p: &Json) -> Result<Json> {
-    let i = target_sheet(s, p)?;
-    let d = s.doc_mut()?;
-    d.wb_switch_sheet(i);
-    Ok(json!({"sheet": i, "name": d.wb.active().map(|s| s.name.clone())}))
-}
-
-fn step_sheet(s: &mut Session, dir: isize) -> Result<Json> {
-    let d = s.doc()?;
-    let mut i = d.wb.active_sheet();
-    while let Some(next) = i.checked_add_signed(dir) {
-        let Some(sheet) = d.wb.sheet(next) else { break };
-        if sheet.visibility == Visibility::Visible {
-            s.doc_mut()?.wb_switch_sheet(next);
-            return ok();
-        }
-        i = next;
-    }
-    // No visible sheet in this direction: keep the current sheet and its selection.
-    ok()
-}
-
 /// Where a range of the edited sheet goes after a structural edit (`None` = deleted).
 pub(crate) fn map_range(r: RangeRef, e: &Edit) -> Option<RangeRef> {
     let expr = gridcraft_formula::Expr::Ref(gridcraft_formula::Reference {
diff --git a/crates/engine/src/cmd/sheet/tabs.rs b/crates/engine/src/cmd/sheet/tabs.rs
new file mode 100644
index 000000000..245404723
--- /dev/null
+++ b/crates/engine/src/cmd/sheet/tabs.rs
@@ -0,0 +1,285 @@
+use super::*;
+
+pub(super) fn insert_sheet(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    let name = match str_param(p, "name") {
+        Some(n) => n.to_string(),
+        None => s.doc()?.wb.next_sheet_name(),
+    };
+    s.doc()?.wb.check_sheet_name(&name, None).map_err(EngineError::Other)?;
+    let d = s.doc_mut()?;
+    let before = p.get("before").and_then(Json::as_u64).map(|v| v as usize);
+    let idx = edit_doc(d, |cx| {
+        // Excel inserts before the active sheet; the "+" button appends after it.
+        let at = before.unwrap_or(cx.wb.active_sheet() + 1).min(cx.wb.sheets.len());
+        cx.wb.sheets.insert(at, Arc::new(Sheet::new(name.clone())));
+        // Names scoped to later sheets shift.
+        for n in cx.wb.names.iter_mut() {
+            if let Some(sc) = n.scope.as_mut()
+                && *sc >= at
+            {
+                *sc += 1;
+            }
+        }
+        cx.wb.set_active_sheet(at);
+        *cx.sel = crate::Selection::default();
+        cx.structural = true;
+        Ok(at)
+    })?;
+    d.sheet_selections.insert(idx.min(d.sheet_selections.len()), crate::Selection::default());
+    Ok(json!({"index": idx, "name": name}))
+}
+
+fn edit_doc<R>(d: &mut crate::DocState, f: impl FnOnce(&mut Ctx) -> Result<R>) -> Result<R> {
+    crate::cmd::commit(d, f)
+}
+
+pub(super) fn delete_sheet(s: &mut Session, p: &Json) -> Result<Json> {
+    let i = target_sheet(s, p)?;
+    let d = s.doc()?;
+    if d.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    if d.wb.sheets.iter().filter(|s| s.visibility == Visibility::Visible).count() <= 1 {
+        return Err(EngineError::Other("A workbook must contain at least one visible worksheet.".into()));
+    }
+    let name = d.wb.sheet(i).map(|s| s.name.clone()).unwrap_or_default();
+    let order: Vec<String> = d.wb.sheets.iter().map(|s| s.name.clone()).collect();
+    let d = s.doc_mut()?;
+    edit_doc(d, |cx| {
+        cx.wb.sheets.remove(i);
+        for si in 0..cx.wb.sheets.len() {
+            let keys: Vec<(CellRef, Arc<gridcraft_model::Formula>)> =
+                cx.wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
+            let Some(sh) = cx.wb.sheet_mut(si) else { continue };
+            for (c, f) in keys {
+                if let Some(e) = f.expr() {
+                    let ne = gridcraft_formula::adjust::delete_sheet(e, &name, &order);
+                    if let Some(cell) = sh.cells.get_mut(c) {
+                        cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
+                    }
+                }
+            }
+        }
+        cx.wb.names.retain(|n| n.scope != Some(i));
+        for n in cx.wb.names.iter_mut() {
+            if let Some(sc) = n.scope.as_mut()
+                && *sc > i
+            {
+                *sc -= 1;
+            }
+            // Names referring to the sheet become #REF!.
+            if let Ok(e) = gridcraft_formula::parse_name(&n.formula) {
+                let ne = gridcraft_formula::adjust::delete_sheet(e.clone(), &name, &order);
+                if ne != e {
+                    n.formula = gridcraft_formula::print(&ne);
+                }
+            }
+        }
+        if cx.wb.active_sheet() >= cx.wb.sheets.len() || cx.wb.active_sheet() > i {
+            cx.wb.set_active_sheet(cx.wb.active_sheet().saturating_sub(1).min(cx.wb.sheets.len().saturating_sub(1)));
+        }
+        *cx.sel = crate::Selection::default();
+        cx.structural = true;
+        Ok(())
+    })?;
+    if i < d.sheet_selections.len() {
+        d.sheet_selections.remove(i);
+    }
+    ok()
+}
+
+pub(super) fn rename_sheet(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    let i = target_sheet(s, p)?;
+    let Some(name) = str_param(p, "name").map(|n| n.trim().to_string()) else { return Err(bad("sheet.rename", "missing `name`")) };
+    s.doc()?.wb.check_sheet_name(&name, Some(i)).map_err(EngineError::Other)?;
+    edit(s, |cx| {
+        let old = cx.wb.sheet(i).map(|s| s.name.clone()).unwrap_or_default();
+        cx.sheet_mut(i)?.name = name.clone();
+        for si in 0..cx.wb.sheets.len() {
+            let keys: Vec<(CellRef, Arc<gridcraft_model::Formula>)> =
+                cx.wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
+            let Some(sh) = cx.wb.sheet_mut(si) else { continue };
+            for (c, f) in keys {
+                if let Some(e) = f.expr() {
+                    let ne = gridcraft_formula::adjust::rename_sheet(e, &old, &name);
+                    let text = gridcraft_formula::print(&ne);
+                    if text != f.text
+                        && let Some(cell) = sh.cells.get_mut(c)
+                    {
+                        cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
+                    }
+                }
+            }
+            let fix = |t: &str| {
+                gridcraft_formula::parse(t)
+                    .map(|e| gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name)))
+                    .unwrap_or_else(|_| t.to_string())
+            };
+            for ch in sh.charts.iter_mut() {
+                for se in ch.series.iter_mut() {
+                    se.values = fix(&se.values);
+                    se.categories = se.categories.as_deref().map(fix);
+                    se.name = se.name.as_deref().map(fix);
+                }
+                // A PivotChart follows its PivotTable's sheet.
+                if let Some((sheet, pivot)) = ch.pivot.as_deref().and_then(crate::pivot::parse_chart_link)
+                    && sheet.eq_ignore_ascii_case(&old)
+                {
+                    ch.pivot = Some(crate::pivot::chart_link(&name, &pivot));
+                }
+            }
+        }
+        for n in cx.wb.names.iter_mut() {
+            if let Ok(e) = gridcraft_formula::parse_name(&n.formula) {
+                n.formula = gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name));
+            }
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn move_sheet(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    let i = target_sheet(s, p)?;
+    let copy = bool_param(p, "copy").unwrap_or(false);
+    let to = p.get("to").and_then(Json::as_u64).map(|v| v as usize).ok_or_else(|| bad("sheet.move", "missing `to`"))?;
+    edit(s, |cx| {
+        let n = cx.wb.sheets.len();
+        let Some(src) = cx.wb.sheets.get(i).cloned() else { return Err(bad("sheet.move", "no such sheet")) };
+        if copy {
+            let mut sh = (*src).clone();
+            let base = sh.name.clone();
+            // `Name (2)`: the name is shortened so the suffix fits in Excel's 31 characters.
+            let name = (2..)
+                .map(|k| {
+                    let suffix = format!(" ({k})");
+                    let keep = 31usize.saturating_sub(suffix.chars().count());
+                    format!("{}{suffix}", base.chars().take(keep).collect::<String>().trim_end())
+                })
+                .find(|nm| cx.wb.sheet_index(nm).is_none())
+                .unwrap_or(base.clone());
+            sh.name = name;
+            sh.tables.clear(); // table names must be unique
+            sh.preserved = None; // kept file content (form controls, OLE objects…) stays with the original
+            let at = to.min(n);
+            // The copy gets its own copies of the sheet's names, referring to the copy.
+            let copies: Vec<gridcraft_model::DefinedName> = cx
+                .wb
+                .names
+                .iter()
+                .filter(|nm| nm.scope == Some(i))
+                .map(|nm| {
+                    let formula = gridcraft_formula::parse_name(&nm.formula)
+                        .map(|e| gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &base, &sh.name)))
+                        .unwrap_or_else(|_| nm.formula.clone());
+                    gridcraft_model::DefinedName { scope: Some(at), formula, ..nm.clone() }
+                })
+                .collect();
+            for nm in cx.wb.names.iter_mut() {
+                if let Some(sc) = nm.scope.as_mut()
+                    && *sc >= at
+                {
+                    *sc += 1;
+                }
+            }
+            cx.wb.names.extend(copies);
+            cx.wb.sheets.insert(at, Arc::new(sh));
+            cx.wb.set_active_sheet(at);
+        } else {
+            let sh = cx.wb.sheets.remove(i);
+            let at = to.min(n - 1);
+            cx.wb.sheets.insert(at, sh);
+            cx.wb.set_active_sheet(at);
+            // Sheet-level names follow their sheet.
+            for nm in cx.wb.names.iter_mut() {
+                if let Some(sc) = nm.scope.as_mut() {
+                    *sc = match *sc {
+                        x if x == i => at,
+                        x if i < x && x <= at => x - 1,
+                        x if at <= x && x < i => x + 1,
+                        x => x,
+                    };
+                }
+            }
+        }
+        cx.structural = true;
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn tab_color(s: &mut Session, p: &Json) -> Result<Json> {
+    let i = target_sheet(s, p)?;
+    let c = crate::cmd::format::color_param(p.get("color"));
+    edit(s, |cx| {
+        cx.sheet_mut(i)?.tab_color = c.filter(|c| *c != gridcraft_model::Color::Auto);
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn hide_sheet(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    let i = target_sheet(s, p)?;
+    if s.doc()?.wb.sheets.iter().filter(|s| s.visibility == Visibility::Visible).count() <= 1 {
+        return Err(EngineError::Other("A workbook must contain at least one visible worksheet.".into()));
+    }
+    edit(s, |cx| {
+        cx.sheet_mut(i)?.visibility = Visibility::Hidden;
+        if cx.wb.active_sheet() == i {
+            cx.wb.set_active_sheet(cx.wb.sheets.iter().position(|s| s.visibility == Visibility::Visible).unwrap_or(0));
+        }
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn unhide_sheet(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure {
+        return Err(EngineError::Other("The workbook is protected and cannot be changed.".into()));
+    }
+    if p.get("sheet").is_none() {
+        let hidden: Vec<String> = s.doc()?.wb.sheets.iter().filter(|s| s.visibility != Visibility::Visible).map(|s| s.name.clone()).collect();
+        if hidden.is_empty() {
+            return Err(EngineError::Other("No sheets are hidden.".into()));
+        }
+        s.ui_requests.push(crate::UiRequest::Dialog("unhideSheet".into(), json!({"sheets": hidden})));
+        return ok();
+    }
+    let i = target_sheet(s, p)?;
+    edit(s, |cx| {
+        cx.sheet_mut(i)?.visibility = Visibility::Visible;
+        cx.wb.set_active_sheet(i);
+        Ok(Json::Null)
+    })
+}
+
+pub(super) fn activate(s: &mut Session, p: &Json) -> Result<Json> {
+    let i = target_sheet(s, p)?;
+    let d = s.doc_mut()?;
+    d.wb_switch_sheet(i);
+    Ok(json!({"sheet": i, "name": d.wb.active().map(|s| s.name.clone())}))
+}
+
+pub(super) fn step_sheet(s: &mut Session, dir: isize) -> Result<Json> {
+    let d = s.doc()?;
+    let mut i = d.wb.active_sheet();
+    while let Some(next) = i.checked_add_signed(dir) {
+        let Some(sheet) = d.wb.sheet(next) else { break };
+        if sheet.visibility == Visibility::Visible {
+            s.doc_mut()?.wb_switch_sheet(next);
+            return ok();
+        }
+        i = next;
+    }
+    // No visible sheet in this direction: keep the current sheet and its selection.
+    ok()
+}

From 4b3fd234580f5463da7aeef11f35306ca6886191 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:59:32 +0000
Subject: [PATCH 56/76] refactor(engine): move cmd/whatif.rs items to
 cmd/whatif/

---
 crates/engine/src/cmd/whatif.rs               | 725 +-----------------
 .../engine/src/cmd/whatif/advanced_filter.rs  | 231 ++++++
 crates/engine/src/cmd/whatif/consolidate.rs   | 193 +++++
 crates/engine/src/cmd/whatif/scenarios.rs     | 294 +++++++
 4 files changed, 730 insertions(+), 713 deletions(-)
 create mode 100644 crates/engine/src/cmd/whatif/advanced_filter.rs
 create mode 100644 crates/engine/src/cmd/whatif/consolidate.rs
 create mode 100644 crates/engine/src/cmd/whatif/scenarios.rs

diff --git a/crates/engine/src/cmd/whatif.rs b/crates/engine/src/cmd/whatif.rs
index 1b9ed0f54..7b6f20c8d 100644
--- a/crates/engine/src/cmd/whatif.rs
+++ b/crates/engine/src/cmd/whatif.rs
@@ -16,6 +16,18 @@ use serde_json::{Value as Json, json};
 
 use super::*;
 
+mod advanced_filter;
+mod consolidate;
+mod scenarios;
+
+use advanced_filter::advanced_filter;
+#[cfg(test)]
+pub(crate) use advanced_filter::criterion_matches;
+use consolidate::consolidate;
+#[cfg(test)]
+pub(crate) use scenarios::{SCENARIO_NAME, load_scenarios};
+use scenarios::{scenario_add, scenario_delete, scenario_list, scenario_show, scenario_summary};
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -338,297 +350,6 @@ fn goal_seek(s: &mut Session, p: &Json) -> Result<Json> {
     Ok(json!({"value": r.x, "result": value_json(&result), "iterations": r.iterations, "converged": r.converged}))
 }
 
-// ---------------------------------------------------------------- scenarios
-
-/// Hidden workbook-scope name holding the scenarios as a quoted JSON string.
-pub(crate) const SCENARIO_NAME: &str = "_sc_scenarios";
-const MAX_SCENARIO_CELLS: usize = 32;
-const MAX_SCENARIOS: usize = 1000;
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub(crate) struct Scenario {
-    pub name: String,
-    pub sheet: String,
-    pub changing: String,
-    pub values: Vec<Json>,
-    #[serde(default)]
-    pub comment: String,
-}
-
-pub(crate) fn load_scenarios(wb: &Workbook) -> Vec<Scenario> {
-    let Some(n) = wb.names.iter().find(|n| n.scope.is_none() && n.name.eq_ignore_ascii_case(SCENARIO_NAME)) else { return vec![] };
-    serde_json::from_str(&string_literals(&n.formula)).unwrap_or_default()
-}
-
-/// Concatenates the string literals of a `"a"&"b""c"` formula.
-fn string_literals(f: &str) -> String {
-    let mut out = String::new();
-    let mut it = f.chars().peekable();
-    let mut in_str = false;
-    while let Some(c) = it.next() {
-        if !in_str {
-            if c == '"' {
-                in_str = true;
-            }
-            continue;
-        }
-        if c == '"' {
-            if it.peek() == Some(&'"') {
-                it.next();
-                out.push('"');
-            } else {
-                in_str = false;
-            }
-        } else {
-            out.push(c);
-        }
-    }
-    out
-}
-
-fn store_scenarios(wb: &mut Workbook, list: &[Scenario]) {
-    wb.names.retain(|n| !(n.scope.is_none() && n.name.eq_ignore_ascii_case(SCENARIO_NAME)));
-    if list.is_empty() {
-        return;
-    }
-    let text = serde_json::to_string(list).unwrap_or_else(|_| "[]".into());
-    wb.names.push(DefinedName {
-        name: SCENARIO_NAME.into(),
-        scope: None,
-        // Excel caps string literals at 255 characters: store `"…"&"…"` chunks.
-        formula: text
-            .chars()
-            .collect::<Vec<char>>()
-            .chunks(250)
-            .map(|c| format!("\"{}\"", c.iter().collect::<String>().replace('"', "\"\"")))
-            .collect::<Vec<_>>()
-            .join("&"),
-        comment: "GridCraft Scenario Manager data".into(),
-        hidden: true,
-    });
-}
-
-fn scenario_json(sc: &Scenario) -> Json {
-    json!({"name": sc.name, "sheet": sc.sheet, "changing": sc.changing, "values": sc.values, "comment": sc.comment})
-}
-
-fn scenario_list(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let sheet = str_param(p, "sheet").map(str::to_string).unwrap_or_else(|| d.wb.active().map(|s| s.name.clone()).unwrap_or_default());
-    let list: Vec<Json> =
-        load_scenarios(&d.wb).iter().filter(|sc| sheet == "*" || sc.sheet.eq_ignore_ascii_case(&sheet)).map(scenario_json).collect();
-    Ok(json!({"scenarios": list}))
-}
-
-fn scenario_add(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "data.scenarioAdd";
-    let name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad(CMD, "missing `name`"))?.to_string();
-    if name.chars().count() > 255 {
-        return Err(bad(CMD, "the name is too long (255 characters max)"));
-    }
-    let changing = str_param(p, "changing").ok_or_else(|| bad(CMD, "missing `changing`"))?.to_string();
-    let d = s.doc()?;
-    let (si, cells) = cell_list(&d.wb, &changing, CMD, MAX_SCENARIO_CELLS)?;
-    if cells.is_empty() {
-        return Err(bad(CMD, "no changing cells"));
-    }
-    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
-    let values: Vec<Json> = match p.get("values").and_then(Json::as_array) {
-        Some(a) => {
-            if a.len() != cells.len() {
-                return Err(bad(CMD, format!("{} values for {} changing cells", a.len(), cells.len())));
-            }
-            a.clone()
-        }
-        None => cells.iter().map(|c| value_json(&sh.value(*c))).collect(),
-    };
-    let changing = cells.iter().map(|c| c.a1()).collect::<Vec<_>>().join(",");
-    let sc = Scenario { name: name.clone(), sheet: sh.name.clone(), changing, values, comment: str_param(p, "comment").unwrap_or("").to_string() };
-    let replace = bool_param(p, "replace").unwrap_or(false);
-    let mut list = load_scenarios(&d.wb);
-    match list.iter().position(|x| x.name.eq_ignore_ascii_case(&name) && x.sheet.eq_ignore_ascii_case(&sc.sheet)) {
-        Some(i) if replace => {
-            if let Some(slot) = list.get_mut(i) {
-                *slot = sc.clone();
-            }
-        }
-        Some(_) => return Err(EngineError::Other(format!("A scenario named '{name}' already exists on this sheet."))),
-        None => {
-            if list.len() >= MAX_SCENARIOS {
-                return Err(bad(CMD, "too many scenarios"));
-            }
-            list.push(sc.clone());
-        }
-    }
-    edit(s, |cx| {
-        store_scenarios(&mut cx.wb, &list);
-        Ok(())
-    })?;
-    Ok(scenario_json(&sc))
-}
-
-fn find_scenario(wb: &Workbook, p: &Json, cmd: &str) -> Result<(Vec<Scenario>, usize)> {
-    let name = str_param(p, "name").ok_or_else(|| bad(cmd, "missing `name`"))?;
-    let list = load_scenarios(wb);
-    let active = wb.active().map(|s| s.name.clone()).unwrap_or_default();
-    let i = list
-        .iter()
-        .position(|x| x.name.eq_ignore_ascii_case(name) && x.sheet.eq_ignore_ascii_case(&active))
-        .or_else(|| list.iter().position(|x| x.name.eq_ignore_ascii_case(name)))
-        .ok_or_else(|| bad(cmd, format!("no scenario named `{name}`")))?;
-    Ok((list, i))
-}
-
-fn scenario_show(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "data.scenarioShow";
-    let d = s.doc()?;
-    let (list, i) = find_scenario(&d.wb, p, CMD)?;
-    let sc = list.get(i).cloned().ok_or_else(|| bad(CMD, "no such scenario"))?;
-    let si = d.wb.sheet_index(&sc.sheet).ok_or_else(|| bad(CMD, format!("the scenario's sheet `{}` no longer exists", sc.sheet)))?;
-    let (_, cells) = cell_list(&d.wb, &sc.changing, CMD, MAX_SCENARIO_CELLS)?;
-    edit(s, |cx| {
-        for (c, v) in cells.iter().zip(sc.values.iter()) {
-            // Stored numbers are values, not typed text: entering them through the parser would
-            // apply percent entry (9 -> 9%) to a Percentage-formatted cell.
-            let cell = match v.as_f64() {
-                Some(n) => {
-                    let style = cx.wb.sheet(si).map(|sh| sh.style_id(*c)).unwrap_or_default();
-                    Some(Cell { value: Value::Number(n), formula: None, style })
-                }
-                None => super::edit::input_to_cell(&super::edit::json_to_input(v), si, *c, &mut cx.wb)?,
-            };
-            let sh = cx.sheet_mut(si)?;
-            match cell {
-                Some(cell) => sh.set_cell(*c, cell),
-                None => {
-                    sh.remove_cell(*c);
-                }
-            }
-            cx.touch(si, *c);
-        }
-        Ok(())
-    })?;
-    Ok(scenario_json(&sc))
-}
-
-fn scenario_delete(s: &mut Session, p: &Json) -> Result<Json> {
-    let d = s.doc()?;
-    let (mut list, i) = find_scenario(&d.wb, p, "data.scenarioDelete")?;
-    let removed = list.remove(i);
-    edit(s, |cx| {
-        store_scenarios(&mut cx.wb, &list);
-        Ok(())
-    })?;
-    Ok(json!({"deleted": removed.name}))
-}
-
-fn scenario_summary(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "data.scenarioSummary";
-    let d = s.doc()?;
-    let si = d.wb.active_sheet();
-    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
-    let scenarios: Vec<Scenario> = load_scenarios(&d.wb).into_iter().filter(|x| x.sheet.eq_ignore_ascii_case(&sh.name)).collect();
-    if scenarios.is_empty() {
-        return Err(EngineError::Other("There are no scenarios on this sheet.".into()));
-    }
-    let results: Vec<CellRef> = match str_param(p, "resultCells").map(str::trim).filter(|t| !t.is_empty()) {
-        Some(t) => {
-            let (rsi, cells) = cell_list(&d.wb, t, CMD, 255)?;
-            if rsi != si {
-                return Err(bad(CMD, "result cells must be on the scenarios' sheet"));
-            }
-            cells
-        }
-        None => vec![],
-    };
-    // Changing cells of every scenario, first-seen order; per scenario its values.
-    let mut changing: Vec<CellRef> = Vec::new();
-    let mut per: Vec<HashMap<CellRef, Value>> = Vec::new();
-    for sc in &scenarios {
-        let (_, cells) = cell_list(&d.wb, &sc.changing, CMD, MAX_SCENARIO_CELLS)?;
-        let mut m = HashMap::new();
-        for (c, v) in cells.iter().zip(sc.values.iter()) {
-            if !changing.contains(c) {
-                changing.push(*c);
-            }
-            m.insert(*c, json_value(v, &d.wb));
-        }
-        per.push(m);
-    }
-    let current: Vec<Value> = changing.iter().map(|c| sh.value(*c)).collect();
-    let current_results: Vec<Value> = results.iter().map(|c| sh.value(*c)).collect();
-    let mut trial = Trial::new(d);
-    let reads: Vec<(usize, CellRef)> = results.iter().map(|c| (si, *c)).collect();
-    let scenario_results: Vec<Vec<Value>> = per
-        .iter()
-        .map(|m| {
-            let sets: Vec<(usize, CellRef, Value)> = m.iter().map(|(c, v)| (si, *c, v.clone())).collect();
-            trial.run(&sets, &reads)
-        })
-        .collect();
-    let fmt_of = |c: CellRef| d.wb.styles.get(sh.style_id(c)).num_fmt.clone();
-    let changing_fmts: Vec<_> = changing.iter().map(|c| fmt_of(*c)).collect();
-    let result_fmts: Vec<_> = results.iter().map(|c| fmt_of(*c)).collect();
-    let name = (1..)
-        .map(|n| if n == 1 { "Scenario Summary".to_string() } else { format!("Scenario Summary {n}") })
-        .find(|n| d.wb.sheet_index(n).is_none())
-        .unwrap_or_else(|| "Scenario Summary".into());
-    let names: Vec<String> = scenarios.iter().map(|x| x.name.clone()).collect();
-    let new_index = edit(s, |cx| {
-        let bold = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.font.bold = true);
-        let mut sheet = Sheet::new(name.clone());
-        let put = |sheet: &mut Sheet, row: u32, col: u32, v: Value, style: StyleId| {
-            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style });
-        };
-        put(&mut sheet, 1, 1, Value::text("Scenario Summary"), bold);
-        put(&mut sheet, 2, 2, Value::text("Current Values:"), bold);
-        for (k, n) in names.iter().enumerate() {
-            put(&mut sheet, 2, 3 + k as u32, Value::text(n.as_str()), bold);
-        }
-        put(&mut sheet, 3, 1, Value::text("Changing Cells:"), bold);
-        let mut row = 4u32;
-        for (i, c) in changing.iter().enumerate() {
-            let fmt = changing_fmts.get(i).cloned().unwrap_or_default();
-            let st = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.num_fmt = fmt);
-            put(&mut sheet, row, 1, Value::text(format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1)), StyleId::DEFAULT);
-            let cur = current.get(i).cloned().unwrap_or_default();
-            put(&mut sheet, row, 2, cur.clone(), st);
-            for (k, m) in per.iter().enumerate() {
-                put(&mut sheet, row, 3 + k as u32, m.get(c).cloned().unwrap_or_else(|| cur.clone()), st);
-            }
-            row += 1;
-        }
-        if !results.is_empty() {
-            put(&mut sheet, row, 1, Value::text("Result Cells:"), bold);
-            row += 1;
-            for (i, c) in results.iter().enumerate() {
-                let fmt = result_fmts.get(i).cloned().unwrap_or_default();
-                let st = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.num_fmt = fmt);
-                put(&mut sheet, row, 1, Value::text(format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1)), StyleId::DEFAULT);
-                put(&mut sheet, row, 2, current_results.get(i).cloned().unwrap_or_default(), st);
-                for (k, r) in scenario_results.iter().enumerate() {
-                    put(&mut sheet, row, 3 + k as u32, r.get(i).cloned().unwrap_or_default(), st);
-                }
-                row += 1;
-            }
-        }
-        put(
-            &mut sheet,
-            row + 1,
-            1,
-            Value::text("Notes: Current Values column represents values of changing cells at time Scenario Summary Report was created."),
-            StyleId::DEFAULT,
-        );
-        sheet.cols.insert(1, gridcraft_model::LineInfo { size: Some(110.0), ..Default::default() });
-        sheet.cols.insert(2, gridcraft_model::LineInfo { size: Some(100.0), ..Default::default() });
-        cx.wb.sheets.push(std::sync::Arc::new(sheet));
-        cx.structural = true;
-        Ok(cx.wb.sheets.len() - 1)
-    })?;
-    s.doc_mut()?.wb_switch_sheet(new_index);
-    Ok(json!({"sheet": name, "scenarios": names.len(), "changingCells": changing.len(), "resultCells": results.len()}))
-}
-
 // ---------------------------------------------------------------- data tables
 
 const MAX_TABLE_CELLS: u64 = 100_000;
@@ -709,427 +430,5 @@ fn data_table(s: &mut Session, p: &Json) -> Result<Json> {
     Ok(json!({"range": body.a1(), "cells": n, "mode": mode, "static": true}))
 }
 
-// ---------------------------------------------------------------- advanced filter
-
-#[derive(Clone, Debug)]
-enum Cond {
-    /// Column offset in the list, comparison operator and operand text.
-    Compare(u32, Value),
-    /// A computed criterion: formula relative to the first data row, evaluated at `at`.
-    Computed(gridcraft_formula::Expr, CellRef),
-}
-
-/// Splits `">=10"` into (`">="`, `"10"`); text without an operator means "begins with".
-fn split_op(t: &str) -> (&str, &str) {
-    for op in ["<>", ">=", "<=", "=", ">", "<"] {
-        if let Some(rest) = t.strip_prefix(op) {
-            return (op, rest);
-        }
-    }
-    ("begins", t)
-}
-
-/// Does a list value match one criteria cell's value (Excel's advanced-filter semantics)?
-pub(crate) fn criterion_matches(v: &Value, text: &str, crit: &Value) -> bool {
-    let crit_text = match crit {
-        Value::Empty => return true,
-        Value::Number(n) => return v.as_f64().is_some_and(|x| (x - n).abs() <= 1e-12 * n.abs().max(1.0)),
-        Value::Bool(b) => return matches!(v, Value::Bool(x) if x == b),
-        Value::Error(e) => return v.as_error() == Some(*e),
-        Value::Text(t) => t.to_string(),
-        Value::Array(_) => return false,
-    };
-    let (op, operand) = split_op(&crit_text);
-    if operand.is_empty() {
-        return match op {
-            "=" => v.is_empty() || text.is_empty(),
-            "<>" => !(v.is_empty() || text.is_empty()),
-            _ => true,
-        };
-    }
-    let num = gridcraft_core::parse::parse_number_text(operand);
-    let lower_text = text.to_lowercase();
-    let lower_op = operand.to_lowercase();
-    use std::cmp::Ordering;
-    let cmp: Option<Ordering> = match (v, num) {
-        (Value::Number(a), Some(b)) => a.partial_cmp(&b),
-        (Value::Number(_), None) => None,
-        (Value::Empty, _) => None,
-        (_, Some(_)) if op != "begins" => None,
-        _ => Some(gridcraft_core::compare_text(text, operand)),
-    };
-    let wild = |pat: &str| super::edit::wildcard(&lower_text, pat);
-    match op {
-        "=" => {
-            if num.is_none() && operand.contains(['*', '?']) {
-                wild(&lower_op)
-            } else if num.is_none() {
-                lower_text == lower_op
-            } else {
-                cmp == Some(Ordering::Equal)
-            }
-        }
-        "<>" => {
-            if num.is_none() && operand.contains(['*', '?']) {
-                !wild(&lower_op)
-            } else if num.is_none() {
-                lower_text != lower_op
-            } else {
-                cmp != Some(Ordering::Equal)
-            }
-        }
-        ">" => cmp == Some(Ordering::Greater),
-        "<" => cmp == Some(Ordering::Less),
-        ">=" => matches!(cmp, Some(Ordering::Greater | Ordering::Equal)),
-        "<=" => matches!(cmp, Some(Ordering::Less | Ordering::Equal)),
-        _ => {
-            // Plain text criterion: begins with (wildcards allowed); a plain number equals.
-            match (v, num) {
-                (Value::Number(a), Some(b)) => (a - b).abs() <= 1e-12 * b.abs().max(1.0),
-                _ => !v.is_empty() && wild(&format!("{lower_op}*")),
-            }
-        }
-    }
-}
-
-fn advanced_filter(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "data.advancedFilter";
-    let d = s.doc()?;
-    let (si, list) = match str_param(p, "range") {
-        Some(t) => parse_range(&d.wb, t, CMD)?,
-        None => {
-            let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
-            (d.wb.active_sheet(), crate::selection::current_region(sh, d.selection.active))
-        }
-    };
-    let criteria = str_param(p, "criteria").filter(|t| !t.trim().is_empty()).map(|t| parse_range(&d.wb, t, CMD)).transpose()?;
-    if list.height() < 1 || list.count() > 50_000_000 {
-        return Err(bad(CMD, "the list range is too large"));
-    }
-    if let Some((_, crit)) = criteria
-        && (crit.width() > 1024 || crit.height() > 10_000)
-    {
-        return Err(bad(CMD, "the criteria range is too large"));
-    }
-    let wb = &d.wb;
-    let sh = wb.sheet(si).ok_or(EngineError::NoDocument)?;
-    let headers: Vec<String> =
-        (list.start.col..=list.end.col).map(|c| crate::display::cell_text(wb, sh, CellRef::new(list.start.row, c)).trim().to_lowercase()).collect();
-    let first_data = list.start.row + 1;
-    // Criteria rows → conditions.
-    let mut rows: Vec<Vec<Cond>> = Vec::new();
-    if let Some((csi, crit)) = criteria {
-        let csh = wb.sheet(csi).ok_or(EngineError::NoDocument)?;
-        for cr in crit.start.row + 1..=crit.end.row {
-            let mut conds = Vec::new();
-            for cc in crit.start.col..=crit.end.col {
-                let at = CellRef::new(cr, cc);
-                let cell = csh.cell(at);
-                let v = csh.value(at);
-                let formula = cell.and_then(|c| c.formula.as_ref());
-                if v.is_empty() && formula.is_none() {
-                    continue;
-                }
-                let head = crate::display::cell_text(wb, csh, CellRef::new(crit.start.row, cc)).trim().to_lowercase();
-                match headers.iter().position(|h| !head.is_empty() && *h == head) {
-                    Some(off) => conds.push(Cond::Compare(off as u32, v)),
-                    None => match formula.and_then(|f| f.expr()) {
-                        Some(e) => conds.push(Cond::Computed(e, at)),
-                        None => return Err(EngineError::Other(format!("The criteria label `{head}` doesn't match a column of the list."))),
-                    },
-                }
-            }
-            rows.push(conds);
-        }
-    }
-    let matches_row = |row: u32| -> bool {
-        if rows.is_empty() {
-            return true;
-        }
-        rows.iter().any(|conds| {
-            conds.iter().all(|c| match c {
-                Cond::Compare(off, crit) => {
-                    let at = CellRef::new(row, list.start.col + off);
-                    let v = sh.value(at);
-                    let text = crate::display::cell_text(wb, sh, at);
-                    criterion_matches(&v, &text, crit)
-                }
-                Cond::Computed(e, at) => {
-                    let shifted = gridcraft_formula::adjust::shift_relative(e.clone(), row as i64 - first_data as i64, 0);
-                    let v = gridcraft_calc::recalc::evaluate_expr(wb, criteria.map(|(si, _)| si).unwrap_or(si), *at, &shifted);
-                    matches!(v.scalar().to_bool(), Ok(true))
-                }
-            })
-        })
-    };
-    let unique = bool_param(p, "unique").unwrap_or(false);
-    let mut seen: HashSet<Vec<String>> = HashSet::new();
-    let mut keep: Vec<(u32, bool)> = Vec::new();
-    for row in first_data..=list.end.row {
-        let mut ok = matches_row(row);
-        if ok && unique {
-            let key: Vec<String> =
-                (list.start.col..=list.end.col).map(|c| crate::display::cell_text(wb, sh, CellRef::new(row, c)).to_lowercase()).collect();
-            ok = seen.insert(key);
-        }
-        keep.push((row, ok));
-    }
-    let matched = keep.iter().filter(|(_, k)| *k).count();
-    if let Some(t) = str_param(p, "copyTo") {
-        let (dsi, dest) = parse_range(wb, t, CMD)?;
-        let dest = dest.start;
-        let mut rows_out: Vec<u32> = vec![list.start.row];
-        rows_out.extend(keep.iter().filter(|(_, k)| *k).map(|(r, _)| *r));
-        let end =
-            dest.offset(rows_out.len() as i64 - 1, list.width() as i64 - 1).ok_or_else(|| bad(CMD, "the extract range exceeds the worksheet"))?;
-        let out_range = RangeRef::new(dest, end);
-        if dsi == si && out_range.intersects(&list) {
-            return Err(EngineError::Other("The extract range can't overlap the list range.".into()));
-        }
-        let cells: Vec<(CellRef, Cell)> = rows_out
-            .iter()
-            .enumerate()
-            .flat_map(|(i, row)| {
-                (list.start.col..=list.end.col).map(move |c| {
-                    let src = CellRef::new(*row, c);
-                    // The full output footprint was checked above.
-                    let to = CellRef::new(dest.row + i as u32, dest.col + c - list.start.col);
-                    let style = sh.style_id(src);
-                    (to, Cell { value: sh.value(src), formula: None, style })
-                })
-            })
-            .collect();
-        edit(s, |cx| {
-            let shm = cx.sheet_mut(dsi)?;
-            let old: Vec<CellRef> = shm.cells.iter_range(out_range).map(|(c, _)| c).collect();
-            for c in &old {
-                shm.remove_cell(*c);
-            }
-            for (c, cell) in cells {
-                shm.set_cell(c, cell);
-            }
-            for c in old {
-                cx.touch(dsi, c);
-            }
-            for c in out_range.iter() {
-                cx.touch(dsi, c);
-            }
-            Ok(())
-        })?;
-        return Ok(json!({"matched": matched, "range": out_range.a1()}));
-    }
-    let hidden = keep.iter().filter(|(_, k)| !*k).count();
-    edit(s, |cx| {
-        let shm = cx.sheet_mut(si)?;
-        for (row, k) in &keep {
-            if *k {
-                if let Some(e) = shm.rows.get_mut(row) {
-                    e.hidden = false;
-                    if *e == gridcraft_model::LineInfo::default() {
-                        shm.rows.remove(row);
-                    }
-                }
-            } else {
-                shm.rows.entry(*row).or_default().hidden = true;
-            }
-        }
-        cx.structural = true;
-        Ok(())
-    })?;
-    Ok(json!({"matched": matched, "hiddenRows": hidden}))
-}
-
-// ---------------------------------------------------------------- consolidate
-
-#[derive(Clone, Copy, Debug, Default)]
-struct Agg {
-    count: u64,
-    nums: u64,
-    sum: f64,
-    product: f64,
-    min: f64,
-    max: f64,
-}
-
-impl Agg {
-    fn add(&mut self, v: &Value) {
-        if v.is_empty() {
-            return;
-        }
-        self.count += 1;
-        if let Value::Number(n) = v {
-            if self.nums == 0 {
-                self.min = *n;
-                self.max = *n;
-                self.product = 1.0;
-            }
-            self.nums += 1;
-            self.sum += n;
-            self.product *= n;
-            self.min = self.min.min(*n);
-            self.max = self.max.max(*n);
-        }
-    }
-    fn result(&self, func: &str) -> Value {
-        match func {
-            "count" => Value::number(self.count as f64),
-            "countNums" | "countnums" => Value::number(self.nums as f64),
-            "average" => {
-                if self.nums == 0 {
-                    Value::Error(gridcraft_core::CellError::Div0)
-                } else {
-                    Value::number(self.sum / self.nums as f64)
-                }
-            }
-            "max" => Value::number(if self.nums == 0 { 0.0 } else { self.max }),
-            "min" => Value::number(if self.nums == 0 { 0.0 } else { self.min }),
-            "product" => Value::number(if self.nums == 0 { 0.0 } else { self.product }),
-            _ => Value::number(self.sum),
-        }
-    }
-}
-
-/// A row/column key: a position or a label (matched case-insensitively).
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-enum Key {
-    Pos(u32),
-    Label(String),
-}
-
-const MAX_CONSOLIDATE_CELLS: u64 = 5_000_000;
-
-fn consolidate(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "data.consolidate";
-    let func = str_param(p, "function").unwrap_or("sum").to_string();
-    if !["sum", "count", "countNums", "countnums", "average", "max", "min", "product"].contains(&func.as_str()) {
-        return Err(bad(CMD, format!("unknown function `{func}`")));
-    }
-    let top = bool_param(p, "topRow").unwrap_or(false);
-    let left = bool_param(p, "leftColumn").unwrap_or(false);
-    let d = s.doc()?;
-    let srcs: Vec<String> = p
-        .get("sources")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect())
-        .or_else(|| str_param(p, "sources").map(|t| t.split(';').map(str::to_string).collect()))
-        .unwrap_or_default();
-    if srcs.is_empty() {
-        return Err(bad(CMD, "give at least one source range in `sources`"));
-    }
-    if srcs.len() > 255 {
-        return Err(bad(CMD, "too many sources (255 max)"));
-    }
-    let (dsi, dest) = match str_param(p, "destination") {
-        Some(t) => {
-            let (si, r) = parse_range(&d.wb, t, CMD)?;
-            (si, r.start)
-        }
-        None => (d.wb.active_sheet(), d.selection.active),
-    };
-    let mut row_keys: Vec<Key> = Vec::new();
-    let mut col_keys: Vec<Key> = Vec::new();
-    let mut row_label: HashMap<Key, String> = HashMap::new();
-    let mut col_label: HashMap<Key, String> = HashMap::new();
-    let mut aggs: HashMap<(usize, usize), Agg> = HashMap::new();
-    let mut total: u64 = 0;
-    let index_of = |keys: &mut Vec<Key>, k: Key| -> usize {
-        match keys.iter().position(|x| *x == k) {
-            Some(i) => i,
-            None => {
-                keys.push(k);
-                keys.len() - 1
-            }
-        }
-    };
-    for t in &srcs {
-        let (si, r) = parse_range(&d.wb, t, CMD)?;
-        total = total.saturating_add(r.count());
-        if total > MAX_CONSOLIDATE_CELLS {
-            return Err(bad(CMD, "the sources are too large"));
-        }
-        let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
-        let r0 = r.start.row + top as u32;
-        let c0 = r.start.col + left as u32;
-        if r0 > r.end.row || c0 > r.end.col {
-            continue;
-        }
-        let label = |c: CellRef| crate::display::cell_text(&d.wb, sh, c).trim().to_string();
-        // Column keys of this source.
-        let mut cols: Vec<(u32, usize)> = Vec::new();
-        for col in c0..=r.end.col {
-            let k = if top {
-                let l = label(CellRef::new(r.start.row, col));
-                if l.is_empty() {
-                    continue;
-                }
-                let k = Key::Label(l.to_lowercase());
-                col_label.entry(k.clone()).or_insert(l);
-                k
-            } else {
-                Key::Pos(col - c0)
-            };
-            cols.push((col, index_of(&mut col_keys, k)));
-        }
-        for row in r0..=r.end.row {
-            let k = if left {
-                let l = label(CellRef::new(row, r.start.col));
-                if l.is_empty() {
-                    continue;
-                }
-                let k = Key::Label(l.to_lowercase());
-                row_label.entry(k.clone()).or_insert(l);
-                k
-            } else {
-                Key::Pos(row - r0)
-            };
-            let ri = index_of(&mut row_keys, k);
-            for (col, ci) in &cols {
-                aggs.entry((ri, *ci)).or_default().add(&sh.value(CellRef::new(row, *col)));
-            }
-        }
-    }
-    let (out_r0, out_c0) = (dest.row + top as u32, dest.col + left as u32);
-    if out_r0 as u64 + row_keys.len() as u64 > gridcraft_core::MAX_ROWS as u64
-        || out_c0 as u64 + col_keys.len() as u64 > gridcraft_core::MAX_COLS as u64
-    {
-        return Err(EngineError::Other("The consolidated data doesn't fit below and right of the destination.".into()));
-    }
-    let mut cells: Vec<(CellRef, Value)> = Vec::new();
-    if top {
-        for (ci, k) in col_keys.iter().enumerate() {
-            cells.push((CellRef::new(dest.row, out_c0 + ci as u32), Value::text(col_label.get(k).cloned().unwrap_or_default())));
-        }
-    }
-    if left {
-        for (ri, k) in row_keys.iter().enumerate() {
-            cells.push((CellRef::new(out_r0 + ri as u32, dest.col), Value::text(row_label.get(k).cloned().unwrap_or_default())));
-        }
-    }
-    for ri in 0..row_keys.len() {
-        for ci in 0..col_keys.len() {
-            let v = aggs.get(&(ri, ci)).map(|a| if a.count == 0 { Value::Empty } else { a.result(&func) }).unwrap_or_default();
-            cells.push((CellRef::new(out_r0 + ri as u32, out_c0 + ci as u32), v));
-        }
-    }
-    let end = CellRef::new(
-        (out_r0 + row_keys.len() as u32).saturating_sub(1).max(dest.row),
-        (out_c0 + col_keys.len() as u32).saturating_sub(1).max(dest.col),
-    );
-    edit(s, |cx| {
-        for (c, v) in cells {
-            let sh = cx.sheet_mut(dsi)?;
-            let style = sh.style_id(c);
-            if v.is_empty() && style == StyleId::DEFAULT {
-                sh.remove_cell(c);
-            } else {
-                sh.set_cell(c, Cell { value: v, formula: None, style });
-            }
-            cx.touch(dsi, c);
-        }
-        Ok(())
-    })?;
-    Ok(json!({"range": RangeRef::new(dest, end).a1(), "rows": row_keys.len(), "columns": col_keys.len()}))
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/crates/engine/src/cmd/whatif/advanced_filter.rs b/crates/engine/src/cmd/whatif/advanced_filter.rs
new file mode 100644
index 000000000..53e55820c
--- /dev/null
+++ b/crates/engine/src/cmd/whatif/advanced_filter.rs
@@ -0,0 +1,231 @@
+use super::*;
+
+// ---------------------------------------------------------------- advanced filter
+
+#[derive(Clone, Debug)]
+enum Cond {
+    /// Column offset in the list, comparison operator and operand text.
+    Compare(u32, Value),
+    /// A computed criterion: formula relative to the first data row, evaluated at `at`.
+    Computed(gridcraft_formula::Expr, CellRef),
+}
+
+/// Splits `">=10"` into (`">="`, `"10"`); text without an operator means "begins with".
+fn split_op(t: &str) -> (&str, &str) {
+    for op in ["<>", ">=", "<=", "=", ">", "<"] {
+        if let Some(rest) = t.strip_prefix(op) {
+            return (op, rest);
+        }
+    }
+    ("begins", t)
+}
+
+/// Does a list value match one criteria cell's value (Excel's advanced-filter semantics)?
+pub(crate) fn criterion_matches(v: &Value, text: &str, crit: &Value) -> bool {
+    let crit_text = match crit {
+        Value::Empty => return true,
+        Value::Number(n) => return v.as_f64().is_some_and(|x| (x - n).abs() <= 1e-12 * n.abs().max(1.0)),
+        Value::Bool(b) => return matches!(v, Value::Bool(x) if x == b),
+        Value::Error(e) => return v.as_error() == Some(*e),
+        Value::Text(t) => t.to_string(),
+        Value::Array(_) => return false,
+    };
+    let (op, operand) = split_op(&crit_text);
+    if operand.is_empty() {
+        return match op {
+            "=" => v.is_empty() || text.is_empty(),
+            "<>" => !(v.is_empty() || text.is_empty()),
+            _ => true,
+        };
+    }
+    let num = gridcraft_core::parse::parse_number_text(operand);
+    let lower_text = text.to_lowercase();
+    let lower_op = operand.to_lowercase();
+    use std::cmp::Ordering;
+    let cmp: Option<Ordering> = match (v, num) {
+        (Value::Number(a), Some(b)) => a.partial_cmp(&b),
+        (Value::Number(_), None) => None,
+        (Value::Empty, _) => None,
+        (_, Some(_)) if op != "begins" => None,
+        _ => Some(gridcraft_core::compare_text(text, operand)),
+    };
+    let wild = |pat: &str| crate::cmd::edit::wildcard(&lower_text, pat);
+    match op {
+        "=" => {
+            if num.is_none() && operand.contains(['*', '?']) {
+                wild(&lower_op)
+            } else if num.is_none() {
+                lower_text == lower_op
+            } else {
+                cmp == Some(Ordering::Equal)
+            }
+        }
+        "<>" => {
+            if num.is_none() && operand.contains(['*', '?']) {
+                !wild(&lower_op)
+            } else if num.is_none() {
+                lower_text != lower_op
+            } else {
+                cmp != Some(Ordering::Equal)
+            }
+        }
+        ">" => cmp == Some(Ordering::Greater),
+        "<" => cmp == Some(Ordering::Less),
+        ">=" => matches!(cmp, Some(Ordering::Greater | Ordering::Equal)),
+        "<=" => matches!(cmp, Some(Ordering::Less | Ordering::Equal)),
+        _ => {
+            // Plain text criterion: begins with (wildcards allowed); a plain number equals.
+            match (v, num) {
+                (Value::Number(a), Some(b)) => (a - b).abs() <= 1e-12 * b.abs().max(1.0),
+                _ => !v.is_empty() && wild(&format!("{lower_op}*")),
+            }
+        }
+    }
+}
+
+pub(super) fn advanced_filter(s: &mut Session, p: &Json) -> Result<Json> {
+    const CMD: &str = "data.advancedFilter";
+    let d = s.doc()?;
+    let (si, list) = match str_param(p, "range") {
+        Some(t) => parse_range(&d.wb, t, CMD)?,
+        None => {
+            let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
+            (d.wb.active_sheet(), crate::selection::current_region(sh, d.selection.active))
+        }
+    };
+    let criteria = str_param(p, "criteria").filter(|t| !t.trim().is_empty()).map(|t| parse_range(&d.wb, t, CMD)).transpose()?;
+    if list.height() < 1 || list.count() > 50_000_000 {
+        return Err(bad(CMD, "the list range is too large"));
+    }
+    if let Some((_, crit)) = criteria
+        && (crit.width() > 1024 || crit.height() > 10_000)
+    {
+        return Err(bad(CMD, "the criteria range is too large"));
+    }
+    let wb = &d.wb;
+    let sh = wb.sheet(si).ok_or(EngineError::NoDocument)?;
+    let headers: Vec<String> =
+        (list.start.col..=list.end.col).map(|c| crate::display::cell_text(wb, sh, CellRef::new(list.start.row, c)).trim().to_lowercase()).collect();
+    let first_data = list.start.row + 1;
+    // Criteria rows → conditions.
+    let mut rows: Vec<Vec<Cond>> = Vec::new();
+    if let Some((csi, crit)) = criteria {
+        let csh = wb.sheet(csi).ok_or(EngineError::NoDocument)?;
+        for cr in crit.start.row + 1..=crit.end.row {
+            let mut conds = Vec::new();
+            for cc in crit.start.col..=crit.end.col {
+                let at = CellRef::new(cr, cc);
+                let cell = csh.cell(at);
+                let v = csh.value(at);
+                let formula = cell.and_then(|c| c.formula.as_ref());
+                if v.is_empty() && formula.is_none() {
+                    continue;
+                }
+                let head = crate::display::cell_text(wb, csh, CellRef::new(crit.start.row, cc)).trim().to_lowercase();
+                match headers.iter().position(|h| !head.is_empty() && *h == head) {
+                    Some(off) => conds.push(Cond::Compare(off as u32, v)),
+                    None => match formula.and_then(|f| f.expr()) {
+                        Some(e) => conds.push(Cond::Computed(e, at)),
+                        None => return Err(EngineError::Other(format!("The criteria label `{head}` doesn't match a column of the list."))),
+                    },
+                }
+            }
+            rows.push(conds);
+        }
+    }
+    let matches_row = |row: u32| -> bool {
+        if rows.is_empty() {
+            return true;
+        }
+        rows.iter().any(|conds| {
+            conds.iter().all(|c| match c {
+                Cond::Compare(off, crit) => {
+                    let at = CellRef::new(row, list.start.col + off);
+                    let v = sh.value(at);
+                    let text = crate::display::cell_text(wb, sh, at);
+                    criterion_matches(&v, &text, crit)
+                }
+                Cond::Computed(e, at) => {
+                    let shifted = gridcraft_formula::adjust::shift_relative(e.clone(), row as i64 - first_data as i64, 0);
+                    let v = gridcraft_calc::recalc::evaluate_expr(wb, criteria.map(|(si, _)| si).unwrap_or(si), *at, &shifted);
+                    matches!(v.scalar().to_bool(), Ok(true))
+                }
+            })
+        })
+    };
+    let unique = bool_param(p, "unique").unwrap_or(false);
+    let mut seen: HashSet<Vec<String>> = HashSet::new();
+    let mut keep: Vec<(u32, bool)> = Vec::new();
+    for row in first_data..=list.end.row {
+        let mut ok = matches_row(row);
+        if ok && unique {
+            let key: Vec<String> =
+                (list.start.col..=list.end.col).map(|c| crate::display::cell_text(wb, sh, CellRef::new(row, c)).to_lowercase()).collect();
+            ok = seen.insert(key);
+        }
+        keep.push((row, ok));
+    }
+    let matched = keep.iter().filter(|(_, k)| *k).count();
+    if let Some(t) = str_param(p, "copyTo") {
+        let (dsi, dest) = parse_range(wb, t, CMD)?;
+        let dest = dest.start;
+        let mut rows_out: Vec<u32> = vec![list.start.row];
+        rows_out.extend(keep.iter().filter(|(_, k)| *k).map(|(r, _)| *r));
+        let end =
+            dest.offset(rows_out.len() as i64 - 1, list.width() as i64 - 1).ok_or_else(|| bad(CMD, "the extract range exceeds the worksheet"))?;
+        let out_range = RangeRef::new(dest, end);
+        if dsi == si && out_range.intersects(&list) {
+            return Err(EngineError::Other("The extract range can't overlap the list range.".into()));
+        }
+        let cells: Vec<(CellRef, Cell)> = rows_out
+            .iter()
+            .enumerate()
+            .flat_map(|(i, row)| {
+                (list.start.col..=list.end.col).map(move |c| {
+                    let src = CellRef::new(*row, c);
+                    // The full output footprint was checked above.
+                    let to = CellRef::new(dest.row + i as u32, dest.col + c - list.start.col);
+                    let style = sh.style_id(src);
+                    (to, Cell { value: sh.value(src), formula: None, style })
+                })
+            })
+            .collect();
+        edit(s, |cx| {
+            let shm = cx.sheet_mut(dsi)?;
+            let old: Vec<CellRef> = shm.cells.iter_range(out_range).map(|(c, _)| c).collect();
+            for c in &old {
+                shm.remove_cell(*c);
+            }
+            for (c, cell) in cells {
+                shm.set_cell(c, cell);
+            }
+            for c in old {
+                cx.touch(dsi, c);
+            }
+            for c in out_range.iter() {
+                cx.touch(dsi, c);
+            }
+            Ok(())
+        })?;
+        return Ok(json!({"matched": matched, "range": out_range.a1()}));
+    }
+    let hidden = keep.iter().filter(|(_, k)| !*k).count();
+    edit(s, |cx| {
+        let shm = cx.sheet_mut(si)?;
+        for (row, k) in &keep {
+            if *k {
+                if let Some(e) = shm.rows.get_mut(row) {
+                    e.hidden = false;
+                    if *e == gridcraft_model::LineInfo::default() {
+                        shm.rows.remove(row);
+                    }
+                }
+            } else {
+                shm.rows.entry(*row).or_default().hidden = true;
+            }
+        }
+        cx.structural = true;
+        Ok(())
+    })?;
+    Ok(json!({"matched": matched, "hiddenRows": hidden}))
+}
diff --git a/crates/engine/src/cmd/whatif/consolidate.rs b/crates/engine/src/cmd/whatif/consolidate.rs
new file mode 100644
index 000000000..1962f64e5
--- /dev/null
+++ b/crates/engine/src/cmd/whatif/consolidate.rs
@@ -0,0 +1,193 @@
+use super::*;
+
+// ---------------------------------------------------------------- consolidate
+
+#[derive(Clone, Copy, Debug, Default)]
+struct Agg {
+    count: u64,
+    nums: u64,
+    sum: f64,
+    product: f64,
+    min: f64,
+    max: f64,
+}
+
+impl Agg {
+    fn add(&mut self, v: &Value) {
+        if v.is_empty() {
+            return;
+        }
+        self.count += 1;
+        if let Value::Number(n) = v {
+            if self.nums == 0 {
+                self.min = *n;
+                self.max = *n;
+                self.product = 1.0;
+            }
+            self.nums += 1;
+            self.sum += n;
+            self.product *= n;
+            self.min = self.min.min(*n);
+            self.max = self.max.max(*n);
+        }
+    }
+    fn result(&self, func: &str) -> Value {
+        match func {
+            "count" => Value::number(self.count as f64),
+            "countNums" | "countnums" => Value::number(self.nums as f64),
+            "average" => {
+                if self.nums == 0 {
+                    Value::Error(gridcraft_core::CellError::Div0)
+                } else {
+                    Value::number(self.sum / self.nums as f64)
+                }
+            }
+            "max" => Value::number(if self.nums == 0 { 0.0 } else { self.max }),
+            "min" => Value::number(if self.nums == 0 { 0.0 } else { self.min }),
+            "product" => Value::number(if self.nums == 0 { 0.0 } else { self.product }),
+            _ => Value::number(self.sum),
+        }
+    }
+}
+
+/// A row/column key: a position or a label (matched case-insensitively).
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+enum Key {
+    Pos(u32),
+    Label(String),
+}
+
+const MAX_CONSOLIDATE_CELLS: u64 = 5_000_000;
+
+pub(super) fn consolidate(s: &mut Session, p: &Json) -> Result<Json> {
+    const CMD: &str = "data.consolidate";
+    let func = str_param(p, "function").unwrap_or("sum").to_string();
+    if !["sum", "count", "countNums", "countnums", "average", "max", "min", "product"].contains(&func.as_str()) {
+        return Err(bad(CMD, format!("unknown function `{func}`")));
+    }
+    let top = bool_param(p, "topRow").unwrap_or(false);
+    let left = bool_param(p, "leftColumn").unwrap_or(false);
+    let d = s.doc()?;
+    let srcs: Vec<String> = p
+        .get("sources")
+        .and_then(Json::as_array)
+        .map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect())
+        .or_else(|| str_param(p, "sources").map(|t| t.split(';').map(str::to_string).collect()))
+        .unwrap_or_default();
+    if srcs.is_empty() {
+        return Err(bad(CMD, "give at least one source range in `sources`"));
+    }
+    if srcs.len() > 255 {
+        return Err(bad(CMD, "too many sources (255 max)"));
+    }
+    let (dsi, dest) = match str_param(p, "destination") {
+        Some(t) => {
+            let (si, r) = parse_range(&d.wb, t, CMD)?;
+            (si, r.start)
+        }
+        None => (d.wb.active_sheet(), d.selection.active),
+    };
+    let mut row_keys: Vec<Key> = Vec::new();
+    let mut col_keys: Vec<Key> = Vec::new();
+    let mut row_label: HashMap<Key, String> = HashMap::new();
+    let mut col_label: HashMap<Key, String> = HashMap::new();
+    let mut aggs: HashMap<(usize, usize), Agg> = HashMap::new();
+    let mut total: u64 = 0;
+    let index_of = |keys: &mut Vec<Key>, k: Key| -> usize {
+        match keys.iter().position(|x| *x == k) {
+            Some(i) => i,
+            None => {
+                keys.push(k);
+                keys.len() - 1
+            }
+        }
+    };
+    for t in &srcs {
+        let (si, r) = parse_range(&d.wb, t, CMD)?;
+        total = total.saturating_add(r.count());
+        if total > MAX_CONSOLIDATE_CELLS {
+            return Err(bad(CMD, "the sources are too large"));
+        }
+        let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
+        let r0 = r.start.row + top as u32;
+        let c0 = r.start.col + left as u32;
+        if r0 > r.end.row || c0 > r.end.col {
+            continue;
+        }
+        let label = |c: CellRef| crate::display::cell_text(&d.wb, sh, c).trim().to_string();
+        // Column keys of this source.
+        let mut cols: Vec<(u32, usize)> = Vec::new();
+        for col in c0..=r.end.col {
+            let k = if top {
+                let l = label(CellRef::new(r.start.row, col));
+                if l.is_empty() {
+                    continue;
+                }
+                let k = Key::Label(l.to_lowercase());
+                col_label.entry(k.clone()).or_insert(l);
+                k
+            } else {
+                Key::Pos(col - c0)
+            };
+            cols.push((col, index_of(&mut col_keys, k)));
+        }
+        for row in r0..=r.end.row {
+            let k = if left {
+                let l = label(CellRef::new(row, r.start.col));
+                if l.is_empty() {
+                    continue;
+                }
+                let k = Key::Label(l.to_lowercase());
+                row_label.entry(k.clone()).or_insert(l);
+                k
+            } else {
+                Key::Pos(row - r0)
+            };
+            let ri = index_of(&mut row_keys, k);
+            for (col, ci) in &cols {
+                aggs.entry((ri, *ci)).or_default().add(&sh.value(CellRef::new(row, *col)));
+            }
+        }
+    }
+    let (out_r0, out_c0) = (dest.row + top as u32, dest.col + left as u32);
+    if out_r0 as u64 + row_keys.len() as u64 > gridcraft_core::MAX_ROWS as u64
+        || out_c0 as u64 + col_keys.len() as u64 > gridcraft_core::MAX_COLS as u64
+    {
+        return Err(EngineError::Other("The consolidated data doesn't fit below and right of the destination.".into()));
+    }
+    let mut cells: Vec<(CellRef, Value)> = Vec::new();
+    if top {
+        for (ci, k) in col_keys.iter().enumerate() {
+            cells.push((CellRef::new(dest.row, out_c0 + ci as u32), Value::text(col_label.get(k).cloned().unwrap_or_default())));
+        }
+    }
+    if left {
+        for (ri, k) in row_keys.iter().enumerate() {
+            cells.push((CellRef::new(out_r0 + ri as u32, dest.col), Value::text(row_label.get(k).cloned().unwrap_or_default())));
+        }
+    }
+    for ri in 0..row_keys.len() {
+        for ci in 0..col_keys.len() {
+            let v = aggs.get(&(ri, ci)).map(|a| if a.count == 0 { Value::Empty } else { a.result(&func) }).unwrap_or_default();
+            cells.push((CellRef::new(out_r0 + ri as u32, out_c0 + ci as u32), v));
+        }
+    }
+    let end = CellRef::new(
+        (out_r0 + row_keys.len() as u32).saturating_sub(1).max(dest.row),
+        (out_c0 + col_keys.len() as u32).saturating_sub(1).max(dest.col),
+    );
+    edit(s, |cx| {
+        for (c, v) in cells {
+            let sh = cx.sheet_mut(dsi)?;
+            let style = sh.style_id(c);
+            if v.is_empty() && style == StyleId::DEFAULT {
+                sh.remove_cell(c);
+            } else {
+                sh.set_cell(c, Cell { value: v, formula: None, style });
+            }
+            cx.touch(dsi, c);
+        }
+        Ok(())
+    })?;
+    Ok(json!({"range": RangeRef::new(dest, end).a1(), "rows": row_keys.len(), "columns": col_keys.len()}))
+}
diff --git a/crates/engine/src/cmd/whatif/scenarios.rs b/crates/engine/src/cmd/whatif/scenarios.rs
new file mode 100644
index 000000000..15aa053eb
--- /dev/null
+++ b/crates/engine/src/cmd/whatif/scenarios.rs
@@ -0,0 +1,294 @@
+use super::*;
+
+// ---------------------------------------------------------------- scenarios
+
+/// Hidden workbook-scope name holding the scenarios as a quoted JSON string.
+pub(crate) const SCENARIO_NAME: &str = "_sc_scenarios";
+
+const MAX_SCENARIO_CELLS: usize = 32;
+
+const MAX_SCENARIOS: usize = 1000;
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub(crate) struct Scenario {
+    pub name: String,
+    pub sheet: String,
+    pub changing: String,
+    pub values: Vec<Json>,
+    #[serde(default)]
+    pub comment: String,
+}
+
+pub(crate) fn load_scenarios(wb: &Workbook) -> Vec<Scenario> {
+    let Some(n) = wb.names.iter().find(|n| n.scope.is_none() && n.name.eq_ignore_ascii_case(SCENARIO_NAME)) else { return vec![] };
+    serde_json::from_str(&string_literals(&n.formula)).unwrap_or_default()
+}
+
+/// Concatenates the string literals of a `"a"&"b""c"` formula.
+fn string_literals(f: &str) -> String {
+    let mut out = String::new();
+    let mut it = f.chars().peekable();
+    let mut in_str = false;
+    while let Some(c) = it.next() {
+        if !in_str {
+            if c == '"' {
+                in_str = true;
+            }
+            continue;
+        }
+        if c == '"' {
+            if it.peek() == Some(&'"') {
+                it.next();
+                out.push('"');
+            } else {
+                in_str = false;
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
+fn store_scenarios(wb: &mut Workbook, list: &[Scenario]) {
+    wb.names.retain(|n| !(n.scope.is_none() && n.name.eq_ignore_ascii_case(SCENARIO_NAME)));
+    if list.is_empty() {
+        return;
+    }
+    let text = serde_json::to_string(list).unwrap_or_else(|_| "[]".into());
+    wb.names.push(DefinedName {
+        name: SCENARIO_NAME.into(),
+        scope: None,
+        // Excel caps string literals at 255 characters: store `"…"&"…"` chunks.
+        formula: text
+            .chars()
+            .collect::<Vec<char>>()
+            .chunks(250)
+            .map(|c| format!("\"{}\"", c.iter().collect::<String>().replace('"', "\"\"")))
+            .collect::<Vec<_>>()
+            .join("&"),
+        comment: "GridCraft Scenario Manager data".into(),
+        hidden: true,
+    });
+}
+
+fn scenario_json(sc: &Scenario) -> Json {
+    json!({"name": sc.name, "sheet": sc.sheet, "changing": sc.changing, "values": sc.values, "comment": sc.comment})
+}
+
+pub(super) fn scenario_list(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let sheet = str_param(p, "sheet").map(str::to_string).unwrap_or_else(|| d.wb.active().map(|s| s.name.clone()).unwrap_or_default());
+    let list: Vec<Json> =
+        load_scenarios(&d.wb).iter().filter(|sc| sheet == "*" || sc.sheet.eq_ignore_ascii_case(&sheet)).map(scenario_json).collect();
+    Ok(json!({"scenarios": list}))
+}
+
+pub(super) fn scenario_add(s: &mut Session, p: &Json) -> Result<Json> {
+    const CMD: &str = "data.scenarioAdd";
+    let name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad(CMD, "missing `name`"))?.to_string();
+    if name.chars().count() > 255 {
+        return Err(bad(CMD, "the name is too long (255 characters max)"));
+    }
+    let changing = str_param(p, "changing").ok_or_else(|| bad(CMD, "missing `changing`"))?.to_string();
+    let d = s.doc()?;
+    let (si, cells) = cell_list(&d.wb, &changing, CMD, MAX_SCENARIO_CELLS)?;
+    if cells.is_empty() {
+        return Err(bad(CMD, "no changing cells"));
+    }
+    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
+    let values: Vec<Json> = match p.get("values").and_then(Json::as_array) {
+        Some(a) => {
+            if a.len() != cells.len() {
+                return Err(bad(CMD, format!("{} values for {} changing cells", a.len(), cells.len())));
+            }
+            a.clone()
+        }
+        None => cells.iter().map(|c| value_json(&sh.value(*c))).collect(),
+    };
+    let changing = cells.iter().map(|c| c.a1()).collect::<Vec<_>>().join(",");
+    let sc = Scenario { name: name.clone(), sheet: sh.name.clone(), changing, values, comment: str_param(p, "comment").unwrap_or("").to_string() };
+    let replace = bool_param(p, "replace").unwrap_or(false);
+    let mut list = load_scenarios(&d.wb);
+    match list.iter().position(|x| x.name.eq_ignore_ascii_case(&name) && x.sheet.eq_ignore_ascii_case(&sc.sheet)) {
+        Some(i) if replace => {
+            if let Some(slot) = list.get_mut(i) {
+                *slot = sc.clone();
+            }
+        }
+        Some(_) => return Err(EngineError::Other(format!("A scenario named '{name}' already exists on this sheet."))),
+        None => {
+            if list.len() >= MAX_SCENARIOS {
+                return Err(bad(CMD, "too many scenarios"));
+            }
+            list.push(sc.clone());
+        }
+    }
+    edit(s, |cx| {
+        store_scenarios(&mut cx.wb, &list);
+        Ok(())
+    })?;
+    Ok(scenario_json(&sc))
+}
+
+fn find_scenario(wb: &Workbook, p: &Json, cmd: &str) -> Result<(Vec<Scenario>, usize)> {
+    let name = str_param(p, "name").ok_or_else(|| bad(cmd, "missing `name`"))?;
+    let list = load_scenarios(wb);
+    let active = wb.active().map(|s| s.name.clone()).unwrap_or_default();
+    let i = list
+        .iter()
+        .position(|x| x.name.eq_ignore_ascii_case(name) && x.sheet.eq_ignore_ascii_case(&active))
+        .or_else(|| list.iter().position(|x| x.name.eq_ignore_ascii_case(name)))
+        .ok_or_else(|| bad(cmd, format!("no scenario named `{name}`")))?;
+    Ok((list, i))
+}
+
+pub(super) fn scenario_show(s: &mut Session, p: &Json) -> Result<Json> {
+    const CMD: &str = "data.scenarioShow";
+    let d = s.doc()?;
+    let (list, i) = find_scenario(&d.wb, p, CMD)?;
+    let sc = list.get(i).cloned().ok_or_else(|| bad(CMD, "no such scenario"))?;
+    let si = d.wb.sheet_index(&sc.sheet).ok_or_else(|| bad(CMD, format!("the scenario's sheet `{}` no longer exists", sc.sheet)))?;
+    let (_, cells) = cell_list(&d.wb, &sc.changing, CMD, MAX_SCENARIO_CELLS)?;
+    edit(s, |cx| {
+        for (c, v) in cells.iter().zip(sc.values.iter()) {
+            // Stored numbers are values, not typed text: entering them through the parser would
+            // apply percent entry (9 -> 9%) to a Percentage-formatted cell.
+            let cell = match v.as_f64() {
+                Some(n) => {
+                    let style = cx.wb.sheet(si).map(|sh| sh.style_id(*c)).unwrap_or_default();
+                    Some(Cell { value: Value::Number(n), formula: None, style })
+                }
+                None => crate::cmd::edit::input_to_cell(&crate::cmd::edit::json_to_input(v), si, *c, &mut cx.wb)?,
+            };
+            let sh = cx.sheet_mut(si)?;
+            match cell {
+                Some(cell) => sh.set_cell(*c, cell),
+                None => {
+                    sh.remove_cell(*c);
+                }
+            }
+            cx.touch(si, *c);
+        }
+        Ok(())
+    })?;
+    Ok(scenario_json(&sc))
+}
+
+pub(super) fn scenario_delete(s: &mut Session, p: &Json) -> Result<Json> {
+    let d = s.doc()?;
+    let (mut list, i) = find_scenario(&d.wb, p, "data.scenarioDelete")?;
+    let removed = list.remove(i);
+    edit(s, |cx| {
+        store_scenarios(&mut cx.wb, &list);
+        Ok(())
+    })?;
+    Ok(json!({"deleted": removed.name}))
+}
+
+pub(super) fn scenario_summary(s: &mut Session, p: &Json) -> Result<Json> {
+    const CMD: &str = "data.scenarioSummary";
+    let d = s.doc()?;
+    let si = d.wb.active_sheet();
+    let sh = d.wb.sheet(si).ok_or(EngineError::NoDocument)?;
+    let scenarios: Vec<Scenario> = load_scenarios(&d.wb).into_iter().filter(|x| x.sheet.eq_ignore_ascii_case(&sh.name)).collect();
+    if scenarios.is_empty() {
+        return Err(EngineError::Other("There are no scenarios on this sheet.".into()));
+    }
+    let results: Vec<CellRef> = match str_param(p, "resultCells").map(str::trim).filter(|t| !t.is_empty()) {
+        Some(t) => {
+            let (rsi, cells) = cell_list(&d.wb, t, CMD, 255)?;
+            if rsi != si {
+                return Err(bad(CMD, "result cells must be on the scenarios' sheet"));
+            }
+            cells
+        }
+        None => vec![],
+    };
+    // Changing cells of every scenario, first-seen order; per scenario its values.
+    let mut changing: Vec<CellRef> = Vec::new();
+    let mut per: Vec<HashMap<CellRef, Value>> = Vec::new();
+    for sc in &scenarios {
+        let (_, cells) = cell_list(&d.wb, &sc.changing, CMD, MAX_SCENARIO_CELLS)?;
+        let mut m = HashMap::new();
+        for (c, v) in cells.iter().zip(sc.values.iter()) {
+            if !changing.contains(c) {
+                changing.push(*c);
+            }
+            m.insert(*c, json_value(v, &d.wb));
+        }
+        per.push(m);
+    }
+    let current: Vec<Value> = changing.iter().map(|c| sh.value(*c)).collect();
+    let current_results: Vec<Value> = results.iter().map(|c| sh.value(*c)).collect();
+    let mut trial = Trial::new(d);
+    let reads: Vec<(usize, CellRef)> = results.iter().map(|c| (si, *c)).collect();
+    let scenario_results: Vec<Vec<Value>> = per
+        .iter()
+        .map(|m| {
+            let sets: Vec<(usize, CellRef, Value)> = m.iter().map(|(c, v)| (si, *c, v.clone())).collect();
+            trial.run(&sets, &reads)
+        })
+        .collect();
+    let fmt_of = |c: CellRef| d.wb.styles.get(sh.style_id(c)).num_fmt.clone();
+    let changing_fmts: Vec<_> = changing.iter().map(|c| fmt_of(*c)).collect();
+    let result_fmts: Vec<_> = results.iter().map(|c| fmt_of(*c)).collect();
+    let name = (1..)
+        .map(|n| if n == 1 { "Scenario Summary".to_string() } else { format!("Scenario Summary {n}") })
+        .find(|n| d.wb.sheet_index(n).is_none())
+        .unwrap_or_else(|| "Scenario Summary".into());
+    let names: Vec<String> = scenarios.iter().map(|x| x.name.clone()).collect();
+    let new_index = edit(s, |cx| {
+        let bold = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.font.bold = true);
+        let mut sheet = Sheet::new(name.clone());
+        let put = |sheet: &mut Sheet, row: u32, col: u32, v: Value, style: StyleId| {
+            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style });
+        };
+        put(&mut sheet, 1, 1, Value::text("Scenario Summary"), bold);
+        put(&mut sheet, 2, 2, Value::text("Current Values:"), bold);
+        for (k, n) in names.iter().enumerate() {
+            put(&mut sheet, 2, 3 + k as u32, Value::text(n.as_str()), bold);
+        }
+        put(&mut sheet, 3, 1, Value::text("Changing Cells:"), bold);
+        let mut row = 4u32;
+        for (i, c) in changing.iter().enumerate() {
+            let fmt = changing_fmts.get(i).cloned().unwrap_or_default();
+            let st = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.num_fmt = fmt);
+            put(&mut sheet, row, 1, Value::text(format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1)), StyleId::DEFAULT);
+            let cur = current.get(i).cloned().unwrap_or_default();
+            put(&mut sheet, row, 2, cur.clone(), st);
+            for (k, m) in per.iter().enumerate() {
+                put(&mut sheet, row, 3 + k as u32, m.get(c).cloned().unwrap_or_else(|| cur.clone()), st);
+            }
+            row += 1;
+        }
+        if !results.is_empty() {
+            put(&mut sheet, row, 1, Value::text("Result Cells:"), bold);
+            row += 1;
+            for (i, c) in results.iter().enumerate() {
+                let fmt = result_fmts.get(i).cloned().unwrap_or_default();
+                let st = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.num_fmt = fmt);
+                put(&mut sheet, row, 1, Value::text(format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row + 1)), StyleId::DEFAULT);
+                put(&mut sheet, row, 2, current_results.get(i).cloned().unwrap_or_default(), st);
+                for (k, r) in scenario_results.iter().enumerate() {
+                    put(&mut sheet, row, 3 + k as u32, r.get(i).cloned().unwrap_or_default(), st);
+                }
+                row += 1;
+            }
+        }
+        put(
+            &mut sheet,
+            row + 1,
+            1,
+            Value::text("Notes: Current Values column represents values of changing cells at time Scenario Summary Report was created."),
+            StyleId::DEFAULT,
+        );
+        sheet.cols.insert(1, gridcraft_model::LineInfo { size: Some(110.0), ..Default::default() });
+        sheet.cols.insert(2, gridcraft_model::LineInfo { size: Some(100.0), ..Default::default() });
+        cx.wb.sheets.push(std::sync::Arc::new(sheet));
+        cx.structural = true;
+        Ok(cx.wb.sheets.len() - 1)
+    })?;
+    s.doc_mut()?.wb_switch_sheet(new_index);
+    Ok(json!({"sheet": name, "scenarios": names.len(), "changingCells": changing.len(), "resultCells": results.len()}))
+}

From 8b3a6e0362910dd930a6f9b981c920a51714623c Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:01:41 +0000
Subject: [PATCH 57/76] refactor(engine): move pivot.rs items to pivot/

---
 crates/engine/src/pivot.rs         | 1376 +---------------------------
 crates/engine/src/pivot/charts.rs  |  108 +++
 crates/engine/src/pivot/compute.rs |  556 +++++++++++
 crates/engine/src/pivot/items.rs   |  268 ++++++
 crates/engine/src/pivot/output.rs  |  437 +++++++++
 5 files changed, 1384 insertions(+), 1361 deletions(-)
 create mode 100644 crates/engine/src/pivot/charts.rs
 create mode 100644 crates/engine/src/pivot/compute.rs
 create mode 100644 crates/engine/src/pivot/items.rs
 create mode 100644 crates/engine/src/pivot/output.rs

diff --git a/crates/engine/src/pivot.rs b/crates/engine/src/pivot.rs
index a074f5729..fb72492d5 100644
--- a/crates/engine/src/pivot.rs
+++ b/crates/engine/src/pivot.rs
@@ -18,6 +18,21 @@ use gridcraft_model::{
 
 use crate::pivot_calc::CalcSet;
 
+mod charts;
+mod compute;
+mod items;
+mod output;
+
+use charts::rebind_charts;
+pub use charts::{chart_link, chart_series, clear_output, links_to, parse_chart_link};
+use compute::compute_from;
+pub use compute::{NOT_A_VALUE_CELL, detail_cells, detail_records};
+pub use items::{distinct_labels, func_caption, item_label};
+#[cfg(test)]
+use output::data_cols_exceed_sheet;
+pub use output::{CellKind, OutCell, Output, RowKind};
+use output::{cell_style, look};
+
 /// Largest source block read (cells).
 pub const MAX_SOURCE_CELLS: u64 = 10_000_000;
 /// Largest report written (cells).
@@ -171,1267 +186,12 @@ pub fn read_source(wb: &Workbook, text: &str, default_sheet: usize) -> Result<So
     Ok(Source { sheet: si, range: r, headers, formats, numeric, dates, rows })
 }
 
-// ---------------------------------------------------------------- items
-
-#[derive(Clone, Debug)]
-struct Item {
-    value: Value,
-    label: String,
-    class: u8,
-    num: f64,
-    text: String,
-    first: usize,
-    /// The value is a number shown with the source format.
-    formatted: bool,
-}
-
-#[derive(Default)]
-struct FieldItems {
-    items: Vec<Item>,
-    index: HashMap<String, u32>,
-}
-
-fn cmp_items(a: &Item, b: &Item) -> Ordering {
-    a.class.cmp(&b.class).then(a.num.total_cmp(&b.num)).then_with(|| a.text.cmp(&b.text))
-}
-
-/// (identity key, item) for a source value under a field's date grouping.
-fn make_item(wb: &Workbook, v: &Value, group: PivotDateGroup, fmt: &str, first: usize) -> (String, Item) {
-    let it = |value: Value, label: String, class: u8, num: f64, formatted: bool| Item {
-        text: label.to_lowercase(),
-        value,
-        label,
-        class,
-        num,
-        first,
-        formatted,
-    };
-    match v {
-        Value::Empty => ("b".into(), it(Value::text("(blank)"), "(blank)".into(), 4, 0.0, false)),
-        Value::Number(n) => {
-            if group != PivotDateGroup::None
-                && let Some(dt) = datetime_from_serial(wb.date_system, *n)
-            {
-                let mon = MONTHS.get(dt.month.saturating_sub(1) as usize).copied().unwrap_or("Jan");
-                let (label, key) = match group {
-                    PivotDateGroup::Years => (dt.year.to_string(), dt.year as f64),
-                    PivotDateGroup::Quarters => {
-                        let q = (dt.month.saturating_sub(1)) / 3 + 1;
-                        (format!("Qtr{q}"), q as f64)
-                    }
-                    PivotDateGroup::Months => (mon.to_string(), dt.month as f64),
-                    _ => (format!("{}-{mon}", dt.day), (dt.month * 100 + dt.day) as f64),
-                };
-                return (format!("g{key}"), it(Value::text(label.as_str()), label, 0, key, false));
-            }
-            let label = crate::display::format(v, fmt, wb).text;
-            (format!("n{}", n.to_bits()), it(v.clone(), label, 0, *n, true))
-        }
-        Value::Text(t) => (format!("t{}", t.to_lowercase()), it(v.clone(), t.to_string(), 1, 0.0, false)),
-        Value::Bool(b) => {
-            let l = if *b { "TRUE" } else { "FALSE" };
-            (format!("l{l}"), it(Value::Bool(*b), l.into(), 2, *b as u8 as f64, false))
-        }
-        Value::Error(e) => (format!("e{}", e.as_str()), it(v.clone(), e.as_str().into(), 3, 0.0, false)),
-        Value::Array(_) => make_item(wb, &v.scalar(), group, fmt, first),
-    }
-}
-
-impl FieldItems {
-    fn intern(&mut self, wb: &Workbook, v: &Value, group: PivotDateGroup, fmt: &str, first: usize) -> u32 {
-        let (key, item) = make_item(wb, v, group, fmt, first);
-        if let Some(i) = self.index.get(&key) {
-            return *i;
-        }
-        let i = self.items.len() as u32;
-        self.items.push(item);
-        self.index.insert(key, i);
-        i
-    }
-    fn get(&self, i: u32) -> Option<&Item> {
-        self.items.get(i as usize)
-    }
-    fn label(&self, i: u32) -> String {
-        self.get(i).map(|x| x.label.clone()).unwrap_or_default()
-    }
-}
-
-/// The label of a source value under a date grouping (for filters and field lists).
-pub fn item_label(wb: &Workbook, v: &Value, group: PivotDateGroup, fmt: &str) -> String {
-    make_item(wb, v, group, fmt, 0).1.label
-}
-
-/// Distinct item labels of a source column, sorted like the field list shows them.
-pub fn distinct_labels(wb: &Workbook, src: &Source, col: usize, group: PivotDateGroup, limit: usize) -> Vec<String> {
-    let mut fi = FieldItems::default();
-    let fmt = src.formats.get(col).map(String::as_str).unwrap_or("General");
-    for (i, r) in src.rows.iter().enumerate() {
-        if let Some(v) = r.get(col) {
-            fi.intern(wb, v, group, fmt, i);
-        }
-        if fi.items.len() > 100_000 {
-            break;
-        }
-    }
-    let mut items = fi.items;
-    items.sort_by(cmp_items);
-    items.into_iter().take(limit).map(|i| i.label).collect()
-}
-
-// ---------------------------------------------------------------- aggregation
-
-#[derive(Clone, Debug, Default)]
-struct Acc {
-    count: u64,
-    nums: u64,
-    sum: f64,
-    prod: f64,
-    min: f64,
-    max: f64,
-    mean: f64,
-    m2: f64,
-    err: Option<CellError>,
-}
-
-impl Acc {
-    fn add(&mut self, v: &Value) {
-        match v {
-            Value::Empty => {}
-            Value::Number(n) => {
-                let n = *n;
-                self.count += 1;
-                self.nums += 1;
-                self.sum += n;
-                if self.nums == 1 {
-                    self.prod = n;
-                    self.min = n;
-                    self.max = n;
-                } else {
-                    self.prod *= n;
-                    self.min = self.min.min(n);
-                    self.max = self.max.max(n);
-                }
-                let d = n - self.mean;
-                self.mean += d / self.nums as f64;
-                self.m2 += d * (n - self.mean);
-            }
-            Value::Error(e) => {
-                self.count += 1;
-                if self.err.is_none() {
-                    self.err = Some(*e);
-                }
-            }
-            _ => self.count += 1,
-        }
-    }
-    fn result(&self, f: PivotFunc) -> Value {
-        let n = self.nums as f64;
-        match f {
-            PivotFunc::Count => return Value::number(self.count as f64),
-            PivotFunc::CountNumbers => return Value::number(n),
-            _ => {}
-        }
-        if let Some(e) = self.err {
-            return Value::Error(e);
-        }
-        let div0 = Value::Error(CellError::Div0);
-        match f {
-            PivotFunc::Sum => Value::number(self.sum),
-            PivotFunc::Average => {
-                if self.nums == 0 {
-                    div0
-                } else {
-                    Value::number(self.sum / n)
-                }
-            }
-            PivotFunc::Max => Value::number(if self.nums == 0 { 0.0 } else { self.max }),
-            PivotFunc::Min => Value::number(if self.nums == 0 { 0.0 } else { self.min }),
-            PivotFunc::Product => Value::number(if self.nums == 0 { 0.0 } else { self.prod }),
-            PivotFunc::StdDev | PivotFunc::Var => {
-                if self.nums < 2 {
-                    div0
-                } else {
-                    let var = (self.m2 / (n - 1.0)).max(0.0);
-                    Value::number(if f == PivotFunc::Var { var } else { var.sqrt() })
-                }
-            }
-            PivotFunc::StdDevP | PivotFunc::VarP => {
-                if self.nums < 1 {
-                    div0
-                } else {
-                    let var = (self.m2 / n).max(0.0);
-                    Value::number(if f == PivotFunc::VarP { var } else { var.sqrt() })
-                }
-            }
-            PivotFunc::Count | PivotFunc::CountNumbers => Value::Empty,
-        }
-    }
-}
-
-/// Excel's caption verb for a function ("Sum of Sales").
-pub fn func_caption(f: PivotFunc) -> &'static str {
-    match f {
-        PivotFunc::Sum => "Sum",
-        PivotFunc::Count => "Count",
-        PivotFunc::Average => "Average",
-        PivotFunc::Max => "Max",
-        PivotFunc::Min => "Min",
-        PivotFunc::Product => "Product",
-        PivotFunc::CountNumbers => "Count Numbers",
-        PivotFunc::StdDev => "StdDev",
-        PivotFunc::StdDevP => "StdDevp",
-        PivotFunc::Var => "Var",
-        PivotFunc::VarP => "Varp",
-    }
-}
-
-// ---------------------------------------------------------------- trees
-
-#[derive(Clone, Debug)]
-struct Node {
-    item: u32,
-    children: Vec<Node>,
-}
-
-fn build_tree(paths: &[&[u32]], depth: usize, fields: &[&PivotField], items: &[FieldItems]) -> Vec<Node> {
-    let (Some(field), Some(fi)) = (fields.get(depth), items.get(depth)) else { return vec![] };
-    let mut order: Vec<u32> = Vec::new();
-    let mut groups: HashMap<u32, Vec<&[u32]>> = HashMap::new();
-    for p in paths {
-        if let Some(&it) = p.get(depth) {
-            let g = groups.entry(it).or_default();
-            if g.is_empty() {
-                order.push(it);
-            }
-            g.push(p);
-        }
-    }
-    let mut nodes: Vec<Node> = order
-        .into_iter()
-        .map(|it| {
-            let ps = groups.remove(&it).unwrap_or_default();
-            Node { item: it, children: build_tree(&ps, depth + 1, fields, items) }
-        })
-        .collect();
-    let by = |a: &Node, b: &Node| match (fi.get(a.item), fi.get(b.item)) {
-        (Some(x), Some(y)) => match field.sort {
-            PivotSort::Asc => cmp_items(x, y),
-            PivotSort::Desc => cmp_items(y, x),
-            PivotSort::None => x.first.cmp(&y.first),
-        },
-        _ => Ordering::Equal,
-    };
-    nodes.sort_by(by);
-    nodes
-}
-
-fn is_collapsed(field: &PivotField, label: &str) -> bool {
-    field.collapsed_items.iter().any(|c| c.eq_ignore_ascii_case(label))
-}
-
-fn collect_siblings(nodes: &[Node], prefix: &mut Vec<u32>, out: &mut HashMap<Vec<u32>, Vec<u32>>) {
-    out.insert(prefix.clone(), nodes.iter().map(|n| n.item).collect());
-    for n in nodes {
-        prefix.push(n.item);
-        collect_siblings(&n.children, prefix, out);
-        prefix.pop();
-    }
-}
-
-// ---------------------------------------------------------------- output
-
-/// What a report cell is.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
-pub enum CellKind {
-    Empty,
-    Header,
-    RowLabel,
-    ColLabel,
-    Data,
-    Subtotal,
-    GrandTotal,
-    Filter,
-    Placeholder,
-}
-
-/// What a report row is (for row-wide styling).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
-pub enum RowKind {
-    Filter,
-    Blank,
-    Header,
-    /// Item row; `true` for a parent item (bold).
-    Item(bool),
-    Subtotal,
-    Grand,
-    Placeholder,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct OutCell {
-    pub value: Value,
-    pub kind: CellKind,
-    pub indent: u8,
-    pub num_fmt: Option<String>,
-}
-
-impl OutCell {
-    fn empty() -> OutCell {
-        OutCell { value: Value::Empty, kind: CellKind::Empty, indent: 0, num_fmt: None }
-    }
-}
-
-/// A computed report: a dense grid relative to its top-left, with row kinds.
-#[derive(Clone, Debug)]
-pub struct Output {
-    pub grid: Vec<Vec<OutCell>>,
-    pub row_kinds: Vec<RowKind>,
-    /// Rows above the body (report filters plus a blank row).
-    pub body_offset: u32,
-    pub width: u32,
-    /// Grid rows of the innermost (or collapsed) items: a PivotChart's categories.
-    pub chart_rows: Vec<u32>,
-    /// Grid columns of item (not total) values with their series names: a PivotChart's series.
-    pub chart_cols: Vec<(u32, String)>,
-    /// Grid column holding the innermost row labels (`None` without row fields).
-    pub label_col: Option<u32>,
-}
-
-impl Output {
-    pub fn height(&self) -> u32 {
-        self.grid.len() as u32
-    }
-    /// Value at (row, col) relative to the top-left.
-    pub fn value(&self, r: usize, c: usize) -> Value {
-        self.grid.get(r).and_then(|row| row.get(c)).map(|x| x.value.clone()).unwrap_or_default()
-    }
-}
-
-struct Grid {
-    rows: Vec<Vec<OutCell>>,
-    kinds: Vec<RowKind>,
-    width: usize,
-}
-
-impl Grid {
-    fn push_row(&mut self, kind: RowKind) -> Result<usize, String> {
-        if (self.rows.len() as u64 + 1) * self.width.max(1) as u64 > MAX_OUTPUT_CELLS || self.rows.len() as u64 >= MAX_ROWS as u64 {
-            return Err("The PivotTable report is too large.".into());
-        }
-        self.rows.push(vec![OutCell::empty(); self.width]);
-        self.kinds.push(kind);
-        Ok(self.rows.len() - 1)
-    }
-    fn set(&mut self, r: usize, c: usize, value: Value, kind: CellKind, indent: u8, fmt: Option<String>) {
-        if let Some(cell) = self.rows.get_mut(r).and_then(|row| row.get_mut(c)) {
-            *cell = OutCell { value, kind, indent, num_fmt: fmt };
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum LineKind {
-    Item(bool),
-    Subtotal,
-    Grand,
-}
-
-struct Line {
-    kind: LineKind,
-    /// A category of a PivotChart: an innermost (or collapsed) item.
-    leaf: bool,
-    path: Vec<u32>,
-    values: bool,
-    /// (column, value, indent, number format)
-    labels: Vec<(usize, Value, u8, Option<String>)>,
-    /// The value field of the line when Σ Values sits in Rows (`None`: one per data column).
-    vi: Option<usize>,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum ColKind {
-    Leaf,
-    Subtotal,
-    Grand,
-}
-
-struct ColSpec {
-    kind: ColKind,
-    path: Vec<u32>,
-}
-
-struct Ctx<'a> {
-    pt: &'a PivotTable,
-    rows: Vec<&'a PivotField>,
-    row_items: Vec<FieldItems>,
-    row_fmts: Vec<String>,
-    /// Depth of Σ Values among the row fields when it sits in Rows (two or more value fields).
-    vpos: Option<usize>,
-    /// Value field captions.
-    val_names: Vec<String>,
-}
-
-impl Ctx<'_> {
-    fn label_cell(&self, depth: usize, item: u32) -> (Value, Option<String>, String) {
-        let Some(it) = self.row_items.get(depth).and_then(|fi| fi.get(item)) else { return (Value::Empty, None, String::new()) };
-        let fmt = if it.formatted { self.row_fmts.get(depth).cloned() } else { None };
-        (it.value.clone(), fmt, it.label.clone())
-    }
-
-    /// (column, indent) of a row level (Σ Values counts as a level) in Compact/Outline form.
-    fn level_cell(&self, level: usize) -> (usize, u8) {
-        if self.pt.layout == PivotLayout::Outline { (level, 0) } else { (0, level.min(250) as u8) }
-    }
-
-    /// Σ Values comes right here, at row field depth `depth` (`vi`: the value field already chosen above).
-    fn values_here(&self, depth: usize, vi: Option<usize>) -> bool {
-        vi.is_none() && self.vpos == Some(depth)
-    }
-
-    /// Per-value subtotal lines of an item with Σ Values below it ("East Sum of Sales").
-    fn value_subtotals(&self, col: usize, indent: u8, label: &str, prefix: &[u32], out: &mut Vec<Line>) {
-        for (vi, name) in self.val_names.iter().enumerate() {
-            out.push(Line {
-                kind: LineKind::Subtotal,
-                leaf: false,
-                path: prefix.to_vec(),
-                values: true,
-                labels: vec![(col, Value::text(format!("{label} {name}")), indent, None)],
-                vi: Some(vi),
-            });
-        }
-    }
-
-    /// The Σ Values level at row field depth `depth`: one item per value field, each followed by
-    /// the row fields below it (`nodes`) or, innermost, holding that value.
-    fn flatten_values(&self, nodes: &[Node], depth: usize, prefix: &mut Vec<u32>, out: &mut Vec<Line>) {
-        let (col, indent) = self.level_cell(depth);
-        for (vi, name) in self.val_names.iter().enumerate() {
-            let labels = vec![(col, Value::text(name.as_str()), indent, None)];
-            let leaf = nodes.is_empty();
-            out.push(Line { kind: LineKind::Item(!leaf), leaf, path: prefix.clone(), values: leaf, labels, vi: Some(vi) });
-            if !leaf {
-                self.flatten(nodes, depth, Some(vi), prefix, out);
-            }
-        }
-    }
-
-    fn flatten(&self, nodes: &[Node], depth: usize, vi: Option<usize>, prefix: &mut Vec<u32>, out: &mut Vec<Line>) {
-        if self.values_here(depth, vi) {
-            self.flatten_values(nodes, depth, prefix, out);
-            return;
-        }
-        let n = self.rows.len();
-        // Σ Values still to come below this level: totals need one line per value field.
-        let values_below = vi.is_none() && self.vpos.is_some();
-        let (col, indent) = self.level_cell(depth + usize::from(vi.is_some() && self.vpos.is_some()));
-        for node in nodes {
-            prefix.push(node.item);
-            let (v, fmt, label) = self.label_cell(depth, node.item);
-            let collapsed = depth + 1 < n && self.rows.get(depth).is_some_and(|f| is_collapsed(f, &label));
-            let leaf = depth + 1 >= n || collapsed || node.children.is_empty();
-            if leaf && !values_below {
-                out.push(Line {
-                    kind: LineKind::Item(depth + 1 < n),
-                    leaf: true,
-                    path: prefix.clone(),
-                    values: true,
-                    labels: vec![(col, v, indent, fmt)],
-                    vi,
-                });
-            } else if leaf {
-                out.push(Line {
-                    kind: LineKind::Item(true),
-                    leaf: false,
-                    path: prefix.clone(),
-                    values: false,
-                    labels: vec![(col, v, indent, fmt)],
-                    vi,
-                });
-                // Outline gives each level its own column, so the captions go in the Values
-                // column even when the levels between are collapsed away.
-                let level = if self.pt.layout == PivotLayout::Outline { self.vpos.unwrap_or(depth + 1) } else { depth + 1 };
-                self.flatten_values(&[], level, prefix, out);
-            } else if values_below {
-                // Subtotals per value field, below the group (one line can't hold them all).
-                out.push(Line {
-                    kind: LineKind::Item(true),
-                    leaf: false,
-                    path: prefix.clone(),
-                    values: false,
-                    labels: vec![(col, v, indent, fmt)],
-                    vi,
-                });
-                self.flatten(&node.children, depth + 1, None, prefix, out);
-                if self.pt.subtotals {
-                    self.value_subtotals(col, indent, &label, prefix, out);
-                }
-            } else {
-                let top = self.pt.subtotals && self.pt.subtotals_top;
-                out.push(Line {
-                    kind: LineKind::Item(true),
-                    leaf: false,
-                    path: prefix.clone(),
-                    values: top,
-                    labels: vec![(col, v, indent, fmt)],
-                    vi,
-                });
-                self.flatten(&node.children, depth + 1, vi, prefix, out);
-                if self.pt.subtotals && !self.pt.subtotals_top {
-                    out.push(Line {
-                        kind: LineKind::Subtotal,
-                        leaf: false,
-                        path: prefix.clone(),
-                        values: true,
-                        labels: vec![(col, Value::text(format!("{label} Total")), indent, None)],
-                        vi,
-                    });
-                }
-            }
-            prefix.pop();
-        }
-    }
-
-    /// Tabular form of [`Self::flatten_values`]: the first line also carries the parents' labels.
-    fn flatten_tabular_values(
-        &self,
-        nodes: &[Node],
-        depth: usize,
-        prefix: &mut Vec<u32>,
-        pending: &[(usize, Value, u8, Option<String>)],
-        out: &mut Vec<Line>,
-    ) {
-        for (vi, name) in self.val_names.iter().enumerate() {
-            let mut labels: Vec<(usize, Value, u8, Option<String>)> = if vi == 0 { pending.to_vec() } else { vec![] };
-            labels.push((depth, Value::text(name.as_str()), 0, None));
-            if nodes.is_empty() {
-                out.push(Line { kind: LineKind::Item(false), leaf: true, path: prefix.clone(), values: true, labels, vi: Some(vi) });
-            } else {
-                self.flatten_tabular(nodes, depth, Some(vi), prefix, &labels, out);
-            }
-        }
-    }
-
-    fn flatten_tabular(
-        &self,
-        nodes: &[Node],
-        depth: usize,
-        vi: Option<usize>,
-        prefix: &mut Vec<u32>,
-        pending: &[(usize, Value, u8, Option<String>)],
-        out: &mut Vec<Line>,
-    ) {
-        if self.values_here(depth, vi) {
-            self.flatten_tabular_values(nodes, depth, prefix, pending, out);
-            return;
-        }
-        let n = self.rows.len();
-        let values_below = vi.is_none() && self.vpos.is_some();
-        let col = depth + usize::from(vi.is_some() && self.vpos.is_some());
-        for (i, node) in nodes.iter().enumerate() {
-            prefix.push(node.item);
-            let (v, fmt, label) = self.label_cell(depth, node.item);
-            let mut labels: Vec<(usize, Value, u8, Option<String>)> = if i == 0 { pending.to_vec() } else { vec![] };
-            labels.push((col, v, 0, fmt));
-            let collapsed = depth + 1 < n && self.rows.get(depth).is_some_and(|f| is_collapsed(f, &label));
-            if depth + 1 >= n || collapsed || node.children.is_empty() {
-                if values_below {
-                    self.flatten_tabular_values(&[], self.vpos.unwrap_or(depth + 1), prefix, &labels, out);
-                } else {
-                    out.push(Line { kind: LineKind::Item(false), leaf: true, path: prefix.clone(), values: true, labels, vi });
-                }
-            } else {
-                self.flatten_tabular(&node.children, depth + 1, vi, prefix, &labels, out);
-                if self.pt.subtotals && values_below {
-                    self.value_subtotals(col, 0, &label, prefix, out);
-                } else if self.pt.subtotals {
-                    out.push(Line {
-                        kind: LineKind::Subtotal,
-                        leaf: false,
-                        path: prefix.clone(),
-                        values: true,
-                        labels: vec![(col, Value::text(format!("{label} Total")), 0, None)],
-                        vi,
-                    });
-                }
-            }
-            prefix.pop();
-        }
-    }
-}
-
-fn flatten_cols(
-    nodes: &[Node],
-    depth: usize,
-    fields: &[&PivotField],
-    items: &[FieldItems],
-    subtotals: bool,
-    prefix: &mut Vec<u32>,
-    out: &mut Vec<ColSpec>,
-) {
-    let n = fields.len();
-    for node in nodes {
-        prefix.push(node.item);
-        let label = items.get(depth).map(|fi| fi.label(node.item)).unwrap_or_default();
-        let collapsed = depth + 1 < n && fields.get(depth).is_some_and(|f| is_collapsed(f, &label));
-        if depth + 1 >= n || collapsed || node.children.is_empty() {
-            out.push(ColSpec { kind: ColKind::Leaf, path: prefix.clone() });
-        } else {
-            flatten_cols(&node.children, depth + 1, fields, items, subtotals, prefix, out);
-            if subtotals {
-                out.push(ColSpec { kind: ColKind::Subtotal, path: prefix.clone() });
-            }
-        }
-        prefix.pop();
-    }
-}
-
-type AggMap = HashMap<(Vec<u32>, Vec<u32>), Vec<Acc>>;
-
-/// Where a value field's numbers come from.
-#[derive(Clone, Copy)]
-enum ValSrc {
-    /// A source column.
-    Col(usize),
-    /// A calculated field (index into the PivotTable's calculated fields).
-    Calc(usize),
-}
-
-/// True when `col_groups` distinct column leaves (plus the grand-total column) times `values` value fields
-/// (at least one data column per group) already exceed the sheet width. This is a lower bound on the final column count.
-fn data_cols_exceed_sheet(col_groups: usize, grand_total: bool, values: usize) -> bool {
-    (col_groups + usize::from(grand_total)).saturating_mul(values.max(1)) > MAX_COLS as usize
-}
-
 /// Computes a PivotTable report from the workbook.
 pub fn compute(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Result<Output, String> {
     let src = read_source(wb, &pt.source, pivot_sheet)?;
     compute_from(wb, pt, &src, None)
 }
 
-/// Why Show Details turns a cell down when it isn't a value cell of a PivotTable (the front end
-/// edits that cell instead).
-pub const NOT_A_VALUE_CELL: &str = "select a value cell in a PivotTable";
-
-/// Show Details: the source list and the indices of its records behind the value cell at
-/// (`row`, `col`) of the report grid (relative to its top-left), in source order. `None` when
-/// that cell holds no value (a label, a header, a blank). An error, for any cell, when the report
-/// on the sheet is no longer what the source computes: the cell's records would be another cell's.
-pub fn detail_records(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize, row: u32, col: u32) -> Result<Option<(Source, Vec<usize>)>, String> {
-    let src = read_source(wb, &pt.source, pivot_sheet)?;
-    let mut probe = Probe { at: Some((row as usize, col as usize)), hit: None, paths: Some(Vec::new()), cells: None };
-    let out = compute_from(wb, pt, &src, Some(&mut probe))?;
-    // Checked first: in a stale report even a cell that computes as a label may show a value.
-    check_current(wb, pt, pivot_sheet, &out)?;
-    let Some((rp, cp)) = probe.hit else { return Ok(None) };
-    let records =
-        probe.paths.unwrap_or_default().into_iter().filter(|(_, r, c)| r.starts_with(&rp) && c.starts_with(&cp)).map(|(i, _, _)| i).collect();
-    Ok(Some((src, records)))
-}
-
-/// The cells of the report grid (relative to its top-left) where [`detail_records`] finds
-/// records: its value, subtotal and grand total cells, from one computation of the report. The
-/// same errors as [`detail_records`].
-pub fn detail_cells(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Result<HashSet<(u32, u32)>, String> {
-    let src = read_source(wb, &pt.source, pivot_sheet)?;
-    let mut probe = Probe { at: None, hit: None, paths: None, cells: Some(HashSet::new()) };
-    let out = compute_from(wb, pt, &src, Some(&mut probe))?;
-    check_current(wb, pt, pivot_sheet, &out)?;
-    Ok(probe.cells.unwrap_or_default().into_iter().map(|(r, c)| (r as u32, c as u32)).collect())
-}
-
-/// An error when the report on the sheet is not what `out` computes. Excel reads its PivotTable
-/// cache; without one, the report written by the last refresh must still be what the source gives.
-fn check_current(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize, out: &Output) -> Result<(), String> {
-    let sh = wb.sheet(pivot_sheet).ok_or("There's no such sheet.")?;
-    let current = pt.last_range.is_some_and(|r| {
-        r.height() == out.height().max(1)
-            && r.width() == out.width.max(1)
-            && out.grid.iter().enumerate().all(|(ri, line)| {
-                line.iter().enumerate().all(|(ci, oc)| {
-                    sh.value_ref(CellRef::new(r.start.row + ri as u32, r.start.col + ci as u32)).unwrap_or(&Value::Empty) == &oc.value
-                })
-            })
-    });
-    if !current {
-        return Err("The PivotTable report is out of date. Refresh it first.".into());
-    }
-    Ok(())
-}
-
-/// What [`detail_records`] and [`detail_cells`] ask of a report computation: the row and column
-/// item paths of the value cell at `at`, the paths of every record the filters let through (when
-/// `paths` is set), and every value cell (when `cells` is set).
-struct Probe {
-    at: Option<(usize, usize)>,
-    hit: Option<(Vec<u32>, Vec<u32>)>,
-    paths: Option<Vec<(usize, Vec<u32>, Vec<u32>)>>,
-    cells: Option<HashSet<(usize, usize)>>,
-}
-
-fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut probe: Option<&mut Probe>) -> Result<Output, String> {
-    let fmt_of = |c: usize| src.formats.get(c).cloned().unwrap_or_else(|| "General".into());
-    let rows: Vec<(usize, &PivotField)> = pt.rows.iter().filter_map(|f| src.col(&f.source_col).map(|c| (c, f))).collect();
-    let cols: Vec<(usize, &PivotField)> = pt.columns.iter().filter_map(|f| src.col(&f.source_col).map(|c| (c, f))).collect();
-    // Value fields: a source column, or a calculated field evaluated on sums (see `pivot_calc`).
-    let calc = CalcSet::new(pt, &src.headers);
-    let vals: Vec<(ValSrc, &PivotValue)> = pt
-        .values
-        .iter()
-        .filter_map(|v| match src.col(&v.source_col) {
-            Some(c) => Some((ValSrc::Col(c), v)),
-            None => calc.index(&v.source_col).map(|i| (ValSrc::Calc(i), v)),
-        })
-        .collect();
-    // Source columns summed for the calculated fields, accumulated after the value fields.
-    let mut extra: Vec<usize> = Vec::new();
-    for (vs, _) in &vals {
-        if let ValSrc::Calc(i) = vs {
-            for name in calc.source_refs(*i) {
-                if let Some(c) = src.col(&name)
-                    && !extra.contains(&c)
-                {
-                    extra.push(c);
-                }
-            }
-        }
-    }
-    if rows.len() + cols.len() > MAX_AXIS_FIELDS {
-        return Err(format!("A PivotTable can have at most {MAX_AXIS_FIELDS} row and column fields."));
-    }
-    if vals.len() > MAX_VALUE_FIELDS {
-        return Err(format!("A PivotTable can have at most {MAX_VALUE_FIELDS} value fields."));
-    }
-    let axis_group = |name: &str| -> Option<PivotDateGroup> {
-        pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(name)).map(|f| f.date_group)
-    };
-    // (column, filter, grouping used for labels, shown as a report filter)
-    let filters: Vec<(usize, &PivotFilter, PivotDateGroup, bool)> = pt
-        .filters
-        .iter()
-        .filter_map(|f| {
-            let c = src.col(&f.source_col)?;
-            let g = axis_group(&f.source_col);
-            Some((c, f, g.unwrap_or_default(), g.is_none()))
-        })
-        .collect();
-    let shown_filters: Vec<&(usize, &PivotFilter, PivotDateGroup, bool)> = filters.iter().filter(|f| f.3).collect();
-
-    let k = vals.len();
-    let empty = rows.is_empty() && cols.is_empty() && vals.is_empty();
-    // Σ Values in Rows (it exists with two or more value fields): its depth among the row fields
-    // found in the source.
-    let vpos: Option<usize> = (pt.values_on_rows && k > 1).then(|| {
-        let p = pt.values_position.unwrap_or(pt.rows.len());
-        pt.rows.iter().take(p).filter(|f| src.col(&f.source_col).is_some()).count()
-    });
-    let on_rows = vpos.is_some();
-    let row_levels = rows.len() + usize::from(on_rows);
-
-    // ---- aggregate
-    let mut row_items: Vec<FieldItems> = rows.iter().map(|_| FieldItems::default()).collect();
-    let mut col_items: Vec<FieldItems> = cols.iter().map(|_| FieldItems::default()).collect();
-    let mut aggs: AggMap = HashMap::new();
-    let mut row_set: HashSet<Vec<u32>> = HashSet::new();
-    let mut col_set: HashSet<Vec<u32>> = HashSet::new();
-    let mut col_leaves: HashSet<Vec<u32>> = HashSet::new();
-    let filter_fmts: Vec<String> = filters.iter().map(|f| fmt_of(f.0)).collect();
-    let row_fmts: Vec<String> = rows.iter().map(|(c, _)| fmt_of(*c)).collect();
-    let col_fmts: Vec<String> = cols.iter().map(|(c, _)| fmt_of(*c)).collect();
-    'rec: for (ri, rec) in src.rows.iter().enumerate() {
-        for ((c, f, g, _), fmt) in filters.iter().zip(filter_fmts.iter()) {
-            if let Some(sel) = &f.selected {
-                let label = item_label(wb, rec.get(*c).unwrap_or(&Value::Empty), *g, fmt);
-                if !sel.iter().any(|s| s.eq_ignore_ascii_case(&label)) {
-                    continue 'rec;
-                }
-            }
-        }
-        if empty {
-            continue;
-        }
-        let mut rp = Vec::with_capacity(rows.len());
-        for (((c, f), fi), fmt) in rows.iter().zip(row_items.iter_mut()).zip(row_fmts.iter()) {
-            rp.push(fi.intern(wb, rec.get(*c).unwrap_or(&Value::Empty), f.date_group, fmt, ri));
-        }
-        let mut cp = Vec::with_capacity(cols.len());
-        for (((c, f), fi), fmt) in cols.iter().zip(col_items.iter_mut()).zip(col_fmts.iter()) {
-            cp.push(fi.intern(wb, rec.get(*c).unwrap_or(&Value::Empty), f.date_group, fmt, ri));
-        }
-        for a in 0..=rp.len() {
-            for b in 0..=cp.len() {
-                let e = aggs.entry((rp[..a].to_vec(), cp[..b].to_vec())).or_insert_with(|| vec![Acc::default(); k + extra.len()]);
-                for (acc, (vs, _)) in e.iter_mut().zip(vals.iter()) {
-                    if let ValSrc::Col(c) = vs {
-                        acc.add(rec.get(*c).unwrap_or(&Value::Empty));
-                    }
-                }
-                for (acc, c) in e.iter_mut().skip(k).zip(extra.iter()) {
-                    acc.add(rec.get(*c).unwrap_or(&Value::Empty));
-                }
-            }
-        }
-        // The column leaf this record lands in: its path cut after the first collapsed item (as in `flatten_cols`).
-        let shown = cols
-            .iter()
-            .zip(col_items.iter())
-            .zip(cp.iter())
-            .position(|(((_, f), fi), &it)| !f.collapsed_items.is_empty() && is_collapsed(f, &fi.label(it)))
-            .map_or(cp.len(), |d| d + 1);
-        if !col_leaves.contains(&cp[..shown]) {
-            col_leaves.insert(cp[..shown].to_vec());
-        }
-        if let Some(paths) = probe.as_deref_mut().and_then(|pr| pr.paths.as_mut()) {
-            paths.push((ri, rp.clone(), cp.clone()));
-        }
-        row_set.insert(rp);
-        col_set.insert(cp);
-        // Refuse a report that cannot fit before the accumulators for more column groups are allocated.
-        if !cols.is_empty() && data_cols_exceed_sheet(col_leaves.len(), pt.grand_totals_rows, k) {
-            return Err("The PivotTable report will not fit on the sheet.".into());
-        }
-        if aggs.len() > 5_000_000 {
-            return Err("The PivotTable report is too large.".into());
-        }
-    }
-
-    // ---- axes
-    let row_fields: Vec<&PivotField> = rows.iter().map(|(_, f)| *f).collect();
-    let col_fields: Vec<&PivotField> = cols.iter().map(|(_, f)| *f).collect();
-    let row_paths: Vec<&[u32]> = row_set.iter().map(Vec::as_slice).collect();
-    let col_paths: Vec<&[u32]> = col_set.iter().map(Vec::as_slice).collect();
-    let row_tree = build_tree(&row_paths, 0, &row_fields, &row_items);
-    let col_tree = build_tree(&col_paths, 0, &col_fields, &col_items);
-    let mut siblings: HashMap<Vec<u32>, Vec<u32>> = HashMap::new();
-    collect_siblings(&row_tree, &mut Vec::new(), &mut siblings);
-    let level0: Vec<u32> = row_tree.iter().map(|n| n.item).collect();
-
-    let val_names: Vec<String> = vals.iter().map(|(_, v)| v.name.clone()).collect();
-    let ctx = Ctx { pt, rows: row_fields.clone(), row_items, row_fmts: row_fmts.clone(), vpos, val_names: val_names.clone() };
-    let mut lines: Vec<Line> = Vec::new();
-    if row_levels == 0 {
-        lines.push(Line { kind: LineKind::Item(false), leaf: true, path: vec![], values: true, labels: vec![], vi: None });
-    } else {
-        if pt.layout == PivotLayout::Tabular {
-            ctx.flatten_tabular(&row_tree, 0, None, &mut Vec::new(), &[], &mut lines);
-        } else {
-            ctx.flatten(&row_tree, 0, None, &mut Vec::new(), &mut lines);
-        }
-        // With only Σ Values in Rows its items are the totals already.
-        if pt.grand_totals_cols && !rows.is_empty() {
-            let grand = |text: String, vi: Option<usize>| Line {
-                kind: LineKind::Grand,
-                leaf: false,
-                path: vec![],
-                values: true,
-                labels: vec![(0, Value::text(text), 0, None)],
-                vi,
-            };
-            if on_rows {
-                lines.extend(val_names.iter().enumerate().map(|(vi, name)| grand(format!("Total {name}"), Some(vi))));
-            } else {
-                lines.push(grand("Grand Total".into(), None));
-            }
-        }
-    }
-    let mut specs: Vec<ColSpec> = Vec::new();
-    if cols.is_empty() {
-        specs.push(ColSpec { kind: ColKind::Leaf, path: vec![] });
-    } else {
-        flatten_cols(&col_tree, 0, &col_fields, &col_items, pt.subtotals, &mut Vec::new(), &mut specs);
-        if pt.grand_totals_rows {
-            specs.push(ColSpec { kind: ColKind::Grand, path: vec![] });
-        }
-    }
-    let mut data_cols: Vec<(usize, Option<usize>)> = Vec::new();
-    for (si, _) in specs.iter().enumerate() {
-        if on_rows {
-            // Each line names its value field; one data column per column item.
-            data_cols.push((si, None));
-        } else if k == 0 {
-            if !cols.is_empty() {
-                data_cols.push((si, None));
-            }
-        } else {
-            for vi in 0..k {
-                data_cols.push((si, Some(vi)));
-            }
-        }
-        if data_cols.len() > MAX_COLS as usize {
-            return Err("The PivotTable report will not fit on the sheet.".into());
-        }
-    }
-
-    let compact = pt.layout == PivotLayout::Compact;
-    let l = if row_levels == 0 && cols.is_empty() {
-        0
-    } else if compact {
-        1
-    } else {
-        row_levels.max(1)
-    };
-    let mut width = l + data_cols.len();
-    if !shown_filters.is_empty() {
-        width = width.max(2);
-    }
-    if empty {
-        width = width.max(1);
-    }
-    let width = width.max(1);
-    let mut g = Grid { rows: vec![], kinds: vec![], width };
-
-    // ---- report filters
-    for (c, f, _, _) in &shown_filters {
-        let r = g.push_row(RowKind::Filter)?;
-        let name = src.headers.get(*c).cloned().unwrap_or_default();
-        let shown = match &f.selected {
-            None => "(All)".to_string(),
-            Some(v) if v.len() == 1 => v.first().cloned().unwrap_or_default(),
-            Some(_) => "(Multiple Items)".to_string(),
-        };
-        g.set(r, 0, Value::text(name), CellKind::Filter, 0, None);
-        g.set(r, 1, Value::text(shown), CellKind::Filter, 0, None);
-    }
-    if !shown_filters.is_empty() {
-        g.push_row(RowKind::Blank)?;
-    }
-    let body_offset = g.rows.len() as u32;
-
-    if empty {
-        let r = g.push_row(RowKind::Placeholder)?;
-        g.set(r, 0, Value::text(format!("{} — choose fields", pt.name)), CellKind::Placeholder, 0, None);
-        return Ok(Output {
-            width: g.width as u32,
-            grid: g.rows,
-            row_kinds: g.kinds,
-            body_offset,
-            chart_rows: vec![],
-            chart_cols: vec![],
-            label_col: None,
-        });
-    }
-
-    let val_name = |vi: usize| vals.get(vi).map(|(_, v)| v.name.clone()).unwrap_or_default();
-    let headers_on = pt.show_headers;
-    let row_header = |g: &mut Grid, r: usize| {
-        if row_levels == 0 || !headers_on {
-            return;
-        }
-        if compact {
-            g.set(r, 0, Value::text("Row Labels"), CellKind::Header, 0, None);
-        } else {
-            // One column per row field, Σ Values ("Values") at its place.
-            let mut names: Vec<&str> = row_fields.iter().map(|f| f.source_col.as_str()).collect();
-            if let Some(p) = vpos {
-                names.insert(p.min(names.len()), "Values");
-            }
-            for (i, name) in names.into_iter().enumerate() {
-                g.set(r, i, Value::text(name), CellKind::Header, 0, None);
-            }
-        }
-    };
-
-    // ---- header rows
-    if cols.is_empty() {
-        let r = g.push_row(RowKind::Header)?;
-        row_header(&mut g, r);
-        for (j, (_, vi)) in data_cols.iter().enumerate() {
-            match vi {
-                Some(vi) => g.set(r, l + j, Value::text(val_name(*vi)), CellKind::Header, 0, None),
-                // Values on rows, no column field: the one data column is the grand total.
-                None if on_rows => g.set(r, l + j, Value::text("Total"), CellKind::Header, 0, None),
-                None => {}
-            }
-        }
-    } else {
-        let cap = g.push_row(RowKind::Header)?;
-        if l > 0 && k == 1 {
-            g.set(cap, 0, Value::text(val_name(0)), CellKind::Header, 0, None);
-        }
-        if headers_on {
-            let caption = if compact { "Column Labels".to_string() } else { col_fields.first().map(|f| f.source_col.clone()).unwrap_or_default() };
-            g.set(cap, l, Value::text(caption), CellKind::Header, 0, None);
-        }
-        let levels = cols.len() + usize::from(k > 1 && !on_rows);
-        let first_level = g.rows.len();
-        for _ in 0..levels {
-            g.push_row(RowKind::Header)?;
-        }
-        let mut prev: Option<&ColSpec> = None;
-        for (j, (si, vi)) in data_cols.iter().enumerate() {
-            let Some(spec) = specs.get(*si) else { continue };
-            let c = l + j;
-            match spec.kind {
-                ColKind::Leaf => {
-                    for (lv, &it) in spec.path.iter().enumerate() {
-                        let same = prev.is_some_and(|p| p.kind != ColKind::Grand && p.path.get(..=lv) == spec.path.get(..=lv));
-                        if !same {
-                            let Some(item) = col_items.get(lv).and_then(|fi| fi.get(it)) else { continue };
-                            let fmt = if item.formatted { cols.get(lv).map(|(cc, _)| fmt_of(*cc)) } else { None };
-                            g.set(first_level + lv, c, item.value.clone(), CellKind::ColLabel, 0, fmt);
-                        }
-                    }
-                    if k > 1
-                        && let Some(vi) = vi
-                    {
-                        g.set(first_level + cols.len(), c, Value::text(val_name(*vi)), CellKind::ColLabel, 0, None);
-                    }
-                }
-                ColKind::Subtotal => {
-                    let lv = spec.path.len().saturating_sub(1);
-                    let label = spec.path.last().and_then(|it| col_items.get(lv).map(|fi| fi.label(*it))).unwrap_or_default();
-                    let text = match vi {
-                        Some(vi) if k > 1 => format!("{label} {}", val_name(*vi)),
-                        _ => format!("{label} Total"),
-                    };
-                    g.set(first_level + lv, c, Value::text(text), CellKind::ColLabel, 0, None);
-                }
-                ColKind::Grand => {
-                    let text = match vi {
-                        Some(vi) if k > 1 => format!("Total {}", val_name(*vi)),
-                        _ => "Grand Total".to_string(),
-                    };
-                    g.set(first_level, c, Value::text(text), CellKind::ColLabel, 0, None);
-                }
-            }
-            prev = Some(spec);
-        }
-        let last = g.rows.len() - 1;
-        row_header(&mut g, last);
-    }
-
-    // ---- body
-    let get = |rp: &[u32], cp: &[u32], vi: usize| -> Option<Value> {
-        let (vs, v) = vals.get(vi)?;
-        let accs = aggs.get(&(rp.to_vec(), cp.to_vec()))?;
-        match vs {
-            ValSrc::Col(_) => accs.get(vi).map(|a| a.result(v.func)),
-            ValSrc::Calc(i) => {
-                let sum = |name: &str| -> Value {
-                    src.col(name)
-                        .and_then(|c| extra.iter().position(|x| *x == c))
-                        .and_then(|j| accs.get(k + j))
-                        .map(|a| a.result(PivotFunc::Sum))
-                        .unwrap_or(Value::Number(0.0))
-                };
-                Some(calc.value(wb, *i, &sum))
-            }
-        }
-    };
-    let num = |v: &Option<Value>| v.as_ref().and_then(Value::as_f64);
-    let ratio = |a: Value, b: Option<Value>| -> Value {
-        match (a, b) {
-            (Value::Error(e), _) => Value::Error(e),
-            (_, Some(Value::Error(e))) => Value::Error(e),
-            (Value::Number(x), Some(Value::Number(y))) => {
-                if y == 0.0 {
-                    Value::Error(CellError::Div0)
-                } else {
-                    Value::number(x / y)
-                }
-            }
-            (v, _) => v,
-        }
-    };
-    let data_fmt: Vec<Option<String>> = vals
-        .iter()
-        .map(|(vs, v)| match v.show_as {
-            PivotShowAs::PercentOfGrandTotal | PivotShowAs::PercentOfColumnTotal | PivotShowAs::PercentOfRowTotal => {
-                Some(v.number_format.clone().unwrap_or_else(|| "0.00%".into()))
-            }
-            PivotShowAs::Rank => v.number_format.clone(),
-            _ => v.number_format.clone().or_else(|| match v.func {
-                PivotFunc::Count | PivotFunc::CountNumbers => None,
-                _ => {
-                    let f = match vs {
-                        ValSrc::Col(c) => fmt_of(*c),
-                        ValSrc::Calc(_) => "General".to_string(),
-                    };
-                    (f != "General").then_some(f)
-                }
-            }),
-        })
-        .collect();
-    let mut chart_rows: Vec<u32> = Vec::new();
-    let chart_cols: Vec<(u32, String)> = data_cols
-        .iter()
-        .enumerate()
-        .filter_map(|(j, (si, vi))| {
-            let spec = specs.get(*si)?;
-            if spec.kind != ColKind::Leaf {
-                return None;
-            }
-            let mut parts: Vec<String> =
-                spec.path.iter().enumerate().map(|(lv, it)| col_items.get(lv).map(|fi| fi.label(*it)).unwrap_or_default()).collect();
-            if let Some(vi) = vi
-                && (k > 1 || parts.is_empty())
-            {
-                parts.push(val_name(*vi));
-            } else if parts.is_empty() {
-                parts.push("Total".into());
-            }
-            Some(((l + j) as u32, parts.join(" - ")))
-        })
-        .filter(|_| k > 0)
-        .collect();
-    let label_col = if row_levels == 0 {
-        None
-    } else if compact {
-        Some(0)
-    } else {
-        Some(row_levels.saturating_sub(1) as u32)
-    };
-    for line in &lines {
-        let rk = match line.kind {
-            LineKind::Item(b) => RowKind::Item(b),
-            LineKind::Subtotal => RowKind::Subtotal,
-            LineKind::Grand => RowKind::Grand,
-        };
-        let ck = match line.kind {
-            LineKind::Item(_) => (CellKind::RowLabel, CellKind::Data),
-            LineKind::Subtotal => (CellKind::Subtotal, CellKind::Subtotal),
-            LineKind::Grand => (CellKind::GrandTotal, CellKind::GrandTotal),
-        };
-        let r = g.push_row(rk)?;
-        if line.leaf && k > 0 {
-            chart_rows.push(r as u32);
-        }
-        for (c, v, indent, fmt) in &line.labels {
-            g.set(r, *c, v.clone(), ck.0, *indent, fmt.clone());
-        }
-        if !line.values {
-            continue;
-        }
-        let rp = line.path.as_slice();
-        for (j, (si, col_vi)) in data_cols.iter().enumerate() {
-            let line_vi = col_vi.or(line.vi);
-            let (Some(spec), Some(vi)) = (specs.get(*si), &line_vi) else { continue };
-            let Some((_, vdef)) = vals.get(*vi) else { continue };
-            let cp = spec.path.as_slice();
-            let Some(raw) = get(rp, cp, *vi) else { continue };
-            let shown = match vdef.show_as {
-                PivotShowAs::Normal => raw,
-                PivotShowAs::PercentOfGrandTotal => ratio(raw, get(&[], &[], *vi)),
-                PivotShowAs::PercentOfColumnTotal => ratio(raw, get(&[], cp, *vi)),
-                PivotShowAs::PercentOfRowTotal => ratio(raw, get(rp, &[], *vi)),
-                PivotShowAs::RunningTotal => match (rp.first(), &raw) {
-                    (Some(first), Value::Number(_)) => {
-                        let mut acc = 0.0;
-                        for it in &level0 {
-                            let mut p = rp.to_vec();
-                            if let Some(x) = p.first_mut() {
-                                *x = *it;
-                            }
-                            acc += num(&get(&p, cp, *vi)).unwrap_or(0.0);
-                            if it == first {
-                                break;
-                            }
-                        }
-                        Value::number(acc)
-                    }
-                    _ => raw,
-                },
-                PivotShowAs::Rank => match (rp.split_last(), raw.as_f64()) {
-                    (Some((_, parent)), Some(me)) => {
-                        let sibs = siblings.get(parent).cloned().unwrap_or_default();
-                        let mut rank = 1u64;
-                        for sib in sibs {
-                            let mut p = parent.to_vec();
-                            p.push(sib);
-                            if num(&get(&p, cp, *vi)).is_some_and(|x| x > me) {
-                                rank += 1;
-                            }
-                        }
-                        Value::number(rank as f64)
-                    }
-                    (None, _) => Value::Empty,
-                    _ => raw,
-                },
-            };
-            if let Some(pr) = probe.as_deref_mut() {
-                if pr.at == Some((r, l + j)) {
-                    pr.hit = Some((rp.to_vec(), cp.to_vec()));
-                }
-                if let Some(cells) = pr.cells.as_mut() {
-                    cells.insert((r, l + j));
-                }
-            }
-            g.set(r, l + j, shown, ck.1, 0, data_fmt.get(*vi).cloned().flatten());
-        }
-    }
-    Ok(Output { width: g.width as u32, grid: g.rows, row_kinds: g.kinds, body_offset, chart_rows, chart_cols, label_col })
-}
-
-// ---------------------------------------------------------------- styling and writing
-
-/// Colours for a PivotTable style name (our own palette, keyed by the familiar
-/// `PivotStyleLight1…28 / Medium1…28 / Dark1…28` names).
-struct Look {
-    header_fill: Color,
-    header_font: Color,
-    line: Color,
-    filter_fill: Color,
-}
-
-fn look(style: &str) -> Look {
-    let rest = style.strip_prefix("PivotStyle").unwrap_or(style);
-    let (fam, n) = ["Light", "Medium", "Dark"]
-        .iter()
-        .find_map(|f| rest.strip_prefix(f).map(|num| (*f, num.parse::<u32>().unwrap_or(16))))
-        .unwrap_or(("Light", 16));
-    let k = n.saturating_sub(1) % 7;
-    let acc = if k == 0 { None } else { Some(3 + k as u8) };
-    let tone = |tint: i16| match acc {
-        Some(a) => Color::Theme(a, tint),
-        None => Color::Theme(1, tint.clamp(-1000, 1000)),
-    };
-    match fam {
-        "Dark" => Look { header_fill: Color::Theme(1, 0), header_font: Color::Theme(0, 0), line: tone(0), filter_fill: tone(600) },
-        "Medium" => Look { header_fill: tone(0), header_font: Color::Theme(0, 0), line: tone(0), filter_fill: tone(800) },
-        _ => Look { header_fill: tone(800), header_font: Color::Auto, line: tone(400), filter_fill: tone(800) },
-    }
-}
-
-fn cell_style(lk: &Look, rk: RowKind, cell: &OutCell, last_header: bool) -> Style {
-    let mut s = Style::default();
-    match rk {
-        RowKind::Header => {
-            s.font.bold = true;
-            s.fill = Fill::solid(lk.header_fill);
-            s.font.color = lk.header_font;
-            if last_header {
-                s.borders.bottom = BorderLine { style: BorderStyle::Thin, color: lk.line };
-            }
-        }
-        RowKind::Filter => {
-            s.fill = Fill::solid(lk.filter_fill);
-            s.font.bold = last_header;
-        }
-        RowKind::Item(parent) => s.font.bold = parent,
-        RowKind::Subtotal => s.font.bold = true,
-        RowKind::Grand => {
-            s.font.bold = true;
-            s.borders.top = BorderLine { style: BorderStyle::Thin, color: lk.line };
-        }
-        RowKind::Placeholder => {
-            s.font.italic = true;
-            s.font.color = Color::Theme(1, 500);
-        }
-        RowKind::Blank => {}
-    }
-    if matches!(cell.kind, CellKind::RowLabel | CellKind::ColLabel | CellKind::Subtotal | CellKind::GrandTotal) && !cell.value.is_number() {
-        s.align.h = HAlign::Left;
-    }
-    if matches!(cell.kind, CellKind::RowLabel | CellKind::ColLabel) && cell.value.is_number() {
-        s.align.h = HAlign::Left;
-    }
-    s.align.indent = cell.indent.min(15);
-    if let Some(f) = &cell.num_fmt {
-        s.num_fmt = NumFmt::new(f);
-    }
-    s
-}
-
 /// Recomputes a pivot and writes its report. With `replace` false, refuses when the target area
 /// holds other data. Returns the written area.
 pub fn refresh(wb: &mut Workbook, sheet: usize, idx: usize, replace: bool) -> Result<RangeRef, String> {
@@ -1554,112 +314,6 @@ pub fn refresh(wb: &mut Workbook, sheet: usize, idx: usize, replace: bool) -> Re
     Ok(area)
 }
 
-// ---------------------------------------------------------------- PivotCharts
-
-/// The link a PivotChart stores to its PivotTable: `Sheet2!PivotTable1`.
-pub fn chart_link(sheet: &str, pivot: &str) -> String {
-    format!("{}!{pivot}", quote_sheet(sheet))
-}
-
-/// (sheet, PivotTable name) of a PivotChart link; a leading `[Book.xlsx]` is ignored.
-pub fn parse_chart_link(link: &str) -> Option<(String, String)> {
-    let t = link.trim();
-    let t = match t.strip_prefix('[') {
-        Some(rest) => rest.split_once(']').map(|(_, r)| r).unwrap_or(rest),
-        None => t,
-    };
-    let (sheet, name) = t.rsplit_once('!')?;
-    let sheet = sheet.trim();
-    let sheet = gridcraft_core::unquote_sheet(sheet);
-    let name = name.trim();
-    if sheet.is_empty() || name.is_empty() {
-        return None;
-    }
-    Some((sheet, name.to_string()))
-}
-
-/// Whether a PivotChart link points at `pivot` on `sheet`.
-pub fn links_to(link: &str, sheet: &str, pivot: &str) -> bool {
-    parse_chart_link(link).is_some_and(|(s, n)| s.eq_ignore_ascii_case(sheet) && n.eq_ignore_ascii_case(pivot))
-}
-
-/// An absolute reference to `col` over grid `rows` (contiguous runs joined into a union).
-fn rows_ref(sheet: &str, origin: CellRef, col: u32, rows: &[u32]) -> Option<String> {
-    let q = quote_sheet(sheet);
-    let c = origin.col.checked_add(col)?;
-    let letters = gridcraft_core::col_to_letters(c);
-    let mut parts: Vec<String> = Vec::new();
-    let mut i = 0;
-    while let Some(&start) = rows.get(i) {
-        let mut end = start;
-        while rows.get(i + 1).is_some_and(|n| Some(*n) == end.checked_add(1)) {
-            end += 1;
-            i += 1;
-        }
-        i += 1;
-        let (a, b) = (origin.row.checked_add(start)? + 1, origin.row.checked_add(end)? + 1);
-        parts.push(if a == b { format!("{q}!${letters}${a}") } else { format!("{q}!${letters}${a}:${letters}${b}") });
-    }
-    match parts.len() {
-        0 => None,
-        1 => parts.pop(),
-        _ => Some(format!("({})", parts.join(","))),
-    }
-}
-
-/// Most category rows a PivotChart plots.
-const MAX_CHART_ROWS: usize = 10_000;
-
-/// A PivotChart's series for a report written at `origin`: categories are the innermost row
-/// items, one series per item column (column items × value fields); totals are left out.
-pub fn chart_series(sheet: &str, origin: CellRef, out: &Output) -> Vec<Series> {
-    let rows: Vec<u32> = out.chart_rows.iter().copied().take(MAX_CHART_ROWS).collect();
-    let categories = out.label_col.and_then(|c| rows_ref(sheet, origin, c, &rows));
-    out.chart_cols
-        .iter()
-        .filter_map(|(c, name)| {
-            Some(Series {
-                name: Some(format!("\"{}\"", name.replace('"', "\"\""))),
-                categories: categories.clone(),
-                values: rows_ref(sheet, origin, *c, &rows)?,
-                bubble_sizes: None,
-                color: None,
-                secondary: false,
-                kind: None,
-                quartiles: Default::default(),
-                smooth: false,
-                trendlines: Vec::new(),
-            })
-        })
-        .collect()
-}
-
-/// Rebuilds the series of every PivotChart of a PivotTable after its report was written.
-fn rebind_charts(wb: &mut Workbook, sheet: &str, pivot: &str, origin: CellRef, out: &Output) {
-    let linked = |ch: &Chart| ch.pivot.as_deref().is_some_and(|l| links_to(l, sheet, pivot));
-    let hits: Vec<usize> = (0..wb.sheets.len()).filter(|i| wb.sheet(*i).is_some_and(|sh| sh.charts.iter().any(linked))).collect();
-    if hits.is_empty() {
-        return;
-    }
-    let series = chart_series(sheet, origin, out);
-    for i in hits {
-        let Some(sh) = wb.sheet_mut(i) else { continue };
-        for ch in sh.charts.iter_mut().filter(|c| linked(c)) {
-            ch.series = series.clone();
-        }
-    }
-}
-
-/// Clears a pivot's last output area.
-pub fn clear_output(wb: &mut Workbook, sheet: usize, idx: usize) {
-    let Some(shm) = wb.sheet_mut(sheet) else { return };
-    let Some(r) = shm.pivots.get(idx).and_then(|p| p.last_range) else { return };
-    shm.take_cells(r);
-    if let Some(p) = shm.pivots.get_mut(idx) {
-        p.last_range = None;
-    }
-}
-
 #[cfg(test)]
 mod fit_tests {
     use super::data_cols_exceed_sheet;
diff --git a/crates/engine/src/pivot/charts.rs b/crates/engine/src/pivot/charts.rs
new file mode 100644
index 000000000..0126d6c7b
--- /dev/null
+++ b/crates/engine/src/pivot/charts.rs
@@ -0,0 +1,108 @@
+use super::output::Output;
+use super::*;
+
+// ---------------------------------------------------------------- PivotCharts
+
+/// The link a PivotChart stores to its PivotTable: `Sheet2!PivotTable1`.
+pub fn chart_link(sheet: &str, pivot: &str) -> String {
+    format!("{}!{pivot}", quote_sheet(sheet))
+}
+
+/// (sheet, PivotTable name) of a PivotChart link; a leading `[Book.xlsx]` is ignored.
+pub fn parse_chart_link(link: &str) -> Option<(String, String)> {
+    let t = link.trim();
+    let t = match t.strip_prefix('[') {
+        Some(rest) => rest.split_once(']').map(|(_, r)| r).unwrap_or(rest),
+        None => t,
+    };
+    let (sheet, name) = t.rsplit_once('!')?;
+    let sheet = sheet.trim();
+    let sheet = gridcraft_core::unquote_sheet(sheet);
+    let name = name.trim();
+    if sheet.is_empty() || name.is_empty() {
+        return None;
+    }
+    Some((sheet, name.to_string()))
+}
+
+/// Whether a PivotChart link points at `pivot` on `sheet`.
+pub fn links_to(link: &str, sheet: &str, pivot: &str) -> bool {
+    parse_chart_link(link).is_some_and(|(s, n)| s.eq_ignore_ascii_case(sheet) && n.eq_ignore_ascii_case(pivot))
+}
+
+/// An absolute reference to `col` over grid `rows` (contiguous runs joined into a union).
+fn rows_ref(sheet: &str, origin: CellRef, col: u32, rows: &[u32]) -> Option<String> {
+    let q = quote_sheet(sheet);
+    let c = origin.col.checked_add(col)?;
+    let letters = gridcraft_core::col_to_letters(c);
+    let mut parts: Vec<String> = Vec::new();
+    let mut i = 0;
+    while let Some(&start) = rows.get(i) {
+        let mut end = start;
+        while rows.get(i + 1).is_some_and(|n| Some(*n) == end.checked_add(1)) {
+            end += 1;
+            i += 1;
+        }
+        i += 1;
+        let (a, b) = (origin.row.checked_add(start)? + 1, origin.row.checked_add(end)? + 1);
+        parts.push(if a == b { format!("{q}!${letters}${a}") } else { format!("{q}!${letters}${a}:${letters}${b}") });
+    }
+    match parts.len() {
+        0 => None,
+        1 => parts.pop(),
+        _ => Some(format!("({})", parts.join(","))),
+    }
+}
+
+/// Most category rows a PivotChart plots.
+const MAX_CHART_ROWS: usize = 10_000;
+
+/// A PivotChart's series for a report written at `origin`: categories are the innermost row
+/// items, one series per item column (column items × value fields); totals are left out.
+pub fn chart_series(sheet: &str, origin: CellRef, out: &Output) -> Vec<Series> {
+    let rows: Vec<u32> = out.chart_rows.iter().copied().take(MAX_CHART_ROWS).collect();
+    let categories = out.label_col.and_then(|c| rows_ref(sheet, origin, c, &rows));
+    out.chart_cols
+        .iter()
+        .filter_map(|(c, name)| {
+            Some(Series {
+                name: Some(format!("\"{}\"", name.replace('"', "\"\""))),
+                categories: categories.clone(),
+                values: rows_ref(sheet, origin, *c, &rows)?,
+                bubble_sizes: None,
+                color: None,
+                secondary: false,
+                kind: None,
+                quartiles: Default::default(),
+                smooth: false,
+                trendlines: Vec::new(),
+            })
+        })
+        .collect()
+}
+
+/// Rebuilds the series of every PivotChart of a PivotTable after its report was written.
+pub(super) fn rebind_charts(wb: &mut Workbook, sheet: &str, pivot: &str, origin: CellRef, out: &Output) {
+    let linked = |ch: &Chart| ch.pivot.as_deref().is_some_and(|l| links_to(l, sheet, pivot));
+    let hits: Vec<usize> = (0..wb.sheets.len()).filter(|i| wb.sheet(*i).is_some_and(|sh| sh.charts.iter().any(linked))).collect();
+    if hits.is_empty() {
+        return;
+    }
+    let series = chart_series(sheet, origin, out);
+    for i in hits {
+        let Some(sh) = wb.sheet_mut(i) else { continue };
+        for ch in sh.charts.iter_mut().filter(|c| linked(c)) {
+            ch.series = series.clone();
+        }
+    }
+}
+
+/// Clears a pivot's last output area.
+pub fn clear_output(wb: &mut Workbook, sheet: usize, idx: usize) {
+    let Some(shm) = wb.sheet_mut(sheet) else { return };
+    let Some(r) = shm.pivots.get(idx).and_then(|p| p.last_range) else { return };
+    shm.take_cells(r);
+    if let Some(p) = shm.pivots.get_mut(idx) {
+        p.last_range = None;
+    }
+}
diff --git a/crates/engine/src/pivot/compute.rs b/crates/engine/src/pivot/compute.rs
new file mode 100644
index 000000000..19864ab9a
--- /dev/null
+++ b/crates/engine/src/pivot/compute.rs
@@ -0,0 +1,556 @@
+use super::items::{Acc, FieldItems, build_tree, collect_siblings, is_collapsed, item_label};
+use super::output::{AggMap, CellKind, ColKind, ColSpec, Ctx, Grid, Line, LineKind, Output, RowKind, ValSrc, data_cols_exceed_sheet, flatten_cols};
+use super::*;
+
+/// Why Show Details turns a cell down when it isn't a value cell of a PivotTable (the front end
+/// edits that cell instead).
+pub const NOT_A_VALUE_CELL: &str = "select a value cell in a PivotTable";
+
+/// Show Details: the source list and the indices of its records behind the value cell at
+/// (`row`, `col`) of the report grid (relative to its top-left), in source order. `None` when
+/// that cell holds no value (a label, a header, a blank). An error, for any cell, when the report
+/// on the sheet is no longer what the source computes: the cell's records would be another cell's.
+pub fn detail_records(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize, row: u32, col: u32) -> Result<Option<(Source, Vec<usize>)>, String> {
+    let src = read_source(wb, &pt.source, pivot_sheet)?;
+    let mut probe = Probe { at: Some((row as usize, col as usize)), hit: None, paths: Some(Vec::new()), cells: None };
+    let out = compute_from(wb, pt, &src, Some(&mut probe))?;
+    // Checked first: in a stale report even a cell that computes as a label may show a value.
+    check_current(wb, pt, pivot_sheet, &out)?;
+    let Some((rp, cp)) = probe.hit else { return Ok(None) };
+    let records =
+        probe.paths.unwrap_or_default().into_iter().filter(|(_, r, c)| r.starts_with(&rp) && c.starts_with(&cp)).map(|(i, _, _)| i).collect();
+    Ok(Some((src, records)))
+}
+
+/// The cells of the report grid (relative to its top-left) where [`detail_records`] finds
+/// records: its value, subtotal and grand total cells, from one computation of the report. The
+/// same errors as [`detail_records`].
+pub fn detail_cells(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Result<HashSet<(u32, u32)>, String> {
+    let src = read_source(wb, &pt.source, pivot_sheet)?;
+    let mut probe = Probe { at: None, hit: None, paths: None, cells: Some(HashSet::new()) };
+    let out = compute_from(wb, pt, &src, Some(&mut probe))?;
+    check_current(wb, pt, pivot_sheet, &out)?;
+    Ok(probe.cells.unwrap_or_default().into_iter().map(|(r, c)| (r as u32, c as u32)).collect())
+}
+
+/// An error when the report on the sheet is not what `out` computes. Excel reads its PivotTable
+/// cache; without one, the report written by the last refresh must still be what the source gives.
+fn check_current(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize, out: &Output) -> Result<(), String> {
+    let sh = wb.sheet(pivot_sheet).ok_or("There's no such sheet.")?;
+    let current = pt.last_range.is_some_and(|r| {
+        r.height() == out.height().max(1)
+            && r.width() == out.width.max(1)
+            && out.grid.iter().enumerate().all(|(ri, line)| {
+                line.iter().enumerate().all(|(ci, oc)| {
+                    sh.value_ref(CellRef::new(r.start.row + ri as u32, r.start.col + ci as u32)).unwrap_or(&Value::Empty) == &oc.value
+                })
+            })
+    });
+    if !current {
+        return Err("The PivotTable report is out of date. Refresh it first.".into());
+    }
+    Ok(())
+}
+
+/// What [`detail_records`] and [`detail_cells`] ask of a report computation: the row and column
+/// item paths of the value cell at `at`, the paths of every record the filters let through (when
+/// `paths` is set), and every value cell (when `cells` is set).
+pub(super) struct Probe {
+    at: Option<(usize, usize)>,
+    hit: Option<(Vec<u32>, Vec<u32>)>,
+    paths: Option<Vec<(usize, Vec<u32>, Vec<u32>)>>,
+    cells: Option<HashSet<(usize, usize)>>,
+}
+
+pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut probe: Option<&mut Probe>) -> Result<Output, String> {
+    let fmt_of = |c: usize| src.formats.get(c).cloned().unwrap_or_else(|| "General".into());
+    let rows: Vec<(usize, &PivotField)> = pt.rows.iter().filter_map(|f| src.col(&f.source_col).map(|c| (c, f))).collect();
+    let cols: Vec<(usize, &PivotField)> = pt.columns.iter().filter_map(|f| src.col(&f.source_col).map(|c| (c, f))).collect();
+    // Value fields: a source column, or a calculated field evaluated on sums (see `pivot_calc`).
+    let calc = CalcSet::new(pt, &src.headers);
+    let vals: Vec<(ValSrc, &PivotValue)> = pt
+        .values
+        .iter()
+        .filter_map(|v| match src.col(&v.source_col) {
+            Some(c) => Some((ValSrc::Col(c), v)),
+            None => calc.index(&v.source_col).map(|i| (ValSrc::Calc(i), v)),
+        })
+        .collect();
+    // Source columns summed for the calculated fields, accumulated after the value fields.
+    let mut extra: Vec<usize> = Vec::new();
+    for (vs, _) in &vals {
+        if let ValSrc::Calc(i) = vs {
+            for name in calc.source_refs(*i) {
+                if let Some(c) = src.col(&name)
+                    && !extra.contains(&c)
+                {
+                    extra.push(c);
+                }
+            }
+        }
+    }
+    if rows.len() + cols.len() > MAX_AXIS_FIELDS {
+        return Err(format!("A PivotTable can have at most {MAX_AXIS_FIELDS} row and column fields."));
+    }
+    if vals.len() > MAX_VALUE_FIELDS {
+        return Err(format!("A PivotTable can have at most {MAX_VALUE_FIELDS} value fields."));
+    }
+    let axis_group = |name: &str| -> Option<PivotDateGroup> {
+        pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(name)).map(|f| f.date_group)
+    };
+    // (column, filter, grouping used for labels, shown as a report filter)
+    let filters: Vec<(usize, &PivotFilter, PivotDateGroup, bool)> = pt
+        .filters
+        .iter()
+        .filter_map(|f| {
+            let c = src.col(&f.source_col)?;
+            let g = axis_group(&f.source_col);
+            Some((c, f, g.unwrap_or_default(), g.is_none()))
+        })
+        .collect();
+    let shown_filters: Vec<&(usize, &PivotFilter, PivotDateGroup, bool)> = filters.iter().filter(|f| f.3).collect();
+
+    let k = vals.len();
+    let empty = rows.is_empty() && cols.is_empty() && vals.is_empty();
+    // Σ Values in Rows (it exists with two or more value fields): its depth among the row fields
+    // found in the source.
+    let vpos: Option<usize> = (pt.values_on_rows && k > 1).then(|| {
+        let p = pt.values_position.unwrap_or(pt.rows.len());
+        pt.rows.iter().take(p).filter(|f| src.col(&f.source_col).is_some()).count()
+    });
+    let on_rows = vpos.is_some();
+    let row_levels = rows.len() + usize::from(on_rows);
+
+    // ---- aggregate
+    let mut row_items: Vec<FieldItems> = rows.iter().map(|_| FieldItems::default()).collect();
+    let mut col_items: Vec<FieldItems> = cols.iter().map(|_| FieldItems::default()).collect();
+    let mut aggs: AggMap = HashMap::new();
+    let mut row_set: HashSet<Vec<u32>> = HashSet::new();
+    let mut col_set: HashSet<Vec<u32>> = HashSet::new();
+    let mut col_leaves: HashSet<Vec<u32>> = HashSet::new();
+    let filter_fmts: Vec<String> = filters.iter().map(|f| fmt_of(f.0)).collect();
+    let row_fmts: Vec<String> = rows.iter().map(|(c, _)| fmt_of(*c)).collect();
+    let col_fmts: Vec<String> = cols.iter().map(|(c, _)| fmt_of(*c)).collect();
+    'rec: for (ri, rec) in src.rows.iter().enumerate() {
+        for ((c, f, g, _), fmt) in filters.iter().zip(filter_fmts.iter()) {
+            if let Some(sel) = &f.selected {
+                let label = item_label(wb, rec.get(*c).unwrap_or(&Value::Empty), *g, fmt);
+                if !sel.iter().any(|s| s.eq_ignore_ascii_case(&label)) {
+                    continue 'rec;
+                }
+            }
+        }
+        if empty {
+            continue;
+        }
+        let mut rp = Vec::with_capacity(rows.len());
+        for (((c, f), fi), fmt) in rows.iter().zip(row_items.iter_mut()).zip(row_fmts.iter()) {
+            rp.push(fi.intern(wb, rec.get(*c).unwrap_or(&Value::Empty), f.date_group, fmt, ri));
+        }
+        let mut cp = Vec::with_capacity(cols.len());
+        for (((c, f), fi), fmt) in cols.iter().zip(col_items.iter_mut()).zip(col_fmts.iter()) {
+            cp.push(fi.intern(wb, rec.get(*c).unwrap_or(&Value::Empty), f.date_group, fmt, ri));
+        }
+        for a in 0..=rp.len() {
+            for b in 0..=cp.len() {
+                let e = aggs.entry((rp[..a].to_vec(), cp[..b].to_vec())).or_insert_with(|| vec![Acc::default(); k + extra.len()]);
+                for (acc, (vs, _)) in e.iter_mut().zip(vals.iter()) {
+                    if let ValSrc::Col(c) = vs {
+                        acc.add(rec.get(*c).unwrap_or(&Value::Empty));
+                    }
+                }
+                for (acc, c) in e.iter_mut().skip(k).zip(extra.iter()) {
+                    acc.add(rec.get(*c).unwrap_or(&Value::Empty));
+                }
+            }
+        }
+        // The column leaf this record lands in: its path cut after the first collapsed item (as in `flatten_cols`).
+        let shown = cols
+            .iter()
+            .zip(col_items.iter())
+            .zip(cp.iter())
+            .position(|(((_, f), fi), &it)| !f.collapsed_items.is_empty() && is_collapsed(f, &fi.label(it)))
+            .map_or(cp.len(), |d| d + 1);
+        if !col_leaves.contains(&cp[..shown]) {
+            col_leaves.insert(cp[..shown].to_vec());
+        }
+        if let Some(paths) = probe.as_deref_mut().and_then(|pr| pr.paths.as_mut()) {
+            paths.push((ri, rp.clone(), cp.clone()));
+        }
+        row_set.insert(rp);
+        col_set.insert(cp);
+        // Refuse a report that cannot fit before the accumulators for more column groups are allocated.
+        if !cols.is_empty() && data_cols_exceed_sheet(col_leaves.len(), pt.grand_totals_rows, k) {
+            return Err("The PivotTable report will not fit on the sheet.".into());
+        }
+        if aggs.len() > 5_000_000 {
+            return Err("The PivotTable report is too large.".into());
+        }
+    }
+
+    // ---- axes
+    let row_fields: Vec<&PivotField> = rows.iter().map(|(_, f)| *f).collect();
+    let col_fields: Vec<&PivotField> = cols.iter().map(|(_, f)| *f).collect();
+    let row_paths: Vec<&[u32]> = row_set.iter().map(Vec::as_slice).collect();
+    let col_paths: Vec<&[u32]> = col_set.iter().map(Vec::as_slice).collect();
+    let row_tree = build_tree(&row_paths, 0, &row_fields, &row_items);
+    let col_tree = build_tree(&col_paths, 0, &col_fields, &col_items);
+    let mut siblings: HashMap<Vec<u32>, Vec<u32>> = HashMap::new();
+    collect_siblings(&row_tree, &mut Vec::new(), &mut siblings);
+    let level0: Vec<u32> = row_tree.iter().map(|n| n.item).collect();
+
+    let val_names: Vec<String> = vals.iter().map(|(_, v)| v.name.clone()).collect();
+    let ctx = Ctx { pt, rows: row_fields.clone(), row_items, row_fmts: row_fmts.clone(), vpos, val_names: val_names.clone() };
+    let mut lines: Vec<Line> = Vec::new();
+    if row_levels == 0 {
+        lines.push(Line { kind: LineKind::Item(false), leaf: true, path: vec![], values: true, labels: vec![], vi: None });
+    } else {
+        if pt.layout == PivotLayout::Tabular {
+            ctx.flatten_tabular(&row_tree, 0, None, &mut Vec::new(), &[], &mut lines);
+        } else {
+            ctx.flatten(&row_tree, 0, None, &mut Vec::new(), &mut lines);
+        }
+        // With only Σ Values in Rows its items are the totals already.
+        if pt.grand_totals_cols && !rows.is_empty() {
+            let grand = |text: String, vi: Option<usize>| Line {
+                kind: LineKind::Grand,
+                leaf: false,
+                path: vec![],
+                values: true,
+                labels: vec![(0, Value::text(text), 0, None)],
+                vi,
+            };
+            if on_rows {
+                lines.extend(val_names.iter().enumerate().map(|(vi, name)| grand(format!("Total {name}"), Some(vi))));
+            } else {
+                lines.push(grand("Grand Total".into(), None));
+            }
+        }
+    }
+    let mut specs: Vec<ColSpec> = Vec::new();
+    if cols.is_empty() {
+        specs.push(ColSpec { kind: ColKind::Leaf, path: vec![] });
+    } else {
+        flatten_cols(&col_tree, 0, &col_fields, &col_items, pt.subtotals, &mut Vec::new(), &mut specs);
+        if pt.grand_totals_rows {
+            specs.push(ColSpec { kind: ColKind::Grand, path: vec![] });
+        }
+    }
+    let mut data_cols: Vec<(usize, Option<usize>)> = Vec::new();
+    for (si, _) in specs.iter().enumerate() {
+        if on_rows {
+            // Each line names its value field; one data column per column item.
+            data_cols.push((si, None));
+        } else if k == 0 {
+            if !cols.is_empty() {
+                data_cols.push((si, None));
+            }
+        } else {
+            for vi in 0..k {
+                data_cols.push((si, Some(vi)));
+            }
+        }
+        if data_cols.len() > MAX_COLS as usize {
+            return Err("The PivotTable report will not fit on the sheet.".into());
+        }
+    }
+
+    let compact = pt.layout == PivotLayout::Compact;
+    let l = if row_levels == 0 && cols.is_empty() {
+        0
+    } else if compact {
+        1
+    } else {
+        row_levels.max(1)
+    };
+    let mut width = l + data_cols.len();
+    if !shown_filters.is_empty() {
+        width = width.max(2);
+    }
+    if empty {
+        width = width.max(1);
+    }
+    let width = width.max(1);
+    let mut g = Grid { rows: vec![], kinds: vec![], width };
+
+    // ---- report filters
+    for (c, f, _, _) in &shown_filters {
+        let r = g.push_row(RowKind::Filter)?;
+        let name = src.headers.get(*c).cloned().unwrap_or_default();
+        let shown = match &f.selected {
+            None => "(All)".to_string(),
+            Some(v) if v.len() == 1 => v.first().cloned().unwrap_or_default(),
+            Some(_) => "(Multiple Items)".to_string(),
+        };
+        g.set(r, 0, Value::text(name), CellKind::Filter, 0, None);
+        g.set(r, 1, Value::text(shown), CellKind::Filter, 0, None);
+    }
+    if !shown_filters.is_empty() {
+        g.push_row(RowKind::Blank)?;
+    }
+    let body_offset = g.rows.len() as u32;
+
+    if empty {
+        let r = g.push_row(RowKind::Placeholder)?;
+        g.set(r, 0, Value::text(format!("{} — choose fields", pt.name)), CellKind::Placeholder, 0, None);
+        return Ok(Output {
+            width: g.width as u32,
+            grid: g.rows,
+            row_kinds: g.kinds,
+            body_offset,
+            chart_rows: vec![],
+            chart_cols: vec![],
+            label_col: None,
+        });
+    }
+
+    let val_name = |vi: usize| vals.get(vi).map(|(_, v)| v.name.clone()).unwrap_or_default();
+    let headers_on = pt.show_headers;
+    let row_header = |g: &mut Grid, r: usize| {
+        if row_levels == 0 || !headers_on {
+            return;
+        }
+        if compact {
+            g.set(r, 0, Value::text("Row Labels"), CellKind::Header, 0, None);
+        } else {
+            // One column per row field, Σ Values ("Values") at its place.
+            let mut names: Vec<&str> = row_fields.iter().map(|f| f.source_col.as_str()).collect();
+            if let Some(p) = vpos {
+                names.insert(p.min(names.len()), "Values");
+            }
+            for (i, name) in names.into_iter().enumerate() {
+                g.set(r, i, Value::text(name), CellKind::Header, 0, None);
+            }
+        }
+    };
+
+    // ---- header rows
+    if cols.is_empty() {
+        let r = g.push_row(RowKind::Header)?;
+        row_header(&mut g, r);
+        for (j, (_, vi)) in data_cols.iter().enumerate() {
+            match vi {
+                Some(vi) => g.set(r, l + j, Value::text(val_name(*vi)), CellKind::Header, 0, None),
+                // Values on rows, no column field: the one data column is the grand total.
+                None if on_rows => g.set(r, l + j, Value::text("Total"), CellKind::Header, 0, None),
+                None => {}
+            }
+        }
+    } else {
+        let cap = g.push_row(RowKind::Header)?;
+        if l > 0 && k == 1 {
+            g.set(cap, 0, Value::text(val_name(0)), CellKind::Header, 0, None);
+        }
+        if headers_on {
+            let caption = if compact { "Column Labels".to_string() } else { col_fields.first().map(|f| f.source_col.clone()).unwrap_or_default() };
+            g.set(cap, l, Value::text(caption), CellKind::Header, 0, None);
+        }
+        let levels = cols.len() + usize::from(k > 1 && !on_rows);
+        let first_level = g.rows.len();
+        for _ in 0..levels {
+            g.push_row(RowKind::Header)?;
+        }
+        let mut prev: Option<&ColSpec> = None;
+        for (j, (si, vi)) in data_cols.iter().enumerate() {
+            let Some(spec) = specs.get(*si) else { continue };
+            let c = l + j;
+            match spec.kind {
+                ColKind::Leaf => {
+                    for (lv, &it) in spec.path.iter().enumerate() {
+                        let same = prev.is_some_and(|p| p.kind != ColKind::Grand && p.path.get(..=lv) == spec.path.get(..=lv));
+                        if !same {
+                            let Some(item) = col_items.get(lv).and_then(|fi| fi.get(it)) else { continue };
+                            let fmt = if item.formatted { cols.get(lv).map(|(cc, _)| fmt_of(*cc)) } else { None };
+                            g.set(first_level + lv, c, item.value.clone(), CellKind::ColLabel, 0, fmt);
+                        }
+                    }
+                    if k > 1
+                        && let Some(vi) = vi
+                    {
+                        g.set(first_level + cols.len(), c, Value::text(val_name(*vi)), CellKind::ColLabel, 0, None);
+                    }
+                }
+                ColKind::Subtotal => {
+                    let lv = spec.path.len().saturating_sub(1);
+                    let label = spec.path.last().and_then(|it| col_items.get(lv).map(|fi| fi.label(*it))).unwrap_or_default();
+                    let text = match vi {
+                        Some(vi) if k > 1 => format!("{label} {}", val_name(*vi)),
+                        _ => format!("{label} Total"),
+                    };
+                    g.set(first_level + lv, c, Value::text(text), CellKind::ColLabel, 0, None);
+                }
+                ColKind::Grand => {
+                    let text = match vi {
+                        Some(vi) if k > 1 => format!("Total {}", val_name(*vi)),
+                        _ => "Grand Total".to_string(),
+                    };
+                    g.set(first_level, c, Value::text(text), CellKind::ColLabel, 0, None);
+                }
+            }
+            prev = Some(spec);
+        }
+        let last = g.rows.len() - 1;
+        row_header(&mut g, last);
+    }
+
+    // ---- body
+    let get = |rp: &[u32], cp: &[u32], vi: usize| -> Option<Value> {
+        let (vs, v) = vals.get(vi)?;
+        let accs = aggs.get(&(rp.to_vec(), cp.to_vec()))?;
+        match vs {
+            ValSrc::Col(_) => accs.get(vi).map(|a| a.result(v.func)),
+            ValSrc::Calc(i) => {
+                let sum = |name: &str| -> Value {
+                    src.col(name)
+                        .and_then(|c| extra.iter().position(|x| *x == c))
+                        .and_then(|j| accs.get(k + j))
+                        .map(|a| a.result(PivotFunc::Sum))
+                        .unwrap_or(Value::Number(0.0))
+                };
+                Some(calc.value(wb, *i, &sum))
+            }
+        }
+    };
+    let num = |v: &Option<Value>| v.as_ref().and_then(Value::as_f64);
+    let ratio = |a: Value, b: Option<Value>| -> Value {
+        match (a, b) {
+            (Value::Error(e), _) => Value::Error(e),
+            (_, Some(Value::Error(e))) => Value::Error(e),
+            (Value::Number(x), Some(Value::Number(y))) => {
+                if y == 0.0 {
+                    Value::Error(CellError::Div0)
+                } else {
+                    Value::number(x / y)
+                }
+            }
+            (v, _) => v,
+        }
+    };
+    let data_fmt: Vec<Option<String>> = vals
+        .iter()
+        .map(|(vs, v)| match v.show_as {
+            PivotShowAs::PercentOfGrandTotal | PivotShowAs::PercentOfColumnTotal | PivotShowAs::PercentOfRowTotal => {
+                Some(v.number_format.clone().unwrap_or_else(|| "0.00%".into()))
+            }
+            PivotShowAs::Rank => v.number_format.clone(),
+            _ => v.number_format.clone().or_else(|| match v.func {
+                PivotFunc::Count | PivotFunc::CountNumbers => None,
+                _ => {
+                    let f = match vs {
+                        ValSrc::Col(c) => fmt_of(*c),
+                        ValSrc::Calc(_) => "General".to_string(),
+                    };
+                    (f != "General").then_some(f)
+                }
+            }),
+        })
+        .collect();
+    let mut chart_rows: Vec<u32> = Vec::new();
+    let chart_cols: Vec<(u32, String)> = data_cols
+        .iter()
+        .enumerate()
+        .filter_map(|(j, (si, vi))| {
+            let spec = specs.get(*si)?;
+            if spec.kind != ColKind::Leaf {
+                return None;
+            }
+            let mut parts: Vec<String> =
+                spec.path.iter().enumerate().map(|(lv, it)| col_items.get(lv).map(|fi| fi.label(*it)).unwrap_or_default()).collect();
+            if let Some(vi) = vi
+                && (k > 1 || parts.is_empty())
+            {
+                parts.push(val_name(*vi));
+            } else if parts.is_empty() {
+                parts.push("Total".into());
+            }
+            Some(((l + j) as u32, parts.join(" - ")))
+        })
+        .filter(|_| k > 0)
+        .collect();
+    let label_col = if row_levels == 0 {
+        None
+    } else if compact {
+        Some(0)
+    } else {
+        Some(row_levels.saturating_sub(1) as u32)
+    };
+    for line in &lines {
+        let rk = match line.kind {
+            LineKind::Item(b) => RowKind::Item(b),
+            LineKind::Subtotal => RowKind::Subtotal,
+            LineKind::Grand => RowKind::Grand,
+        };
+        let ck = match line.kind {
+            LineKind::Item(_) => (CellKind::RowLabel, CellKind::Data),
+            LineKind::Subtotal => (CellKind::Subtotal, CellKind::Subtotal),
+            LineKind::Grand => (CellKind::GrandTotal, CellKind::GrandTotal),
+        };
+        let r = g.push_row(rk)?;
+        if line.leaf && k > 0 {
+            chart_rows.push(r as u32);
+        }
+        for (c, v, indent, fmt) in &line.labels {
+            g.set(r, *c, v.clone(), ck.0, *indent, fmt.clone());
+        }
+        if !line.values {
+            continue;
+        }
+        let rp = line.path.as_slice();
+        for (j, (si, col_vi)) in data_cols.iter().enumerate() {
+            let line_vi = col_vi.or(line.vi);
+            let (Some(spec), Some(vi)) = (specs.get(*si), &line_vi) else { continue };
+            let Some((_, vdef)) = vals.get(*vi) else { continue };
+            let cp = spec.path.as_slice();
+            let Some(raw) = get(rp, cp, *vi) else { continue };
+            let shown = match vdef.show_as {
+                PivotShowAs::Normal => raw,
+                PivotShowAs::PercentOfGrandTotal => ratio(raw, get(&[], &[], *vi)),
+                PivotShowAs::PercentOfColumnTotal => ratio(raw, get(&[], cp, *vi)),
+                PivotShowAs::PercentOfRowTotal => ratio(raw, get(rp, &[], *vi)),
+                PivotShowAs::RunningTotal => match (rp.first(), &raw) {
+                    (Some(first), Value::Number(_)) => {
+                        let mut acc = 0.0;
+                        for it in &level0 {
+                            let mut p = rp.to_vec();
+                            if let Some(x) = p.first_mut() {
+                                *x = *it;
+                            }
+                            acc += num(&get(&p, cp, *vi)).unwrap_or(0.0);
+                            if it == first {
+                                break;
+                            }
+                        }
+                        Value::number(acc)
+                    }
+                    _ => raw,
+                },
+                PivotShowAs::Rank => match (rp.split_last(), raw.as_f64()) {
+                    (Some((_, parent)), Some(me)) => {
+                        let sibs = siblings.get(parent).cloned().unwrap_or_default();
+                        let mut rank = 1u64;
+                        for sib in sibs {
+                            let mut p = parent.to_vec();
+                            p.push(sib);
+                            if num(&get(&p, cp, *vi)).is_some_and(|x| x > me) {
+                                rank += 1;
+                            }
+                        }
+                        Value::number(rank as f64)
+                    }
+                    (None, _) => Value::Empty,
+                    _ => raw,
+                },
+            };
+            if let Some(pr) = probe.as_deref_mut() {
+                if pr.at == Some((r, l + j)) {
+                    pr.hit = Some((rp.to_vec(), cp.to_vec()));
+                }
+                if let Some(cells) = pr.cells.as_mut() {
+                    cells.insert((r, l + j));
+                }
+            }
+            g.set(r, l + j, shown, ck.1, 0, data_fmt.get(*vi).cloned().flatten());
+        }
+    }
+    Ok(Output { width: g.width as u32, grid: g.rows, row_kinds: g.kinds, body_offset, chart_rows, chart_cols, label_col })
+}
diff --git a/crates/engine/src/pivot/items.rs b/crates/engine/src/pivot/items.rs
new file mode 100644
index 000000000..2877d0ef0
--- /dev/null
+++ b/crates/engine/src/pivot/items.rs
@@ -0,0 +1,268 @@
+use super::*;
+
+// ---------------------------------------------------------------- items
+
+#[derive(Clone, Debug)]
+pub(super) struct Item {
+    pub(super) value: Value,
+    pub(super) label: String,
+    class: u8,
+    num: f64,
+    text: String,
+    first: usize,
+    /// The value is a number shown with the source format.
+    pub(super) formatted: bool,
+}
+
+#[derive(Default)]
+pub(super) struct FieldItems {
+    items: Vec<Item>,
+    index: HashMap<String, u32>,
+}
+
+fn cmp_items(a: &Item, b: &Item) -> Ordering {
+    a.class.cmp(&b.class).then(a.num.total_cmp(&b.num)).then_with(|| a.text.cmp(&b.text))
+}
+
+/// (identity key, item) for a source value under a field's date grouping.
+fn make_item(wb: &Workbook, v: &Value, group: PivotDateGroup, fmt: &str, first: usize) -> (String, Item) {
+    let it = |value: Value, label: String, class: u8, num: f64, formatted: bool| Item {
+        text: label.to_lowercase(),
+        value,
+        label,
+        class,
+        num,
+        first,
+        formatted,
+    };
+    match v {
+        Value::Empty => ("b".into(), it(Value::text("(blank)"), "(blank)".into(), 4, 0.0, false)),
+        Value::Number(n) => {
+            if group != PivotDateGroup::None
+                && let Some(dt) = datetime_from_serial(wb.date_system, *n)
+            {
+                let mon = MONTHS.get(dt.month.saturating_sub(1) as usize).copied().unwrap_or("Jan");
+                let (label, key) = match group {
+                    PivotDateGroup::Years => (dt.year.to_string(), dt.year as f64),
+                    PivotDateGroup::Quarters => {
+                        let q = (dt.month.saturating_sub(1)) / 3 + 1;
+                        (format!("Qtr{q}"), q as f64)
+                    }
+                    PivotDateGroup::Months => (mon.to_string(), dt.month as f64),
+                    _ => (format!("{}-{mon}", dt.day), (dt.month * 100 + dt.day) as f64),
+                };
+                return (format!("g{key}"), it(Value::text(label.as_str()), label, 0, key, false));
+            }
+            let label = crate::display::format(v, fmt, wb).text;
+            (format!("n{}", n.to_bits()), it(v.clone(), label, 0, *n, true))
+        }
+        Value::Text(t) => (format!("t{}", t.to_lowercase()), it(v.clone(), t.to_string(), 1, 0.0, false)),
+        Value::Bool(b) => {
+            let l = if *b { "TRUE" } else { "FALSE" };
+            (format!("l{l}"), it(Value::Bool(*b), l.into(), 2, *b as u8 as f64, false))
+        }
+        Value::Error(e) => (format!("e{}", e.as_str()), it(v.clone(), e.as_str().into(), 3, 0.0, false)),
+        Value::Array(_) => make_item(wb, &v.scalar(), group, fmt, first),
+    }
+}
+
+impl FieldItems {
+    pub(super) fn intern(&mut self, wb: &Workbook, v: &Value, group: PivotDateGroup, fmt: &str, first: usize) -> u32 {
+        let (key, item) = make_item(wb, v, group, fmt, first);
+        if let Some(i) = self.index.get(&key) {
+            return *i;
+        }
+        let i = self.items.len() as u32;
+        self.items.push(item);
+        self.index.insert(key, i);
+        i
+    }
+    pub(super) fn get(&self, i: u32) -> Option<&Item> {
+        self.items.get(i as usize)
+    }
+    pub(super) fn label(&self, i: u32) -> String {
+        self.get(i).map(|x| x.label.clone()).unwrap_or_default()
+    }
+}
+
+/// The label of a source value under a date grouping (for filters and field lists).
+pub fn item_label(wb: &Workbook, v: &Value, group: PivotDateGroup, fmt: &str) -> String {
+    make_item(wb, v, group, fmt, 0).1.label
+}
+
+/// Distinct item labels of a source column, sorted like the field list shows them.
+pub fn distinct_labels(wb: &Workbook, src: &Source, col: usize, group: PivotDateGroup, limit: usize) -> Vec<String> {
+    let mut fi = FieldItems::default();
+    let fmt = src.formats.get(col).map(String::as_str).unwrap_or("General");
+    for (i, r) in src.rows.iter().enumerate() {
+        if let Some(v) = r.get(col) {
+            fi.intern(wb, v, group, fmt, i);
+        }
+        if fi.items.len() > 100_000 {
+            break;
+        }
+    }
+    let mut items = fi.items;
+    items.sort_by(cmp_items);
+    items.into_iter().take(limit).map(|i| i.label).collect()
+}
+
+// ---------------------------------------------------------------- aggregation
+
+#[derive(Clone, Debug, Default)]
+pub(super) struct Acc {
+    count: u64,
+    nums: u64,
+    sum: f64,
+    prod: f64,
+    min: f64,
+    max: f64,
+    mean: f64,
+    m2: f64,
+    err: Option<CellError>,
+}
+
+impl Acc {
+    pub(super) fn add(&mut self, v: &Value) {
+        match v {
+            Value::Empty => {}
+            Value::Number(n) => {
+                let n = *n;
+                self.count += 1;
+                self.nums += 1;
+                self.sum += n;
+                if self.nums == 1 {
+                    self.prod = n;
+                    self.min = n;
+                    self.max = n;
+                } else {
+                    self.prod *= n;
+                    self.min = self.min.min(n);
+                    self.max = self.max.max(n);
+                }
+                let d = n - self.mean;
+                self.mean += d / self.nums as f64;
+                self.m2 += d * (n - self.mean);
+            }
+            Value::Error(e) => {
+                self.count += 1;
+                if self.err.is_none() {
+                    self.err = Some(*e);
+                }
+            }
+            _ => self.count += 1,
+        }
+    }
+    pub(super) fn result(&self, f: PivotFunc) -> Value {
+        let n = self.nums as f64;
+        match f {
+            PivotFunc::Count => return Value::number(self.count as f64),
+            PivotFunc::CountNumbers => return Value::number(n),
+            _ => {}
+        }
+        if let Some(e) = self.err {
+            return Value::Error(e);
+        }
+        let div0 = Value::Error(CellError::Div0);
+        match f {
+            PivotFunc::Sum => Value::number(self.sum),
+            PivotFunc::Average => {
+                if self.nums == 0 {
+                    div0
+                } else {
+                    Value::number(self.sum / n)
+                }
+            }
+            PivotFunc::Max => Value::number(if self.nums == 0 { 0.0 } else { self.max }),
+            PivotFunc::Min => Value::number(if self.nums == 0 { 0.0 } else { self.min }),
+            PivotFunc::Product => Value::number(if self.nums == 0 { 0.0 } else { self.prod }),
+            PivotFunc::StdDev | PivotFunc::Var => {
+                if self.nums < 2 {
+                    div0
+                } else {
+                    let var = (self.m2 / (n - 1.0)).max(0.0);
+                    Value::number(if f == PivotFunc::Var { var } else { var.sqrt() })
+                }
+            }
+            PivotFunc::StdDevP | PivotFunc::VarP => {
+                if self.nums < 1 {
+                    div0
+                } else {
+                    let var = (self.m2 / n).max(0.0);
+                    Value::number(if f == PivotFunc::VarP { var } else { var.sqrt() })
+                }
+            }
+            PivotFunc::Count | PivotFunc::CountNumbers => Value::Empty,
+        }
+    }
+}
+
+/// Excel's caption verb for a function ("Sum of Sales").
+pub fn func_caption(f: PivotFunc) -> &'static str {
+    match f {
+        PivotFunc::Sum => "Sum",
+        PivotFunc::Count => "Count",
+        PivotFunc::Average => "Average",
+        PivotFunc::Max => "Max",
+        PivotFunc::Min => "Min",
+        PivotFunc::Product => "Product",
+        PivotFunc::CountNumbers => "Count Numbers",
+        PivotFunc::StdDev => "StdDev",
+        PivotFunc::StdDevP => "StdDevp",
+        PivotFunc::Var => "Var",
+        PivotFunc::VarP => "Varp",
+    }
+}
+
+// ---------------------------------------------------------------- trees
+
+#[derive(Clone, Debug)]
+pub(super) struct Node {
+    pub(super) item: u32,
+    pub(super) children: Vec<Node>,
+}
+
+pub(super) fn build_tree(paths: &[&[u32]], depth: usize, fields: &[&PivotField], items: &[FieldItems]) -> Vec<Node> {
+    let (Some(field), Some(fi)) = (fields.get(depth), items.get(depth)) else { return vec![] };
+    let mut order: Vec<u32> = Vec::new();
+    let mut groups: HashMap<u32, Vec<&[u32]>> = HashMap::new();
+    for p in paths {
+        if let Some(&it) = p.get(depth) {
+            let g = groups.entry(it).or_default();
+            if g.is_empty() {
+                order.push(it);
+            }
+            g.push(p);
+        }
+    }
+    let mut nodes: Vec<Node> = order
+        .into_iter()
+        .map(|it| {
+            let ps = groups.remove(&it).unwrap_or_default();
+            Node { item: it, children: build_tree(&ps, depth + 1, fields, items) }
+        })
+        .collect();
+    let by = |a: &Node, b: &Node| match (fi.get(a.item), fi.get(b.item)) {
+        (Some(x), Some(y)) => match field.sort {
+            PivotSort::Asc => cmp_items(x, y),
+            PivotSort::Desc => cmp_items(y, x),
+            PivotSort::None => x.first.cmp(&y.first),
+        },
+        _ => Ordering::Equal,
+    };
+    nodes.sort_by(by);
+    nodes
+}
+
+pub(super) fn is_collapsed(field: &PivotField, label: &str) -> bool {
+    field.collapsed_items.iter().any(|c| c.eq_ignore_ascii_case(label))
+}
+
+pub(super) fn collect_siblings(nodes: &[Node], prefix: &mut Vec<u32>, out: &mut HashMap<Vec<u32>, Vec<u32>>) {
+    out.insert(prefix.clone(), nodes.iter().map(|n| n.item).collect());
+    for n in nodes {
+        prefix.push(n.item);
+        collect_siblings(&n.children, prefix, out);
+        prefix.pop();
+    }
+}
diff --git a/crates/engine/src/pivot/output.rs b/crates/engine/src/pivot/output.rs
new file mode 100644
index 000000000..9dbf8836c
--- /dev/null
+++ b/crates/engine/src/pivot/output.rs
@@ -0,0 +1,437 @@
+use super::items::{Acc, FieldItems, Node, is_collapsed};
+use super::*;
+
+// ---------------------------------------------------------------- output
+
+/// What a report cell is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
+pub enum CellKind {
+    Empty,
+    Header,
+    RowLabel,
+    ColLabel,
+    Data,
+    Subtotal,
+    GrandTotal,
+    Filter,
+    Placeholder,
+}
+
+/// What a report row is (for row-wide styling).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
+pub enum RowKind {
+    Filter,
+    Blank,
+    Header,
+    /// Item row; `true` for a parent item (bold).
+    Item(bool),
+    Subtotal,
+    Grand,
+    Placeholder,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct OutCell {
+    pub value: Value,
+    pub kind: CellKind,
+    pub indent: u8,
+    pub num_fmt: Option<String>,
+}
+
+impl OutCell {
+    fn empty() -> OutCell {
+        OutCell { value: Value::Empty, kind: CellKind::Empty, indent: 0, num_fmt: None }
+    }
+}
+
+/// A computed report: a dense grid relative to its top-left, with row kinds.
+#[derive(Clone, Debug)]
+pub struct Output {
+    pub grid: Vec<Vec<OutCell>>,
+    pub row_kinds: Vec<RowKind>,
+    /// Rows above the body (report filters plus a blank row).
+    pub body_offset: u32,
+    pub width: u32,
+    /// Grid rows of the innermost (or collapsed) items: a PivotChart's categories.
+    pub chart_rows: Vec<u32>,
+    /// Grid columns of item (not total) values with their series names: a PivotChart's series.
+    pub chart_cols: Vec<(u32, String)>,
+    /// Grid column holding the innermost row labels (`None` without row fields).
+    pub label_col: Option<u32>,
+}
+
+impl Output {
+    pub fn height(&self) -> u32 {
+        self.grid.len() as u32
+    }
+    /// Value at (row, col) relative to the top-left.
+    pub fn value(&self, r: usize, c: usize) -> Value {
+        self.grid.get(r).and_then(|row| row.get(c)).map(|x| x.value.clone()).unwrap_or_default()
+    }
+}
+
+pub(super) struct Grid {
+    pub(super) rows: Vec<Vec<OutCell>>,
+    pub(super) kinds: Vec<RowKind>,
+    pub(super) width: usize,
+}
+
+impl Grid {
+    pub(super) fn push_row(&mut self, kind: RowKind) -> Result<usize, String> {
+        if (self.rows.len() as u64 + 1) * self.width.max(1) as u64 > MAX_OUTPUT_CELLS || self.rows.len() as u64 >= MAX_ROWS as u64 {
+            return Err("The PivotTable report is too large.".into());
+        }
+        self.rows.push(vec![OutCell::empty(); self.width]);
+        self.kinds.push(kind);
+        Ok(self.rows.len() - 1)
+    }
+    pub(super) fn set(&mut self, r: usize, c: usize, value: Value, kind: CellKind, indent: u8, fmt: Option<String>) {
+        if let Some(cell) = self.rows.get_mut(r).and_then(|row| row.get_mut(c)) {
+            *cell = OutCell { value, kind, indent, num_fmt: fmt };
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum LineKind {
+    Item(bool),
+    Subtotal,
+    Grand,
+}
+
+pub(super) struct Line {
+    pub(super) kind: LineKind,
+    /// A category of a PivotChart: an innermost (or collapsed) item.
+    pub(super) leaf: bool,
+    pub(super) path: Vec<u32>,
+    pub(super) values: bool,
+    /// (column, value, indent, number format)
+    pub(super) labels: Vec<(usize, Value, u8, Option<String>)>,
+    /// The value field of the line when Σ Values sits in Rows (`None`: one per data column).
+    pub(super) vi: Option<usize>,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum ColKind {
+    Leaf,
+    Subtotal,
+    Grand,
+}
+
+pub(super) struct ColSpec {
+    pub(super) kind: ColKind,
+    pub(super) path: Vec<u32>,
+}
+
+pub(super) struct Ctx<'a> {
+    pub(super) pt: &'a PivotTable,
+    pub(super) rows: Vec<&'a PivotField>,
+    pub(super) row_items: Vec<FieldItems>,
+    pub(super) row_fmts: Vec<String>,
+    /// Depth of Σ Values among the row fields when it sits in Rows (two or more value fields).
+    pub(super) vpos: Option<usize>,
+    /// Value field captions.
+    pub(super) val_names: Vec<String>,
+}
+
+impl Ctx<'_> {
+    fn label_cell(&self, depth: usize, item: u32) -> (Value, Option<String>, String) {
+        let Some(it) = self.row_items.get(depth).and_then(|fi| fi.get(item)) else { return (Value::Empty, None, String::new()) };
+        let fmt = if it.formatted { self.row_fmts.get(depth).cloned() } else { None };
+        (it.value.clone(), fmt, it.label.clone())
+    }
+
+    /// (column, indent) of a row level (Σ Values counts as a level) in Compact/Outline form.
+    fn level_cell(&self, level: usize) -> (usize, u8) {
+        if self.pt.layout == PivotLayout::Outline { (level, 0) } else { (0, level.min(250) as u8) }
+    }
+
+    /// Σ Values comes right here, at row field depth `depth` (`vi`: the value field already chosen above).
+    fn values_here(&self, depth: usize, vi: Option<usize>) -> bool {
+        vi.is_none() && self.vpos == Some(depth)
+    }
+
+    /// Per-value subtotal lines of an item with Σ Values below it ("East Sum of Sales").
+    fn value_subtotals(&self, col: usize, indent: u8, label: &str, prefix: &[u32], out: &mut Vec<Line>) {
+        for (vi, name) in self.val_names.iter().enumerate() {
+            out.push(Line {
+                kind: LineKind::Subtotal,
+                leaf: false,
+                path: prefix.to_vec(),
+                values: true,
+                labels: vec![(col, Value::text(format!("{label} {name}")), indent, None)],
+                vi: Some(vi),
+            });
+        }
+    }
+
+    /// The Σ Values level at row field depth `depth`: one item per value field, each followed by
+    /// the row fields below it (`nodes`) or, innermost, holding that value.
+    fn flatten_values(&self, nodes: &[Node], depth: usize, prefix: &mut Vec<u32>, out: &mut Vec<Line>) {
+        let (col, indent) = self.level_cell(depth);
+        for (vi, name) in self.val_names.iter().enumerate() {
+            let labels = vec![(col, Value::text(name.as_str()), indent, None)];
+            let leaf = nodes.is_empty();
+            out.push(Line { kind: LineKind::Item(!leaf), leaf, path: prefix.clone(), values: leaf, labels, vi: Some(vi) });
+            if !leaf {
+                self.flatten(nodes, depth, Some(vi), prefix, out);
+            }
+        }
+    }
+
+    pub(super) fn flatten(&self, nodes: &[Node], depth: usize, vi: Option<usize>, prefix: &mut Vec<u32>, out: &mut Vec<Line>) {
+        if self.values_here(depth, vi) {
+            self.flatten_values(nodes, depth, prefix, out);
+            return;
+        }
+        let n = self.rows.len();
+        // Σ Values still to come below this level: totals need one line per value field.
+        let values_below = vi.is_none() && self.vpos.is_some();
+        let (col, indent) = self.level_cell(depth + usize::from(vi.is_some() && self.vpos.is_some()));
+        for node in nodes {
+            prefix.push(node.item);
+            let (v, fmt, label) = self.label_cell(depth, node.item);
+            let collapsed = depth + 1 < n && self.rows.get(depth).is_some_and(|f| is_collapsed(f, &label));
+            let leaf = depth + 1 >= n || collapsed || node.children.is_empty();
+            if leaf && !values_below {
+                out.push(Line {
+                    kind: LineKind::Item(depth + 1 < n),
+                    leaf: true,
+                    path: prefix.clone(),
+                    values: true,
+                    labels: vec![(col, v, indent, fmt)],
+                    vi,
+                });
+            } else if leaf {
+                out.push(Line {
+                    kind: LineKind::Item(true),
+                    leaf: false,
+                    path: prefix.clone(),
+                    values: false,
+                    labels: vec![(col, v, indent, fmt)],
+                    vi,
+                });
+                // Outline gives each level its own column, so the captions go in the Values
+                // column even when the levels between are collapsed away.
+                let level = if self.pt.layout == PivotLayout::Outline { self.vpos.unwrap_or(depth + 1) } else { depth + 1 };
+                self.flatten_values(&[], level, prefix, out);
+            } else if values_below {
+                // Subtotals per value field, below the group (one line can't hold them all).
+                out.push(Line {
+                    kind: LineKind::Item(true),
+                    leaf: false,
+                    path: prefix.clone(),
+                    values: false,
+                    labels: vec![(col, v, indent, fmt)],
+                    vi,
+                });
+                self.flatten(&node.children, depth + 1, None, prefix, out);
+                if self.pt.subtotals {
+                    self.value_subtotals(col, indent, &label, prefix, out);
+                }
+            } else {
+                let top = self.pt.subtotals && self.pt.subtotals_top;
+                out.push(Line {
+                    kind: LineKind::Item(true),
+                    leaf: false,
+                    path: prefix.clone(),
+                    values: top,
+                    labels: vec![(col, v, indent, fmt)],
+                    vi,
+                });
+                self.flatten(&node.children, depth + 1, vi, prefix, out);
+                if self.pt.subtotals && !self.pt.subtotals_top {
+                    out.push(Line {
+                        kind: LineKind::Subtotal,
+                        leaf: false,
+                        path: prefix.clone(),
+                        values: true,
+                        labels: vec![(col, Value::text(format!("{label} Total")), indent, None)],
+                        vi,
+                    });
+                }
+            }
+            prefix.pop();
+        }
+    }
+
+    /// Tabular form of [`Self::flatten_values`]: the first line also carries the parents' labels.
+    fn flatten_tabular_values(
+        &self,
+        nodes: &[Node],
+        depth: usize,
+        prefix: &mut Vec<u32>,
+        pending: &[(usize, Value, u8, Option<String>)],
+        out: &mut Vec<Line>,
+    ) {
+        for (vi, name) in self.val_names.iter().enumerate() {
+            let mut labels: Vec<(usize, Value, u8, Option<String>)> = if vi == 0 { pending.to_vec() } else { vec![] };
+            labels.push((depth, Value::text(name.as_str()), 0, None));
+            if nodes.is_empty() {
+                out.push(Line { kind: LineKind::Item(false), leaf: true, path: prefix.clone(), values: true, labels, vi: Some(vi) });
+            } else {
+                self.flatten_tabular(nodes, depth, Some(vi), prefix, &labels, out);
+            }
+        }
+    }
+
+    pub(super) fn flatten_tabular(
+        &self,
+        nodes: &[Node],
+        depth: usize,
+        vi: Option<usize>,
+        prefix: &mut Vec<u32>,
+        pending: &[(usize, Value, u8, Option<String>)],
+        out: &mut Vec<Line>,
+    ) {
+        if self.values_here(depth, vi) {
+            self.flatten_tabular_values(nodes, depth, prefix, pending, out);
+            return;
+        }
+        let n = self.rows.len();
+        let values_below = vi.is_none() && self.vpos.is_some();
+        let col = depth + usize::from(vi.is_some() && self.vpos.is_some());
+        for (i, node) in nodes.iter().enumerate() {
+            prefix.push(node.item);
+            let (v, fmt, label) = self.label_cell(depth, node.item);
+            let mut labels: Vec<(usize, Value, u8, Option<String>)> = if i == 0 { pending.to_vec() } else { vec![] };
+            labels.push((col, v, 0, fmt));
+            let collapsed = depth + 1 < n && self.rows.get(depth).is_some_and(|f| is_collapsed(f, &label));
+            if depth + 1 >= n || collapsed || node.children.is_empty() {
+                if values_below {
+                    self.flatten_tabular_values(&[], self.vpos.unwrap_or(depth + 1), prefix, &labels, out);
+                } else {
+                    out.push(Line { kind: LineKind::Item(false), leaf: true, path: prefix.clone(), values: true, labels, vi });
+                }
+            } else {
+                self.flatten_tabular(&node.children, depth + 1, vi, prefix, &labels, out);
+                if self.pt.subtotals && values_below {
+                    self.value_subtotals(col, 0, &label, prefix, out);
+                } else if self.pt.subtotals {
+                    out.push(Line {
+                        kind: LineKind::Subtotal,
+                        leaf: false,
+                        path: prefix.clone(),
+                        values: true,
+                        labels: vec![(col, Value::text(format!("{label} Total")), 0, None)],
+                        vi,
+                    });
+                }
+            }
+            prefix.pop();
+        }
+    }
+}
+
+pub(super) fn flatten_cols(
+    nodes: &[Node],
+    depth: usize,
+    fields: &[&PivotField],
+    items: &[FieldItems],
+    subtotals: bool,
+    prefix: &mut Vec<u32>,
+    out: &mut Vec<ColSpec>,
+) {
+    let n = fields.len();
+    for node in nodes {
+        prefix.push(node.item);
+        let label = items.get(depth).map(|fi| fi.label(node.item)).unwrap_or_default();
+        let collapsed = depth + 1 < n && fields.get(depth).is_some_and(|f| is_collapsed(f, &label));
+        if depth + 1 >= n || collapsed || node.children.is_empty() {
+            out.push(ColSpec { kind: ColKind::Leaf, path: prefix.clone() });
+        } else {
+            flatten_cols(&node.children, depth + 1, fields, items, subtotals, prefix, out);
+            if subtotals {
+                out.push(ColSpec { kind: ColKind::Subtotal, path: prefix.clone() });
+            }
+        }
+        prefix.pop();
+    }
+}
+
+pub(super) type AggMap = HashMap<(Vec<u32>, Vec<u32>), Vec<Acc>>;
+
+/// Where a value field's numbers come from.
+#[derive(Clone, Copy)]
+pub(super) enum ValSrc {
+    /// A source column.
+    Col(usize),
+    /// A calculated field (index into the PivotTable's calculated fields).
+    Calc(usize),
+}
+
+/// True when `col_groups` distinct column leaves (plus the grand-total column) times `values` value fields
+/// (at least one data column per group) already exceed the sheet width. This is a lower bound on the final column count.
+pub(super) fn data_cols_exceed_sheet(col_groups: usize, grand_total: bool, values: usize) -> bool {
+    (col_groups + usize::from(grand_total)).saturating_mul(values.max(1)) > MAX_COLS as usize
+}
+
+// ---------------------------------------------------------------- styling and writing
+
+/// Colours for a PivotTable style name (our own palette, keyed by the familiar
+/// `PivotStyleLight1…28 / Medium1…28 / Dark1…28` names).
+pub(super) struct Look {
+    header_fill: Color,
+    header_font: Color,
+    line: Color,
+    filter_fill: Color,
+}
+
+pub(super) fn look(style: &str) -> Look {
+    let rest = style.strip_prefix("PivotStyle").unwrap_or(style);
+    let (fam, n) = ["Light", "Medium", "Dark"]
+        .iter()
+        .find_map(|f| rest.strip_prefix(f).map(|num| (*f, num.parse::<u32>().unwrap_or(16))))
+        .unwrap_or(("Light", 16));
+    let k = n.saturating_sub(1) % 7;
+    let acc = if k == 0 { None } else { Some(3 + k as u8) };
+    let tone = |tint: i16| match acc {
+        Some(a) => Color::Theme(a, tint),
+        None => Color::Theme(1, tint.clamp(-1000, 1000)),
+    };
+    match fam {
+        "Dark" => Look { header_fill: Color::Theme(1, 0), header_font: Color::Theme(0, 0), line: tone(0), filter_fill: tone(600) },
+        "Medium" => Look { header_fill: tone(0), header_font: Color::Theme(0, 0), line: tone(0), filter_fill: tone(800) },
+        _ => Look { header_fill: tone(800), header_font: Color::Auto, line: tone(400), filter_fill: tone(800) },
+    }
+}
+
+pub(super) fn cell_style(lk: &Look, rk: RowKind, cell: &OutCell, last_header: bool) -> Style {
+    let mut s = Style::default();
+    match rk {
+        RowKind::Header => {
+            s.font.bold = true;
+            s.fill = Fill::solid(lk.header_fill);
+            s.font.color = lk.header_font;
+            if last_header {
+                s.borders.bottom = BorderLine { style: BorderStyle::Thin, color: lk.line };
+            }
+        }
+        RowKind::Filter => {
+            s.fill = Fill::solid(lk.filter_fill);
+            s.font.bold = last_header;
+        }
+        RowKind::Item(parent) => s.font.bold = parent,
+        RowKind::Subtotal => s.font.bold = true,
+        RowKind::Grand => {
+            s.font.bold = true;
+            s.borders.top = BorderLine { style: BorderStyle::Thin, color: lk.line };
+        }
+        RowKind::Placeholder => {
+            s.font.italic = true;
+            s.font.color = Color::Theme(1, 500);
+        }
+        RowKind::Blank => {}
+    }
+    if matches!(cell.kind, CellKind::RowLabel | CellKind::ColLabel | CellKind::Subtotal | CellKind::GrandTotal) && !cell.value.is_number() {
+        s.align.h = HAlign::Left;
+    }
+    if matches!(cell.kind, CellKind::RowLabel | CellKind::ColLabel) && cell.value.is_number() {
+        s.align.h = HAlign::Left;
+    }
+    s.align.indent = cell.indent.min(15);
+    if let Some(f) = &cell.num_fmt {
+        s.num_fmt = NumFmt::new(f);
+    }
+    s
+}

From 1ff44e5ba2a177907ecec5a3397cc7dfca79a7d3 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:34:54 +0000
Subject: [PATCH 58/76] refactor(functions): move stat.rs items to stat/

---
 crates/functions/src/stat.rs               | 1605 +-------------------
 crates/functions/src/stat/descriptive.rs   |  547 +++++++
 crates/functions/src/stat/distributions.rs |  702 +++++++++
 crates/functions/src/stat/regression.rs    |  342 +++++
 4 files changed, 1611 insertions(+), 1585 deletions(-)
 create mode 100644 crates/functions/src/stat/descriptive.rs
 create mode 100644 crates/functions/src/stat/distributions.rs
 create mode 100644 crates/functions/src/stat/regression.rs

diff --git a/crates/functions/src/stat.rs b/crates/functions/src/stat.rs
index 554b75271..270bd2373 100644
--- a/crates/functions/src/stat.rs
+++ b/crates/functions/src/stat.rs
@@ -7,1593 +7,28 @@ use crate::special::{erf, gamma, invert, ln_beta, ln_gamma, norm_cdf, norm_inv,
 use crate::util::{A, R, S, arg, array_numbers, array_val, as_array, boolean, has, num, num_val, numbers, numbers_a, opt_num};
 use crate::{Arg, Ctx, FnSpec, VAR};
 
+mod descriptive;
+mod distributions;
+mod regression;
+
+pub use descriptive::{aggregate_values, aggregate_values_k};
+use descriptive::{
+    arg_nums, arg_pairs, avedev, correl, count_impl, counta_impl, countblank, devsq, frequency, geomean, harmean, intercept, kurt, large, max_of,
+    mean, median, min_of, mode_mult, mode_numbers, mode_sngl, percentile_exc, percentile_inc, percentrank_impl, prob, quartile_exc, quartile_inc,
+    rank_impl, skew, skew_p, slope, small, standardize, trimmean, var_p, var_s,
+};
+use distributions::{
+    beta_dist, beta_inv, betadist_legacy, binom_dist, binom_dist_range, binom_inv, chisq_dist, chisq_dist_rt, chisq_inv, chisq_inv_rt, chisq_test,
+    confidence_norm, confidence_t, expon_dist, f_dist, f_dist_rt, f_inv, f_inv_rt, f_test, fisher, gamma_dist, gamma_fn, gamma_inv, gammaln, gauss,
+    hypgeom_dist, lognorm_dist, lognorm_inv, negbinom_dist, norm_dist, norm_inv_fn, norm_s_dist, norm_s_inv, poisson_dist, t_dist, t_dist_2t,
+    t_dist_rt, t_inv, t_inv_2t, t_test, tdist_legacy, weibull_dist, z_test,
+};
+#[cfg(test)]
+use regression::{MAX_REGRESSORS, check_regression_size};
+use regression::{covariance, forecast, linest_impl, steyx, trend_impl};
+
 type C<'a> = &'a mut dyn Ctx;
 
-// ---------------------------------------------------------------------------------------------
-// Basic helpers over number lists
-// ---------------------------------------------------------------------------------------------
-
-fn mean(x: &[f64]) -> R<f64> {
-    if x.is_empty() {
-        return Err(CellError::Div0);
-    }
-    Ok(x.iter().sum::<f64>() / x.len() as f64)
-}
-
-fn devsq(x: &[f64]) -> f64 {
-    if x.is_empty() {
-        return 0.0;
-    }
-    let m = x.iter().sum::<f64>() / x.len() as f64;
-    x.iter().map(|v| (v - m) * (v - m)).sum()
-}
-
-fn var_s(x: &[f64]) -> R<f64> {
-    if x.len() < 2 {
-        return Err(CellError::Div0);
-    }
-    Ok(devsq(x) / (x.len() - 1) as f64)
-}
-
-fn var_p(x: &[f64]) -> R<f64> {
-    if x.is_empty() {
-        return Err(CellError::Div0);
-    }
-    Ok(devsq(x) / x.len() as f64)
-}
-
-fn sorted(mut v: Vec<f64>) -> Vec<f64> {
-    v.sort_by(f64::total_cmp);
-    v
-}
-
-fn median(v: Vec<f64>) -> R<f64> {
-    if v.is_empty() {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    let n = s.len();
-    let hi = s.get(n / 2).copied().unwrap_or(0.0);
-    if n % 2 == 1 { Ok(hi) } else { Ok(s.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) }
-}
-
-/// Values occurring at least twice, ordered by first occurrence, with their (equal, maximal) count.
-fn modes(v: &[f64]) -> Vec<f64> {
-    let mut counts: Vec<(f64, usize)> = Vec::new();
-    for &x in v {
-        if let Some(e) = counts.iter_mut().find(|e| e.0 == x) {
-            e.1 += 1;
-        } else {
-            counts.push((x, 1));
-        }
-    }
-    let best = counts.iter().map(|e| e.1).max().unwrap_or(0);
-    if best < 2 {
-        return Vec::new();
-    }
-    counts.into_iter().filter(|e| e.1 == best).map(|e| e.0).collect()
-}
-
-fn mode_sngl(v: &[f64]) -> R<f64> {
-    modes(v).first().copied().ok_or(CellError::NA)
-}
-
-/// Numbers for MODE / MODE.SNGL / MODE.MULT. Inside multi-cell ranges and arrays only numbers
-/// count, like [`numbers`]. Scalar arguments differ from SUM: in Excel 365, text and logical
-/// values are skipped whether typed or referenced (even numeric text such as `"1"`, so
-/// `MODE(1,"1",2,3)` is `#N/A`, and `MODE(1,TRUE,TRUE,2)` is `#N/A`), but a single-cell reference
-/// to a blank cell is `#VALUE!` (`MODE(B9,2,D7)` with D7 blank). Arguments are processed left to
-/// right, so the first error wins. The results cached in POI's FormulaEvalTestData come from an
-/// older Excel that answered `#VALUE!` for typed text; they are not the reference here.
-fn mode_numbers(args: &[Arg]) -> R<Vec<f64>> {
-    let mut out = Vec::new();
-    for a in args {
-        match &a.value {
-            Value::Array(arr) => {
-                for v in arr.iter() {
-                    match v {
-                        Value::Number(n) => out.push(*n),
-                        Value::Error(e) => return Err(*e),
-                        _ => {}
-                    }
-                }
-            }
-            Value::Number(n) => out.push(*n),
-            Value::Error(e) => return Err(*e),
-            Value::Text(_) | Value::Bool(_) => {}
-            Value::Empty => return Err(CellError::Value),
-        }
-    }
-    Ok(out)
-}
-
-fn product(v: &[f64]) -> f64 {
-    if v.is_empty() { 0.0 } else { v.iter().product() }
-}
-
-fn min_of(v: &[f64]) -> f64 {
-    if v.is_empty() { 0.0 } else { v.iter().copied().fold(f64::INFINITY, f64::min) }
-}
-
-fn max_of(v: &[f64]) -> f64 {
-    if v.is_empty() { 0.0 } else { v.iter().copied().fold(f64::NEG_INFINITY, f64::max) }
-}
-
-/// k-th largest (k is rounded up like Excel).
-fn kth(v: Vec<f64>, k: f64, largest: bool) -> R<f64> {
-    let k = k.ceil();
-    if k.is_nan() || k < 1.0 || k > v.len() as f64 {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    let k = k as usize;
-    let idx = if largest { s.len() - k } else { k - 1 };
-    s.get(idx).copied().ok_or(CellError::Num)
-}
-
-fn interp(s: &[f64], pos: f64) -> R<f64> {
-    let i = pos.floor();
-    let frac = pos - i;
-    let i = i as usize;
-    let lo = *s.get(i).ok_or(CellError::Num)?;
-    match s.get(i + 1) {
-        Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)),
-        _ => Ok(lo),
-    }
-}
-
-fn percentile_inc(v: Vec<f64>, k: f64) -> R<f64> {
-    if v.is_empty() || !(0.0..=1.0).contains(&k) {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    interp(&s, k * (s.len() - 1) as f64)
-}
-
-fn percentile_exc(v: Vec<f64>, k: f64) -> R<f64> {
-    let n = v.len() as f64;
-    if v.is_empty() || !(k > 0.0 && k < 1.0) {
-        return Err(CellError::Num);
-    }
-    let pos = k * (n + 1.0);
-    if pos < 1.0 || pos > n {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    interp(&s, pos - 1.0)
-}
-
-fn quartile_inc(v: Vec<f64>, q: f64) -> R<f64> {
-    let q = q.trunc();
-    if !(0.0..=4.0).contains(&q) {
-        return Err(CellError::Num);
-    }
-    percentile_inc(v, q / 4.0)
-}
-
-fn quartile_exc(v: Vec<f64>, q: f64) -> R<f64> {
-    let q = q.trunc();
-    if !(1.0..=3.0).contains(&q) {
-        return Err(CellError::Num);
-    }
-    percentile_exc(v, q / 4.0)
-}
-
-fn arg_nums(a: &[Arg], i: usize) -> R<Vec<f64>> {
-    array_numbers(&arg(a, i)?.value)
-}
-
-/// Pairs of numbers at matching positions of two arrays (pairs with a non-number skipped).
-/// Different sizes give `#N/A`; errors propagate.
-fn pairs(x: &Value, y: &Value) -> R<(Vec<f64>, Vec<f64>)> {
-    let xa = as_array(x);
-    let ya = as_array(y);
-    if xa.data.len() != ya.data.len() {
-        return Err(CellError::NA);
-    }
-    let mut xs = Vec::new();
-    let mut ys = Vec::new();
-    for (a, b) in xa.data.iter().zip(ya.data.iter()) {
-        if let Value::Error(e) = a {
-            return Err(*e);
-        }
-        if let Value::Error(e) = b {
-            return Err(*e);
-        }
-        if let (Value::Number(p), Value::Number(q)) = (a, b) {
-            xs.push(*p);
-            ys.push(*q);
-        }
-    }
-    Ok((xs, ys))
-}
-
-fn arg_pairs(a: &[Arg], i: usize, j: usize) -> R<(Vec<f64>, Vec<f64>)> {
-    pairs(&arg(a, i)?.value, &arg(a, j)?.value)
-}
-
-/// (sum of cross deviations, devsq x, devsq y, mean x, mean y).
-fn moments(x: &[f64], y: &[f64]) -> R<(f64, f64, f64, f64, f64)> {
-    let mx = mean(x)?;
-    let my = mean(y)?;
-    let mut sxy = 0.0;
-    let mut sxx = 0.0;
-    let mut syy = 0.0;
-    for (a, b) in x.iter().zip(y) {
-        sxy += (a - mx) * (b - my);
-        sxx += (a - mx) * (a - mx);
-        syy += (b - my) * (b - my);
-    }
-    Ok((sxy, sxx, syy, mx, my))
-}
-
-fn correl(x: &[f64], y: &[f64]) -> R<f64> {
-    if x.len() < 2 {
-        return Err(CellError::Div0);
-    }
-    let (sxy, sxx, syy, _, _) = moments(x, y)?;
-    if sxx == 0.0 || syy == 0.0 {
-        return Err(CellError::Div0);
-    }
-    Ok(sxy / (sxx * syy).sqrt())
-}
-
-fn slope(y: &[f64], x: &[f64]) -> R<f64> {
-    let (sxy, sxx, _, _, _) = moments(x, y)?;
-    if sxx == 0.0 {
-        return Err(CellError::Div0);
-    }
-    Ok(sxy / sxx)
-}
-
-fn intercept(y: &[f64], x: &[f64]) -> R<f64> {
-    let (sxy, sxx, _, mx, my) = moments(x, y)?;
-    if sxx == 0.0 {
-        return Err(CellError::Div0);
-    }
-    Ok(my - sxy / sxx * mx)
-}
-
-fn trunc_digits(r: f64, sig: f64) -> f64 {
-    let f = 10f64.powi(sig as i32);
-    if !f.is_finite() {
-        return r;
-    }
-    ((r * f) + 1e-9).floor() / f
-}
-
-fn col_value(v: Vec<f64>) -> R<Value> {
-    let n = v.len();
-    array_val(n, 1, v.into_iter().map(Value::Number).collect())
-}
-
-// ---------------------------------------------------------------------------------------------
-// Aggregates
-// ---------------------------------------------------------------------------------------------
-
-fn count_impl(a: &[Arg]) -> f64 {
-    let mut c = 0usize;
-    for x in a {
-        match &x.value {
-            Value::Array(arr) => c += arr.iter().filter(|v| v.is_number()).count(),
-            Value::Number(_) => c += 1,
-            _ if x.from_ref => {}
-            Value::Bool(_) => c += 1,
-            Value::Text(t) if gridcraft_core::parse::parse_number_text(t).is_some() => c += 1,
-            _ => {}
-        }
-    }
-    c as f64
-}
-
-fn counta_impl(a: &[Arg]) -> f64 {
-    let mut c = 0usize;
-    for x in a {
-        match &x.value {
-            Value::Array(arr) => c += arr.iter().filter(|v| !v.is_empty()).count(),
-            Value::Empty if x.from_ref => {}
-            _ => c += 1,
-        }
-    }
-    c as f64
-}
-
-fn countblank(a: &[Arg], _: C) -> R<Value> {
-    let v = &arg(a, 0)?.value;
-    let blank = |x: &Value| matches!(x, Value::Empty) || matches!(x, Value::Text(t) if t.is_empty());
-    let c = match v {
-        Value::Array(arr) => arr.iter().filter(|x| blank(x)).count(),
-        x => usize::from(blank(x)),
-    };
-    num_val(c as f64)
-}
-
-fn mode_mult(a: &[Arg], _: C) -> R<Value> {
-    let v = mode_numbers(a)?;
-    let m = modes(&v);
-    if m.is_empty() {
-        return Err(CellError::NA);
-    }
-    col_value(m)
-}
-
-fn large(a: &[Arg], _: C) -> R<Value> {
-    num_val(kth(arg_nums(a, 0)?, num(a, 1)?, true)?)
-}
-
-fn small(a: &[Arg], _: C) -> R<Value> {
-    num_val(kth(arg_nums(a, 0)?, num(a, 1)?, false)?)
-}
-
-fn rank_impl(a: &[Arg], avg: bool) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = arg_nums(a, 1)?;
-    let asc = opt_num(a, 2, 0.0)? != 0.0;
-    let eq = v.iter().filter(|&&y| y == x).count();
-    if eq == 0 {
-        return Err(CellError::NA);
-    }
-    let before = v.iter().filter(|&&y| if asc { y < x } else { y > x }).count();
-    let r = before as f64 + 1.0;
-    num_val(if avg { r + (eq as f64 - 1.0) / 2.0 } else { r })
-}
-
-fn percentrank_impl(a: &[Arg], exc: bool) -> R<Value> {
-    let s = sorted(arg_nums(a, 0)?);
-    let x = num(a, 1)?;
-    let sig = opt_num(a, 2, 3.0)?.trunc();
-    if sig < 1.0 || s.is_empty() {
-        return Err(CellError::Num);
-    }
-    let (first, last) = (s.first().copied().unwrap_or(0.0), s.last().copied().unwrap_or(0.0));
-    if x < first || x > last {
-        return Err(CellError::NA);
-    }
-    let n = s.len() as f64;
-    let rank_of = |v: f64| -> f64 {
-        let less = s.iter().filter(|&&y| y < v).count() as f64;
-        if exc {
-            (less + 1.0) / (n + 1.0)
-        } else if n <= 1.0 {
-            1.0
-        } else {
-            less / (n - 1.0)
-        }
-    };
-    let r = if s.contains(&x) {
-        rank_of(x)
-    } else {
-        let lo = s.iter().copied().filter(|&y| y < x).fold(f64::NEG_INFINITY, f64::max);
-        let hi = s.iter().copied().filter(|&y| y > x).fold(f64::INFINITY, f64::min);
-        let (rl, rh) = (rank_of(lo), rank_of(hi));
-        rl + (x - lo) / (hi - lo) * (rh - rl)
-    };
-    num_val(trunc_digits(r, sig))
-}
-
-fn trimmean(a: &[Arg], _: C) -> R<Value> {
-    let v = arg_nums(a, 0)?;
-    let p = num(a, 1)?;
-    if !(0.0..1.0).contains(&p) || v.is_empty() {
-        return Err(CellError::Num);
-    }
-    let n = v.len();
-    let per_side = ((n as f64 * p) / 2.0).floor() as usize;
-    let s = sorted(v);
-    let kept = s.get(per_side..n - per_side).unwrap_or(&[]);
-    num_val(mean(kept)?)
-}
-
-fn kurt(v: &[f64]) -> R<f64> {
-    let n = v.len() as f64;
-    if v.len() < 4 {
-        return Err(CellError::Div0);
-    }
-    let m = mean(v)?;
-    let s = var_s(v)?.sqrt();
-    if s == 0.0 {
-        return Err(CellError::Div0);
-    }
-    let sum4: f64 = v.iter().map(|x| ((x - m) / s).powi(4)).sum();
-    Ok(n * (n + 1.0) / ((n - 1.0) * (n - 2.0) * (n - 3.0)) * sum4 - 3.0 * (n - 1.0).powi(2) / ((n - 2.0) * (n - 3.0)))
-}
-
-fn skew(v: &[f64]) -> R<f64> {
-    let n = v.len() as f64;
-    if v.len() < 3 {
-        return Err(CellError::Div0);
-    }
-    let m = mean(v)?;
-    let s = var_s(v)?.sqrt();
-    if s == 0.0 {
-        return Err(CellError::Div0);
-    }
-    let sum3: f64 = v.iter().map(|x| ((x - m) / s).powi(3)).sum();
-    Ok(n / ((n - 1.0) * (n - 2.0)) * sum3)
-}
-
-fn skew_p(v: &[f64]) -> R<f64> {
-    let m = mean(v)?;
-    let s = var_p(v)?.sqrt();
-    if s == 0.0 {
-        return Err(CellError::Div0);
-    }
-    Ok(v.iter().map(|x| ((x - m) / s).powi(3)).sum::<f64>() / v.len() as f64)
-}
-
-fn geomean(v: &[f64]) -> R<f64> {
-    if v.is_empty() || v.iter().any(|&x| x <= 0.0) {
-        return Err(CellError::Num);
-    }
-    Ok((v.iter().map(|x| x.ln()).sum::<f64>() / v.len() as f64).exp())
-}
-
-fn harmean(v: &[f64]) -> R<f64> {
-    if v.is_empty() || v.iter().any(|&x| x <= 0.0) {
-        return Err(CellError::Num);
-    }
-    Ok(v.len() as f64 / v.iter().map(|x| 1.0 / x).sum::<f64>())
-}
-
-fn avedev(v: &[f64]) -> R<f64> {
-    if v.is_empty() {
-        return Err(CellError::Num);
-    }
-    let m = mean(v)?;
-    Ok(v.iter().map(|x| (x - m).abs()).sum::<f64>() / v.len() as f64)
-}
-
-fn frequency(a: &[Arg], _: C) -> R<Value> {
-    let data = arg_nums(a, 0)?;
-    let bins = arg_nums(a, 1)?;
-    if bins.is_empty() {
-        return col_value(vec![data.len() as f64]);
-    }
-    let mut order: Vec<usize> = (0..bins.len()).collect();
-    order.sort_by(|&i, &j| bins.get(i).copied().unwrap_or(0.0).total_cmp(&bins.get(j).copied().unwrap_or(0.0)));
-    let mut counts = vec![0.0; bins.len() + 1];
-    for x in data {
-        let slot = order.iter().find(|&&i| x <= bins.get(i).copied().unwrap_or(f64::INFINITY)).copied().unwrap_or(bins.len());
-        if let Some(c) = counts.get_mut(slot) {
-            *c += 1.0;
-        }
-    }
-    col_value(counts)
-}
-
-fn prob(a: &[Arg], _: C) -> R<Value> {
-    let (xs, ps) = arg_pairs(a, 0, 1)?;
-    let lo = num(a, 2)?;
-    let hi = if has(a, 3) { num(a, 3)? } else { lo };
-    if ps.iter().any(|&p| p <= 0.0 || p > 1.0) {
-        return Err(CellError::Num);
-    }
-    let total: f64 = ps.iter().sum();
-    if (total - 1.0).abs() > 1e-7 {
-        return Err(CellError::Num);
-    }
-    num_val(xs.iter().zip(&ps).filter(|(x, _)| **x >= lo && **x <= hi).map(|(_, p)| p).sum())
-}
-
-fn standardize(a: &[Arg], _: C) -> R<Value> {
-    let (x, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if sd <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((x - m) / sd)
-}
-
-fn forecast(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let (ys, xs) = arg_pairs(a, 1, 2)?;
-    if ys.is_empty() {
-        return Err(CellError::Div0);
-    }
-    num_val(intercept(&ys, &xs)? + slope(&ys, &xs)? * x)
-}
-
-fn steyx(a: &[Arg], _: C) -> R<Value> {
-    let (ys, xs) = arg_pairs(a, 0, 1)?;
-    let n = ys.len() as f64;
-    if ys.len() < 3 {
-        return Err(CellError::Div0);
-    }
-    let (sxy, sxx, syy, _, _) = moments(&xs, &ys)?;
-    if sxx == 0.0 {
-        return Err(CellError::Div0);
-    }
-    num_val(((syy - sxy * sxy / sxx) / (n - 2.0)).max(0.0).sqrt())
-}
-
-fn covariance(a: &[Arg], sample: bool) -> R<Value> {
-    let (xs, ys) = arg_pairs(a, 0, 1)?;
-    let n = xs.len();
-    if n == 0 || (sample && n < 2) {
-        return Err(CellError::Div0);
-    }
-    let (sxy, ..) = moments(&xs, &ys)?;
-    num_val(sxy / if sample { (n - 1) as f64 } else { n as f64 })
-}
-
-// ---------------------------------------------------------------------------------------------
-// Regression (LINEST, LOGEST, TREND, GROWTH)
-// ---------------------------------------------------------------------------------------------
-
-struct Xy {
-    y: Vec<f64>,
-    /// n rows of k predictor values.
-    x: Vec<Vec<f64>>,
-    k: usize,
-    y_is_row: bool,
-    y_rows: usize,
-    y_cols: usize,
-}
-
-fn strict_num(v: &Value) -> R<f64> {
-    match v {
-        Value::Number(n) => Ok(*n),
-        Value::Error(e) => Err(*e),
-        _ => Err(CellError::Value),
-    }
-}
-
-/// Most predictor columns LINEST, LOGEST, TREND and GROWTH accept. The normal equations are a
-/// k×k matrix inverted in O(k³), so an unbounded k (one `SEQUENCE(1,16384)` argument) allocated
-/// gigabytes and could abort the process.
-const MAX_REGRESSORS: usize = 255;
-/// Most multiply-adds (rows × k²) a regression may spend building its normal equations.
-const MAX_REGRESSION_WORK: usize = 1_000_000_000;
-
-/// Rejects regressions too large to fit: more than [`MAX_REGRESSORS`] predictors is `#VALUE!`,
-/// more than [`MAX_REGRESSION_WORK`] multiply-adds is `#NUM!`.
-fn check_regression_size(n: usize, k: usize) -> R<()> {
-    if k > MAX_REGRESSORS {
-        return Err(CellError::Value);
-    }
-    match n.checked_mul(k).and_then(|nk| nk.checked_mul(k)) {
-        Some(work) if work <= MAX_REGRESSION_WORK => Ok(()),
-        _ => Err(CellError::Num),
-    }
-}
-
-fn parse_xy(y: &Value, x: Option<&Value>) -> R<Xy> {
-    let ya = as_array(y);
-    let n = ya.data.len();
-    let y_is_row = ya.rows == 1 && ya.cols > 1;
-    let yv: Vec<f64> = ya.data.iter().map(strict_num).collect::<R<_>>()?;
-    let (xs, k) = match x {
-        None => ((1..=n).map(|i| vec![i as f64]).collect(), 1),
-        Some(xv) => {
-            let xa = as_array(xv);
-            if xa.rows == ya.rows && xa.cols == ya.cols {
-                (xa.data.iter().map(|v| strict_num(v).map(|f| vec![f])).collect::<R<Vec<_>>>()?, 1)
-            } else if !y_is_row && xa.rows == n {
-                check_regression_size(n, xa.cols)?;
-                let mut rows = Vec::with_capacity(n);
-                for r in 0..n {
-                    rows.push((0..xa.cols).map(|c| strict_num(xa.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?);
-                }
-                (rows, xa.cols)
-            } else if y_is_row && xa.cols == n {
-                check_regression_size(n, xa.rows)?;
-                let mut rows = Vec::with_capacity(n);
-                for c in 0..n {
-                    rows.push((0..xa.rows).map(|r| strict_num(xa.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?);
-                }
-                (rows, xa.rows)
-            } else {
-                return Err(CellError::Ref);
-            }
-        }
-    };
-    Ok(Xy { y: yv, x: xs, k, y_is_row, y_rows: ya.rows, y_cols: ya.cols })
-}
-
-struct Fit {
-    coef: Vec<f64>,
-    b: f64,
-    se: Vec<f64>,
-    se_b: Option<f64>,
-    r2: R<f64>,
-    sey: R<f64>,
-    f: R<f64>,
-    df: f64,
-    ssreg: f64,
-    ssresid: f64,
-}
-
-/// Inverts a symmetric positive semi-definite matrix by Gauss–Jordan on the diagonal, dropping
-/// (zeroing) collinear variables. Returns the inverse and the dropped flags.
-fn sym_inverse(m: &[Vec<f64>]) -> (Vec<Vec<f64>>, Vec<bool>) {
-    let p = m.len();
-    let mut a: Vec<Vec<f64>> = m.to_vec();
-    let mut inv: Vec<Vec<f64>> = (0..p).map(|i| (0..p).map(|j| if i == j { 1.0 } else { 0.0 }).collect()).collect();
-    let mut dropped = vec![false; p];
-    let diag: Vec<f64> = (0..p).map(|i| m.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0).abs()).collect();
-    for j in 0..p {
-        let piv = a.get(j).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
-        let scale = diag.get(j).copied().unwrap_or(0.0);
-        if piv.abs() <= 1e-12 * scale || piv.abs() < 1e-300 {
-            if let Some(d) = dropped.get_mut(j) {
-                *d = true;
-            }
-            for row in a.iter_mut() {
-                if let Some(v) = row.get_mut(j) {
-                    *v = 0.0;
-                }
-            }
-            if let Some(r) = a.get_mut(j) {
-                r.iter_mut().for_each(|v| *v = 0.0);
-            }
-            if let Some(r) = inv.get_mut(j) {
-                r.iter_mut().for_each(|v| *v = 0.0);
-            }
-            continue;
-        }
-        let arow: Vec<f64> = a.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
-        let irow: Vec<f64> = inv.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
-        for i in 0..p {
-            if i == j {
-                continue;
-            }
-            let f = a.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
-            if f == 0.0 {
-                continue;
-            }
-            if let Some(r) = a.get_mut(i) {
-                r.iter_mut().zip(&arow).for_each(|(v, w)| *v -= f * w);
-            }
-            if let Some(r) = inv.get_mut(i) {
-                r.iter_mut().zip(&irow).for_each(|(v, w)| *v -= f * w);
-            }
-        }
-        if let Some(r) = a.get_mut(j) {
-            *r = arow;
-        }
-        if let Some(r) = inv.get_mut(j) {
-            *r = irow;
-        }
-    }
-    (inv, dropped)
-}
-
-fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
-    let n = y.len();
-    if n == 0 || x.len() != n {
-        return Err(CellError::Value);
-    }
-    check_regression_size(n, k)?;
-    let nf = n as f64;
-    let (xm, ym) = if constant {
-        let xm: Vec<f64> = (0..k).map(|j| x.iter().map(|r| r.get(j).copied().unwrap_or(0.0)).sum::<f64>() / nf).collect();
-        (xm, y.iter().sum::<f64>() / nf)
-    } else {
-        (vec![0.0; k], 0.0)
-    };
-    // Normal equations on (centred) data.
-    let mut xtx = vec![vec![0.0; k]; k];
-    let mut xty = vec![0.0; k];
-    for (row, yv) in x.iter().zip(y) {
-        let d: Vec<f64> = (0..k).map(|j| row.get(j).copied().unwrap_or(0.0) - xm.get(j).copied().unwrap_or(0.0)).collect();
-        let yd = yv - ym;
-        for (i, di) in d.iter().enumerate() {
-            if let Some(t) = xty.get_mut(i) {
-                *t += di * yd;
-            }
-            if let Some(r) = xtx.get_mut(i) {
-                for (j, dj) in d.iter().enumerate() {
-                    if let Some(v) = r.get_mut(j) {
-                        *v += di * dj;
-                    }
-                }
-            }
-        }
-    }
-    let (inv, dropped) = sym_inverse(&xtx);
-    let coef: Vec<f64> = (0..k).map(|i| inv.get(i).map(|r| r.iter().zip(&xty).map(|(a, b)| a * b).sum()).unwrap_or(0.0)).collect();
-    let b = if constant { ym - coef.iter().zip(&xm).map(|(c, m)| c * m).sum::<f64>() } else { 0.0 };
-    let mut ssresid = 0.0;
-    let mut sstot = 0.0;
-    for (row, yv) in x.iter().zip(y) {
-        let pred = b + coef.iter().zip(row).map(|(c, v)| c * v).sum::<f64>();
-        ssresid += (yv - pred).powi(2);
-        sstot += if constant { (yv - ym).powi(2) } else { yv * yv };
-    }
-    let used = dropped.iter().filter(|d| !**d).count() + usize::from(constant);
-    let df = nf - used as f64;
-    let ssreg = sstot - ssresid;
-    let r2 = if sstot == 0.0 { Err(CellError::Num) } else { Ok(ssreg / sstot) };
-    let sey2 = if df > 0.0 { Ok(ssresid / df) } else { Err(CellError::Num) };
-    let sey = sey2.map(f64::sqrt);
-    let v1 = if constant { nf - df - 1.0 } else { nf - df };
-    let f = match sey2 {
-        Ok(s2) if s2 > 0.0 && v1 > 0.0 => Ok((ssreg / v1) / s2),
-        _ => Err(CellError::Num),
-    };
-    let s2 = sey2.unwrap_or(f64::NAN);
-    let se: Vec<f64> = (0..k)
-        .map(|i| if dropped.get(i).copied().unwrap_or(true) { 0.0 } else { (inv.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0) * s2).sqrt() })
-        .collect();
-    let se_b = if constant {
-        let mut q = 0.0;
-        for (i, mi) in xm.iter().enumerate() {
-            for (j, mj) in xm.iter().enumerate() {
-                q += mi * mj * inv.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
-            }
-        }
-        Some((s2 * (1.0 / nf + q)).sqrt())
-    } else {
-        None
-    };
-    Ok(Fit { coef, b, se, se_b, r2, sey, f, df, ssreg, ssresid })
-}
-
-fn const_arg(a: &[Arg], i: usize) -> R<bool> {
-    if has(a, i) { boolean(a, i) } else { Ok(true) }
-}
-
-fn opt_value(a: &[Arg], i: usize) -> Option<&Value> {
-    if has(a, i) { a.get(i).map(|x| &x.value) } else { None }
-}
-
-fn linest_impl(a: &[Arg], log: bool) -> R<Value> {
-    let mut xy = parse_xy(&arg(a, 0)?.value, opt_value(a, 1))?;
-    if log {
-        if xy.y.iter().any(|&v| v <= 0.0) {
-            return Err(CellError::Num);
-        }
-        xy.y.iter_mut().for_each(|v| *v = v.ln());
-    }
-    let constant = const_arg(a, 2)?;
-    let stats = if has(a, 3) { boolean(a, 3)? } else { false };
-    let fit = regress(&xy.y, &xy.x, xy.k, constant)?;
-    let tr = |v: f64| if log { v.exp() } else { v };
-    let cols = xy.k + 1;
-    let mut data: Vec<Value> = Vec::new();
-    for c in fit.coef.iter().rev() {
-        data.push(Value::number(tr(*c)));
-    }
-    data.push(Value::number(tr(fit.b)));
-    if stats {
-        let rv = |r: R<f64>| r.map(Value::number).unwrap_or_else(Value::Error);
-        let na = Value::Error(CellError::NA);
-        for s in fit.se.iter().rev() {
-            data.push(Value::number(*s));
-        }
-        data.push(fit.se_b.map(Value::number).unwrap_or(na.clone()));
-        let rows: [[Value; 2]; 3] =
-            [[rv(fit.r2), rv(fit.sey)], [rv(fit.f), Value::number(fit.df)], [Value::number(fit.ssreg), Value::number(fit.ssresid)]];
-        for [p, q] in rows {
-            data.push(p);
-            if cols > 1 {
-                data.push(q);
-            }
-            for _ in 2..cols {
-                data.push(na.clone());
-            }
-        }
-        return array_val(5, cols, data);
-    }
-    array_val(1, cols, data)
-}
-
-fn trend_impl(a: &[Arg], log: bool) -> R<Value> {
-    let mut xy = parse_xy(&arg(a, 0)?.value, opt_value(a, 1))?;
-    if log {
-        if xy.y.iter().any(|&v| v <= 0.0) {
-            return Err(CellError::Num);
-        }
-        xy.y.iter_mut().for_each(|v| *v = v.ln());
-    }
-    let constant = const_arg(a, 3)?;
-    let fit = regress(&xy.y, &xy.x, xy.k, constant)?;
-    let predict = |row: &[f64]| -> Value {
-        let v = fit.b + fit.coef.iter().zip(row).map(|(c, x)| c * x).sum::<f64>();
-        Value::number(if log { v.exp() } else { v })
-    };
-    match opt_value(a, 2) {
-        None => {
-            let data: Vec<Value> = xy.x.iter().map(|r| predict(r)).collect();
-            array_val(xy.y_rows, xy.y_cols, data)
-        }
-        Some(nv) => {
-            let na = as_array(nv);
-            if xy.k == 1 {
-                let data = na.data.iter().map(|v| strict_num(v).map(|x| predict(&[x]))).collect::<R<Vec<_>>>()?;
-                array_val(na.rows, na.cols, data)
-            } else if !xy.y_is_row && na.cols == xy.k {
-                let mut data = Vec::with_capacity(na.rows);
-                for r in 0..na.rows {
-                    let row = (0..na.cols).map(|c| strict_num(na.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?;
-                    data.push(predict(&row));
-                }
-                array_val(na.rows, 1, data)
-            } else if xy.y_is_row && na.rows == xy.k {
-                let mut data = Vec::with_capacity(na.cols);
-                for c in 0..na.cols {
-                    let row = (0..na.rows).map(|r| strict_num(na.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?;
-                    data.push(predict(&row));
-                }
-                array_val(1, na.cols, data)
-            } else {
-                Err(CellError::Ref)
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-// Distributions
-// ---------------------------------------------------------------------------------------------
-
-fn ln_comb(n: f64, k: f64) -> f64 {
-    ln_gamma(n + 1.0) - ln_gamma(k + 1.0) - ln_gamma(n - k + 1.0)
-}
-
-fn t_upper(t: f64, v: f64) -> f64 {
-    // P(T > t) for t ≥ 0.
-    0.5 * reg_inc_beta(v / (v + t * t), v / 2.0, 0.5)
-}
-
-fn t_cdf(t: f64, v: f64) -> f64 {
-    if t >= 0.0 { 1.0 - t_upper(t, v) } else { t_upper(-t, v) }
-}
-
-fn t_pdf(t: f64, v: f64) -> f64 {
-    (ln_gamma((v + 1.0) / 2.0) - ln_gamma(v / 2.0) - 0.5 * (v * std::f64::consts::PI).ln() - (v + 1.0) / 2.0 * (1.0 + t * t / v).ln()).exp()
-}
-
-/// t ≥ 0 with P(T > t) = q, q in (0, 0.5].
-fn t_inv_upper(q: f64, v: f64) -> f64 {
-    if q >= 0.5 {
-        return 0.0;
-    }
-    invert(|t| t_upper(t, v), q, 0.0, 1.0, 1e60)
-}
-
-fn chi_inv(p: f64, v: f64) -> f64 {
-    if p <= 0.0 {
-        return 0.0;
-    }
-    invert(|x| reg_gamma_p(v / 2.0, x / 2.0), p, 0.0, v.max(1.0), 1e60)
-}
-
-fn chi_inv_rt(q: f64, v: f64) -> f64 {
-    if q >= 1.0 {
-        return 0.0;
-    }
-    invert(|x| reg_gamma_q(v / 2.0, x / 2.0), q, 0.0, v.max(1.0), 1e60)
-}
-
-fn f_cdf(x: f64, d1: f64, d2: f64) -> f64 {
-    if x <= 0.0 {
-        return 0.0;
-    }
-    reg_inc_beta(d1 * x / (d1 * x + d2), d1 / 2.0, d2 / 2.0)
-}
-
-fn f_upper(x: f64, d1: f64, d2: f64) -> f64 {
-    if x <= 0.0 {
-        return 1.0;
-    }
-    reg_inc_beta(d2 / (d2 + d1 * x), d2 / 2.0, d1 / 2.0)
-}
-
-fn f_pdf(x: f64, d1: f64, d2: f64) -> f64 {
-    if x == 0.0 {
-        return if d1 < 2.0 {
-            f64::INFINITY
-        } else if d1 == 2.0 {
-            1.0
-        } else {
-            0.0
-        };
-    }
-    ((d1 / 2.0) * (d1 / d2).ln() + (d1 / 2.0 - 1.0) * x.ln() - ((d1 + d2) / 2.0) * (1.0 + d1 * x / d2).ln() - ln_beta(d1 / 2.0, d2 / 2.0)).exp()
-}
-
-fn binom_pmf(k: f64, n: f64, p: f64) -> f64 {
-    if k < 0.0 || k > n {
-        return 0.0;
-    }
-    if p == 0.0 {
-        return if k == 0.0 { 1.0 } else { 0.0 };
-    }
-    if p == 1.0 {
-        return if k == n { 1.0 } else { 0.0 };
-    }
-    (ln_comb(n, k) + k * p.ln() + (n - k) * (1.0 - p).ln()).exp()
-}
-
-fn binom_cdf(k: f64, n: f64, p: f64) -> f64 {
-    if k < 0.0 {
-        return 0.0;
-    }
-    if k >= n {
-        return 1.0;
-    }
-    if n <= 10_000.0 {
-        let mut s = 0.0;
-        let mut i = 0.0;
-        while i <= k {
-            s += binom_pmf(i, n, p);
-            i += 1.0;
-        }
-        return s.min(1.0);
-    }
-    if p == 0.0 {
-        return 1.0;
-    }
-    if p == 1.0 {
-        return 0.0;
-    }
-    reg_inc_beta(1.0 - p, n - k, k + 1.0)
-}
-
-fn poisson_pmf(x: f64, m: f64) -> f64 {
-    if m == 0.0 {
-        return if x == 0.0 { 1.0 } else { 0.0 };
-    }
-    (-m + x * m.ln() - ln_gamma(x + 1.0)).exp()
-}
-
-fn poisson_cdf(x: f64, m: f64) -> f64 {
-    if m == 0.0 {
-        return 1.0;
-    }
-    if x <= 1000.0 {
-        let mut s = 0.0;
-        let mut i = 0.0;
-        while i <= x {
-            s += poisson_pmf(i, m);
-            i += 1.0;
-        }
-        return s.min(1.0);
-    }
-    reg_gamma_q(x + 1.0, m)
-}
-
-fn norm_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, m, sd, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
-    if sd <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let z = (x - m) / sd;
-    num_val(if cum { norm_cdf(z) } else { norm_pdf(z) / sd })
-}
-
-fn norm_inv_fn(a: &[Arg], _: C) -> R<Value> {
-    let (p, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if !(p > 0.0 && p < 1.0) || sd <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(m + sd * norm_inv(p))
-}
-
-fn norm_s_dist(a: &[Arg], _: C) -> R<Value> {
-    let z = num(a, 0)?;
-    let cum = if a.len() > 1 { boolean(a, 1)? } else { true };
-    num_val(if cum { norm_cdf(z) } else { norm_pdf(z) })
-}
-
-fn norm_s_inv(a: &[Arg], _: C) -> R<Value> {
-    let p = num(a, 0)?;
-    if !(p > 0.0 && p < 1.0) {
-        return Err(CellError::Num);
-    }
-    num_val(norm_inv(p))
-}
-
-fn df_arg(a: &[Arg], i: usize) -> R<f64> {
-    let v = num(a, i)?.trunc();
-    if v < 1.0 {
-        return Err(CellError::Num);
-    }
-    Ok(v)
-}
-
-fn t_dist(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    let cum = boolean(a, 2)?;
-    num_val(if cum { t_cdf(x, v) } else { t_pdf(x, v) })
-}
-
-fn t_dist_2t(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    if x < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(2.0 * t_upper(x, v))
-}
-
-fn t_dist_rt(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    num_val(1.0 - t_cdf(x, v))
-}
-
-fn tdist_legacy(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    let tails = num(a, 2)?.trunc();
-    if x < 0.0 || !(tails == 1.0 || tails == 2.0) {
-        return Err(CellError::Num);
-    }
-    num_val(tails * t_upper(x, v))
-}
-
-fn t_inv(a: &[Arg], _: C) -> R<Value> {
-    let p = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    if !(p > 0.0 && p < 1.0) {
-        return Err(CellError::Num);
-    }
-    num_val(if p < 0.5 { -t_inv_upper(p, v) } else { t_inv_upper(1.0 - p, v) })
-}
-
-fn t_inv_2t(a: &[Arg], _: C) -> R<Value> {
-    let p = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    if !(p > 0.0 && p <= 1.0) {
-        return Err(CellError::Num);
-    }
-    num_val(t_inv_upper(p / 2.0, v))
-}
-
-fn t_test(a: &[Arg], _: C) -> R<Value> {
-    let tails = num(a, 2)?.trunc();
-    let ty = num(a, 3)?.trunc();
-    if !(tails == 1.0 || tails == 2.0) || !(1.0..=3.0).contains(&ty) {
-        return Err(CellError::Num);
-    }
-    let (t, v) = if ty == 1.0 {
-        let (x, y) = arg_pairs(a, 0, 1)?;
-        let d: Vec<f64> = x.iter().zip(&y).map(|(p, q)| p - q).collect();
-        let n = d.len() as f64;
-        let sd = var_s(&d)?.sqrt();
-        if sd == 0.0 {
-            return Err(CellError::Div0);
-        }
-        (mean(&d)? / (sd / n.sqrt()), n - 1.0)
-    } else {
-        let x = arg_nums(a, 0)?;
-        let y = arg_nums(a, 1)?;
-        let (n1, n2) = (x.len() as f64, y.len() as f64);
-        let (v1, v2) = (var_s(&x)?, var_s(&y)?);
-        let diff = mean(&x)? - mean(&y)?;
-        if ty == 2.0 {
-            let df = n1 + n2 - 2.0;
-            let sp = ((n1 - 1.0) * v1 + (n2 - 1.0) * v2) / df;
-            let se = (sp * (1.0 / n1 + 1.0 / n2)).sqrt();
-            if se == 0.0 {
-                return Err(CellError::Div0);
-            }
-            (diff / se, df)
-        } else {
-            let (a1, a2) = (v1 / n1, v2 / n2);
-            let se = (a1 + a2).sqrt();
-            if se == 0.0 {
-                return Err(CellError::Div0);
-            }
-            let df = (a1 + a2).powi(2) / (a1 * a1 / (n1 - 1.0) + a2 * a2 / (n2 - 1.0));
-            (diff / se, df)
-        }
-    };
-    num_val(tails * t_upper(t.abs(), v))
-}
-
-fn chisq_dist(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    let cum = boolean(a, 2)?;
-    if x < 0.0 || v > 1e10 {
-        return Err(CellError::Num);
-    }
-    if cum {
-        return num_val(reg_gamma_p(v / 2.0, x / 2.0));
-    }
-    if x == 0.0 {
-        return if v == 2.0 {
-            num_val(0.5)
-        } else if v < 2.0 {
-            Err(CellError::Num)
-        } else {
-            num_val(0.0)
-        };
-    }
-    num_val(((v / 2.0 - 1.0) * x.ln() - x / 2.0 - (v / 2.0) * 2f64.ln() - ln_gamma(v / 2.0)).exp())
-}
-
-fn chisq_dist_rt(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    if x < 0.0 || v > 1e10 {
-        return Err(CellError::Num);
-    }
-    num_val(reg_gamma_q(v / 2.0, x / 2.0))
-}
-
-fn chisq_inv(a: &[Arg], _: C) -> R<Value> {
-    let p = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    if !(0.0..1.0).contains(&p) || v > 1e10 {
-        return Err(CellError::Num);
-    }
-    num_val(chi_inv(p, v))
-}
-
-fn chisq_inv_rt(a: &[Arg], _: C) -> R<Value> {
-    let p = num(a, 0)?;
-    let v = df_arg(a, 1)?;
-    if !(p > 0.0 && p <= 1.0) || v > 1e10 {
-        return Err(CellError::Num);
-    }
-    num_val(chi_inv_rt(p, v))
-}
-
-fn chisq_test(a: &[Arg], _: C) -> R<Value> {
-    let act = as_array(&arg(a, 0)?.value).into_owned();
-    let exp = as_array(&arg(a, 1)?.value).into_owned();
-    if act.rows != exp.rows || act.cols != exp.cols {
-        return Err(CellError::NA);
-    }
-    let mut x2 = 0.0;
-    for (o, e) in act.data.iter().zip(&exp.data) {
-        if let Value::Error(err) = o {
-            return Err(*err);
-        }
-        if let Value::Error(err) = e {
-            return Err(*err);
-        }
-        if let (Value::Number(o), Value::Number(e)) = (o, e) {
-            if *e == 0.0 {
-                return Err(CellError::Div0);
-            }
-            x2 += (o - e).powi(2) / e;
-        }
-    }
-    let df = if act.rows > 1 && act.cols > 1 { ((act.rows - 1) * (act.cols - 1)) as f64 } else { (act.data.len().saturating_sub(1)) as f64 };
-    if df < 1.0 {
-        return Err(CellError::NA);
-    }
-    num_val(reg_gamma_q(df / 2.0, x2 / 2.0))
-}
-
-fn f_args(a: &[Arg]) -> R<(f64, f64, f64)> {
-    let x = num(a, 0)?;
-    let d1 = num(a, 1)?.trunc();
-    let d2 = num(a, 2)?.trunc();
-    if d1 < 1.0 || d2 < 1.0 || d1 >= 1e10 || d2 >= 1e10 {
-        return Err(CellError::Num);
-    }
-    Ok((x, d1, d2))
-}
-
-fn f_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, d1, d2) = f_args(a)?;
-    let cum = boolean(a, 3)?;
-    if x < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(if cum { f_cdf(x, d1, d2) } else { f_pdf(x, d1, d2) })
-}
-
-fn f_dist_rt(a: &[Arg], _: C) -> R<Value> {
-    let (x, d1, d2) = f_args(a)?;
-    if x < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(f_upper(x, d1, d2))
-}
-
-fn f_inv(a: &[Arg], _: C) -> R<Value> {
-    let (p, d1, d2) = f_args(a)?;
-    if !(0.0..1.0).contains(&p) {
-        return Err(CellError::Num);
-    }
-    if p == 0.0 {
-        return num_val(0.0);
-    }
-    num_val(invert(|x| f_cdf(x, d1, d2), p, 0.0, 1.0, 1e60))
-}
-
-fn f_inv_rt(a: &[Arg], _: C) -> R<Value> {
-    let (p, d1, d2) = f_args(a)?;
-    if !(p > 0.0 && p <= 1.0) {
-        return Err(CellError::Num);
-    }
-    if p == 1.0 {
-        return num_val(0.0);
-    }
-    num_val(invert(|x| f_upper(x, d1, d2), p, 0.0, 1.0, 1e60))
-}
-
-fn f_test(a: &[Arg], _: C) -> R<Value> {
-    let x = arg_nums(a, 0)?;
-    let y = arg_nums(a, 1)?;
-    let (v1, v2) = (var_s(&x)?, var_s(&y)?);
-    if v1 == 0.0 || v2 == 0.0 {
-        return Err(CellError::Div0);
-    }
-    let f = v1 / v2;
-    let (d1, d2) = ((x.len() - 1) as f64, (y.len() - 1) as f64);
-    let c = f_cdf(f, d1, d2);
-    num_val((2.0 * c.min(1.0 - c)).min(1.0))
-}
-
-fn binom_dist(a: &[Arg], _: C) -> R<Value> {
-    let k = num(a, 0)?.trunc();
-    let n = num(a, 1)?.trunc();
-    let p = num(a, 2)?;
-    let cum = boolean(a, 3)?;
-    if k < 0.0 || k > n || !(0.0..=1.0).contains(&p) {
-        return Err(CellError::Num);
-    }
-    num_val(if cum { binom_cdf(k, n, p) } else { binom_pmf(k, n, p) })
-}
-
-fn binom_dist_range(a: &[Arg], _: C) -> R<Value> {
-    let n = num(a, 0)?.trunc();
-    let p = num(a, 1)?;
-    let s1 = num(a, 2)?.trunc();
-    let s2 = if has(a, 3) { num(a, 3)?.trunc() } else { s1 };
-    if !(0.0..=1e15).contains(&n) || !(0.0..=1.0).contains(&p) || s1 < 0.0 || s1 > n || s2 < s1 || s2 > n {
-        return Err(CellError::Num);
-    }
-    if s2 - s1 > 10_000.0 {
-        return num_val(binom_cdf(s2, n, p) - binom_cdf(s1 - 1.0, n, p));
-    }
-    let mut s = 0.0;
-    let mut k = s1;
-    while k <= s2 {
-        s += binom_pmf(k, n, p);
-        k += 1.0;
-    }
-    num_val(s)
-}
-
-fn binom_inv(a: &[Arg], _: C) -> R<Value> {
-    let n = num(a, 0)?.trunc();
-    let p = num(a, 1)?;
-    let alpha = num(a, 2)?;
-    if n < 0.0 || !(0.0..=1.0).contains(&p) || !(0.0..=1.0).contains(&alpha) {
-        return Err(CellError::Num);
-    }
-    // Smallest k with cdf(k) ≥ alpha, by bisection on the integer k.
-    let (mut lo, mut hi) = (0.0f64, n);
-    if binom_cdf(0.0, n, p) >= alpha {
-        return num_val(0.0);
-    }
-    while hi - lo > 1.0 {
-        let mid = ((lo + hi) / 2.0).floor();
-        // Above 2^53 adjacent f64 values are more than 1 apart, so the gap can stop shrinking.
-        if mid <= lo || mid >= hi {
-            break;
-        }
-        if binom_cdf(mid, n, p) >= alpha {
-            hi = mid;
-        } else {
-            lo = mid;
-        }
-    }
-    num_val(hi)
-}
-
-fn poisson_dist(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?.trunc();
-    let m = num(a, 1)?;
-    let cum = boolean(a, 2)?;
-    if x < 0.0 || m < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(if cum { poisson_cdf(x, m) } else { poisson_pmf(x, m) })
-}
-
-fn expon_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, l, cum) = (num(a, 0)?, num(a, 1)?, boolean(a, 2)?);
-    if x < 0.0 || l <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(if cum { -(-l * x).exp_m1() } else { l * (-l * x).exp() })
-}
-
-fn gamma_fn(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    let g = gamma(x);
-    if !g.is_finite() {
-        return Err(CellError::Num);
-    }
-    num_val(g)
-}
-
-fn gamma_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, al, be, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
-    if x < 0.0 || al <= 0.0 || be <= 0.0 {
-        return Err(CellError::Num);
-    }
-    if cum {
-        return num_val(reg_gamma_p(al, x / be));
-    }
-    if x == 0.0 {
-        return if al < 1.0 {
-            Err(CellError::Num)
-        } else if al == 1.0 {
-            num_val(1.0 / be)
-        } else {
-            num_val(0.0)
-        };
-    }
-    num_val(((al - 1.0) * x.ln() - x / be - al * be.ln() - ln_gamma(al)).exp())
-}
-
-fn gamma_inv(a: &[Arg], _: C) -> R<Value> {
-    let (p, al, be) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if !(0.0..1.0).contains(&p) || al <= 0.0 || be <= 0.0 {
-        return Err(CellError::Num);
-    }
-    if p == 0.0 {
-        return num_val(0.0);
-    }
-    num_val(invert(|x| reg_gamma_p(al, x / be), p, 0.0, (al * be).max(1e-3), 1e60))
-}
-
-fn gammaln(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    if x <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(ln_gamma(x))
-}
-
-fn beta_bounds(a: &[Arg], i: usize) -> R<(f64, f64)> {
-    let lo = if has(a, i) { num(a, i)? } else { 0.0 };
-    let hi = if has(a, i + 1) { num(a, i + 1)? } else { 1.0 };
-    if lo >= hi {
-        return Err(CellError::Num);
-    }
-    Ok((lo, hi))
-}
-
-fn beta_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, al, be, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
-    let (lo, hi) = beta_bounds(a, 4)?;
-    if al <= 0.0 || be <= 0.0 || x < lo || x > hi {
-        return Err(CellError::Num);
-    }
-    let z = (x - lo) / (hi - lo);
-    if cum {
-        return num_val(reg_inc_beta(z, al, be));
-    }
-    if (z == 0.0 && al < 1.0) || (z == 1.0 && be < 1.0) {
-        return Err(CellError::Num);
-    }
-    let lp = if z == 0.0 || z == 1.0 {
-        let base = if z == 0.0 { al } else { be };
-        if base == 1.0 { -ln_beta(al, be) } else { f64::NEG_INFINITY }
-    } else {
-        (al - 1.0) * z.ln() + (be - 1.0) * (1.0 - z).ln() - ln_beta(al, be)
-    };
-    num_val(lp.exp() / (hi - lo))
-}
-
-fn betadist_legacy(a: &[Arg], _: C) -> R<Value> {
-    let (x, al, be) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let (lo, hi) = beta_bounds(a, 3)?;
-    if al <= 0.0 || be <= 0.0 || x < lo || x > hi {
-        return Err(CellError::Num);
-    }
-    num_val(reg_inc_beta((x - lo) / (hi - lo), al, be))
-}
-
-fn beta_inv(a: &[Arg], _: C) -> R<Value> {
-    let (p, al, be) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let (lo, hi) = beta_bounds(a, 3)?;
-    if al <= 0.0 || be <= 0.0 || !(0.0..=1.0).contains(&p) {
-        return Err(CellError::Num);
-    }
-    let z = if p == 0.0 {
-        0.0
-    } else if p == 1.0 {
-        1.0
-    } else {
-        invert(|x| reg_inc_beta(x, al, be), p, 0.0, 1.0, 1.0)
-    };
-    num_val(lo + z * (hi - lo))
-}
-
-fn lognorm_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let cum = if a.len() > 3 { boolean(a, 3)? } else { true };
-    if x <= 0.0 || sd <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let z = (x.ln() - m) / sd;
-    num_val(if cum { norm_cdf(z) } else { norm_pdf(z) / (x * sd) })
-}
-
-fn lognorm_inv(a: &[Arg], _: C) -> R<Value> {
-    let (p, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if !(p > 0.0 && p < 1.0) || sd <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((m + sd * norm_inv(p)).exp())
-}
-
-fn weibull_dist(a: &[Arg], _: C) -> R<Value> {
-    let (x, al, be, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
-    if x < 0.0 || al <= 0.0 || be <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let t = (x / be).powf(al);
-    num_val(if cum { -(-t).exp_m1() } else { al / be.powf(al) * x.powf(al - 1.0) * (-t).exp() })
-}
-
-fn hypgeom_dist(a: &[Arg], _: C) -> R<Value> {
-    let k = num(a, 0)?.trunc();
-    let n = num(a, 1)?.trunc();
-    let kk = num(a, 2)?.trunc();
-    let nn = num(a, 3)?.trunc();
-    let cum = if a.len() > 4 { boolean(a, 4)? } else { false };
-    if k < 0.0 || n <= 0.0 || kk <= 0.0 || nn <= 0.0 || n > nn || kk > nn || k > n.min(kk) || k < (n - nn + kk).max(0.0) {
-        return Err(CellError::Num);
-    }
-    let pmf = |i: f64| (ln_comb(kk, i) + ln_comb(nn - kk, n - i) - ln_comb(nn, n)).exp();
-    if !cum {
-        return num_val(pmf(k));
-    }
-    let mut s = 0.0;
-    let mut i = (n - nn + kk).max(0.0);
-    if k - i > 1e6 || i + 1.0 == i {
-        return Err(CellError::Num);
-    }
-    while i <= k {
-        s += pmf(i);
-        i += 1.0;
-    }
-    num_val(s.min(1.0))
-}
-
-fn negbinom_dist(a: &[Arg], _: C) -> R<Value> {
-    let f = num(a, 0)?.trunc();
-    let s = num(a, 1)?.trunc();
-    let p = num(a, 2)?;
-    let cum = if a.len() > 3 { boolean(a, 3)? } else { false };
-    if f < 0.0 || s < 1.0 || !(0.0..=1.0).contains(&p) {
-        return Err(CellError::Num);
-    }
-    if cum {
-        if p == 0.0 {
-            return num_val(0.0);
-        }
-        return num_val(reg_inc_beta(p, s, f + 1.0));
-    }
-    if p == 0.0 || p == 1.0 {
-        return num_val(if p == 1.0 && f == 0.0 { 1.0 } else { 0.0 });
-    }
-    num_val((ln_comb(f + s - 1.0, s - 1.0) + s * p.ln() + f * (1.0 - p).ln()).exp())
-}
-
-fn confidence_norm(a: &[Arg], _: C) -> R<Value> {
-    let (al, sd, n) = (num(a, 0)?, num(a, 1)?, num(a, 2)?.trunc());
-    if !(al > 0.0 && al < 1.0) || sd <= 0.0 || n < 1.0 {
-        return Err(CellError::Num);
-    }
-    num_val(norm_inv(1.0 - al / 2.0) * sd / n.sqrt())
-}
-
-fn confidence_t(a: &[Arg], _: C) -> R<Value> {
-    let (al, sd, n) = (num(a, 0)?, num(a, 1)?, num(a, 2)?.trunc());
-    if !(al > 0.0 && al < 1.0) || sd <= 0.0 || n < 1.0 {
-        return Err(CellError::Num);
-    }
-    if n == 1.0 {
-        return Err(CellError::Div0);
-    }
-    num_val(t_inv_upper(al / 2.0, n - 1.0) * sd / n.sqrt())
-}
-
-fn z_test(a: &[Arg], _: C) -> R<Value> {
-    let v = arg_nums(a, 0)?;
-    let x = num(a, 1)?;
-    if v.is_empty() {
-        return Err(CellError::NA);
-    }
-    let sd = if has(a, 2) { num(a, 2)? } else { var_s(&v)?.sqrt() };
-    if sd <= 0.0 {
-        return Err(if has(a, 2) { CellError::Num } else { CellError::Div0 });
-    }
-    let z = (mean(&v)? - x) / (sd / (v.len() as f64).sqrt());
-    num_val(1.0 - norm_cdf(z))
-}
-
-fn fisher(a: &[Arg], _: C) -> R<Value> {
-    let x = num(a, 0)?;
-    if x <= -1.0 || x >= 1.0 {
-        return Err(CellError::Num);
-    }
-    num_val(0.5 * ((1.0 + x) / (1.0 - x)).ln())
-}
-
-fn gauss(a: &[Arg], _: C) -> R<Value> {
-    let z = num(a, 0)?;
-    // Φ(z) − 0.5 = erf(z/√2)/2, accurate near zero.
-    num_val(0.5 * erf(z / std::f64::consts::SQRT_2))
-}
-
-// ---------------------------------------------------------------------------------------------
-// SUBTOTAL / AGGREGATE support
-// ---------------------------------------------------------------------------------------------
-
-/// Evaluates SUBTOTAL/AGGREGATE function `function_num` over already-filtered cell values.
-///
-/// Codes 1–11 (and 101–111) are AVERAGE, COUNT, COUNTA, MAX, MIN, PRODUCT, STDEV.S, STDEV.P,
-/// SUM, VAR.S, VAR.P; 12 = MEDIAN, 13 = MODE.SNGL. Codes 14–19 need `k`: use
-/// [`aggregate_values_k`] (they give `#VALUE!` here). Values that are not numbers are ignored
-/// (COUNTA counts non-empty values); the first error value present is returned.
-pub fn aggregate_values(function_num: u32, values: &[Value]) -> Value {
-    crate::util::finish(aggregate_impl(function_num, values, None))
-}
-
-/// AGGREGATE codes 14 = LARGE, 15 = SMALL, 16 = PERCENTILE.INC, 17 = QUARTILE.INC,
-/// 18 = PERCENTILE.EXC, 19 = QUARTILE.EXC with their `k` argument; codes 1–13 delegate to
-/// [`aggregate_values`].
-pub fn aggregate_values_k(function_num: u32, values: &[Value], k: &Value) -> Value {
-    crate::util::finish(aggregate_impl(function_num, values, Some(k)))
-}
-
-fn aggregate_impl(function_num: u32, values: &[Value], k: Option<&Value>) -> R<Value> {
-    let code = if (101..=111).contains(&function_num) { function_num - 100 } else { function_num };
-    let mut xs = Vec::new();
-    let mut nonempty = 0usize;
-    let mut push = |v: &Value| -> R<()> {
-        match v {
-            Value::Number(n) => xs.push(*n),
-            Value::Error(e) => return Err(*e),
-            _ => {}
-        }
-        if !v.is_empty() {
-            nonempty += 1;
-        }
-        Ok(())
-    };
-    for v in values {
-        match v {
-            Value::Array(arr) => arr.iter().try_for_each(&mut push)?,
-            other => push(other)?,
-        }
-    }
-    let k = match (code, k) {
-        (14..=19, Some(k)) => k.scalar().to_number()?,
-        (14..=19, None) => return Err(CellError::Value),
-        _ => 0.0,
-    };
-    let r = match code {
-        1 => mean(&xs)?,
-        2 => xs.len() as f64,
-        3 => nonempty as f64,
-        4 => max_of(&xs),
-        5 => min_of(&xs),
-        6 => product(&xs),
-        7 => var_s(&xs)?.sqrt(),
-        8 => var_p(&xs)?.sqrt(),
-        9 => xs.iter().sum(),
-        10 => var_s(&xs)?,
-        11 => var_p(&xs)?,
-        12 => median(xs)?,
-        13 => mode_sngl(&xs)?,
-        14 => kth(xs, k, true)?,
-        15 => kth(xs, k, false)?,
-        16 => percentile_inc(xs, k)?,
-        17 => quartile_inc(xs, k)?,
-        18 => percentile_exc(xs, k)?,
-        19 => quartile_exc(xs, k)?,
-        _ => return Err(CellError::Value),
-    };
-    num_val(r)
-}
-
 // ---------------------------------------------------------------------------------------------
 // Registration
 // ---------------------------------------------------------------------------------------------
diff --git a/crates/functions/src/stat/descriptive.rs b/crates/functions/src/stat/descriptive.rs
new file mode 100644
index 000000000..af4c53607
--- /dev/null
+++ b/crates/functions/src/stat/descriptive.rs
@@ -0,0 +1,547 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Basic helpers over number lists
+// ---------------------------------------------------------------------------------------------
+
+pub(super) fn mean(x: &[f64]) -> R<f64> {
+    if x.is_empty() {
+        return Err(CellError::Div0);
+    }
+    Ok(x.iter().sum::<f64>() / x.len() as f64)
+}
+
+pub(super) fn devsq(x: &[f64]) -> f64 {
+    if x.is_empty() {
+        return 0.0;
+    }
+    let m = x.iter().sum::<f64>() / x.len() as f64;
+    x.iter().map(|v| (v - m) * (v - m)).sum()
+}
+
+pub(super) fn var_s(x: &[f64]) -> R<f64> {
+    if x.len() < 2 {
+        return Err(CellError::Div0);
+    }
+    Ok(devsq(x) / (x.len() - 1) as f64)
+}
+
+pub(super) fn var_p(x: &[f64]) -> R<f64> {
+    if x.is_empty() {
+        return Err(CellError::Div0);
+    }
+    Ok(devsq(x) / x.len() as f64)
+}
+
+fn sorted(mut v: Vec<f64>) -> Vec<f64> {
+    v.sort_by(f64::total_cmp);
+    v
+}
+
+pub(super) fn median(v: Vec<f64>) -> R<f64> {
+    if v.is_empty() {
+        return Err(CellError::Num);
+    }
+    let s = sorted(v);
+    let n = s.len();
+    let hi = s.get(n / 2).copied().unwrap_or(0.0);
+    if n % 2 == 1 { Ok(hi) } else { Ok(s.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) }
+}
+
+/// Values occurring at least twice, ordered by first occurrence, with their (equal, maximal) count.
+fn modes(v: &[f64]) -> Vec<f64> {
+    let mut counts: Vec<(f64, usize)> = Vec::new();
+    for &x in v {
+        if let Some(e) = counts.iter_mut().find(|e| e.0 == x) {
+            e.1 += 1;
+        } else {
+            counts.push((x, 1));
+        }
+    }
+    let best = counts.iter().map(|e| e.1).max().unwrap_or(0);
+    if best < 2 {
+        return Vec::new();
+    }
+    counts.into_iter().filter(|e| e.1 == best).map(|e| e.0).collect()
+}
+
+pub(super) fn mode_sngl(v: &[f64]) -> R<f64> {
+    modes(v).first().copied().ok_or(CellError::NA)
+}
+
+/// Numbers for MODE / MODE.SNGL / MODE.MULT. Inside multi-cell ranges and arrays only numbers
+/// count, like [`numbers`]. Scalar arguments differ from SUM: in Excel 365, text and logical
+/// values are skipped whether typed or referenced (even numeric text such as `"1"`, so
+/// `MODE(1,"1",2,3)` is `#N/A`, and `MODE(1,TRUE,TRUE,2)` is `#N/A`), but a single-cell reference
+/// to a blank cell is `#VALUE!` (`MODE(B9,2,D7)` with D7 blank). Arguments are processed left to
+/// right, so the first error wins. The results cached in POI's FormulaEvalTestData come from an
+/// older Excel that answered `#VALUE!` for typed text; they are not the reference here.
+pub(super) fn mode_numbers(args: &[Arg]) -> R<Vec<f64>> {
+    let mut out = Vec::new();
+    for a in args {
+        match &a.value {
+            Value::Array(arr) => {
+                for v in arr.iter() {
+                    match v {
+                        Value::Number(n) => out.push(*n),
+                        Value::Error(e) => return Err(*e),
+                        _ => {}
+                    }
+                }
+            }
+            Value::Number(n) => out.push(*n),
+            Value::Error(e) => return Err(*e),
+            Value::Text(_) | Value::Bool(_) => {}
+            Value::Empty => return Err(CellError::Value),
+        }
+    }
+    Ok(out)
+}
+
+fn product(v: &[f64]) -> f64 {
+    if v.is_empty() { 0.0 } else { v.iter().product() }
+}
+
+pub(super) fn min_of(v: &[f64]) -> f64 {
+    if v.is_empty() { 0.0 } else { v.iter().copied().fold(f64::INFINITY, f64::min) }
+}
+
+pub(super) fn max_of(v: &[f64]) -> f64 {
+    if v.is_empty() { 0.0 } else { v.iter().copied().fold(f64::NEG_INFINITY, f64::max) }
+}
+
+/// k-th largest (k is rounded up like Excel).
+fn kth(v: Vec<f64>, k: f64, largest: bool) -> R<f64> {
+    let k = k.ceil();
+    if k.is_nan() || k < 1.0 || k > v.len() as f64 {
+        return Err(CellError::Num);
+    }
+    let s = sorted(v);
+    let k = k as usize;
+    let idx = if largest { s.len() - k } else { k - 1 };
+    s.get(idx).copied().ok_or(CellError::Num)
+}
+
+fn interp(s: &[f64], pos: f64) -> R<f64> {
+    let i = pos.floor();
+    let frac = pos - i;
+    let i = i as usize;
+    let lo = *s.get(i).ok_or(CellError::Num)?;
+    match s.get(i + 1) {
+        Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)),
+        _ => Ok(lo),
+    }
+}
+
+pub(super) fn percentile_inc(v: Vec<f64>, k: f64) -> R<f64> {
+    if v.is_empty() || !(0.0..=1.0).contains(&k) {
+        return Err(CellError::Num);
+    }
+    let s = sorted(v);
+    interp(&s, k * (s.len() - 1) as f64)
+}
+
+pub(super) fn percentile_exc(v: Vec<f64>, k: f64) -> R<f64> {
+    let n = v.len() as f64;
+    if v.is_empty() || !(k > 0.0 && k < 1.0) {
+        return Err(CellError::Num);
+    }
+    let pos = k * (n + 1.0);
+    if pos < 1.0 || pos > n {
+        return Err(CellError::Num);
+    }
+    let s = sorted(v);
+    interp(&s, pos - 1.0)
+}
+
+pub(super) fn quartile_inc(v: Vec<f64>, q: f64) -> R<f64> {
+    let q = q.trunc();
+    if !(0.0..=4.0).contains(&q) {
+        return Err(CellError::Num);
+    }
+    percentile_inc(v, q / 4.0)
+}
+
+pub(super) fn quartile_exc(v: Vec<f64>, q: f64) -> R<f64> {
+    let q = q.trunc();
+    if !(1.0..=3.0).contains(&q) {
+        return Err(CellError::Num);
+    }
+    percentile_exc(v, q / 4.0)
+}
+
+pub(super) fn arg_nums(a: &[Arg], i: usize) -> R<Vec<f64>> {
+    array_numbers(&arg(a, i)?.value)
+}
+
+/// Pairs of numbers at matching positions of two arrays (pairs with a non-number skipped).
+/// Different sizes give `#N/A`; errors propagate.
+fn pairs(x: &Value, y: &Value) -> R<(Vec<f64>, Vec<f64>)> {
+    let xa = as_array(x);
+    let ya = as_array(y);
+    if xa.data.len() != ya.data.len() {
+        return Err(CellError::NA);
+    }
+    let mut xs = Vec::new();
+    let mut ys = Vec::new();
+    for (a, b) in xa.data.iter().zip(ya.data.iter()) {
+        if let Value::Error(e) = a {
+            return Err(*e);
+        }
+        if let Value::Error(e) = b {
+            return Err(*e);
+        }
+        if let (Value::Number(p), Value::Number(q)) = (a, b) {
+            xs.push(*p);
+            ys.push(*q);
+        }
+    }
+    Ok((xs, ys))
+}
+
+pub(super) fn arg_pairs(a: &[Arg], i: usize, j: usize) -> R<(Vec<f64>, Vec<f64>)> {
+    pairs(&arg(a, i)?.value, &arg(a, j)?.value)
+}
+
+/// (sum of cross deviations, devsq x, devsq y, mean x, mean y).
+pub(super) fn moments(x: &[f64], y: &[f64]) -> R<(f64, f64, f64, f64, f64)> {
+    let mx = mean(x)?;
+    let my = mean(y)?;
+    let mut sxy = 0.0;
+    let mut sxx = 0.0;
+    let mut syy = 0.0;
+    for (a, b) in x.iter().zip(y) {
+        sxy += (a - mx) * (b - my);
+        sxx += (a - mx) * (a - mx);
+        syy += (b - my) * (b - my);
+    }
+    Ok((sxy, sxx, syy, mx, my))
+}
+
+pub(super) fn correl(x: &[f64], y: &[f64]) -> R<f64> {
+    if x.len() < 2 {
+        return Err(CellError::Div0);
+    }
+    let (sxy, sxx, syy, _, _) = moments(x, y)?;
+    if sxx == 0.0 || syy == 0.0 {
+        return Err(CellError::Div0);
+    }
+    Ok(sxy / (sxx * syy).sqrt())
+}
+
+pub(super) fn slope(y: &[f64], x: &[f64]) -> R<f64> {
+    let (sxy, sxx, _, _, _) = moments(x, y)?;
+    if sxx == 0.0 {
+        return Err(CellError::Div0);
+    }
+    Ok(sxy / sxx)
+}
+
+pub(super) fn intercept(y: &[f64], x: &[f64]) -> R<f64> {
+    let (sxy, sxx, _, mx, my) = moments(x, y)?;
+    if sxx == 0.0 {
+        return Err(CellError::Div0);
+    }
+    Ok(my - sxy / sxx * mx)
+}
+
+fn trunc_digits(r: f64, sig: f64) -> f64 {
+    let f = 10f64.powi(sig as i32);
+    if !f.is_finite() {
+        return r;
+    }
+    ((r * f) + 1e-9).floor() / f
+}
+
+fn col_value(v: Vec<f64>) -> R<Value> {
+    let n = v.len();
+    array_val(n, 1, v.into_iter().map(Value::Number).collect())
+}
+
+// ---------------------------------------------------------------------------------------------
+// Aggregates
+// ---------------------------------------------------------------------------------------------
+
+pub(super) fn count_impl(a: &[Arg]) -> f64 {
+    let mut c = 0usize;
+    for x in a {
+        match &x.value {
+            Value::Array(arr) => c += arr.iter().filter(|v| v.is_number()).count(),
+            Value::Number(_) => c += 1,
+            _ if x.from_ref => {}
+            Value::Bool(_) => c += 1,
+            Value::Text(t) if gridcraft_core::parse::parse_number_text(t).is_some() => c += 1,
+            _ => {}
+        }
+    }
+    c as f64
+}
+
+pub(super) fn counta_impl(a: &[Arg]) -> f64 {
+    let mut c = 0usize;
+    for x in a {
+        match &x.value {
+            Value::Array(arr) => c += arr.iter().filter(|v| !v.is_empty()).count(),
+            Value::Empty if x.from_ref => {}
+            _ => c += 1,
+        }
+    }
+    c as f64
+}
+
+pub(super) fn countblank(a: &[Arg], _: C) -> R<Value> {
+    let v = &arg(a, 0)?.value;
+    let blank = |x: &Value| matches!(x, Value::Empty) || matches!(x, Value::Text(t) if t.is_empty());
+    let c = match v {
+        Value::Array(arr) => arr.iter().filter(|x| blank(x)).count(),
+        x => usize::from(blank(x)),
+    };
+    num_val(c as f64)
+}
+
+pub(super) fn mode_mult(a: &[Arg], _: C) -> R<Value> {
+    let v = mode_numbers(a)?;
+    let m = modes(&v);
+    if m.is_empty() {
+        return Err(CellError::NA);
+    }
+    col_value(m)
+}
+
+pub(super) fn large(a: &[Arg], _: C) -> R<Value> {
+    num_val(kth(arg_nums(a, 0)?, num(a, 1)?, true)?)
+}
+
+pub(super) fn small(a: &[Arg], _: C) -> R<Value> {
+    num_val(kth(arg_nums(a, 0)?, num(a, 1)?, false)?)
+}
+
+pub(super) fn rank_impl(a: &[Arg], avg: bool) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = arg_nums(a, 1)?;
+    let asc = opt_num(a, 2, 0.0)? != 0.0;
+    let eq = v.iter().filter(|&&y| y == x).count();
+    if eq == 0 {
+        return Err(CellError::NA);
+    }
+    let before = v.iter().filter(|&&y| if asc { y < x } else { y > x }).count();
+    let r = before as f64 + 1.0;
+    num_val(if avg { r + (eq as f64 - 1.0) / 2.0 } else { r })
+}
+
+pub(super) fn percentrank_impl(a: &[Arg], exc: bool) -> R<Value> {
+    let s = sorted(arg_nums(a, 0)?);
+    let x = num(a, 1)?;
+    let sig = opt_num(a, 2, 3.0)?.trunc();
+    if sig < 1.0 || s.is_empty() {
+        return Err(CellError::Num);
+    }
+    let (first, last) = (s.first().copied().unwrap_or(0.0), s.last().copied().unwrap_or(0.0));
+    if x < first || x > last {
+        return Err(CellError::NA);
+    }
+    let n = s.len() as f64;
+    let rank_of = |v: f64| -> f64 {
+        let less = s.iter().filter(|&&y| y < v).count() as f64;
+        if exc {
+            (less + 1.0) / (n + 1.0)
+        } else if n <= 1.0 {
+            1.0
+        } else {
+            less / (n - 1.0)
+        }
+    };
+    let r = if s.contains(&x) {
+        rank_of(x)
+    } else {
+        let lo = s.iter().copied().filter(|&y| y < x).fold(f64::NEG_INFINITY, f64::max);
+        let hi = s.iter().copied().filter(|&y| y > x).fold(f64::INFINITY, f64::min);
+        let (rl, rh) = (rank_of(lo), rank_of(hi));
+        rl + (x - lo) / (hi - lo) * (rh - rl)
+    };
+    num_val(trunc_digits(r, sig))
+}
+
+pub(super) fn trimmean(a: &[Arg], _: C) -> R<Value> {
+    let v = arg_nums(a, 0)?;
+    let p = num(a, 1)?;
+    if !(0.0..1.0).contains(&p) || v.is_empty() {
+        return Err(CellError::Num);
+    }
+    let n = v.len();
+    let per_side = ((n as f64 * p) / 2.0).floor() as usize;
+    let s = sorted(v);
+    let kept = s.get(per_side..n - per_side).unwrap_or(&[]);
+    num_val(mean(kept)?)
+}
+
+pub(super) fn kurt(v: &[f64]) -> R<f64> {
+    let n = v.len() as f64;
+    if v.len() < 4 {
+        return Err(CellError::Div0);
+    }
+    let m = mean(v)?;
+    let s = var_s(v)?.sqrt();
+    if s == 0.0 {
+        return Err(CellError::Div0);
+    }
+    let sum4: f64 = v.iter().map(|x| ((x - m) / s).powi(4)).sum();
+    Ok(n * (n + 1.0) / ((n - 1.0) * (n - 2.0) * (n - 3.0)) * sum4 - 3.0 * (n - 1.0).powi(2) / ((n - 2.0) * (n - 3.0)))
+}
+
+pub(super) fn skew(v: &[f64]) -> R<f64> {
+    let n = v.len() as f64;
+    if v.len() < 3 {
+        return Err(CellError::Div0);
+    }
+    let m = mean(v)?;
+    let s = var_s(v)?.sqrt();
+    if s == 0.0 {
+        return Err(CellError::Div0);
+    }
+    let sum3: f64 = v.iter().map(|x| ((x - m) / s).powi(3)).sum();
+    Ok(n / ((n - 1.0) * (n - 2.0)) * sum3)
+}
+
+pub(super) fn skew_p(v: &[f64]) -> R<f64> {
+    let m = mean(v)?;
+    let s = var_p(v)?.sqrt();
+    if s == 0.0 {
+        return Err(CellError::Div0);
+    }
+    Ok(v.iter().map(|x| ((x - m) / s).powi(3)).sum::<f64>() / v.len() as f64)
+}
+
+pub(super) fn geomean(v: &[f64]) -> R<f64> {
+    if v.is_empty() || v.iter().any(|&x| x <= 0.0) {
+        return Err(CellError::Num);
+    }
+    Ok((v.iter().map(|x| x.ln()).sum::<f64>() / v.len() as f64).exp())
+}
+
+pub(super) fn harmean(v: &[f64]) -> R<f64> {
+    if v.is_empty() || v.iter().any(|&x| x <= 0.0) {
+        return Err(CellError::Num);
+    }
+    Ok(v.len() as f64 / v.iter().map(|x| 1.0 / x).sum::<f64>())
+}
+
+pub(super) fn avedev(v: &[f64]) -> R<f64> {
+    if v.is_empty() {
+        return Err(CellError::Num);
+    }
+    let m = mean(v)?;
+    Ok(v.iter().map(|x| (x - m).abs()).sum::<f64>() / v.len() as f64)
+}
+
+pub(super) fn frequency(a: &[Arg], _: C) -> R<Value> {
+    let data = arg_nums(a, 0)?;
+    let bins = arg_nums(a, 1)?;
+    if bins.is_empty() {
+        return col_value(vec![data.len() as f64]);
+    }
+    let mut order: Vec<usize> = (0..bins.len()).collect();
+    order.sort_by(|&i, &j| bins.get(i).copied().unwrap_or(0.0).total_cmp(&bins.get(j).copied().unwrap_or(0.0)));
+    let mut counts = vec![0.0; bins.len() + 1];
+    for x in data {
+        let slot = order.iter().find(|&&i| x <= bins.get(i).copied().unwrap_or(f64::INFINITY)).copied().unwrap_or(bins.len());
+        if let Some(c) = counts.get_mut(slot) {
+            *c += 1.0;
+        }
+    }
+    col_value(counts)
+}
+
+pub(super) fn prob(a: &[Arg], _: C) -> R<Value> {
+    let (xs, ps) = arg_pairs(a, 0, 1)?;
+    let lo = num(a, 2)?;
+    let hi = if has(a, 3) { num(a, 3)? } else { lo };
+    if ps.iter().any(|&p| p <= 0.0 || p > 1.0) {
+        return Err(CellError::Num);
+    }
+    let total: f64 = ps.iter().sum();
+    if (total - 1.0).abs() > 1e-7 {
+        return Err(CellError::Num);
+    }
+    num_val(xs.iter().zip(&ps).filter(|(x, _)| **x >= lo && **x <= hi).map(|(_, p)| p).sum())
+}
+
+pub(super) fn standardize(a: &[Arg], _: C) -> R<Value> {
+    let (x, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if sd <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((x - m) / sd)
+}
+
+// ---------------------------------------------------------------------------------------------
+// SUBTOTAL / AGGREGATE support
+// ---------------------------------------------------------------------------------------------
+
+/// Evaluates SUBTOTAL/AGGREGATE function `function_num` over already-filtered cell values.
+///
+/// Codes 1–11 (and 101–111) are AVERAGE, COUNT, COUNTA, MAX, MIN, PRODUCT, STDEV.S, STDEV.P,
+/// SUM, VAR.S, VAR.P; 12 = MEDIAN, 13 = MODE.SNGL. Codes 14–19 need `k`: use
+/// [`aggregate_values_k`] (they give `#VALUE!` here). Values that are not numbers are ignored
+/// (COUNTA counts non-empty values); the first error value present is returned.
+pub fn aggregate_values(function_num: u32, values: &[Value]) -> Value {
+    crate::util::finish(aggregate_impl(function_num, values, None))
+}
+
+/// AGGREGATE codes 14 = LARGE, 15 = SMALL, 16 = PERCENTILE.INC, 17 = QUARTILE.INC,
+/// 18 = PERCENTILE.EXC, 19 = QUARTILE.EXC with their `k` argument; codes 1–13 delegate to
+/// [`aggregate_values`].
+pub fn aggregate_values_k(function_num: u32, values: &[Value], k: &Value) -> Value {
+    crate::util::finish(aggregate_impl(function_num, values, Some(k)))
+}
+
+fn aggregate_impl(function_num: u32, values: &[Value], k: Option<&Value>) -> R<Value> {
+    let code = if (101..=111).contains(&function_num) { function_num - 100 } else { function_num };
+    let mut xs = Vec::new();
+    let mut nonempty = 0usize;
+    let mut push = |v: &Value| -> R<()> {
+        match v {
+            Value::Number(n) => xs.push(*n),
+            Value::Error(e) => return Err(*e),
+            _ => {}
+        }
+        if !v.is_empty() {
+            nonempty += 1;
+        }
+        Ok(())
+    };
+    for v in values {
+        match v {
+            Value::Array(arr) => arr.iter().try_for_each(&mut push)?,
+            other => push(other)?,
+        }
+    }
+    let k = match (code, k) {
+        (14..=19, Some(k)) => k.scalar().to_number()?,
+        (14..=19, None) => return Err(CellError::Value),
+        _ => 0.0,
+    };
+    let r = match code {
+        1 => mean(&xs)?,
+        2 => xs.len() as f64,
+        3 => nonempty as f64,
+        4 => max_of(&xs),
+        5 => min_of(&xs),
+        6 => product(&xs),
+        7 => var_s(&xs)?.sqrt(),
+        8 => var_p(&xs)?.sqrt(),
+        9 => xs.iter().sum(),
+        10 => var_s(&xs)?,
+        11 => var_p(&xs)?,
+        12 => median(xs)?,
+        13 => mode_sngl(&xs)?,
+        14 => kth(xs, k, true)?,
+        15 => kth(xs, k, false)?,
+        16 => percentile_inc(xs, k)?,
+        17 => quartile_inc(xs, k)?,
+        18 => percentile_exc(xs, k)?,
+        19 => quartile_exc(xs, k)?,
+        _ => return Err(CellError::Value),
+    };
+    num_val(r)
+}
diff --git a/crates/functions/src/stat/distributions.rs b/crates/functions/src/stat/distributions.rs
new file mode 100644
index 000000000..cb2f0398a
--- /dev/null
+++ b/crates/functions/src/stat/distributions.rs
@@ -0,0 +1,702 @@
+use super::descriptive::{arg_nums, arg_pairs, mean, var_s};
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Distributions
+// ---------------------------------------------------------------------------------------------
+
+fn ln_comb(n: f64, k: f64) -> f64 {
+    ln_gamma(n + 1.0) - ln_gamma(k + 1.0) - ln_gamma(n - k + 1.0)
+}
+
+fn t_upper(t: f64, v: f64) -> f64 {
+    // P(T > t) for t ≥ 0.
+    0.5 * reg_inc_beta(v / (v + t * t), v / 2.0, 0.5)
+}
+
+fn t_cdf(t: f64, v: f64) -> f64 {
+    if t >= 0.0 { 1.0 - t_upper(t, v) } else { t_upper(-t, v) }
+}
+
+fn t_pdf(t: f64, v: f64) -> f64 {
+    (ln_gamma((v + 1.0) / 2.0) - ln_gamma(v / 2.0) - 0.5 * (v * std::f64::consts::PI).ln() - (v + 1.0) / 2.0 * (1.0 + t * t / v).ln()).exp()
+}
+
+/// t ≥ 0 with P(T > t) = q, q in (0, 0.5].
+fn t_inv_upper(q: f64, v: f64) -> f64 {
+    if q >= 0.5 {
+        return 0.0;
+    }
+    invert(|t| t_upper(t, v), q, 0.0, 1.0, 1e60)
+}
+
+fn chi_inv(p: f64, v: f64) -> f64 {
+    if p <= 0.0 {
+        return 0.0;
+    }
+    invert(|x| reg_gamma_p(v / 2.0, x / 2.0), p, 0.0, v.max(1.0), 1e60)
+}
+
+fn chi_inv_rt(q: f64, v: f64) -> f64 {
+    if q >= 1.0 {
+        return 0.0;
+    }
+    invert(|x| reg_gamma_q(v / 2.0, x / 2.0), q, 0.0, v.max(1.0), 1e60)
+}
+
+fn f_cdf(x: f64, d1: f64, d2: f64) -> f64 {
+    if x <= 0.0 {
+        return 0.0;
+    }
+    reg_inc_beta(d1 * x / (d1 * x + d2), d1 / 2.0, d2 / 2.0)
+}
+
+fn f_upper(x: f64, d1: f64, d2: f64) -> f64 {
+    if x <= 0.0 {
+        return 1.0;
+    }
+    reg_inc_beta(d2 / (d2 + d1 * x), d2 / 2.0, d1 / 2.0)
+}
+
+fn f_pdf(x: f64, d1: f64, d2: f64) -> f64 {
+    if x == 0.0 {
+        return if d1 < 2.0 {
+            f64::INFINITY
+        } else if d1 == 2.0 {
+            1.0
+        } else {
+            0.0
+        };
+    }
+    ((d1 / 2.0) * (d1 / d2).ln() + (d1 / 2.0 - 1.0) * x.ln() - ((d1 + d2) / 2.0) * (1.0 + d1 * x / d2).ln() - ln_beta(d1 / 2.0, d2 / 2.0)).exp()
+}
+
+fn binom_pmf(k: f64, n: f64, p: f64) -> f64 {
+    if k < 0.0 || k > n {
+        return 0.0;
+    }
+    if p == 0.0 {
+        return if k == 0.0 { 1.0 } else { 0.0 };
+    }
+    if p == 1.0 {
+        return if k == n { 1.0 } else { 0.0 };
+    }
+    (ln_comb(n, k) + k * p.ln() + (n - k) * (1.0 - p).ln()).exp()
+}
+
+fn binom_cdf(k: f64, n: f64, p: f64) -> f64 {
+    if k < 0.0 {
+        return 0.0;
+    }
+    if k >= n {
+        return 1.0;
+    }
+    if n <= 10_000.0 {
+        let mut s = 0.0;
+        let mut i = 0.0;
+        while i <= k {
+            s += binom_pmf(i, n, p);
+            i += 1.0;
+        }
+        return s.min(1.0);
+    }
+    if p == 0.0 {
+        return 1.0;
+    }
+    if p == 1.0 {
+        return 0.0;
+    }
+    reg_inc_beta(1.0 - p, n - k, k + 1.0)
+}
+
+fn poisson_pmf(x: f64, m: f64) -> f64 {
+    if m == 0.0 {
+        return if x == 0.0 { 1.0 } else { 0.0 };
+    }
+    (-m + x * m.ln() - ln_gamma(x + 1.0)).exp()
+}
+
+fn poisson_cdf(x: f64, m: f64) -> f64 {
+    if m == 0.0 {
+        return 1.0;
+    }
+    if x <= 1000.0 {
+        let mut s = 0.0;
+        let mut i = 0.0;
+        while i <= x {
+            s += poisson_pmf(i, m);
+            i += 1.0;
+        }
+        return s.min(1.0);
+    }
+    reg_gamma_q(x + 1.0, m)
+}
+
+pub(super) fn norm_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, m, sd, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
+    if sd <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let z = (x - m) / sd;
+    num_val(if cum { norm_cdf(z) } else { norm_pdf(z) / sd })
+}
+
+pub(super) fn norm_inv_fn(a: &[Arg], _: C) -> R<Value> {
+    let (p, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if !(p > 0.0 && p < 1.0) || sd <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(m + sd * norm_inv(p))
+}
+
+pub(super) fn norm_s_dist(a: &[Arg], _: C) -> R<Value> {
+    let z = num(a, 0)?;
+    let cum = if a.len() > 1 { boolean(a, 1)? } else { true };
+    num_val(if cum { norm_cdf(z) } else { norm_pdf(z) })
+}
+
+pub(super) fn norm_s_inv(a: &[Arg], _: C) -> R<Value> {
+    let p = num(a, 0)?;
+    if !(p > 0.0 && p < 1.0) {
+        return Err(CellError::Num);
+    }
+    num_val(norm_inv(p))
+}
+
+fn df_arg(a: &[Arg], i: usize) -> R<f64> {
+    let v = num(a, i)?.trunc();
+    if v < 1.0 {
+        return Err(CellError::Num);
+    }
+    Ok(v)
+}
+
+pub(super) fn t_dist(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    let cum = boolean(a, 2)?;
+    num_val(if cum { t_cdf(x, v) } else { t_pdf(x, v) })
+}
+
+pub(super) fn t_dist_2t(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    if x < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(2.0 * t_upper(x, v))
+}
+
+pub(super) fn t_dist_rt(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    num_val(1.0 - t_cdf(x, v))
+}
+
+pub(super) fn tdist_legacy(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    let tails = num(a, 2)?.trunc();
+    if x < 0.0 || !(tails == 1.0 || tails == 2.0) {
+        return Err(CellError::Num);
+    }
+    num_val(tails * t_upper(x, v))
+}
+
+pub(super) fn t_inv(a: &[Arg], _: C) -> R<Value> {
+    let p = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    if !(p > 0.0 && p < 1.0) {
+        return Err(CellError::Num);
+    }
+    num_val(if p < 0.5 { -t_inv_upper(p, v) } else { t_inv_upper(1.0 - p, v) })
+}
+
+pub(super) fn t_inv_2t(a: &[Arg], _: C) -> R<Value> {
+    let p = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    if !(p > 0.0 && p <= 1.0) {
+        return Err(CellError::Num);
+    }
+    num_val(t_inv_upper(p / 2.0, v))
+}
+
+pub(super) fn t_test(a: &[Arg], _: C) -> R<Value> {
+    let tails = num(a, 2)?.trunc();
+    let ty = num(a, 3)?.trunc();
+    if !(tails == 1.0 || tails == 2.0) || !(1.0..=3.0).contains(&ty) {
+        return Err(CellError::Num);
+    }
+    let (t, v) = if ty == 1.0 {
+        let (x, y) = arg_pairs(a, 0, 1)?;
+        let d: Vec<f64> = x.iter().zip(&y).map(|(p, q)| p - q).collect();
+        let n = d.len() as f64;
+        let sd = var_s(&d)?.sqrt();
+        if sd == 0.0 {
+            return Err(CellError::Div0);
+        }
+        (mean(&d)? / (sd / n.sqrt()), n - 1.0)
+    } else {
+        let x = arg_nums(a, 0)?;
+        let y = arg_nums(a, 1)?;
+        let (n1, n2) = (x.len() as f64, y.len() as f64);
+        let (v1, v2) = (var_s(&x)?, var_s(&y)?);
+        let diff = mean(&x)? - mean(&y)?;
+        if ty == 2.0 {
+            let df = n1 + n2 - 2.0;
+            let sp = ((n1 - 1.0) * v1 + (n2 - 1.0) * v2) / df;
+            let se = (sp * (1.0 / n1 + 1.0 / n2)).sqrt();
+            if se == 0.0 {
+                return Err(CellError::Div0);
+            }
+            (diff / se, df)
+        } else {
+            let (a1, a2) = (v1 / n1, v2 / n2);
+            let se = (a1 + a2).sqrt();
+            if se == 0.0 {
+                return Err(CellError::Div0);
+            }
+            let df = (a1 + a2).powi(2) / (a1 * a1 / (n1 - 1.0) + a2 * a2 / (n2 - 1.0));
+            (diff / se, df)
+        }
+    };
+    num_val(tails * t_upper(t.abs(), v))
+}
+
+pub(super) fn chisq_dist(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    let cum = boolean(a, 2)?;
+    if x < 0.0 || v > 1e10 {
+        return Err(CellError::Num);
+    }
+    if cum {
+        return num_val(reg_gamma_p(v / 2.0, x / 2.0));
+    }
+    if x == 0.0 {
+        return if v == 2.0 {
+            num_val(0.5)
+        } else if v < 2.0 {
+            Err(CellError::Num)
+        } else {
+            num_val(0.0)
+        };
+    }
+    num_val(((v / 2.0 - 1.0) * x.ln() - x / 2.0 - (v / 2.0) * 2f64.ln() - ln_gamma(v / 2.0)).exp())
+}
+
+pub(super) fn chisq_dist_rt(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    if x < 0.0 || v > 1e10 {
+        return Err(CellError::Num);
+    }
+    num_val(reg_gamma_q(v / 2.0, x / 2.0))
+}
+
+pub(super) fn chisq_inv(a: &[Arg], _: C) -> R<Value> {
+    let p = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    if !(0.0..1.0).contains(&p) || v > 1e10 {
+        return Err(CellError::Num);
+    }
+    num_val(chi_inv(p, v))
+}
+
+pub(super) fn chisq_inv_rt(a: &[Arg], _: C) -> R<Value> {
+    let p = num(a, 0)?;
+    let v = df_arg(a, 1)?;
+    if !(p > 0.0 && p <= 1.0) || v > 1e10 {
+        return Err(CellError::Num);
+    }
+    num_val(chi_inv_rt(p, v))
+}
+
+pub(super) fn chisq_test(a: &[Arg], _: C) -> R<Value> {
+    let act = as_array(&arg(a, 0)?.value).into_owned();
+    let exp = as_array(&arg(a, 1)?.value).into_owned();
+    if act.rows != exp.rows || act.cols != exp.cols {
+        return Err(CellError::NA);
+    }
+    let mut x2 = 0.0;
+    for (o, e) in act.data.iter().zip(&exp.data) {
+        if let Value::Error(err) = o {
+            return Err(*err);
+        }
+        if let Value::Error(err) = e {
+            return Err(*err);
+        }
+        if let (Value::Number(o), Value::Number(e)) = (o, e) {
+            if *e == 0.0 {
+                return Err(CellError::Div0);
+            }
+            x2 += (o - e).powi(2) / e;
+        }
+    }
+    let df = if act.rows > 1 && act.cols > 1 { ((act.rows - 1) * (act.cols - 1)) as f64 } else { (act.data.len().saturating_sub(1)) as f64 };
+    if df < 1.0 {
+        return Err(CellError::NA);
+    }
+    num_val(reg_gamma_q(df / 2.0, x2 / 2.0))
+}
+
+fn f_args(a: &[Arg]) -> R<(f64, f64, f64)> {
+    let x = num(a, 0)?;
+    let d1 = num(a, 1)?.trunc();
+    let d2 = num(a, 2)?.trunc();
+    if d1 < 1.0 || d2 < 1.0 || d1 >= 1e10 || d2 >= 1e10 {
+        return Err(CellError::Num);
+    }
+    Ok((x, d1, d2))
+}
+
+pub(super) fn f_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, d1, d2) = f_args(a)?;
+    let cum = boolean(a, 3)?;
+    if x < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(if cum { f_cdf(x, d1, d2) } else { f_pdf(x, d1, d2) })
+}
+
+pub(super) fn f_dist_rt(a: &[Arg], _: C) -> R<Value> {
+    let (x, d1, d2) = f_args(a)?;
+    if x < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(f_upper(x, d1, d2))
+}
+
+pub(super) fn f_inv(a: &[Arg], _: C) -> R<Value> {
+    let (p, d1, d2) = f_args(a)?;
+    if !(0.0..1.0).contains(&p) {
+        return Err(CellError::Num);
+    }
+    if p == 0.0 {
+        return num_val(0.0);
+    }
+    num_val(invert(|x| f_cdf(x, d1, d2), p, 0.0, 1.0, 1e60))
+}
+
+pub(super) fn f_inv_rt(a: &[Arg], _: C) -> R<Value> {
+    let (p, d1, d2) = f_args(a)?;
+    if !(p > 0.0 && p <= 1.0) {
+        return Err(CellError::Num);
+    }
+    if p == 1.0 {
+        return num_val(0.0);
+    }
+    num_val(invert(|x| f_upper(x, d1, d2), p, 0.0, 1.0, 1e60))
+}
+
+pub(super) fn f_test(a: &[Arg], _: C) -> R<Value> {
+    let x = arg_nums(a, 0)?;
+    let y = arg_nums(a, 1)?;
+    let (v1, v2) = (var_s(&x)?, var_s(&y)?);
+    if v1 == 0.0 || v2 == 0.0 {
+        return Err(CellError::Div0);
+    }
+    let f = v1 / v2;
+    let (d1, d2) = ((x.len() - 1) as f64, (y.len() - 1) as f64);
+    let c = f_cdf(f, d1, d2);
+    num_val((2.0 * c.min(1.0 - c)).min(1.0))
+}
+
+pub(super) fn binom_dist(a: &[Arg], _: C) -> R<Value> {
+    let k = num(a, 0)?.trunc();
+    let n = num(a, 1)?.trunc();
+    let p = num(a, 2)?;
+    let cum = boolean(a, 3)?;
+    if k < 0.0 || k > n || !(0.0..=1.0).contains(&p) {
+        return Err(CellError::Num);
+    }
+    num_val(if cum { binom_cdf(k, n, p) } else { binom_pmf(k, n, p) })
+}
+
+pub(super) fn binom_dist_range(a: &[Arg], _: C) -> R<Value> {
+    let n = num(a, 0)?.trunc();
+    let p = num(a, 1)?;
+    let s1 = num(a, 2)?.trunc();
+    let s2 = if has(a, 3) { num(a, 3)?.trunc() } else { s1 };
+    if !(0.0..=1e15).contains(&n) || !(0.0..=1.0).contains(&p) || s1 < 0.0 || s1 > n || s2 < s1 || s2 > n {
+        return Err(CellError::Num);
+    }
+    if s2 - s1 > 10_000.0 {
+        return num_val(binom_cdf(s2, n, p) - binom_cdf(s1 - 1.0, n, p));
+    }
+    let mut s = 0.0;
+    let mut k = s1;
+    while k <= s2 {
+        s += binom_pmf(k, n, p);
+        k += 1.0;
+    }
+    num_val(s)
+}
+
+pub(super) fn binom_inv(a: &[Arg], _: C) -> R<Value> {
+    let n = num(a, 0)?.trunc();
+    let p = num(a, 1)?;
+    let alpha = num(a, 2)?;
+    if n < 0.0 || !(0.0..=1.0).contains(&p) || !(0.0..=1.0).contains(&alpha) {
+        return Err(CellError::Num);
+    }
+    // Smallest k with cdf(k) ≥ alpha, by bisection on the integer k.
+    let (mut lo, mut hi) = (0.0f64, n);
+    if binom_cdf(0.0, n, p) >= alpha {
+        return num_val(0.0);
+    }
+    while hi - lo > 1.0 {
+        let mid = ((lo + hi) / 2.0).floor();
+        // Above 2^53 adjacent f64 values are more than 1 apart, so the gap can stop shrinking.
+        if mid <= lo || mid >= hi {
+            break;
+        }
+        if binom_cdf(mid, n, p) >= alpha {
+            hi = mid;
+        } else {
+            lo = mid;
+        }
+    }
+    num_val(hi)
+}
+
+pub(super) fn poisson_dist(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?.trunc();
+    let m = num(a, 1)?;
+    let cum = boolean(a, 2)?;
+    if x < 0.0 || m < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(if cum { poisson_cdf(x, m) } else { poisson_pmf(x, m) })
+}
+
+pub(super) fn expon_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, l, cum) = (num(a, 0)?, num(a, 1)?, boolean(a, 2)?);
+    if x < 0.0 || l <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(if cum { -(-l * x).exp_m1() } else { l * (-l * x).exp() })
+}
+
+pub(super) fn gamma_fn(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let g = gamma(x);
+    if !g.is_finite() {
+        return Err(CellError::Num);
+    }
+    num_val(g)
+}
+
+pub(super) fn gamma_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, al, be, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
+    if x < 0.0 || al <= 0.0 || be <= 0.0 {
+        return Err(CellError::Num);
+    }
+    if cum {
+        return num_val(reg_gamma_p(al, x / be));
+    }
+    if x == 0.0 {
+        return if al < 1.0 {
+            Err(CellError::Num)
+        } else if al == 1.0 {
+            num_val(1.0 / be)
+        } else {
+            num_val(0.0)
+        };
+    }
+    num_val(((al - 1.0) * x.ln() - x / be - al * be.ln() - ln_gamma(al)).exp())
+}
+
+pub(super) fn gamma_inv(a: &[Arg], _: C) -> R<Value> {
+    let (p, al, be) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if !(0.0..1.0).contains(&p) || al <= 0.0 || be <= 0.0 {
+        return Err(CellError::Num);
+    }
+    if p == 0.0 {
+        return num_val(0.0);
+    }
+    num_val(invert(|x| reg_gamma_p(al, x / be), p, 0.0, (al * be).max(1e-3), 1e60))
+}
+
+pub(super) fn gammaln(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    if x <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(ln_gamma(x))
+}
+
+fn beta_bounds(a: &[Arg], i: usize) -> R<(f64, f64)> {
+    let lo = if has(a, i) { num(a, i)? } else { 0.0 };
+    let hi = if has(a, i + 1) { num(a, i + 1)? } else { 1.0 };
+    if lo >= hi {
+        return Err(CellError::Num);
+    }
+    Ok((lo, hi))
+}
+
+pub(super) fn beta_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, al, be, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
+    let (lo, hi) = beta_bounds(a, 4)?;
+    if al <= 0.0 || be <= 0.0 || x < lo || x > hi {
+        return Err(CellError::Num);
+    }
+    let z = (x - lo) / (hi - lo);
+    if cum {
+        return num_val(reg_inc_beta(z, al, be));
+    }
+    if (z == 0.0 && al < 1.0) || (z == 1.0 && be < 1.0) {
+        return Err(CellError::Num);
+    }
+    let lp = if z == 0.0 || z == 1.0 {
+        let base = if z == 0.0 { al } else { be };
+        if base == 1.0 { -ln_beta(al, be) } else { f64::NEG_INFINITY }
+    } else {
+        (al - 1.0) * z.ln() + (be - 1.0) * (1.0 - z).ln() - ln_beta(al, be)
+    };
+    num_val(lp.exp() / (hi - lo))
+}
+
+pub(super) fn betadist_legacy(a: &[Arg], _: C) -> R<Value> {
+    let (x, al, be) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let (lo, hi) = beta_bounds(a, 3)?;
+    if al <= 0.0 || be <= 0.0 || x < lo || x > hi {
+        return Err(CellError::Num);
+    }
+    num_val(reg_inc_beta((x - lo) / (hi - lo), al, be))
+}
+
+pub(super) fn beta_inv(a: &[Arg], _: C) -> R<Value> {
+    let (p, al, be) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let (lo, hi) = beta_bounds(a, 3)?;
+    if al <= 0.0 || be <= 0.0 || !(0.0..=1.0).contains(&p) {
+        return Err(CellError::Num);
+    }
+    let z = if p == 0.0 {
+        0.0
+    } else if p == 1.0 {
+        1.0
+    } else {
+        invert(|x| reg_inc_beta(x, al, be), p, 0.0, 1.0, 1.0)
+    };
+    num_val(lo + z * (hi - lo))
+}
+
+pub(super) fn lognorm_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let cum = if a.len() > 3 { boolean(a, 3)? } else { true };
+    if x <= 0.0 || sd <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let z = (x.ln() - m) / sd;
+    num_val(if cum { norm_cdf(z) } else { norm_pdf(z) / (x * sd) })
+}
+
+pub(super) fn lognorm_inv(a: &[Arg], _: C) -> R<Value> {
+    let (p, m, sd) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if !(p > 0.0 && p < 1.0) || sd <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((m + sd * norm_inv(p)).exp())
+}
+
+pub(super) fn weibull_dist(a: &[Arg], _: C) -> R<Value> {
+    let (x, al, be, cum) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, boolean(a, 3)?);
+    if x < 0.0 || al <= 0.0 || be <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let t = (x / be).powf(al);
+    num_val(if cum { -(-t).exp_m1() } else { al / be.powf(al) * x.powf(al - 1.0) * (-t).exp() })
+}
+
+pub(super) fn hypgeom_dist(a: &[Arg], _: C) -> R<Value> {
+    let k = num(a, 0)?.trunc();
+    let n = num(a, 1)?.trunc();
+    let kk = num(a, 2)?.trunc();
+    let nn = num(a, 3)?.trunc();
+    let cum = if a.len() > 4 { boolean(a, 4)? } else { false };
+    if k < 0.0 || n <= 0.0 || kk <= 0.0 || nn <= 0.0 || n > nn || kk > nn || k > n.min(kk) || k < (n - nn + kk).max(0.0) {
+        return Err(CellError::Num);
+    }
+    let pmf = |i: f64| (ln_comb(kk, i) + ln_comb(nn - kk, n - i) - ln_comb(nn, n)).exp();
+    if !cum {
+        return num_val(pmf(k));
+    }
+    let mut s = 0.0;
+    let mut i = (n - nn + kk).max(0.0);
+    if k - i > 1e6 || i + 1.0 == i {
+        return Err(CellError::Num);
+    }
+    while i <= k {
+        s += pmf(i);
+        i += 1.0;
+    }
+    num_val(s.min(1.0))
+}
+
+pub(super) fn negbinom_dist(a: &[Arg], _: C) -> R<Value> {
+    let f = num(a, 0)?.trunc();
+    let s = num(a, 1)?.trunc();
+    let p = num(a, 2)?;
+    let cum = if a.len() > 3 { boolean(a, 3)? } else { false };
+    if f < 0.0 || s < 1.0 || !(0.0..=1.0).contains(&p) {
+        return Err(CellError::Num);
+    }
+    if cum {
+        if p == 0.0 {
+            return num_val(0.0);
+        }
+        return num_val(reg_inc_beta(p, s, f + 1.0));
+    }
+    if p == 0.0 || p == 1.0 {
+        return num_val(if p == 1.0 && f == 0.0 { 1.0 } else { 0.0 });
+    }
+    num_val((ln_comb(f + s - 1.0, s - 1.0) + s * p.ln() + f * (1.0 - p).ln()).exp())
+}
+
+pub(super) fn confidence_norm(a: &[Arg], _: C) -> R<Value> {
+    let (al, sd, n) = (num(a, 0)?, num(a, 1)?, num(a, 2)?.trunc());
+    if !(al > 0.0 && al < 1.0) || sd <= 0.0 || n < 1.0 {
+        return Err(CellError::Num);
+    }
+    num_val(norm_inv(1.0 - al / 2.0) * sd / n.sqrt())
+}
+
+pub(super) fn confidence_t(a: &[Arg], _: C) -> R<Value> {
+    let (al, sd, n) = (num(a, 0)?, num(a, 1)?, num(a, 2)?.trunc());
+    if !(al > 0.0 && al < 1.0) || sd <= 0.0 || n < 1.0 {
+        return Err(CellError::Num);
+    }
+    if n == 1.0 {
+        return Err(CellError::Div0);
+    }
+    num_val(t_inv_upper(al / 2.0, n - 1.0) * sd / n.sqrt())
+}
+
+pub(super) fn z_test(a: &[Arg], _: C) -> R<Value> {
+    let v = arg_nums(a, 0)?;
+    let x = num(a, 1)?;
+    if v.is_empty() {
+        return Err(CellError::NA);
+    }
+    let sd = if has(a, 2) { num(a, 2)? } else { var_s(&v)?.sqrt() };
+    if sd <= 0.0 {
+        return Err(if has(a, 2) { CellError::Num } else { CellError::Div0 });
+    }
+    let z = (mean(&v)? - x) / (sd / (v.len() as f64).sqrt());
+    num_val(1.0 - norm_cdf(z))
+}
+
+pub(super) fn fisher(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    if x <= -1.0 || x >= 1.0 {
+        return Err(CellError::Num);
+    }
+    num_val(0.5 * ((1.0 + x) / (1.0 - x)).ln())
+}
+
+pub(super) fn gauss(a: &[Arg], _: C) -> R<Value> {
+    let z = num(a, 0)?;
+    // Φ(z) − 0.5 = erf(z/√2)/2, accurate near zero.
+    num_val(0.5 * erf(z / std::f64::consts::SQRT_2))
+}
diff --git a/crates/functions/src/stat/regression.rs b/crates/functions/src/stat/regression.rs
new file mode 100644
index 000000000..410b086d4
--- /dev/null
+++ b/crates/functions/src/stat/regression.rs
@@ -0,0 +1,342 @@
+use super::descriptive::{arg_pairs, intercept, moments, slope};
+use super::*;
+
+pub(super) fn forecast(a: &[Arg], _: C) -> R<Value> {
+    let x = num(a, 0)?;
+    let (ys, xs) = arg_pairs(a, 1, 2)?;
+    if ys.is_empty() {
+        return Err(CellError::Div0);
+    }
+    num_val(intercept(&ys, &xs)? + slope(&ys, &xs)? * x)
+}
+
+pub(super) fn steyx(a: &[Arg], _: C) -> R<Value> {
+    let (ys, xs) = arg_pairs(a, 0, 1)?;
+    let n = ys.len() as f64;
+    if ys.len() < 3 {
+        return Err(CellError::Div0);
+    }
+    let (sxy, sxx, syy, _, _) = moments(&xs, &ys)?;
+    if sxx == 0.0 {
+        return Err(CellError::Div0);
+    }
+    num_val(((syy - sxy * sxy / sxx) / (n - 2.0)).max(0.0).sqrt())
+}
+
+pub(super) fn covariance(a: &[Arg], sample: bool) -> R<Value> {
+    let (xs, ys) = arg_pairs(a, 0, 1)?;
+    let n = xs.len();
+    if n == 0 || (sample && n < 2) {
+        return Err(CellError::Div0);
+    }
+    let (sxy, ..) = moments(&xs, &ys)?;
+    num_val(sxy / if sample { (n - 1) as f64 } else { n as f64 })
+}
+
+// ---------------------------------------------------------------------------------------------
+// Regression (LINEST, LOGEST, TREND, GROWTH)
+// ---------------------------------------------------------------------------------------------
+
+struct Xy {
+    y: Vec<f64>,
+    /// n rows of k predictor values.
+    x: Vec<Vec<f64>>,
+    k: usize,
+    y_is_row: bool,
+    y_rows: usize,
+    y_cols: usize,
+}
+
+fn strict_num(v: &Value) -> R<f64> {
+    match v {
+        Value::Number(n) => Ok(*n),
+        Value::Error(e) => Err(*e),
+        _ => Err(CellError::Value),
+    }
+}
+
+/// Most predictor columns LINEST, LOGEST, TREND and GROWTH accept. The normal equations are a
+/// k×k matrix inverted in O(k³), so an unbounded k (one `SEQUENCE(1,16384)` argument) allocated
+/// gigabytes and could abort the process.
+pub(super) const MAX_REGRESSORS: usize = 255;
+
+/// Most multiply-adds (rows × k²) a regression may spend building its normal equations.
+const MAX_REGRESSION_WORK: usize = 1_000_000_000;
+
+/// Rejects regressions too large to fit: more than [`MAX_REGRESSORS`] predictors is `#VALUE!`,
+/// more than [`MAX_REGRESSION_WORK`] multiply-adds is `#NUM!`.
+pub(super) fn check_regression_size(n: usize, k: usize) -> R<()> {
+    if k > MAX_REGRESSORS {
+        return Err(CellError::Value);
+    }
+    match n.checked_mul(k).and_then(|nk| nk.checked_mul(k)) {
+        Some(work) if work <= MAX_REGRESSION_WORK => Ok(()),
+        _ => Err(CellError::Num),
+    }
+}
+
+fn parse_xy(y: &Value, x: Option<&Value>) -> R<Xy> {
+    let ya = as_array(y);
+    let n = ya.data.len();
+    let y_is_row = ya.rows == 1 && ya.cols > 1;
+    let yv: Vec<f64> = ya.data.iter().map(strict_num).collect::<R<_>>()?;
+    let (xs, k) = match x {
+        None => ((1..=n).map(|i| vec![i as f64]).collect(), 1),
+        Some(xv) => {
+            let xa = as_array(xv);
+            if xa.rows == ya.rows && xa.cols == ya.cols {
+                (xa.data.iter().map(|v| strict_num(v).map(|f| vec![f])).collect::<R<Vec<_>>>()?, 1)
+            } else if !y_is_row && xa.rows == n {
+                check_regression_size(n, xa.cols)?;
+                let mut rows = Vec::with_capacity(n);
+                for r in 0..n {
+                    rows.push((0..xa.cols).map(|c| strict_num(xa.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?);
+                }
+                (rows, xa.cols)
+            } else if y_is_row && xa.cols == n {
+                check_regression_size(n, xa.rows)?;
+                let mut rows = Vec::with_capacity(n);
+                for c in 0..n {
+                    rows.push((0..xa.rows).map(|r| strict_num(xa.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?);
+                }
+                (rows, xa.rows)
+            } else {
+                return Err(CellError::Ref);
+            }
+        }
+    };
+    Ok(Xy { y: yv, x: xs, k, y_is_row, y_rows: ya.rows, y_cols: ya.cols })
+}
+
+struct Fit {
+    coef: Vec<f64>,
+    b: f64,
+    se: Vec<f64>,
+    se_b: Option<f64>,
+    r2: R<f64>,
+    sey: R<f64>,
+    f: R<f64>,
+    df: f64,
+    ssreg: f64,
+    ssresid: f64,
+}
+
+/// Inverts a symmetric positive semi-definite matrix by Gauss–Jordan on the diagonal, dropping
+/// (zeroing) collinear variables. Returns the inverse and the dropped flags.
+fn sym_inverse(m: &[Vec<f64>]) -> (Vec<Vec<f64>>, Vec<bool>) {
+    let p = m.len();
+    let mut a: Vec<Vec<f64>> = m.to_vec();
+    let mut inv: Vec<Vec<f64>> = (0..p).map(|i| (0..p).map(|j| if i == j { 1.0 } else { 0.0 }).collect()).collect();
+    let mut dropped = vec![false; p];
+    let diag: Vec<f64> = (0..p).map(|i| m.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0).abs()).collect();
+    for j in 0..p {
+        let piv = a.get(j).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
+        let scale = diag.get(j).copied().unwrap_or(0.0);
+        if piv.abs() <= 1e-12 * scale || piv.abs() < 1e-300 {
+            if let Some(d) = dropped.get_mut(j) {
+                *d = true;
+            }
+            for row in a.iter_mut() {
+                if let Some(v) = row.get_mut(j) {
+                    *v = 0.0;
+                }
+            }
+            if let Some(r) = a.get_mut(j) {
+                r.iter_mut().for_each(|v| *v = 0.0);
+            }
+            if let Some(r) = inv.get_mut(j) {
+                r.iter_mut().for_each(|v| *v = 0.0);
+            }
+            continue;
+        }
+        let arow: Vec<f64> = a.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
+        let irow: Vec<f64> = inv.get(j).map(|r| r.iter().map(|v| v / piv).collect()).unwrap_or_default();
+        for i in 0..p {
+            if i == j {
+                continue;
+            }
+            let f = a.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
+            if f == 0.0 {
+                continue;
+            }
+            if let Some(r) = a.get_mut(i) {
+                r.iter_mut().zip(&arow).for_each(|(v, w)| *v -= f * w);
+            }
+            if let Some(r) = inv.get_mut(i) {
+                r.iter_mut().zip(&irow).for_each(|(v, w)| *v -= f * w);
+            }
+        }
+        if let Some(r) = a.get_mut(j) {
+            *r = arow;
+        }
+        if let Some(r) = inv.get_mut(j) {
+            *r = irow;
+        }
+    }
+    (inv, dropped)
+}
+
+fn regress(y: &[f64], x: &[Vec<f64>], k: usize, constant: bool) -> R<Fit> {
+    let n = y.len();
+    if n == 0 || x.len() != n {
+        return Err(CellError::Value);
+    }
+    check_regression_size(n, k)?;
+    let nf = n as f64;
+    let (xm, ym) = if constant {
+        let xm: Vec<f64> = (0..k).map(|j| x.iter().map(|r| r.get(j).copied().unwrap_or(0.0)).sum::<f64>() / nf).collect();
+        (xm, y.iter().sum::<f64>() / nf)
+    } else {
+        (vec![0.0; k], 0.0)
+    };
+    // Normal equations on (centred) data.
+    let mut xtx = vec![vec![0.0; k]; k];
+    let mut xty = vec![0.0; k];
+    for (row, yv) in x.iter().zip(y) {
+        let d: Vec<f64> = (0..k).map(|j| row.get(j).copied().unwrap_or(0.0) - xm.get(j).copied().unwrap_or(0.0)).collect();
+        let yd = yv - ym;
+        for (i, di) in d.iter().enumerate() {
+            if let Some(t) = xty.get_mut(i) {
+                *t += di * yd;
+            }
+            if let Some(r) = xtx.get_mut(i) {
+                for (j, dj) in d.iter().enumerate() {
+                    if let Some(v) = r.get_mut(j) {
+                        *v += di * dj;
+                    }
+                }
+            }
+        }
+    }
+    let (inv, dropped) = sym_inverse(&xtx);
+    let coef: Vec<f64> = (0..k).map(|i| inv.get(i).map(|r| r.iter().zip(&xty).map(|(a, b)| a * b).sum()).unwrap_or(0.0)).collect();
+    let b = if constant { ym - coef.iter().zip(&xm).map(|(c, m)| c * m).sum::<f64>() } else { 0.0 };
+    let mut ssresid = 0.0;
+    let mut sstot = 0.0;
+    for (row, yv) in x.iter().zip(y) {
+        let pred = b + coef.iter().zip(row).map(|(c, v)| c * v).sum::<f64>();
+        ssresid += (yv - pred).powi(2);
+        sstot += if constant { (yv - ym).powi(2) } else { yv * yv };
+    }
+    let used = dropped.iter().filter(|d| !**d).count() + usize::from(constant);
+    let df = nf - used as f64;
+    let ssreg = sstot - ssresid;
+    let r2 = if sstot == 0.0 { Err(CellError::Num) } else { Ok(ssreg / sstot) };
+    let sey2 = if df > 0.0 { Ok(ssresid / df) } else { Err(CellError::Num) };
+    let sey = sey2.map(f64::sqrt);
+    let v1 = if constant { nf - df - 1.0 } else { nf - df };
+    let f = match sey2 {
+        Ok(s2) if s2 > 0.0 && v1 > 0.0 => Ok((ssreg / v1) / s2),
+        _ => Err(CellError::Num),
+    };
+    let s2 = sey2.unwrap_or(f64::NAN);
+    let se: Vec<f64> = (0..k)
+        .map(|i| if dropped.get(i).copied().unwrap_or(true) { 0.0 } else { (inv.get(i).and_then(|r| r.get(i)).copied().unwrap_or(0.0) * s2).sqrt() })
+        .collect();
+    let se_b = if constant {
+        let mut q = 0.0;
+        for (i, mi) in xm.iter().enumerate() {
+            for (j, mj) in xm.iter().enumerate() {
+                q += mi * mj * inv.get(i).and_then(|r| r.get(j)).copied().unwrap_or(0.0);
+            }
+        }
+        Some((s2 * (1.0 / nf + q)).sqrt())
+    } else {
+        None
+    };
+    Ok(Fit { coef, b, se, se_b, r2, sey, f, df, ssreg, ssresid })
+}
+
+fn const_arg(a: &[Arg], i: usize) -> R<bool> {
+    if has(a, i) { boolean(a, i) } else { Ok(true) }
+}
+
+fn opt_value(a: &[Arg], i: usize) -> Option<&Value> {
+    if has(a, i) { a.get(i).map(|x| &x.value) } else { None }
+}
+
+pub(super) fn linest_impl(a: &[Arg], log: bool) -> R<Value> {
+    let mut xy = parse_xy(&arg(a, 0)?.value, opt_value(a, 1))?;
+    if log {
+        if xy.y.iter().any(|&v| v <= 0.0) {
+            return Err(CellError::Num);
+        }
+        xy.y.iter_mut().for_each(|v| *v = v.ln());
+    }
+    let constant = const_arg(a, 2)?;
+    let stats = if has(a, 3) { boolean(a, 3)? } else { false };
+    let fit = regress(&xy.y, &xy.x, xy.k, constant)?;
+    let tr = |v: f64| if log { v.exp() } else { v };
+    let cols = xy.k + 1;
+    let mut data: Vec<Value> = Vec::new();
+    for c in fit.coef.iter().rev() {
+        data.push(Value::number(tr(*c)));
+    }
+    data.push(Value::number(tr(fit.b)));
+    if stats {
+        let rv = |r: R<f64>| r.map(Value::number).unwrap_or_else(Value::Error);
+        let na = Value::Error(CellError::NA);
+        for s in fit.se.iter().rev() {
+            data.push(Value::number(*s));
+        }
+        data.push(fit.se_b.map(Value::number).unwrap_or(na.clone()));
+        let rows: [[Value; 2]; 3] =
+            [[rv(fit.r2), rv(fit.sey)], [rv(fit.f), Value::number(fit.df)], [Value::number(fit.ssreg), Value::number(fit.ssresid)]];
+        for [p, q] in rows {
+            data.push(p);
+            if cols > 1 {
+                data.push(q);
+            }
+            for _ in 2..cols {
+                data.push(na.clone());
+            }
+        }
+        return array_val(5, cols, data);
+    }
+    array_val(1, cols, data)
+}
+
+pub(super) fn trend_impl(a: &[Arg], log: bool) -> R<Value> {
+    let mut xy = parse_xy(&arg(a, 0)?.value, opt_value(a, 1))?;
+    if log {
+        if xy.y.iter().any(|&v| v <= 0.0) {
+            return Err(CellError::Num);
+        }
+        xy.y.iter_mut().for_each(|v| *v = v.ln());
+    }
+    let constant = const_arg(a, 3)?;
+    let fit = regress(&xy.y, &xy.x, xy.k, constant)?;
+    let predict = |row: &[f64]| -> Value {
+        let v = fit.b + fit.coef.iter().zip(row).map(|(c, x)| c * x).sum::<f64>();
+        Value::number(if log { v.exp() } else { v })
+    };
+    match opt_value(a, 2) {
+        None => {
+            let data: Vec<Value> = xy.x.iter().map(|r| predict(r)).collect();
+            array_val(xy.y_rows, xy.y_cols, data)
+        }
+        Some(nv) => {
+            let na = as_array(nv);
+            if xy.k == 1 {
+                let data = na.data.iter().map(|v| strict_num(v).map(|x| predict(&[x]))).collect::<R<Vec<_>>>()?;
+                array_val(na.rows, na.cols, data)
+            } else if !xy.y_is_row && na.cols == xy.k {
+                let mut data = Vec::with_capacity(na.rows);
+                for r in 0..na.rows {
+                    let row = (0..na.cols).map(|c| strict_num(na.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?;
+                    data.push(predict(&row));
+                }
+                array_val(na.rows, 1, data)
+            } else if xy.y_is_row && na.rows == xy.k {
+                let mut data = Vec::with_capacity(na.cols);
+                for c in 0..na.cols {
+                    let row = (0..na.rows).map(|r| strict_num(na.get(r, c).unwrap_or(&Value::Empty))).collect::<R<Vec<_>>>()?;
+                    data.push(predict(&row));
+                }
+                array_val(1, na.cols, data)
+            } else {
+                Err(CellError::Ref)
+            }
+        }
+    }
+}

From 17b29b891d1bc99d168e1ae87960a9cb83b7cbeb Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:37:47 +0000
Subject: [PATCH 59/76] refactor(functions): move financial.rs items to
 financial/

---
 crates/functions/src/financial.rs             | 1320 +----------------
 crates/functions/src/financial/day_count.rs   |  214 +++
 .../functions/src/financial/depreciation.rs   |  173 +++
 crates/functions/src/financial/securities.rs  |  512 +++++++
 crates/functions/src/financial/tvm.rs         |  415 ++++++
 5 files changed, 1328 insertions(+), 1306 deletions(-)
 create mode 100644 crates/functions/src/financial/day_count.rs
 create mode 100644 crates/functions/src/financial/depreciation.rs
 create mode 100644 crates/functions/src/financial/securities.rs
 create mode 100644 crates/functions/src/financial/tvm.rs

diff --git a/crates/functions/src/financial.rs b/crates/functions/src/financial.rs
index 22c926185..b569c1617 100644
--- a/crates/functions/src/financial.rs
+++ b/crates/functions/src/financial.rs
@@ -9,1318 +9,26 @@ use gridcraft_core::{CellError, DateSystem, Value};
 use crate::util::{R, S, array_numbers, as_array, flatten, has, num, num_val, numbers, opt_bool, opt_num, round_half_away, text, to_sig_digits};
 use crate::{Arg, Ctx, FnSpec, VAR};
 
-// ---------------------------------------------------------------------------------------------
-// Time value of money
-// ---------------------------------------------------------------------------------------------
+mod day_count;
+mod depreciation;
+mod securities;
+mod tvm;
 
-/// The payment per period. `(1 + rate)^nper` comes from `nper * ln_1p(rate)` and `p - 1` from
-/// `exp_m1`: rounding `1 + rate` first throws away the low bits of a small rate, which left PMT up to
-/// about 1000 ULPs from Excel (observed over 400 synthetic probes; this form is within 4). A loan
-/// schedule's last `IF(p - SUM(principal) > 0, ...)` turns on those bits. Excel gives #NUM! for a
-/// rate of -1 or less, and -pv*rate (no divide) once `(1 + rate)^nper` overflows.
-fn pmt_calc(rate: f64, nper: f64, pv: f64, fv: f64, typ: f64) -> f64 {
-    if rate == 0.0 {
-        return -(pv + fv) / nper;
-    }
-    if rate <= -1.0 {
-        return f64::NAN;
-    }
-    let l = nper * rate.ln_1p();
-    let m = l.exp_m1();
-    let k = 1.0 + rate * typ;
-    if m > 0.0 {
-        // (fv + pv*p) / (p - 1) = pv + (pv + fv) / (p - 1), without the cancellation in p - 1.
-        // rate / m (about 1 / nper for a tiny rate) is taken first so (pv + fv) / m can't overflow.
-        -(pv * rate + (pv + fv) * (rate / m)) / k
-    } else if m > -0.5 {
-        // p near 1 from below: fv + pv*p = (pv + fv) + pv*m keeps the small terms that rounding p would drop.
-        -(rate * (pv + fv + pv * m)) / (k * m)
-    } else {
-        // p well below 1: m nears -1 and pv*m would swallow pv + fv, so use p itself.
-        -(rate * (fv + pv * l.exp())) / (k * m)
-    }
-}
-
-fn fv_calc(rate: f64, nper: f64, pmt: f64, pv: f64, typ: f64) -> f64 {
-    if rate == 0.0 {
-        return -(pv + pmt * nper);
-    }
-    let p = (1.0 + rate).powf(nper);
-    -(pv * p + pmt * (1.0 + rate * typ) * (p - 1.0) / rate)
-}
-
-fn pv_calc(rate: f64, nper: f64, pmt: f64, fv: f64, typ: f64) -> f64 {
-    if rate == 0.0 {
-        return -(fv + pmt * nper);
-    }
-    let p = (1.0 + rate).powf(nper);
-    -(fv + pmt * (1.0 + rate * typ) * (p - 1.0) / rate) / p
-}
+use day_count::{coupdaybs, coupdays, coupdaysnc, coupncd, coupnum, couppcd};
+use depreciation::{amordegrc, amorlinc, db, ddb, sln, syd, vdb};
+use securities::{
+    accrint, accrintm, disc, duration, intrate, mduration, oddfprice, oddfyield, oddlprice, oddlyield, price, pricedisc, pricemat, received, tbilleq,
+    tbillprice, tbillyield, yield_, yielddisc, yieldmat,
+};
+use tvm::{
+    cumipmt, cumprinc, dollarde, dollarfr, effect, fv, fvschedule, ipmt, irr, ispmt, mirr, nominal, nper, npv, pduration, pmt, ppmt, pv, rate, rri,
+    xirr, xnpv,
+};
 
 fn type_arg(args: &[Arg], i: usize) -> R<f64> {
     Ok(if opt_num(args, i, 0.0)? != 0.0 { 1.0 } else { 0.0 })
 }
 
-fn pmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, nper, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let (fv, typ) = (opt_num(a, 3, 0.0)?, type_arg(a, 4)?);
-    if nper == 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(pmt_calc(rate, nper, pv, fv, typ))
-}
-
-fn fv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, nper, pmt) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    num_val(fv_calc(rate, nper, pmt, opt_num(a, 3, 0.0)?, type_arg(a, 4)?))
-}
-
-fn pv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, nper, pmt) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    num_val(pv_calc(rate, nper, pmt, opt_num(a, 3, 0.0)?, type_arg(a, 4)?))
-}
-
-fn nper(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, pmt, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let (fv, typ) = (opt_num(a, 3, 0.0)?, type_arg(a, 4)?);
-    if rate == 0.0 {
-        if pmt == 0.0 {
-            return Err(CellError::Num);
-        }
-        return num_val(-(pv + fv) / pmt);
-    }
-    let numer = pmt * (1.0 + rate * typ) - fv * rate;
-    let denom = pv * rate + pmt * (1.0 + rate * typ);
-    if denom == 0.0 {
-        return Err(CellError::Num);
-    }
-    let q = numer / denom;
-    if q <= 0.0 || rate <= -1.0 {
-        return Err(CellError::Num);
-    }
-    num_val(q.ln() / (1.0 + rate).ln())
-}
-
-fn ipmt_calc(rate: f64, per: f64, nper: f64, pv: f64, fv: f64, typ: f64) -> f64 {
-    let p = pmt_calc(rate, nper, pv, fv, typ);
-    if typ == 1.0 && per == 1.0 {
-        return 0.0;
-    }
-    let bal = fv_calc(rate, per - 1.0, p, pv, typ);
-    let i = bal * rate;
-    if typ == 1.0 { i / (1.0 + rate) } else { i }
-}
-
-fn ipmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, per, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
-    let (fv, typ) = (opt_num(a, 4, 0.0)?, type_arg(a, 5)?);
-    if per < 1.0 || per > np || np == 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(ipmt_calc(rate, per, np, pv, fv, typ))
-}
-
-fn ppmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, per, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
-    let (fv, typ) = (opt_num(a, 4, 0.0)?, type_arg(a, 5)?);
-    if per < 1.0 || per > np || np == 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(pmt_calc(rate, np, pv, fv, typ) - ipmt_calc(rate, per, np, pv, fv, typ))
-}
-
-fn cumulative(a: &[Arg], principal: bool) -> R<Value> {
-    let (rate, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let (start, end, typ) = (num(a, 3)?.trunc(), num(a, 4)?.trunc(), num(a, 5)?);
-    let np_i = np.trunc();
-    if rate <= 0.0 || np_i <= 0.0 || pv <= 0.0 || start < 1.0 || end < start || end > np_i || (typ != 0.0 && typ != 1.0) {
-        return Err(CellError::Num);
-    }
-    if end - start > 1e7 || np_i > 1e15 {
-        return Err(CellError::Num);
-    }
-    let p = pmt_calc(rate, np_i, pv, 0.0, typ);
-    let mut sum = 0.0;
-    let mut per = start;
-    while per <= end {
-        let i = ipmt_calc(rate, per, np_i, pv, 0.0, typ);
-        sum += if principal { p - i } else { i };
-        per += 1.0;
-    }
-    num_val(sum)
-}
-
-fn cumipmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    cumulative(a, false)
-}
-
-fn cumprinc(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    cumulative(a, true)
-}
-
-/// Newton iteration with a numeric derivative, keeping the rate above -1.
-fn newton(f: impl Fn(f64) -> f64, guess: f64) -> Option<f64> {
-    let mut x = guess;
-    for _ in 0..200 {
-        let y = f(x);
-        if !y.is_finite() {
-            return None;
-        }
-        let h = 1e-6 * x.abs().max(1e-3);
-        let d = (f(x + h) - f(x - h)) / (2.0 * h);
-        if d == 0.0 || !d.is_finite() {
-            return None;
-        }
-        let mut nx = x - y / d;
-        if nx <= -1.0 {
-            nx = (x - 1.0) / 2.0;
-            if nx <= -1.0 {
-                nx = -0.999_999_999;
-            }
-        }
-        if (nx - x).abs() < 1e-12 * nx.abs().max(1.0) {
-            return Some(nx);
-        }
-        x = nx;
-    }
-    None
-}
-
-/// Tries Newton from the guess and a few fallback starting points; then bisection over a
-/// bracket if one can be found.
-fn solve_rate(f: impl Fn(f64) -> f64, guess: f64) -> R<f64> {
-    let check = |r: f64| f(r).is_finite() && f(r).abs() < 1e-7 * (1.0 + f(guess).abs().min(1e12));
-    for g in [guess, 0.1, 0.01, 0.5, -0.5, 1.0, 0.001, 5.0, -0.9, 10.0] {
-        if let Some(r) = newton(&f, g)
-            && r > -1.0
-            && check(r)
-        {
-            return Ok(r);
-        }
-    }
-    // Scan for a sign change and bisect.
-    let grid: Vec<f64> = [-0.999_999, -0.99, -0.9, -0.5, -0.2, 0.0, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 100.0, 1000.0].to_vec();
-    for w in grid.windows(2) {
-        let (mut lo, mut hi) = match w {
-            [a, b] => (*a, *b),
-            _ => continue,
-        };
-        let (flo, fhi) = (f(lo), f(hi));
-        if !(flo.is_finite() && fhi.is_finite()) || flo * fhi > 0.0 {
-            continue;
-        }
-        let lo_neg = flo < 0.0;
-        for _ in 0..200 {
-            let mid = 0.5 * (lo + hi);
-            let fm = f(mid);
-            if (fm < 0.0) == lo_neg {
-                lo = mid;
-            } else {
-                hi = mid;
-            }
-        }
-        return Ok(0.5 * (lo + hi));
-    }
-    Err(CellError::Num)
-}
-
-fn rate(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (np, pmt, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    let (fv, typ, guess) = (opt_num(a, 3, 0.0)?, type_arg(a, 4)?, opt_num(a, 5, 0.1)?);
-    if np <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let f = |r: f64| {
-        if r.abs() < 1e-12 {
-            pv + pmt * np + fv
-        } else {
-            let p = (1.0 + r).powf(np);
-            pv * p + pmt * (1.0 + r * typ) * (p - 1.0) / r + fv
-        }
-    };
-    num_val(solve_rate(f, guess)?)
-}
-
-fn npv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let rate = num(a, 0)?;
-    if rate == -1.0 {
-        return Err(CellError::Div0);
-    }
-    let vals = numbers(a.get(1..).unwrap_or(&[]))?;
-    let mut sum = 0.0;
-    let mut d = 1.0;
-    for v in vals {
-        d *= 1.0 + rate;
-        sum += v / d;
-    }
-    num_val(sum)
-}
-
-/// Values and dates for XNPV/XIRR: both must be numeric and of equal length.
-fn dated_flows(values: &Value, dates: &Value) -> R<(Vec<f64>, Vec<f64>)> {
-    let va = as_array(values);
-    let da = as_array(dates);
-    if va.data.len() != da.data.len() {
-        return Err(CellError::Num);
-    }
-    let mut v = Vec::with_capacity(va.data.len());
-    let mut d = Vec::with_capacity(da.data.len());
-    for (x, y) in va.data.iter().zip(da.data.iter()) {
-        match x {
-            Value::Number(n) => v.push(*n),
-            Value::Error(e) => return Err(*e),
-            _ => return Err(CellError::Value),
-        }
-        match y {
-            Value::Number(n) => d.push(n.trunc()),
-            Value::Error(e) => return Err(*e),
-            Value::Text(_) => d.push(y.to_number()?.trunc()),
-            _ => return Err(CellError::Value),
-        }
-    }
-    let d0 = *d.first().ok_or(CellError::Num)?;
-    if d.iter().any(|&x| x < d0 || x < 0.0) {
-        return Err(CellError::Num);
-    }
-    Ok((v, d))
-}
-
-fn xnpv_calc(rate: f64, v: &[f64], d: &[f64]) -> f64 {
-    let d0 = d.first().copied().unwrap_or(0.0);
-    v.iter().zip(d).map(|(x, t)| x / (1.0 + rate).powf((t - d0) / 365.0)).sum()
-}
-
-fn xnpv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let rate = num(a, 0)?;
-    if rate <= -1.0 {
-        return Err(CellError::Num);
-    }
-    let (v, d) = dated_flows(&a.get(1).ok_or(CellError::Value)?.value, &a.get(2).ok_or(CellError::Value)?.value)?;
-    num_val(xnpv_calc(rate, &v, &d))
-}
-
-fn xirr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (v, d) = dated_flows(&a.first().ok_or(CellError::Value)?.value, &a.get(1).ok_or(CellError::Value)?.value)?;
-    let guess = opt_num(a, 2, 0.1)?;
-    if !v.iter().any(|x| *x > 0.0) || !v.iter().any(|x| *x < 0.0) {
-        return Err(CellError::Num);
-    }
-    num_val(solve_rate(|r| xnpv_calc(r, &v, &d), guess)?)
-}
-
-fn irr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let v = array_numbers(&a.first().ok_or(CellError::Value)?.value)?;
-    let guess = opt_num(a, 1, 0.1)?;
-    if !v.iter().any(|x| *x > 0.0) || !v.iter().any(|x| *x < 0.0) {
-        return Err(CellError::Num);
-    }
-    let f = |r: f64| {
-        let mut s = 0.0;
-        let mut d = 1.0;
-        for x in &v {
-            s += x / d;
-            d *= 1.0 + r;
-        }
-        s
-    };
-    num_val(solve_rate(f, guess)?)
-}
-
-fn mirr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let v = array_numbers(&a.first().ok_or(CellError::Value)?.value)?;
-    let (fr, rr) = (num(a, 1)?, num(a, 2)?);
-    let n = v.len() as f64;
-    if v.len() < 2 {
-        return Err(CellError::Div0);
-    }
-    let (mut pos, mut neg) = (0.0, 0.0);
-    for (i, x) in v.iter().enumerate() {
-        if *x > 0.0 {
-            pos += x / (1.0 + rr).powi(i as i32);
-        } else if *x < 0.0 {
-            neg += x / (1.0 + fr).powi(i as i32);
-        }
-    }
-    // No positive flow is not an error in Excel: the formula below gives -1.
-    if neg == 0.0 {
-        return Err(CellError::Div0);
-    }
-    let r = (-pos * (1.0 + rr).powf(n - 1.0) / neg).powf(1.0 / (n - 1.0)) - 1.0;
-    num_val(r)
-}
-
-fn fvschedule(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let mut p = num(a, 0)?;
-    for v in flatten(a.get(1..2).unwrap_or(&[])) {
-        let r = match v {
-            Value::Number(n) => n,
-            Value::Empty => 0.0,
-            Value::Error(e) => return Err(e),
-            _ => return Err(CellError::Value),
-        };
-        p *= 1.0 + r;
-    }
-    num_val(p)
-}
-
-fn effect(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (nom, n) = (num(a, 0)?, num(a, 1)?.trunc());
-    if nom <= 0.0 || n < 1.0 {
-        return Err(CellError::Num);
-    }
-    num_val((1.0 + nom / n).powf(n) - 1.0)
-}
-
-fn nominal(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (eff, n) = (num(a, 0)?, num(a, 1)?.trunc());
-    if eff <= 0.0 || n < 1.0 {
-        return Err(CellError::Num);
-    }
-    num_val(n * ((1.0 + eff).powf(1.0 / n) - 1.0))
-}
-
-fn ispmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, per, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
-    if np == 0.0 {
-        return Err(CellError::Div0);
-    }
-    num_val(pv * rate * (per / np - 1.0))
-}
-
-fn pduration(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (rate, pv, fv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if rate <= 0.0 || pv <= 0.0 || fv <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((fv.ln() - pv.ln()) / (1.0 + rate).ln())
-}
-
-fn rri(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (np, pv, fv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if np <= 0.0 || pv == 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((fv / pv).powf(1.0 / np) - 1.0)
-}
-
-fn dollar_digits(fraction: f64) -> R<f64> {
-    if fraction < 0.0 {
-        return Err(CellError::Num);
-    }
-    if fraction < 1.0 {
-        return Err(CellError::Div0);
-    }
-    Ok(10f64.powf(fraction.log10().ceil()))
-}
-
-fn dollarde(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (x, f) = (num(a, 0)?, num(a, 1)?.trunc());
-    let p = dollar_digits(f)?;
-    let int = x.trunc();
-    num_val(int + (x - int) * p / f)
-}
-
-fn dollarfr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (x, f) = (num(a, 0)?, num(a, 1)?.trunc());
-    let p = dollar_digits(f)?;
-    let int = x.trunc();
-    num_val(int + (x - int) * f / p)
-}
-
-// ---------------------------------------------------------------------------------------------
-// Depreciation
-// ---------------------------------------------------------------------------------------------
-
-fn sln(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (cost, salvage, life) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
-    if life == 0.0 {
-        return Err(CellError::Div0);
-    }
-    num_val((cost - salvage) / life)
-}
-
-fn syd(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (cost, salvage, life, per) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
-    if life <= 0.0 || per <= 0.0 || per > life || salvage < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((cost - salvage) * (life - per + 1.0) * 2.0 / (life * (life + 1.0)))
-}
-
-fn db(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (cost, salvage, life, period) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?.trunc());
-    let month = opt_num(a, 4, 12.0)?.trunc();
-    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || period <= 0.0 || !(1.0..=12.0).contains(&month) {
-        return Err(CellError::Num);
-    }
-    let max_period = if month == 12.0 { life.trunc() } else { life.trunc() + 1.0 };
-    if period > max_period.max(1.0) || period > 1e7 {
-        return Err(CellError::Num);
-    }
-    if cost == 0.0 {
-        return num_val(0.0);
-    }
-    let rate = crate::util::round_half_away(1.0 - (salvage / cost).powf(1.0 / life), 3);
-    let mut total = 0.0;
-    let mut dep = 0.0;
-    let mut p = 1.0;
-    while p <= period {
-        dep = if p == 1.0 {
-            cost * rate * month / 12.0
-        } else if p == life.trunc() + 1.0 {
-            (cost - total) * rate * (12.0 - month) / 12.0
-        } else {
-            (cost - total) * rate
-        };
-        total += dep;
-        p += 1.0;
-    }
-    num_val(dep)
-}
-
-fn ddb(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (cost, salvage, life, period) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
-    let factor = opt_num(a, 4, 2.0)?;
-    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || period <= 0.0 || factor <= 0.0 || period > life {
-        return Err(CellError::Num);
-    }
-    let mut rate = factor / life;
-    let old;
-    if rate >= 1.0 {
-        rate = 1.0;
-        old = if period == 1.0 { cost } else { 0.0 };
-    } else {
-        old = cost * (1.0 - rate).powf(period - 1.0);
-    }
-    let new = cost * (1.0 - rate).powf(period);
-    let dep = if new < salvage { old - salvage } else { old - new };
-    num_val(dep.max(0.0))
-}
-
-/// Per-period declining-balance depreciation with optional switch to straight line.
-fn vdb_schedule(cost: f64, salvage: f64, life: f64, factor: f64, no_switch: bool, periods: usize) -> Vec<f64> {
-    let mut out = Vec::with_capacity(periods);
-    let mut book = cost;
-    let mut sl: Option<f64> = None;
-    for i in 0..periods {
-        let dep = if let Some(s) = sl {
-            s.min((book - salvage).max(0.0))
-        } else {
-            let ddb = (book * factor / life).min((book - salvage).max(0.0));
-            let remaining = life - i as f64;
-            let slv = if remaining > 0.0 { (book - salvage) / remaining.max(1.0) } else { 0.0 };
-            if !no_switch && slv > ddb {
-                sl = Some(slv);
-                slv.min((book - salvage).max(0.0))
-            } else {
-                ddb
-            }
-        };
-        out.push(dep);
-        book -= dep;
-    }
-    out
-}
-
-fn vdb(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (cost, salvage, life, start, end) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?, num(a, 4)?);
-    let factor = opt_num(a, 5, 2.0)?;
-    let no_switch = opt_bool(a, 6, false)?;
-    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || start < 0.0 || end < start || end > life || factor <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let periods = end.ceil();
-    if periods > 1e7 {
-        return Err(CellError::Num);
-    }
-    let sched = vdb_schedule(cost, salvage, life, factor, no_switch, periods as usize);
-    let mut total = 0.0;
-    for (i, d) in sched.iter().enumerate() {
-        let (p0, p1) = (i as f64, i as f64 + 1.0);
-        let overlap = (p1.min(end) - p0.max(start)).max(0.0);
-        total += d * overlap;
-    }
-    num_val(total)
-}
-
-fn amorlinc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (cost, purchased, first, salvage) = (num(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?);
-    let (period, rate, basis) = (num(a, 4)?.trunc(), num(a, 5)?, basis_arg(a, 6)?);
-    if cost < 0.0 || salvage < 0.0 || salvage > cost || period < 0.0 || rate <= 0.0 || first < purchased {
-        return Err(CellError::Num);
-    }
-    let full = cost * rate;
-    let limit = cost - salvage;
-    let dep0 = (full * year_frac(c.date_system(), purchased, first, basis)?).min(limit);
-    if period == 0.0 {
-        return num_val(dep0);
-    }
-    let remaining = limit - dep0 - (period - 1.0) * full;
-    num_val(full.min(remaining.max(0.0)))
-}
-
-fn amordegrc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (cost, purchased, first, salvage) = (num(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?);
-    let (period, rate, basis) = (num(a, 4)?.trunc(), num(a, 5)?, basis_arg(a, 6)?);
-    if cost < 0.0 || salvage < 0.0 || salvage > cost || period < 0.0 || rate <= 0.0 || first < purchased || period > 1e6 {
-        return Err(CellError::Num);
-    }
-    let life = 1.0 / rate;
-    let coef = if life < 3.0 {
-        1.0
-    } else if life < 5.0 {
-        1.5
-    } else if life <= 6.0 {
-        2.0
-    } else {
-        2.5
-    };
-    let r = rate * coef;
-    let mut book = cost;
-    let mut dep = (year_frac(c.date_system(), purchased, first, basis)? * r * cost).round();
-    if period == 0.0 {
-        return num_val(dep);
-    }
-    book -= dep;
-    let mut rest = book - salvage;
-    let mut n = 1.0;
-    while n <= period {
-        dep = (r * book).round();
-        rest -= dep;
-        if rest < 0.0 {
-            // The two final periods split what remains; afterwards nothing is left.
-            let left = period - n;
-            return num_val(if left <= 1.0 { (book * 0.5).round() } else { 0.0 });
-        }
-        book -= dep;
-        n += 1.0;
-    }
-    num_val(dep)
-}
-
-// ---------------------------------------------------------------------------------------------
-// Dates and day counts
-// ---------------------------------------------------------------------------------------------
-
-fn date(a: &[Arg], i: usize) -> R<f64> {
-    let d = num(a, i)?.trunc();
-    if !(0.0..=2_958_465.0).contains(&d) {
-        return Err(CellError::Num);
-    }
-    Ok(d)
-}
-
-fn ymd(sys: DateSystem, s: f64) -> R<(i32, u32, u32)> {
-    let dt = datetime_from_serial(sys, s.trunc()).ok_or(CellError::Num)?;
-    Ok((dt.year, dt.month, dt.day.max(1)))
-}
-
-fn serial(sys: DateSystem, y: i32, m: u32, d: u32) -> R<f64> {
-    serial_from_ymd(sys, y as i64, m as i64, d as i64).ok_or(CellError::Num)
-}
-
-fn basis_arg(a: &[Arg], i: usize) -> R<u32> {
-    let b = opt_num(a, i, 0.0)?.trunc();
-    if !(0.0..=4.0).contains(&b) {
-        return Err(CellError::Num);
-    }
-    Ok(b as u32)
-}
-
-fn freq_arg(a: &[Arg], i: usize) -> R<f64> {
-    let f = num(a, i)?.trunc();
-    if f != 1.0 && f != 2.0 && f != 4.0 {
-        return Err(CellError::Num);
-    }
-    Ok(f)
-}
-
-/// 30/360 day count (US/NASD when `us`, European otherwise).
-fn days360(sys: DateSystem, s1: f64, s2: f64, us: bool) -> R<f64> {
-    let (y1, m1, mut d1) = ymd(sys, s1)?;
-    let (y2, m2, mut d2) = ymd(sys, s2)?;
-    if us {
-        let feb_end1 = m1 == 2 && d1 >= days_in_month(y1, 2);
-        let feb_end2 = m2 == 2 && d2 >= days_in_month(y2, 2);
-        if feb_end1 && feb_end2 {
-            d2 = 30;
-        }
-        if feb_end1 {
-            d1 = 30;
-        }
-        if d2 == 31 && d1 >= 30 {
-            d2 = 30;
-        }
-        if d1 == 31 {
-            d1 = 30;
-        }
-    } else {
-        d1 = d1.min(30);
-        d2 = d2.min(30);
-    }
-    Ok((y2 - y1) as f64 * 360.0 + (m2 as f64 - m1 as f64) * 30.0 + (d2 as f64 - d1 as f64))
-}
-
-/// Days between two dates under a basis.
-fn day_count(sys: DateSystem, s1: f64, s2: f64, basis: u32) -> R<f64> {
-    match basis {
-        0 => days360(sys, s1, s2, true),
-        4 => days360(sys, s1, s2, false),
-        _ => Ok(s2 - s1),
-    }
-}
-
-/// Year fraction between two dates under a basis (YEARFRAC semantics).
-fn year_frac(sys: DateSystem, s1: f64, s2: f64, basis: u32) -> R<f64> {
-    let (s1, s2) = if s1 <= s2 { (s1, s2) } else { (s2, s1) };
-    match basis {
-        0 => Ok(days360(sys, s1, s2, true)? / 360.0),
-        2 => Ok((s2 - s1) / 360.0),
-        3 => Ok((s2 - s1) / 365.0),
-        4 => Ok(days360(sys, s1, s2, false)? / 360.0),
-        _ => {
-            let (y1, m1, d1) = ymd(sys, s1)?;
-            let (y2, m2, d2) = ymd(sys, s2)?;
-            let days = s2 - s1;
-            if y1 == y2 {
-                return Ok(days / if is_leap(y1) { 366.0 } else { 365.0 });
-            }
-            let within_year = y2 == y1 + 1 && (m2 < m1 || (m2 == m1 && d2 <= d1));
-            if within_year {
-                let feb29_1 = is_leap(y1) && (m1 < 2 || (m1 == 2 && d1 <= 29));
-                let feb29_2 = is_leap(y2) && (m2 > 2 || (m2 == 2 && d2 == 29));
-                let denom = if feb29_1 || feb29_2 { 366.0 } else { 365.0 };
-                return Ok(days / denom);
-            }
-            let start = serial(sys, y1, 1, 1)?;
-            let end = serial(sys, y2 + 1, 1, 1).unwrap_or(max_serial(sys) as f64 + 1.0);
-            let avg = (end - start) / (y2 - y1 + 1) as f64;
-            Ok(days / avg)
-        }
-    }
-}
-
-/// Days in a year for discount securities.
-fn year_basis(sys: DateSystem, basis: u32, s: f64) -> R<f64> {
-    Ok(match basis {
-        0 | 2 | 4 => 360.0,
-        3 => 365.0,
-        _ => {
-            if is_leap(ymd(sys, s)?.0) {
-                366.0
-            } else {
-                365.0
-            }
-        }
-    })
-}
-
-/// Date `months` months before/after an anchor date, keeping end-of-month alignment.
-fn shift_months(sys: DateSystem, anchor: (i32, u32, u32), months: i64, eom: bool) -> R<f64> {
-    let (y, m, d) = anchor;
-    let total = y as i64 * 12 + (m as i64 - 1) + months;
-    let ny = total.div_euclid(12);
-    let nm = (total.rem_euclid(12) + 1) as u32;
-    if !(1900..=9999).contains(&ny) {
-        return Err(CellError::Num);
-    }
-    let dim = days_in_month(ny as i32, nm);
-    let nd = if eom { dim } else { d.min(dim) };
-    serial(sys, ny as i32, nm, nd)
-}
-
-struct Coupon {
-    pcd: f64,
-    ncd: f64,
-    num: f64,
-}
-
-fn coupons(sys: DateSystem, settle: f64, mat: f64, freq: f64) -> R<Coupon> {
-    if settle >= mat {
-        return Err(CellError::Num);
-    }
-    let anchor = ymd(sys, mat)?;
-    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
-    let step = (12.0 / freq) as i64;
-    // Estimate the count from the span, then adjust.
-    let mut k = (((mat - settle) / 365.25 * freq).floor() as i64).max(1);
-    while k > 1 && shift_months(sys, anchor, -(k - 1) * step, eom)? <= settle {
-        k -= 1;
-    }
-    let mut guard = 0;
-    while shift_months(sys, anchor, -k * step, eom)? > settle {
-        k += 1;
-        guard += 1;
-        if guard > 100_000 {
-            return Err(CellError::Num);
-        }
-    }
-    Ok(Coupon { pcd: shift_months(sys, anchor, -k * step, eom)?, ncd: shift_months(sys, anchor, -(k - 1) * step, eom)?, num: k as f64 })
-}
-
-fn coup_days(c: &Coupon, freq: f64, basis: u32) -> f64 {
-    match basis {
-        1 => c.ncd - c.pcd,
-        3 => 365.0 / freq,
-        _ => 360.0 / freq,
-    }
-}
-
-fn coup_daybs(sys: DateSystem, c: &Coupon, settle: f64, basis: u32) -> R<f64> {
-    day_count(sys, c.pcd, settle, basis)
-}
-
-fn coup_daysnc(sys: DateSystem, c: &Coupon, settle: f64, freq: f64, basis: u32) -> R<f64> {
-    match basis {
-        0 | 4 => Ok(coup_days(c, freq, basis) - coup_daybs(sys, c, settle, basis)?),
-        _ => Ok(c.ncd - settle),
-    }
-}
-
-/// settlement, maturity, frequency, basis at positions 0..=3 for the COUP* functions.
-fn coup_args(a: &[Arg], sys: DateSystem) -> R<(f64, f64, f64, u32, Coupon)> {
-    let (s, m, f, b) = (date(a, 0)?, date(a, 1)?, freq_arg(a, 2)?, basis_arg(a, 3)?);
-    let c = coupons(sys, s, m, f)?;
-    Ok((s, m, f, b, c))
-}
-
-fn coupdaybs(a: &[Arg], cx: &mut dyn Ctx) -> R<Value> {
-    let (s, _, _, b, c) = coup_args(a, cx.date_system())?;
-    num_val(coup_daybs(cx.date_system(), &c, s, b)?)
-}
-
-fn coupdays(a: &[Arg], cx: &mut dyn Ctx) -> R<Value> {
-    let (_, _, f, b, c) = coup_args(a, cx.date_system())?;
-    num_val(coup_days(&c, f, b))
-}
-
-fn coupdaysnc(a: &[Arg], cx: &mut dyn Ctx) -> R<Value> {
-    let (s, _, f, b, c) = coup_args(a, cx.date_system())?;
-    num_val(coup_daysnc(cx.date_system(), &c, s, f, b)?)
-}
-
-fn coupncd(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    num_val(coup_args(a, c.date_system())?.4.ncd)
-}
-
-fn couppcd(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    num_val(coup_args(a, c.date_system())?.4.pcd)
-}
-
-fn coupnum(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    num_val(coup_args(a, c.date_system())?.4.num)
-}
-
-// ---------------------------------------------------------------------------------------------
-// Securities
-// ---------------------------------------------------------------------------------------------
-
-fn accrint(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let sys = c.date_system();
-    let (issue, first, settle, rate) = (date(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?);
-    let par = if has(a, 4) { num(a, 4)? } else { 1000.0 };
-    let freq = freq_arg(a, 5)?;
-    let basis = basis_arg(a, 6)?;
-    let calc_method = opt_bool(a, 7, true)?;
-    if issue >= settle || rate <= 0.0 || par <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let anchor = ymd(sys, first)?;
-    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
-    let step = (12.0 / freq) as i64;
-    let cd = |j: i64| shift_months(sys, anchor, j * step, eom);
-    // Coupon index of the period containing a date: cd(j) <= date < cd(j+1).
-    let index_of = |d: f64| -> R<i64> {
-        let mut j = (((d - first) / 365.25 * freq).floor() as i64).clamp(-200_000, 200_000);
-        let mut guard = 0;
-        while cd(j)? > d {
-            j -= 1;
-            guard += 1;
-            if guard > 400_000 {
-                return Err(CellError::Num);
-            }
-        }
-        while cd(j + 1)? <= d {
-            j += 1;
-            guard += 1;
-            if guard > 400_000 {
-                return Err(CellError::Num);
-            }
-        }
-        Ok(j)
-    };
-    let start = if calc_method || settle <= first { issue } else { cd(index_of(settle)?)? };
-    let mut j = index_of(start)?;
-    let mut sum = 0.0;
-    let mut guard = 0;
-    loop {
-        let (p0, p1) = (cd(j)?, cd(j + 1)?);
-        if p0 >= settle {
-            break;
-        }
-        let from = p0.max(start);
-        let to = p1.min(settle);
-        if to > from {
-            let nl = match basis {
-                1 => p1 - p0,
-                3 => 365.0 / freq,
-                _ => 360.0 / freq,
-            };
-            sum += day_count(sys, from, to, basis)? / nl;
-        }
-        j += 1;
-        guard += 1;
-        if guard > 100_000 {
-            return Err(CellError::Num);
-        }
-    }
-    num_val(par * rate / freq * sum)
-}
-
-fn accrintm(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (issue, settle, rate) = (date(a, 0)?, date(a, 1)?, num(a, 2)?);
-    let par = if has(a, 3) { num(a, 3)? } else { 1000.0 };
-    let basis = basis_arg(a, 4)?;
-    if issue >= settle || rate <= 0.0 || par <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(par * rate * year_frac(c.date_system(), issue, settle, basis)?)
-}
-
-/// settlement, maturity, value, value, [basis] for discount securities.
-fn disc_args(a: &[Arg]) -> R<(f64, f64, f64, f64, u32)> {
-    let (s, m, x, y, b) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?, basis_arg(a, 4)?);
-    if s >= m || x <= 0.0 || y <= 0.0 {
-        return Err(CellError::Num);
-    }
-    Ok((s, m, x, y, b))
-}
-
-fn disc_frac(sys: DateSystem, s: f64, m: f64, b: u32) -> R<f64> {
-    Ok(day_count(sys, s, m, b)? / year_basis(sys, b, s)?)
-}
-
-fn disc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, pr, red, b) = disc_args(a)?;
-    num_val((1.0 - pr / red) / disc_frac(c.date_system(), s, m, b)?)
-}
-
-fn pricedisc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, d, red, b) = disc_args(a)?;
-    num_val(red - d * red * disc_frac(c.date_system(), s, m, b)?)
-}
-
-fn yielddisc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, pr, red, b) = disc_args(a)?;
-    num_val((red / pr - 1.0) / disc_frac(c.date_system(), s, m, b)?)
-}
-
-fn intrate(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, inv, red, b) = disc_args(a)?;
-    num_val((red - inv) / inv / disc_frac(c.date_system(), s, m, b)?)
-}
-
-fn received(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, inv, d, b) = disc_args(a)?;
-    let denom = 1.0 - d * disc_frac(c.date_system(), s, m, b)?;
-    if denom <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(inv / denom)
-}
-
-fn tbill_args(a: &[Arg], sys: DateSystem) -> R<(f64, f64)> {
-    let (s, m, x) = (date(a, 0)?, date(a, 1)?, num(a, 2)?);
-    if s >= m || x <= 0.0 {
-        return Err(CellError::Num);
-    }
-    // At most one year after settlement.
-    let (y, mo, d) = ymd(sys, s)?;
-    let limit = shift_months(sys, (y, mo, d), 12, false)?;
-    if m > limit {
-        return Err(CellError::Num);
-    }
-    Ok((m - s, x))
-}
-
-fn tbillprice(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (dsm, d) = tbill_args(a, c.date_system())?;
-    let p = 100.0 * (1.0 - d * dsm / 360.0);
-    if p <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(p)
-}
-
-fn tbillyield(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (dsm, pr) = tbill_args(a, c.date_system())?;
-    num_val((100.0 - pr) / pr * 360.0 / dsm)
-}
-
-fn tbilleq(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (dsm, d) = tbill_args(a, c.date_system())?;
-    if dsm <= 182.0 {
-        return num_val(365.0 * d / (360.0 - d * dsm));
-    }
-    let price = 100.0 * (1.0 - d * dsm / 360.0);
-    if price <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let t = dsm / 365.0;
-    let disc = t * t - (2.0 * t - 1.0) * (1.0 - 100.0 / price);
-    if disc < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((-t + disc.sqrt()) / (t - 0.5))
-}
-
-/// settlement, maturity, issue, rate, value, [basis].
-fn mat_terms(a: &[Arg], sys: DateSystem) -> R<(f64, f64, f64, f64, f64)> {
-    let (s, m, issue, rate, x, b) = (date(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?, num(a, 4)?, basis_arg(a, 5)?);
-    if s >= m || issue >= s || rate < 0.0 || x < 0.0 {
-        return Err(CellError::Num);
-    }
-    let dim = year_frac(sys, issue, m, b)?;
-    let dsm = year_frac(sys, s, m, b)?;
-    let ai = year_frac(sys, issue, s, b)?;
-    Ok((dim, dsm, ai, rate, x))
-}
-
-fn pricemat(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (dim, dsm, ai, rate, yld) = mat_terms(a, c.date_system())?;
-    num_val((100.0 + dim * rate * 100.0) / (1.0 + dsm * yld) - ai * rate * 100.0)
-}
-
-fn yieldmat(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (dim, dsm, ai, rate, pr) = mat_terms(a, c.date_system())?;
-    if pr <= 0.0 || dsm == 0.0 {
-        return Err(CellError::Num);
-    }
-    let base = pr / 100.0 + ai * rate;
-    num_val(((1.0 + dim * rate) - base) / base / dsm)
-}
-
-struct Bond {
-    n: f64,
-    e: f64,
-    a: f64,
-    dsc: f64,
-    freq: f64,
-}
-
-fn bond(sys: DateSystem, settle: f64, mat: f64, freq: f64, basis: u32) -> R<Bond> {
-    let c = coupons(sys, settle, mat, freq)?;
-    let e = coup_days(&c, freq, basis);
-    let a = coup_daybs(sys, &c, settle, basis)?;
-    let dsc = coup_daysnc(sys, &c, settle, freq, basis)?;
-    if e <= 0.0 {
-        return Err(CellError::Num);
-    }
-    Ok(Bond { n: c.num, e, a, dsc, freq })
-}
-
-fn bond_price(b: &Bond, rate: f64, yld: f64, red: f64) -> f64 {
-    let f = b.freq;
-    let coupon = 100.0 * rate / f;
-    let accrued = coupon * b.a / b.e;
-    if b.n == 1.0 {
-        return (red + coupon) / (1.0 + b.dsc / b.e * yld / f) - accrued;
-    }
-    let base = 1.0 + yld / f;
-    let frac = b.dsc / b.e;
-    let mut sum = red / base.powf(b.n - 1.0 + frac);
-    let mut k = 1.0;
-    while k <= b.n {
-        sum += coupon / base.powf(k - 1.0 + frac);
-        k += 1.0;
-    }
-    sum - accrued
-}
-
-fn price(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, rate, yld, red) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?, num(a, 4)?);
-    let (f, basis) = (freq_arg(a, 5)?, basis_arg(a, 6)?);
-    if rate < 0.0 || yld < 0.0 || red <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let b = bond(c.date_system(), s, m, f, basis)?;
-    num_val(bond_price(&b, rate, yld, red))
-}
-
-fn yield_(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (s, m, rate, pr, red) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?, num(a, 4)?);
-    let (f, basis) = (freq_arg(a, 5)?, basis_arg(a, 6)?);
-    if rate < 0.0 || pr <= 0.0 || red <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let b = bond(c.date_system(), s, m, f, basis)?;
-    if b.n == 1.0 {
-        let base = pr / 100.0 + b.a / b.e * rate / f;
-        return num_val(((red / 100.0 + rate / f) - base) / base * f * b.e / b.dsc);
-    }
-    // Price is decreasing in yield: bisect on [0, hi].
-    let g = |y: f64| bond_price(&b, rate, y, red) - pr;
-    let (mut lo, mut hi) = (-0.999_999 * f, 1.0);
-    let mut guard = 0;
-    while g(hi) > 0.0 && guard < 60 {
-        hi *= 2.0;
-        guard += 1;
-    }
-    if !(g(lo) >= 0.0 && g(hi) <= 0.0) {
-        return Err(CellError::Num);
-    }
-    for _ in 0..200 {
-        let mid = 0.5 * (lo + hi);
-        if g(mid) > 0.0 {
-            lo = mid;
-        } else {
-            hi = mid;
-        }
-    }
-    num_val(0.5 * (lo + hi))
-}
-
-fn duration_calc(a: &[Arg], sys: DateSystem) -> R<(f64, f64, f64)> {
-    let (s, m, coupon, yld) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?);
-    let (f, basis) = (freq_arg(a, 4)?, basis_arg(a, 5)?);
-    if coupon < 0.0 || yld < 0.0 {
-        return Err(CellError::Num);
-    }
-    let b = bond(sys, s, m, f, basis)?;
-    let c = coupon * 100.0 / f;
-    let y = 1.0 + yld / f;
-    let frac = b.dsc / b.e;
-    let (mut wsum, mut psum) = (0.0, 0.0);
-    let mut k = 1.0;
-    while k <= b.n {
-        let t = k - 1.0 + frac;
-        let cf = if k == b.n { c + 100.0 } else { c };
-        let pv = cf / y.powf(t);
-        wsum += t * pv;
-        psum += pv;
-        k += 1.0;
-    }
-    if psum == 0.0 {
-        return Err(CellError::Num);
-    }
-    Ok((wsum / psum / f, yld, f))
-}
-
-fn duration(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    num_val(duration_calc(a, c.date_system())?.0)
-}
-
-fn mduration(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (d, y, f) = duration_calc(a, c.date_system())?;
-    num_val(d / (1.0 + y / f))
-}
-
-// ---------------------------------------------------------------------------------------------
-// Odd first and last coupon periods
-// ---------------------------------------------------------------------------------------------
-//
-// An odd period is split into quasi-coupon periods: the regular coupon periods the security
-// would have had, counted back from the first coupon (ODDF*) or forward from the last interest
-// date (ODDL*). For quasi-period i, NL is its normal length, DC the days of it inside the odd
-// period, A the accrued days of it before settlement and DSC the days of it from settlement on.
-
-/// Most quasi-coupon periods an odd period may span (the date range allows ~32,400 quarters).
-const MAX_QUASI: i64 = 40_000;
-
-/// Normal length of the coupon period `[start, end]` under a basis (COUPDAYS semantics).
-fn normal_length(start: f64, end: f64, freq: f64, basis: u32) -> f64 {
-    match basis {
-        1 => end - start,
-        3 => 365.0 / freq,
-        _ => 360.0 / freq,
-    }
-}
-
-/// Days of `[from, to]` under a basis, or 0 when the span is empty.
-fn span(sys: DateSystem, from: f64, to: f64, basis: u32) -> R<f64> {
-    if to > from { day_count(sys, from, to, basis) } else { Ok(0.0) }
-}
-
-/// The odd-first-period terms that ODDFPRICE and ODDFYIELD share.
-struct OddFirst {
-    /// Coupons after the first coupon up to maturity.
-    n: f64,
-    /// Whole quasi-coupon periods between settlement and the first coupon.
-    nq: f64,
-    /// DSC / NL of the quasi-period holding settlement.
-    frac: f64,
-    /// Σ DCi / NLi over the odd period.
-    dc: f64,
-    /// Σ Ai / NLi over the odd period.
-    acc: f64,
-    freq: f64,
-}
-
-fn odd_first(sys: DateSystem, settle: f64, mat: f64, issue: f64, first: f64, freq: f64, basis: u32) -> R<OddFirst> {
-    if !(mat > first && first > settle && settle > issue) {
-        return Err(CellError::Num);
-    }
-    let anchor = ymd(sys, first)?;
-    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
-    let step = (12.0 / freq) as i64;
-    let quasi = |k: i64| shift_months(sys, anchor, -k * step, eom);
-    let (mut dc, mut acc) = (0.0, 0.0);
-    let (mut nq, mut frac) = (None, 0.0);
-    // Walk back from the first coupon: period k runs from quasi(k + 1) to quasi(k).
-    let mut k = 0;
-    loop {
-        if k >= MAX_QUASI {
-            return Err(CellError::Num);
-        }
-        let (end, start) = (quasi(k)?, quasi(k + 1)?);
-        let nl = normal_length(start, end, freq, basis);
-        if nl <= 0.0 {
-            return Err(CellError::Num);
-        }
-        let from = start.max(issue);
-        dc += span(sys, from, end, basis)? / nl;
-        acc += span(sys, from, settle.min(end), basis)? / nl;
-        if start <= settle && settle < end {
-            nq = Some(k as f64);
-            frac = span(sys, settle, end, basis)? / nl;
-        }
-        if start <= issue {
-            break;
-        }
-        k += 1;
-    }
-    let nq = nq.ok_or(CellError::Num)?;
-    let n = coupons(sys, first, mat, freq)?.num;
-    Ok(OddFirst { n, nq, frac, dc, acc, freq })
-}
-
-fn odd_first_price(t: &OddFirst, rate: f64, yld: f64, red: f64) -> f64 {
-    let coupon = 100.0 * rate / t.freq;
-    let base = 1.0 + yld / t.freq;
-    let lead = t.nq + t.frac;
-    let mut p = red / base.powf(t.n + lead) + coupon * t.dc / base.powf(lead);
-    let mut k = 1.0;
-    while k <= t.n {
-        p += coupon / base.powf(k + lead);
-        k += 1.0;
-    }
-    p - coupon * t.acc
-}
-
-/// settlement, maturity, issue, first_coupon, rate, yld/pr, redemption, frequency, [basis].
-fn odd_first_args(a: &[Arg], sys: DateSystem) -> R<(OddFirst, f64, f64, f64)> {
-    let (s, m, issue, first) = (date(a, 0)?, date(a, 1)?, date(a, 2)?, date(a, 3)?);
-    let (rate, x, red) = (num(a, 4)?, num(a, 5)?, num(a, 6)?);
-    let (f, basis) = (freq_arg(a, 7)?, basis_arg(a, 8)?);
-    if rate < 0.0 || red <= 0.0 {
-        return Err(CellError::Num);
-    }
-    Ok((odd_first(sys, s, m, issue, first, f, basis)?, rate, x, red))
-}
-
-fn oddfprice(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (t, rate, yld, red) = odd_first_args(a, c.date_system())?;
-    if yld < 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(odd_first_price(&t, rate, yld, red))
-}
-
-fn oddfyield(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let (t, rate, pr, red) = odd_first_args(a, c.date_system())?;
-    if pr <= 0.0 {
-        return Err(CellError::Num);
-    }
-    // The price falls as the yield rises: bracket the root, then bisect.
-    let g = |y: f64| odd_first_price(&t, rate, y, red) - pr;
-    let (mut lo, mut hi) = (-0.999_999 * t.freq, 1.0);
-    let mut guard = 0;
-    while g(hi) > 0.0 && guard < 60 {
-        hi *= 2.0;
-        guard += 1;
-    }
-    // NaN fails both comparisons.
-    if !(g(lo) >= 0.0 && g(hi) <= 0.0) {
-        return Err(CellError::Num);
-    }
-    for _ in 0..200 {
-        let mid = 0.5 * (lo + hi);
-        if g(mid) > 0.0 {
-            lo = mid;
-        } else {
-            hi = mid;
-        }
-    }
-    num_val(0.5 * (lo + hi))
-}
-
-/// Σ DCi/NLi, Σ Ai/NLi and Σ DSCi/NLi over an odd last period.
-fn odd_last(sys: DateSystem, settle: f64, mat: f64, last: f64, freq: f64, basis: u32) -> R<(f64, f64, f64)> {
-    if !(mat > settle && settle > last) {
-        return Err(CellError::Num);
-    }
-    let anchor = ymd(sys, last)?;
-    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
-    let step = (12.0 / freq) as i64;
-    let (mut dc, mut acc, mut dsc) = (0.0, 0.0, 0.0);
-    // Walk forward from the last interest date: period k runs from quasi(k - 1) to quasi(k).
-    let mut start = last;
-    let mut k = 1;
-    loop {
-        if k > MAX_QUASI {
-            return Err(CellError::Num);
-        }
-        let end = shift_months(sys, anchor, k * step, eom)?;
-        let nl = normal_length(start, end, freq, basis);
-        if nl <= 0.0 {
-            return Err(CellError::Num);
-        }
-        let stop = end.min(mat);
-        dc += span(sys, start, stop, basis)? / nl;
-        acc += span(sys, start, settle.min(stop), basis)? / nl;
-        dsc += span(sys, settle.max(start), stop, basis)? / nl;
-        if end >= mat {
-            break;
-        }
-        start = end;
-        k += 1;
-    }
-    Ok((dc, acc, dsc))
-}
-
-/// settlement, maturity, last_interest, rate, yld/pr, redemption, frequency, [basis].
-fn odd_last_args(a: &[Arg], sys: DateSystem) -> R<((f64, f64, f64), f64, f64, f64, f64)> {
-    let (s, m, last) = (date(a, 0)?, date(a, 1)?, date(a, 2)?);
-    let (rate, x, red) = (num(a, 3)?, num(a, 4)?, num(a, 5)?);
-    let (f, basis) = (freq_arg(a, 6)?, basis_arg(a, 7)?);
-    if rate < 0.0 || red <= 0.0 {
-        return Err(CellError::Num);
-    }
-    Ok((odd_last(sys, s, m, last, f, basis)?, rate, x, red, f))
-}
-
-fn oddlprice(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let ((dc, acc, dsc), rate, yld, red, f) = odd_last_args(a, c.date_system())?;
-    if yld < 0.0 {
-        return Err(CellError::Num);
-    }
-    let coupon = 100.0 * rate / f;
-    num_val((red + dc * coupon) / (1.0 + dsc * yld / f) - acc * coupon)
-}
-
-fn oddlyield(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
-    let ((dc, acc, dsc), rate, pr, red, f) = odd_last_args(a, c.date_system())?;
-    if pr <= 0.0 {
-        return Err(CellError::Num);
-    }
-    let coupon = 100.0 * rate / f;
-    let paid = pr + acc * coupon;
-    if paid <= 0.0 || dsc <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val((red + dc * coupon - paid) / paid * f / dsc)
-}
-
 // ---------------------------------------------------------------------------------------------
 // Euro conversion
 // ---------------------------------------------------------------------------------------------
diff --git a/crates/functions/src/financial/day_count.rs b/crates/functions/src/financial/day_count.rs
new file mode 100644
index 000000000..f91e7968f
--- /dev/null
+++ b/crates/functions/src/financial/day_count.rs
@@ -0,0 +1,214 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Dates and day counts
+// ---------------------------------------------------------------------------------------------
+
+pub(super) fn date(a: &[Arg], i: usize) -> R<f64> {
+    let d = num(a, i)?.trunc();
+    if !(0.0..=2_958_465.0).contains(&d) {
+        return Err(CellError::Num);
+    }
+    Ok(d)
+}
+
+pub(super) fn ymd(sys: DateSystem, s: f64) -> R<(i32, u32, u32)> {
+    let dt = datetime_from_serial(sys, s.trunc()).ok_or(CellError::Num)?;
+    Ok((dt.year, dt.month, dt.day.max(1)))
+}
+
+fn serial(sys: DateSystem, y: i32, m: u32, d: u32) -> R<f64> {
+    serial_from_ymd(sys, y as i64, m as i64, d as i64).ok_or(CellError::Num)
+}
+
+pub(super) fn basis_arg(a: &[Arg], i: usize) -> R<u32> {
+    let b = opt_num(a, i, 0.0)?.trunc();
+    if !(0.0..=4.0).contains(&b) {
+        return Err(CellError::Num);
+    }
+    Ok(b as u32)
+}
+
+pub(super) fn freq_arg(a: &[Arg], i: usize) -> R<f64> {
+    let f = num(a, i)?.trunc();
+    if f != 1.0 && f != 2.0 && f != 4.0 {
+        return Err(CellError::Num);
+    }
+    Ok(f)
+}
+
+/// 30/360 day count (US/NASD when `us`, European otherwise).
+fn days360(sys: DateSystem, s1: f64, s2: f64, us: bool) -> R<f64> {
+    let (y1, m1, mut d1) = ymd(sys, s1)?;
+    let (y2, m2, mut d2) = ymd(sys, s2)?;
+    if us {
+        let feb_end1 = m1 == 2 && d1 >= days_in_month(y1, 2);
+        let feb_end2 = m2 == 2 && d2 >= days_in_month(y2, 2);
+        if feb_end1 && feb_end2 {
+            d2 = 30;
+        }
+        if feb_end1 {
+            d1 = 30;
+        }
+        if d2 == 31 && d1 >= 30 {
+            d2 = 30;
+        }
+        if d1 == 31 {
+            d1 = 30;
+        }
+    } else {
+        d1 = d1.min(30);
+        d2 = d2.min(30);
+    }
+    Ok((y2 - y1) as f64 * 360.0 + (m2 as f64 - m1 as f64) * 30.0 + (d2 as f64 - d1 as f64))
+}
+
+/// Days between two dates under a basis.
+pub(super) fn day_count(sys: DateSystem, s1: f64, s2: f64, basis: u32) -> R<f64> {
+    match basis {
+        0 => days360(sys, s1, s2, true),
+        4 => days360(sys, s1, s2, false),
+        _ => Ok(s2 - s1),
+    }
+}
+
+/// Year fraction between two dates under a basis (YEARFRAC semantics).
+pub(super) fn year_frac(sys: DateSystem, s1: f64, s2: f64, basis: u32) -> R<f64> {
+    let (s1, s2) = if s1 <= s2 { (s1, s2) } else { (s2, s1) };
+    match basis {
+        0 => Ok(days360(sys, s1, s2, true)? / 360.0),
+        2 => Ok((s2 - s1) / 360.0),
+        3 => Ok((s2 - s1) / 365.0),
+        4 => Ok(days360(sys, s1, s2, false)? / 360.0),
+        _ => {
+            let (y1, m1, d1) = ymd(sys, s1)?;
+            let (y2, m2, d2) = ymd(sys, s2)?;
+            let days = s2 - s1;
+            if y1 == y2 {
+                return Ok(days / if is_leap(y1) { 366.0 } else { 365.0 });
+            }
+            let within_year = y2 == y1 + 1 && (m2 < m1 || (m2 == m1 && d2 <= d1));
+            if within_year {
+                let feb29_1 = is_leap(y1) && (m1 < 2 || (m1 == 2 && d1 <= 29));
+                let feb29_2 = is_leap(y2) && (m2 > 2 || (m2 == 2 && d2 == 29));
+                let denom = if feb29_1 || feb29_2 { 366.0 } else { 365.0 };
+                return Ok(days / denom);
+            }
+            let start = serial(sys, y1, 1, 1)?;
+            let end = serial(sys, y2 + 1, 1, 1).unwrap_or(max_serial(sys) as f64 + 1.0);
+            let avg = (end - start) / (y2 - y1 + 1) as f64;
+            Ok(days / avg)
+        }
+    }
+}
+
+/// Days in a year for discount securities.
+pub(super) fn year_basis(sys: DateSystem, basis: u32, s: f64) -> R<f64> {
+    Ok(match basis {
+        0 | 2 | 4 => 360.0,
+        3 => 365.0,
+        _ => {
+            if is_leap(ymd(sys, s)?.0) {
+                366.0
+            } else {
+                365.0
+            }
+        }
+    })
+}
+
+/// Date `months` months before/after an anchor date, keeping end-of-month alignment.
+pub(super) fn shift_months(sys: DateSystem, anchor: (i32, u32, u32), months: i64, eom: bool) -> R<f64> {
+    let (y, m, d) = anchor;
+    let total = y as i64 * 12 + (m as i64 - 1) + months;
+    let ny = total.div_euclid(12);
+    let nm = (total.rem_euclid(12) + 1) as u32;
+    if !(1900..=9999).contains(&ny) {
+        return Err(CellError::Num);
+    }
+    let dim = days_in_month(ny as i32, nm);
+    let nd = if eom { dim } else { d.min(dim) };
+    serial(sys, ny as i32, nm, nd)
+}
+
+pub(super) struct Coupon {
+    pcd: f64,
+    ncd: f64,
+    pub(super) num: f64,
+}
+
+pub(super) fn coupons(sys: DateSystem, settle: f64, mat: f64, freq: f64) -> R<Coupon> {
+    if settle >= mat {
+        return Err(CellError::Num);
+    }
+    let anchor = ymd(sys, mat)?;
+    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
+    let step = (12.0 / freq) as i64;
+    // Estimate the count from the span, then adjust.
+    let mut k = (((mat - settle) / 365.25 * freq).floor() as i64).max(1);
+    while k > 1 && shift_months(sys, anchor, -(k - 1) * step, eom)? <= settle {
+        k -= 1;
+    }
+    let mut guard = 0;
+    while shift_months(sys, anchor, -k * step, eom)? > settle {
+        k += 1;
+        guard += 1;
+        if guard > 100_000 {
+            return Err(CellError::Num);
+        }
+    }
+    Ok(Coupon { pcd: shift_months(sys, anchor, -k * step, eom)?, ncd: shift_months(sys, anchor, -(k - 1) * step, eom)?, num: k as f64 })
+}
+
+pub(super) fn coup_days(c: &Coupon, freq: f64, basis: u32) -> f64 {
+    match basis {
+        1 => c.ncd - c.pcd,
+        3 => 365.0 / freq,
+        _ => 360.0 / freq,
+    }
+}
+
+pub(super) fn coup_daybs(sys: DateSystem, c: &Coupon, settle: f64, basis: u32) -> R<f64> {
+    day_count(sys, c.pcd, settle, basis)
+}
+
+pub(super) fn coup_daysnc(sys: DateSystem, c: &Coupon, settle: f64, freq: f64, basis: u32) -> R<f64> {
+    match basis {
+        0 | 4 => Ok(coup_days(c, freq, basis) - coup_daybs(sys, c, settle, basis)?),
+        _ => Ok(c.ncd - settle),
+    }
+}
+
+/// settlement, maturity, frequency, basis at positions 0..=3 for the COUP* functions.
+fn coup_args(a: &[Arg], sys: DateSystem) -> R<(f64, f64, f64, u32, Coupon)> {
+    let (s, m, f, b) = (date(a, 0)?, date(a, 1)?, freq_arg(a, 2)?, basis_arg(a, 3)?);
+    let c = coupons(sys, s, m, f)?;
+    Ok((s, m, f, b, c))
+}
+
+pub(super) fn coupdaybs(a: &[Arg], cx: &mut dyn Ctx) -> R<Value> {
+    let (s, _, _, b, c) = coup_args(a, cx.date_system())?;
+    num_val(coup_daybs(cx.date_system(), &c, s, b)?)
+}
+
+pub(super) fn coupdays(a: &[Arg], cx: &mut dyn Ctx) -> R<Value> {
+    let (_, _, f, b, c) = coup_args(a, cx.date_system())?;
+    num_val(coup_days(&c, f, b))
+}
+
+pub(super) fn coupdaysnc(a: &[Arg], cx: &mut dyn Ctx) -> R<Value> {
+    let (s, _, f, b, c) = coup_args(a, cx.date_system())?;
+    num_val(coup_daysnc(cx.date_system(), &c, s, f, b)?)
+}
+
+pub(super) fn coupncd(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    num_val(coup_args(a, c.date_system())?.4.ncd)
+}
+
+pub(super) fn couppcd(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    num_val(coup_args(a, c.date_system())?.4.pcd)
+}
+
+pub(super) fn coupnum(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    num_val(coup_args(a, c.date_system())?.4.num)
+}
diff --git a/crates/functions/src/financial/depreciation.rs b/crates/functions/src/financial/depreciation.rs
new file mode 100644
index 000000000..d656aa76f
--- /dev/null
+++ b/crates/functions/src/financial/depreciation.rs
@@ -0,0 +1,173 @@
+use super::day_count::{basis_arg, date, year_frac};
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Depreciation
+// ---------------------------------------------------------------------------------------------
+
+pub(super) fn sln(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (cost, salvage, life) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if life == 0.0 {
+        return Err(CellError::Div0);
+    }
+    num_val((cost - salvage) / life)
+}
+
+pub(super) fn syd(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (cost, salvage, life, per) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
+    if life <= 0.0 || per <= 0.0 || per > life || salvage < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((cost - salvage) * (life - per + 1.0) * 2.0 / (life * (life + 1.0)))
+}
+
+pub(super) fn db(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (cost, salvage, life, period) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?.trunc());
+    let month = opt_num(a, 4, 12.0)?.trunc();
+    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || period <= 0.0 || !(1.0..=12.0).contains(&month) {
+        return Err(CellError::Num);
+    }
+    let max_period = if month == 12.0 { life.trunc() } else { life.trunc() + 1.0 };
+    if period > max_period.max(1.0) || period > 1e7 {
+        return Err(CellError::Num);
+    }
+    if cost == 0.0 {
+        return num_val(0.0);
+    }
+    let rate = crate::util::round_half_away(1.0 - (salvage / cost).powf(1.0 / life), 3);
+    let mut total = 0.0;
+    let mut dep = 0.0;
+    let mut p = 1.0;
+    while p <= period {
+        dep = if p == 1.0 {
+            cost * rate * month / 12.0
+        } else if p == life.trunc() + 1.0 {
+            (cost - total) * rate * (12.0 - month) / 12.0
+        } else {
+            (cost - total) * rate
+        };
+        total += dep;
+        p += 1.0;
+    }
+    num_val(dep)
+}
+
+pub(super) fn ddb(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (cost, salvage, life, period) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
+    let factor = opt_num(a, 4, 2.0)?;
+    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || period <= 0.0 || factor <= 0.0 || period > life {
+        return Err(CellError::Num);
+    }
+    let mut rate = factor / life;
+    let old;
+    if rate >= 1.0 {
+        rate = 1.0;
+        old = if period == 1.0 { cost } else { 0.0 };
+    } else {
+        old = cost * (1.0 - rate).powf(period - 1.0);
+    }
+    let new = cost * (1.0 - rate).powf(period);
+    let dep = if new < salvage { old - salvage } else { old - new };
+    num_val(dep.max(0.0))
+}
+
+/// Per-period declining-balance depreciation with optional switch to straight line.
+fn vdb_schedule(cost: f64, salvage: f64, life: f64, factor: f64, no_switch: bool, periods: usize) -> Vec<f64> {
+    let mut out = Vec::with_capacity(periods);
+    let mut book = cost;
+    let mut sl: Option<f64> = None;
+    for i in 0..periods {
+        let dep = if let Some(s) = sl {
+            s.min((book - salvage).max(0.0))
+        } else {
+            let ddb = (book * factor / life).min((book - salvage).max(0.0));
+            let remaining = life - i as f64;
+            let slv = if remaining > 0.0 { (book - salvage) / remaining.max(1.0) } else { 0.0 };
+            if !no_switch && slv > ddb {
+                sl = Some(slv);
+                slv.min((book - salvage).max(0.0))
+            } else {
+                ddb
+            }
+        };
+        out.push(dep);
+        book -= dep;
+    }
+    out
+}
+
+pub(super) fn vdb(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (cost, salvage, life, start, end) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?, num(a, 4)?);
+    let factor = opt_num(a, 5, 2.0)?;
+    let no_switch = opt_bool(a, 6, false)?;
+    if cost < 0.0 || salvage < 0.0 || life <= 0.0 || start < 0.0 || end < start || end > life || factor <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let periods = end.ceil();
+    if periods > 1e7 {
+        return Err(CellError::Num);
+    }
+    let sched = vdb_schedule(cost, salvage, life, factor, no_switch, periods as usize);
+    let mut total = 0.0;
+    for (i, d) in sched.iter().enumerate() {
+        let (p0, p1) = (i as f64, i as f64 + 1.0);
+        let overlap = (p1.min(end) - p0.max(start)).max(0.0);
+        total += d * overlap;
+    }
+    num_val(total)
+}
+
+pub(super) fn amorlinc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (cost, purchased, first, salvage) = (num(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?);
+    let (period, rate, basis) = (num(a, 4)?.trunc(), num(a, 5)?, basis_arg(a, 6)?);
+    if cost < 0.0 || salvage < 0.0 || salvage > cost || period < 0.0 || rate <= 0.0 || first < purchased {
+        return Err(CellError::Num);
+    }
+    let full = cost * rate;
+    let limit = cost - salvage;
+    let dep0 = (full * year_frac(c.date_system(), purchased, first, basis)?).min(limit);
+    if period == 0.0 {
+        return num_val(dep0);
+    }
+    let remaining = limit - dep0 - (period - 1.0) * full;
+    num_val(full.min(remaining.max(0.0)))
+}
+
+pub(super) fn amordegrc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (cost, purchased, first, salvage) = (num(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?);
+    let (period, rate, basis) = (num(a, 4)?.trunc(), num(a, 5)?, basis_arg(a, 6)?);
+    if cost < 0.0 || salvage < 0.0 || salvage > cost || period < 0.0 || rate <= 0.0 || first < purchased || period > 1e6 {
+        return Err(CellError::Num);
+    }
+    let life = 1.0 / rate;
+    let coef = if life < 3.0 {
+        1.0
+    } else if life < 5.0 {
+        1.5
+    } else if life <= 6.0 {
+        2.0
+    } else {
+        2.5
+    };
+    let r = rate * coef;
+    let mut book = cost;
+    let mut dep = (year_frac(c.date_system(), purchased, first, basis)? * r * cost).round();
+    if period == 0.0 {
+        return num_val(dep);
+    }
+    book -= dep;
+    let mut rest = book - salvage;
+    let mut n = 1.0;
+    while n <= period {
+        dep = (r * book).round();
+        rest -= dep;
+        if rest < 0.0 {
+            // The two final periods split what remains; afterwards nothing is left.
+            let left = period - n;
+            return num_val(if left <= 1.0 { (book * 0.5).round() } else { 0.0 });
+        }
+        book -= dep;
+        n += 1.0;
+    }
+    num_val(dep)
+}
diff --git a/crates/functions/src/financial/securities.rs b/crates/functions/src/financial/securities.rs
new file mode 100644
index 000000000..cfecd763a
--- /dev/null
+++ b/crates/functions/src/financial/securities.rs
@@ -0,0 +1,512 @@
+use super::day_count::{basis_arg, coup_daybs, coup_days, coup_daysnc, coupons, date, day_count, freq_arg, shift_months, year_basis, year_frac, ymd};
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Securities
+// ---------------------------------------------------------------------------------------------
+
+pub(super) fn accrint(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let sys = c.date_system();
+    let (issue, first, settle, rate) = (date(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?);
+    let par = if has(a, 4) { num(a, 4)? } else { 1000.0 };
+    let freq = freq_arg(a, 5)?;
+    let basis = basis_arg(a, 6)?;
+    let calc_method = opt_bool(a, 7, true)?;
+    if issue >= settle || rate <= 0.0 || par <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let anchor = ymd(sys, first)?;
+    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
+    let step = (12.0 / freq) as i64;
+    let cd = |j: i64| shift_months(sys, anchor, j * step, eom);
+    // Coupon index of the period containing a date: cd(j) <= date < cd(j+1).
+    let index_of = |d: f64| -> R<i64> {
+        let mut j = (((d - first) / 365.25 * freq).floor() as i64).clamp(-200_000, 200_000);
+        let mut guard = 0;
+        while cd(j)? > d {
+            j -= 1;
+            guard += 1;
+            if guard > 400_000 {
+                return Err(CellError::Num);
+            }
+        }
+        while cd(j + 1)? <= d {
+            j += 1;
+            guard += 1;
+            if guard > 400_000 {
+                return Err(CellError::Num);
+            }
+        }
+        Ok(j)
+    };
+    let start = if calc_method || settle <= first { issue } else { cd(index_of(settle)?)? };
+    let mut j = index_of(start)?;
+    let mut sum = 0.0;
+    let mut guard = 0;
+    loop {
+        let (p0, p1) = (cd(j)?, cd(j + 1)?);
+        if p0 >= settle {
+            break;
+        }
+        let from = p0.max(start);
+        let to = p1.min(settle);
+        if to > from {
+            let nl = match basis {
+                1 => p1 - p0,
+                3 => 365.0 / freq,
+                _ => 360.0 / freq,
+            };
+            sum += day_count(sys, from, to, basis)? / nl;
+        }
+        j += 1;
+        guard += 1;
+        if guard > 100_000 {
+            return Err(CellError::Num);
+        }
+    }
+    num_val(par * rate / freq * sum)
+}
+
+pub(super) fn accrintm(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (issue, settle, rate) = (date(a, 0)?, date(a, 1)?, num(a, 2)?);
+    let par = if has(a, 3) { num(a, 3)? } else { 1000.0 };
+    let basis = basis_arg(a, 4)?;
+    if issue >= settle || rate <= 0.0 || par <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(par * rate * year_frac(c.date_system(), issue, settle, basis)?)
+}
+
+/// settlement, maturity, value, value, [basis] for discount securities.
+fn disc_args(a: &[Arg]) -> R<(f64, f64, f64, f64, u32)> {
+    let (s, m, x, y, b) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?, basis_arg(a, 4)?);
+    if s >= m || x <= 0.0 || y <= 0.0 {
+        return Err(CellError::Num);
+    }
+    Ok((s, m, x, y, b))
+}
+
+fn disc_frac(sys: DateSystem, s: f64, m: f64, b: u32) -> R<f64> {
+    Ok(day_count(sys, s, m, b)? / year_basis(sys, b, s)?)
+}
+
+pub(super) fn disc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, pr, red, b) = disc_args(a)?;
+    num_val((1.0 - pr / red) / disc_frac(c.date_system(), s, m, b)?)
+}
+
+pub(super) fn pricedisc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, d, red, b) = disc_args(a)?;
+    num_val(red - d * red * disc_frac(c.date_system(), s, m, b)?)
+}
+
+pub(super) fn yielddisc(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, pr, red, b) = disc_args(a)?;
+    num_val((red / pr - 1.0) / disc_frac(c.date_system(), s, m, b)?)
+}
+
+pub(super) fn intrate(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, inv, red, b) = disc_args(a)?;
+    num_val((red - inv) / inv / disc_frac(c.date_system(), s, m, b)?)
+}
+
+pub(super) fn received(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, inv, d, b) = disc_args(a)?;
+    let denom = 1.0 - d * disc_frac(c.date_system(), s, m, b)?;
+    if denom <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(inv / denom)
+}
+
+fn tbill_args(a: &[Arg], sys: DateSystem) -> R<(f64, f64)> {
+    let (s, m, x) = (date(a, 0)?, date(a, 1)?, num(a, 2)?);
+    if s >= m || x <= 0.0 {
+        return Err(CellError::Num);
+    }
+    // At most one year after settlement.
+    let (y, mo, d) = ymd(sys, s)?;
+    let limit = shift_months(sys, (y, mo, d), 12, false)?;
+    if m > limit {
+        return Err(CellError::Num);
+    }
+    Ok((m - s, x))
+}
+
+pub(super) fn tbillprice(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (dsm, d) = tbill_args(a, c.date_system())?;
+    let p = 100.0 * (1.0 - d * dsm / 360.0);
+    if p <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(p)
+}
+
+pub(super) fn tbillyield(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (dsm, pr) = tbill_args(a, c.date_system())?;
+    num_val((100.0 - pr) / pr * 360.0 / dsm)
+}
+
+pub(super) fn tbilleq(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (dsm, d) = tbill_args(a, c.date_system())?;
+    if dsm <= 182.0 {
+        return num_val(365.0 * d / (360.0 - d * dsm));
+    }
+    let price = 100.0 * (1.0 - d * dsm / 360.0);
+    if price <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let t = dsm / 365.0;
+    let disc = t * t - (2.0 * t - 1.0) * (1.0 - 100.0 / price);
+    if disc < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((-t + disc.sqrt()) / (t - 0.5))
+}
+
+/// settlement, maturity, issue, rate, value, [basis].
+fn mat_terms(a: &[Arg], sys: DateSystem) -> R<(f64, f64, f64, f64, f64)> {
+    let (s, m, issue, rate, x, b) = (date(a, 0)?, date(a, 1)?, date(a, 2)?, num(a, 3)?, num(a, 4)?, basis_arg(a, 5)?);
+    if s >= m || issue >= s || rate < 0.0 || x < 0.0 {
+        return Err(CellError::Num);
+    }
+    let dim = year_frac(sys, issue, m, b)?;
+    let dsm = year_frac(sys, s, m, b)?;
+    let ai = year_frac(sys, issue, s, b)?;
+    Ok((dim, dsm, ai, rate, x))
+}
+
+pub(super) fn pricemat(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (dim, dsm, ai, rate, yld) = mat_terms(a, c.date_system())?;
+    num_val((100.0 + dim * rate * 100.0) / (1.0 + dsm * yld) - ai * rate * 100.0)
+}
+
+pub(super) fn yieldmat(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (dim, dsm, ai, rate, pr) = mat_terms(a, c.date_system())?;
+    if pr <= 0.0 || dsm == 0.0 {
+        return Err(CellError::Num);
+    }
+    let base = pr / 100.0 + ai * rate;
+    num_val(((1.0 + dim * rate) - base) / base / dsm)
+}
+
+struct Bond {
+    n: f64,
+    e: f64,
+    a: f64,
+    dsc: f64,
+    freq: f64,
+}
+
+fn bond(sys: DateSystem, settle: f64, mat: f64, freq: f64, basis: u32) -> R<Bond> {
+    let c = coupons(sys, settle, mat, freq)?;
+    let e = coup_days(&c, freq, basis);
+    let a = coup_daybs(sys, &c, settle, basis)?;
+    let dsc = coup_daysnc(sys, &c, settle, freq, basis)?;
+    if e <= 0.0 {
+        return Err(CellError::Num);
+    }
+    Ok(Bond { n: c.num, e, a, dsc, freq })
+}
+
+fn bond_price(b: &Bond, rate: f64, yld: f64, red: f64) -> f64 {
+    let f = b.freq;
+    let coupon = 100.0 * rate / f;
+    let accrued = coupon * b.a / b.e;
+    if b.n == 1.0 {
+        return (red + coupon) / (1.0 + b.dsc / b.e * yld / f) - accrued;
+    }
+    let base = 1.0 + yld / f;
+    let frac = b.dsc / b.e;
+    let mut sum = red / base.powf(b.n - 1.0 + frac);
+    let mut k = 1.0;
+    while k <= b.n {
+        sum += coupon / base.powf(k - 1.0 + frac);
+        k += 1.0;
+    }
+    sum - accrued
+}
+
+pub(super) fn price(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, rate, yld, red) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?, num(a, 4)?);
+    let (f, basis) = (freq_arg(a, 5)?, basis_arg(a, 6)?);
+    if rate < 0.0 || yld < 0.0 || red <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let b = bond(c.date_system(), s, m, f, basis)?;
+    num_val(bond_price(&b, rate, yld, red))
+}
+
+pub(super) fn yield_(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (s, m, rate, pr, red) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?, num(a, 4)?);
+    let (f, basis) = (freq_arg(a, 5)?, basis_arg(a, 6)?);
+    if rate < 0.0 || pr <= 0.0 || red <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let b = bond(c.date_system(), s, m, f, basis)?;
+    if b.n == 1.0 {
+        let base = pr / 100.0 + b.a / b.e * rate / f;
+        return num_val(((red / 100.0 + rate / f) - base) / base * f * b.e / b.dsc);
+    }
+    // Price is decreasing in yield: bisect on [0, hi].
+    let g = |y: f64| bond_price(&b, rate, y, red) - pr;
+    let (mut lo, mut hi) = (-0.999_999 * f, 1.0);
+    let mut guard = 0;
+    while g(hi) > 0.0 && guard < 60 {
+        hi *= 2.0;
+        guard += 1;
+    }
+    if !(g(lo) >= 0.0 && g(hi) <= 0.0) {
+        return Err(CellError::Num);
+    }
+    for _ in 0..200 {
+        let mid = 0.5 * (lo + hi);
+        if g(mid) > 0.0 {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+    num_val(0.5 * (lo + hi))
+}
+
+fn duration_calc(a: &[Arg], sys: DateSystem) -> R<(f64, f64, f64)> {
+    let (s, m, coupon, yld) = (date(a, 0)?, date(a, 1)?, num(a, 2)?, num(a, 3)?);
+    let (f, basis) = (freq_arg(a, 4)?, basis_arg(a, 5)?);
+    if coupon < 0.0 || yld < 0.0 {
+        return Err(CellError::Num);
+    }
+    let b = bond(sys, s, m, f, basis)?;
+    let c = coupon * 100.0 / f;
+    let y = 1.0 + yld / f;
+    let frac = b.dsc / b.e;
+    let (mut wsum, mut psum) = (0.0, 0.0);
+    let mut k = 1.0;
+    while k <= b.n {
+        let t = k - 1.0 + frac;
+        let cf = if k == b.n { c + 100.0 } else { c };
+        let pv = cf / y.powf(t);
+        wsum += t * pv;
+        psum += pv;
+        k += 1.0;
+    }
+    if psum == 0.0 {
+        return Err(CellError::Num);
+    }
+    Ok((wsum / psum / f, yld, f))
+}
+
+pub(super) fn duration(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    num_val(duration_calc(a, c.date_system())?.0)
+}
+
+pub(super) fn mduration(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (d, y, f) = duration_calc(a, c.date_system())?;
+    num_val(d / (1.0 + y / f))
+}
+
+// ---------------------------------------------------------------------------------------------
+// Odd first and last coupon periods
+// ---------------------------------------------------------------------------------------------
+//
+// An odd period is split into quasi-coupon periods: the regular coupon periods the security
+// would have had, counted back from the first coupon (ODDF*) or forward from the last interest
+// date (ODDL*). For quasi-period i, NL is its normal length, DC the days of it inside the odd
+// period, A the accrued days of it before settlement and DSC the days of it from settlement on.
+
+/// Most quasi-coupon periods an odd period may span (the date range allows ~32,400 quarters).
+const MAX_QUASI: i64 = 40_000;
+
+/// Normal length of the coupon period `[start, end]` under a basis (COUPDAYS semantics).
+fn normal_length(start: f64, end: f64, freq: f64, basis: u32) -> f64 {
+    match basis {
+        1 => end - start,
+        3 => 365.0 / freq,
+        _ => 360.0 / freq,
+    }
+}
+
+/// Days of `[from, to]` under a basis, or 0 when the span is empty.
+fn span(sys: DateSystem, from: f64, to: f64, basis: u32) -> R<f64> {
+    if to > from { day_count(sys, from, to, basis) } else { Ok(0.0) }
+}
+
+/// The odd-first-period terms that ODDFPRICE and ODDFYIELD share.
+struct OddFirst {
+    /// Coupons after the first coupon up to maturity.
+    n: f64,
+    /// Whole quasi-coupon periods between settlement and the first coupon.
+    nq: f64,
+    /// DSC / NL of the quasi-period holding settlement.
+    frac: f64,
+    /// Σ DCi / NLi over the odd period.
+    dc: f64,
+    /// Σ Ai / NLi over the odd period.
+    acc: f64,
+    freq: f64,
+}
+
+fn odd_first(sys: DateSystem, settle: f64, mat: f64, issue: f64, first: f64, freq: f64, basis: u32) -> R<OddFirst> {
+    if !(mat > first && first > settle && settle > issue) {
+        return Err(CellError::Num);
+    }
+    let anchor = ymd(sys, first)?;
+    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
+    let step = (12.0 / freq) as i64;
+    let quasi = |k: i64| shift_months(sys, anchor, -k * step, eom);
+    let (mut dc, mut acc) = (0.0, 0.0);
+    let (mut nq, mut frac) = (None, 0.0);
+    // Walk back from the first coupon: period k runs from quasi(k + 1) to quasi(k).
+    let mut k = 0;
+    loop {
+        if k >= MAX_QUASI {
+            return Err(CellError::Num);
+        }
+        let (end, start) = (quasi(k)?, quasi(k + 1)?);
+        let nl = normal_length(start, end, freq, basis);
+        if nl <= 0.0 {
+            return Err(CellError::Num);
+        }
+        let from = start.max(issue);
+        dc += span(sys, from, end, basis)? / nl;
+        acc += span(sys, from, settle.min(end), basis)? / nl;
+        if start <= settle && settle < end {
+            nq = Some(k as f64);
+            frac = span(sys, settle, end, basis)? / nl;
+        }
+        if start <= issue {
+            break;
+        }
+        k += 1;
+    }
+    let nq = nq.ok_or(CellError::Num)?;
+    let n = coupons(sys, first, mat, freq)?.num;
+    Ok(OddFirst { n, nq, frac, dc, acc, freq })
+}
+
+fn odd_first_price(t: &OddFirst, rate: f64, yld: f64, red: f64) -> f64 {
+    let coupon = 100.0 * rate / t.freq;
+    let base = 1.0 + yld / t.freq;
+    let lead = t.nq + t.frac;
+    let mut p = red / base.powf(t.n + lead) + coupon * t.dc / base.powf(lead);
+    let mut k = 1.0;
+    while k <= t.n {
+        p += coupon / base.powf(k + lead);
+        k += 1.0;
+    }
+    p - coupon * t.acc
+}
+
+/// settlement, maturity, issue, first_coupon, rate, yld/pr, redemption, frequency, [basis].
+fn odd_first_args(a: &[Arg], sys: DateSystem) -> R<(OddFirst, f64, f64, f64)> {
+    let (s, m, issue, first) = (date(a, 0)?, date(a, 1)?, date(a, 2)?, date(a, 3)?);
+    let (rate, x, red) = (num(a, 4)?, num(a, 5)?, num(a, 6)?);
+    let (f, basis) = (freq_arg(a, 7)?, basis_arg(a, 8)?);
+    if rate < 0.0 || red <= 0.0 {
+        return Err(CellError::Num);
+    }
+    Ok((odd_first(sys, s, m, issue, first, f, basis)?, rate, x, red))
+}
+
+pub(super) fn oddfprice(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (t, rate, yld, red) = odd_first_args(a, c.date_system())?;
+    if yld < 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(odd_first_price(&t, rate, yld, red))
+}
+
+pub(super) fn oddfyield(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let (t, rate, pr, red) = odd_first_args(a, c.date_system())?;
+    if pr <= 0.0 {
+        return Err(CellError::Num);
+    }
+    // The price falls as the yield rises: bracket the root, then bisect.
+    let g = |y: f64| odd_first_price(&t, rate, y, red) - pr;
+    let (mut lo, mut hi) = (-0.999_999 * t.freq, 1.0);
+    let mut guard = 0;
+    while g(hi) > 0.0 && guard < 60 {
+        hi *= 2.0;
+        guard += 1;
+    }
+    // NaN fails both comparisons.
+    if !(g(lo) >= 0.0 && g(hi) <= 0.0) {
+        return Err(CellError::Num);
+    }
+    for _ in 0..200 {
+        let mid = 0.5 * (lo + hi);
+        if g(mid) > 0.0 {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+    num_val(0.5 * (lo + hi))
+}
+
+/// Σ DCi/NLi, Σ Ai/NLi and Σ DSCi/NLi over an odd last period.
+fn odd_last(sys: DateSystem, settle: f64, mat: f64, last: f64, freq: f64, basis: u32) -> R<(f64, f64, f64)> {
+    if !(mat > settle && settle > last) {
+        return Err(CellError::Num);
+    }
+    let anchor = ymd(sys, last)?;
+    let eom = anchor.2 == days_in_month(anchor.0, anchor.1);
+    let step = (12.0 / freq) as i64;
+    let (mut dc, mut acc, mut dsc) = (0.0, 0.0, 0.0);
+    // Walk forward from the last interest date: period k runs from quasi(k - 1) to quasi(k).
+    let mut start = last;
+    let mut k = 1;
+    loop {
+        if k > MAX_QUASI {
+            return Err(CellError::Num);
+        }
+        let end = shift_months(sys, anchor, k * step, eom)?;
+        let nl = normal_length(start, end, freq, basis);
+        if nl <= 0.0 {
+            return Err(CellError::Num);
+        }
+        let stop = end.min(mat);
+        dc += span(sys, start, stop, basis)? / nl;
+        acc += span(sys, start, settle.min(stop), basis)? / nl;
+        dsc += span(sys, settle.max(start), stop, basis)? / nl;
+        if end >= mat {
+            break;
+        }
+        start = end;
+        k += 1;
+    }
+    Ok((dc, acc, dsc))
+}
+
+/// settlement, maturity, last_interest, rate, yld/pr, redemption, frequency, [basis].
+fn odd_last_args(a: &[Arg], sys: DateSystem) -> R<((f64, f64, f64), f64, f64, f64, f64)> {
+    let (s, m, last) = (date(a, 0)?, date(a, 1)?, date(a, 2)?);
+    let (rate, x, red) = (num(a, 3)?, num(a, 4)?, num(a, 5)?);
+    let (f, basis) = (freq_arg(a, 6)?, basis_arg(a, 7)?);
+    if rate < 0.0 || red <= 0.0 {
+        return Err(CellError::Num);
+    }
+    Ok((odd_last(sys, s, m, last, f, basis)?, rate, x, red, f))
+}
+
+pub(super) fn oddlprice(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let ((dc, acc, dsc), rate, yld, red, f) = odd_last_args(a, c.date_system())?;
+    if yld < 0.0 {
+        return Err(CellError::Num);
+    }
+    let coupon = 100.0 * rate / f;
+    num_val((red + dc * coupon) / (1.0 + dsc * yld / f) - acc * coupon)
+}
+
+pub(super) fn oddlyield(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
+    let ((dc, acc, dsc), rate, pr, red, f) = odd_last_args(a, c.date_system())?;
+    if pr <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let coupon = 100.0 * rate / f;
+    let paid = pr + acc * coupon;
+    if paid <= 0.0 || dsc <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((red + dc * coupon - paid) / paid * f / dsc)
+}
diff --git a/crates/functions/src/financial/tvm.rs b/crates/functions/src/financial/tvm.rs
new file mode 100644
index 000000000..a62d29bb5
--- /dev/null
+++ b/crates/functions/src/financial/tvm.rs
@@ -0,0 +1,415 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Time value of money
+// ---------------------------------------------------------------------------------------------
+
+/// The payment per period. `(1 + rate)^nper` comes from `nper * ln_1p(rate)` and `p - 1` from
+/// `exp_m1`: rounding `1 + rate` first throws away the low bits of a small rate, which left PMT up to
+/// about 1000 ULPs from Excel (observed over 400 synthetic probes; this form is within 4). A loan
+/// schedule's last `IF(p - SUM(principal) > 0, ...)` turns on those bits. Excel gives #NUM! for a
+/// rate of -1 or less, and -pv*rate (no divide) once `(1 + rate)^nper` overflows.
+fn pmt_calc(rate: f64, nper: f64, pv: f64, fv: f64, typ: f64) -> f64 {
+    if rate == 0.0 {
+        return -(pv + fv) / nper;
+    }
+    if rate <= -1.0 {
+        return f64::NAN;
+    }
+    let l = nper * rate.ln_1p();
+    let m = l.exp_m1();
+    let k = 1.0 + rate * typ;
+    if m > 0.0 {
+        // (fv + pv*p) / (p - 1) = pv + (pv + fv) / (p - 1), without the cancellation in p - 1.
+        // rate / m (about 1 / nper for a tiny rate) is taken first so (pv + fv) / m can't overflow.
+        -(pv * rate + (pv + fv) * (rate / m)) / k
+    } else if m > -0.5 {
+        // p near 1 from below: fv + pv*p = (pv + fv) + pv*m keeps the small terms that rounding p would drop.
+        -(rate * (pv + fv + pv * m)) / (k * m)
+    } else {
+        // p well below 1: m nears -1 and pv*m would swallow pv + fv, so use p itself.
+        -(rate * (fv + pv * l.exp())) / (k * m)
+    }
+}
+
+fn fv_calc(rate: f64, nper: f64, pmt: f64, pv: f64, typ: f64) -> f64 {
+    if rate == 0.0 {
+        return -(pv + pmt * nper);
+    }
+    let p = (1.0 + rate).powf(nper);
+    -(pv * p + pmt * (1.0 + rate * typ) * (p - 1.0) / rate)
+}
+
+fn pv_calc(rate: f64, nper: f64, pmt: f64, fv: f64, typ: f64) -> f64 {
+    if rate == 0.0 {
+        return -(fv + pmt * nper);
+    }
+    let p = (1.0 + rate).powf(nper);
+    -(fv + pmt * (1.0 + rate * typ) * (p - 1.0) / rate) / p
+}
+
+pub(super) fn pmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, nper, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let (fv, typ) = (opt_num(a, 3, 0.0)?, type_arg(a, 4)?);
+    if nper == 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(pmt_calc(rate, nper, pv, fv, typ))
+}
+
+pub(super) fn fv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, nper, pmt) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    num_val(fv_calc(rate, nper, pmt, opt_num(a, 3, 0.0)?, type_arg(a, 4)?))
+}
+
+pub(super) fn pv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, nper, pmt) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    num_val(pv_calc(rate, nper, pmt, opt_num(a, 3, 0.0)?, type_arg(a, 4)?))
+}
+
+pub(super) fn nper(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, pmt, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let (fv, typ) = (opt_num(a, 3, 0.0)?, type_arg(a, 4)?);
+    if rate == 0.0 {
+        if pmt == 0.0 {
+            return Err(CellError::Num);
+        }
+        return num_val(-(pv + fv) / pmt);
+    }
+    let numer = pmt * (1.0 + rate * typ) - fv * rate;
+    let denom = pv * rate + pmt * (1.0 + rate * typ);
+    if denom == 0.0 {
+        return Err(CellError::Num);
+    }
+    let q = numer / denom;
+    if q <= 0.0 || rate <= -1.0 {
+        return Err(CellError::Num);
+    }
+    num_val(q.ln() / (1.0 + rate).ln())
+}
+
+fn ipmt_calc(rate: f64, per: f64, nper: f64, pv: f64, fv: f64, typ: f64) -> f64 {
+    let p = pmt_calc(rate, nper, pv, fv, typ);
+    if typ == 1.0 && per == 1.0 {
+        return 0.0;
+    }
+    let bal = fv_calc(rate, per - 1.0, p, pv, typ);
+    let i = bal * rate;
+    if typ == 1.0 { i / (1.0 + rate) } else { i }
+}
+
+pub(super) fn ipmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, per, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
+    let (fv, typ) = (opt_num(a, 4, 0.0)?, type_arg(a, 5)?);
+    if per < 1.0 || per > np || np == 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(ipmt_calc(rate, per, np, pv, fv, typ))
+}
+
+pub(super) fn ppmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, per, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
+    let (fv, typ) = (opt_num(a, 4, 0.0)?, type_arg(a, 5)?);
+    if per < 1.0 || per > np || np == 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(pmt_calc(rate, np, pv, fv, typ) - ipmt_calc(rate, per, np, pv, fv, typ))
+}
+
+fn cumulative(a: &[Arg], principal: bool) -> R<Value> {
+    let (rate, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let (start, end, typ) = (num(a, 3)?.trunc(), num(a, 4)?.trunc(), num(a, 5)?);
+    let np_i = np.trunc();
+    if rate <= 0.0 || np_i <= 0.0 || pv <= 0.0 || start < 1.0 || end < start || end > np_i || (typ != 0.0 && typ != 1.0) {
+        return Err(CellError::Num);
+    }
+    if end - start > 1e7 || np_i > 1e15 {
+        return Err(CellError::Num);
+    }
+    let p = pmt_calc(rate, np_i, pv, 0.0, typ);
+    let mut sum = 0.0;
+    let mut per = start;
+    while per <= end {
+        let i = ipmt_calc(rate, per, np_i, pv, 0.0, typ);
+        sum += if principal { p - i } else { i };
+        per += 1.0;
+    }
+    num_val(sum)
+}
+
+pub(super) fn cumipmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    cumulative(a, false)
+}
+
+pub(super) fn cumprinc(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    cumulative(a, true)
+}
+
+/// Newton iteration with a numeric derivative, keeping the rate above -1.
+fn newton(f: impl Fn(f64) -> f64, guess: f64) -> Option<f64> {
+    let mut x = guess;
+    for _ in 0..200 {
+        let y = f(x);
+        if !y.is_finite() {
+            return None;
+        }
+        let h = 1e-6 * x.abs().max(1e-3);
+        let d = (f(x + h) - f(x - h)) / (2.0 * h);
+        if d == 0.0 || !d.is_finite() {
+            return None;
+        }
+        let mut nx = x - y / d;
+        if nx <= -1.0 {
+            nx = (x - 1.0) / 2.0;
+            if nx <= -1.0 {
+                nx = -0.999_999_999;
+            }
+        }
+        if (nx - x).abs() < 1e-12 * nx.abs().max(1.0) {
+            return Some(nx);
+        }
+        x = nx;
+    }
+    None
+}
+
+/// Tries Newton from the guess and a few fallback starting points; then bisection over a
+/// bracket if one can be found.
+fn solve_rate(f: impl Fn(f64) -> f64, guess: f64) -> R<f64> {
+    let check = |r: f64| f(r).is_finite() && f(r).abs() < 1e-7 * (1.0 + f(guess).abs().min(1e12));
+    for g in [guess, 0.1, 0.01, 0.5, -0.5, 1.0, 0.001, 5.0, -0.9, 10.0] {
+        if let Some(r) = newton(&f, g)
+            && r > -1.0
+            && check(r)
+        {
+            return Ok(r);
+        }
+    }
+    // Scan for a sign change and bisect.
+    let grid: Vec<f64> = [-0.999_999, -0.99, -0.9, -0.5, -0.2, 0.0, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 100.0, 1000.0].to_vec();
+    for w in grid.windows(2) {
+        let (mut lo, mut hi) = match w {
+            [a, b] => (*a, *b),
+            _ => continue,
+        };
+        let (flo, fhi) = (f(lo), f(hi));
+        if !(flo.is_finite() && fhi.is_finite()) || flo * fhi > 0.0 {
+            continue;
+        }
+        let lo_neg = flo < 0.0;
+        for _ in 0..200 {
+            let mid = 0.5 * (lo + hi);
+            let fm = f(mid);
+            if (fm < 0.0) == lo_neg {
+                lo = mid;
+            } else {
+                hi = mid;
+            }
+        }
+        return Ok(0.5 * (lo + hi));
+    }
+    Err(CellError::Num)
+}
+
+pub(super) fn rate(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (np, pmt, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    let (fv, typ, guess) = (opt_num(a, 3, 0.0)?, type_arg(a, 4)?, opt_num(a, 5, 0.1)?);
+    if np <= 0.0 {
+        return Err(CellError::Num);
+    }
+    let f = |r: f64| {
+        if r.abs() < 1e-12 {
+            pv + pmt * np + fv
+        } else {
+            let p = (1.0 + r).powf(np);
+            pv * p + pmt * (1.0 + r * typ) * (p - 1.0) / r + fv
+        }
+    };
+    num_val(solve_rate(f, guess)?)
+}
+
+pub(super) fn npv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let rate = num(a, 0)?;
+    if rate == -1.0 {
+        return Err(CellError::Div0);
+    }
+    let vals = numbers(a.get(1..).unwrap_or(&[]))?;
+    let mut sum = 0.0;
+    let mut d = 1.0;
+    for v in vals {
+        d *= 1.0 + rate;
+        sum += v / d;
+    }
+    num_val(sum)
+}
+
+/// Values and dates for XNPV/XIRR: both must be numeric and of equal length.
+fn dated_flows(values: &Value, dates: &Value) -> R<(Vec<f64>, Vec<f64>)> {
+    let va = as_array(values);
+    let da = as_array(dates);
+    if va.data.len() != da.data.len() {
+        return Err(CellError::Num);
+    }
+    let mut v = Vec::with_capacity(va.data.len());
+    let mut d = Vec::with_capacity(da.data.len());
+    for (x, y) in va.data.iter().zip(da.data.iter()) {
+        match x {
+            Value::Number(n) => v.push(*n),
+            Value::Error(e) => return Err(*e),
+            _ => return Err(CellError::Value),
+        }
+        match y {
+            Value::Number(n) => d.push(n.trunc()),
+            Value::Error(e) => return Err(*e),
+            Value::Text(_) => d.push(y.to_number()?.trunc()),
+            _ => return Err(CellError::Value),
+        }
+    }
+    let d0 = *d.first().ok_or(CellError::Num)?;
+    if d.iter().any(|&x| x < d0 || x < 0.0) {
+        return Err(CellError::Num);
+    }
+    Ok((v, d))
+}
+
+fn xnpv_calc(rate: f64, v: &[f64], d: &[f64]) -> f64 {
+    let d0 = d.first().copied().unwrap_or(0.0);
+    v.iter().zip(d).map(|(x, t)| x / (1.0 + rate).powf((t - d0) / 365.0)).sum()
+}
+
+pub(super) fn xnpv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let rate = num(a, 0)?;
+    if rate <= -1.0 {
+        return Err(CellError::Num);
+    }
+    let (v, d) = dated_flows(&a.get(1).ok_or(CellError::Value)?.value, &a.get(2).ok_or(CellError::Value)?.value)?;
+    num_val(xnpv_calc(rate, &v, &d))
+}
+
+pub(super) fn xirr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (v, d) = dated_flows(&a.first().ok_or(CellError::Value)?.value, &a.get(1).ok_or(CellError::Value)?.value)?;
+    let guess = opt_num(a, 2, 0.1)?;
+    if !v.iter().any(|x| *x > 0.0) || !v.iter().any(|x| *x < 0.0) {
+        return Err(CellError::Num);
+    }
+    num_val(solve_rate(|r| xnpv_calc(r, &v, &d), guess)?)
+}
+
+pub(super) fn irr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let v = array_numbers(&a.first().ok_or(CellError::Value)?.value)?;
+    let guess = opt_num(a, 1, 0.1)?;
+    if !v.iter().any(|x| *x > 0.0) || !v.iter().any(|x| *x < 0.0) {
+        return Err(CellError::Num);
+    }
+    let f = |r: f64| {
+        let mut s = 0.0;
+        let mut d = 1.0;
+        for x in &v {
+            s += x / d;
+            d *= 1.0 + r;
+        }
+        s
+    };
+    num_val(solve_rate(f, guess)?)
+}
+
+pub(super) fn mirr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let v = array_numbers(&a.first().ok_or(CellError::Value)?.value)?;
+    let (fr, rr) = (num(a, 1)?, num(a, 2)?);
+    let n = v.len() as f64;
+    if v.len() < 2 {
+        return Err(CellError::Div0);
+    }
+    let (mut pos, mut neg) = (0.0, 0.0);
+    for (i, x) in v.iter().enumerate() {
+        if *x > 0.0 {
+            pos += x / (1.0 + rr).powi(i as i32);
+        } else if *x < 0.0 {
+            neg += x / (1.0 + fr).powi(i as i32);
+        }
+    }
+    // No positive flow is not an error in Excel: the formula below gives -1.
+    if neg == 0.0 {
+        return Err(CellError::Div0);
+    }
+    let r = (-pos * (1.0 + rr).powf(n - 1.0) / neg).powf(1.0 / (n - 1.0)) - 1.0;
+    num_val(r)
+}
+
+pub(super) fn fvschedule(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let mut p = num(a, 0)?;
+    for v in flatten(a.get(1..2).unwrap_or(&[])) {
+        let r = match v {
+            Value::Number(n) => n,
+            Value::Empty => 0.0,
+            Value::Error(e) => return Err(e),
+            _ => return Err(CellError::Value),
+        };
+        p *= 1.0 + r;
+    }
+    num_val(p)
+}
+
+pub(super) fn effect(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (nom, n) = (num(a, 0)?, num(a, 1)?.trunc());
+    if nom <= 0.0 || n < 1.0 {
+        return Err(CellError::Num);
+    }
+    num_val((1.0 + nom / n).powf(n) - 1.0)
+}
+
+pub(super) fn nominal(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (eff, n) = (num(a, 0)?, num(a, 1)?.trunc());
+    if eff <= 0.0 || n < 1.0 {
+        return Err(CellError::Num);
+    }
+    num_val(n * ((1.0 + eff).powf(1.0 / n) - 1.0))
+}
+
+pub(super) fn ispmt(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, per, np, pv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?, num(a, 3)?);
+    if np == 0.0 {
+        return Err(CellError::Div0);
+    }
+    num_val(pv * rate * (per / np - 1.0))
+}
+
+pub(super) fn pduration(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (rate, pv, fv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if rate <= 0.0 || pv <= 0.0 || fv <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((fv.ln() - pv.ln()) / (1.0 + rate).ln())
+}
+
+pub(super) fn rri(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (np, pv, fv) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
+    if np <= 0.0 || pv == 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val((fv / pv).powf(1.0 / np) - 1.0)
+}
+
+fn dollar_digits(fraction: f64) -> R<f64> {
+    if fraction < 0.0 {
+        return Err(CellError::Num);
+    }
+    if fraction < 1.0 {
+        return Err(CellError::Div0);
+    }
+    Ok(10f64.powf(fraction.log10().ceil()))
+}
+
+pub(super) fn dollarde(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (x, f) = (num(a, 0)?, num(a, 1)?.trunc());
+    let p = dollar_digits(f)?;
+    let int = x.trunc();
+    num_val(int + (x - int) * p / f)
+}
+
+pub(super) fn dollarfr(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (x, f) = (num(a, 0)?, num(a, 1)?.trunc());
+    let p = dollar_digits(f)?;
+    let int = x.trunc();
+    num_val(int + (x - int) * f / p)
+}

From be18ee051935c4765bd9acdd79ade327eb138cd4 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:59:48 +0000
Subject: [PATCH 60/76] refactor(functions): move engineering.rs items to
 engineering/

---
 crates/functions/src/engineering.rs         | 786 +-------------------
 crates/functions/src/engineering/bessel.rs  | 245 ++++++
 crates/functions/src/engineering/complex.rs | 268 +++++++
 crates/functions/src/engineering/units.rs   | 286 +++++++
 4 files changed, 809 insertions(+), 776 deletions(-)
 create mode 100644 crates/functions/src/engineering/bessel.rs
 create mode 100644 crates/functions/src/engineering/complex.rs
 create mode 100644 crates/functions/src/engineering/units.rs

diff --git a/crates/functions/src/engineering.rs b/crates/functions/src/engineering.rs
index 86ab7d7c7..ed2572f90 100644
--- a/crates/functions/src/engineering.rs
+++ b/crates/functions/src/engineering.rs
@@ -197,283 +197,6 @@ fn bitrshift(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     shift(a, false)
 }
 
-// ---------------------------------------------------------------------------------------------
-// CONVERT
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-enum Dim {
-    Mass,
-    Length,
-    Time,
-    Pressure,
-    Force,
-    Energy,
-    Power,
-    Magnetism,
-    Temperature,
-    Volume,
-    Area,
-    Information,
-    Speed,
-}
-
-/// How a unit accepts prefixes: none, SI (raised to `power` for areas/volumes) or SI + binary.
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Pre {
-    No,
-    Si(i32),
-    Bin,
-}
-
-struct Unit {
-    names: &'static [&'static str],
-    dim: Dim,
-    factor: f64,
-    pre: Pre,
-}
-
-const fn u(names: &'static [&'static str], dim: Dim, factor: f64, pre: Pre) -> Unit {
-    Unit { names, dim, factor, pre }
-}
-
-const IN: f64 = 0.0254;
-const FT: f64 = 0.3048;
-const YD: f64 = 0.9144;
-const MI: f64 = 1609.344;
-const NMI: f64 = 1852.0;
-const LY: f64 = 9_460_730_472_580_800.0;
-const PICA_PT: f64 = 0.0254 / 72.0;
-const PICA: f64 = 0.0254 / 6.0;
-const GAL: f64 = 0.003_785_411_784;
-
-const UNITS: &[Unit] = &[
-    // Mass (gram)
-    u(&["g"], Dim::Mass, 1.0, Pre::Si(1)),
-    u(&["sg"], Dim::Mass, 14_593.902_937_206_4, Pre::No),
-    u(&["lbm"], Dim::Mass, 453.592_37, Pre::No),
-    u(&["u"], Dim::Mass, 1.660_539_066_6e-24, Pre::Si(1)),
-    u(&["ozm"], Dim::Mass, 28.349_523_125, Pre::No),
-    u(&["grain"], Dim::Mass, 0.064_798_91, Pre::No),
-    u(&["cwt", "shweight"], Dim::Mass, 45_359.237, Pre::No),
-    u(&["uk_cwt", "lcwt", "hweight"], Dim::Mass, 50_802.345_44, Pre::No),
-    u(&["stone"], Dim::Mass, 6_350.293_18, Pre::No),
-    u(&["ton"], Dim::Mass, 907_184.74, Pre::No),
-    u(&["uk_ton", "LTON", "brton"], Dim::Mass, 1_016_046.908_8, Pre::No),
-    // Length (metre)
-    u(&["m"], Dim::Length, 1.0, Pre::Si(1)),
-    u(&["mi"], Dim::Length, MI, Pre::No),
-    u(&["Nmi"], Dim::Length, NMI, Pre::No),
-    u(&["in"], Dim::Length, IN, Pre::No),
-    u(&["ft"], Dim::Length, FT, Pre::No),
-    u(&["yd"], Dim::Length, YD, Pre::No),
-    u(&["ang"], Dim::Length, 1e-10, Pre::Si(1)),
-    u(&["ell"], Dim::Length, 1.143, Pre::No),
-    u(&["ly"], Dim::Length, LY, Pre::Si(1)),
-    u(&["parsec", "pc"], Dim::Length, 30_856_775_814_913_673.0, Pre::Si(1)),
-    u(&["Picapt", "Pica"], Dim::Length, PICA_PT, Pre::No),
-    u(&["pica"], Dim::Length, PICA, Pre::No),
-    u(&["survey_mi"], Dim::Length, 1_609.347_218_694_437, Pre::No),
-    // Time (second)
-    u(&["yr"], Dim::Time, 31_557_600.0, Pre::No),
-    u(&["day", "d"], Dim::Time, 86_400.0, Pre::No),
-    u(&["hr"], Dim::Time, 3_600.0, Pre::No),
-    u(&["mn", "min"], Dim::Time, 60.0, Pre::No),
-    u(&["sec", "s"], Dim::Time, 1.0, Pre::Si(1)),
-    // Pressure (pascal)
-    u(&["Pa", "p"], Dim::Pressure, 1.0, Pre::Si(1)),
-    u(&["atm", "at"], Dim::Pressure, 101_325.0, Pre::Si(1)),
-    u(&["mmHg"], Dim::Pressure, 133.322_387_415, Pre::Si(1)),
-    u(&["psi"], Dim::Pressure, 6_894.757_293_168_36, Pre::No),
-    u(&["Torr"], Dim::Pressure, 101_325.0 / 760.0, Pre::No),
-    // Force (newton)
-    u(&["N"], Dim::Force, 1.0, Pre::Si(1)),
-    u(&["dyn", "dy"], Dim::Force, 1e-5, Pre::Si(1)),
-    u(&["lbf"], Dim::Force, 4.448_221_615_260_5, Pre::No),
-    u(&["pond"], Dim::Force, 0.009_806_65, Pre::Si(1)),
-    // Energy (joule)
-    u(&["J"], Dim::Energy, 1.0, Pre::Si(1)),
-    u(&["e"], Dim::Energy, 1e-7, Pre::Si(1)),
-    u(&["c"], Dim::Energy, 4.184, Pre::Si(1)),
-    u(&["cal"], Dim::Energy, 4.1868, Pre::Si(1)),
-    u(&["eV", "ev"], Dim::Energy, 1.602_176_634e-19, Pre::Si(1)),
-    u(&["HPh", "hh"], Dim::Energy, 2_684_519.537_696_17, Pre::No),
-    u(&["Wh", "wh"], Dim::Energy, 3_600.0, Pre::Si(1)),
-    u(&["flb"], Dim::Energy, 1.355_817_948_331_4, Pre::No),
-    u(&["BTU", "btu"], Dim::Energy, 1_055.055_852_62, Pre::No),
-    // Power (watt)
-    u(&["W", "w"], Dim::Power, 1.0, Pre::Si(1)),
-    u(&["HP", "h"], Dim::Power, 745.699_871_582_270_2, Pre::No),
-    u(&["PS"], Dim::Power, 735.498_75, Pre::No),
-    // Magnetism (tesla)
-    u(&["T"], Dim::Magnetism, 1.0, Pre::Si(1)),
-    u(&["ga"], Dim::Magnetism, 1e-4, Pre::Si(1)),
-    // Temperature (handled specially; factor unused)
-    u(&["C", "cel"], Dim::Temperature, 1.0, Pre::No),
-    u(&["F", "fah"], Dim::Temperature, 1.0, Pre::No),
-    u(&["K", "kel"], Dim::Temperature, 1.0, Pre::Si(1)),
-    u(&["Rank"], Dim::Temperature, 1.0, Pre::No),
-    u(&["Reau"], Dim::Temperature, 1.0, Pre::No),
-    // Volume (cubic metre)
-    u(&["l", "L", "lt"], Dim::Volume, 0.001, Pre::Si(1)),
-    u(&["tsp"], Dim::Volume, GAL / 768.0, Pre::No),
-    u(&["tspm"], Dim::Volume, 5e-6, Pre::No),
-    u(&["tbs"], Dim::Volume, GAL / 256.0, Pre::No),
-    u(&["oz"], Dim::Volume, GAL / 128.0, Pre::No),
-    u(&["cup"], Dim::Volume, GAL / 16.0, Pre::No),
-    u(&["pt", "us_pt"], Dim::Volume, GAL / 8.0, Pre::No),
-    u(&["uk_pt"], Dim::Volume, 0.000_568_261_25, Pre::No),
-    u(&["qt"], Dim::Volume, GAL / 4.0, Pre::No),
-    u(&["uk_qt"], Dim::Volume, 0.001_136_522_5, Pre::No),
-    u(&["gal"], Dim::Volume, GAL, Pre::No),
-    u(&["uk_gal"], Dim::Volume, 0.004_546_09, Pre::No),
-    u(&["m3"], Dim::Volume, 1.0, Pre::Si(3)),
-    u(&["mi3"], Dim::Volume, MI * MI * MI, Pre::No),
-    u(&["Nmi3"], Dim::Volume, NMI * NMI * NMI, Pre::No),
-    u(&["yd3"], Dim::Volume, YD * YD * YD, Pre::No),
-    u(&["ft3"], Dim::Volume, FT * FT * FT, Pre::No),
-    u(&["in3"], Dim::Volume, IN * IN * IN, Pre::No),
-    u(&["ang3"], Dim::Volume, 1e-30, Pre::Si(3)),
-    u(&["ly3"], Dim::Volume, LY * LY * LY, Pre::No),
-    u(&["Picapt3", "Pica3"], Dim::Volume, PICA_PT * PICA_PT * PICA_PT, Pre::No),
-    u(&["barrel"], Dim::Volume, 0.158_987_294_928, Pre::No),
-    u(&["bushel"], Dim::Volume, 0.035_239_070_166_88, Pre::No),
-    u(&["MTON"], Dim::Volume, 1.132_673_863_68, Pre::No),
-    u(&["GRT", "regton"], Dim::Volume, 2.831_684_659_2, Pre::No),
-    // Area (square metre)
-    u(&["m2"], Dim::Area, 1.0, Pre::Si(2)),
-    u(&["ha"], Dim::Area, 10_000.0, Pre::No),
-    u(&["ar"], Dim::Area, 100.0, Pre::Si(1)),
-    u(&["ft2"], Dim::Area, FT * FT, Pre::No),
-    u(&["in2"], Dim::Area, IN * IN, Pre::No),
-    u(&["yd2"], Dim::Area, YD * YD, Pre::No),
-    u(&["mi2"], Dim::Area, MI * MI, Pre::No),
-    u(&["Nmi2"], Dim::Area, NMI * NMI, Pre::No),
-    u(&["ang2"], Dim::Area, 1e-20, Pre::Si(2)),
-    u(&["ly2"], Dim::Area, LY * LY, Pre::No),
-    u(&["Picapt2", "Pica2"], Dim::Area, PICA_PT * PICA_PT, Pre::No),
-    u(&["uk_acre"], Dim::Area, 4_046.856_422_4, Pre::No),
-    u(&["us_acre"], Dim::Area, 4_046.872_609_874_252, Pre::No),
-    u(&["Morgen"], Dim::Area, 2_500.0, Pre::No),
-    // Information (bit)
-    u(&["bit"], Dim::Information, 1.0, Pre::Bin),
-    u(&["byte"], Dim::Information, 8.0, Pre::Bin),
-    // Speed (metres per second)
-    u(&["m/s", "m/sec"], Dim::Speed, 1.0, Pre::Si(1)),
-    u(&["m/h", "m/hr"], Dim::Speed, 1.0 / 3600.0, Pre::Si(1)),
-    u(&["mph"], Dim::Speed, MI / 3600.0, Pre::No),
-    u(&["kn"], Dim::Speed, NMI / 3600.0, Pre::No),
-    u(&["admkn"], Dim::Speed, 6080.0 * FT / 3600.0, Pre::No),
-];
-
-const SI_PREFIXES: &[(&str, f64)] = &[
-    ("da", 1e1),
-    ("Y", 1e24),
-    ("Z", 1e21),
-    ("E", 1e18),
-    ("P", 1e15),
-    ("T", 1e12),
-    ("G", 1e9),
-    ("M", 1e6),
-    ("k", 1e3),
-    ("h", 1e2),
-    ("e", 1e1),
-    ("d", 1e-1),
-    ("c", 1e-2),
-    ("m", 1e-3),
-    ("u", 1e-6),
-    ("n", 1e-9),
-    ("p", 1e-12),
-    ("f", 1e-15),
-    ("a", 1e-18),
-    ("z", 1e-21),
-    ("y", 1e-24),
-];
-
-const BIN_PREFIXES: &[(&str, f64)] = &[
-    ("ki", 1024.0),
-    ("Mi", 1_048_576.0),
-    ("Gi", 1_073_741_824.0),
-    ("Ti", 1_099_511_627_776.0),
-    ("Pi", 1_125_899_906_842_624.0),
-    ("Ei", 1_152_921_504_606_846_976.0),
-    ("Zi", 1_180_591_620_717_411_303_424.0),
-    ("Yi", 1_208_925_819_614_629_174_706_176.0),
-];
-
-fn find_unit(name: &str) -> Option<&'static Unit> {
-    UNITS.iter().find(|u| u.names.contains(&name))
-}
-
-/// Resolves a unit name to (unit, prefix multiplier). Exact names win over prefixed ones.
-fn resolve(name: &str) -> Option<(&'static Unit, f64)> {
-    let name = name.replace("^2", "2").replace("^3", "3");
-    if let Some(u) = find_unit(&name) {
-        return Some((u, 1.0));
-    }
-    for (p, f) in BIN_PREFIXES {
-        if let Some(rest) = name.strip_prefix(p)
-            && let Some(u) = find_unit(rest)
-            && u.pre == Pre::Bin
-        {
-            return Some((u, *f));
-        }
-    }
-    for (p, f) in SI_PREFIXES {
-        if let Some(rest) = name.strip_prefix(p)
-            && let Some(u) = find_unit(rest)
-        {
-            match u.pre {
-                Pre::Si(pow) => return Some((u, f.powi(pow))),
-                Pre::Bin => return Some((u, *f)),
-                Pre::No => {}
-            }
-        }
-    }
-    None
-}
-
-fn to_kelvin(name: &str, x: f64) -> f64 {
-    match name {
-        "C" | "cel" => x + 273.15,
-        "F" | "fah" => (x - 32.0) * 5.0 / 9.0 + 273.15,
-        "Rank" => x * 5.0 / 9.0,
-        "Reau" => x * 1.25 + 273.15,
-        _ => x,
-    }
-}
-
-fn from_kelvin(name: &str, k: f64) -> f64 {
-    match name {
-        "C" | "cel" => k - 273.15,
-        "F" | "fah" => (k - 273.15) * 9.0 / 5.0 + 32.0,
-        "Rank" => k * 9.0 / 5.0,
-        "Reau" => (k - 273.15) / 1.25,
-        _ => k,
-    }
-}
-
-fn convert(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let x = num(a, 0)?;
-    let from = text(a, 1)?;
-    let to = text(a, 2)?;
-    let (fu, fp) = resolve(&from).ok_or(CellError::NA)?;
-    let (tu, tp) = resolve(&to).ok_or(CellError::NA)?;
-    if fu.dim != tu.dim {
-        return Err(CellError::NA);
-    }
-    if fu.dim == Dim::Temperature {
-        let fname = fu.names.first().copied().unwrap_or("K");
-        let tname = tu.names.first().copied().unwrap_or("K");
-        if fname == tname && fp == tp {
-            return num_val(x);
-        }
-        let k = to_kelvin(fname, x * fp);
-        return num_val(from_kelvin(tname, k) / tp);
-    }
-    let base = x * fu.factor * fp;
-    num_val(base / (tu.factor * tp))
-}
-
 // ---------------------------------------------------------------------------------------------
 // DELTA, GESTEP, ERF
 
@@ -502,201 +225,6 @@ fn erfc_fn(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     num_val(erfc(num(a, 0)?))
 }
 
-// ---------------------------------------------------------------------------------------------
-// Complex numbers
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-struct Cx {
-    re: f64,
-    im: f64,
-}
-
-impl Cx {
-    fn new(re: f64, im: f64) -> Cx {
-        Cx { re, im }
-    }
-    fn add(self, o: Cx) -> Cx {
-        Cx::new(self.re + o.re, self.im + o.im)
-    }
-    fn sub(self, o: Cx) -> Cx {
-        Cx::new(self.re - o.re, self.im - o.im)
-    }
-    fn mul(self, o: Cx) -> Cx {
-        Cx::new(self.re * o.re - self.im * o.im, self.re * o.im + self.im * o.re)
-    }
-    fn div(self, o: Cx) -> R<Cx> {
-        let d = o.re * o.re + o.im * o.im;
-        if d == 0.0 {
-            return Err(CellError::Num);
-        }
-        Ok(Cx::new((self.re * o.re + self.im * o.im) / d, (self.im * o.re - self.re * o.im) / d))
-    }
-    fn abs(self) -> f64 {
-        self.re.hypot(self.im)
-    }
-    fn arg(self) -> f64 {
-        self.im.atan2(self.re)
-    }
-    fn exp(self) -> Cx {
-        let e = self.re.exp();
-        Cx::new(e * self.im.cos(), e * self.im.sin())
-    }
-    fn ln(self) -> R<Cx> {
-        if self.re == 0.0 && self.im == 0.0 {
-            return Err(CellError::Num);
-        }
-        Ok(Cx::new(self.abs().ln(), self.arg()))
-    }
-    fn sin(self) -> Cx {
-        Cx::new(self.re.sin() * self.im.cosh(), self.re.cos() * self.im.sinh())
-    }
-    fn cos(self) -> Cx {
-        Cx::new(self.re.cos() * self.im.cosh(), -self.re.sin() * self.im.sinh())
-    }
-    fn sinh(self) -> Cx {
-        Cx::new(self.re.sinh() * self.im.cos(), self.re.cosh() * self.im.sin())
-    }
-    fn cosh(self) -> Cx {
-        Cx::new(self.re.cosh() * self.im.cos(), self.re.sinh() * self.im.sin())
-    }
-    fn powf(self, n: f64) -> R<Cx> {
-        if self.re == 0.0 && self.im == 0.0 {
-            return if n > 0.0 { Ok(Cx::new(0.0, 0.0)) } else { Err(CellError::Num) };
-        }
-        let r = self.abs().powf(n);
-        let t = self.arg() * n;
-        Ok(Cx::new(r * t.cos(), r * t.sin()))
-    }
-}
-
-const ONE: Cx = Cx { re: 1.0, im: 0.0 };
-
-/// Parses a real number written in a complex string (no spaces, optional exponent).
-fn parse_real(s: &str) -> Option<f64> {
-    if s.is_empty() || s.contains(char::is_whitespace) {
-        return None;
-    }
-    let ok = s.chars().all(|c| c.is_ascii_digit() || matches!(c, '.' | 'e' | 'E' | '+' | '-'));
-    if !ok {
-        return None;
-    }
-    s.parse::<f64>().ok().filter(|v| v.is_finite())
-}
-
-/// Parses "a+bi" forms. Returns the number and its suffix ('i', 'j' or none).
-fn parse_complex(s: &str) -> R<(Cx, Option<char>)> {
-    if s.is_empty() {
-        return Ok((Cx::new(0.0, 0.0), None));
-    }
-    let suffix = match s.chars().last() {
-        Some(c @ ('i' | 'j')) => Some(c),
-        _ => None,
-    };
-    let Some(sfx) = suffix else {
-        return parse_real(s).map(|r| (Cx::new(r, 0.0), None)).ok_or(CellError::Num);
-    };
-    let body = &s[..s.len() - 1];
-    // Split at the last sign that is not at the start and not part of an exponent.
-    let bytes = body.as_bytes();
-    let mut split = None;
-    for i in (1..bytes.len()).rev() {
-        let c = bytes.get(i).copied().unwrap_or(0);
-        let prev = bytes.get(i - 1).copied().unwrap_or(0);
-        if (c == b'+' || c == b'-') && prev != b'e' && prev != b'E' {
-            split = Some(i);
-            break;
-        }
-    }
-    let (re_s, im_s) = match split {
-        Some(i) => (&body[..i], &body[i..]),
-        None => ("", body),
-    };
-    let re = if re_s.is_empty() { 0.0 } else { parse_real(re_s).ok_or(CellError::Num)? };
-    let im = match im_s {
-        "" | "+" => 1.0,
-        "-" => -1.0,
-        t => parse_real(t).ok_or(CellError::Num)?,
-    };
-    Ok((Cx::new(re, im), Some(sfx)))
-}
-
-fn cx_of(v: &Value) -> R<(Cx, Option<char>)> {
-    match v {
-        Value::Number(n) => Ok((Cx::new(*n, 0.0), None)),
-        Value::Empty => Ok((Cx::new(0.0, 0.0), None)),
-        Value::Bool(_) => Err(CellError::Value),
-        Value::Error(e) => Err(*e),
-        Value::Text(t) => parse_complex(t),
-        Value::Array(a) => cx_of(a.data.first().unwrap_or(&Value::Empty)),
-    }
-}
-
-fn cx_arg(a: &[Arg], i: usize) -> R<(Cx, Option<char>)> {
-    cx_of(&a.get(i).map(scalar).unwrap_or(Value::Empty))
-}
-
-fn merge_suffix(acc: Option<char>, s: Option<char>) -> R<Option<char>> {
-    match (acc, s) {
-        (Some(x), Some(y)) if x != y => Err(CellError::Value),
-        (Some(x), _) => Ok(Some(x)),
-        (None, y) => Ok(y),
-    }
-}
-
-fn fmt_complex(z: Cx, suffix: char) -> R<Value> {
-    if !z.re.is_finite() || !z.im.is_finite() {
-        return Err(CellError::Num);
-    }
-    let re = clean(z.re);
-    let im = clean(z.im);
-    let mut s = String::new();
-    if im == 0.0 {
-        s.push_str(&number_to_text(re));
-        return text_val(s);
-    }
-    if re != 0.0 {
-        s.push_str(&number_to_text(re));
-        if im > 0.0 {
-            s.push('+');
-        }
-    }
-    if im == -1.0 {
-        s.push('-');
-    } else if im != 1.0 {
-        s.push_str(&number_to_text(im));
-    }
-    s.push(suffix);
-    text_val(s)
-}
-
-/// Rounds to 15 significant digits so values like 0.999999999999999999 print as 1.
-fn clean(x: f64) -> f64 {
-    let s = format!("{:.14e}", x);
-    s.parse().unwrap_or(x)
-}
-
-fn complex(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let re = num(a, 0)?;
-    let im = num(a, 1)?;
-    let sfx = if has(a, 2) { text(a, 2)? } else { "i".into() };
-    let sfx = match sfx.as_str() {
-        "i" | "" => 'i',
-        "j" => 'j',
-        _ => return Err(CellError::Value),
-    };
-    fmt_complex(Cx::new(re, im), sfx)
-}
-
-fn im_unary(a: &[Arg], f: fn(Cx) -> R<Cx>) -> R<Value> {
-    let (z, s) = cx_arg(a, 0)?;
-    fmt_complex(f(z)?, s.unwrap_or('i'))
-}
-
-fn im_real_fn(a: &[Arg], f: fn(Cx) -> R<f64>) -> R<Value> {
-    let (z, _) = cx_arg(a, 0)?;
-    num_val(f(z)?)
-}
-
 macro_rules! im1 {
     ($name:ident, $f:expr) => {
         fn $name(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
@@ -705,6 +233,16 @@ macro_rules! im1 {
     };
 }
 
+mod bessel;
+mod complex;
+mod units;
+
+use bessel::{besseli, besselj, besselk, bessely};
+#[cfg(test)]
+use complex::parse_complex;
+use complex::{Cx, ONE, complex, im_unary, imabs, imaginary, imargument, imdiv, impower, improduct, imreal, imsub, imsum};
+use units::convert;
+
 im1!(imconjugate, |z: Cx| Ok(Cx::new(z.re, -z.im)));
 im1!(imexp, |z: Cx| Ok(z.exp()));
 im1!(imln, |z: Cx| z.ln());
@@ -727,310 +265,6 @@ im1!(imcosh, |z: Cx| Ok(z.cosh()));
 im1!(imsech, |z: Cx| ONE.div(z.cosh()));
 im1!(imcsch, |z: Cx| ONE.div(z.sinh()));
 
-fn imabs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_real_fn(a, |z| Ok(z.abs()))
-}
-fn imreal(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_real_fn(a, |z| Ok(z.re))
-}
-fn imaginary(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_real_fn(a, |z| Ok(z.im))
-}
-fn imargument(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_real_fn(a, |z| if z.re == 0.0 && z.im == 0.0 { Err(CellError::Div0) } else { Ok(z.arg()) })
-}
-
-fn im_binary(a: &[Arg], f: fn(Cx, Cx) -> R<Cx>) -> R<Value> {
-    let (x, s1) = cx_arg(a, 0)?;
-    let (y, s2) = cx_arg(a, 1)?;
-    let s = merge_suffix(s1, s2)?;
-    fmt_complex(f(x, y)?, s.unwrap_or('i'))
-}
-fn imdiv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_binary(a, Cx::div)
-}
-fn imsub(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_binary(a, |x, y| Ok(x.sub(y)))
-}
-fn impower(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (z, s) = cx_arg(a, 0)?;
-    let n = num(a, 1)?;
-    // Integer powers by repeated multiplication are exact for small Gaussian integers.
-    let r = if n == n.trunc() && n.abs() <= 64.0 && !(z.re == 0.0 && z.im == 0.0) {
-        let mut acc = ONE;
-        for _ in 0..(n.abs() as u32) {
-            acc = acc.mul(z);
-        }
-        if n < 0.0 { ONE.div(acc)? } else { acc }
-    } else {
-        z.powf(n)?
-    };
-    fmt_complex(r, s.unwrap_or('i'))
-}
-
-fn im_fold(a: &[Arg], init: Cx, f: fn(Cx, Cx) -> Cx) -> R<Value> {
-    let mut acc = init;
-    let mut sfx = None;
-    for arg in a {
-        let direct = !matches!(arg.value, Value::Array(_));
-        for v in flatten(std::slice::from_ref(arg)) {
-            if matches!(v, Value::Empty) && !direct {
-                continue;
-            }
-            let (z, s) = cx_of(&v)?;
-            sfx = merge_suffix(sfx, s)?;
-            acc = f(acc, z);
-        }
-    }
-    fmt_complex(acc, sfx.unwrap_or('i'))
-}
-fn imsum(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_fold(a, Cx::new(0.0, 0.0), Cx::add)
-}
-fn improduct(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    im_fold(a, ONE, Cx::mul)
-}
-
-// ---------------------------------------------------------------------------------------------
-// Bessel functions
-
-const MAX_BESSEL_POINTS: f64 = 4_000_000.0;
-
-/// J_n(x) for integer n ≥ 0 via Bessel's integral, J_n(x) = (1/2π)∫₀^{2π} cos(nτ − x sin τ) dτ,
-/// evaluated with the trapezoid rule, which converges exponentially for periodic integrands.
-fn bessel_j(n: u32, x: f64) -> Option<f64> {
-    let pts = (2.0 * (x.abs() + n as f64) + 64.0).ceil();
-    if pts > MAX_BESSEL_POINTS {
-        return if x.abs() > 1e6 { hankel(n, x.abs()).map(|(j, _)| if x < 0.0 && n % 2 == 1 { -j } else { j }) } else { None };
-    }
-    let m = pts as usize;
-    let h = 2.0 * PI / m as f64;
-    let nf = n as f64;
-    let mut sum = 0.0;
-    for k in 0..m {
-        let t = k as f64 * h;
-        sum += (nf * t - x * t.sin()).cos();
-    }
-    Some(sum / m as f64)
-}
-
-/// Hankel asymptotic expansion: (J_n(x), Y_n(x)) for large x.
-fn hankel(n: u32, x: f64) -> Option<(f64, f64)> {
-    let mu = 4.0 * (n as f64) * (n as f64);
-    let mut p = 0.0;
-    let mut q = 0.0;
-    let mut term: f64 = 1.0;
-    let mut last = f64::INFINITY;
-    for k in 0..200 {
-        if term.abs() > last {
-            break;
-        }
-        let t = if k % 4 < 2 { term } else { -term };
-        if k % 2 == 0 {
-            p += t;
-        } else {
-            q += t;
-        }
-        last = term.abs();
-        if last < 1e-17 {
-            break;
-        }
-        let kk = (k + 1) as f64;
-        let odd = 2.0 * kk - 1.0;
-        term *= (mu - odd * odd) / (kk * 8.0 * x);
-    }
-    let chi = x - (n as f64 / 2.0 + 0.25) * PI;
-    let f = (2.0 / (PI * x)).sqrt();
-    let j = f * (p * chi.cos() - q * chi.sin());
-    let y = f * (p * chi.sin() + q * chi.cos());
-    if j.is_finite() && y.is_finite() { Some((j, y)) } else { None }
-}
-
-const EULER: f64 = std::f64::consts::EULER_GAMMA;
-
-/// J_0..J_m(x) for 0 < x ≤ ~100 by Miller's backward recurrence, normalised with
-/// J_0 + 2ΣJ_{2k} = 1.
-fn bessel_j_all(x: f64) -> Vec<f64> {
-    let top = x.ceil() as usize + 30 + (40.0 * x.max(1.0)).sqrt() as usize;
-    let m = top + top % 2;
-    let mut j = vec![0.0f64; m + 2];
-    if let Some(v) = j.get_mut(m) {
-        *v = 1e-30;
-    }
-    for k in (1..=m).rev() {
-        let jk = j.get(k).copied().unwrap_or(0.0);
-        let jk1 = j.get(k + 1).copied().unwrap_or(0.0);
-        let mut prev = 2.0 * k as f64 / x * jk - jk1;
-        if prev.abs() > 1e250 {
-            for v in j.iter_mut() {
-                *v *= 1e-250;
-            }
-            prev *= 1e-250;
-        }
-        if let Some(v) = j.get_mut(k - 1) {
-            *v = prev;
-        }
-    }
-    let norm: f64 = j.first().copied().unwrap_or(0.0) + 2.0 * j.iter().skip(2).step_by(2).sum::<f64>();
-    if norm != 0.0 {
-        for v in j.iter_mut() {
-            *v /= norm;
-        }
-    }
-    j
-}
-
-/// Y_0 and Y_1 by Neumann series over J_k (x ≤ 25) or the asymptotic expansion.
-fn bessel_y01(x: f64) -> Option<(f64, f64)> {
-    if x > 25.0 {
-        let (_, y0) = hankel(0, x)?;
-        let (_, y1) = hankel(1, x)?;
-        return Some((y0, y1));
-    }
-    let j = bessel_j_all(x);
-    let jj = |k: usize| j.get(k).copied().unwrap_or(0.0);
-    let l = (x / 2.0).ln() + EULER;
-    // Y0 = (2/π)(L J0) − (4/π) Σ (−1)^k J_{2k}/k
-    // Y1 = −Y0' = −(2/π)(J0/x − L J1) + (2/π) Σ (−1)^k (J_{2k−1} − J_{2k+1})/k
-    let mut s0 = 0.0;
-    let mut s1 = 0.0;
-    let mut k = 1usize;
-    while 2 * k + 1 < j.len() {
-        let sign = if k.is_multiple_of(2) { 1.0 } else { -1.0 };
-        s0 += sign * jj(2 * k) / k as f64;
-        s1 += sign * (jj(2 * k - 1) - jj(2 * k + 1)) / k as f64;
-        k += 1;
-    }
-    let y0 = (2.0 / PI) * l * jj(0) - (4.0 / PI) * s0;
-    let y1 = -(2.0 / PI) * (jj(0) / x - l * jj(1)) + (2.0 / PI) * s1;
-    if y0.is_finite() && y1.is_finite() { Some((y0, y1)) } else { None }
-}
-
-fn bessel_y(n: u32, x: f64) -> Option<f64> {
-    let (y0, y1) = bessel_y01(x)?;
-    if n == 0 {
-        return Some(y0);
-    }
-    let (mut a, mut b) = (y0, y1);
-    for k in 1..n {
-        let c = 2.0 * k as f64 / x * b - a;
-        a = b;
-        b = c;
-        if !b.is_finite() {
-            return None;
-        }
-    }
-    Some(b)
-}
-
-/// I_n(x) by its power series (all terms positive), computed with a log-scaled first term.
-fn bessel_i(n: u32, x: f64) -> Option<f64> {
-    if x == 0.0 {
-        return Some(if n == 0 { 1.0 } else { 0.0 });
-    }
-    let ax = x.abs();
-    let nf = n as f64;
-    let ln_t0 = nf * (ax / 2.0).ln() - crate::special::ln_gamma(nf + 1.0);
-    let q = ax * ax / 4.0;
-    let mut term = 1.0;
-    let mut sum = 1.0;
-    let mut k = 0.0;
-    while k < 1e6 {
-        k += 1.0;
-        term *= q / (k * (k + nf));
-        sum += term;
-        if term < 1e-17 * sum {
-            break;
-        }
-        if !sum.is_finite() {
-            return None;
-        }
-    }
-    let r = (ln_t0 + sum.ln()).exp();
-    let r = if x < 0.0 && n % 2 == 1 { -r } else { r };
-    if r.is_finite() { Some(r) } else { None }
-}
-
-/// K_n(x) for x > 0: K_0 and K_1 from ∫₀^∞ e^{−x cosh t} cosh(νt) dt (trapezoid rule), then
-/// upward recurrence.
-fn bessel_k(n: u32, x: f64) -> Option<f64> {
-    let k_int = |nu: f64| -> f64 {
-        let h: f64 = 0.02;
-        let mut sum = 0.5 * (-x).exp();
-        let mut t: f64 = h;
-        while t < 800.0 {
-            let v = (-x * t.cosh() + (nu * t).ln_cosh_safe()).exp();
-            sum += v;
-            if v < 1e-18 * sum && x * t.cosh() > 50.0 {
-                break;
-            }
-            t += h;
-        }
-        sum * h
-    };
-    let k0 = k_int(0.0);
-    if n == 0 {
-        return Some(k0);
-    }
-    let k1 = k_int(1.0);
-    let (mut a, mut b) = (k0, k1);
-    for k in 1..n {
-        let c = a + 2.0 * k as f64 / x * b;
-        a = b;
-        b = c;
-        if !b.is_finite() {
-            return None;
-        }
-    }
-    if b.is_finite() { Some(b) } else { None }
-}
-
-trait LnCosh {
-    fn ln_cosh_safe(self) -> f64;
-}
-impl LnCosh for f64 {
-    /// ln(cosh(x)) without overflow.
-    fn ln_cosh_safe(self) -> f64 {
-        let a = self.abs();
-        a + (-2.0 * a).exp().ln_1p() - std::f64::consts::LN_2
-    }
-}
-
-fn bessel_args(a: &[Arg]) -> R<(f64, u32)> {
-    let x = num(a, 0)?;
-    let n = num(a, 1)?.trunc();
-    if n < 0.0 {
-        return Err(CellError::Num);
-    }
-    if n > 100_000.0 {
-        return Err(CellError::Num);
-    }
-    Ok((x, n as u32))
-}
-
-fn besselj(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (x, n) = bessel_args(a)?;
-    num_val(bessel_j(n, x).ok_or(CellError::Num)?)
-}
-fn bessely(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (x, n) = bessel_args(a)?;
-    if x <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(bessel_y(n, x).ok_or(CellError::Num)?)
-}
-fn besseli(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (x, n) = bessel_args(a)?;
-    num_val(bessel_i(n, x).ok_or(CellError::Num)?)
-}
-fn besselk(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (x, n) = bessel_args(a)?;
-    if x <= 0.0 {
-        return Err(CellError::Num);
-    }
-    num_val(bessel_k(n, x).ok_or(CellError::Num)?)
-}
-
 pub(crate) fn specs() -> Vec<FnSpec> {
     vec![
         f!("BIN2DEC", 1, 1, Engineering, S, "BIN2DEC(number)", "Converts a binary number to decimal.", bin2dec),
diff --git a/crates/functions/src/engineering/bessel.rs b/crates/functions/src/engineering/bessel.rs
new file mode 100644
index 000000000..34be81783
--- /dev/null
+++ b/crates/functions/src/engineering/bessel.rs
@@ -0,0 +1,245 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Bessel functions
+
+const MAX_BESSEL_POINTS: f64 = 4_000_000.0;
+
+/// J_n(x) for integer n ≥ 0 via Bessel's integral, J_n(x) = (1/2π)∫₀^{2π} cos(nτ − x sin τ) dτ,
+/// evaluated with the trapezoid rule, which converges exponentially for periodic integrands.
+fn bessel_j(n: u32, x: f64) -> Option<f64> {
+    let pts = (2.0 * (x.abs() + n as f64) + 64.0).ceil();
+    if pts > MAX_BESSEL_POINTS {
+        return if x.abs() > 1e6 { hankel(n, x.abs()).map(|(j, _)| if x < 0.0 && n % 2 == 1 { -j } else { j }) } else { None };
+    }
+    let m = pts as usize;
+    let h = 2.0 * PI / m as f64;
+    let nf = n as f64;
+    let mut sum = 0.0;
+    for k in 0..m {
+        let t = k as f64 * h;
+        sum += (nf * t - x * t.sin()).cos();
+    }
+    Some(sum / m as f64)
+}
+
+/// Hankel asymptotic expansion: (J_n(x), Y_n(x)) for large x.
+fn hankel(n: u32, x: f64) -> Option<(f64, f64)> {
+    let mu = 4.0 * (n as f64) * (n as f64);
+    let mut p = 0.0;
+    let mut q = 0.0;
+    let mut term: f64 = 1.0;
+    let mut last = f64::INFINITY;
+    for k in 0..200 {
+        if term.abs() > last {
+            break;
+        }
+        let t = if k % 4 < 2 { term } else { -term };
+        if k % 2 == 0 {
+            p += t;
+        } else {
+            q += t;
+        }
+        last = term.abs();
+        if last < 1e-17 {
+            break;
+        }
+        let kk = (k + 1) as f64;
+        let odd = 2.0 * kk - 1.0;
+        term *= (mu - odd * odd) / (kk * 8.0 * x);
+    }
+    let chi = x - (n as f64 / 2.0 + 0.25) * PI;
+    let f = (2.0 / (PI * x)).sqrt();
+    let j = f * (p * chi.cos() - q * chi.sin());
+    let y = f * (p * chi.sin() + q * chi.cos());
+    if j.is_finite() && y.is_finite() { Some((j, y)) } else { None }
+}
+
+const EULER: f64 = std::f64::consts::EULER_GAMMA;
+
+/// J_0..J_m(x) for 0 < x ≤ ~100 by Miller's backward recurrence, normalised with
+/// J_0 + 2ΣJ_{2k} = 1.
+fn bessel_j_all(x: f64) -> Vec<f64> {
+    let top = x.ceil() as usize + 30 + (40.0 * x.max(1.0)).sqrt() as usize;
+    let m = top + top % 2;
+    let mut j = vec![0.0f64; m + 2];
+    if let Some(v) = j.get_mut(m) {
+        *v = 1e-30;
+    }
+    for k in (1..=m).rev() {
+        let jk = j.get(k).copied().unwrap_or(0.0);
+        let jk1 = j.get(k + 1).copied().unwrap_or(0.0);
+        let mut prev = 2.0 * k as f64 / x * jk - jk1;
+        if prev.abs() > 1e250 {
+            for v in j.iter_mut() {
+                *v *= 1e-250;
+            }
+            prev *= 1e-250;
+        }
+        if let Some(v) = j.get_mut(k - 1) {
+            *v = prev;
+        }
+    }
+    let norm: f64 = j.first().copied().unwrap_or(0.0) + 2.0 * j.iter().skip(2).step_by(2).sum::<f64>();
+    if norm != 0.0 {
+        for v in j.iter_mut() {
+            *v /= norm;
+        }
+    }
+    j
+}
+
+/// Y_0 and Y_1 by Neumann series over J_k (x ≤ 25) or the asymptotic expansion.
+fn bessel_y01(x: f64) -> Option<(f64, f64)> {
+    if x > 25.0 {
+        let (_, y0) = hankel(0, x)?;
+        let (_, y1) = hankel(1, x)?;
+        return Some((y0, y1));
+    }
+    let j = bessel_j_all(x);
+    let jj = |k: usize| j.get(k).copied().unwrap_or(0.0);
+    let l = (x / 2.0).ln() + EULER;
+    // Y0 = (2/π)(L J0) − (4/π) Σ (−1)^k J_{2k}/k
+    // Y1 = −Y0' = −(2/π)(J0/x − L J1) + (2/π) Σ (−1)^k (J_{2k−1} − J_{2k+1})/k
+    let mut s0 = 0.0;
+    let mut s1 = 0.0;
+    let mut k = 1usize;
+    while 2 * k + 1 < j.len() {
+        let sign = if k.is_multiple_of(2) { 1.0 } else { -1.0 };
+        s0 += sign * jj(2 * k) / k as f64;
+        s1 += sign * (jj(2 * k - 1) - jj(2 * k + 1)) / k as f64;
+        k += 1;
+    }
+    let y0 = (2.0 / PI) * l * jj(0) - (4.0 / PI) * s0;
+    let y1 = -(2.0 / PI) * (jj(0) / x - l * jj(1)) + (2.0 / PI) * s1;
+    if y0.is_finite() && y1.is_finite() { Some((y0, y1)) } else { None }
+}
+
+fn bessel_y(n: u32, x: f64) -> Option<f64> {
+    let (y0, y1) = bessel_y01(x)?;
+    if n == 0 {
+        return Some(y0);
+    }
+    let (mut a, mut b) = (y0, y1);
+    for k in 1..n {
+        let c = 2.0 * k as f64 / x * b - a;
+        a = b;
+        b = c;
+        if !b.is_finite() {
+            return None;
+        }
+    }
+    Some(b)
+}
+
+/// I_n(x) by its power series (all terms positive), computed with a log-scaled first term.
+fn bessel_i(n: u32, x: f64) -> Option<f64> {
+    if x == 0.0 {
+        return Some(if n == 0 { 1.0 } else { 0.0 });
+    }
+    let ax = x.abs();
+    let nf = n as f64;
+    let ln_t0 = nf * (ax / 2.0).ln() - crate::special::ln_gamma(nf + 1.0);
+    let q = ax * ax / 4.0;
+    let mut term = 1.0;
+    let mut sum = 1.0;
+    let mut k = 0.0;
+    while k < 1e6 {
+        k += 1.0;
+        term *= q / (k * (k + nf));
+        sum += term;
+        if term < 1e-17 * sum {
+            break;
+        }
+        if !sum.is_finite() {
+            return None;
+        }
+    }
+    let r = (ln_t0 + sum.ln()).exp();
+    let r = if x < 0.0 && n % 2 == 1 { -r } else { r };
+    if r.is_finite() { Some(r) } else { None }
+}
+
+/// K_n(x) for x > 0: K_0 and K_1 from ∫₀^∞ e^{−x cosh t} cosh(νt) dt (trapezoid rule), then
+/// upward recurrence.
+fn bessel_k(n: u32, x: f64) -> Option<f64> {
+    let k_int = |nu: f64| -> f64 {
+        let h: f64 = 0.02;
+        let mut sum = 0.5 * (-x).exp();
+        let mut t: f64 = h;
+        while t < 800.0 {
+            let v = (-x * t.cosh() + (nu * t).ln_cosh_safe()).exp();
+            sum += v;
+            if v < 1e-18 * sum && x * t.cosh() > 50.0 {
+                break;
+            }
+            t += h;
+        }
+        sum * h
+    };
+    let k0 = k_int(0.0);
+    if n == 0 {
+        return Some(k0);
+    }
+    let k1 = k_int(1.0);
+    let (mut a, mut b) = (k0, k1);
+    for k in 1..n {
+        let c = a + 2.0 * k as f64 / x * b;
+        a = b;
+        b = c;
+        if !b.is_finite() {
+            return None;
+        }
+    }
+    if b.is_finite() { Some(b) } else { None }
+}
+
+trait LnCosh {
+    fn ln_cosh_safe(self) -> f64;
+}
+
+impl LnCosh for f64 {
+    /// ln(cosh(x)) without overflow.
+    fn ln_cosh_safe(self) -> f64 {
+        let a = self.abs();
+        a + (-2.0 * a).exp().ln_1p() - std::f64::consts::LN_2
+    }
+}
+
+fn bessel_args(a: &[Arg]) -> R<(f64, u32)> {
+    let x = num(a, 0)?;
+    let n = num(a, 1)?.trunc();
+    if n < 0.0 {
+        return Err(CellError::Num);
+    }
+    if n > 100_000.0 {
+        return Err(CellError::Num);
+    }
+    Ok((x, n as u32))
+}
+
+pub(super) fn besselj(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (x, n) = bessel_args(a)?;
+    num_val(bessel_j(n, x).ok_or(CellError::Num)?)
+}
+
+pub(super) fn bessely(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (x, n) = bessel_args(a)?;
+    if x <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(bessel_y(n, x).ok_or(CellError::Num)?)
+}
+
+pub(super) fn besseli(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (x, n) = bessel_args(a)?;
+    num_val(bessel_i(n, x).ok_or(CellError::Num)?)
+}
+
+pub(super) fn besselk(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (x, n) = bessel_args(a)?;
+    if x <= 0.0 {
+        return Err(CellError::Num);
+    }
+    num_val(bessel_k(n, x).ok_or(CellError::Num)?)
+}
diff --git a/crates/functions/src/engineering/complex.rs b/crates/functions/src/engineering/complex.rs
new file mode 100644
index 000000000..86ab6b535
--- /dev/null
+++ b/crates/functions/src/engineering/complex.rs
@@ -0,0 +1,268 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Complex numbers
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct Cx {
+    pub(super) re: f64,
+    pub(super) im: f64,
+}
+
+impl Cx {
+    pub(super) fn new(re: f64, im: f64) -> Cx {
+        Cx { re, im }
+    }
+    fn add(self, o: Cx) -> Cx {
+        Cx::new(self.re + o.re, self.im + o.im)
+    }
+    fn sub(self, o: Cx) -> Cx {
+        Cx::new(self.re - o.re, self.im - o.im)
+    }
+    fn mul(self, o: Cx) -> Cx {
+        Cx::new(self.re * o.re - self.im * o.im, self.re * o.im + self.im * o.re)
+    }
+    pub(super) fn div(self, o: Cx) -> R<Cx> {
+        let d = o.re * o.re + o.im * o.im;
+        if d == 0.0 {
+            return Err(CellError::Num);
+        }
+        Ok(Cx::new((self.re * o.re + self.im * o.im) / d, (self.im * o.re - self.re * o.im) / d))
+    }
+    pub(super) fn abs(self) -> f64 {
+        self.re.hypot(self.im)
+    }
+    fn arg(self) -> f64 {
+        self.im.atan2(self.re)
+    }
+    pub(super) fn exp(self) -> Cx {
+        let e = self.re.exp();
+        Cx::new(e * self.im.cos(), e * self.im.sin())
+    }
+    pub(super) fn ln(self) -> R<Cx> {
+        if self.re == 0.0 && self.im == 0.0 {
+            return Err(CellError::Num);
+        }
+        Ok(Cx::new(self.abs().ln(), self.arg()))
+    }
+    pub(super) fn sin(self) -> Cx {
+        Cx::new(self.re.sin() * self.im.cosh(), self.re.cos() * self.im.sinh())
+    }
+    pub(super) fn cos(self) -> Cx {
+        Cx::new(self.re.cos() * self.im.cosh(), -self.re.sin() * self.im.sinh())
+    }
+    pub(super) fn sinh(self) -> Cx {
+        Cx::new(self.re.sinh() * self.im.cos(), self.re.cosh() * self.im.sin())
+    }
+    pub(super) fn cosh(self) -> Cx {
+        Cx::new(self.re.cosh() * self.im.cos(), self.re.sinh() * self.im.sin())
+    }
+    fn powf(self, n: f64) -> R<Cx> {
+        if self.re == 0.0 && self.im == 0.0 {
+            return if n > 0.0 { Ok(Cx::new(0.0, 0.0)) } else { Err(CellError::Num) };
+        }
+        let r = self.abs().powf(n);
+        let t = self.arg() * n;
+        Ok(Cx::new(r * t.cos(), r * t.sin()))
+    }
+}
+
+pub(super) const ONE: Cx = Cx { re: 1.0, im: 0.0 };
+
+/// Parses a real number written in a complex string (no spaces, optional exponent).
+fn parse_real(s: &str) -> Option<f64> {
+    if s.is_empty() || s.contains(char::is_whitespace) {
+        return None;
+    }
+    let ok = s.chars().all(|c| c.is_ascii_digit() || matches!(c, '.' | 'e' | 'E' | '+' | '-'));
+    if !ok {
+        return None;
+    }
+    s.parse::<f64>().ok().filter(|v| v.is_finite())
+}
+
+/// Parses "a+bi" forms. Returns the number and its suffix ('i', 'j' or none).
+pub(super) fn parse_complex(s: &str) -> R<(Cx, Option<char>)> {
+    if s.is_empty() {
+        return Ok((Cx::new(0.0, 0.0), None));
+    }
+    let suffix = match s.chars().last() {
+        Some(c @ ('i' | 'j')) => Some(c),
+        _ => None,
+    };
+    let Some(sfx) = suffix else {
+        return parse_real(s).map(|r| (Cx::new(r, 0.0), None)).ok_or(CellError::Num);
+    };
+    let body = &s[..s.len() - 1];
+    // Split at the last sign that is not at the start and not part of an exponent.
+    let bytes = body.as_bytes();
+    let mut split = None;
+    for i in (1..bytes.len()).rev() {
+        let c = bytes.get(i).copied().unwrap_or(0);
+        let prev = bytes.get(i - 1).copied().unwrap_or(0);
+        if (c == b'+' || c == b'-') && prev != b'e' && prev != b'E' {
+            split = Some(i);
+            break;
+        }
+    }
+    let (re_s, im_s) = match split {
+        Some(i) => (&body[..i], &body[i..]),
+        None => ("", body),
+    };
+    let re = if re_s.is_empty() { 0.0 } else { parse_real(re_s).ok_or(CellError::Num)? };
+    let im = match im_s {
+        "" | "+" => 1.0,
+        "-" => -1.0,
+        t => parse_real(t).ok_or(CellError::Num)?,
+    };
+    Ok((Cx::new(re, im), Some(sfx)))
+}
+
+fn cx_of(v: &Value) -> R<(Cx, Option<char>)> {
+    match v {
+        Value::Number(n) => Ok((Cx::new(*n, 0.0), None)),
+        Value::Empty => Ok((Cx::new(0.0, 0.0), None)),
+        Value::Bool(_) => Err(CellError::Value),
+        Value::Error(e) => Err(*e),
+        Value::Text(t) => parse_complex(t),
+        Value::Array(a) => cx_of(a.data.first().unwrap_or(&Value::Empty)),
+    }
+}
+
+fn cx_arg(a: &[Arg], i: usize) -> R<(Cx, Option<char>)> {
+    cx_of(&a.get(i).map(scalar).unwrap_or(Value::Empty))
+}
+
+fn merge_suffix(acc: Option<char>, s: Option<char>) -> R<Option<char>> {
+    match (acc, s) {
+        (Some(x), Some(y)) if x != y => Err(CellError::Value),
+        (Some(x), _) => Ok(Some(x)),
+        (None, y) => Ok(y),
+    }
+}
+
+fn fmt_complex(z: Cx, suffix: char) -> R<Value> {
+    if !z.re.is_finite() || !z.im.is_finite() {
+        return Err(CellError::Num);
+    }
+    let re = clean(z.re);
+    let im = clean(z.im);
+    let mut s = String::new();
+    if im == 0.0 {
+        s.push_str(&number_to_text(re));
+        return text_val(s);
+    }
+    if re != 0.0 {
+        s.push_str(&number_to_text(re));
+        if im > 0.0 {
+            s.push('+');
+        }
+    }
+    if im == -1.0 {
+        s.push('-');
+    } else if im != 1.0 {
+        s.push_str(&number_to_text(im));
+    }
+    s.push(suffix);
+    text_val(s)
+}
+
+/// Rounds to 15 significant digits so values like 0.999999999999999999 print as 1.
+fn clean(x: f64) -> f64 {
+    let s = format!("{:.14e}", x);
+    s.parse().unwrap_or(x)
+}
+
+pub(super) fn complex(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let re = num(a, 0)?;
+    let im = num(a, 1)?;
+    let sfx = if has(a, 2) { text(a, 2)? } else { "i".into() };
+    let sfx = match sfx.as_str() {
+        "i" | "" => 'i',
+        "j" => 'j',
+        _ => return Err(CellError::Value),
+    };
+    fmt_complex(Cx::new(re, im), sfx)
+}
+
+pub(super) fn im_unary(a: &[Arg], f: fn(Cx) -> R<Cx>) -> R<Value> {
+    let (z, s) = cx_arg(a, 0)?;
+    fmt_complex(f(z)?, s.unwrap_or('i'))
+}
+
+fn im_real_fn(a: &[Arg], f: fn(Cx) -> R<f64>) -> R<Value> {
+    let (z, _) = cx_arg(a, 0)?;
+    num_val(f(z)?)
+}
+
+pub(super) fn imabs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_real_fn(a, |z| Ok(z.abs()))
+}
+
+pub(super) fn imreal(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_real_fn(a, |z| Ok(z.re))
+}
+
+pub(super) fn imaginary(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_real_fn(a, |z| Ok(z.im))
+}
+
+pub(super) fn imargument(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_real_fn(a, |z| if z.re == 0.0 && z.im == 0.0 { Err(CellError::Div0) } else { Ok(z.arg()) })
+}
+
+fn im_binary(a: &[Arg], f: fn(Cx, Cx) -> R<Cx>) -> R<Value> {
+    let (x, s1) = cx_arg(a, 0)?;
+    let (y, s2) = cx_arg(a, 1)?;
+    let s = merge_suffix(s1, s2)?;
+    fmt_complex(f(x, y)?, s.unwrap_or('i'))
+}
+
+pub(super) fn imdiv(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_binary(a, Cx::div)
+}
+
+pub(super) fn imsub(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_binary(a, |x, y| Ok(x.sub(y)))
+}
+
+pub(super) fn impower(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (z, s) = cx_arg(a, 0)?;
+    let n = num(a, 1)?;
+    // Integer powers by repeated multiplication are exact for small Gaussian integers.
+    let r = if n == n.trunc() && n.abs() <= 64.0 && !(z.re == 0.0 && z.im == 0.0) {
+        let mut acc = ONE;
+        for _ in 0..(n.abs() as u32) {
+            acc = acc.mul(z);
+        }
+        if n < 0.0 { ONE.div(acc)? } else { acc }
+    } else {
+        z.powf(n)?
+    };
+    fmt_complex(r, s.unwrap_or('i'))
+}
+
+fn im_fold(a: &[Arg], init: Cx, f: fn(Cx, Cx) -> Cx) -> R<Value> {
+    let mut acc = init;
+    let mut sfx = None;
+    for arg in a {
+        let direct = !matches!(arg.value, Value::Array(_));
+        for v in flatten(std::slice::from_ref(arg)) {
+            if matches!(v, Value::Empty) && !direct {
+                continue;
+            }
+            let (z, s) = cx_of(&v)?;
+            sfx = merge_suffix(sfx, s)?;
+            acc = f(acc, z);
+        }
+    }
+    fmt_complex(acc, sfx.unwrap_or('i'))
+}
+
+pub(super) fn imsum(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_fold(a, Cx::new(0.0, 0.0), Cx::add)
+}
+
+pub(super) fn improduct(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    im_fold(a, ONE, Cx::mul)
+}
diff --git a/crates/functions/src/engineering/units.rs b/crates/functions/src/engineering/units.rs
new file mode 100644
index 000000000..e54abd87a
--- /dev/null
+++ b/crates/functions/src/engineering/units.rs
@@ -0,0 +1,286 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// CONVERT
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum Dim {
+    Mass,
+    Length,
+    Time,
+    Pressure,
+    Force,
+    Energy,
+    Power,
+    Magnetism,
+    Temperature,
+    Volume,
+    Area,
+    Information,
+    Speed,
+}
+
+/// How a unit accepts prefixes: none, SI (raised to `power` for areas/volumes) or SI + binary.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Pre {
+    No,
+    Si(i32),
+    Bin,
+}
+
+struct Unit {
+    names: &'static [&'static str],
+    dim: Dim,
+    factor: f64,
+    pre: Pre,
+}
+
+const fn u(names: &'static [&'static str], dim: Dim, factor: f64, pre: Pre) -> Unit {
+    Unit { names, dim, factor, pre }
+}
+
+const IN: f64 = 0.0254;
+
+const FT: f64 = 0.3048;
+
+const YD: f64 = 0.9144;
+
+const MI: f64 = 1609.344;
+
+const NMI: f64 = 1852.0;
+
+const LY: f64 = 9_460_730_472_580_800.0;
+
+const PICA_PT: f64 = 0.0254 / 72.0;
+
+const PICA: f64 = 0.0254 / 6.0;
+
+const GAL: f64 = 0.003_785_411_784;
+
+const UNITS: &[Unit] = &[
+    // Mass (gram)
+    u(&["g"], Dim::Mass, 1.0, Pre::Si(1)),
+    u(&["sg"], Dim::Mass, 14_593.902_937_206_4, Pre::No),
+    u(&["lbm"], Dim::Mass, 453.592_37, Pre::No),
+    u(&["u"], Dim::Mass, 1.660_539_066_6e-24, Pre::Si(1)),
+    u(&["ozm"], Dim::Mass, 28.349_523_125, Pre::No),
+    u(&["grain"], Dim::Mass, 0.064_798_91, Pre::No),
+    u(&["cwt", "shweight"], Dim::Mass, 45_359.237, Pre::No),
+    u(&["uk_cwt", "lcwt", "hweight"], Dim::Mass, 50_802.345_44, Pre::No),
+    u(&["stone"], Dim::Mass, 6_350.293_18, Pre::No),
+    u(&["ton"], Dim::Mass, 907_184.74, Pre::No),
+    u(&["uk_ton", "LTON", "brton"], Dim::Mass, 1_016_046.908_8, Pre::No),
+    // Length (metre)
+    u(&["m"], Dim::Length, 1.0, Pre::Si(1)),
+    u(&["mi"], Dim::Length, MI, Pre::No),
+    u(&["Nmi"], Dim::Length, NMI, Pre::No),
+    u(&["in"], Dim::Length, IN, Pre::No),
+    u(&["ft"], Dim::Length, FT, Pre::No),
+    u(&["yd"], Dim::Length, YD, Pre::No),
+    u(&["ang"], Dim::Length, 1e-10, Pre::Si(1)),
+    u(&["ell"], Dim::Length, 1.143, Pre::No),
+    u(&["ly"], Dim::Length, LY, Pre::Si(1)),
+    u(&["parsec", "pc"], Dim::Length, 30_856_775_814_913_673.0, Pre::Si(1)),
+    u(&["Picapt", "Pica"], Dim::Length, PICA_PT, Pre::No),
+    u(&["pica"], Dim::Length, PICA, Pre::No),
+    u(&["survey_mi"], Dim::Length, 1_609.347_218_694_437, Pre::No),
+    // Time (second)
+    u(&["yr"], Dim::Time, 31_557_600.0, Pre::No),
+    u(&["day", "d"], Dim::Time, 86_400.0, Pre::No),
+    u(&["hr"], Dim::Time, 3_600.0, Pre::No),
+    u(&["mn", "min"], Dim::Time, 60.0, Pre::No),
+    u(&["sec", "s"], Dim::Time, 1.0, Pre::Si(1)),
+    // Pressure (pascal)
+    u(&["Pa", "p"], Dim::Pressure, 1.0, Pre::Si(1)),
+    u(&["atm", "at"], Dim::Pressure, 101_325.0, Pre::Si(1)),
+    u(&["mmHg"], Dim::Pressure, 133.322_387_415, Pre::Si(1)),
+    u(&["psi"], Dim::Pressure, 6_894.757_293_168_36, Pre::No),
+    u(&["Torr"], Dim::Pressure, 101_325.0 / 760.0, Pre::No),
+    // Force (newton)
+    u(&["N"], Dim::Force, 1.0, Pre::Si(1)),
+    u(&["dyn", "dy"], Dim::Force, 1e-5, Pre::Si(1)),
+    u(&["lbf"], Dim::Force, 4.448_221_615_260_5, Pre::No),
+    u(&["pond"], Dim::Force, 0.009_806_65, Pre::Si(1)),
+    // Energy (joule)
+    u(&["J"], Dim::Energy, 1.0, Pre::Si(1)),
+    u(&["e"], Dim::Energy, 1e-7, Pre::Si(1)),
+    u(&["c"], Dim::Energy, 4.184, Pre::Si(1)),
+    u(&["cal"], Dim::Energy, 4.1868, Pre::Si(1)),
+    u(&["eV", "ev"], Dim::Energy, 1.602_176_634e-19, Pre::Si(1)),
+    u(&["HPh", "hh"], Dim::Energy, 2_684_519.537_696_17, Pre::No),
+    u(&["Wh", "wh"], Dim::Energy, 3_600.0, Pre::Si(1)),
+    u(&["flb"], Dim::Energy, 1.355_817_948_331_4, Pre::No),
+    u(&["BTU", "btu"], Dim::Energy, 1_055.055_852_62, Pre::No),
+    // Power (watt)
+    u(&["W", "w"], Dim::Power, 1.0, Pre::Si(1)),
+    u(&["HP", "h"], Dim::Power, 745.699_871_582_270_2, Pre::No),
+    u(&["PS"], Dim::Power, 735.498_75, Pre::No),
+    // Magnetism (tesla)
+    u(&["T"], Dim::Magnetism, 1.0, Pre::Si(1)),
+    u(&["ga"], Dim::Magnetism, 1e-4, Pre::Si(1)),
+    // Temperature (handled specially; factor unused)
+    u(&["C", "cel"], Dim::Temperature, 1.0, Pre::No),
+    u(&["F", "fah"], Dim::Temperature, 1.0, Pre::No),
+    u(&["K", "kel"], Dim::Temperature, 1.0, Pre::Si(1)),
+    u(&["Rank"], Dim::Temperature, 1.0, Pre::No),
+    u(&["Reau"], Dim::Temperature, 1.0, Pre::No),
+    // Volume (cubic metre)
+    u(&["l", "L", "lt"], Dim::Volume, 0.001, Pre::Si(1)),
+    u(&["tsp"], Dim::Volume, GAL / 768.0, Pre::No),
+    u(&["tspm"], Dim::Volume, 5e-6, Pre::No),
+    u(&["tbs"], Dim::Volume, GAL / 256.0, Pre::No),
+    u(&["oz"], Dim::Volume, GAL / 128.0, Pre::No),
+    u(&["cup"], Dim::Volume, GAL / 16.0, Pre::No),
+    u(&["pt", "us_pt"], Dim::Volume, GAL / 8.0, Pre::No),
+    u(&["uk_pt"], Dim::Volume, 0.000_568_261_25, Pre::No),
+    u(&["qt"], Dim::Volume, GAL / 4.0, Pre::No),
+    u(&["uk_qt"], Dim::Volume, 0.001_136_522_5, Pre::No),
+    u(&["gal"], Dim::Volume, GAL, Pre::No),
+    u(&["uk_gal"], Dim::Volume, 0.004_546_09, Pre::No),
+    u(&["m3"], Dim::Volume, 1.0, Pre::Si(3)),
+    u(&["mi3"], Dim::Volume, MI * MI * MI, Pre::No),
+    u(&["Nmi3"], Dim::Volume, NMI * NMI * NMI, Pre::No),
+    u(&["yd3"], Dim::Volume, YD * YD * YD, Pre::No),
+    u(&["ft3"], Dim::Volume, FT * FT * FT, Pre::No),
+    u(&["in3"], Dim::Volume, IN * IN * IN, Pre::No),
+    u(&["ang3"], Dim::Volume, 1e-30, Pre::Si(3)),
+    u(&["ly3"], Dim::Volume, LY * LY * LY, Pre::No),
+    u(&["Picapt3", "Pica3"], Dim::Volume, PICA_PT * PICA_PT * PICA_PT, Pre::No),
+    u(&["barrel"], Dim::Volume, 0.158_987_294_928, Pre::No),
+    u(&["bushel"], Dim::Volume, 0.035_239_070_166_88, Pre::No),
+    u(&["MTON"], Dim::Volume, 1.132_673_863_68, Pre::No),
+    u(&["GRT", "regton"], Dim::Volume, 2.831_684_659_2, Pre::No),
+    // Area (square metre)
+    u(&["m2"], Dim::Area, 1.0, Pre::Si(2)),
+    u(&["ha"], Dim::Area, 10_000.0, Pre::No),
+    u(&["ar"], Dim::Area, 100.0, Pre::Si(1)),
+    u(&["ft2"], Dim::Area, FT * FT, Pre::No),
+    u(&["in2"], Dim::Area, IN * IN, Pre::No),
+    u(&["yd2"], Dim::Area, YD * YD, Pre::No),
+    u(&["mi2"], Dim::Area, MI * MI, Pre::No),
+    u(&["Nmi2"], Dim::Area, NMI * NMI, Pre::No),
+    u(&["ang2"], Dim::Area, 1e-20, Pre::Si(2)),
+    u(&["ly2"], Dim::Area, LY * LY, Pre::No),
+    u(&["Picapt2", "Pica2"], Dim::Area, PICA_PT * PICA_PT, Pre::No),
+    u(&["uk_acre"], Dim::Area, 4_046.856_422_4, Pre::No),
+    u(&["us_acre"], Dim::Area, 4_046.872_609_874_252, Pre::No),
+    u(&["Morgen"], Dim::Area, 2_500.0, Pre::No),
+    // Information (bit)
+    u(&["bit"], Dim::Information, 1.0, Pre::Bin),
+    u(&["byte"], Dim::Information, 8.0, Pre::Bin),
+    // Speed (metres per second)
+    u(&["m/s", "m/sec"], Dim::Speed, 1.0, Pre::Si(1)),
+    u(&["m/h", "m/hr"], Dim::Speed, 1.0 / 3600.0, Pre::Si(1)),
+    u(&["mph"], Dim::Speed, MI / 3600.0, Pre::No),
+    u(&["kn"], Dim::Speed, NMI / 3600.0, Pre::No),
+    u(&["admkn"], Dim::Speed, 6080.0 * FT / 3600.0, Pre::No),
+];
+
+const SI_PREFIXES: &[(&str, f64)] = &[
+    ("da", 1e1),
+    ("Y", 1e24),
+    ("Z", 1e21),
+    ("E", 1e18),
+    ("P", 1e15),
+    ("T", 1e12),
+    ("G", 1e9),
+    ("M", 1e6),
+    ("k", 1e3),
+    ("h", 1e2),
+    ("e", 1e1),
+    ("d", 1e-1),
+    ("c", 1e-2),
+    ("m", 1e-3),
+    ("u", 1e-6),
+    ("n", 1e-9),
+    ("p", 1e-12),
+    ("f", 1e-15),
+    ("a", 1e-18),
+    ("z", 1e-21),
+    ("y", 1e-24),
+];
+
+const BIN_PREFIXES: &[(&str, f64)] = &[
+    ("ki", 1024.0),
+    ("Mi", 1_048_576.0),
+    ("Gi", 1_073_741_824.0),
+    ("Ti", 1_099_511_627_776.0),
+    ("Pi", 1_125_899_906_842_624.0),
+    ("Ei", 1_152_921_504_606_846_976.0),
+    ("Zi", 1_180_591_620_717_411_303_424.0),
+    ("Yi", 1_208_925_819_614_629_174_706_176.0),
+];
+
+fn find_unit(name: &str) -> Option<&'static Unit> {
+    UNITS.iter().find(|u| u.names.contains(&name))
+}
+
+/// Resolves a unit name to (unit, prefix multiplier). Exact names win over prefixed ones.
+fn resolve(name: &str) -> Option<(&'static Unit, f64)> {
+    let name = name.replace("^2", "2").replace("^3", "3");
+    if let Some(u) = find_unit(&name) {
+        return Some((u, 1.0));
+    }
+    for (p, f) in BIN_PREFIXES {
+        if let Some(rest) = name.strip_prefix(p)
+            && let Some(u) = find_unit(rest)
+            && u.pre == Pre::Bin
+        {
+            return Some((u, *f));
+        }
+    }
+    for (p, f) in SI_PREFIXES {
+        if let Some(rest) = name.strip_prefix(p)
+            && let Some(u) = find_unit(rest)
+        {
+            match u.pre {
+                Pre::Si(pow) => return Some((u, f.powi(pow))),
+                Pre::Bin => return Some((u, *f)),
+                Pre::No => {}
+            }
+        }
+    }
+    None
+}
+
+fn to_kelvin(name: &str, x: f64) -> f64 {
+    match name {
+        "C" | "cel" => x + 273.15,
+        "F" | "fah" => (x - 32.0) * 5.0 / 9.0 + 273.15,
+        "Rank" => x * 5.0 / 9.0,
+        "Reau" => x * 1.25 + 273.15,
+        _ => x,
+    }
+}
+
+fn from_kelvin(name: &str, k: f64) -> f64 {
+    match name {
+        "C" | "cel" => k - 273.15,
+        "F" | "fah" => (k - 273.15) * 9.0 / 5.0 + 32.0,
+        "Rank" => k * 9.0 / 5.0,
+        "Reau" => (k - 273.15) / 1.25,
+        _ => k,
+    }
+}
+
+pub(super) fn convert(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let x = num(a, 0)?;
+    let from = text(a, 1)?;
+    let to = text(a, 2)?;
+    let (fu, fp) = resolve(&from).ok_or(CellError::NA)?;
+    let (tu, tp) = resolve(&to).ok_or(CellError::NA)?;
+    if fu.dim != tu.dim {
+        return Err(CellError::NA);
+    }
+    if fu.dim == Dim::Temperature {
+        let fname = fu.names.first().copied().unwrap_or("K");
+        let tname = tu.names.first().copied().unwrap_or("K");
+        if fname == tname && fp == tp {
+            return num_val(x);
+        }
+        let k = to_kelvin(fname, x * fp);
+        return num_val(from_kelvin(tname, k) / tp);
+    }
+    let base = x * fu.factor * fp;
+    num_val(base / (tu.factor * tp))
+}

From 1db55e4e5fb41dbd1a18b30233d7098d374248cd Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:02:35 +0000
Subject: [PATCH 61/76] refactor(functions): move math.rs items to math/

---
 crates/functions/src/math.rs            | 431 +-----------------------
 crates/functions/src/math/criteria.rs   | 128 +++++++
 crates/functions/src/math/matrix.rs     | 182 ++++++++++
 crates/functions/src/math/roman_base.rs | 121 +++++++
 4 files changed, 439 insertions(+), 423 deletions(-)
 create mode 100644 crates/functions/src/math/criteria.rs
 create mode 100644 crates/functions/src/math/matrix.rs
 create mode 100644 crates/functions/src/math/roman_base.rs

diff --git a/crates/functions/src/math.rs b/crates/functions/src/math.rs
index 964af2e5e..6d4cdcf58 100644
--- a/crates/functions/src/math.rs
+++ b/crates/functions/src/math.rs
@@ -11,6 +11,14 @@ use crate::util::{
 };
 use crate::{Arg, Ctx, FnSpec, VAR};
 
+mod criteria;
+mod matrix;
+mod roman_base;
+
+use criteria::{averageif, averageifs, countif, countifs, maxifs, minifs, sumif, sumifs};
+use matrix::{mdeterm, minverse, mmult, munit};
+use roman_base::{arabic, base, decimal, roman};
+
 // ---------------------------------------------------------------------------------------------
 // Lifting tables
 
@@ -635,307 +643,6 @@ fn radians(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     unary(a, |x| Ok(x * PI / 180.0))
 }
 
-// ---------------------------------------------------------------------------------------------
-// Number systems
-
-const NUMERALS: [(char, u32); 7] = [('I', 1), ('V', 5), ('X', 10), ('L', 50), ('C', 100), ('D', 500), ('M', 1000)];
-
-/// Tokens (text, value) for a ROMAN form, largest value first. Form 0 is classic; each higher
-/// form widens one of two limits on the subtracted numeral's ratio to the larger one, alternating:
-/// the limit for I/X/C (10, 10, 100, 100, 1000) and for V/L (none, 20, 20, 200, 200). So form 2
-/// allows IC and XM but not VD, and form 3 adds VD and VM but not ID.
-fn roman_tokens(form: u32) -> Vec<(String, u32)> {
-    let (pow10_max, five_max) = [(10, 0), (10, 20), (100, 20), (100, 200), (1000, 200)].get(form as usize).copied().unwrap_or((10, 0));
-    let mut toks: Vec<(String, u32)> = NUMERALS.iter().map(|(c, v)| (c.to_string(), *v)).collect();
-    for (i, (sc, sv)) in NUMERALS.iter().enumerate() {
-        for (lc, lv) in NUMERALS.iter().skip(i + 1) {
-            let ratio = lv / sv;
-            let pow10 = matches!(sc, 'I' | 'X' | 'C');
-            let ok = ratio <= if pow10 { pow10_max } else { five_max };
-            let value = lv - sv;
-            // Skip pairs that equal a single numeral (VX = V) – they are never shorter.
-            if ok && !NUMERALS.iter().any(|(_, v)| *v == value) {
-                toks.push((format!("{sc}{lc}"), value));
-            }
-        }
-    }
-    // Largest value first; on ties prefer the shorter / classic token.
-    toks.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.len().cmp(&b.0.len())));
-    toks
-}
-
-fn roman(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let n = num(a, 0)?.trunc();
-    let form = match a.get(1).map(|x| x.value.scalar()) {
-        None => 0.0,
-        Some(Value::Bool(true)) => 0.0,
-        Some(Value::Bool(false)) => 4.0,
-        Some(_) => num(a, 1)?.trunc(),
-    };
-    if !(0.0..=3999.0).contains(&n) || !(0.0..=4.0).contains(&form) {
-        return Err(CellError::Value);
-    }
-    let toks = roman_tokens(form as u32);
-    let mut rem = n as u32;
-    let mut out = String::new();
-    while rem > 0 {
-        let Some((t, v)) = toks.iter().find(|(_, v)| *v <= rem) else { break };
-        out.push_str(t);
-        rem -= v;
-    }
-    text_val(out)
-}
-
-fn arabic(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let s = text(a, 0)?;
-    let s = s.trim();
-    if s.chars().count() > 255 {
-        return Err(CellError::Value);
-    }
-    let (neg, body) = match s.strip_prefix('-') {
-        Some(r) => (true, r),
-        None => (false, s),
-    };
-    let mut vals = Vec::new();
-    for ch in body.chars() {
-        let u = ch.to_ascii_uppercase();
-        let Some((_, v)) = NUMERALS.iter().find(|(c, _)| *c == u) else { return Err(CellError::Value) };
-        vals.push(*v as i64);
-    }
-    let mut total = 0i64;
-    for (i, v) in vals.iter().enumerate() {
-        if vals.get(i + 1).is_some_and(|next| next > v) {
-            total -= v;
-        } else {
-            total += v;
-        }
-    }
-    num_val(if neg { -total as f64 } else { total as f64 })
-}
-
-fn base(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let n = num(a, 0)?.trunc();
-    let radix = num(a, 1)?.trunc();
-    let min_len = opt_num(a, 2, 0.0)?.trunc();
-    if !(0.0..9.007_199_254_740_992e15).contains(&n) || !(2.0..=36.0).contains(&radix) || !(0.0..=255.0).contains(&min_len) {
-        return Err(CellError::Num);
-    }
-    let radix = radix as u64;
-    let mut v = n as u64;
-    let mut digits = Vec::new();
-    loop {
-        let d = (v % radix) as u32;
-        digits.push(char::from_digit(d, radix as u32).unwrap_or('0').to_ascii_uppercase());
-        v /= radix;
-        if v == 0 {
-            break;
-        }
-    }
-    while digits.len() < min_len as usize {
-        digits.push('0');
-    }
-    text_val(digits.iter().rev().collect::<String>())
-}
-
-fn decimal(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let s = text(a, 0)?;
-    let radix = num(a, 1)?.trunc();
-    if !(2.0..=36.0).contains(&radix) || s.chars().count() > 255 {
-        return Err(CellError::Num);
-    }
-    let radix = radix as u32;
-    let mut total = 0f64;
-    for ch in s.trim().chars() {
-        let Some(d) = ch.to_digit(radix) else { return Err(CellError::Num) };
-        total = total * radix as f64 + d as f64;
-    }
-    if total >= 9.007_199_254_740_992e15 {
-        return Err(CellError::Num);
-    }
-    num_val(total)
-}
-
-// ---------------------------------------------------------------------------------------------
-// Matrices
-
-/// A numeric matrix (every element must be a number, else `#VALUE!`).
-fn matrix(v: &Value) -> R<(usize, usize, Vec<f64>)> {
-    let arr = as_array(v);
-    let mut out = Vec::with_capacity(arr.data.len());
-    for x in arr.iter() {
-        match x {
-            Value::Number(n) => out.push(*n),
-            Value::Error(e) => return Err(*e),
-            _ => return Err(CellError::Value),
-        }
-    }
-    Ok((arr.rows, arr.cols, out))
-}
-
-fn to_value_array(rows: usize, cols: usize, data: Vec<f64>) -> R<Value> {
-    let vals = data.into_iter().map(|x| if x.is_finite() { Value::Number(x) } else { Value::Error(CellError::Num) }).collect();
-    array_val(rows, cols, vals)
-}
-
-fn mmult(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (ar, ac, ad) = matrix(&crate::util::arg(a, 0)?.value)?;
-    let (br, bc, bd) = matrix(&crate::util::arg(a, 1)?.value)?;
-    if ac != br {
-        return Err(CellError::Value);
-    }
-    if ar.saturating_mul(bc) > MAX_CELLS || ar.saturating_mul(bc).saturating_mul(ac) > 2_000_000_000 {
-        return Err(CellError::Num);
-    }
-    let mut out = vec![0.0; ar * bc];
-    for i in 0..ar {
-        for k in 0..ac {
-            let x = ad.get(i * ac + k).copied().unwrap_or(0.0);
-            if x == 0.0 {
-                continue;
-            }
-            for j in 0..bc {
-                if let (Some(o), Some(y)) = (out.get_mut(i * bc + j), bd.get(k * bc + j)) {
-                    *o += x * y;
-                }
-            }
-        }
-    }
-    to_value_array(ar, bc, out)
-}
-
-/// LU decomposition with partial pivoting; returns (lu, perm, sign) or None when singular.
-fn square(a: &[Arg]) -> R<(usize, Vec<f64>)> {
-    let (r, c, d) = matrix(&crate::util::arg(a, 0)?.value)?;
-    if r != c {
-        return Err(CellError::Value);
-    }
-    if r > 2000 {
-        return Err(CellError::Num);
-    }
-    Ok((r, d))
-}
-
-fn determinant(n: usize, mut m: Vec<f64>) -> f64 {
-    let mut det = 1.0;
-    for col in 0..n {
-        let mut piv = col;
-        let mut best = 0.0;
-        for row in col..n {
-            let v = m.get(row * n + col).copied().unwrap_or(0.0).abs();
-            if v > best {
-                best = v;
-                piv = row;
-            }
-        }
-        if best == 0.0 {
-            return 0.0;
-        }
-        if piv != col {
-            for k in 0..n {
-                m.swap(piv * n + k, col * n + k);
-            }
-            det = -det;
-        }
-        let p = m.get(col * n + col).copied().unwrap_or(0.0);
-        det *= p;
-        for row in col + 1..n {
-            let f = m.get(row * n + col).copied().unwrap_or(0.0) / p;
-            if f == 0.0 {
-                continue;
-            }
-            for k in col..n {
-                let v = m.get(col * n + k).copied().unwrap_or(0.0);
-                if let Some(x) = m.get_mut(row * n + k) {
-                    *x -= f * v;
-                }
-            }
-        }
-    }
-    det
-}
-
-fn mdeterm(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (n, m) = square(a)?;
-    let d = determinant(n, m);
-    // Tidy results that should be integers (e.g. 0.9999999999999998 → 1).
-    num_val(if d.abs() > 1e-300 { to_sig_digits(d, 15) } else { d })
-}
-
-fn minverse(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let (n, mut m) = square(a)?;
-    let mut inv = vec![0.0; n * n];
-    for i in 0..n {
-        if let Some(x) = inv.get_mut(i * n + i) {
-            *x = 1.0;
-        }
-    }
-    let scale = m.iter().fold(0.0f64, |acc, x| acc.max(x.abs())).max(1e-300);
-    for col in 0..n {
-        let mut piv = col;
-        let mut best = 0.0;
-        for row in col..n {
-            let v = m.get(row * n + col).copied().unwrap_or(0.0).abs();
-            if v > best {
-                best = v;
-                piv = row;
-            }
-        }
-        if best <= scale * 1e-15 {
-            return Err(CellError::Num);
-        }
-        if piv != col {
-            for k in 0..n {
-                m.swap(piv * n + k, col * n + k);
-                inv.swap(piv * n + k, col * n + k);
-            }
-        }
-        let p = m.get(col * n + col).copied().unwrap_or(1.0);
-        for k in 0..n {
-            if let Some(x) = m.get_mut(col * n + k) {
-                *x /= p;
-            }
-            if let Some(x) = inv.get_mut(col * n + k) {
-                *x /= p;
-            }
-        }
-        for row in 0..n {
-            if row == col {
-                continue;
-            }
-            let f = m.get(row * n + col).copied().unwrap_or(0.0);
-            if f == 0.0 {
-                continue;
-            }
-            for k in 0..n {
-                let mv = m.get(col * n + k).copied().unwrap_or(0.0);
-                let iv = inv.get(col * n + k).copied().unwrap_or(0.0);
-                if let Some(x) = m.get_mut(row * n + k) {
-                    *x -= f * mv;
-                }
-                if let Some(x) = inv.get_mut(row * n + k) {
-                    *x -= f * iv;
-                }
-            }
-        }
-    }
-    // Rounding noise in the inverse scales with 1/scale of the input matrix.
-    let noise = 1e-15 / scale;
-    let inv = inv.into_iter().map(|x| if x.abs() < noise { 0.0 } else { x }).collect();
-    to_value_array(n, n, inv)
-}
-
-fn munit(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let n = num(a, 0)?.trunc();
-    let (r, _) = check_size(n, n)?;
-    let mut data = vec![Value::Number(0.0); r * r];
-    for i in 0..r {
-        if let Some(x) = data.get_mut(i * r + i) {
-            *x = Value::Number(1.0);
-        }
-    }
-    array_val(r, r, data)
-}
-
 fn seriessum(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     let (x, n, m) = (num(a, 0)?, num(a, 1)?, num(a, 2)?);
     let coeffs = as_array(&crate::util::arg(a, 3)?.value);
@@ -951,128 +658,6 @@ fn seriessum(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     num_val(total)
 }
 
-// ---------------------------------------------------------------------------------------------
-// Criteria aggregates
-
-/// Values at the matched positions of `target` for every (range, criteria) pair.
-fn criteria_mask(a: &[Arg], first_pair: usize, rows: usize, cols: usize) -> R<Vec<bool>> {
-    let rest = a.get(first_pair..).unwrap_or(&[]);
-    if rest.is_empty() || rest.len() % 2 != 0 {
-        return Err(CellError::Value);
-    }
-    // A text criterion over 255 characters is `#VALUE!` only when there is a single criteria
-    // pair. With two or more pairs Excel matches its first 255 characters instead.
-    let single_pair = rest.len() == 2;
-    let mut mask = vec![true; rows.saturating_mul(cols)];
-    for pair in rest.chunks(2) {
-        let (Some(range), Some(crit)) = (pair.first(), pair.get(1)) else { return Err(CellError::Value) };
-        let r = as_array(&range.value);
-        if r.rows != rows || r.cols != cols {
-            return Err(CellError::Value);
-        }
-        let scalar = crit.value.scalar();
-        let c = if single_pair { Criterion::parse_arg(&scalar)? } else { Criterion::parse_arg_truncated(&scalar) };
-        for (m, v) in mask.iter_mut().zip(r.iter()) {
-            if *m && !c.matches(v) {
-                *m = false;
-            }
-        }
-    }
-    Ok(mask)
-}
-
-/// Numbers in `target` where `mask` is set (errors at matched positions propagate).
-fn masked_numbers(target: &Array, mask: &[bool]) -> R<Vec<f64>> {
-    let mut out = Vec::new();
-    for (v, m) in target.iter().zip(mask.iter()) {
-        if !*m {
-            continue;
-        }
-        match v {
-            Value::Number(n) => out.push(*n),
-            Value::Error(e) => return Err(*e),
-            _ => {}
-        }
-    }
-    Ok(out)
-}
-
-fn countifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let first = as_array(&crate::util::arg(a, 0)?.value);
-    let mask = criteria_mask(a, 0, first.rows, first.cols)?;
-    num_val(mask.iter().filter(|m| **m).count() as f64)
-}
-
-/// The values of the `*IFS` target range with the mask from its pairs.
-fn ifs_numbers(a: &[Arg]) -> R<Vec<f64>> {
-    let target = as_array(&crate::util::arg(a, 0)?.value);
-    let mask = criteria_mask(a, 1, target.rows, target.cols)?;
-    masked_numbers(&target, &mask)
-}
-
-fn sumifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    num_val(ifs_numbers(a)?.iter().sum())
-}
-fn averageifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let v = ifs_numbers(a)?;
-    if v.is_empty() {
-        return Err(CellError::Div0);
-    }
-    num_val(v.iter().sum::<f64>() / v.len() as f64)
-}
-fn maxifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let v = ifs_numbers(a)?;
-    num_val(v.iter().copied().reduce(f64::max).unwrap_or(0.0))
-}
-fn minifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let v = ifs_numbers(a)?;
-    num_val(v.iter().copied().reduce(f64::min).unwrap_or(0.0))
-}
-
-fn countif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let range = as_array(&crate::util::arg(a, 0)?.value);
-    let c = Criterion::parse_arg(&crate::util::arg(a, 1)?.value.scalar())?;
-    num_val(range.iter().filter(|v| c.matches(v)).count() as f64)
-}
-
-/// SUMIF / AVERAGEIF: matched numbers from the sum range, read at the criteria range's positions.
-/// Excel sizes a sum range reference like the criteria range, anchored at its own top-left cell;
-/// the evaluator does that resizing (it has the references), so cells line up one to one here.
-fn if_numbers(a: &[Arg]) -> R<Vec<f64>> {
-    let range = as_array(&crate::util::arg(a, 0)?.value);
-    let c = Criterion::parse_arg(&crate::util::arg(a, 1)?.value.scalar())?;
-    let sum_range = if has(a, 2) { Some(as_array(&crate::util::arg(a, 2)?.value)) } else { None };
-    let mut out = Vec::new();
-    for r in 0..range.rows {
-        for col in 0..range.cols {
-            let Some(v) = range.get(r, col) else { continue };
-            if !c.matches(v) {
-                continue;
-            }
-            let target = match &sum_range {
-                Some(s) => s.get(r, col),
-                None => Some(v),
-            };
-            match target {
-                Some(Value::Number(n)) => out.push(*n),
-                Some(Value::Error(e)) => return Err(*e),
-                _ => {}
-            }
-        }
-    }
-    Ok(out)
-}
-fn sumif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    num_val(if_numbers(a)?.iter().sum())
-}
-fn averageif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let v = if_numbers(a)?;
-    if v.is_empty() {
-        return Err(CellError::Div0);
-    }
-    num_val(v.iter().sum::<f64>() / v.len() as f64)
-}
-
 // ---------------------------------------------------------------------------------------------
 // Registry
 
diff --git a/crates/functions/src/math/criteria.rs b/crates/functions/src/math/criteria.rs
new file mode 100644
index 000000000..fd77aed34
--- /dev/null
+++ b/crates/functions/src/math/criteria.rs
@@ -0,0 +1,128 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Criteria aggregates
+
+/// Values at the matched positions of `target` for every (range, criteria) pair.
+fn criteria_mask(a: &[Arg], first_pair: usize, rows: usize, cols: usize) -> R<Vec<bool>> {
+    let rest = a.get(first_pair..).unwrap_or(&[]);
+    if rest.is_empty() || rest.len() % 2 != 0 {
+        return Err(CellError::Value);
+    }
+    // A text criterion over 255 characters is `#VALUE!` only when there is a single criteria
+    // pair. With two or more pairs Excel matches its first 255 characters instead.
+    let single_pair = rest.len() == 2;
+    let mut mask = vec![true; rows.saturating_mul(cols)];
+    for pair in rest.chunks(2) {
+        let (Some(range), Some(crit)) = (pair.first(), pair.get(1)) else { return Err(CellError::Value) };
+        let r = as_array(&range.value);
+        if r.rows != rows || r.cols != cols {
+            return Err(CellError::Value);
+        }
+        let scalar = crit.value.scalar();
+        let c = if single_pair { Criterion::parse_arg(&scalar)? } else { Criterion::parse_arg_truncated(&scalar) };
+        for (m, v) in mask.iter_mut().zip(r.iter()) {
+            if *m && !c.matches(v) {
+                *m = false;
+            }
+        }
+    }
+    Ok(mask)
+}
+
+/// Numbers in `target` where `mask` is set (errors at matched positions propagate).
+fn masked_numbers(target: &Array, mask: &[bool]) -> R<Vec<f64>> {
+    let mut out = Vec::new();
+    for (v, m) in target.iter().zip(mask.iter()) {
+        if !*m {
+            continue;
+        }
+        match v {
+            Value::Number(n) => out.push(*n),
+            Value::Error(e) => return Err(*e),
+            _ => {}
+        }
+    }
+    Ok(out)
+}
+
+pub(super) fn countifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let first = as_array(&crate::util::arg(a, 0)?.value);
+    let mask = criteria_mask(a, 0, first.rows, first.cols)?;
+    num_val(mask.iter().filter(|m| **m).count() as f64)
+}
+
+/// The values of the `*IFS` target range with the mask from its pairs.
+fn ifs_numbers(a: &[Arg]) -> R<Vec<f64>> {
+    let target = as_array(&crate::util::arg(a, 0)?.value);
+    let mask = criteria_mask(a, 1, target.rows, target.cols)?;
+    masked_numbers(&target, &mask)
+}
+
+pub(super) fn sumifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    num_val(ifs_numbers(a)?.iter().sum())
+}
+
+pub(super) fn averageifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let v = ifs_numbers(a)?;
+    if v.is_empty() {
+        return Err(CellError::Div0);
+    }
+    num_val(v.iter().sum::<f64>() / v.len() as f64)
+}
+
+pub(super) fn maxifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let v = ifs_numbers(a)?;
+    num_val(v.iter().copied().reduce(f64::max).unwrap_or(0.0))
+}
+
+pub(super) fn minifs(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let v = ifs_numbers(a)?;
+    num_val(v.iter().copied().reduce(f64::min).unwrap_or(0.0))
+}
+
+pub(super) fn countif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let range = as_array(&crate::util::arg(a, 0)?.value);
+    let c = Criterion::parse_arg(&crate::util::arg(a, 1)?.value.scalar())?;
+    num_val(range.iter().filter(|v| c.matches(v)).count() as f64)
+}
+
+/// SUMIF / AVERAGEIF: matched numbers from the sum range, read at the criteria range's positions.
+/// Excel sizes a sum range reference like the criteria range, anchored at its own top-left cell;
+/// the evaluator does that resizing (it has the references), so cells line up one to one here.
+fn if_numbers(a: &[Arg]) -> R<Vec<f64>> {
+    let range = as_array(&crate::util::arg(a, 0)?.value);
+    let c = Criterion::parse_arg(&crate::util::arg(a, 1)?.value.scalar())?;
+    let sum_range = if has(a, 2) { Some(as_array(&crate::util::arg(a, 2)?.value)) } else { None };
+    let mut out = Vec::new();
+    for r in 0..range.rows {
+        for col in 0..range.cols {
+            let Some(v) = range.get(r, col) else { continue };
+            if !c.matches(v) {
+                continue;
+            }
+            let target = match &sum_range {
+                Some(s) => s.get(r, col),
+                None => Some(v),
+            };
+            match target {
+                Some(Value::Number(n)) => out.push(*n),
+                Some(Value::Error(e)) => return Err(*e),
+                _ => {}
+            }
+        }
+    }
+    Ok(out)
+}
+
+pub(super) fn sumif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    num_val(if_numbers(a)?.iter().sum())
+}
+
+pub(super) fn averageif(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let v = if_numbers(a)?;
+    if v.is_empty() {
+        return Err(CellError::Div0);
+    }
+    num_val(v.iter().sum::<f64>() / v.len() as f64)
+}
diff --git a/crates/functions/src/math/matrix.rs b/crates/functions/src/math/matrix.rs
new file mode 100644
index 000000000..9bfb75c53
--- /dev/null
+++ b/crates/functions/src/math/matrix.rs
@@ -0,0 +1,182 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Matrices
+
+/// A numeric matrix (every element must be a number, else `#VALUE!`).
+fn matrix(v: &Value) -> R<(usize, usize, Vec<f64>)> {
+    let arr = as_array(v);
+    let mut out = Vec::with_capacity(arr.data.len());
+    for x in arr.iter() {
+        match x {
+            Value::Number(n) => out.push(*n),
+            Value::Error(e) => return Err(*e),
+            _ => return Err(CellError::Value),
+        }
+    }
+    Ok((arr.rows, arr.cols, out))
+}
+
+fn to_value_array(rows: usize, cols: usize, data: Vec<f64>) -> R<Value> {
+    let vals = data.into_iter().map(|x| if x.is_finite() { Value::Number(x) } else { Value::Error(CellError::Num) }).collect();
+    array_val(rows, cols, vals)
+}
+
+pub(super) fn mmult(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (ar, ac, ad) = matrix(&crate::util::arg(a, 0)?.value)?;
+    let (br, bc, bd) = matrix(&crate::util::arg(a, 1)?.value)?;
+    if ac != br {
+        return Err(CellError::Value);
+    }
+    if ar.saturating_mul(bc) > MAX_CELLS || ar.saturating_mul(bc).saturating_mul(ac) > 2_000_000_000 {
+        return Err(CellError::Num);
+    }
+    let mut out = vec![0.0; ar * bc];
+    for i in 0..ar {
+        for k in 0..ac {
+            let x = ad.get(i * ac + k).copied().unwrap_or(0.0);
+            if x == 0.0 {
+                continue;
+            }
+            for j in 0..bc {
+                if let (Some(o), Some(y)) = (out.get_mut(i * bc + j), bd.get(k * bc + j)) {
+                    *o += x * y;
+                }
+            }
+        }
+    }
+    to_value_array(ar, bc, out)
+}
+
+/// LU decomposition with partial pivoting; returns (lu, perm, sign) or None when singular.
+fn square(a: &[Arg]) -> R<(usize, Vec<f64>)> {
+    let (r, c, d) = matrix(&crate::util::arg(a, 0)?.value)?;
+    if r != c {
+        return Err(CellError::Value);
+    }
+    if r > 2000 {
+        return Err(CellError::Num);
+    }
+    Ok((r, d))
+}
+
+fn determinant(n: usize, mut m: Vec<f64>) -> f64 {
+    let mut det = 1.0;
+    for col in 0..n {
+        let mut piv = col;
+        let mut best = 0.0;
+        for row in col..n {
+            let v = m.get(row * n + col).copied().unwrap_or(0.0).abs();
+            if v > best {
+                best = v;
+                piv = row;
+            }
+        }
+        if best == 0.0 {
+            return 0.0;
+        }
+        if piv != col {
+            for k in 0..n {
+                m.swap(piv * n + k, col * n + k);
+            }
+            det = -det;
+        }
+        let p = m.get(col * n + col).copied().unwrap_or(0.0);
+        det *= p;
+        for row in col + 1..n {
+            let f = m.get(row * n + col).copied().unwrap_or(0.0) / p;
+            if f == 0.0 {
+                continue;
+            }
+            for k in col..n {
+                let v = m.get(col * n + k).copied().unwrap_or(0.0);
+                if let Some(x) = m.get_mut(row * n + k) {
+                    *x -= f * v;
+                }
+            }
+        }
+    }
+    det
+}
+
+pub(super) fn mdeterm(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (n, m) = square(a)?;
+    let d = determinant(n, m);
+    // Tidy results that should be integers (e.g. 0.9999999999999998 → 1).
+    num_val(if d.abs() > 1e-300 { to_sig_digits(d, 15) } else { d })
+}
+
+pub(super) fn minverse(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let (n, mut m) = square(a)?;
+    let mut inv = vec![0.0; n * n];
+    for i in 0..n {
+        if let Some(x) = inv.get_mut(i * n + i) {
+            *x = 1.0;
+        }
+    }
+    let scale = m.iter().fold(0.0f64, |acc, x| acc.max(x.abs())).max(1e-300);
+    for col in 0..n {
+        let mut piv = col;
+        let mut best = 0.0;
+        for row in col..n {
+            let v = m.get(row * n + col).copied().unwrap_or(0.0).abs();
+            if v > best {
+                best = v;
+                piv = row;
+            }
+        }
+        if best <= scale * 1e-15 {
+            return Err(CellError::Num);
+        }
+        if piv != col {
+            for k in 0..n {
+                m.swap(piv * n + k, col * n + k);
+                inv.swap(piv * n + k, col * n + k);
+            }
+        }
+        let p = m.get(col * n + col).copied().unwrap_or(1.0);
+        for k in 0..n {
+            if let Some(x) = m.get_mut(col * n + k) {
+                *x /= p;
+            }
+            if let Some(x) = inv.get_mut(col * n + k) {
+                *x /= p;
+            }
+        }
+        for row in 0..n {
+            if row == col {
+                continue;
+            }
+            let f = m.get(row * n + col).copied().unwrap_or(0.0);
+            if f == 0.0 {
+                continue;
+            }
+            for k in 0..n {
+                let mv = m.get(col * n + k).copied().unwrap_or(0.0);
+                let iv = inv.get(col * n + k).copied().unwrap_or(0.0);
+                if let Some(x) = m.get_mut(row * n + k) {
+                    *x -= f * mv;
+                }
+                if let Some(x) = inv.get_mut(row * n + k) {
+                    *x -= f * iv;
+                }
+            }
+        }
+    }
+    // Rounding noise in the inverse scales with 1/scale of the input matrix.
+    let noise = 1e-15 / scale;
+    let inv = inv.into_iter().map(|x| if x.abs() < noise { 0.0 } else { x }).collect();
+    to_value_array(n, n, inv)
+}
+
+pub(super) fn munit(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let n = num(a, 0)?.trunc();
+    let (r, _) = check_size(n, n)?;
+    let mut data = vec![Value::Number(0.0); r * r];
+    for i in 0..r {
+        if let Some(x) = data.get_mut(i * r + i) {
+            *x = Value::Number(1.0);
+        }
+    }
+    array_val(r, r, data)
+}
diff --git a/crates/functions/src/math/roman_base.rs b/crates/functions/src/math/roman_base.rs
new file mode 100644
index 000000000..931552e93
--- /dev/null
+++ b/crates/functions/src/math/roman_base.rs
@@ -0,0 +1,121 @@
+use super::*;
+
+// ---------------------------------------------------------------------------------------------
+// Number systems
+
+const NUMERALS: [(char, u32); 7] = [('I', 1), ('V', 5), ('X', 10), ('L', 50), ('C', 100), ('D', 500), ('M', 1000)];
+
+/// Tokens (text, value) for a ROMAN form, largest value first. Form 0 is classic; each higher
+/// form widens one of two limits on the subtracted numeral's ratio to the larger one, alternating:
+/// the limit for I/X/C (10, 10, 100, 100, 1000) and for V/L (none, 20, 20, 200, 200). So form 2
+/// allows IC and XM but not VD, and form 3 adds VD and VM but not ID.
+fn roman_tokens(form: u32) -> Vec<(String, u32)> {
+    let (pow10_max, five_max) = [(10, 0), (10, 20), (100, 20), (100, 200), (1000, 200)].get(form as usize).copied().unwrap_or((10, 0));
+    let mut toks: Vec<(String, u32)> = NUMERALS.iter().map(|(c, v)| (c.to_string(), *v)).collect();
+    for (i, (sc, sv)) in NUMERALS.iter().enumerate() {
+        for (lc, lv) in NUMERALS.iter().skip(i + 1) {
+            let ratio = lv / sv;
+            let pow10 = matches!(sc, 'I' | 'X' | 'C');
+            let ok = ratio <= if pow10 { pow10_max } else { five_max };
+            let value = lv - sv;
+            // Skip pairs that equal a single numeral (VX = V) – they are never shorter.
+            if ok && !NUMERALS.iter().any(|(_, v)| *v == value) {
+                toks.push((format!("{sc}{lc}"), value));
+            }
+        }
+    }
+    // Largest value first; on ties prefer the shorter / classic token.
+    toks.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.len().cmp(&b.0.len())));
+    toks
+}
+
+pub(super) fn roman(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let n = num(a, 0)?.trunc();
+    let form = match a.get(1).map(|x| x.value.scalar()) {
+        None => 0.0,
+        Some(Value::Bool(true)) => 0.0,
+        Some(Value::Bool(false)) => 4.0,
+        Some(_) => num(a, 1)?.trunc(),
+    };
+    if !(0.0..=3999.0).contains(&n) || !(0.0..=4.0).contains(&form) {
+        return Err(CellError::Value);
+    }
+    let toks = roman_tokens(form as u32);
+    let mut rem = n as u32;
+    let mut out = String::new();
+    while rem > 0 {
+        let Some((t, v)) = toks.iter().find(|(_, v)| *v <= rem) else { break };
+        out.push_str(t);
+        rem -= v;
+    }
+    text_val(out)
+}
+
+pub(super) fn arabic(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let s = text(a, 0)?;
+    let s = s.trim();
+    if s.chars().count() > 255 {
+        return Err(CellError::Value);
+    }
+    let (neg, body) = match s.strip_prefix('-') {
+        Some(r) => (true, r),
+        None => (false, s),
+    };
+    let mut vals = Vec::new();
+    for ch in body.chars() {
+        let u = ch.to_ascii_uppercase();
+        let Some((_, v)) = NUMERALS.iter().find(|(c, _)| *c == u) else { return Err(CellError::Value) };
+        vals.push(*v as i64);
+    }
+    let mut total = 0i64;
+    for (i, v) in vals.iter().enumerate() {
+        if vals.get(i + 1).is_some_and(|next| next > v) {
+            total -= v;
+        } else {
+            total += v;
+        }
+    }
+    num_val(if neg { -total as f64 } else { total as f64 })
+}
+
+pub(super) fn base(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let n = num(a, 0)?.trunc();
+    let radix = num(a, 1)?.trunc();
+    let min_len = opt_num(a, 2, 0.0)?.trunc();
+    if !(0.0..9.007_199_254_740_992e15).contains(&n) || !(2.0..=36.0).contains(&radix) || !(0.0..=255.0).contains(&min_len) {
+        return Err(CellError::Num);
+    }
+    let radix = radix as u64;
+    let mut v = n as u64;
+    let mut digits = Vec::new();
+    loop {
+        let d = (v % radix) as u32;
+        digits.push(char::from_digit(d, radix as u32).unwrap_or('0').to_ascii_uppercase());
+        v /= radix;
+        if v == 0 {
+            break;
+        }
+    }
+    while digits.len() < min_len as usize {
+        digits.push('0');
+    }
+    text_val(digits.iter().rev().collect::<String>())
+}
+
+pub(super) fn decimal(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
+    let s = text(a, 0)?;
+    let radix = num(a, 1)?.trunc();
+    if !(2.0..=36.0).contains(&radix) || s.chars().count() > 255 {
+        return Err(CellError::Num);
+    }
+    let radix = radix as u32;
+    let mut total = 0f64;
+    for ch in s.trim().chars() {
+        let Some(d) = ch.to_digit(radix) else { return Err(CellError::Num) };
+        total = total * radix as f64 + d as f64;
+    }
+    if total >= 9.007_199_254_740_992e15 {
+        return Err(CellError::Num);
+    }
+    num_val(total)
+}

From e8f3b6f0cfd4a5e72c6e0774ef1e973fac1d4436 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:04:34 +0000
Subject: [PATCH 62/76] refactor(xlsx): move pivot.rs items to pivot/

---
 crates/xlsx/src/pivot.rs       | 1262 +-------------------------------
 crates/xlsx/src/pivot/read.rs  |  382 ++++++++++
 crates/xlsx/src/pivot/write.rs |  876 ++++++++++++++++++++++
 3 files changed, 1264 insertions(+), 1256 deletions(-)
 create mode 100644 crates/xlsx/src/pivot/read.rs
 create mode 100644 crates/xlsx/src/pivot/write.rs

diff --git a/crates/xlsx/src/pivot.rs b/crates/xlsx/src/pivot.rs
index b3837e2f0..45a618893 100644
--- a/crates/xlsx/src/pivot.rs
+++ b/crates/xlsx/src/pivot.rs
@@ -26,6 +26,12 @@ use crate::read::Ctx;
 use crate::write::{NS_MAIN, NS_REL, Out, Rels, XML_DECL, abs_range};
 use crate::xml::{El, esc_attr};
 
+mod read;
+mod write;
+
+pub use read::{CachesIn, read_pivots};
+pub use write::PivotWriter;
+
 pub const CT_PIVOT_TABLE: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml";
 pub const CT_PIVOT_CACHE_DEF: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml";
 pub const CT_PIVOT_CACHE_REC: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml";
@@ -168,1259 +174,3 @@ fn key(v: &Value) -> Key {
         Value::Array(_) => key(&v.scalar()),
     }
 }
-
-#[derive(Default)]
-struct Stats {
-    blank: bool,
-    text: bool,
-    number: bool,
-    non_int: bool,
-    boolean: bool,
-    error: bool,
-    long: bool,
-    min: f64,
-    max: f64,
-}
-
-impl Stats {
-    fn add(&mut self, v: &Value) {
-        match v {
-            Value::Empty => self.blank = true,
-            Value::Number(n) => {
-                if !self.number {
-                    self.min = *n;
-                    self.max = *n;
-                }
-                self.number = true;
-                self.min = self.min.min(*n);
-                self.max = self.max.max(*n);
-                if n.fract() != 0.0 {
-                    self.non_int = true;
-                }
-            }
-            Value::Text(t) => {
-                self.text = true;
-                if t.chars().count() > 255 {
-                    self.long = true;
-                }
-            }
-            Value::Bool(_) => self.boolean = true,
-            Value::Error(_) => self.error = true,
-            Value::Array(_) => self.add(&v.scalar()),
-        }
-    }
-    /// Excel counts booleans and errors as strings in the cache field flags.
-    fn strings(&self) -> bool {
-        self.text || self.boolean || self.error
-    }
-    /// Kinds for `containsMixedTypes`: strings (text, booleans, errors) and numbers.
-    fn kinds(&self) -> usize {
-        usize::from(self.strings()) + usize::from(self.number)
-    }
-}
-
-/// Date grouping of a cache field.
-struct Group {
-    by: PivotDateGroup,
-    /// The database field the grouping applies to.
-    base: usize,
-    /// The next (coarser) grouping field of the same base.
-    par: Option<usize>,
-    start: f64,
-    end: f64,
-    /// Group item captions, including the `<start` and `>end` items.
-    items: Vec<String>,
-}
-
-struct CField {
-    name: String,
-    /// Column offset in the source (database fields only).
-    col: Option<u32>,
-    stats: Stats,
-    /// Shared items (written when `itemized`).
-    items: Vec<Value>,
-    index: HashMap<Key, u32>,
-    itemized: bool,
-    group: Option<Group>,
-    /// A calculated field's formula (without `=`); such fields aren't database fields.
-    formula: Option<String>,
-}
-
-impl CField {
-    /// Item captions the PivotTable's `<item x>` indices refer to.
-    fn item_labels(&self) -> Vec<String> {
-        match &self.group {
-            Some(g) => g.items.clone(),
-            None => self.items.iter().map(label).collect(),
-        }
-    }
-}
-
-/// A cache built from a PivotTable's source.
-struct Cache {
-    fields: Vec<CField>,
-    /// Pivot field → cache field, by the pivot field's position in rows, then columns.
-    axis_map: Vec<Option<usize>>,
-    source_xml: String,
-    records: Option<(u64, String)>,
-}
-
-/// PivotTables being written; the tables themselves are finished after the styles part (their
-/// value number formats need style number-format ids).
-#[derive(Default)]
-pub struct PivotWriter {
-    /// (cache id, workbook-relative part name).
-    caches: Vec<(u32, String)>,
-    pending: Vec<Pending>,
-    tables: u32,
-}
-
-struct Pending {
-    part: String,
-    sheet: usize,
-    idx: usize,
-    cache_id: u32,
-    cache: Cache,
-}
-
-impl PivotWriter {
-    /// Writes the caches of a sheet's PivotTables and adds the sheet's relationships to its
-    /// PivotTable parts. Pivots whose source can't be resolved are not written.
-    pub fn add_sheet(&mut self, wb: &Workbook, si: usize, out: &mut Out, rels: &mut Rels) {
-        let Some(sheet) = wb.sheet(si) else { return };
-        for (idx, pt) in sheet.pivots.iter().enumerate() {
-            let Some(cache) = build_cache(wb, pt, si) else { continue };
-            let n = self.caches.len() as u32 + 1;
-            let cache_part = format!("xl/pivotCache/pivotCacheDefinition{n}.xml");
-            let rec_rid = if let Some((count, xml)) = &cache.records {
-                let mut r = Rels::default();
-                let rid = r.add("pivotCacheRecords", &format!("pivotCacheRecords{n}.xml"));
-                out.part(&format!("xl/pivotCache/_rels/pivotCacheDefinition{n}.xml.rels"), None, r.xml().into_bytes());
-                let s = format!("{XML_DECL}<pivotCacheRecords xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\" count=\"{count}\">{xml}</pivotCacheRecords>");
-                out.part(&format!("xl/pivotCache/pivotCacheRecords{n}.xml"), Some(CT_PIVOT_CACHE_REC), s.into_bytes());
-                Some(rid)
-            } else {
-                None
-            };
-            out.part(&cache_part, Some(CT_PIVOT_CACHE_DEF), cache_xml(&cache, rec_rid.as_deref(), wb.date_system).into_bytes());
-            self.caches.push((n, format!("pivotCache/pivotCacheDefinition{n}.xml")));
-            self.tables += 1;
-            let t = self.tables;
-            rels.add("pivotTable", &format!("../pivotTables/pivotTable{t}.xml"));
-            let mut tr = Rels::default();
-            tr.add("pivotCacheDefinition", &format!("../pivotCache/pivotCacheDefinition{n}.xml"));
-            out.part(&format!("xl/pivotTables/_rels/pivotTable{t}.xml.rels"), None, tr.xml().into_bytes());
-            self.pending.push(Pending { part: format!("xl/pivotTables/pivotTable{t}.xml"), sheet: si, idx, cache_id: n, cache });
-        }
-    }
-
-    /// Adds the workbook relationships to the caches; returns the `<pivotCaches>` element (empty
-    /// when there are none).
-    pub fn workbook_xml(&self, wb_rels: &mut Rels) -> String {
-        if self.caches.is_empty() {
-            return String::new();
-        }
-        let mut s = String::from("<pivotCaches>");
-        for (id, target) in &self.caches {
-            let rid = wb_rels.add("pivotCacheDefinition", target);
-            let _ = write!(s, "<pivotCache cacheId=\"{id}\" r:id=\"{rid}\"/>");
-        }
-        s.push_str("</pivotCaches>");
-        s
-    }
-
-    /// Number formats used by value fields (to be registered in the styles part).
-    pub fn number_formats(&self, wb: &Workbook) -> Vec<String> {
-        let mut v = Vec::new();
-        for p in &self.pending {
-            if let Some(pt) = wb.sheet(p.sheet).and_then(|s| s.pivots.get(p.idx)) {
-                for val in &pt.values {
-                    if let Some(f) = &val.number_format
-                        && !v.contains(f)
-                    {
-                        v.push(f.clone());
-                    }
-                }
-            }
-        }
-        v
-    }
-
-    /// Writes the PivotTable parts. `fmt_id` maps a number format code to its styles id.
-    pub fn finish(self, wb: &Workbook, out: &mut Out, fmt_id: &dyn Fn(&str) -> Option<u32>) {
-        for p in self.pending {
-            let Some(pt) = wb.sheet(p.sheet).and_then(|s| s.pivots.get(p.idx)) else { continue };
-            let xml = table_xml(pt, p.idx, p.cache_id, &p.cache, fmt_id);
-            out.part(&p.part, Some(CT_PIVOT_TABLE), xml.into_bytes());
-        }
-    }
-}
-
-/// Resolves a pivot source to (sheet, range including the header row, worksheetSource XML).
-fn resolve_source(wb: &Workbook, text: &str, default_sheet: usize, depth: u32) -> Option<(usize, RangeRef, String)> {
-    let t = text.trim().trim_start_matches('=').trim();
-    if t.is_empty() || depth > 4 {
-        return None;
-    }
-    if let Some((si, ti)) = wb.table(t)
-        && let Some(sh) = wb.sheet(si)
-        && let Some(tb) = sh.tables.get(ti)
-    {
-        if !tb.header_row {
-            return None;
-        }
-        let end_row = tb.range.end.row.saturating_sub(tb.totals_row as u32).max(tb.range.start.row);
-        let r = RangeRef::new(tb.range.start, CellRef::new(end_row, tb.range.end.col));
-        // Table names are sanitized when written; refer by range when this one would change.
-        let valid = !tb.name.is_empty()
-            && tb.name.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '.')
-            && tb.name.starts_with(|c: char| c.is_alphabetic() || c == '_')
-            && CellRef::parse(&tb.name).is_none();
-        let xml = if valid { format!("<worksheetSource name=\"{}\"/>", esc_attr(&tb.name)) } else { range_source_xml(&sh.name, r) };
-        return Some((si, r, xml));
-    }
-    let (sheet, body) = gridcraft_core::split_sheet(t);
-    if let Some(r) = RangeRef::parse(body) {
-        let si = match &sheet {
-            Some(n) => wb.sheet_index(n)?,
-            None => default_sheet,
-        };
-        let sh = wb.sheet(si)?;
-        let r = if r.is_full_cols() || r.is_full_rows() { r.intersection(&sh.used_range()?)? } else { r };
-        return Some((si, r, range_source_xml(&sh.name, r)));
-    }
-    if sheet.is_none()
-        && let Some(n) = wb.name(t, default_sheet)
-    {
-        let (si, r, _) = resolve_source(wb, &n.formula.clone(), default_sheet, depth + 1)?;
-        let xml = if n.scope.is_none() {
-            format!("<worksheetSource name=\"{}\"/>", esc_attr(&n.name))
-        } else {
-            wb.sheet(si).map(|s| range_source_xml(&s.name, r))?
-        };
-        return Some((si, r, xml));
-    }
-    None
-}
-
-fn range_source_xml(sheet: &str, r: RangeRef) -> String {
-    let name: String = sheet.chars().take(31).collect();
-    format!("<worksheetSource ref=\"{}\" sheet=\"{}\"/>", r.a1(), esc_attr(&name))
-}
-
-fn header_text(v: &Value) -> String {
-    match v {
-        Value::Empty => String::new(),
-        v => label(v).trim().to_string(),
-    }
-}
-
-fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cache> {
-    let (si, r, source_xml) = resolve_source(wb, &pt.source, pivot_sheet, 0)?;
-    if r.count() > MAX_SOURCE_CELLS {
-        return None;
-    }
-    let sh = wb.sheet(si)?;
-    let mut fields: Vec<CField> = Vec::new();
-    // Lower-case names taken, and the next suffix for each header (linear for repeated headers).
-    let mut taken = std::collections::HashSet::new();
-    let mut next_suffix: HashMap<String, usize> = HashMap::new();
-    for (k, c) in (r.start.col..=r.end.col).enumerate() {
-        let mut h = header_text(&sh.value(CellRef::new(r.start.row, c)).scalar());
-        if h.is_empty() {
-            h = format!("Column{}", k + 1);
-        }
-        let mut n = h.clone();
-        let mut i = next_suffix.get(&h.to_lowercase()).copied().unwrap_or(2);
-        while taken.contains(&n.to_lowercase()) {
-            n = format!("{h}{i}");
-            i += 1;
-        }
-        next_suffix.insert(h.to_lowercase(), i);
-        taken.insert(n.to_lowercase());
-        fields.push(CField {
-            name: n,
-            col: Some(k as u32),
-            stats: Stats::default(),
-            items: vec![],
-            index: HashMap::new(),
-            itemized: false,
-            group: None,
-            formula: None,
-        });
-    }
-    let find = |fields: &[CField], name: &str| fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
-
-    // Records (rows that aren't entirely blank), read once.
-    let mut rows: Vec<u32> = Vec::new();
-    if r.end.row > r.start.row {
-        for row in r.start.row + 1..=r.end.row {
-            let blank = (r.start.col..=r.end.col).all(|c| sh.value(CellRef::new(row, c)).scalar().is_empty());
-            if !blank {
-                rows.push(row);
-            }
-        }
-    }
-    for &row in &rows {
-        for f in fields.iter_mut() {
-            let c = r.start.col + f.col.unwrap_or(0);
-            f.stats.add(&sh.value(CellRef::new(row, c)).scalar());
-        }
-    }
-
-    // Which fields are on an axis, and how dates are grouped: per base column, the base field
-    // takes the finest grouping and coarser ones become extra (non-database) fields chained
-    // through `par`, as Excel lays them out.
-    let axis: Vec<&PivotField> = pt.rows.iter().chain(pt.columns.iter()).collect();
-    let groupable = |f: &CField| {
-        let s = &f.stats;
-        s.number
-            && !s.text
-            && !s.boolean
-            && !s.error
-            && datetime_from_serial(wb.date_system, s.min).is_some()
-            && datetime_from_serial(wb.date_system, s.max).is_some()
-    };
-    // (base column field, groupings fine → coarse)
-    let mut groupings: Vec<(usize, Vec<PivotDateGroup>)> = Vec::new();
-    for pf in &axis {
-        let Some(b) = find(&fields, &pf.source_col) else { continue };
-        if pf.date_group == PivotDateGroup::None || !fields.get(b).is_some_and(groupable) {
-            continue;
-        }
-        match groupings.iter_mut().find(|(x, _)| *x == b) {
-            Some((_, v)) => {
-                if !v.contains(&pf.date_group) {
-                    v.push(pf.date_group);
-                }
-            }
-            None => groupings.push((b, vec![pf.date_group])),
-        }
-    }
-    let fineness = |g: &PivotDateGroup| match g {
-        PivotDateGroup::Days => 0,
-        PivotDateGroup::Months => 1,
-        PivotDateGroup::Quarters => 2,
-        PivotDateGroup::Years => 3,
-        PivotDateGroup::None => 4,
-    };
-    for (b, list) in groupings.iter_mut() {
-        list.sort_by_key(fineness);
-        let (min, max) = fields.get(*b).map(|f| (f.stats.min, f.stats.max)).unwrap_or((0.0, 0.0));
-        let (start, end) = (min.floor(), max.floor() + 1.0);
-        let make = |by: PivotDateGroup| Group { by, base: *b, par: None, start, end, items: group_items(wb.date_system, by, start, end) };
-        let mut prev = *b;
-        for (k, by) in list.iter().enumerate() {
-            if k == 0 {
-                if let Some(f) = fields.get_mut(*b) {
-                    f.group = Some(make(*by));
-                }
-                continue;
-            }
-            let new = fields.len();
-            let caption = group_caption(*by);
-            let mut n = caption.to_string();
-            let mut i = 2;
-            while fields.iter().any(|f| same(&f.name, &n)) {
-                n = format!("{caption}{i}");
-                i += 1;
-            }
-            if let Some(g) = fields.get_mut(prev).and_then(|f| f.group.as_mut()) {
-                g.par = Some(new);
-            }
-            fields.push(CField {
-                name: n,
-                col: None,
-                stats: Stats::default(),
-                items: vec![],
-                index: HashMap::new(),
-                itemized: false,
-                group: Some(make(*by)),
-                formula: None,
-            });
-            prev = new;
-        }
-    }
-    let mut axis_map: Vec<Option<usize>> = Vec::with_capacity(axis.len());
-    for pf in &axis {
-        let Some(b) = find(&fields, &pf.source_col) else {
-            axis_map.push(None);
-            continue;
-        };
-        let grouped = fields.iter().position(|f| f.group.as_ref().is_some_and(|g| g.base == b && g.by == pf.date_group));
-        match grouped {
-            Some(i) if pf.date_group != PivotDateGroup::None => axis_map.push(Some(i)),
-            _ => {
-                if let Some(f) = fields.get_mut(b)
-                    && f.group.is_none()
-                {
-                    f.itemized = true;
-                }
-                axis_map.push(Some(b));
-            }
-        }
-    }
-    // Page fields (filters not on an axis) need items too.
-    for f in &pt.filters {
-        let on_axis = axis.iter().any(|a| same(&a.source_col, &f.source_col));
-        if !on_axis
-            && let Some(i) = find(&fields, &f.source_col)
-            && let Some(cf) = fields.get_mut(i)
-        {
-            cf.itemized = true;
-        }
-    }
-    for f in fields.iter_mut() {
-        if f.group.is_some() {
-            f.itemized = false;
-        } else if f.col.is_some() && (f.stats.text || f.stats.boolean || f.stats.error) {
-            f.itemized = true;
-        }
-    }
-    // Shared items, in order of first appearance.
-    for &row in &rows {
-        for f in fields.iter_mut().filter(|f| f.itemized) {
-            let c = r.start.col + f.col.unwrap_or(0);
-            let v = sh.value(CellRef::new(row, c)).scalar();
-            let k = key(&v);
-            if !f.index.contains_key(&k) && f.items.len() < MAX_ITEMS {
-                f.index.insert(k, f.items.len() as u32);
-                f.items.push(v);
-            }
-        }
-    }
-    // Records snapshot.
-    let db_fields = fields.iter().filter(|f| f.col.is_some()).count() as u64;
-    let records = if (rows.len() as u64).saturating_mul(db_fields) <= MAX_RECORD_CELLS {
-        let mut s = String::new();
-        for &row in &rows {
-            s.push_str("<r>");
-            for f in fields.iter().filter(|f| f.col.is_some()) {
-                let c = r.start.col + f.col.unwrap_or(0);
-                let v = sh.value(CellRef::new(row, c)).scalar();
-                if f.itemized {
-                    match f.index.get(&key(&v)) {
-                        Some(i) => {
-                            let _ = write!(s, "<x v=\"{i}\"/>");
-                        }
-                        None => s.push_str(&item_xml(&v, wb.date_system, false)),
-                    }
-                } else {
-                    s.push_str(&item_xml(&v, wb.date_system, f.group.is_some()));
-                }
-            }
-            s.push_str("</r>");
-        }
-        Some((rows.len() as u64, s))
-    } else {
-        None
-    };
-    // Calculated fields come after the database and grouping fields.
-    for cf in &pt.calculated_fields {
-        let f = cf.formula.trim();
-        let f = f.strip_prefix('=').unwrap_or(f).trim();
-        if cf.name.trim().is_empty() || f.is_empty() || fields.iter().any(|x| same(&x.name, &cf.name)) {
-            continue;
-        }
-        fields.push(CField {
-            name: cf.name.clone(),
-            col: None,
-            stats: Stats::default(),
-            items: vec![],
-            index: HashMap::new(),
-            itemized: false,
-            group: None,
-            formula: Some(f.to_string()),
-        });
-    }
-    Some(Cache { fields, axis_map, source_xml, records })
-}
-
-fn group_items(sys: DateSystem, by: PivotDateGroup, start: f64, end: f64) -> Vec<String> {
-    let mut v = vec![format!("<{}", mdy(sys, start))];
-    match by {
-        PivotDateGroup::Years => {
-            let y0 = datetime_from_serial(sys, start).map(|d| d.year).unwrap_or(1900);
-            let y1 = datetime_from_serial(sys, end - 1.0).map(|d| d.year).unwrap_or(y0).max(y0);
-            for y in y0..=y1.min(y0 + 10_000) {
-                v.push(y.to_string());
-            }
-        }
-        PivotDateGroup::Quarters => v.extend((1..=4).map(|q| format!("Qtr{q}"))),
-        PivotDateGroup::Months => v.extend(MONTHS.iter().map(ToString::to_string)),
-        PivotDateGroup::Days | PivotDateGroup::None => {
-            const DAYS: [u32; 12] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-            for (m, n) in MONTHS.iter().zip(DAYS) {
-                for d in 1..=n {
-                    v.push(format!("{d}-{m}"));
-                }
-            }
-        }
-    }
-    v.push(format!(">{}", mdy(sys, end)));
-    v
-}
-
-/// A cache value element (`<n>`, `<s>`, `<m>`…); `date` writes numbers as `<d>`.
-fn item_xml(v: &Value, sys: DateSystem, date: bool) -> String {
-    match v {
-        Value::Empty => "<m/>".into(),
-        Value::Number(n) => {
-            if date && let Some(d) = iso(sys, *n) {
-                return format!("<d v=\"{d}\"/>");
-            }
-            format!("<n v=\"{}\"/>", crate::xml::num(*n))
-        }
-        Value::Text(t) => format!("<s v=\"{}\"/>", esc_attr(t)),
-        Value::Bool(b) => format!("<b v=\"{}\"/>", u8::from(*b)),
-        Value::Error(e) => format!("<e v=\"{}\"/>", esc_attr(e.as_str())),
-        Value::Array(_) => item_xml(&v.scalar(), sys, date),
-    }
-}
-
-fn cache_xml(c: &Cache, records_rid: Option<&str>, sys: DateSystem) -> String {
-    let mut s = format!("{XML_DECL}<pivotCacheDefinition xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\"");
-    match (records_rid, &c.records) {
-        (Some(rid), Some((count, _))) => {
-            let _ = write!(s, " r:id=\"{rid}\" recordCount=\"{count}\"");
-        }
-        _ => s.push_str(" saveData=\"0\""),
-    }
-    s.push_str(" refreshOnLoad=\"1\" refreshedBy=\"GridCraft\" createdVersion=\"6\" refreshedVersion=\"6\" minRefreshableVersion=\"3\">");
-    let _ = write!(s, "<cacheSource type=\"worksheet\">{}</cacheSource>", c.source_xml);
-    let _ = write!(s, "<cacheFields count=\"{}\">", c.fields.len());
-    for f in &c.fields {
-        let fmt = if f.group.is_some() { 14 } else { 0 };
-        let _ = write!(s, "<cacheField name=\"{}\" numFmtId=\"{fmt}\"", esc_attr(&f.name));
-        if let Some(formula) = &f.formula {
-            let _ = write!(s, " formula=\"{}\"", esc_attr(formula));
-        }
-        if f.col.is_none() {
-            s.push_str(" databaseField=\"0\"");
-        }
-        s.push('>');
-        let st = &f.stats;
-        if f.col.is_some() {
-            s.push_str("<sharedItems");
-            if let Some(g) = &f.group {
-                s.push_str(" containsSemiMixedTypes=\"0\" containsNonDate=\"0\" containsDate=\"1\" containsString=\"0\"");
-                if st.blank {
-                    s.push_str(" containsBlank=\"1\"");
-                }
-                if let (Some(a), Some(b)) = (iso(sys, st.min), iso(sys, st.max)) {
-                    let _ = write!(s, " minDate=\"{a}\" maxDate=\"{b}\"");
-                }
-                let _ = g;
-            } else {
-                if !st.strings() && !st.blank {
-                    s.push_str(" containsSemiMixedTypes=\"0\"");
-                }
-                if !st.strings() {
-                    s.push_str(" containsString=\"0\"");
-                }
-                if st.blank {
-                    s.push_str(" containsBlank=\"1\"");
-                }
-                if st.kinds() > 1 {
-                    s.push_str(" containsMixedTypes=\"1\"");
-                }
-                if st.number {
-                    s.push_str(" containsNumber=\"1\"");
-                    if !st.non_int {
-                        s.push_str(" containsInteger=\"1\"");
-                    }
-                    let _ = write!(s, " minValue=\"{}\" maxValue=\"{}\"", crate::xml::num(st.min), crate::xml::num(st.max));
-                }
-                if st.long {
-                    s.push_str(" longText=\"1\"");
-                }
-            }
-            if f.itemized {
-                let _ = write!(s, " count=\"{}\">", f.items.len());
-                for v in &f.items {
-                    s.push_str(&item_xml(v, sys, false));
-                }
-                s.push_str("</sharedItems>");
-            } else {
-                s.push_str("/>");
-            }
-        }
-        if let Some(g) = &f.group {
-            s.push_str("<fieldGroup");
-            if let Some(p) = g.par {
-                let _ = write!(s, " par=\"{p}\"");
-            }
-            let _ = write!(s, " base=\"{}\">", g.base);
-            let _ = write!(s, "<rangePr groupBy=\"{}\"", group_by_name(g.by));
-            if let (Some(a), Some(b)) = (iso(sys, g.start), iso(sys, g.end)) {
-                let _ = write!(s, " startDate=\"{a}\" endDate=\"{b}\"");
-            }
-            let _ = write!(s, "/><groupItems count=\"{}\">", g.items.len());
-            for it in &g.items {
-                let _ = write!(s, "<s v=\"{}\"/>", esc_attr(it));
-            }
-            s.push_str("</groupItems></fieldGroup>");
-        }
-        s.push_str("</cacheField>");
-    }
-    s.push_str("</cacheFields></pivotCacheDefinition>");
-    s
-}
-
-fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn Fn(&str) -> Option<u32>) -> String {
-    let nf = c.fields.len();
-    let find_db = |name: &str| c.fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
-    let row_idx: Vec<usize> = c.axis_map.iter().take(pt.rows.len()).filter_map(|x| *x).collect();
-    let col_idx: Vec<usize> = c.axis_map.iter().skip(pt.rows.len()).filter_map(|x| *x).collect();
-    // Filters: on an axis field → hidden items there; otherwise a page field.
-    let mut hidden: HashMap<usize, &PivotFilter> = HashMap::new();
-    let mut pages: Vec<(usize, &PivotFilter)> = Vec::new();
-    for f in &pt.filters {
-        let axis_pos = pt.rows.iter().chain(pt.columns.iter()).position(|a| same(&a.source_col, &f.source_col));
-        match axis_pos {
-            Some(p) => {
-                if let Some(Some(i)) = c.axis_map.get(p) {
-                    hidden.insert(*i, f);
-                }
-            }
-            None => {
-                if let Some(i) = find_db(&f.source_col)
-                    && !pages.iter().any(|(j, _)| *j == i)
-                {
-                    pages.push((i, f));
-                    hidden.insert(i, f);
-                }
-            }
-        }
-    }
-    let find_calc = |name: &str| c.fields.iter().position(|f| f.formula.is_some() && same(&f.name, name));
-    let vals: Vec<(usize, &PivotValue)> =
-        pt.values.iter().filter_map(|v| find_db(&v.source_col).or_else(|| find_calc(&v.source_col)).map(|i| (i, v))).collect();
-    let axis_field = |i: usize| -> Option<&PivotField> {
-        let p = c.axis_map.iter().position(|x| *x == Some(i))?;
-        pt.rows.iter().chain(pt.columns.iter()).nth(p)
-    };
-
-    let compact = pt.layout == PivotLayout::Compact;
-    let name = if pt.name.trim().is_empty() { format!("PivotTable{}", idx + 1) } else { pt.name.clone() };
-    let mut s = format!(
-        "{XML_DECL}<pivotTableDefinition xmlns=\"{NS_MAIN}\" name=\"{}\" cacheId=\"{cache_id}\" applyNumberFormats=\"0\" applyBorderFormats=\"0\" applyFontFormats=\"0\" applyPatternFormats=\"0\" applyAlignmentFormats=\"0\" applyWidthHeightFormats=\"1\" dataCaption=\"Values\" updatedVersion=\"6\" minRefreshableVersion=\"3\" useAutoFormatting=\"1\" itemPrintTitles=\"1\" createdVersion=\"6\" indent=\"0\"",
-        esc_attr(&name)
-    );
-    match pt.layout {
-        PivotLayout::Compact => s.push_str(" outline=\"1\" outlineData=\"1\""),
-        PivotLayout::Outline => s.push_str(" compact=\"0\" compactData=\"0\" outline=\"1\" outlineData=\"1\""),
-        PivotLayout::Tabular => s.push_str(" compact=\"0\" compactData=\"0\""),
-    }
-    if pt.values_on_rows {
-        s.push_str(" dataOnRows=\"1\"");
-    }
-    if !pt.show_headers {
-        s.push_str(" showHeaders=\"0\"");
-    }
-    if !pt.enable_show_details {
-        s.push_str(" enableDrill=\"0\"");
-    }
-    // `rowGrandTotals` is the grand total row below the report (Excel's "On for Columns"),
-    // `colGrandTotals` the grand total column at its right ("On for Rows").
-    if !pt.grand_totals_cols {
-        s.push_str(" rowGrandTotals=\"0\"");
-    }
-    if !pt.grand_totals_rows {
-        s.push_str(" colGrandTotals=\"0\"");
-    }
-    s.push_str(" multipleFieldFilters=\"0\">");
-
-    // Location: the body (report filters sit above it).
-    let a = pt.anchor;
-    let end = pt.last_range.map(|r| r.end).unwrap_or(a);
-    let loc = RangeRef::new(a, CellRef::new(end.row.max(a.row), end.col.max(a.col)));
-    let k = vals.len();
-    // Σ Values (two or more value fields): its index among the written fields of its axis.
-    let (row_map, _) = c.axis_map.split_at(pt.rows.len().min(c.axis_map.len()));
-    let values_at = |map: &[Option<usize>], n: usize| pt.values_position.map_or(n, |p| map.iter().take(p).filter(|x| x.is_some()).count());
-    let row_values = (k > 1 && pt.values_on_rows).then(|| values_at(row_map, row_idx.len()));
-    // In Columns Σ Values comes after the last field: the column layout doesn't place it elsewhere.
-    let col_values = (k > 1 && !pt.values_on_rows).then_some(col_idx.len());
-    let first_data_row = if col_idx.is_empty() { 1 } else { 1 + col_idx.len() + usize::from(col_values.is_some()) };
-    let row_levels = row_idx.len() + usize::from(row_values.is_some());
-    let first_data_col = if row_levels == 0 && col_idx.is_empty() {
-        0
-    } else if compact {
-        1
-    } else {
-        row_levels.max(1)
-    };
-    // Two or more value fields in Columns alone: Excel 365 would add a `Values` caption row.
-    let hide_values_row = col_values.is_some() && col_idx.is_empty();
-    let first_header_row = usize::from(!hide_values_row);
-    let _ = write!(
-        s,
-        "<location ref=\"{}\" firstHeaderRow=\"{first_header_row}\" firstDataRow=\"{first_data_row}\" firstDataCol=\"{first_data_col}\"",
-        loc.a1()
-    );
-    if !pages.is_empty() {
-        let _ = write!(s, " rowPageCount=\"{}\" colPageCount=\"1\"", pages.len());
-    }
-    s.push_str("/>");
-
-    // Fields.
-    let _ = write!(s, "<pivotFields count=\"{nf}\">");
-    for (i, f) in c.fields.iter().enumerate() {
-        s.push_str("<pivotField");
-        let axis = if row_idx.contains(&i) {
-            Some("axisRow")
-        } else if col_idx.contains(&i) {
-            Some("axisCol")
-        } else if pages.iter().any(|(j, _)| *j == i) {
-            Some("axisPage")
-        } else {
-            None
-        };
-        if let Some(ax) = axis {
-            let _ = write!(s, " axis=\"{ax}\"");
-        }
-        if vals.iter().any(|(j, _)| *j == i) {
-            s.push_str(" dataField=\"1\"");
-        }
-        if f.formula.is_some() {
-            s.push_str(" dragToRow=\"0\" dragToCol=\"0\" dragToPage=\"0\"");
-        }
-        match pt.layout {
-            PivotLayout::Compact => {}
-            PivotLayout::Outline => s.push_str(" compact=\"0\""),
-            PivotLayout::Tabular => s.push_str(" compact=\"0\" outline=\"0\""),
-        }
-        if f.group.is_some() {
-            s.push_str(" numFmtId=\"14\"");
-        }
-        let filter = hidden.get(&i).copied();
-        let labels = f.item_labels();
-        let is_page = axis == Some("axisPage");
-        // Hidden items; never hide every item (a field needs one visible item).
-        let mut hide: Vec<bool> = match filter.and_then(|f| f.selected.as_ref()) {
-            Some(sel) if !(is_page && sel.len() == 1) => labels.iter().map(|l| !sel.iter().any(|x| same(x, l))).collect(),
-            _ => vec![false; labels.len()],
-        };
-        if !hide.is_empty() && hide.iter().all(|h| *h) {
-            hide.iter_mut().for_each(|h| *h = false);
-        }
-        if is_page && hide.iter().any(|h| *h) {
-            s.push_str(" multipleItemSelectionAllowed=\"1\"");
-        }
-        s.push_str(" showAll=\"0\"");
-        if let Some(af) = axis_field(i) {
-            match af.sort {
-                PivotSort::Asc => s.push_str(" sortType=\"ascending\""),
-                PivotSort::Desc => s.push_str(" sortType=\"descending\""),
-                PivotSort::None => {}
-            }
-        }
-        if !pt.subtotals {
-            s.push_str(" defaultSubtotal=\"0\"");
-        }
-        if !pt.subtotals_top {
-            s.push_str(" subtotalTop=\"0\"");
-        }
-        if axis.is_some() {
-            let collapsed: &[String] = axis_field(i).map(|f| f.collapsed_items.as_slice()).unwrap_or(&[]);
-            let count = labels.len() + usize::from(pt.subtotals);
-            let _ = write!(s, "><items count=\"{count}\">");
-            for (x, l) in labels.iter().enumerate() {
-                let _ = write!(s, "<item x=\"{x}\"");
-                if hide.get(x).copied().unwrap_or(false) {
-                    s.push_str(" h=\"1\"");
-                }
-                if collapsed.iter().any(|cl| same(cl, l)) {
-                    s.push_str(" sd=\"0\"");
-                }
-                s.push_str("/>");
-            }
-            if pt.subtotals {
-                s.push_str("<item t=\"default\"/>");
-            }
-            s.push_str("</items></pivotField>");
-        } else {
-            s.push_str("/>");
-        }
-    }
-    s.push_str("</pivotFields>");
-
-    axis_fields_xml(&mut s, "rowFields", &row_idx, row_values);
-    axis_fields_xml(&mut s, "colFields", &col_idx, col_values);
-    if !pages.is_empty() {
-        let _ = write!(s, "<pageFields count=\"{}\">", pages.len());
-        for (i, f) in &pages {
-            let _ = write!(s, "<pageField fld=\"{i}\"");
-            if let Some(sel) = &f.selected
-                && sel.len() == 1
-                && let Some(one) = sel.first()
-                && let Some(x) = c.fields.get(*i).and_then(|cf| cf.item_labels().iter().position(|l| same(l, one)))
-            {
-                let _ = write!(s, " item=\"{x}\"");
-            }
-            s.push_str(" hier=\"-1\"/>");
-        }
-        s.push_str("</pageFields>");
-    }
-    if !vals.is_empty() {
-        let _ = write!(s, "<dataFields count=\"{k}\">");
-        let mut used: Vec<String> = Vec::new();
-        for (i, v) in &vals {
-            let base = if v.name.trim().is_empty() {
-                format!("{} of {}", func_caption(v.func), c.fields.get(*i).map(|f| f.name.as_str()).unwrap_or(""))
-            } else {
-                v.name.clone()
-            };
-            let mut n = base.clone();
-            let mut j = 2;
-            while used.iter().any(|u| same(u, &n)) {
-                n = format!("{base}{j}");
-                j += 1;
-            }
-            used.push(n.clone());
-            let _ = write!(s, "<dataField name=\"{}\" fld=\"{i}\"", esc_attr(&n));
-            if v.func != PivotFunc::Sum {
-                let _ = write!(s, " subtotal=\"{}\"", func_name(v.func));
-            }
-            let base_field = row_idx.first().or(col_idx.first()).copied().unwrap_or(0);
-            match v.show_as {
-                PivotShowAs::Normal => s.push_str(" baseField=\"0\" baseItem=\"0\""),
-                PivotShowAs::PercentOfGrandTotal => s.push_str(" showDataAs=\"percentOfTotal\" baseField=\"0\" baseItem=\"0\""),
-                PivotShowAs::PercentOfColumnTotal => s.push_str(" showDataAs=\"percentOfCol\" baseField=\"0\" baseItem=\"0\""),
-                PivotShowAs::PercentOfRowTotal => s.push_str(" showDataAs=\"percentOfRow\" baseField=\"0\" baseItem=\"0\""),
-                PivotShowAs::RunningTotal => {
-                    let _ = write!(s, " showDataAs=\"runTotal\" baseField=\"{base_field}\" baseItem=\"0\"");
-                }
-                PivotShowAs::Rank => {
-                    let _ = write!(s, " baseField=\"{base_field}\" baseItem=\"0\"");
-                }
-            }
-            if let Some(id) = v.number_format.as_deref().and_then(fmt_id) {
-                let _ = write!(s, " numFmtId=\"{id}\"");
-            }
-            if v.show_as == PivotShowAs::Rank {
-                let _ = write!(
-                    s,
-                    "><extLst><ext uri=\"{EXT_X14_DATA_FIELD}\" xmlns:x14=\"{NS_X14}\"><x14:dataField pivotShowAs=\"rankDescending\"/></ext></extLst></dataField>"
-                );
-            } else {
-                s.push_str("/>");
-            }
-        }
-        s.push_str("</dataFields>");
-    }
-    s.push_str("<pivotTableStyleInfo");
-    if !pt.style.is_empty() {
-        let _ = write!(s, " name=\"{}\"", esc_attr(&pt.style));
-    }
-    s.push_str(" showRowHeaders=\"1\" showColHeaders=\"1\" showRowStripes=\"0\" showColStripes=\"0\" showLastColumn=\"1\"/>");
-    if hide_values_row {
-        let _ = write!(
-            s,
-            "<extLst><ext uri=\"{EXT_X14_PIVOT_TABLE}\" xmlns:x14=\"{NS_X14}\"><x14:pivotTableDefinition hideValuesRow=\"1\"/></ext></extLst>"
-        );
-    }
-    s.push_str("</pivotTableDefinition>");
-    s
-}
-
-/// `<rowFields>`/`<colFields>`: the axis's cache field indices, with Σ Values (`-2`) at `values_at`.
-fn axis_fields_xml(s: &mut String, tag: &str, idx: &[usize], values_at: Option<usize>) {
-    let n = idx.len() + usize::from(values_at.is_some());
-    if n == 0 {
-        return;
-    }
-    let _ = write!(s, "<{tag} count=\"{n}\">");
-    for (j, i) in idx.iter().enumerate() {
-        if values_at == Some(j) {
-            s.push_str("<field x=\"-2\"/>");
-        }
-        let _ = write!(s, "<field x=\"{i}\"/>");
-    }
-    if values_at.is_some_and(|p| p >= idx.len()) {
-        s.push_str("<field x=\"-2\"/>");
-    }
-    let _ = write!(s, "</{tag}>");
-}
-
-// ================================================================ reading
-
-/// A cache field as read.
-#[derive(Clone, Debug, Default)]
-struct FieldIn {
-    name: String,
-    database: bool,
-    /// Shared item captions.
-    items: Vec<String>,
-    /// (base field, grouping, group item captions); grouping `None` = unsupported grouping.
-    group: Option<(Option<usize>, Option<PivotDateGroup>, Vec<String>)>,
-    /// A calculated field's formula.
-    formula: Option<String>,
-}
-
-impl FieldIn {
-    fn labels(&self) -> &[String] {
-        match &self.group {
-            Some((_, _, items)) if !items.is_empty() => items,
-            _ => &self.items,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-struct CacheIn {
-    source: String,
-    fields: Vec<FieldIn>,
-}
-
-/// Workbook-level pivot cache lookup, filled from `<pivotCaches>`; caches are parsed once.
-#[derive(Default)]
-pub struct CachesIn {
-    by_id: HashMap<u32, String>,
-    parsed: HashMap<String, Option<CacheIn>>,
-    next_id: u32,
-}
-
-impl CachesIn {
-    pub fn new(wb_xml: &El, wb_rels: &[crate::package::Rel]) -> CachesIn {
-        let mut by_id = HashMap::new();
-        if let Some(pc) = wb_xml.child("pivotCaches") {
-            for c in pc.kids("pivotCache") {
-                if let (Some(id), Some(rid)) = (c.attr_u32("cacheId"), c.attr("id"))
-                    && let Some(r) = wb_rels.iter().find(|r| r.id == rid)
-                {
-                    by_id.insert(id, r.target.clone());
-                }
-            }
-        }
-        CachesIn { by_id, parsed: HashMap::new(), next_id: 1 }
-    }
-}
-
-fn item_label_el(e: &El, sys: DateSystem) -> String {
-    let v = e.attr("v").unwrap_or("");
-    match e.name.as_str() {
-        "m" => "(blank)".into(),
-        "n" => v.trim().parse::<f64>().ok().filter(|n| n.is_finite()).map(number_to_text).unwrap_or_else(|| v.to_string()),
-        "b" => if matches!(v.trim(), "1" | "true") { "TRUE" } else { "FALSE" }.into(),
-        "d" => crate::sheet_read::parse_iso_datetime(v, sys).map(number_to_text).unwrap_or_else(|| v.to_string()),
-        _ => v.to_string(),
-    }
-}
-
-fn read_cache(cx: &mut Ctx<'_>, part: &str, sheet_name: &str) -> Option<CacheIn> {
-    let x = cx.optional_xml(part).ok().flatten()?;
-    if x.name != "pivotCacheDefinition" {
-        cx.warn(format!("{part} is not a pivot cache definition; its PivotTable was kept as plain cells"));
-        return None;
-    }
-    let src = x.child("cacheSource");
-    let ty = src.and_then(|s| s.attr("type")).unwrap_or("worksheet");
-    if ty != "worksheet" {
-        cx.warn(format!("PivotTables with a {ty} data source are not supported; kept as plain cells"));
-        return None;
-    }
-    let ws = src.and_then(|s| s.child("worksheetSource"));
-    let source = match ws {
-        Some(w) if w.attr("name").is_some_and(|n| !n.trim().is_empty()) => w.attr("name").unwrap_or("").trim().to_string(),
-        Some(w) => {
-            if w.attr("id").is_some() {
-                cx.warn("a PivotTable's source is in another workbook; its source reference may not resolve");
-            }
-            let r = w.attr("ref").map(|r| r.replace('$', "")).and_then(|r| RangeRef::parse(&r));
-            let Some(r) = r else {
-                cx.warn("a PivotTable's source reference is missing or invalid; kept as plain cells");
-                return None;
-            };
-            let sheet = w.attr("sheet").filter(|s| !s.is_empty()).unwrap_or(sheet_name);
-            format!("{}!{}", quote_sheet(sheet), abs_range(&r))
-        }
-        None => {
-            cx.warn("a PivotTable's cache has no worksheet source; kept as plain cells");
-            return None;
-        }
-    };
-    let sys = cx.date_system;
-    let mut fields = Vec::new();
-    if let Some(cf) = x.child("cacheFields") {
-        for f in cf.kids("cacheField").take(MAX_FIELDS) {
-            let items = f.child("sharedItems").map(|si| si.children.iter().map(|e| item_label_el(e, sys)).collect()).unwrap_or_default();
-            let group = f.child("fieldGroup").map(|g| {
-                let base = g.attr_u32("base").map(|b| b as usize);
-                let by = match g.child("rangePr").map(|r| r.attr("groupBy").unwrap_or("range")) {
-                    Some("years") => Some(PivotDateGroup::Years),
-                    Some("quarters") => Some(PivotDateGroup::Quarters),
-                    Some("months") => Some(PivotDateGroup::Months),
-                    Some("days") => Some(PivotDateGroup::Days),
-                    _ => None,
-                };
-                let gi = g.child("groupItems").map(|gi| gi.children.iter().map(|e| item_label_el(e, sys)).collect()).unwrap_or_default();
-                (base, by, gi)
-            });
-            fields.push(FieldIn {
-                name: f.attr("name").unwrap_or("").to_string(),
-                database: f.flag("databaseField", true),
-                items,
-                group,
-                formula: f.attr("formula").map(str::to_string),
-            });
-        }
-    }
-    if fields.is_empty() {
-        cx.warn("a PivotTable's cache has no fields; kept as plain cells");
-        return None;
-    }
-    Some(CacheIn { source, fields })
-}
-
-/// Reads the PivotTables related to a worksheet part.
-pub fn read_pivots(cx: &mut Ctx<'_>, caches: &mut CachesIn, sheet_part: &str, sheet_name: &str) -> Result<Vec<PivotTable>, IoError> {
-    let rels = cx.pkg.rels(sheet_part)?;
-    let mut out = Vec::new();
-    for rel in rels.iter().filter(|r| r.kind == "pivotTable" && !r.external) {
-        let Some(x) = cx.optional_xml(&rel.target)? else { continue };
-        if x.name != "pivotTableDefinition" {
-            cx.warn(format!("{} is not a PivotTable definition; skipped", rel.target));
-            continue;
-        }
-        // The cache: the table's own relationship, else the workbook's cache id.
-        let trels = cx.pkg.rels(&rel.target)?;
-        let cache_part = trels
-            .iter()
-            .find(|r| r.kind == "pivotCacheDefinition" && !r.external)
-            .map(|r| r.target.clone())
-            .or_else(|| x.attr_u32("cacheId").and_then(|id| caches.by_id.get(&id).cloned()));
-        let Some(cache_part) = cache_part else {
-            cx.warn(format!("PivotTable in {} has no cache; kept as plain cells", rel.target));
-            continue;
-        };
-        let cache = match caches.parsed.get(&cache_part) {
-            Some(c) => c.clone(),
-            None => {
-                let c = read_cache(cx, &cache_part, sheet_name);
-                caches.parsed.insert(cache_part.clone(), c.clone());
-                c
-            }
-        };
-        let Some(cache) = cache else { continue };
-        if let Some(pt) = read_table(cx, &x, &cache, caches.next_id) {
-            caches.next_id = caches.next_id.saturating_add(1);
-            out.push(pt);
-        }
-    }
-    Ok(out)
-}
-
-/// A pivot field's data items (not subtotal or grand-total items).
-fn items_of(e: &El) -> Vec<&El> {
-    e.child("items").map(|it| it.kids("item").filter(|i| i.attr("t").is_none_or(|t| t == "data")).collect()).unwrap_or_default()
-}
-
-/// (source column name, date grouping) of a cache field used on an axis.
-fn field_ref(cx: &mut Ctx<'_>, cache: &CacheIn, i: usize) -> Option<(String, PivotDateGroup)> {
-    let f = cache.fields.get(i)?;
-    if f.formula.is_some() {
-        cx.warn("calculated PivotTable fields are not supported");
-        return None;
-    }
-    match &f.group {
-        Some((base, by, _)) => {
-            let by = match by {
-                Some(b) => *b,
-                None => {
-                    cx.warn(format!("PivotTable grouping of \"{}\" is not supported; the field is ungrouped", f.name));
-                    PivotDateGroup::None
-                }
-            };
-            let base_name = if f.database { f.name.clone() } else { base.and_then(|b| cache.fields.get(b))?.name.clone() };
-            Some((base_name, by))
-        }
-        None if !f.database => {
-            cx.warn(format!("PivotTable field \"{}\" (grouped items) is not supported", f.name));
-            None
-        }
-        None => Some((f.name.clone(), PivotDateGroup::None)),
-    }
-}
-
-fn read_table(cx: &mut Ctx<'_>, x: &El, cache: &CacheIn, id: u32) -> Option<PivotTable> {
-    let mut pt = PivotTable { id, ..PivotTable::default() };
-    if let Some(n) = x.attr("name").filter(|n| !n.trim().is_empty()) {
-        pt.name = n.to_string();
-    } else {
-        pt.name = format!("PivotTable{id}");
-    }
-    pt.source = cache.source.clone();
-    let Some(loc) = x.child("location").and_then(|l| l.attr("ref")).and_then(|r| RangeRef::parse(&r.replace('$', ""))) else {
-        cx.warn(format!("PivotTable \"{}\" has no valid location; kept as plain cells", pt.name));
-        return None;
-    };
-    let pfs: Vec<&El> = x.child("pivotFields").map(|p| p.kids("pivotField").collect()).unwrap_or_default();
-    let pf = |i: usize| pfs.get(i).copied();
-    let idx_list = |name: &str, attr: &str| -> Vec<i64> {
-        x.child(name).map(|e| e.children.iter().filter_map(|f| f.attr_i64(attr)).collect()).unwrap_or_default()
-    };
-    let row_x = idx_list("rowFields", "x");
-    let col_x = idx_list("colFields", "x");
-    let pages: Vec<&El> = x.child("pageFields").map(|p| p.kids("pageField").collect()).unwrap_or_default();
-
-    // Layout from the first axis field (pivotField defaults: compact and outline on).
-    let first_axis = row_x.iter().chain(col_x.iter()).find(|i| **i >= 0).and_then(|i| pf(*i as usize));
-    let (compact, outline) = match first_axis {
-        Some(f) => (f.flag("compact", true), f.flag("outline", true)),
-        None => (x.flag("compact", true), x.flag("outline", false)),
-    };
-    pt.layout = if compact {
-        PivotLayout::Compact
-    } else if outline {
-        PivotLayout::Outline
-    } else {
-        PivotLayout::Tabular
-    };
-    if let Some(f) = first_axis {
-        pt.subtotals = f.flag("defaultSubtotal", true);
-        pt.subtotals_top = f.flag("subtotalTop", true);
-    }
-    pt.grand_totals_rows = x.flag("colGrandTotals", true);
-    pt.grand_totals_cols = x.flag("rowGrandTotals", true);
-    pt.show_headers = x.flag("showHeaders", true);
-    pt.enable_show_details = x.flag("enableDrill", true);
-    pt.style = x.child("pivotTableStyleInfo").and_then(|s| s.attr("name")).unwrap_or("").to_string();
-    if x.child("calculatedItems").is_some() || x.path(&["filters", "filter"]).is_some() {
-        cx.warn(format!("PivotTable \"{}\": calculated items and label/value filters are not supported", pt.name));
-    }
-
-    let mut filters: Vec<PivotFilter> = Vec::new();
-
-    // (fields, position of Σ Values (`-2`) among them)
-    let axis = |cx: &mut Ctx<'_>, list: &[i64], filters: &mut Vec<PivotFilter>| -> (Vec<PivotField>, Option<usize>) {
-        let mut v = Vec::new();
-        let mut values_at = None;
-        for &i in list {
-            if i == -2 {
-                values_at = Some(v.len());
-                continue;
-            }
-            if i < 0 {
-                continue;
-            }
-            let i = i as usize;
-            let Some((name, group)) = field_ref(cx, cache, i) else { continue };
-            let labels = cache.fields.get(i).map(|f| f.labels().to_vec()).unwrap_or_default();
-            let mut f = PivotField { source_col: name.clone(), date_group: group, sort: PivotSort::None, collapsed_items: vec![] };
-            if let Some(e) = pf(i) {
-                f.sort = match e.attr("sortType") {
-                    Some("ascending") => PivotSort::Asc,
-                    Some("descending") => PivotSort::Desc,
-                    _ => PivotSort::None,
-                };
-                let items = items_of(e);
-                let lab = |it: &El| it.attr_u32("x").and_then(|k| labels.get(k as usize)).cloned();
-                f.collapsed_items = items.iter().filter(|it| !it.flag("sd", true)).filter_map(|it| lab(it)).collect();
-                if items.iter().any(|it| it.flag("h", false)) {
-                    let shown: Vec<String> = items.iter().filter(|it| !it.flag("h", false)).filter_map(|it| lab(it)).collect();
-                    if !filters.iter().any(|ff| same(&ff.source_col, &name)) {
-                        filters.push(PivotFilter { source_col: name.clone(), selected: Some(shown) });
-                    }
-                }
-            }
-            v.push(f);
-        }
-        (v, values_at)
-    };
-    let mut page_filters = Vec::new();
-    for p in &pages {
-        let Some(i) = p.attr_i64("fld").filter(|i| *i >= 0).map(|i| i as usize) else { continue };
-        let Some((name, _)) = field_ref(cx, cache, i) else { continue };
-        let labels = cache.fields.get(i).map(|f| f.labels().to_vec()).unwrap_or_default();
-        let selected = if let Some(k) = p.attr_u32("item") {
-            labels.get(k as usize).map(|l| vec![l.clone()])
-        } else {
-            pf(i).and_then(|e| {
-                let items = items_of(e);
-                items.iter().any(|it| it.flag("h", false)).then(|| {
-                    items
-                        .iter()
-                        .filter(|it| !it.flag("h", false))
-                        .filter_map(|it| it.attr_u32("x").and_then(|k| labels.get(k as usize)).cloned())
-                        .collect()
-                })
-            })
-        };
-        page_filters.push(PivotFilter { source_col: name, selected });
-    }
-    let mut axis_filters = Vec::new();
-    let (rows, rows_values) = axis(cx, &row_x, &mut axis_filters);
-    let (columns, cols_values) = axis(cx, &col_x, &mut axis_filters);
-    pt.rows = rows;
-    pt.columns = columns;
-    // Σ Values: where its `-2` entry is, else `dataOnRows` and `dataPosition`; after the last
-    // field by default. In Columns it always comes last, as the column layout puts it there.
-    pt.values_on_rows = rows_values.is_some() || (cols_values.is_none() && x.flag("dataOnRows", false));
-    pt.values_position =
-        if pt.values_on_rows { rows_values.or_else(|| x.attr_u32("dataPosition").map(|p| p as usize)).filter(|p| *p < pt.rows.len()) } else { None };
-    filters.extend(page_filters);
-    filters.extend(axis_filters);
-    pt.filters = filters;
-
-    // Values.
-    if let Some(df) = x.child("dataFields") {
-        for d in df.kids("dataField") {
-            let Some(i) = d.attr_u32("fld").map(|i| i as usize) else { continue };
-            let Some(f) = cache.fields.get(i) else { continue };
-            let func = match d.attr("subtotal") {
-                None => PivotFunc::Sum,
-                Some(s) => func_from(s).unwrap_or_else(|| {
-                    cx.warn(format!("PivotTable function {s} is not supported; using Sum"));
-                    PivotFunc::Sum
-                }),
-            };
-            let ext = d
-                .child("extLst")
-                .into_iter()
-                .flat_map(|l| l.kids("ext"))
-                .filter_map(|e| e.child("dataField"))
-                .find_map(|e| e.attr("pivotShowAs").map(str::to_string));
-            let show_as = match (ext.as_deref(), d.attr("showDataAs")) {
-                (Some("rankDescending"), _) => PivotShowAs::Rank,
-                (Some(other), _) => {
-                    cx.warn(format!("PivotTable show-values-as {other} is not supported"));
-                    PivotShowAs::Normal
-                }
-                (None, None | Some("normal")) => PivotShowAs::Normal,
-                (None, Some("percentOfTotal")) => PivotShowAs::PercentOfGrandTotal,
-                (None, Some("percentOfCol")) => PivotShowAs::PercentOfColumnTotal,
-                (None, Some("percentOfRow")) => PivotShowAs::PercentOfRowTotal,
-                (None, Some("runTotal")) => PivotShowAs::RunningTotal,
-                (None, Some(other)) => {
-                    cx.warn(format!("PivotTable show-values-as {other} is not supported"));
-                    PivotShowAs::Normal
-                }
-            };
-            let number_format = d
-                .attr_u32("numFmtId")
-                .filter(|id| *id != 0)
-                .and_then(|id| crate::tables::builtin_format(id).map(str::to_string).or_else(|| cx.num_fmts.get(&id).cloned()));
-            let name = d.attr("name").map(str::to_string).unwrap_or_else(|| format!("{} of {}", func_caption(func), f.name));
-            pt.values.push(PivotValue { source_col: f.name.clone(), func, name, show_as, number_format });
-        }
-    }
-
-    // Calculated fields of the cache (each PivotTable on it can use them).
-    for f in &cache.fields {
-        if let Some(formula) = &f.formula
-            && !f.name.trim().is_empty()
-            && !pt.calculated_fields.iter().any(|c| same(&c.name, &f.name))
-        {
-            let formula = formula.trim();
-            let formula = if formula.starts_with('=') { formula.to_string() } else { format!("={formula}") };
-            pt.calculated_fields.push(PivotCalcField { name: f.name.clone(), formula });
-        }
-    }
-
-    pt.anchor = loc.start;
-    let above = if pages.is_empty() { 0 } else { pages.len() as u32 + 1 };
-    pt.last_range = Some(RangeRef::new(CellRef::new(loc.start.row.saturating_sub(above), loc.start.col), loc.end));
-    Some(pt)
-}
diff --git a/crates/xlsx/src/pivot/read.rs b/crates/xlsx/src/pivot/read.rs
new file mode 100644
index 000000000..f811533ab
--- /dev/null
+++ b/crates/xlsx/src/pivot/read.rs
@@ -0,0 +1,382 @@
+use super::*;
+
+// ================================================================ reading
+
+/// A cache field as read.
+#[derive(Clone, Debug, Default)]
+struct FieldIn {
+    name: String,
+    database: bool,
+    /// Shared item captions.
+    items: Vec<String>,
+    /// (base field, grouping, group item captions); grouping `None` = unsupported grouping.
+    group: Option<(Option<usize>, Option<PivotDateGroup>, Vec<String>)>,
+    /// A calculated field's formula.
+    formula: Option<String>,
+}
+
+impl FieldIn {
+    fn labels(&self) -> &[String] {
+        match &self.group {
+            Some((_, _, items)) if !items.is_empty() => items,
+            _ => &self.items,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct CacheIn {
+    source: String,
+    fields: Vec<FieldIn>,
+}
+
+/// Workbook-level pivot cache lookup, filled from `<pivotCaches>`; caches are parsed once.
+#[derive(Default)]
+pub struct CachesIn {
+    by_id: HashMap<u32, String>,
+    parsed: HashMap<String, Option<CacheIn>>,
+    next_id: u32,
+}
+
+impl CachesIn {
+    pub fn new(wb_xml: &El, wb_rels: &[crate::package::Rel]) -> CachesIn {
+        let mut by_id = HashMap::new();
+        if let Some(pc) = wb_xml.child("pivotCaches") {
+            for c in pc.kids("pivotCache") {
+                if let (Some(id), Some(rid)) = (c.attr_u32("cacheId"), c.attr("id"))
+                    && let Some(r) = wb_rels.iter().find(|r| r.id == rid)
+                {
+                    by_id.insert(id, r.target.clone());
+                }
+            }
+        }
+        CachesIn { by_id, parsed: HashMap::new(), next_id: 1 }
+    }
+}
+
+fn item_label_el(e: &El, sys: DateSystem) -> String {
+    let v = e.attr("v").unwrap_or("");
+    match e.name.as_str() {
+        "m" => "(blank)".into(),
+        "n" => v.trim().parse::<f64>().ok().filter(|n| n.is_finite()).map(number_to_text).unwrap_or_else(|| v.to_string()),
+        "b" => if matches!(v.trim(), "1" | "true") { "TRUE" } else { "FALSE" }.into(),
+        "d" => crate::sheet_read::parse_iso_datetime(v, sys).map(number_to_text).unwrap_or_else(|| v.to_string()),
+        _ => v.to_string(),
+    }
+}
+
+fn read_cache(cx: &mut Ctx<'_>, part: &str, sheet_name: &str) -> Option<CacheIn> {
+    let x = cx.optional_xml(part).ok().flatten()?;
+    if x.name != "pivotCacheDefinition" {
+        cx.warn(format!("{part} is not a pivot cache definition; its PivotTable was kept as plain cells"));
+        return None;
+    }
+    let src = x.child("cacheSource");
+    let ty = src.and_then(|s| s.attr("type")).unwrap_or("worksheet");
+    if ty != "worksheet" {
+        cx.warn(format!("PivotTables with a {ty} data source are not supported; kept as plain cells"));
+        return None;
+    }
+    let ws = src.and_then(|s| s.child("worksheetSource"));
+    let source = match ws {
+        Some(w) if w.attr("name").is_some_and(|n| !n.trim().is_empty()) => w.attr("name").unwrap_or("").trim().to_string(),
+        Some(w) => {
+            if w.attr("id").is_some() {
+                cx.warn("a PivotTable's source is in another workbook; its source reference may not resolve");
+            }
+            let r = w.attr("ref").map(|r| r.replace('$', "")).and_then(|r| RangeRef::parse(&r));
+            let Some(r) = r else {
+                cx.warn("a PivotTable's source reference is missing or invalid; kept as plain cells");
+                return None;
+            };
+            let sheet = w.attr("sheet").filter(|s| !s.is_empty()).unwrap_or(sheet_name);
+            format!("{}!{}", quote_sheet(sheet), abs_range(&r))
+        }
+        None => {
+            cx.warn("a PivotTable's cache has no worksheet source; kept as plain cells");
+            return None;
+        }
+    };
+    let sys = cx.date_system;
+    let mut fields = Vec::new();
+    if let Some(cf) = x.child("cacheFields") {
+        for f in cf.kids("cacheField").take(MAX_FIELDS) {
+            let items = f.child("sharedItems").map(|si| si.children.iter().map(|e| item_label_el(e, sys)).collect()).unwrap_or_default();
+            let group = f.child("fieldGroup").map(|g| {
+                let base = g.attr_u32("base").map(|b| b as usize);
+                let by = match g.child("rangePr").map(|r| r.attr("groupBy").unwrap_or("range")) {
+                    Some("years") => Some(PivotDateGroup::Years),
+                    Some("quarters") => Some(PivotDateGroup::Quarters),
+                    Some("months") => Some(PivotDateGroup::Months),
+                    Some("days") => Some(PivotDateGroup::Days),
+                    _ => None,
+                };
+                let gi = g.child("groupItems").map(|gi| gi.children.iter().map(|e| item_label_el(e, sys)).collect()).unwrap_or_default();
+                (base, by, gi)
+            });
+            fields.push(FieldIn {
+                name: f.attr("name").unwrap_or("").to_string(),
+                database: f.flag("databaseField", true),
+                items,
+                group,
+                formula: f.attr("formula").map(str::to_string),
+            });
+        }
+    }
+    if fields.is_empty() {
+        cx.warn("a PivotTable's cache has no fields; kept as plain cells");
+        return None;
+    }
+    Some(CacheIn { source, fields })
+}
+
+/// Reads the PivotTables related to a worksheet part.
+pub fn read_pivots(cx: &mut Ctx<'_>, caches: &mut CachesIn, sheet_part: &str, sheet_name: &str) -> Result<Vec<PivotTable>, IoError> {
+    let rels = cx.pkg.rels(sheet_part)?;
+    let mut out = Vec::new();
+    for rel in rels.iter().filter(|r| r.kind == "pivotTable" && !r.external) {
+        let Some(x) = cx.optional_xml(&rel.target)? else { continue };
+        if x.name != "pivotTableDefinition" {
+            cx.warn(format!("{} is not a PivotTable definition; skipped", rel.target));
+            continue;
+        }
+        // The cache: the table's own relationship, else the workbook's cache id.
+        let trels = cx.pkg.rels(&rel.target)?;
+        let cache_part = trels
+            .iter()
+            .find(|r| r.kind == "pivotCacheDefinition" && !r.external)
+            .map(|r| r.target.clone())
+            .or_else(|| x.attr_u32("cacheId").and_then(|id| caches.by_id.get(&id).cloned()));
+        let Some(cache_part) = cache_part else {
+            cx.warn(format!("PivotTable in {} has no cache; kept as plain cells", rel.target));
+            continue;
+        };
+        let cache = match caches.parsed.get(&cache_part) {
+            Some(c) => c.clone(),
+            None => {
+                let c = read_cache(cx, &cache_part, sheet_name);
+                caches.parsed.insert(cache_part.clone(), c.clone());
+                c
+            }
+        };
+        let Some(cache) = cache else { continue };
+        if let Some(pt) = read_table(cx, &x, &cache, caches.next_id) {
+            caches.next_id = caches.next_id.saturating_add(1);
+            out.push(pt);
+        }
+    }
+    Ok(out)
+}
+
+/// A pivot field's data items (not subtotal or grand-total items).
+fn items_of(e: &El) -> Vec<&El> {
+    e.child("items").map(|it| it.kids("item").filter(|i| i.attr("t").is_none_or(|t| t == "data")).collect()).unwrap_or_default()
+}
+
+/// (source column name, date grouping) of a cache field used on an axis.
+fn field_ref(cx: &mut Ctx<'_>, cache: &CacheIn, i: usize) -> Option<(String, PivotDateGroup)> {
+    let f = cache.fields.get(i)?;
+    if f.formula.is_some() {
+        cx.warn("calculated PivotTable fields are not supported");
+        return None;
+    }
+    match &f.group {
+        Some((base, by, _)) => {
+            let by = match by {
+                Some(b) => *b,
+                None => {
+                    cx.warn(format!("PivotTable grouping of \"{}\" is not supported; the field is ungrouped", f.name));
+                    PivotDateGroup::None
+                }
+            };
+            let base_name = if f.database { f.name.clone() } else { base.and_then(|b| cache.fields.get(b))?.name.clone() };
+            Some((base_name, by))
+        }
+        None if !f.database => {
+            cx.warn(format!("PivotTable field \"{}\" (grouped items) is not supported", f.name));
+            None
+        }
+        None => Some((f.name.clone(), PivotDateGroup::None)),
+    }
+}
+
+fn read_table(cx: &mut Ctx<'_>, x: &El, cache: &CacheIn, id: u32) -> Option<PivotTable> {
+    let mut pt = PivotTable { id, ..PivotTable::default() };
+    if let Some(n) = x.attr("name").filter(|n| !n.trim().is_empty()) {
+        pt.name = n.to_string();
+    } else {
+        pt.name = format!("PivotTable{id}");
+    }
+    pt.source = cache.source.clone();
+    let Some(loc) = x.child("location").and_then(|l| l.attr("ref")).and_then(|r| RangeRef::parse(&r.replace('$', ""))) else {
+        cx.warn(format!("PivotTable \"{}\" has no valid location; kept as plain cells", pt.name));
+        return None;
+    };
+    let pfs: Vec<&El> = x.child("pivotFields").map(|p| p.kids("pivotField").collect()).unwrap_or_default();
+    let pf = |i: usize| pfs.get(i).copied();
+    let idx_list = |name: &str, attr: &str| -> Vec<i64> {
+        x.child(name).map(|e| e.children.iter().filter_map(|f| f.attr_i64(attr)).collect()).unwrap_or_default()
+    };
+    let row_x = idx_list("rowFields", "x");
+    let col_x = idx_list("colFields", "x");
+    let pages: Vec<&El> = x.child("pageFields").map(|p| p.kids("pageField").collect()).unwrap_or_default();
+
+    // Layout from the first axis field (pivotField defaults: compact and outline on).
+    let first_axis = row_x.iter().chain(col_x.iter()).find(|i| **i >= 0).and_then(|i| pf(*i as usize));
+    let (compact, outline) = match first_axis {
+        Some(f) => (f.flag("compact", true), f.flag("outline", true)),
+        None => (x.flag("compact", true), x.flag("outline", false)),
+    };
+    pt.layout = if compact {
+        PivotLayout::Compact
+    } else if outline {
+        PivotLayout::Outline
+    } else {
+        PivotLayout::Tabular
+    };
+    if let Some(f) = first_axis {
+        pt.subtotals = f.flag("defaultSubtotal", true);
+        pt.subtotals_top = f.flag("subtotalTop", true);
+    }
+    pt.grand_totals_rows = x.flag("colGrandTotals", true);
+    pt.grand_totals_cols = x.flag("rowGrandTotals", true);
+    pt.show_headers = x.flag("showHeaders", true);
+    pt.enable_show_details = x.flag("enableDrill", true);
+    pt.style = x.child("pivotTableStyleInfo").and_then(|s| s.attr("name")).unwrap_or("").to_string();
+    if x.child("calculatedItems").is_some() || x.path(&["filters", "filter"]).is_some() {
+        cx.warn(format!("PivotTable \"{}\": calculated items and label/value filters are not supported", pt.name));
+    }
+
+    let mut filters: Vec<PivotFilter> = Vec::new();
+
+    // (fields, position of Σ Values (`-2`) among them)
+    let axis = |cx: &mut Ctx<'_>, list: &[i64], filters: &mut Vec<PivotFilter>| -> (Vec<PivotField>, Option<usize>) {
+        let mut v = Vec::new();
+        let mut values_at = None;
+        for &i in list {
+            if i == -2 {
+                values_at = Some(v.len());
+                continue;
+            }
+            if i < 0 {
+                continue;
+            }
+            let i = i as usize;
+            let Some((name, group)) = field_ref(cx, cache, i) else { continue };
+            let labels = cache.fields.get(i).map(|f| f.labels().to_vec()).unwrap_or_default();
+            let mut f = PivotField { source_col: name.clone(), date_group: group, sort: PivotSort::None, collapsed_items: vec![] };
+            if let Some(e) = pf(i) {
+                f.sort = match e.attr("sortType") {
+                    Some("ascending") => PivotSort::Asc,
+                    Some("descending") => PivotSort::Desc,
+                    _ => PivotSort::None,
+                };
+                let items = items_of(e);
+                let lab = |it: &El| it.attr_u32("x").and_then(|k| labels.get(k as usize)).cloned();
+                f.collapsed_items = items.iter().filter(|it| !it.flag("sd", true)).filter_map(|it| lab(it)).collect();
+                if items.iter().any(|it| it.flag("h", false)) {
+                    let shown: Vec<String> = items.iter().filter(|it| !it.flag("h", false)).filter_map(|it| lab(it)).collect();
+                    if !filters.iter().any(|ff| same(&ff.source_col, &name)) {
+                        filters.push(PivotFilter { source_col: name.clone(), selected: Some(shown) });
+                    }
+                }
+            }
+            v.push(f);
+        }
+        (v, values_at)
+    };
+    let mut page_filters = Vec::new();
+    for p in &pages {
+        let Some(i) = p.attr_i64("fld").filter(|i| *i >= 0).map(|i| i as usize) else { continue };
+        let Some((name, _)) = field_ref(cx, cache, i) else { continue };
+        let labels = cache.fields.get(i).map(|f| f.labels().to_vec()).unwrap_or_default();
+        let selected = if let Some(k) = p.attr_u32("item") {
+            labels.get(k as usize).map(|l| vec![l.clone()])
+        } else {
+            pf(i).and_then(|e| {
+                let items = items_of(e);
+                items.iter().any(|it| it.flag("h", false)).then(|| {
+                    items
+                        .iter()
+                        .filter(|it| !it.flag("h", false))
+                        .filter_map(|it| it.attr_u32("x").and_then(|k| labels.get(k as usize)).cloned())
+                        .collect()
+                })
+            })
+        };
+        page_filters.push(PivotFilter { source_col: name, selected });
+    }
+    let mut axis_filters = Vec::new();
+    let (rows, rows_values) = axis(cx, &row_x, &mut axis_filters);
+    let (columns, cols_values) = axis(cx, &col_x, &mut axis_filters);
+    pt.rows = rows;
+    pt.columns = columns;
+    // Σ Values: where its `-2` entry is, else `dataOnRows` and `dataPosition`; after the last
+    // field by default. In Columns it always comes last, as the column layout puts it there.
+    pt.values_on_rows = rows_values.is_some() || (cols_values.is_none() && x.flag("dataOnRows", false));
+    pt.values_position =
+        if pt.values_on_rows { rows_values.or_else(|| x.attr_u32("dataPosition").map(|p| p as usize)).filter(|p| *p < pt.rows.len()) } else { None };
+    filters.extend(page_filters);
+    filters.extend(axis_filters);
+    pt.filters = filters;
+
+    // Values.
+    if let Some(df) = x.child("dataFields") {
+        for d in df.kids("dataField") {
+            let Some(i) = d.attr_u32("fld").map(|i| i as usize) else { continue };
+            let Some(f) = cache.fields.get(i) else { continue };
+            let func = match d.attr("subtotal") {
+                None => PivotFunc::Sum,
+                Some(s) => func_from(s).unwrap_or_else(|| {
+                    cx.warn(format!("PivotTable function {s} is not supported; using Sum"));
+                    PivotFunc::Sum
+                }),
+            };
+            let ext = d
+                .child("extLst")
+                .into_iter()
+                .flat_map(|l| l.kids("ext"))
+                .filter_map(|e| e.child("dataField"))
+                .find_map(|e| e.attr("pivotShowAs").map(str::to_string));
+            let show_as = match (ext.as_deref(), d.attr("showDataAs")) {
+                (Some("rankDescending"), _) => PivotShowAs::Rank,
+                (Some(other), _) => {
+                    cx.warn(format!("PivotTable show-values-as {other} is not supported"));
+                    PivotShowAs::Normal
+                }
+                (None, None | Some("normal")) => PivotShowAs::Normal,
+                (None, Some("percentOfTotal")) => PivotShowAs::PercentOfGrandTotal,
+                (None, Some("percentOfCol")) => PivotShowAs::PercentOfColumnTotal,
+                (None, Some("percentOfRow")) => PivotShowAs::PercentOfRowTotal,
+                (None, Some("runTotal")) => PivotShowAs::RunningTotal,
+                (None, Some(other)) => {
+                    cx.warn(format!("PivotTable show-values-as {other} is not supported"));
+                    PivotShowAs::Normal
+                }
+            };
+            let number_format = d
+                .attr_u32("numFmtId")
+                .filter(|id| *id != 0)
+                .and_then(|id| crate::tables::builtin_format(id).map(str::to_string).or_else(|| cx.num_fmts.get(&id).cloned()));
+            let name = d.attr("name").map(str::to_string).unwrap_or_else(|| format!("{} of {}", func_caption(func), f.name));
+            pt.values.push(PivotValue { source_col: f.name.clone(), func, name, show_as, number_format });
+        }
+    }
+
+    // Calculated fields of the cache (each PivotTable on it can use them).
+    for f in &cache.fields {
+        if let Some(formula) = &f.formula
+            && !f.name.trim().is_empty()
+            && !pt.calculated_fields.iter().any(|c| same(&c.name, &f.name))
+        {
+            let formula = formula.trim();
+            let formula = if formula.starts_with('=') { formula.to_string() } else { format!("={formula}") };
+            pt.calculated_fields.push(PivotCalcField { name: f.name.clone(), formula });
+        }
+    }
+
+    pt.anchor = loc.start;
+    let above = if pages.is_empty() { 0 } else { pages.len() as u32 + 1 };
+    pt.last_range = Some(RangeRef::new(CellRef::new(loc.start.row.saturating_sub(above), loc.start.col), loc.end));
+    Some(pt)
+}
diff --git a/crates/xlsx/src/pivot/write.rs b/crates/xlsx/src/pivot/write.rs
new file mode 100644
index 000000000..44e0c386a
--- /dev/null
+++ b/crates/xlsx/src/pivot/write.rs
@@ -0,0 +1,876 @@
+use super::*;
+
+#[derive(Default)]
+struct Stats {
+    blank: bool,
+    text: bool,
+    number: bool,
+    non_int: bool,
+    boolean: bool,
+    error: bool,
+    long: bool,
+    min: f64,
+    max: f64,
+}
+
+impl Stats {
+    fn add(&mut self, v: &Value) {
+        match v {
+            Value::Empty => self.blank = true,
+            Value::Number(n) => {
+                if !self.number {
+                    self.min = *n;
+                    self.max = *n;
+                }
+                self.number = true;
+                self.min = self.min.min(*n);
+                self.max = self.max.max(*n);
+                if n.fract() != 0.0 {
+                    self.non_int = true;
+                }
+            }
+            Value::Text(t) => {
+                self.text = true;
+                if t.chars().count() > 255 {
+                    self.long = true;
+                }
+            }
+            Value::Bool(_) => self.boolean = true,
+            Value::Error(_) => self.error = true,
+            Value::Array(_) => self.add(&v.scalar()),
+        }
+    }
+    /// Excel counts booleans and errors as strings in the cache field flags.
+    fn strings(&self) -> bool {
+        self.text || self.boolean || self.error
+    }
+    /// Kinds for `containsMixedTypes`: strings (text, booleans, errors) and numbers.
+    fn kinds(&self) -> usize {
+        usize::from(self.strings()) + usize::from(self.number)
+    }
+}
+
+/// Date grouping of a cache field.
+struct Group {
+    by: PivotDateGroup,
+    /// The database field the grouping applies to.
+    base: usize,
+    /// The next (coarser) grouping field of the same base.
+    par: Option<usize>,
+    start: f64,
+    end: f64,
+    /// Group item captions, including the `<start` and `>end` items.
+    items: Vec<String>,
+}
+
+struct CField {
+    name: String,
+    /// Column offset in the source (database fields only).
+    col: Option<u32>,
+    stats: Stats,
+    /// Shared items (written when `itemized`).
+    items: Vec<Value>,
+    index: HashMap<Key, u32>,
+    itemized: bool,
+    group: Option<Group>,
+    /// A calculated field's formula (without `=`); such fields aren't database fields.
+    formula: Option<String>,
+}
+
+impl CField {
+    /// Item captions the PivotTable's `<item x>` indices refer to.
+    fn item_labels(&self) -> Vec<String> {
+        match &self.group {
+            Some(g) => g.items.clone(),
+            None => self.items.iter().map(label).collect(),
+        }
+    }
+}
+
+/// A cache built from a PivotTable's source.
+struct Cache {
+    fields: Vec<CField>,
+    /// Pivot field → cache field, by the pivot field's position in rows, then columns.
+    axis_map: Vec<Option<usize>>,
+    source_xml: String,
+    records: Option<(u64, String)>,
+}
+
+/// PivotTables being written; the tables themselves are finished after the styles part (their
+/// value number formats need style number-format ids).
+#[derive(Default)]
+pub struct PivotWriter {
+    /// (cache id, workbook-relative part name).
+    caches: Vec<(u32, String)>,
+    pending: Vec<Pending>,
+    tables: u32,
+}
+
+struct Pending {
+    part: String,
+    sheet: usize,
+    idx: usize,
+    cache_id: u32,
+    cache: Cache,
+}
+
+impl PivotWriter {
+    /// Writes the caches of a sheet's PivotTables and adds the sheet's relationships to its
+    /// PivotTable parts. Pivots whose source can't be resolved are not written.
+    pub fn add_sheet(&mut self, wb: &Workbook, si: usize, out: &mut Out, rels: &mut Rels) {
+        let Some(sheet) = wb.sheet(si) else { return };
+        for (idx, pt) in sheet.pivots.iter().enumerate() {
+            let Some(cache) = build_cache(wb, pt, si) else { continue };
+            let n = self.caches.len() as u32 + 1;
+            let cache_part = format!("xl/pivotCache/pivotCacheDefinition{n}.xml");
+            let rec_rid = if let Some((count, xml)) = &cache.records {
+                let mut r = Rels::default();
+                let rid = r.add("pivotCacheRecords", &format!("pivotCacheRecords{n}.xml"));
+                out.part(&format!("xl/pivotCache/_rels/pivotCacheDefinition{n}.xml.rels"), None, r.xml().into_bytes());
+                let s = format!("{XML_DECL}<pivotCacheRecords xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\" count=\"{count}\">{xml}</pivotCacheRecords>");
+                out.part(&format!("xl/pivotCache/pivotCacheRecords{n}.xml"), Some(CT_PIVOT_CACHE_REC), s.into_bytes());
+                Some(rid)
+            } else {
+                None
+            };
+            out.part(&cache_part, Some(CT_PIVOT_CACHE_DEF), cache_xml(&cache, rec_rid.as_deref(), wb.date_system).into_bytes());
+            self.caches.push((n, format!("pivotCache/pivotCacheDefinition{n}.xml")));
+            self.tables += 1;
+            let t = self.tables;
+            rels.add("pivotTable", &format!("../pivotTables/pivotTable{t}.xml"));
+            let mut tr = Rels::default();
+            tr.add("pivotCacheDefinition", &format!("../pivotCache/pivotCacheDefinition{n}.xml"));
+            out.part(&format!("xl/pivotTables/_rels/pivotTable{t}.xml.rels"), None, tr.xml().into_bytes());
+            self.pending.push(Pending { part: format!("xl/pivotTables/pivotTable{t}.xml"), sheet: si, idx, cache_id: n, cache });
+        }
+    }
+
+    /// Adds the workbook relationships to the caches; returns the `<pivotCaches>` element (empty
+    /// when there are none).
+    pub fn workbook_xml(&self, wb_rels: &mut Rels) -> String {
+        if self.caches.is_empty() {
+            return String::new();
+        }
+        let mut s = String::from("<pivotCaches>");
+        for (id, target) in &self.caches {
+            let rid = wb_rels.add("pivotCacheDefinition", target);
+            let _ = write!(s, "<pivotCache cacheId=\"{id}\" r:id=\"{rid}\"/>");
+        }
+        s.push_str("</pivotCaches>");
+        s
+    }
+
+    /// Number formats used by value fields (to be registered in the styles part).
+    pub fn number_formats(&self, wb: &Workbook) -> Vec<String> {
+        let mut v = Vec::new();
+        for p in &self.pending {
+            if let Some(pt) = wb.sheet(p.sheet).and_then(|s| s.pivots.get(p.idx)) {
+                for val in &pt.values {
+                    if let Some(f) = &val.number_format
+                        && !v.contains(f)
+                    {
+                        v.push(f.clone());
+                    }
+                }
+            }
+        }
+        v
+    }
+
+    /// Writes the PivotTable parts. `fmt_id` maps a number format code to its styles id.
+    pub fn finish(self, wb: &Workbook, out: &mut Out, fmt_id: &dyn Fn(&str) -> Option<u32>) {
+        for p in self.pending {
+            let Some(pt) = wb.sheet(p.sheet).and_then(|s| s.pivots.get(p.idx)) else { continue };
+            let xml = table_xml(pt, p.idx, p.cache_id, &p.cache, fmt_id);
+            out.part(&p.part, Some(CT_PIVOT_TABLE), xml.into_bytes());
+        }
+    }
+}
+
+/// Resolves a pivot source to (sheet, range including the header row, worksheetSource XML).
+fn resolve_source(wb: &Workbook, text: &str, default_sheet: usize, depth: u32) -> Option<(usize, RangeRef, String)> {
+    let t = text.trim().trim_start_matches('=').trim();
+    if t.is_empty() || depth > 4 {
+        return None;
+    }
+    if let Some((si, ti)) = wb.table(t)
+        && let Some(sh) = wb.sheet(si)
+        && let Some(tb) = sh.tables.get(ti)
+    {
+        if !tb.header_row {
+            return None;
+        }
+        let end_row = tb.range.end.row.saturating_sub(tb.totals_row as u32).max(tb.range.start.row);
+        let r = RangeRef::new(tb.range.start, CellRef::new(end_row, tb.range.end.col));
+        // Table names are sanitized when written; refer by range when this one would change.
+        let valid = !tb.name.is_empty()
+            && tb.name.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '.')
+            && tb.name.starts_with(|c: char| c.is_alphabetic() || c == '_')
+            && CellRef::parse(&tb.name).is_none();
+        let xml = if valid { format!("<worksheetSource name=\"{}\"/>", esc_attr(&tb.name)) } else { range_source_xml(&sh.name, r) };
+        return Some((si, r, xml));
+    }
+    let (sheet, body) = gridcraft_core::split_sheet(t);
+    if let Some(r) = RangeRef::parse(body) {
+        let si = match &sheet {
+            Some(n) => wb.sheet_index(n)?,
+            None => default_sheet,
+        };
+        let sh = wb.sheet(si)?;
+        let r = if r.is_full_cols() || r.is_full_rows() { r.intersection(&sh.used_range()?)? } else { r };
+        return Some((si, r, range_source_xml(&sh.name, r)));
+    }
+    if sheet.is_none()
+        && let Some(n) = wb.name(t, default_sheet)
+    {
+        let (si, r, _) = resolve_source(wb, &n.formula.clone(), default_sheet, depth + 1)?;
+        let xml = if n.scope.is_none() {
+            format!("<worksheetSource name=\"{}\"/>", esc_attr(&n.name))
+        } else {
+            wb.sheet(si).map(|s| range_source_xml(&s.name, r))?
+        };
+        return Some((si, r, xml));
+    }
+    None
+}
+
+fn range_source_xml(sheet: &str, r: RangeRef) -> String {
+    let name: String = sheet.chars().take(31).collect();
+    format!("<worksheetSource ref=\"{}\" sheet=\"{}\"/>", r.a1(), esc_attr(&name))
+}
+
+fn header_text(v: &Value) -> String {
+    match v {
+        Value::Empty => String::new(),
+        v => label(v).trim().to_string(),
+    }
+}
+
+fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cache> {
+    let (si, r, source_xml) = resolve_source(wb, &pt.source, pivot_sheet, 0)?;
+    if r.count() > MAX_SOURCE_CELLS {
+        return None;
+    }
+    let sh = wb.sheet(si)?;
+    let mut fields: Vec<CField> = Vec::new();
+    // Lower-case names taken, and the next suffix for each header (linear for repeated headers).
+    let mut taken = std::collections::HashSet::new();
+    let mut next_suffix: HashMap<String, usize> = HashMap::new();
+    for (k, c) in (r.start.col..=r.end.col).enumerate() {
+        let mut h = header_text(&sh.value(CellRef::new(r.start.row, c)).scalar());
+        if h.is_empty() {
+            h = format!("Column{}", k + 1);
+        }
+        let mut n = h.clone();
+        let mut i = next_suffix.get(&h.to_lowercase()).copied().unwrap_or(2);
+        while taken.contains(&n.to_lowercase()) {
+            n = format!("{h}{i}");
+            i += 1;
+        }
+        next_suffix.insert(h.to_lowercase(), i);
+        taken.insert(n.to_lowercase());
+        fields.push(CField {
+            name: n,
+            col: Some(k as u32),
+            stats: Stats::default(),
+            items: vec![],
+            index: HashMap::new(),
+            itemized: false,
+            group: None,
+            formula: None,
+        });
+    }
+    let find = |fields: &[CField], name: &str| fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
+
+    // Records (rows that aren't entirely blank), read once.
+    let mut rows: Vec<u32> = Vec::new();
+    if r.end.row > r.start.row {
+        for row in r.start.row + 1..=r.end.row {
+            let blank = (r.start.col..=r.end.col).all(|c| sh.value(CellRef::new(row, c)).scalar().is_empty());
+            if !blank {
+                rows.push(row);
+            }
+        }
+    }
+    for &row in &rows {
+        for f in fields.iter_mut() {
+            let c = r.start.col + f.col.unwrap_or(0);
+            f.stats.add(&sh.value(CellRef::new(row, c)).scalar());
+        }
+    }
+
+    // Which fields are on an axis, and how dates are grouped: per base column, the base field
+    // takes the finest grouping and coarser ones become extra (non-database) fields chained
+    // through `par`, as Excel lays them out.
+    let axis: Vec<&PivotField> = pt.rows.iter().chain(pt.columns.iter()).collect();
+    let groupable = |f: &CField| {
+        let s = &f.stats;
+        s.number
+            && !s.text
+            && !s.boolean
+            && !s.error
+            && datetime_from_serial(wb.date_system, s.min).is_some()
+            && datetime_from_serial(wb.date_system, s.max).is_some()
+    };
+    // (base column field, groupings fine → coarse)
+    let mut groupings: Vec<(usize, Vec<PivotDateGroup>)> = Vec::new();
+    for pf in &axis {
+        let Some(b) = find(&fields, &pf.source_col) else { continue };
+        if pf.date_group == PivotDateGroup::None || !fields.get(b).is_some_and(groupable) {
+            continue;
+        }
+        match groupings.iter_mut().find(|(x, _)| *x == b) {
+            Some((_, v)) => {
+                if !v.contains(&pf.date_group) {
+                    v.push(pf.date_group);
+                }
+            }
+            None => groupings.push((b, vec![pf.date_group])),
+        }
+    }
+    let fineness = |g: &PivotDateGroup| match g {
+        PivotDateGroup::Days => 0,
+        PivotDateGroup::Months => 1,
+        PivotDateGroup::Quarters => 2,
+        PivotDateGroup::Years => 3,
+        PivotDateGroup::None => 4,
+    };
+    for (b, list) in groupings.iter_mut() {
+        list.sort_by_key(fineness);
+        let (min, max) = fields.get(*b).map(|f| (f.stats.min, f.stats.max)).unwrap_or((0.0, 0.0));
+        let (start, end) = (min.floor(), max.floor() + 1.0);
+        let make = |by: PivotDateGroup| Group { by, base: *b, par: None, start, end, items: group_items(wb.date_system, by, start, end) };
+        let mut prev = *b;
+        for (k, by) in list.iter().enumerate() {
+            if k == 0 {
+                if let Some(f) = fields.get_mut(*b) {
+                    f.group = Some(make(*by));
+                }
+                continue;
+            }
+            let new = fields.len();
+            let caption = group_caption(*by);
+            let mut n = caption.to_string();
+            let mut i = 2;
+            while fields.iter().any(|f| same(&f.name, &n)) {
+                n = format!("{caption}{i}");
+                i += 1;
+            }
+            if let Some(g) = fields.get_mut(prev).and_then(|f| f.group.as_mut()) {
+                g.par = Some(new);
+            }
+            fields.push(CField {
+                name: n,
+                col: None,
+                stats: Stats::default(),
+                items: vec![],
+                index: HashMap::new(),
+                itemized: false,
+                group: Some(make(*by)),
+                formula: None,
+            });
+            prev = new;
+        }
+    }
+    let mut axis_map: Vec<Option<usize>> = Vec::with_capacity(axis.len());
+    for pf in &axis {
+        let Some(b) = find(&fields, &pf.source_col) else {
+            axis_map.push(None);
+            continue;
+        };
+        let grouped = fields.iter().position(|f| f.group.as_ref().is_some_and(|g| g.base == b && g.by == pf.date_group));
+        match grouped {
+            Some(i) if pf.date_group != PivotDateGroup::None => axis_map.push(Some(i)),
+            _ => {
+                if let Some(f) = fields.get_mut(b)
+                    && f.group.is_none()
+                {
+                    f.itemized = true;
+                }
+                axis_map.push(Some(b));
+            }
+        }
+    }
+    // Page fields (filters not on an axis) need items too.
+    for f in &pt.filters {
+        let on_axis = axis.iter().any(|a| same(&a.source_col, &f.source_col));
+        if !on_axis
+            && let Some(i) = find(&fields, &f.source_col)
+            && let Some(cf) = fields.get_mut(i)
+        {
+            cf.itemized = true;
+        }
+    }
+    for f in fields.iter_mut() {
+        if f.group.is_some() {
+            f.itemized = false;
+        } else if f.col.is_some() && (f.stats.text || f.stats.boolean || f.stats.error) {
+            f.itemized = true;
+        }
+    }
+    // Shared items, in order of first appearance.
+    for &row in &rows {
+        for f in fields.iter_mut().filter(|f| f.itemized) {
+            let c = r.start.col + f.col.unwrap_or(0);
+            let v = sh.value(CellRef::new(row, c)).scalar();
+            let k = key(&v);
+            if !f.index.contains_key(&k) && f.items.len() < MAX_ITEMS {
+                f.index.insert(k, f.items.len() as u32);
+                f.items.push(v);
+            }
+        }
+    }
+    // Records snapshot.
+    let db_fields = fields.iter().filter(|f| f.col.is_some()).count() as u64;
+    let records = if (rows.len() as u64).saturating_mul(db_fields) <= MAX_RECORD_CELLS {
+        let mut s = String::new();
+        for &row in &rows {
+            s.push_str("<r>");
+            for f in fields.iter().filter(|f| f.col.is_some()) {
+                let c = r.start.col + f.col.unwrap_or(0);
+                let v = sh.value(CellRef::new(row, c)).scalar();
+                if f.itemized {
+                    match f.index.get(&key(&v)) {
+                        Some(i) => {
+                            let _ = write!(s, "<x v=\"{i}\"/>");
+                        }
+                        None => s.push_str(&item_xml(&v, wb.date_system, false)),
+                    }
+                } else {
+                    s.push_str(&item_xml(&v, wb.date_system, f.group.is_some()));
+                }
+            }
+            s.push_str("</r>");
+        }
+        Some((rows.len() as u64, s))
+    } else {
+        None
+    };
+    // Calculated fields come after the database and grouping fields.
+    for cf in &pt.calculated_fields {
+        let f = cf.formula.trim();
+        let f = f.strip_prefix('=').unwrap_or(f).trim();
+        if cf.name.trim().is_empty() || f.is_empty() || fields.iter().any(|x| same(&x.name, &cf.name)) {
+            continue;
+        }
+        fields.push(CField {
+            name: cf.name.clone(),
+            col: None,
+            stats: Stats::default(),
+            items: vec![],
+            index: HashMap::new(),
+            itemized: false,
+            group: None,
+            formula: Some(f.to_string()),
+        });
+    }
+    Some(Cache { fields, axis_map, source_xml, records })
+}
+
+fn group_items(sys: DateSystem, by: PivotDateGroup, start: f64, end: f64) -> Vec<String> {
+    let mut v = vec![format!("<{}", mdy(sys, start))];
+    match by {
+        PivotDateGroup::Years => {
+            let y0 = datetime_from_serial(sys, start).map(|d| d.year).unwrap_or(1900);
+            let y1 = datetime_from_serial(sys, end - 1.0).map(|d| d.year).unwrap_or(y0).max(y0);
+            for y in y0..=y1.min(y0 + 10_000) {
+                v.push(y.to_string());
+            }
+        }
+        PivotDateGroup::Quarters => v.extend((1..=4).map(|q| format!("Qtr{q}"))),
+        PivotDateGroup::Months => v.extend(MONTHS.iter().map(ToString::to_string)),
+        PivotDateGroup::Days | PivotDateGroup::None => {
+            const DAYS: [u32; 12] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+            for (m, n) in MONTHS.iter().zip(DAYS) {
+                for d in 1..=n {
+                    v.push(format!("{d}-{m}"));
+                }
+            }
+        }
+    }
+    v.push(format!(">{}", mdy(sys, end)));
+    v
+}
+
+/// A cache value element (`<n>`, `<s>`, `<m>`…); `date` writes numbers as `<d>`.
+fn item_xml(v: &Value, sys: DateSystem, date: bool) -> String {
+    match v {
+        Value::Empty => "<m/>".into(),
+        Value::Number(n) => {
+            if date && let Some(d) = iso(sys, *n) {
+                return format!("<d v=\"{d}\"/>");
+            }
+            format!("<n v=\"{}\"/>", crate::xml::num(*n))
+        }
+        Value::Text(t) => format!("<s v=\"{}\"/>", esc_attr(t)),
+        Value::Bool(b) => format!("<b v=\"{}\"/>", u8::from(*b)),
+        Value::Error(e) => format!("<e v=\"{}\"/>", esc_attr(e.as_str())),
+        Value::Array(_) => item_xml(&v.scalar(), sys, date),
+    }
+}
+
+fn cache_xml(c: &Cache, records_rid: Option<&str>, sys: DateSystem) -> String {
+    let mut s = format!("{XML_DECL}<pivotCacheDefinition xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\"");
+    match (records_rid, &c.records) {
+        (Some(rid), Some((count, _))) => {
+            let _ = write!(s, " r:id=\"{rid}\" recordCount=\"{count}\"");
+        }
+        _ => s.push_str(" saveData=\"0\""),
+    }
+    s.push_str(" refreshOnLoad=\"1\" refreshedBy=\"GridCraft\" createdVersion=\"6\" refreshedVersion=\"6\" minRefreshableVersion=\"3\">");
+    let _ = write!(s, "<cacheSource type=\"worksheet\">{}</cacheSource>", c.source_xml);
+    let _ = write!(s, "<cacheFields count=\"{}\">", c.fields.len());
+    for f in &c.fields {
+        let fmt = if f.group.is_some() { 14 } else { 0 };
+        let _ = write!(s, "<cacheField name=\"{}\" numFmtId=\"{fmt}\"", esc_attr(&f.name));
+        if let Some(formula) = &f.formula {
+            let _ = write!(s, " formula=\"{}\"", esc_attr(formula));
+        }
+        if f.col.is_none() {
+            s.push_str(" databaseField=\"0\"");
+        }
+        s.push('>');
+        let st = &f.stats;
+        if f.col.is_some() {
+            s.push_str("<sharedItems");
+            if let Some(g) = &f.group {
+                s.push_str(" containsSemiMixedTypes=\"0\" containsNonDate=\"0\" containsDate=\"1\" containsString=\"0\"");
+                if st.blank {
+                    s.push_str(" containsBlank=\"1\"");
+                }
+                if let (Some(a), Some(b)) = (iso(sys, st.min), iso(sys, st.max)) {
+                    let _ = write!(s, " minDate=\"{a}\" maxDate=\"{b}\"");
+                }
+                let _ = g;
+            } else {
+                if !st.strings() && !st.blank {
+                    s.push_str(" containsSemiMixedTypes=\"0\"");
+                }
+                if !st.strings() {
+                    s.push_str(" containsString=\"0\"");
+                }
+                if st.blank {
+                    s.push_str(" containsBlank=\"1\"");
+                }
+                if st.kinds() > 1 {
+                    s.push_str(" containsMixedTypes=\"1\"");
+                }
+                if st.number {
+                    s.push_str(" containsNumber=\"1\"");
+                    if !st.non_int {
+                        s.push_str(" containsInteger=\"1\"");
+                    }
+                    let _ = write!(s, " minValue=\"{}\" maxValue=\"{}\"", crate::xml::num(st.min), crate::xml::num(st.max));
+                }
+                if st.long {
+                    s.push_str(" longText=\"1\"");
+                }
+            }
+            if f.itemized {
+                let _ = write!(s, " count=\"{}\">", f.items.len());
+                for v in &f.items {
+                    s.push_str(&item_xml(v, sys, false));
+                }
+                s.push_str("</sharedItems>");
+            } else {
+                s.push_str("/>");
+            }
+        }
+        if let Some(g) = &f.group {
+            s.push_str("<fieldGroup");
+            if let Some(p) = g.par {
+                let _ = write!(s, " par=\"{p}\"");
+            }
+            let _ = write!(s, " base=\"{}\">", g.base);
+            let _ = write!(s, "<rangePr groupBy=\"{}\"", group_by_name(g.by));
+            if let (Some(a), Some(b)) = (iso(sys, g.start), iso(sys, g.end)) {
+                let _ = write!(s, " startDate=\"{a}\" endDate=\"{b}\"");
+            }
+            let _ = write!(s, "/><groupItems count=\"{}\">", g.items.len());
+            for it in &g.items {
+                let _ = write!(s, "<s v=\"{}\"/>", esc_attr(it));
+            }
+            s.push_str("</groupItems></fieldGroup>");
+        }
+        s.push_str("</cacheField>");
+    }
+    s.push_str("</cacheFields></pivotCacheDefinition>");
+    s
+}
+
+fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn Fn(&str) -> Option<u32>) -> String {
+    let nf = c.fields.len();
+    let find_db = |name: &str| c.fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
+    let row_idx: Vec<usize> = c.axis_map.iter().take(pt.rows.len()).filter_map(|x| *x).collect();
+    let col_idx: Vec<usize> = c.axis_map.iter().skip(pt.rows.len()).filter_map(|x| *x).collect();
+    // Filters: on an axis field → hidden items there; otherwise a page field.
+    let mut hidden: HashMap<usize, &PivotFilter> = HashMap::new();
+    let mut pages: Vec<(usize, &PivotFilter)> = Vec::new();
+    for f in &pt.filters {
+        let axis_pos = pt.rows.iter().chain(pt.columns.iter()).position(|a| same(&a.source_col, &f.source_col));
+        match axis_pos {
+            Some(p) => {
+                if let Some(Some(i)) = c.axis_map.get(p) {
+                    hidden.insert(*i, f);
+                }
+            }
+            None => {
+                if let Some(i) = find_db(&f.source_col)
+                    && !pages.iter().any(|(j, _)| *j == i)
+                {
+                    pages.push((i, f));
+                    hidden.insert(i, f);
+                }
+            }
+        }
+    }
+    let find_calc = |name: &str| c.fields.iter().position(|f| f.formula.is_some() && same(&f.name, name));
+    let vals: Vec<(usize, &PivotValue)> =
+        pt.values.iter().filter_map(|v| find_db(&v.source_col).or_else(|| find_calc(&v.source_col)).map(|i| (i, v))).collect();
+    let axis_field = |i: usize| -> Option<&PivotField> {
+        let p = c.axis_map.iter().position(|x| *x == Some(i))?;
+        pt.rows.iter().chain(pt.columns.iter()).nth(p)
+    };
+
+    let compact = pt.layout == PivotLayout::Compact;
+    let name = if pt.name.trim().is_empty() { format!("PivotTable{}", idx + 1) } else { pt.name.clone() };
+    let mut s = format!(
+        "{XML_DECL}<pivotTableDefinition xmlns=\"{NS_MAIN}\" name=\"{}\" cacheId=\"{cache_id}\" applyNumberFormats=\"0\" applyBorderFormats=\"0\" applyFontFormats=\"0\" applyPatternFormats=\"0\" applyAlignmentFormats=\"0\" applyWidthHeightFormats=\"1\" dataCaption=\"Values\" updatedVersion=\"6\" minRefreshableVersion=\"3\" useAutoFormatting=\"1\" itemPrintTitles=\"1\" createdVersion=\"6\" indent=\"0\"",
+        esc_attr(&name)
+    );
+    match pt.layout {
+        PivotLayout::Compact => s.push_str(" outline=\"1\" outlineData=\"1\""),
+        PivotLayout::Outline => s.push_str(" compact=\"0\" compactData=\"0\" outline=\"1\" outlineData=\"1\""),
+        PivotLayout::Tabular => s.push_str(" compact=\"0\" compactData=\"0\""),
+    }
+    if pt.values_on_rows {
+        s.push_str(" dataOnRows=\"1\"");
+    }
+    if !pt.show_headers {
+        s.push_str(" showHeaders=\"0\"");
+    }
+    if !pt.enable_show_details {
+        s.push_str(" enableDrill=\"0\"");
+    }
+    // `rowGrandTotals` is the grand total row below the report (Excel's "On for Columns"),
+    // `colGrandTotals` the grand total column at its right ("On for Rows").
+    if !pt.grand_totals_cols {
+        s.push_str(" rowGrandTotals=\"0\"");
+    }
+    if !pt.grand_totals_rows {
+        s.push_str(" colGrandTotals=\"0\"");
+    }
+    s.push_str(" multipleFieldFilters=\"0\">");
+
+    // Location: the body (report filters sit above it).
+    let a = pt.anchor;
+    let end = pt.last_range.map(|r| r.end).unwrap_or(a);
+    let loc = RangeRef::new(a, CellRef::new(end.row.max(a.row), end.col.max(a.col)));
+    let k = vals.len();
+    // Σ Values (two or more value fields): its index among the written fields of its axis.
+    let (row_map, _) = c.axis_map.split_at(pt.rows.len().min(c.axis_map.len()));
+    let values_at = |map: &[Option<usize>], n: usize| pt.values_position.map_or(n, |p| map.iter().take(p).filter(|x| x.is_some()).count());
+    let row_values = (k > 1 && pt.values_on_rows).then(|| values_at(row_map, row_idx.len()));
+    // In Columns Σ Values comes after the last field: the column layout doesn't place it elsewhere.
+    let col_values = (k > 1 && !pt.values_on_rows).then_some(col_idx.len());
+    let first_data_row = if col_idx.is_empty() { 1 } else { 1 + col_idx.len() + usize::from(col_values.is_some()) };
+    let row_levels = row_idx.len() + usize::from(row_values.is_some());
+    let first_data_col = if row_levels == 0 && col_idx.is_empty() {
+        0
+    } else if compact {
+        1
+    } else {
+        row_levels.max(1)
+    };
+    // Two or more value fields in Columns alone: Excel 365 would add a `Values` caption row.
+    let hide_values_row = col_values.is_some() && col_idx.is_empty();
+    let first_header_row = usize::from(!hide_values_row);
+    let _ = write!(
+        s,
+        "<location ref=\"{}\" firstHeaderRow=\"{first_header_row}\" firstDataRow=\"{first_data_row}\" firstDataCol=\"{first_data_col}\"",
+        loc.a1()
+    );
+    if !pages.is_empty() {
+        let _ = write!(s, " rowPageCount=\"{}\" colPageCount=\"1\"", pages.len());
+    }
+    s.push_str("/>");
+
+    // Fields.
+    let _ = write!(s, "<pivotFields count=\"{nf}\">");
+    for (i, f) in c.fields.iter().enumerate() {
+        s.push_str("<pivotField");
+        let axis = if row_idx.contains(&i) {
+            Some("axisRow")
+        } else if col_idx.contains(&i) {
+            Some("axisCol")
+        } else if pages.iter().any(|(j, _)| *j == i) {
+            Some("axisPage")
+        } else {
+            None
+        };
+        if let Some(ax) = axis {
+            let _ = write!(s, " axis=\"{ax}\"");
+        }
+        if vals.iter().any(|(j, _)| *j == i) {
+            s.push_str(" dataField=\"1\"");
+        }
+        if f.formula.is_some() {
+            s.push_str(" dragToRow=\"0\" dragToCol=\"0\" dragToPage=\"0\"");
+        }
+        match pt.layout {
+            PivotLayout::Compact => {}
+            PivotLayout::Outline => s.push_str(" compact=\"0\""),
+            PivotLayout::Tabular => s.push_str(" compact=\"0\" outline=\"0\""),
+        }
+        if f.group.is_some() {
+            s.push_str(" numFmtId=\"14\"");
+        }
+        let filter = hidden.get(&i).copied();
+        let labels = f.item_labels();
+        let is_page = axis == Some("axisPage");
+        // Hidden items; never hide every item (a field needs one visible item).
+        let mut hide: Vec<bool> = match filter.and_then(|f| f.selected.as_ref()) {
+            Some(sel) if !(is_page && sel.len() == 1) => labels.iter().map(|l| !sel.iter().any(|x| same(x, l))).collect(),
+            _ => vec![false; labels.len()],
+        };
+        if !hide.is_empty() && hide.iter().all(|h| *h) {
+            hide.iter_mut().for_each(|h| *h = false);
+        }
+        if is_page && hide.iter().any(|h| *h) {
+            s.push_str(" multipleItemSelectionAllowed=\"1\"");
+        }
+        s.push_str(" showAll=\"0\"");
+        if let Some(af) = axis_field(i) {
+            match af.sort {
+                PivotSort::Asc => s.push_str(" sortType=\"ascending\""),
+                PivotSort::Desc => s.push_str(" sortType=\"descending\""),
+                PivotSort::None => {}
+            }
+        }
+        if !pt.subtotals {
+            s.push_str(" defaultSubtotal=\"0\"");
+        }
+        if !pt.subtotals_top {
+            s.push_str(" subtotalTop=\"0\"");
+        }
+        if axis.is_some() {
+            let collapsed: &[String] = axis_field(i).map(|f| f.collapsed_items.as_slice()).unwrap_or(&[]);
+            let count = labels.len() + usize::from(pt.subtotals);
+            let _ = write!(s, "><items count=\"{count}\">");
+            for (x, l) in labels.iter().enumerate() {
+                let _ = write!(s, "<item x=\"{x}\"");
+                if hide.get(x).copied().unwrap_or(false) {
+                    s.push_str(" h=\"1\"");
+                }
+                if collapsed.iter().any(|cl| same(cl, l)) {
+                    s.push_str(" sd=\"0\"");
+                }
+                s.push_str("/>");
+            }
+            if pt.subtotals {
+                s.push_str("<item t=\"default\"/>");
+            }
+            s.push_str("</items></pivotField>");
+        } else {
+            s.push_str("/>");
+        }
+    }
+    s.push_str("</pivotFields>");
+
+    axis_fields_xml(&mut s, "rowFields", &row_idx, row_values);
+    axis_fields_xml(&mut s, "colFields", &col_idx, col_values);
+    if !pages.is_empty() {
+        let _ = write!(s, "<pageFields count=\"{}\">", pages.len());
+        for (i, f) in &pages {
+            let _ = write!(s, "<pageField fld=\"{i}\"");
+            if let Some(sel) = &f.selected
+                && sel.len() == 1
+                && let Some(one) = sel.first()
+                && let Some(x) = c.fields.get(*i).and_then(|cf| cf.item_labels().iter().position(|l| same(l, one)))
+            {
+                let _ = write!(s, " item=\"{x}\"");
+            }
+            s.push_str(" hier=\"-1\"/>");
+        }
+        s.push_str("</pageFields>");
+    }
+    if !vals.is_empty() {
+        let _ = write!(s, "<dataFields count=\"{k}\">");
+        let mut used: Vec<String> = Vec::new();
+        for (i, v) in &vals {
+            let base = if v.name.trim().is_empty() {
+                format!("{} of {}", func_caption(v.func), c.fields.get(*i).map(|f| f.name.as_str()).unwrap_or(""))
+            } else {
+                v.name.clone()
+            };
+            let mut n = base.clone();
+            let mut j = 2;
+            while used.iter().any(|u| same(u, &n)) {
+                n = format!("{base}{j}");
+                j += 1;
+            }
+            used.push(n.clone());
+            let _ = write!(s, "<dataField name=\"{}\" fld=\"{i}\"", esc_attr(&n));
+            if v.func != PivotFunc::Sum {
+                let _ = write!(s, " subtotal=\"{}\"", func_name(v.func));
+            }
+            let base_field = row_idx.first().or(col_idx.first()).copied().unwrap_or(0);
+            match v.show_as {
+                PivotShowAs::Normal => s.push_str(" baseField=\"0\" baseItem=\"0\""),
+                PivotShowAs::PercentOfGrandTotal => s.push_str(" showDataAs=\"percentOfTotal\" baseField=\"0\" baseItem=\"0\""),
+                PivotShowAs::PercentOfColumnTotal => s.push_str(" showDataAs=\"percentOfCol\" baseField=\"0\" baseItem=\"0\""),
+                PivotShowAs::PercentOfRowTotal => s.push_str(" showDataAs=\"percentOfRow\" baseField=\"0\" baseItem=\"0\""),
+                PivotShowAs::RunningTotal => {
+                    let _ = write!(s, " showDataAs=\"runTotal\" baseField=\"{base_field}\" baseItem=\"0\"");
+                }
+                PivotShowAs::Rank => {
+                    let _ = write!(s, " baseField=\"{base_field}\" baseItem=\"0\"");
+                }
+            }
+            if let Some(id) = v.number_format.as_deref().and_then(fmt_id) {
+                let _ = write!(s, " numFmtId=\"{id}\"");
+            }
+            if v.show_as == PivotShowAs::Rank {
+                let _ = write!(
+                    s,
+                    "><extLst><ext uri=\"{EXT_X14_DATA_FIELD}\" xmlns:x14=\"{NS_X14}\"><x14:dataField pivotShowAs=\"rankDescending\"/></ext></extLst></dataField>"
+                );
+            } else {
+                s.push_str("/>");
+            }
+        }
+        s.push_str("</dataFields>");
+    }
+    s.push_str("<pivotTableStyleInfo");
+    if !pt.style.is_empty() {
+        let _ = write!(s, " name=\"{}\"", esc_attr(&pt.style));
+    }
+    s.push_str(" showRowHeaders=\"1\" showColHeaders=\"1\" showRowStripes=\"0\" showColStripes=\"0\" showLastColumn=\"1\"/>");
+    if hide_values_row {
+        let _ = write!(
+            s,
+            "<extLst><ext uri=\"{EXT_X14_PIVOT_TABLE}\" xmlns:x14=\"{NS_X14}\"><x14:pivotTableDefinition hideValuesRow=\"1\"/></ext></extLst>"
+        );
+    }
+    s.push_str("</pivotTableDefinition>");
+    s
+}
+
+/// `<rowFields>`/`<colFields>`: the axis's cache field indices, with Σ Values (`-2`) at `values_at`.
+fn axis_fields_xml(s: &mut String, tag: &str, idx: &[usize], values_at: Option<usize>) {
+    let n = idx.len() + usize::from(values_at.is_some());
+    if n == 0 {
+        return;
+    }
+    let _ = write!(s, "<{tag} count=\"{n}\">");
+    for (j, i) in idx.iter().enumerate() {
+        if values_at == Some(j) {
+            s.push_str("<field x=\"-2\"/>");
+        }
+        let _ = write!(s, "<field x=\"{i}\"/>");
+    }
+    if values_at.is_some_and(|p| p >= idx.len()) {
+        s.push_str("<field x=\"-2\"/>");
+    }
+    let _ = write!(s, "</{tag}>");
+}

From d1c8de48e7ac948081aa447c4020dad12faaf6e8 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:11:18 +0000
Subject: [PATCH 63/76] refactor(xlsx): move passthrough.rs items to
 passthrough/

---
 crates/xlsx/src/passthrough.rs        | 1216 +------------------------
 crates/xlsx/src/passthrough/read.rs   |  688 ++++++++++++++
 crates/xlsx/src/passthrough/rebase.rs |  199 ++++
 crates/xlsx/src/passthrough/write.rs  |  325 +++++++
 4 files changed, 1222 insertions(+), 1206 deletions(-)
 create mode 100644 crates/xlsx/src/passthrough/read.rs
 create mode 100644 crates/xlsx/src/passthrough/rebase.rs
 create mode 100644 crates/xlsx/src/passthrough/write.rs

diff --git a/crates/xlsx/src/passthrough.rs b/crates/xlsx/src/passthrough.rs
index 056fc6114..04f757d3a 100644
--- a/crates/xlsx/src/passthrough.rs
+++ b/crates/xlsx/src/passthrough.rs
@@ -42,6 +42,16 @@ use crate::read::Ctx;
 use crate::write::{NS_REL, Out, Rels, XML_DECL};
 use crate::xml::{self, esc_attr};
 
+mod read;
+mod rebase;
+mod write;
+
+pub use read::KeptReader;
+pub use rebase::{SheetKept, rebase_links};
+#[cfg(test)]
+pub(crate) use write::sheet_names_in;
+pub use write::{KeptOut, SheetIds, workbook_elements, write_package_rels, write_workbook};
+
 /// Most bytes kept for one workbook.
 pub const MAX_KEPT_TOTAL: usize = 256 * 1024 * 1024;
 /// Largest single kept part.
@@ -178,1209 +188,3 @@ fn rels_part_name(part: &str) -> String {
     let (dir, file) = package::split_dir(part);
     if dir.is_empty() { format!("_rels/{file}.rels") } else { format!("{dir}/_rels/{file}.rels") }
 }
-
-/// A part's relationships with full type URIs. `Ok(vec![])` when it has none; an error when the
-/// rels part is damaged or too large (its part then can't be kept faithfully).
-fn raw_rels(cx: &mut Ctx<'_>, part: &str) -> Result<Vec<PreservedRel>, String> {
-    let name = rels_part_name(part);
-    let bytes = match cx.pkg.read_limited(&name, MAX_META) {
-        Ok(Some(b)) => b,
-        Ok(None) => return Ok(vec![]),
-        Err(e) => return Err(e.to_string()),
-    };
-    let root = xml::parse(&bytes).map_err(|e| format!("{name}: {e}"))?;
-    let (dir, _) = package::split_dir(part);
-    let mut out = vec![];
-    for r in root.kids("Relationship") {
-        if out.len() >= MAX_RELS {
-            return Err(format!("{name}: too many relationships"));
-        }
-        let (Some(id), Some(target)) = (r.attr("Id"), r.attr("Target")) else { continue };
-        let external = r.attr("TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External"));
-        out.push(PreservedRel {
-            id: id.to_string(),
-            rel_type: r.attr("Type").unwrap_or("").to_string(),
-            target: if external { target.to_string() } else { package::resolve(dir, target) },
-            external,
-        });
-    }
-    Ok(out)
-}
-
-// ---------------------------------------------------------------- reading
-
-/// The `<sheet>` entries of the workbook that are chart sheets, each with the number of worksheets
-/// (model sheets) before it.
-fn chart_sheet_entries<'a>(wb_xml: &'a xml::El, wb_rels: &[PreservedRel], file_to_model: &[Option<usize>]) -> Vec<(usize, &'a xml::El)> {
-    let mut out = vec![];
-    let mut worksheets = 0usize;
-    for (i, se) in wb_xml.child("sheets").into_iter().flat_map(|s| s.kids("sheet")).enumerate() {
-        if file_to_model.get(i).copied().flatten().is_some() {
-            worksheets += 1;
-        } else if se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)).is_some_and(|r| is_kind(r, &["chartsheet"])) {
-            out.push((worksheets, se));
-        }
-    }
-    out
-}
-
-/// Collects kept content while a package is read.
-pub struct KeptReader {
-    on: bool,
-    strict: bool,
-    defaults: HashMap<String, String>,
-    overrides: HashMap<String, String>,
-    budget: usize,
-    parts_left: usize,
-}
-
-impl KeptReader {
-    pub fn new(cx: &mut Ctx<'_>) -> KeptReader {
-        let mut k = KeptReader {
-            on: true,
-            strict: false,
-            defaults: HashMap::new(),
-            overrides: HashMap::new(),
-            budget: kept_total(),
-            parts_left: MAX_KEPT_PARTS,
-        };
-        if let Ok(root) = raw_rels(cx, "")
-            && root.iter().any(|r| r.rel_type.starts_with("http://purl.oclc.org/"))
-        {
-            k.on = false;
-            k.strict = true;
-        }
-        match cx.pkg.read_limited("[Content_Types].xml", MAX_META).ok().flatten().and_then(|b| xml::parse(&b).ok()) {
-            Some(types) => {
-                for d in types.kids("Default") {
-                    if let (Some(e), Some(t)) = (d.attr("Extension"), d.attr("ContentType")) {
-                        k.defaults.insert(e.to_ascii_lowercase(), t.to_string());
-                    }
-                }
-                for o in types.kids("Override") {
-                    if let (Some(p), Some(t)) = (o.attr("PartName"), o.attr("ContentType")) {
-                        k.overrides.insert(normalize(p), t.to_string());
-                    }
-                }
-            }
-            None => k.on = false,
-        }
-        k
-    }
-
-    fn content_type(&self, part: &str) -> Option<String> {
-        let key = normalize(part);
-        if let Some(t) = self.overrides.get(&key) {
-            return Some(t.clone());
-        }
-        let (_, file) = package::split_dir(&key);
-        let ext = file.rsplit_once('.').map(|(_, e)| e)?;
-        self.defaults.get(ext).cloned()
-    }
-
-    /// The parts reachable from `root` that aren't in `seen` yet. Fails (and keeps nothing) when the
-    /// graph reaches rewritten content, a missing or damaged part, or a size limit.
-    fn closure(&mut self, cx: &mut Ctx<'_>, root: &PreservedRel, seen: &HashSet<String>, through: &[&str]) -> Result<Vec<PreservedPart>, String> {
-        if root.external {
-            return Ok(vec![]);
-        }
-        let blocked = |r: &PreservedRel| rewritten(r) && !through.iter().any(|k| k.eq_ignore_ascii_case(kind(&r.rel_type)));
-        if blocked(root) {
-            return Err(format!("it refers to {}", kind(&root.rel_type)));
-        }
-        let mut parts = vec![];
-        let mut bytes = 0usize;
-        let mut local: HashSet<String> = HashSet::new();
-        let mut queue = VecDeque::from([(root.target.clone(), 0usize)]);
-        while let Some((name, depth)) = queue.pop_front() {
-            let key = normalize(&name);
-            if seen.contains(&key) || !local.insert(key) {
-                continue;
-            }
-            if depth > MAX_CHAIN {
-                return Err("its relationships are nested too deeply".into());
-            }
-            if parts.len() >= self.parts_left {
-                return Err("it has too many parts".into());
-            }
-            let content_type = self.content_type(&name).ok_or_else(|| format!("{name} has no content type"))?;
-            let data = match cx.pkg.read_limited(&name, MAX_KEPT_PART) {
-                Ok(Some(d)) => d,
-                Ok(None) => return Err(format!("{name} is missing")),
-                Err(e) => return Err(e.to_string()),
-            };
-            bytes = bytes.saturating_add(data.len());
-            if bytes > self.budget {
-                return Err("it is too large".into());
-            }
-            let rels = raw_rels(cx, &name)?;
-            for r in rels.iter().filter(|r| !r.external) {
-                if blocked(r) {
-                    return Err(format!("it refers to {}", kind(&r.rel_type)));
-                }
-                queue.push_back((r.target.clone(), depth + 1));
-            }
-            parts.push(PreservedPart { name, content_type, data: Arc::from(data), rels });
-        }
-        self.budget = self.budget.saturating_sub(bytes);
-        self.parts_left = self.parts_left.saturating_sub(parts.len());
-        Ok(parts)
-    }
-
-    /// Keeps a set of relationships (all or nothing) and the parts behind them.
-    fn keep(&mut self, cx: &mut Ctx<'_>, p: &mut Preserved, roots: &[PreservedRel], seen: &mut HashSet<String>) -> Result<(), String> {
-        self.keep_through(cx, p, roots, seen, &[])
-    }
-
-    /// [`Self::keep`] for roots whose graph may reach the rewritten kinds in `through`.
-    fn keep_through(
-        &mut self,
-        cx: &mut Ctx<'_>,
-        p: &mut Preserved,
-        roots: &[PreservedRel],
-        seen: &mut HashSet<String>,
-        through: &[&str],
-    ) -> Result<(), String> {
-        let mut new_parts: Vec<PreservedPart> = vec![];
-        let mut scratch = seen.clone();
-        for r in roots {
-            let parts = self.closure(cx, r, &scratch, through)?;
-            scratch.extend(parts.iter().map(|q| normalize(&q.name)));
-            new_parts.extend(parts);
-        }
-        *seen = scratch;
-        p.parts.extend(new_parts);
-        for r in roots {
-            if !p.rels.iter().any(|x| x.id == r.id) {
-                p.rels.push(r.clone());
-            }
-        }
-        Ok(())
-    }
-
-    /// Package-root and workbook-level content.
-    pub fn workbook(&mut self, cx: &mut Ctx<'_>, wb_part: &str, wb_xml: &xml::El, file_to_model: &[Option<usize>]) -> Option<Arc<Preserved>> {
-        if !self.on {
-            let wb_rels = raw_rels(cx, wb_part).unwrap_or_default();
-            for (_, se) in chart_sheet_entries(wb_xml, &wb_rels, file_to_model) {
-                cx.warn(format!("chart sheet \"{}\" was skipped and is not kept on save", se.attr("name").unwrap_or("")));
-            }
-            if self.strict {
-                cx.warn("unmodelled content of a Strict Open XML workbook (custom XML, links, controls…) is not kept on save");
-            }
-            return None;
-        }
-        let mut p = Preserved::default();
-        let mut seen = HashSet::new();
-        // Package root: custom document properties, ribbon customisation, task panes.
-        if let Ok(root) = raw_rels(cx, "") {
-            for r in root.iter().filter(|r| is_kind(r, PACKAGE_ROOTS)) {
-                let mut q = Preserved::default();
-                match self.keep(cx, &mut q, std::slice::from_ref(r), &mut seen) {
-                    Ok(()) => {
-                        p.parts.extend(q.parts);
-                        p.package_rels.extend(q.rels);
-                    }
-                    Err(why) => cx.warn(format!("{} was dropped: {why}", kind(&r.rel_type))),
-                }
-            }
-        }
-        let wb_rels = raw_rels(cx, wb_part).unwrap_or_default();
-        for r in wb_rels.iter().filter(|r| is_kind(r, WORKBOOK_ROOTS)) {
-            if let Err(why) = self.keep(cx, &mut p, std::slice::from_ref(r), &mut seen) {
-                cx.warn(format!("{} part {} was dropped: {why}", kind(&r.rel_type), r.target));
-            }
-        }
-        // Chart sheets: the sheet entry (name, state, position) plus the chart sheet part and the
-        // drawing, chart, style and colour parts behind it.
-        for (worksheets, se) in chart_sheet_entries(wb_xml, &wb_rels, file_to_model) {
-            let name = se.attr("name").unwrap_or("").to_string();
-            let Some(r) = se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)) else { continue };
-            match self.keep_through(cx, &mut p, std::slice::from_ref(r), &mut seen, CHART_SHEET_GRAPH) {
-                Ok(()) => p.sheets.push(PreservedSheet {
-                    name,
-                    visibility: match se.attr("state") {
-                        Some("hidden") => Visibility::Hidden,
-                        Some("veryHidden") => Visibility::VeryHidden,
-                        _ => Visibility::Visible,
-                    },
-                    rel_id: r.id.clone(),
-                    before: worksheets,
-                    sheet_id: se.attr_u32("sheetId").unwrap_or(0),
-                }),
-                Err(why) => cx.warn(format!("chart sheet \"{name}\" was dropped: {why}")),
-            }
-        }
-        // Links to external workbooks: `[1]` in formulas is the position in <externalReferences>,
-        // so they are kept all together or not at all.
-        let ids: Vec<&str> =
-            wb_xml.child("externalReferences").map(|e| e.kids("externalReference").filter_map(|x| x.attr("id")).collect()).unwrap_or_default();
-        if !ids.is_empty() {
-            let roots: Option<Vec<PreservedRel>> =
-                ids.iter().map(|id| wb_rels.iter().find(|r| r.id == *id && is_kind(r, &["externalLink"])).cloned()).collect();
-            let kept = match roots {
-                Some(roots) => self.keep(cx, &mut p, &roots, &mut seen),
-                None => Err("a link has no part".into()),
-            };
-            match kept {
-                Ok(()) => {
-                    let mut x = format!("<externalReferences xmlns:r=\"{NS_REL}\">");
-                    for id in &ids {
-                        let _ = write!(x, "<externalReference r:id=\"{}\"/>", esc_attr(id));
-                    }
-                    x.push_str("</externalReferences>");
-                    p.elements.push(PreservedXml { slot: "externalReferences".into(), xml: x });
-                    cx.warn("links to external workbooks were kept; they are not followed or refreshed");
-                }
-                Err(why) => cx.warn(format!("links to external workbooks were dropped: {why}")),
-            }
-        }
-        // Excel trusts the saved cell values only when both are present; without them it
-        // recalculates everything on open, and links into closed workbooks come back as errors.
-        if let Some(v) = wb_xml.child("fileVersion") {
-            let mut x = String::from("<fileVersion");
-            for k in FILE_VERSION_ATTRS {
-                if let Some(a) = v.attr(k) {
-                    let _ = write!(x, " {k}=\"{}\"", esc_attr(a));
-                }
-            }
-            x.push_str("/>");
-            p.elements.push(PreservedXml { slot: "fileVersion".into(), xml: x });
-        }
-        let calc_features = wb_xml
-            .child("extLst")
-            .and_then(|l| l.kids("ext").find(|e| e.attr("uri").is_some_and(|u| u.eq_ignore_ascii_case(CALC_FEATURES_URI))))
-            .and_then(|e| e.child("calcFeatures"));
-        if let Some(c) = calc_features {
-            let mut x = format!("<ext uri=\"{CALC_FEATURES_URI}\" xmlns:xcalcf=\"{NS_CALC_FEATURES}\"><xcalcf:calcFeatures>");
-            for name in c.kids("feature").filter_map(|f| f.attr("name")) {
-                let _ = write!(x, "<xcalcf:feature name=\"{}\"/>", esc_attr(name));
-            }
-            x.push_str("</xcalcf:calcFeatures></ext>");
-            p.elements.push(PreservedXml { slot: "ext".into(), xml: x });
-        }
-        (!p.is_empty()).then(|| Arc::new(p))
-    }
-
-    /// Sheet-level content of the sheet part `part`.
-    pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str) -> Option<Arc<Preserved>> {
-        if !self.on {
-            return None;
-        }
-        let rels = match raw_rels(cx, part) {
-            Ok(r) => r,
-            Err(e) => {
-                cx.warn(format!("sheet \"{name}\": relationships could not be read ({e}); unmodelled content was dropped"));
-                return None;
-            }
-        };
-        let mut p = Preserved::default();
-        let mut seen = HashSet::new();
-        for r in rels.iter().filter(|r| is_kind(r, SHEET_ROOTS)) {
-            if let Err(why) = self.keep(cx, &mut p, std::slice::from_ref(r), &mut seen) {
-                cx.warn(format!("sheet \"{name}\": {} was dropped: {why}", kind(&r.rel_type)));
-            }
-        }
-        // Notes have one VML drawing per sheet; another one holds the header and footer pictures.
-        let vml_drawings = rels.iter().filter(|r| is_kind(r, &["vmlDrawing"])).count();
-        let notes = rels.iter().filter(|r| is_kind(r, &["comments"])).count();
-        if rels.iter().any(|r| is_kind(r, SHEET_ELEMENT_KINDS)) || vml_drawings > notes {
-            self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen);
-        }
-        (!p.is_empty()).then(|| Arc::new(p))
-    }
-
-    fn sheet_elements(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, rels: &[PreservedRel], p: &mut Preserved, seen: &mut HashSet<String>) {
-        let scan = match cx.pkg.read(part) {
-            Ok(Some(bytes)) => scan_sheet(&bytes),
-            _ => None,
-        };
-        let Some(scan) = scan else {
-            cx.warn(format!("sheet \"{name}\": controls and embedded objects could not be read and were dropped"));
-            return;
-        };
-        // Printer settings (a binary part per sheet) hang off <pageSetup r:id>.
-        if let Some(id) = scan.page_setup.as_deref()
-            && let Some(r) = rels.iter().find(|r| r.id == id && is_kind(r, &["printerSettings"]))
-        {
-            match self.keep(cx, p, std::slice::from_ref(r), seen) {
-                Ok(()) => p.elements.push(PreservedXml { slot: "pageSetup".into(), xml: r.id.clone() }),
-                Err(why) => cx.warn(format!("sheet \"{name}\": printer settings were dropped: {why}")),
-            }
-        }
-        // Header and footer pictures (`&G`): a VML drawing of their own and the images it shows,
-        // kept byte for byte (GridCraft writes the header text, not the pictures).
-        if let Some(id) = scan.legacy_drawing_hf.as_deref()
-            && scan.legacy_drawing.as_deref() != Some(id)
-            && let Some(r) = rels.iter().find(|r| r.id == id && is_kind(r, &["vmlDrawing"]))
-        {
-            match self.keep_through(cx, p, std::slice::from_ref(r), seen, &["vmlDrawing"]) {
-                Ok(()) => {
-                    let xml = format!("<legacyDrawingHF xmlns:r=\"{NS_REL}\" r:id=\"{}\"/>", esc_attr(&r.id));
-                    p.elements.push(PreservedXml { slot: "legacyDrawingHF".into(), xml });
-                    cx.warn(format!("sheet \"{name}\": pictures in the header and footer are not shown; they are kept for saving"));
-                }
-                Err(why) => cx.warn(format!("sheet \"{name}\": header and footer pictures were dropped: {why}")),
-            }
-        }
-        let mut frags = scan.fragments;
-        // Controls and OLE objects are drawn from shapes in the legacy VML drawing.
-        if frags.iter().any(|(slot, _)| slot != "picture") {
-            match self.vml(cx, rels, scan.legacy_drawing.as_deref(), seen) {
-                Ok((vml, parts)) => {
-                    p.parts.extend(parts);
-                    p.vml = Some(vml);
-                }
-                Err(why) => {
-                    cx.warn(format!("sheet \"{name}\": controls and embedded objects were dropped: {why}"));
-                    frags.retain(|(slot, _)| slot == "picture");
-                }
-            }
-        }
-        for (slot, x) in frags {
-            let mut ids = vec![];
-            let ok = map_rel_ids(&x, &mut |id| {
-                ids.push(id.to_string());
-                Some(id.to_string())
-            })
-            .is_some();
-            let roots: Option<Vec<PreservedRel>> = ids.iter().map(|id| rels.iter().find(|r| r.id == *id).cloned()).collect();
-            let kept = match (ok, roots) {
-                (true, Some(roots)) => self.keep(cx, p, &roots, seen),
-                (false, _) => Err("its XML is damaged".into()),
-                (_, None) => Err("it refers to a missing relationship".into()),
-            };
-            match kept {
-                Ok(()) => p.elements.push(PreservedXml { slot, xml: x }),
-                Err(why) => cx.warn(format!("sheet \"{name}\": {slot} were dropped: {why}")),
-            }
-        }
-        if p.elements.iter().any(|e| e.slot == "oleObjects" || e.slot == "controls") {
-            cx.warn(format!("sheet \"{name}\": embedded objects and form controls are not shown; they are kept for saving"));
-        } else {
-            p.vml = None;
-        }
-    }
-
-    /// The sheet's VML drawing without its notes (GridCraft writes those), and the parts its
-    /// shapes refer to (preview images).
-    fn vml(
-        &mut self,
-        cx: &mut Ctx<'_>,
-        rels: &[PreservedRel],
-        rid: Option<&str>,
-        seen: &mut HashSet<String>,
-    ) -> Result<(PreservedPart, Vec<PreservedPart>), String> {
-        let rel = rid.and_then(|id| rels.iter().find(|r| r.id == id && !r.external)).ok_or("the sheet has no VML drawing")?;
-        // Charged to the kept total like any other part: many sheets can point at one highly
-        // compressed VML drawing, and each keeps its own copy.
-        if self.budget == 0 {
-            return Err("it is too large".into());
-        }
-        let limit = MAX_META.min(u64::try_from(self.budget).unwrap_or(u64::MAX));
-        let data = match cx.pkg.read_limited(&rel.target, limit) {
-            Ok(Some(d)) => d,
-            Ok(None) => return Err(format!("{} is missing", rel.target)),
-            Err(IoError::TooLarge(_)) => return Err("it is too large".into()),
-            Err(e) => return Err(e.to_string()),
-        };
-        self.budget = self.budget.saturating_sub(data.len());
-        let text = String::from_utf8(data).map_err(|_| "the VML drawing is not UTF-8".to_string())?;
-        let text = strip_notes(&text);
-        let vrels = raw_rels(cx, &rel.target)?;
-        let mut q = Preserved::default();
-        let roots: Vec<PreservedRel> = vrels.iter().filter(|r| !r.external).cloned().collect();
-        self.keep(cx, &mut q, &roots, seen)?;
-        let vml = PreservedPart { name: rel.target.clone(), content_type: CT_VML.into(), data: Arc::from(text.into_bytes()), rels: vrels };
-        Ok((vml, q.parts))
-    }
-}
-
-/// What a sheet part holds for pass-through.
-struct SheetScan {
-    /// (slot, XML with the namespace declarations it needs).
-    fragments: Vec<(String, String)>,
-    legacy_drawing: Option<String>,
-    /// The relationship id on `<legacyDrawingHF>` (header and footer pictures).
-    legacy_drawing_hf: Option<String>,
-    /// The relationship id on `<pageSetup>` (printer settings).
-    page_setup: Option<String>,
-}
-
-/// Finds the sheet's `<picture>`, `<oleObjects>`, `<controls>` (also inside
-/// `<mc:AlternateContent>`) and the `<legacyDrawing>` and `<legacyDrawingHF>` ids. `None` when the XML is damaged.
-fn scan_sheet(bytes: &[u8]) -> Option<SheetScan> {
-    let data = xml::to_utf8(bytes);
-    let text = std::str::from_utf8(&data).ok()?;
-    let mut reader = Reader::from_str(text);
-    let mut decls: Vec<(String, String)> = vec![];
-    let mut out = SheetScan { fragments: vec![], legacy_drawing: None, legacy_drawing_hf: None, page_setup: None };
-    let mut in_root = false;
-    loop {
-        let start = usize::try_from(reader.buffer_position()).ok()?;
-        match reader.read_event().ok()? {
-            Event::Eof => break,
-            Event::Start(e) if !in_root => {
-                in_root = true;
-                for a in e.attributes().with_checks(false).flatten() {
-                    if let Some(p) = a.key.as_ref().strip_prefix(b"xmlns:")
-                        && let (Ok(p), Ok(v)) = (std::str::from_utf8(p), std::str::from_utf8(&a.value))
-                        && !v.contains('"')
-                    {
-                        decls.push((p.to_string(), v.to_string()));
-                    }
-                }
-            }
-            Event::Start(e) => {
-                let local = e.local_name().as_ref().to_vec();
-                match local.as_slice() {
-                    b"pageSetup" => out.page_setup = rel_id_attr(&e),
-                    b"legacyDrawing" => out.legacy_drawing = rel_id_attr(&e),
-                    b"legacyDrawingHF" => out.legacy_drawing_hf = rel_id_attr(&e),
-                    _ => {}
-                }
-                reader.read_to_end(e.name()).ok()?;
-                let end = usize::try_from(reader.buffer_position()).ok()?;
-                let wanted = matches!(local.as_slice(), b"picture" | b"oleObjects" | b"controls" | b"AlternateContent");
-                if wanted && end.saturating_sub(start) <= MAX_FRAGMENT {
-                    let frag = text.get(start..end)?;
-                    push_fragment(&mut out, frag, &local, &decls);
-                }
-            }
-            Event::Empty(e) if in_root => {
-                let local = e.local_name().as_ref().to_vec();
-                if local == b"legacyDrawing" || local == b"legacyDrawingHF" || local == b"pageSetup" {
-                    let id = rel_id_attr(&e);
-                    match local.as_slice() {
-                        b"pageSetup" => out.page_setup = id,
-                        b"legacyDrawing" => out.legacy_drawing = id,
-                        _ => out.legacy_drawing_hf = id,
-                    }
-                } else if local == b"picture"
-                    && let Some(frag) = text.get(start..usize::try_from(reader.buffer_position()).ok()?)
-                {
-                    push_fragment(&mut out, frag, &local, &decls);
-                }
-            }
-            Event::End(_) => break,
-            _ => {}
-        }
-    }
-    Some(out)
-}
-
-/// The `r:id` of an element (an `id` attribute with a namespace prefix).
-fn rel_id_attr(e: &BytesStart<'_>) -> Option<String> {
-    e.attributes()
-        .with_checks(false)
-        .flatten()
-        .find(|a| a.key.local_name().as_ref() == b"id" && a.key.prefix().is_some())
-        .and_then(|a| String::from_utf8(a.value.to_vec()).ok())
-}
-
-fn push_fragment(out: &mut SheetScan, frag: &str, local: &[u8], decls: &[(String, String)]) {
-    let frag = with_decls(frag, decls);
-    let slot = if local == b"AlternateContent" {
-        // The kept element is the one the first choice holds.
-        let Ok(el) = xml::parse(frag.as_bytes()) else { return };
-        match el.child("Choice").and_then(|c| c.children.first()) {
-            Some(c) => c.name.clone(),
-            None => return,
-        }
-    } else {
-        String::from_utf8_lossy(local).into_owned()
-    };
-    if SHEET_SLOTS.contains(&slot.as_str()) && !out.fragments.iter().any(|(s, _)| *s == slot) {
-        out.fragments.push((slot, frag));
-    }
-}
-
-/// Adds the root's namespace declarations a fragment doesn't declare itself.
-fn with_decls(frag: &str, decls: &[(String, String)]) -> String {
-    let Some(name_end) = frag.char_indices().skip(1).find(|(_, c)| c.is_whitespace() || *c == '/' || *c == '>').map(|(i, _)| i) else {
-        return frag.to_string();
-    };
-    let head = frag.get(..frag.find('>').unwrap_or(frag.len())).unwrap_or("");
-    let mut add = String::new();
-    for (p, v) in decls {
-        if !head.contains(&format!("xmlns:{p}=")) {
-            let _ = write!(add, " xmlns:{p}=\"{v}\"");
-        }
-    }
-    format!("{}{add}{}", frag.get(..name_end).unwrap_or(""), frag.get(name_end..).unwrap_or(""))
-}
-
-/// Byte ranges of the `<v:shape …>…</v:shape>` (or self-closed) elements in VML text.
-fn shape_spans(vml: &str) -> Vec<(usize, usize)> {
-    let mut spans = vec![];
-    let mut from = 0;
-    while let Some(i) = vml.get(from..).and_then(|s| s.find("<v:shape")).map(|i| i + from) {
-        let after = i + "<v:shape".len();
-        let is_shape = vml.get(after..).and_then(|s| s.chars().next()).is_some_and(|c| c.is_whitespace() || c == '>' || c == '/');
-        if !is_shape {
-            from = after;
-            continue;
-        }
-        let Some(tag_end) = vml.get(i..).and_then(|s| s.find('>')).map(|j| i + j + 1) else { break };
-        let end = if vml.get(..tag_end).is_some_and(|t| t.ends_with("/>")) {
-            tag_end
-        } else {
-            match vml.get(tag_end..).and_then(|s| s.find("</v:shape>")) {
-                Some(j) => tag_end + j + "</v:shape>".len(),
-                None => break,
-            }
-        };
-        spans.push((i, end));
-        from = end;
-    }
-    spans
-}
-
-/// VML without its note shapes (`ObjectType="Note"`).
-fn strip_notes(vml: &str) -> String {
-    let mut out = String::with_capacity(vml.len());
-    let mut last = 0;
-    for (a, b) in shape_spans(vml) {
-        let shape = vml.get(a..b).unwrap_or("");
-        if shape.contains("ObjectType=\"Note\"") {
-            out.push_str(vml.get(last..a).unwrap_or(""));
-            last = b;
-        }
-    }
-    out.push_str(vml.get(last..).unwrap_or(""));
-    out
-}
-
-/// Shape numbers (`_x0000_s1025` → 1025) used in VML text.
-fn shape_numbers(vml: &str) -> Vec<u64> {
-    vml.match_indices("_x0000_s")
-        .filter_map(|(i, m)| {
-            let digits: String = vml.get(i + m.len()..)?.chars().take_while(char::is_ascii_digit).take(18).collect();
-            digits.parse().ok()
-        })
-        .collect()
-}
-
-/// The highest shape block VML text claims in `<o:idmap data>` or uses in a shape id.
-fn vml_block_max(vml: &str) -> u64 {
-    let used = shape_numbers(vml).into_iter().max().unwrap_or(0) / 1024;
-    let claimed = vml
-        .find("<o:idmap")
-        .and_then(|i| vml.get(i..)?.find("data=\"").map(|d| i + d + "data=\"".len()))
-        .and_then(|d| Some((d, d + vml.get(d..)?.find('"')?)))
-        .and_then(|(d, e)| vml.get(d..e))
-        .map(|list| list.split(',').filter_map(|b| b.trim().parse::<u64>().ok()).max().unwrap_or(0))
-        .unwrap_or(0);
-    used.max(claimed)
-}
-
-/// Kept VML (controls, OLE objects) plus GridCraft's note shapes: the notes get ids in a fresh
-/// shape block so they can't collide with the kept shapes the sheet XML refers to.
-fn merge_vml(kept: &str, ours: &str) -> String {
-    let Some(close) = kept.rfind("</xml>") else { return ours.to_string() };
-    let block = shape_numbers(kept).into_iter().max().unwrap_or(0) / 1024 + 1;
-    let mut add = String::new();
-    if !kept.contains("id=\"_x0000_t202\"")
-        && let Some(i) = ours.find("<v:shapetype")
-        && let Some(j) = ours.get(i..).and_then(|s| s.find("</v:shapetype>"))
-    {
-        add.push_str(ours.get(i..i + j + "</v:shapetype>".len()).unwrap_or(""));
-    }
-    for (k, (a, b)) in shape_spans(ours).into_iter().enumerate() {
-        let shape = ours.get(a..b).unwrap_or("");
-        let id = block.saturating_mul(1024).saturating_add(1 + k as u64);
-        match (shape.find("id=\"_x0000_s"), shape.find("id=\"_x0000_s").and_then(|i| shape.get(i + 4..)?.find('"').map(|j| i + 4 + j))) {
-            (Some(i), Some(j)) => {
-                let _ = write!(add, "{}id=\"_x0000_s{id}\"{}", shape.get(..i).unwrap_or(""), shape.get(j + 1..).unwrap_or(""));
-            }
-            _ => add.push_str(shape),
-        }
-    }
-    let mut head = kept.get(..close).unwrap_or("").to_string();
-    // Claim the block in the drawing's id map.
-    if let Some(i) = head.find("<o:idmap")
-        && let Some(d) = head.get(i..).and_then(|s| s.find("data=\"")).map(|d| i + d + "data=\"".len())
-        && let Some(e) = head.get(d..).and_then(|s| s.find('"')).map(|e| d + e)
-    {
-        head.insert_str(e, &format!(",{block}"));
-    }
-    format!("{head}{add}{}", kept.get(close..).unwrap_or(""))
-}
-
-/// Rewrites relationship-id attributes (`r:id`, `r:embed`…: any attribute in the relationships
-/// namespace) of an XML fragment through `map`. `None` when the fragment is damaged or `map` has
-/// no id for one of them.
-pub fn map_rel_ids(x: &str, map: &mut dyn FnMut(&str) -> Option<String>) -> Option<String> {
-    let mut reader = Reader::from_str(x);
-    let mut writer = Writer::new(Vec::with_capacity(x.len()));
-    let mut prefixes: HashSet<Vec<u8>> = HashSet::new();
-    let mut depth = 0usize;
-    loop {
-        match reader.read_event().ok()? {
-            Event::Eof => break,
-            Event::Start(e) => {
-                depth += 1;
-                if depth > MAX_FRAGMENT_DEPTH {
-                    return None;
-                }
-                let e = map_start(&e, &mut prefixes, map)?;
-                writer.write_event(Event::Start(e)).ok()?;
-            }
-            Event::Empty(e) => {
-                let e = map_start(&e, &mut prefixes, map)?;
-                writer.write_event(Event::Empty(e)).ok()?;
-            }
-            Event::End(e) => {
-                depth = depth.saturating_sub(1);
-                writer.write_event(Event::End(e)).ok()?;
-            }
-            ev => writer.write_event(ev).ok()?,
-        }
-    }
-    String::from_utf8(writer.into_inner()).ok()
-}
-
-fn map_start(e: &BytesStart<'_>, prefixes: &mut HashSet<Vec<u8>>, map: &mut dyn FnMut(&str) -> Option<String>) -> Option<BytesStart<'static>> {
-    for a in e.attributes().with_checks(false) {
-        let a = a.ok()?;
-        if let Some(p) = a.key.as_ref().strip_prefix(b"xmlns:")
-            && (a.value.as_ref() == NS_REL.as_bytes() || a.value.as_ref() == NS_REL_STRICT.as_bytes())
-        {
-            prefixes.insert(p.to_vec());
-        }
-    }
-    let name = String::from_utf8(e.name().as_ref().to_vec()).ok()?;
-    let mut out = BytesStart::new(name);
-    for a in e.attributes().with_checks(false) {
-        let a = a.ok()?;
-        let key = a.key.as_ref();
-        let is_rel = !key.starts_with(b"xmlns") && a.key.prefix().is_some_and(|p| prefixes.contains(p.as_ref()));
-        if is_rel {
-            let old = std::str::from_utf8(&a.value).ok()?;
-            let new = map(old)?;
-            out.push_attribute(Attribute { key: QName(key), value: Cow::Owned(esc_attr(&new).into_bytes()) });
-        } else {
-            out.push_attribute(Attribute { key: QName(key), value: a.value.clone() });
-        }
-    }
-    Some(out)
-}
-
-// ---------------------------------------------------------------- writing
-
-/// Names given to kept parts while a package is written.
-#[derive(Default)]
-pub struct KeptOut {
-    used: HashSet<String>,
-    n: u32,
-    /// The highest VML shape block a kept header and footer drawing uses: notes go after it.
-    vml_blocks: u32,
-    /// Package-root relationships (type, target, external), added when `_rels/.rels` is written.
-    root: Vec<(String, String, bool)>,
-}
-
-impl KeptOut {
-    /// Reserves the VML shape blocks the kept header and footer drawings of `wb` use, so that the
-    /// notes drawings GridCraft writes don't reuse their shape ids.
-    pub fn reserve_vml_blocks(&mut self, wb: &Workbook) {
-        let vmls =
-            wb.sheets.iter().filter_map(|s| s.preserved.as_deref()).flat_map(|p| &p.parts).filter(|q| q.content_type.eq_ignore_ascii_case(CT_VML));
-        let max = vmls.map(|q| vml_block_max(&String::from_utf8_lossy(&q.data))).max().unwrap_or(0);
-        self.vml_blocks = u32::try_from(max).unwrap_or(u32::MAX);
-    }
-
-    /// The shape block of the `n`th notes drawing.
-    pub fn notes_block(&self, n: u32) -> u32 {
-        n.saturating_add(self.vml_blocks)
-    }
-
-    /// A part name for a kept part: its original name when that can't collide with anything
-    /// written, otherwise a fresh one in the same folder.
-    fn claim(&mut self, original: &str) -> String {
-        let lower = original.to_ascii_lowercase();
-        let own = OWN_DIRS.iter().any(|d| lower.starts_with(d));
-        if own && self.used.insert(lower) {
-            return original.to_string();
-        }
-        let (dir, file) = package::split_dir(original);
-        let (stem, ext) = match file.rsplit_once('.') {
-            Some((s, e)) => (s, format!(".{e}")),
-            None => (file, String::new()),
-        };
-        let stem = if own { format!("{stem}_") } else { "kept".to_string() };
-        loop {
-            self.n = self.n.saturating_add(1);
-            let file = format!("{stem}{}{ext}", self.n);
-            let cand = if dir.is_empty() { file } else { format!("{dir}/{file}") };
-            if self.used.insert(cand.to_ascii_lowercase()) || self.n == u32::MAX {
-                return cand;
-            }
-        }
-    }
-}
-
-/// Original part name (normalized) → written part name.
-type NameMap = HashMap<String, String>;
-
-fn rel_target(r: &PreservedRel, names: &NameMap) -> Option<String> {
-    if r.external { Some(r.target.clone()) } else { names.get(&normalize(&r.target)).map(|n| format!("/{n}")) }
-}
-
-/// A kept part's relationships, ids unchanged, targets renamed.
-fn part_rels_xml(rels: &[PreservedRel], names: &NameMap) -> String {
-    let mut s = format!("{XML_DECL}<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
-    for r in rels {
-        let Some(target) = rel_target(r, names) else { continue };
-        let _ = write!(
-            s,
-            "<Relationship Id=\"{}\" Type=\"{}\" Target=\"{}\"{}/>",
-            esc_attr(&r.id),
-            esc_attr(&r.rel_type),
-            esc_attr(&target),
-            if r.external { " TargetMode=\"External\"" } else { "" }
-        );
-    }
-    s.push_str("</Relationships>");
-    s
-}
-
-fn write_parts(out: &mut Out, parts: &[PreservedPart]) -> NameMap {
-    let mut names = NameMap::new();
-    for p in parts {
-        names.entry(normalize(&p.name)).or_insert_with(|| out.kept.claim(&p.name));
-    }
-    let mut written = HashSet::new();
-    for p in parts {
-        let Some(new) = names.get(&normalize(&p.name)).cloned() else { continue };
-        if !written.insert(new.clone()) {
-            continue;
-        }
-        out.part(&new, Some(&p.content_type), p.data.to_vec());
-        if !p.rels.is_empty() {
-            out.part(&rels_part_name(&new), None, part_rels_xml(&p.rels, &names).into_bytes());
-        }
-    }
-    names
-}
-
-/// Adds the owner's relationships; returns old id → new id.
-fn attach(rels: &mut Rels, list: &[PreservedRel], names: &NameMap) -> HashMap<String, String> {
-    let mut ids = HashMap::new();
-    for r in list {
-        if let Some(target) = rel_target(r, names) {
-            let id = rels.add_raw(&r.rel_type, &target, r.external);
-            ids.insert(r.id.clone(), id);
-        }
-    }
-    ids
-}
-
-fn remap(x: &str, ids: &HashMap<String, String>) -> Option<String> {
-    map_rel_ids(x, &mut |id| ids.get(id).cloned())
-}
-
-/// A kept chart sheet being written: its `<sheet>` entry's fields and its new relationship id.
-pub struct KeptSheet {
-    before: usize,
-    name: String,
-    visibility: Visibility,
-    rid: String,
-    sheet_id: u32,
-}
-
-/// The `sheetId`s of the written sheets: each keeps the one the file gave it, unless another
-/// sheet took it first (a copied sheet) or it has none (a new sheet), and those get the next id
-/// that no sheet asks for.
-pub struct SheetIds {
-    wanted: HashSet<u32>,
-    given: HashSet<u32>,
-    next: u32,
-}
-
-impl SheetIds {
-    pub fn new(wb: &Workbook, kept: &WorkbookKept) -> SheetIds {
-        let wanted: HashSet<u32> = wb.sheets.iter().map(|s| s.file_id).chain(kept.sheets.iter().map(|s| s.sheet_id)).filter(|&id| id != 0).collect();
-        SheetIds { wanted, given: HashSet::new(), next: 1 }
-    }
-
-    pub fn take(&mut self, wanted: u32) -> u32 {
-        if wanted != 0 && self.given.insert(wanted) {
-            return wanted;
-        }
-        while self.wanted.contains(&self.next) || self.given.contains(&self.next) {
-            self.next += 1;
-        }
-        self.given.insert(self.next);
-        self.next
-    }
-}
-
-/// The workbook's kept content as written.
-#[derive(Default)]
-pub struct WorkbookKept {
-    /// Workbook XML elements that go right after `<sheets>` (`<externalReferences>`).
-    pub elements: String,
-    sheets: Vec<KeptSheet>,
-}
-
-impl WorkbookKept {
-    /// Where the model's sheet `i` is in the file's sheet list: chart sheets come between worksheets.
-    pub fn file_index(&self, i: usize) -> usize {
-        i + self.sheets.iter().filter(|s| s.before <= i).count()
-    }
-
-    /// The `<sheet>` entries of the chart sheets that go right before the model's sheet `i`
-    /// (`i` = the number of sheets for those that come last), with their ids from `ids`.
-    pub fn sheet_entries(&self, i: usize, last: bool, ids: &mut SheetIds) -> String {
-        let mut x = String::new();
-        for s in self.sheets.iter().filter(|s| if last { s.before >= i } else { s.before == i }) {
-            let state = match s.visibility {
-                Visibility::Visible => "",
-                Visibility::Hidden => " state=\"hidden\"",
-                Visibility::VeryHidden => " state=\"veryHidden\"",
-            };
-            let name: String = s.name.chars().take(31).collect();
-            let id = ids.take(s.sheet_id);
-            let _ = write!(x, "<sheet name=\"{}\" sheetId=\"{id}\"{state} r:id=\"{}\"/>", esc_attr(&name), esc_attr(&s.rid));
-        }
-        x
-    }
-}
-
-/// The part names reachable from `root` through kept parts' relationships (normalized).
-fn reachable(p: &Preserved, root: &PreservedRel) -> HashSet<String> {
-    let by_name: HashMap<String, &PreservedPart> = p.parts.iter().map(|q| (normalize(&q.name), q)).collect();
-    let mut seen = HashSet::new();
-    let mut queue = VecDeque::from([normalize(&root.target)]);
-    while let Some(n) = queue.pop_front() {
-        if !seen.insert(n.clone()) {
-            continue;
-        }
-        if let Some(q) = by_name.get(&n) {
-            queue.extend(q.rels.iter().filter(|r| !r.external).map(|r| normalize(&r.target)));
-        }
-    }
-    seen
-}
-
-/// Every formula (`<c:f>`) of a chart part, depth first.
-fn chart_formulas(el: &xml::El, out: &mut Vec<String>) {
-    if el.name == "f" && !el.text.trim().is_empty() {
-        out.push(el.text.trim().to_string());
-    }
-    for c in &el.children {
-        chart_formulas(c, out);
-    }
-}
-
-/// The sheet names a formula such as `'My Sheet'!$A$1:$A$9,Data!$B$1` refers to. References to
-/// other workbooks (`[1]Sheet!A1`) are not sheets of this one and are left out.
-pub(crate) fn sheet_names_in(formula: &str) -> Vec<String> {
-    let mut names = vec![];
-    let chars: Vec<char> = formula.chars().collect();
-    let at = |i: usize| chars.get(i).copied();
-    let mut i = 0;
-    while let Some(c) = at(i) {
-        let mut name = String::new();
-        let start = i;
-        if c == '\'' {
-            i += 1;
-            while let Some(c) = at(i) {
-                if c == '\'' {
-                    if at(i + 1) == Some('\'') {
-                        name.push('\'');
-                        i += 2;
-                        continue;
-                    }
-                    break;
-                }
-                name.push(c);
-                i += 1;
-            }
-            i += 1;
-        } else {
-            while let Some(c) = at(i).filter(|c| !matches!(c, '!' | ',' | '(' | ')' | '\'' | ' ')) {
-                name.push(c);
-                i += 1;
-            }
-        }
-        if at(i) == Some('!') {
-            if !name.is_empty() && !name.starts_with('[') {
-                names.push(name);
-            }
-            i += 1;
-        } else if i == start {
-            i += 1;
-        }
-    }
-    names
-}
-
-/// Whether a kept chart sheet can be written back: its chart's series must still refer to sheets
-/// that exist under the same names (the chart is kept as it was, so a series on a deleted or
-/// renamed sheet would be left pointing at nothing), and no worksheet may have taken its name.
-fn chart_sheet_usable(wb: &Workbook, p: &Preserved, s: &PreservedSheet) -> bool {
-    let same = |a: &str, b: &str| a.chars().take(31).collect::<String>().eq_ignore_ascii_case(&b.chars().take(31).collect::<String>());
-    if wb.sheets.iter().any(|w| same(&w.name, &s.name)) {
-        return false;
-    }
-    let Some(root) = p.rels.iter().find(|r| r.id == s.rel_id) else { return false };
-    let parts = reachable(p, root);
-    let mut formulas = vec![];
-    for q in p.parts.iter().filter(|q| parts.contains(&normalize(&q.name)) && q.content_type.contains("chart")) {
-        if let Ok(x) = xml::parse(&q.data) {
-            chart_formulas(&x, &mut formulas);
-        }
-    }
-    formulas.iter().flat_map(|f| sheet_names_in(f)).all(|n| wb.sheets.iter().any(|w| same(&w.name, &n)))
-}
-
-/// Writes the workbook's kept parts and relationships. Chart sheets that can't be written back
-/// (see [`chart_sheet_usable`]) are left out with the parts only they reach.
-pub fn write_workbook(wb: &Workbook, wb_rels: &mut Rels, out: &mut Out) -> WorkbookKept {
-    let Some(p) = wb.preserved.as_deref() else { return WorkbookKept::default() };
-    let (live, dropped): (Vec<&PreservedSheet>, Vec<&PreservedSheet>) = p.sheets.iter().partition(|s| chart_sheet_usable(wb, p, s));
-    let root_of = |s: &PreservedSheet| p.rels.iter().find(|r| r.id == s.rel_id);
-    let dropped_ids: HashSet<&str> = dropped.iter().map(|s| s.rel_id.as_str()).collect();
-    // Parts reached only by dropped chart sheets go with them.
-    let mut gone: HashSet<String> = dropped.iter().filter_map(|s| root_of(s)).flat_map(|r| reachable(p, r)).collect();
-    if !gone.is_empty() {
-        let others = p.rels.iter().filter(|r| !dropped_ids.contains(r.id.as_str())).flat_map(|r| reachable(p, r));
-        for n in others {
-            gone.remove(&n);
-        }
-    }
-    let parts: Vec<PreservedPart> = p.parts.iter().filter(|q| !gone.contains(&normalize(&q.name))).cloned().collect();
-    let rels: Vec<PreservedRel> = p.rels.iter().filter(|r| !dropped_ids.contains(r.id.as_str())).cloned().collect();
-    let names = write_parts(out, &parts);
-    let ids = attach(wb_rels, &rels, &names);
-    for r in &p.package_rels {
-        if let Some(target) = rel_target(r, &names) {
-            out.kept.root.push((r.rel_type.clone(), target, r.external));
-        }
-    }
-    WorkbookKept {
-        elements: p.elements.iter().filter(|e| e.slot == "externalReferences").filter_map(|e| remap(&e.xml, &ids)).collect(),
-        sheets: live
-            .iter()
-            .filter_map(|s| {
-                Some(KeptSheet {
-                    before: s.before,
-                    name: s.name.clone(),
-                    visibility: s.visibility,
-                    rid: ids.get(&s.rel_id)?.clone(),
-                    sheet_id: s.sheet_id,
-                })
-            })
-            .collect(),
-    }
-}
-
-/// The workbook's kept elements of `slot` that refer to no part (`fileVersion`, `ext`).
-pub fn workbook_elements(wb: &Workbook, slot: &str) -> String {
-    let Some(p) = wb.preserved.as_deref() else { return String::new() };
-    p.elements.iter().filter(|e| e.slot == slot).map(|e| e.xml.as_str()).collect()
-}
-
-/// Adds the kept package-root relationships (custom properties…) to `_rels/.rels`.
-pub fn write_package_rels(root: &mut Rels, out: &mut Out) {
-    for (ty, target, external) in std::mem::take(&mut out.kept.root) {
-        root.add_raw(&ty, &target, external);
-    }
-}
-
-/// A sheet's kept content being written.
-pub struct SheetKept<'a> {
-    p: Option<&'a Preserved>,
-    names: NameMap,
-    ids: HashMap<String, String>,
-}
-
-impl<'a> SheetKept<'a> {
-    /// Writes the sheet's kept parts and adds their relationships to the sheet's.
-    pub fn write(sheet: &'a Sheet, rels: &mut Rels, out: &mut Out) -> SheetKept<'a> {
-        let Some(p) = sheet.preserved.as_deref() else { return SheetKept { p: None, names: NameMap::new(), ids: HashMap::new() } };
-        let names = write_parts(out, &p.parts);
-        let ids = attach(rels, &p.rels, &names);
-        SheetKept { p: Some(p), names, ids }
-    }
-
-    fn vml(&self) -> Option<&'a PreservedPart> {
-        self.p?.vml.as_ref()
-    }
-
-    fn write_vml_rels(&self, vml: &PreservedPart, name: &str, out: &mut Out) {
-        if !vml.rels.is_empty() {
-            out.part(&rels_part_name(name), None, part_rels_xml(&vml.rels, &self.names).into_bytes());
-        }
-    }
-
-    /// GridCraft's notes VML for part `name`, merged with the kept control and object shapes.
-    pub fn notes_vml(&self, ours: String, name: &str, out: &mut Out) -> String {
-        let Some(vml) = self.vml() else { return ours };
-        self.write_vml_rels(vml, name, out);
-        merge_vml(&String::from_utf8_lossy(&vml.data), &ours)
-    }
-
-    /// The kept VML drawing of a sheet without notes; its new relationship id.
-    pub fn lone_vml(&self, rels: &mut Rels, out: &mut Out) -> Option<String> {
-        let vml = self.vml()?;
-        let name = out.kept.claim(&vml.name);
-        out.part(&name, Some(CT_VML), vml.data.to_vec());
-        self.write_vml_rels(vml, &name, out);
-        Some(rels.add("vmlDrawing", &format!("/{name}")))
-    }
-
-    /// The new relationship id for `<pageSetup r:id>` (printer settings).
-    pub fn page_setup_id(&self) -> Option<&str> {
-        let old = &self.p?.elements.iter().find(|e| e.slot == "pageSetup")?.xml;
-        self.ids.get(old).map(String::as_str)
-    }
-
-    /// The kept sheet elements, in schema order.
-    pub fn elements(&self) -> String {
-        let Some(p) = self.p else { return String::new() };
-        let mut s = String::new();
-        for slot in SHEET_SLOTS {
-            for e in p.elements.iter().filter(|e| e.slot == *slot) {
-                if let Some(x) = remap(&e.xml, &self.ids) {
-                    s.push_str(&x);
-                }
-            }
-        }
-        s
-    }
-}
-
-// ---------------------------------------------------------------- linked workbooks
-
-/// `wb` as it is saved into the folder `to` (absolute): the relative paths of its linked
-/// workbooks, relative to the folder it was read from, are rewritten relative to `to`, as Excel
-/// does on Save As, or made absolute when no relative path exists (another drive). `None` when
-/// nothing changes.
-pub fn rebase_links(wb: &Workbook, to: &Path) -> Option<Workbook> {
-    let p = wb.preserved.as_deref()?;
-    let from = Folder::of(wb.source_dir.as_deref()?)?;
-    let to = Folder::of(to)?;
-    if from == to {
-        return None;
-    }
-    let mut parts = p.parts.clone();
-    let mut changed = false;
-    for r in parts.iter_mut().flat_map(|part| part.rels.iter_mut()) {
-        if r.external
-            && is_kind(r, &["externalLinkPath"])
-            && let Some(target) = rebase(&r.target, &from, &to)
-        {
-            r.target = target;
-            changed = true;
-        }
-    }
-    if !changed {
-        return None;
-    }
-    let mut out = wb.clone();
-    out.preserved = Some(Arc::new(Preserved { parts, ..p.clone() }));
-    Some(out)
-}
-
-/// An absolute folder, lexically normalized.
-#[derive(PartialEq)]
-struct Folder {
-    /// Drive or share and root separator (`/`, `C:\`, `\\server\share\`).
-    root: String,
-    names: Vec<String>,
-}
-
-impl Folder {
-    fn of(dir: &Path) -> Option<Folder> {
-        if !dir.is_absolute() {
-            return None;
-        }
-        let mut f = Folder { root: String::new(), names: vec![] };
-        for c in dir.components() {
-            match c {
-                Component::Prefix(_) | Component::RootDir => f.root.push_str(&c.as_os_str().to_string_lossy()),
-                Component::CurDir => {}
-                Component::ParentDir => {
-                    f.names.pop();
-                }
-                Component::Normal(n) => f.names.push(n.to_string_lossy().into_owned()),
-            }
-        }
-        Some(f)
-    }
-}
-
-/// A relative link target read from `from`, rewritten for `to`. `None` keeps it as it is: an
-/// absolute path or URL, or a path that climbs above the root.
-fn rebase(target: &str, from: &Folder, to: &Folder) -> Option<String> {
-    if !is_relative_path(target) {
-        return None;
-    }
-    // Each name as the file system knows it, and as it is written in a target. Names taken from
-    // the original target keep their spelling.
-    let mut path: Vec<(String, String)> = from.names.iter().map(|n| (n.clone(), encode_name(n))).collect();
-    for seg in target.split(['/', '\\']) {
-        match seg {
-            "" | "." => {}
-            ".." => {
-                path.pop()?;
-            }
-            _ => path.push((decode_name(seg), seg.to_string())),
-        }
-    }
-    let folders = path.len().checked_sub(1)?;
-    if !from.root.eq_ignore_ascii_case(&to.root) {
-        let sep = if from.root.contains('\\') { "\\" } else { "/" };
-        let names: Vec<&str> = path.iter().map(|(name, _)| name.as_str()).collect();
-        return Some(format!("file:///{}{}", from.root, names.join(sep)));
-    }
-    let common = to.names.iter().zip(&path).take(folders).take_while(|(a, (b, _))| *a == b).count();
-    let up = "../".repeat(to.names.len().saturating_sub(common));
-    let down: Vec<&str> = path.iter().skip(common).map(|(_, written)| written.as_str()).collect();
-    Some(format!("{up}{}", down.join("/")))
-}
-
-/// Not empty, no root, no scheme or drive (`file:`, `http:`, `C:`).
-fn is_relative_path(target: &str) -> bool {
-    let scheme = target.split_once(':').is_some_and(|(s, _)| {
-        s.starts_with(|c: char| c.is_ascii_alphabetic()) && s.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
-    });
-    !target.is_empty() && !target.starts_with(['/', '\\']) && !scheme
-}
-
-/// A folder name as a segment of a relationship target (a URI): ASCII characters a URI path
-/// can't hold are percent-encoded, other characters are written as they are.
-fn encode_name(name: &str) -> String {
-    let mut s = String::with_capacity(name.len());
-    for c in name.chars() {
-        if !c.is_ascii() || c.is_ascii_alphanumeric() || "-._~!$&'()+,;=@".contains(c) {
-            s.push(c);
-        } else {
-            let _ = write!(s, "%{:02X}", c as u32);
-        }
-    }
-    s
-}
-
-/// A target segment with its percent-escapes decoded; as written when they don't decode to UTF-8.
-fn decode_name(seg: &str) -> String {
-    let b = seg.as_bytes();
-    let mut out = Vec::with_capacity(b.len());
-    let mut i = 0;
-    while let Some(&c) = b.get(i) {
-        let hex = b.get(i + 1..i + 3).and_then(|h| std::str::from_utf8(h).ok()).and_then(|h| u8::from_str_radix(h, 16).ok());
-        match hex {
-            Some(byte) if c == b'%' => {
-                out.push(byte);
-                i += 3;
-            }
-            _ => {
-                out.push(c);
-                i += 1;
-            }
-        }
-    }
-    String::from_utf8(out).unwrap_or_else(|_| seg.to_string())
-}
diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs
new file mode 100644
index 000000000..6be20d76d
--- /dev/null
+++ b/crates/xlsx/src/passthrough/read.rs
@@ -0,0 +1,688 @@
+use super::*;
+
+/// A part's relationships with full type URIs. `Ok(vec![])` when it has none; an error when the
+/// rels part is damaged or too large (its part then can't be kept faithfully).
+fn raw_rels(cx: &mut Ctx<'_>, part: &str) -> Result<Vec<PreservedRel>, String> {
+    let name = rels_part_name(part);
+    let bytes = match cx.pkg.read_limited(&name, MAX_META) {
+        Ok(Some(b)) => b,
+        Ok(None) => return Ok(vec![]),
+        Err(e) => return Err(e.to_string()),
+    };
+    let root = xml::parse(&bytes).map_err(|e| format!("{name}: {e}"))?;
+    let (dir, _) = package::split_dir(part);
+    let mut out = vec![];
+    for r in root.kids("Relationship") {
+        if out.len() >= MAX_RELS {
+            return Err(format!("{name}: too many relationships"));
+        }
+        let (Some(id), Some(target)) = (r.attr("Id"), r.attr("Target")) else { continue };
+        let external = r.attr("TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External"));
+        out.push(PreservedRel {
+            id: id.to_string(),
+            rel_type: r.attr("Type").unwrap_or("").to_string(),
+            target: if external { target.to_string() } else { package::resolve(dir, target) },
+            external,
+        });
+    }
+    Ok(out)
+}
+
+// ---------------------------------------------------------------- reading
+
+/// The `<sheet>` entries of the workbook that are chart sheets, each with the number of worksheets
+/// (model sheets) before it.
+fn chart_sheet_entries<'a>(wb_xml: &'a xml::El, wb_rels: &[PreservedRel], file_to_model: &[Option<usize>]) -> Vec<(usize, &'a xml::El)> {
+    let mut out = vec![];
+    let mut worksheets = 0usize;
+    for (i, se) in wb_xml.child("sheets").into_iter().flat_map(|s| s.kids("sheet")).enumerate() {
+        if file_to_model.get(i).copied().flatten().is_some() {
+            worksheets += 1;
+        } else if se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)).is_some_and(|r| is_kind(r, &["chartsheet"])) {
+            out.push((worksheets, se));
+        }
+    }
+    out
+}
+
+/// Collects kept content while a package is read.
+pub struct KeptReader {
+    on: bool,
+    strict: bool,
+    defaults: HashMap<String, String>,
+    overrides: HashMap<String, String>,
+    budget: usize,
+    parts_left: usize,
+}
+
+impl KeptReader {
+    pub fn new(cx: &mut Ctx<'_>) -> KeptReader {
+        let mut k = KeptReader {
+            on: true,
+            strict: false,
+            defaults: HashMap::new(),
+            overrides: HashMap::new(),
+            budget: kept_total(),
+            parts_left: MAX_KEPT_PARTS,
+        };
+        if let Ok(root) = raw_rels(cx, "")
+            && root.iter().any(|r| r.rel_type.starts_with("http://purl.oclc.org/"))
+        {
+            k.on = false;
+            k.strict = true;
+        }
+        match cx.pkg.read_limited("[Content_Types].xml", MAX_META).ok().flatten().and_then(|b| xml::parse(&b).ok()) {
+            Some(types) => {
+                for d in types.kids("Default") {
+                    if let (Some(e), Some(t)) = (d.attr("Extension"), d.attr("ContentType")) {
+                        k.defaults.insert(e.to_ascii_lowercase(), t.to_string());
+                    }
+                }
+                for o in types.kids("Override") {
+                    if let (Some(p), Some(t)) = (o.attr("PartName"), o.attr("ContentType")) {
+                        k.overrides.insert(normalize(p), t.to_string());
+                    }
+                }
+            }
+            None => k.on = false,
+        }
+        k
+    }
+
+    fn content_type(&self, part: &str) -> Option<String> {
+        let key = normalize(part);
+        if let Some(t) = self.overrides.get(&key) {
+            return Some(t.clone());
+        }
+        let (_, file) = package::split_dir(&key);
+        let ext = file.rsplit_once('.').map(|(_, e)| e)?;
+        self.defaults.get(ext).cloned()
+    }
+
+    /// The parts reachable from `root` that aren't in `seen` yet. Fails (and keeps nothing) when the
+    /// graph reaches rewritten content, a missing or damaged part, or a size limit.
+    fn closure(&mut self, cx: &mut Ctx<'_>, root: &PreservedRel, seen: &HashSet<String>, through: &[&str]) -> Result<Vec<PreservedPart>, String> {
+        if root.external {
+            return Ok(vec![]);
+        }
+        let blocked = |r: &PreservedRel| rewritten(r) && !through.iter().any(|k| k.eq_ignore_ascii_case(kind(&r.rel_type)));
+        if blocked(root) {
+            return Err(format!("it refers to {}", kind(&root.rel_type)));
+        }
+        let mut parts = vec![];
+        let mut bytes = 0usize;
+        let mut local: HashSet<String> = HashSet::new();
+        let mut queue = VecDeque::from([(root.target.clone(), 0usize)]);
+        while let Some((name, depth)) = queue.pop_front() {
+            let key = normalize(&name);
+            if seen.contains(&key) || !local.insert(key) {
+                continue;
+            }
+            if depth > MAX_CHAIN {
+                return Err("its relationships are nested too deeply".into());
+            }
+            if parts.len() >= self.parts_left {
+                return Err("it has too many parts".into());
+            }
+            let content_type = self.content_type(&name).ok_or_else(|| format!("{name} has no content type"))?;
+            let data = match cx.pkg.read_limited(&name, MAX_KEPT_PART) {
+                Ok(Some(d)) => d,
+                Ok(None) => return Err(format!("{name} is missing")),
+                Err(e) => return Err(e.to_string()),
+            };
+            bytes = bytes.saturating_add(data.len());
+            if bytes > self.budget {
+                return Err("it is too large".into());
+            }
+            let rels = raw_rels(cx, &name)?;
+            for r in rels.iter().filter(|r| !r.external) {
+                if blocked(r) {
+                    return Err(format!("it refers to {}", kind(&r.rel_type)));
+                }
+                queue.push_back((r.target.clone(), depth + 1));
+            }
+            parts.push(PreservedPart { name, content_type, data: Arc::from(data), rels });
+        }
+        self.budget = self.budget.saturating_sub(bytes);
+        self.parts_left = self.parts_left.saturating_sub(parts.len());
+        Ok(parts)
+    }
+
+    /// Keeps a set of relationships (all or nothing) and the parts behind them.
+    fn keep(&mut self, cx: &mut Ctx<'_>, p: &mut Preserved, roots: &[PreservedRel], seen: &mut HashSet<String>) -> Result<(), String> {
+        self.keep_through(cx, p, roots, seen, &[])
+    }
+
+    /// [`Self::keep`] for roots whose graph may reach the rewritten kinds in `through`.
+    fn keep_through(
+        &mut self,
+        cx: &mut Ctx<'_>,
+        p: &mut Preserved,
+        roots: &[PreservedRel],
+        seen: &mut HashSet<String>,
+        through: &[&str],
+    ) -> Result<(), String> {
+        let mut new_parts: Vec<PreservedPart> = vec![];
+        let mut scratch = seen.clone();
+        for r in roots {
+            let parts = self.closure(cx, r, &scratch, through)?;
+            scratch.extend(parts.iter().map(|q| normalize(&q.name)));
+            new_parts.extend(parts);
+        }
+        *seen = scratch;
+        p.parts.extend(new_parts);
+        for r in roots {
+            if !p.rels.iter().any(|x| x.id == r.id) {
+                p.rels.push(r.clone());
+            }
+        }
+        Ok(())
+    }
+
+    /// Package-root and workbook-level content.
+    pub fn workbook(&mut self, cx: &mut Ctx<'_>, wb_part: &str, wb_xml: &xml::El, file_to_model: &[Option<usize>]) -> Option<Arc<Preserved>> {
+        if !self.on {
+            let wb_rels = raw_rels(cx, wb_part).unwrap_or_default();
+            for (_, se) in chart_sheet_entries(wb_xml, &wb_rels, file_to_model) {
+                cx.warn(format!("chart sheet \"{}\" was skipped and is not kept on save", se.attr("name").unwrap_or("")));
+            }
+            if self.strict {
+                cx.warn("unmodelled content of a Strict Open XML workbook (custom XML, links, controls…) is not kept on save");
+            }
+            return None;
+        }
+        let mut p = Preserved::default();
+        let mut seen = HashSet::new();
+        // Package root: custom document properties, ribbon customisation, task panes.
+        if let Ok(root) = raw_rels(cx, "") {
+            for r in root.iter().filter(|r| is_kind(r, PACKAGE_ROOTS)) {
+                let mut q = Preserved::default();
+                match self.keep(cx, &mut q, std::slice::from_ref(r), &mut seen) {
+                    Ok(()) => {
+                        p.parts.extend(q.parts);
+                        p.package_rels.extend(q.rels);
+                    }
+                    Err(why) => cx.warn(format!("{} was dropped: {why}", kind(&r.rel_type))),
+                }
+            }
+        }
+        let wb_rels = raw_rels(cx, wb_part).unwrap_or_default();
+        for r in wb_rels.iter().filter(|r| is_kind(r, WORKBOOK_ROOTS)) {
+            if let Err(why) = self.keep(cx, &mut p, std::slice::from_ref(r), &mut seen) {
+                cx.warn(format!("{} part {} was dropped: {why}", kind(&r.rel_type), r.target));
+            }
+        }
+        // Chart sheets: the sheet entry (name, state, position) plus the chart sheet part and the
+        // drawing, chart, style and colour parts behind it.
+        for (worksheets, se) in chart_sheet_entries(wb_xml, &wb_rels, file_to_model) {
+            let name = se.attr("name").unwrap_or("").to_string();
+            let Some(r) = se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)) else { continue };
+            match self.keep_through(cx, &mut p, std::slice::from_ref(r), &mut seen, CHART_SHEET_GRAPH) {
+                Ok(()) => p.sheets.push(PreservedSheet {
+                    name,
+                    visibility: match se.attr("state") {
+                        Some("hidden") => Visibility::Hidden,
+                        Some("veryHidden") => Visibility::VeryHidden,
+                        _ => Visibility::Visible,
+                    },
+                    rel_id: r.id.clone(),
+                    before: worksheets,
+                    sheet_id: se.attr_u32("sheetId").unwrap_or(0),
+                }),
+                Err(why) => cx.warn(format!("chart sheet \"{name}\" was dropped: {why}")),
+            }
+        }
+        // Links to external workbooks: `[1]` in formulas is the position in <externalReferences>,
+        // so they are kept all together or not at all.
+        let ids: Vec<&str> =
+            wb_xml.child("externalReferences").map(|e| e.kids("externalReference").filter_map(|x| x.attr("id")).collect()).unwrap_or_default();
+        if !ids.is_empty() {
+            let roots: Option<Vec<PreservedRel>> =
+                ids.iter().map(|id| wb_rels.iter().find(|r| r.id == *id && is_kind(r, &["externalLink"])).cloned()).collect();
+            let kept = match roots {
+                Some(roots) => self.keep(cx, &mut p, &roots, &mut seen),
+                None => Err("a link has no part".into()),
+            };
+            match kept {
+                Ok(()) => {
+                    let mut x = format!("<externalReferences xmlns:r=\"{NS_REL}\">");
+                    for id in &ids {
+                        let _ = write!(x, "<externalReference r:id=\"{}\"/>", esc_attr(id));
+                    }
+                    x.push_str("</externalReferences>");
+                    p.elements.push(PreservedXml { slot: "externalReferences".into(), xml: x });
+                    cx.warn("links to external workbooks were kept; they are not followed or refreshed");
+                }
+                Err(why) => cx.warn(format!("links to external workbooks were dropped: {why}")),
+            }
+        }
+        // Excel trusts the saved cell values only when both are present; without them it
+        // recalculates everything on open, and links into closed workbooks come back as errors.
+        if let Some(v) = wb_xml.child("fileVersion") {
+            let mut x = String::from("<fileVersion");
+            for k in FILE_VERSION_ATTRS {
+                if let Some(a) = v.attr(k) {
+                    let _ = write!(x, " {k}=\"{}\"", esc_attr(a));
+                }
+            }
+            x.push_str("/>");
+            p.elements.push(PreservedXml { slot: "fileVersion".into(), xml: x });
+        }
+        let calc_features = wb_xml
+            .child("extLst")
+            .and_then(|l| l.kids("ext").find(|e| e.attr("uri").is_some_and(|u| u.eq_ignore_ascii_case(CALC_FEATURES_URI))))
+            .and_then(|e| e.child("calcFeatures"));
+        if let Some(c) = calc_features {
+            let mut x = format!("<ext uri=\"{CALC_FEATURES_URI}\" xmlns:xcalcf=\"{NS_CALC_FEATURES}\"><xcalcf:calcFeatures>");
+            for name in c.kids("feature").filter_map(|f| f.attr("name")) {
+                let _ = write!(x, "<xcalcf:feature name=\"{}\"/>", esc_attr(name));
+            }
+            x.push_str("</xcalcf:calcFeatures></ext>");
+            p.elements.push(PreservedXml { slot: "ext".into(), xml: x });
+        }
+        (!p.is_empty()).then(|| Arc::new(p))
+    }
+
+    /// Sheet-level content of the sheet part `part`.
+    pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str) -> Option<Arc<Preserved>> {
+        if !self.on {
+            return None;
+        }
+        let rels = match raw_rels(cx, part) {
+            Ok(r) => r,
+            Err(e) => {
+                cx.warn(format!("sheet \"{name}\": relationships could not be read ({e}); unmodelled content was dropped"));
+                return None;
+            }
+        };
+        let mut p = Preserved::default();
+        let mut seen = HashSet::new();
+        for r in rels.iter().filter(|r| is_kind(r, SHEET_ROOTS)) {
+            if let Err(why) = self.keep(cx, &mut p, std::slice::from_ref(r), &mut seen) {
+                cx.warn(format!("sheet \"{name}\": {} was dropped: {why}", kind(&r.rel_type)));
+            }
+        }
+        // Notes have one VML drawing per sheet; another one holds the header and footer pictures.
+        let vml_drawings = rels.iter().filter(|r| is_kind(r, &["vmlDrawing"])).count();
+        let notes = rels.iter().filter(|r| is_kind(r, &["comments"])).count();
+        if rels.iter().any(|r| is_kind(r, SHEET_ELEMENT_KINDS)) || vml_drawings > notes {
+            self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen);
+        }
+        (!p.is_empty()).then(|| Arc::new(p))
+    }
+
+    fn sheet_elements(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, rels: &[PreservedRel], p: &mut Preserved, seen: &mut HashSet<String>) {
+        let scan = match cx.pkg.read(part) {
+            Ok(Some(bytes)) => scan_sheet(&bytes),
+            _ => None,
+        };
+        let Some(scan) = scan else {
+            cx.warn(format!("sheet \"{name}\": controls and embedded objects could not be read and were dropped"));
+            return;
+        };
+        // Printer settings (a binary part per sheet) hang off <pageSetup r:id>.
+        if let Some(id) = scan.page_setup.as_deref()
+            && let Some(r) = rels.iter().find(|r| r.id == id && is_kind(r, &["printerSettings"]))
+        {
+            match self.keep(cx, p, std::slice::from_ref(r), seen) {
+                Ok(()) => p.elements.push(PreservedXml { slot: "pageSetup".into(), xml: r.id.clone() }),
+                Err(why) => cx.warn(format!("sheet \"{name}\": printer settings were dropped: {why}")),
+            }
+        }
+        // Header and footer pictures (`&G`): a VML drawing of their own and the images it shows,
+        // kept byte for byte (GridCraft writes the header text, not the pictures).
+        if let Some(id) = scan.legacy_drawing_hf.as_deref()
+            && scan.legacy_drawing.as_deref() != Some(id)
+            && let Some(r) = rels.iter().find(|r| r.id == id && is_kind(r, &["vmlDrawing"]))
+        {
+            match self.keep_through(cx, p, std::slice::from_ref(r), seen, &["vmlDrawing"]) {
+                Ok(()) => {
+                    let xml = format!("<legacyDrawingHF xmlns:r=\"{NS_REL}\" r:id=\"{}\"/>", esc_attr(&r.id));
+                    p.elements.push(PreservedXml { slot: "legacyDrawingHF".into(), xml });
+                    cx.warn(format!("sheet \"{name}\": pictures in the header and footer are not shown; they are kept for saving"));
+                }
+                Err(why) => cx.warn(format!("sheet \"{name}\": header and footer pictures were dropped: {why}")),
+            }
+        }
+        let mut frags = scan.fragments;
+        // Controls and OLE objects are drawn from shapes in the legacy VML drawing.
+        if frags.iter().any(|(slot, _)| slot != "picture") {
+            match self.vml(cx, rels, scan.legacy_drawing.as_deref(), seen) {
+                Ok((vml, parts)) => {
+                    p.parts.extend(parts);
+                    p.vml = Some(vml);
+                }
+                Err(why) => {
+                    cx.warn(format!("sheet \"{name}\": controls and embedded objects were dropped: {why}"));
+                    frags.retain(|(slot, _)| slot == "picture");
+                }
+            }
+        }
+        for (slot, x) in frags {
+            let mut ids = vec![];
+            let ok = map_rel_ids(&x, &mut |id| {
+                ids.push(id.to_string());
+                Some(id.to_string())
+            })
+            .is_some();
+            let roots: Option<Vec<PreservedRel>> = ids.iter().map(|id| rels.iter().find(|r| r.id == *id).cloned()).collect();
+            let kept = match (ok, roots) {
+                (true, Some(roots)) => self.keep(cx, p, &roots, seen),
+                (false, _) => Err("its XML is damaged".into()),
+                (_, None) => Err("it refers to a missing relationship".into()),
+            };
+            match kept {
+                Ok(()) => p.elements.push(PreservedXml { slot, xml: x }),
+                Err(why) => cx.warn(format!("sheet \"{name}\": {slot} were dropped: {why}")),
+            }
+        }
+        if p.elements.iter().any(|e| e.slot == "oleObjects" || e.slot == "controls") {
+            cx.warn(format!("sheet \"{name}\": embedded objects and form controls are not shown; they are kept for saving"));
+        } else {
+            p.vml = None;
+        }
+    }
+
+    /// The sheet's VML drawing without its notes (GridCraft writes those), and the parts its
+    /// shapes refer to (preview images).
+    fn vml(
+        &mut self,
+        cx: &mut Ctx<'_>,
+        rels: &[PreservedRel],
+        rid: Option<&str>,
+        seen: &mut HashSet<String>,
+    ) -> Result<(PreservedPart, Vec<PreservedPart>), String> {
+        let rel = rid.and_then(|id| rels.iter().find(|r| r.id == id && !r.external)).ok_or("the sheet has no VML drawing")?;
+        // Charged to the kept total like any other part: many sheets can point at one highly
+        // compressed VML drawing, and each keeps its own copy.
+        if self.budget == 0 {
+            return Err("it is too large".into());
+        }
+        let limit = MAX_META.min(u64::try_from(self.budget).unwrap_or(u64::MAX));
+        let data = match cx.pkg.read_limited(&rel.target, limit) {
+            Ok(Some(d)) => d,
+            Ok(None) => return Err(format!("{} is missing", rel.target)),
+            Err(IoError::TooLarge(_)) => return Err("it is too large".into()),
+            Err(e) => return Err(e.to_string()),
+        };
+        self.budget = self.budget.saturating_sub(data.len());
+        let text = String::from_utf8(data).map_err(|_| "the VML drawing is not UTF-8".to_string())?;
+        let text = strip_notes(&text);
+        let vrels = raw_rels(cx, &rel.target)?;
+        let mut q = Preserved::default();
+        let roots: Vec<PreservedRel> = vrels.iter().filter(|r| !r.external).cloned().collect();
+        self.keep(cx, &mut q, &roots, seen)?;
+        let vml = PreservedPart { name: rel.target.clone(), content_type: CT_VML.into(), data: Arc::from(text.into_bytes()), rels: vrels };
+        Ok((vml, q.parts))
+    }
+}
+
+/// What a sheet part holds for pass-through.
+struct SheetScan {
+    /// (slot, XML with the namespace declarations it needs).
+    fragments: Vec<(String, String)>,
+    legacy_drawing: Option<String>,
+    /// The relationship id on `<legacyDrawingHF>` (header and footer pictures).
+    legacy_drawing_hf: Option<String>,
+    /// The relationship id on `<pageSetup>` (printer settings).
+    page_setup: Option<String>,
+}
+
+/// Finds the sheet's `<picture>`, `<oleObjects>`, `<controls>` (also inside
+/// `<mc:AlternateContent>`) and the `<legacyDrawing>` and `<legacyDrawingHF>` ids. `None` when the XML is damaged.
+fn scan_sheet(bytes: &[u8]) -> Option<SheetScan> {
+    let data = xml::to_utf8(bytes);
+    let text = std::str::from_utf8(&data).ok()?;
+    let mut reader = Reader::from_str(text);
+    let mut decls: Vec<(String, String)> = vec![];
+    let mut out = SheetScan { fragments: vec![], legacy_drawing: None, legacy_drawing_hf: None, page_setup: None };
+    let mut in_root = false;
+    loop {
+        let start = usize::try_from(reader.buffer_position()).ok()?;
+        match reader.read_event().ok()? {
+            Event::Eof => break,
+            Event::Start(e) if !in_root => {
+                in_root = true;
+                for a in e.attributes().with_checks(false).flatten() {
+                    if let Some(p) = a.key.as_ref().strip_prefix(b"xmlns:")
+                        && let (Ok(p), Ok(v)) = (std::str::from_utf8(p), std::str::from_utf8(&a.value))
+                        && !v.contains('"')
+                    {
+                        decls.push((p.to_string(), v.to_string()));
+                    }
+                }
+            }
+            Event::Start(e) => {
+                let local = e.local_name().as_ref().to_vec();
+                match local.as_slice() {
+                    b"pageSetup" => out.page_setup = rel_id_attr(&e),
+                    b"legacyDrawing" => out.legacy_drawing = rel_id_attr(&e),
+                    b"legacyDrawingHF" => out.legacy_drawing_hf = rel_id_attr(&e),
+                    _ => {}
+                }
+                reader.read_to_end(e.name()).ok()?;
+                let end = usize::try_from(reader.buffer_position()).ok()?;
+                let wanted = matches!(local.as_slice(), b"picture" | b"oleObjects" | b"controls" | b"AlternateContent");
+                if wanted && end.saturating_sub(start) <= MAX_FRAGMENT {
+                    let frag = text.get(start..end)?;
+                    push_fragment(&mut out, frag, &local, &decls);
+                }
+            }
+            Event::Empty(e) if in_root => {
+                let local = e.local_name().as_ref().to_vec();
+                if local == b"legacyDrawing" || local == b"legacyDrawingHF" || local == b"pageSetup" {
+                    let id = rel_id_attr(&e);
+                    match local.as_slice() {
+                        b"pageSetup" => out.page_setup = id,
+                        b"legacyDrawing" => out.legacy_drawing = id,
+                        _ => out.legacy_drawing_hf = id,
+                    }
+                } else if local == b"picture"
+                    && let Some(frag) = text.get(start..usize::try_from(reader.buffer_position()).ok()?)
+                {
+                    push_fragment(&mut out, frag, &local, &decls);
+                }
+            }
+            Event::End(_) => break,
+            _ => {}
+        }
+    }
+    Some(out)
+}
+
+/// The `r:id` of an element (an `id` attribute with a namespace prefix).
+fn rel_id_attr(e: &BytesStart<'_>) -> Option<String> {
+    e.attributes()
+        .with_checks(false)
+        .flatten()
+        .find(|a| a.key.local_name().as_ref() == b"id" && a.key.prefix().is_some())
+        .and_then(|a| String::from_utf8(a.value.to_vec()).ok())
+}
+
+fn push_fragment(out: &mut SheetScan, frag: &str, local: &[u8], decls: &[(String, String)]) {
+    let frag = with_decls(frag, decls);
+    let slot = if local == b"AlternateContent" {
+        // The kept element is the one the first choice holds.
+        let Ok(el) = xml::parse(frag.as_bytes()) else { return };
+        match el.child("Choice").and_then(|c| c.children.first()) {
+            Some(c) => c.name.clone(),
+            None => return,
+        }
+    } else {
+        String::from_utf8_lossy(local).into_owned()
+    };
+    if SHEET_SLOTS.contains(&slot.as_str()) && !out.fragments.iter().any(|(s, _)| *s == slot) {
+        out.fragments.push((slot, frag));
+    }
+}
+
+/// Adds the root's namespace declarations a fragment doesn't declare itself.
+fn with_decls(frag: &str, decls: &[(String, String)]) -> String {
+    let Some(name_end) = frag.char_indices().skip(1).find(|(_, c)| c.is_whitespace() || *c == '/' || *c == '>').map(|(i, _)| i) else {
+        return frag.to_string();
+    };
+    let head = frag.get(..frag.find('>').unwrap_or(frag.len())).unwrap_or("");
+    let mut add = String::new();
+    for (p, v) in decls {
+        if !head.contains(&format!("xmlns:{p}=")) {
+            let _ = write!(add, " xmlns:{p}=\"{v}\"");
+        }
+    }
+    format!("{}{add}{}", frag.get(..name_end).unwrap_or(""), frag.get(name_end..).unwrap_or(""))
+}
+
+/// Byte ranges of the `<v:shape …>…</v:shape>` (or self-closed) elements in VML text.
+fn shape_spans(vml: &str) -> Vec<(usize, usize)> {
+    let mut spans = vec![];
+    let mut from = 0;
+    while let Some(i) = vml.get(from..).and_then(|s| s.find("<v:shape")).map(|i| i + from) {
+        let after = i + "<v:shape".len();
+        let is_shape = vml.get(after..).and_then(|s| s.chars().next()).is_some_and(|c| c.is_whitespace() || c == '>' || c == '/');
+        if !is_shape {
+            from = after;
+            continue;
+        }
+        let Some(tag_end) = vml.get(i..).and_then(|s| s.find('>')).map(|j| i + j + 1) else { break };
+        let end = if vml.get(..tag_end).is_some_and(|t| t.ends_with("/>")) {
+            tag_end
+        } else {
+            match vml.get(tag_end..).and_then(|s| s.find("</v:shape>")) {
+                Some(j) => tag_end + j + "</v:shape>".len(),
+                None => break,
+            }
+        };
+        spans.push((i, end));
+        from = end;
+    }
+    spans
+}
+
+/// VML without its note shapes (`ObjectType="Note"`).
+fn strip_notes(vml: &str) -> String {
+    let mut out = String::with_capacity(vml.len());
+    let mut last = 0;
+    for (a, b) in shape_spans(vml) {
+        let shape = vml.get(a..b).unwrap_or("");
+        if shape.contains("ObjectType=\"Note\"") {
+            out.push_str(vml.get(last..a).unwrap_or(""));
+            last = b;
+        }
+    }
+    out.push_str(vml.get(last..).unwrap_or(""));
+    out
+}
+
+/// Shape numbers (`_x0000_s1025` → 1025) used in VML text.
+fn shape_numbers(vml: &str) -> Vec<u64> {
+    vml.match_indices("_x0000_s")
+        .filter_map(|(i, m)| {
+            let digits: String = vml.get(i + m.len()..)?.chars().take_while(char::is_ascii_digit).take(18).collect();
+            digits.parse().ok()
+        })
+        .collect()
+}
+
+/// The highest shape block VML text claims in `<o:idmap data>` or uses in a shape id.
+pub(super) fn vml_block_max(vml: &str) -> u64 {
+    let used = shape_numbers(vml).into_iter().max().unwrap_or(0) / 1024;
+    let claimed = vml
+        .find("<o:idmap")
+        .and_then(|i| vml.get(i..)?.find("data=\"").map(|d| i + d + "data=\"".len()))
+        .and_then(|d| Some((d, d + vml.get(d..)?.find('"')?)))
+        .and_then(|(d, e)| vml.get(d..e))
+        .map(|list| list.split(',').filter_map(|b| b.trim().parse::<u64>().ok()).max().unwrap_or(0))
+        .unwrap_or(0);
+    used.max(claimed)
+}
+
+/// Kept VML (controls, OLE objects) plus GridCraft's note shapes: the notes get ids in a fresh
+/// shape block so they can't collide with the kept shapes the sheet XML refers to.
+pub(super) fn merge_vml(kept: &str, ours: &str) -> String {
+    let Some(close) = kept.rfind("</xml>") else { return ours.to_string() };
+    let block = shape_numbers(kept).into_iter().max().unwrap_or(0) / 1024 + 1;
+    let mut add = String::new();
+    if !kept.contains("id=\"_x0000_t202\"")
+        && let Some(i) = ours.find("<v:shapetype")
+        && let Some(j) = ours.get(i..).and_then(|s| s.find("</v:shapetype>"))
+    {
+        add.push_str(ours.get(i..i + j + "</v:shapetype>".len()).unwrap_or(""));
+    }
+    for (k, (a, b)) in shape_spans(ours).into_iter().enumerate() {
+        let shape = ours.get(a..b).unwrap_or("");
+        let id = block.saturating_mul(1024).saturating_add(1 + k as u64);
+        match (shape.find("id=\"_x0000_s"), shape.find("id=\"_x0000_s").and_then(|i| shape.get(i + 4..)?.find('"').map(|j| i + 4 + j))) {
+            (Some(i), Some(j)) => {
+                let _ = write!(add, "{}id=\"_x0000_s{id}\"{}", shape.get(..i).unwrap_or(""), shape.get(j + 1..).unwrap_or(""));
+            }
+            _ => add.push_str(shape),
+        }
+    }
+    let mut head = kept.get(..close).unwrap_or("").to_string();
+    // Claim the block in the drawing's id map.
+    if let Some(i) = head.find("<o:idmap")
+        && let Some(d) = head.get(i..).and_then(|s| s.find("data=\"")).map(|d| i + d + "data=\"".len())
+        && let Some(e) = head.get(d..).and_then(|s| s.find('"')).map(|e| d + e)
+    {
+        head.insert_str(e, &format!(",{block}"));
+    }
+    format!("{head}{add}{}", kept.get(close..).unwrap_or(""))
+}
+
+/// Rewrites relationship-id attributes (`r:id`, `r:embed`…: any attribute in the relationships
+/// namespace) of an XML fragment through `map`. `None` when the fragment is damaged or `map` has
+/// no id for one of them.
+pub fn map_rel_ids(x: &str, map: &mut dyn FnMut(&str) -> Option<String>) -> Option<String> {
+    let mut reader = Reader::from_str(x);
+    let mut writer = Writer::new(Vec::with_capacity(x.len()));
+    let mut prefixes: HashSet<Vec<u8>> = HashSet::new();
+    let mut depth = 0usize;
+    loop {
+        match reader.read_event().ok()? {
+            Event::Eof => break,
+            Event::Start(e) => {
+                depth += 1;
+                if depth > MAX_FRAGMENT_DEPTH {
+                    return None;
+                }
+                let e = map_start(&e, &mut prefixes, map)?;
+                writer.write_event(Event::Start(e)).ok()?;
+            }
+            Event::Empty(e) => {
+                let e = map_start(&e, &mut prefixes, map)?;
+                writer.write_event(Event::Empty(e)).ok()?;
+            }
+            Event::End(e) => {
+                depth = depth.saturating_sub(1);
+                writer.write_event(Event::End(e)).ok()?;
+            }
+            ev => writer.write_event(ev).ok()?,
+        }
+    }
+    String::from_utf8(writer.into_inner()).ok()
+}
+
+fn map_start(e: &BytesStart<'_>, prefixes: &mut HashSet<Vec<u8>>, map: &mut dyn FnMut(&str) -> Option<String>) -> Option<BytesStart<'static>> {
+    for a in e.attributes().with_checks(false) {
+        let a = a.ok()?;
+        if let Some(p) = a.key.as_ref().strip_prefix(b"xmlns:")
+            && (a.value.as_ref() == NS_REL.as_bytes() || a.value.as_ref() == NS_REL_STRICT.as_bytes())
+        {
+            prefixes.insert(p.to_vec());
+        }
+    }
+    let name = String::from_utf8(e.name().as_ref().to_vec()).ok()?;
+    let mut out = BytesStart::new(name);
+    for a in e.attributes().with_checks(false) {
+        let a = a.ok()?;
+        let key = a.key.as_ref();
+        let is_rel = !key.starts_with(b"xmlns") && a.key.prefix().is_some_and(|p| prefixes.contains(p.as_ref()));
+        if is_rel {
+            let old = std::str::from_utf8(&a.value).ok()?;
+            let new = map(old)?;
+            out.push_attribute(Attribute { key: QName(key), value: Cow::Owned(esc_attr(&new).into_bytes()) });
+        } else {
+            out.push_attribute(Attribute { key: QName(key), value: a.value.clone() });
+        }
+    }
+    Some(out)
+}
diff --git a/crates/xlsx/src/passthrough/rebase.rs b/crates/xlsx/src/passthrough/rebase.rs
new file mode 100644
index 000000000..d758f86d6
--- /dev/null
+++ b/crates/xlsx/src/passthrough/rebase.rs
@@ -0,0 +1,199 @@
+use super::read::merge_vml;
+use super::write::{NameMap, attach, part_rels_xml, remap, write_parts};
+use super::*;
+
+/// A sheet's kept content being written.
+pub struct SheetKept<'a> {
+    p: Option<&'a Preserved>,
+    names: NameMap,
+    ids: HashMap<String, String>,
+}
+
+impl<'a> SheetKept<'a> {
+    /// Writes the sheet's kept parts and adds their relationships to the sheet's.
+    pub fn write(sheet: &'a Sheet, rels: &mut Rels, out: &mut Out) -> SheetKept<'a> {
+        let Some(p) = sheet.preserved.as_deref() else { return SheetKept { p: None, names: NameMap::new(), ids: HashMap::new() } };
+        let names = write_parts(out, &p.parts);
+        let ids = attach(rels, &p.rels, &names);
+        SheetKept { p: Some(p), names, ids }
+    }
+
+    fn vml(&self) -> Option<&'a PreservedPart> {
+        self.p?.vml.as_ref()
+    }
+
+    fn write_vml_rels(&self, vml: &PreservedPart, name: &str, out: &mut Out) {
+        if !vml.rels.is_empty() {
+            out.part(&rels_part_name(name), None, part_rels_xml(&vml.rels, &self.names).into_bytes());
+        }
+    }
+
+    /// GridCraft's notes VML for part `name`, merged with the kept control and object shapes.
+    pub fn notes_vml(&self, ours: String, name: &str, out: &mut Out) -> String {
+        let Some(vml) = self.vml() else { return ours };
+        self.write_vml_rels(vml, name, out);
+        merge_vml(&String::from_utf8_lossy(&vml.data), &ours)
+    }
+
+    /// The kept VML drawing of a sheet without notes; its new relationship id.
+    pub fn lone_vml(&self, rels: &mut Rels, out: &mut Out) -> Option<String> {
+        let vml = self.vml()?;
+        let name = out.kept.claim(&vml.name);
+        out.part(&name, Some(CT_VML), vml.data.to_vec());
+        self.write_vml_rels(vml, &name, out);
+        Some(rels.add("vmlDrawing", &format!("/{name}")))
+    }
+
+    /// The new relationship id for `<pageSetup r:id>` (printer settings).
+    pub fn page_setup_id(&self) -> Option<&str> {
+        let old = &self.p?.elements.iter().find(|e| e.slot == "pageSetup")?.xml;
+        self.ids.get(old).map(String::as_str)
+    }
+
+    /// The kept sheet elements, in schema order.
+    pub fn elements(&self) -> String {
+        let Some(p) = self.p else { return String::new() };
+        let mut s = String::new();
+        for slot in SHEET_SLOTS {
+            for e in p.elements.iter().filter(|e| e.slot == *slot) {
+                if let Some(x) = remap(&e.xml, &self.ids) {
+                    s.push_str(&x);
+                }
+            }
+        }
+        s
+    }
+}
+
+// ---------------------------------------------------------------- linked workbooks
+
+/// `wb` as it is saved into the folder `to` (absolute): the relative paths of its linked
+/// workbooks, relative to the folder it was read from, are rewritten relative to `to`, as Excel
+/// does on Save As, or made absolute when no relative path exists (another drive). `None` when
+/// nothing changes.
+pub fn rebase_links(wb: &Workbook, to: &Path) -> Option<Workbook> {
+    let p = wb.preserved.as_deref()?;
+    let from = Folder::of(wb.source_dir.as_deref()?)?;
+    let to = Folder::of(to)?;
+    if from == to {
+        return None;
+    }
+    let mut parts = p.parts.clone();
+    let mut changed = false;
+    for r in parts.iter_mut().flat_map(|part| part.rels.iter_mut()) {
+        if r.external
+            && is_kind(r, &["externalLinkPath"])
+            && let Some(target) = rebase(&r.target, &from, &to)
+        {
+            r.target = target;
+            changed = true;
+        }
+    }
+    if !changed {
+        return None;
+    }
+    let mut out = wb.clone();
+    out.preserved = Some(Arc::new(Preserved { parts, ..p.clone() }));
+    Some(out)
+}
+
+/// An absolute folder, lexically normalized.
+#[derive(PartialEq)]
+struct Folder {
+    /// Drive or share and root separator (`/`, `C:\`, `\\server\share\`).
+    root: String,
+    names: Vec<String>,
+}
+
+impl Folder {
+    fn of(dir: &Path) -> Option<Folder> {
+        if !dir.is_absolute() {
+            return None;
+        }
+        let mut f = Folder { root: String::new(), names: vec![] };
+        for c in dir.components() {
+            match c {
+                Component::Prefix(_) | Component::RootDir => f.root.push_str(&c.as_os_str().to_string_lossy()),
+                Component::CurDir => {}
+                Component::ParentDir => {
+                    f.names.pop();
+                }
+                Component::Normal(n) => f.names.push(n.to_string_lossy().into_owned()),
+            }
+        }
+        Some(f)
+    }
+}
+
+/// A relative link target read from `from`, rewritten for `to`. `None` keeps it as it is: an
+/// absolute path or URL, or a path that climbs above the root.
+fn rebase(target: &str, from: &Folder, to: &Folder) -> Option<String> {
+    if !is_relative_path(target) {
+        return None;
+    }
+    // Each name as the file system knows it, and as it is written in a target. Names taken from
+    // the original target keep their spelling.
+    let mut path: Vec<(String, String)> = from.names.iter().map(|n| (n.clone(), encode_name(n))).collect();
+    for seg in target.split(['/', '\\']) {
+        match seg {
+            "" | "." => {}
+            ".." => {
+                path.pop()?;
+            }
+            _ => path.push((decode_name(seg), seg.to_string())),
+        }
+    }
+    let folders = path.len().checked_sub(1)?;
+    if !from.root.eq_ignore_ascii_case(&to.root) {
+        let sep = if from.root.contains('\\') { "\\" } else { "/" };
+        let names: Vec<&str> = path.iter().map(|(name, _)| name.as_str()).collect();
+        return Some(format!("file:///{}{}", from.root, names.join(sep)));
+    }
+    let common = to.names.iter().zip(&path).take(folders).take_while(|(a, (b, _))| *a == b).count();
+    let up = "../".repeat(to.names.len().saturating_sub(common));
+    let down: Vec<&str> = path.iter().skip(common).map(|(_, written)| written.as_str()).collect();
+    Some(format!("{up}{}", down.join("/")))
+}
+
+/// Not empty, no root, no scheme or drive (`file:`, `http:`, `C:`).
+fn is_relative_path(target: &str) -> bool {
+    let scheme = target.split_once(':').is_some_and(|(s, _)| {
+        s.starts_with(|c: char| c.is_ascii_alphabetic()) && s.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
+    });
+    !target.is_empty() && !target.starts_with(['/', '\\']) && !scheme
+}
+
+/// A folder name as a segment of a relationship target (a URI): ASCII characters a URI path
+/// can't hold are percent-encoded, other characters are written as they are.
+fn encode_name(name: &str) -> String {
+    let mut s = String::with_capacity(name.len());
+    for c in name.chars() {
+        if !c.is_ascii() || c.is_ascii_alphanumeric() || "-._~!$&'()+,;=@".contains(c) {
+            s.push(c);
+        } else {
+            let _ = write!(s, "%{:02X}", c as u32);
+        }
+    }
+    s
+}
+
+/// A target segment with its percent-escapes decoded; as written when they don't decode to UTF-8.
+fn decode_name(seg: &str) -> String {
+    let b = seg.as_bytes();
+    let mut out = Vec::with_capacity(b.len());
+    let mut i = 0;
+    while let Some(&c) = b.get(i) {
+        let hex = b.get(i + 1..i + 3).and_then(|h| std::str::from_utf8(h).ok()).and_then(|h| u8::from_str_radix(h, 16).ok());
+        match hex {
+            Some(byte) if c == b'%' => {
+                out.push(byte);
+                i += 3;
+            }
+            _ => {
+                out.push(c);
+                i += 1;
+            }
+        }
+    }
+    String::from_utf8(out).unwrap_or_else(|_| seg.to_string())
+}
diff --git a/crates/xlsx/src/passthrough/write.rs b/crates/xlsx/src/passthrough/write.rs
new file mode 100644
index 000000000..8b8d24591
--- /dev/null
+++ b/crates/xlsx/src/passthrough/write.rs
@@ -0,0 +1,325 @@
+use super::read::{map_rel_ids, vml_block_max};
+use super::*;
+
+// ---------------------------------------------------------------- writing
+
+/// Names given to kept parts while a package is written.
+#[derive(Default)]
+pub struct KeptOut {
+    used: HashSet<String>,
+    n: u32,
+    /// The highest VML shape block a kept header and footer drawing uses: notes go after it.
+    vml_blocks: u32,
+    /// Package-root relationships (type, target, external), added when `_rels/.rels` is written.
+    root: Vec<(String, String, bool)>,
+}
+
+impl KeptOut {
+    /// Reserves the VML shape blocks the kept header and footer drawings of `wb` use, so that the
+    /// notes drawings GridCraft writes don't reuse their shape ids.
+    pub fn reserve_vml_blocks(&mut self, wb: &Workbook) {
+        let vmls =
+            wb.sheets.iter().filter_map(|s| s.preserved.as_deref()).flat_map(|p| &p.parts).filter(|q| q.content_type.eq_ignore_ascii_case(CT_VML));
+        let max = vmls.map(|q| vml_block_max(&String::from_utf8_lossy(&q.data))).max().unwrap_or(0);
+        self.vml_blocks = u32::try_from(max).unwrap_or(u32::MAX);
+    }
+
+    /// The shape block of the `n`th notes drawing.
+    pub fn notes_block(&self, n: u32) -> u32 {
+        n.saturating_add(self.vml_blocks)
+    }
+
+    /// A part name for a kept part: its original name when that can't collide with anything
+    /// written, otherwise a fresh one in the same folder.
+    pub(super) fn claim(&mut self, original: &str) -> String {
+        let lower = original.to_ascii_lowercase();
+        let own = OWN_DIRS.iter().any(|d| lower.starts_with(d));
+        if own && self.used.insert(lower) {
+            return original.to_string();
+        }
+        let (dir, file) = package::split_dir(original);
+        let (stem, ext) = match file.rsplit_once('.') {
+            Some((s, e)) => (s, format!(".{e}")),
+            None => (file, String::new()),
+        };
+        let stem = if own { format!("{stem}_") } else { "kept".to_string() };
+        loop {
+            self.n = self.n.saturating_add(1);
+            let file = format!("{stem}{}{ext}", self.n);
+            let cand = if dir.is_empty() { file } else { format!("{dir}/{file}") };
+            if self.used.insert(cand.to_ascii_lowercase()) || self.n == u32::MAX {
+                return cand;
+            }
+        }
+    }
+}
+
+/// Original part name (normalized) → written part name.
+pub(super) type NameMap = HashMap<String, String>;
+
+fn rel_target(r: &PreservedRel, names: &NameMap) -> Option<String> {
+    if r.external { Some(r.target.clone()) } else { names.get(&normalize(&r.target)).map(|n| format!("/{n}")) }
+}
+
+/// A kept part's relationships, ids unchanged, targets renamed.
+pub(super) fn part_rels_xml(rels: &[PreservedRel], names: &NameMap) -> String {
+    let mut s = format!("{XML_DECL}<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
+    for r in rels {
+        let Some(target) = rel_target(r, names) else { continue };
+        let _ = write!(
+            s,
+            "<Relationship Id=\"{}\" Type=\"{}\" Target=\"{}\"{}/>",
+            esc_attr(&r.id),
+            esc_attr(&r.rel_type),
+            esc_attr(&target),
+            if r.external { " TargetMode=\"External\"" } else { "" }
+        );
+    }
+    s.push_str("</Relationships>");
+    s
+}
+
+pub(super) fn write_parts(out: &mut Out, parts: &[PreservedPart]) -> NameMap {
+    let mut names = NameMap::new();
+    for p in parts {
+        names.entry(normalize(&p.name)).or_insert_with(|| out.kept.claim(&p.name));
+    }
+    let mut written = HashSet::new();
+    for p in parts {
+        let Some(new) = names.get(&normalize(&p.name)).cloned() else { continue };
+        if !written.insert(new.clone()) {
+            continue;
+        }
+        out.part(&new, Some(&p.content_type), p.data.to_vec());
+        if !p.rels.is_empty() {
+            out.part(&rels_part_name(&new), None, part_rels_xml(&p.rels, &names).into_bytes());
+        }
+    }
+    names
+}
+
+/// Adds the owner's relationships; returns old id → new id.
+pub(super) fn attach(rels: &mut Rels, list: &[PreservedRel], names: &NameMap) -> HashMap<String, String> {
+    let mut ids = HashMap::new();
+    for r in list {
+        if let Some(target) = rel_target(r, names) {
+            let id = rels.add_raw(&r.rel_type, &target, r.external);
+            ids.insert(r.id.clone(), id);
+        }
+    }
+    ids
+}
+
+pub(super) fn remap(x: &str, ids: &HashMap<String, String>) -> Option<String> {
+    map_rel_ids(x, &mut |id| ids.get(id).cloned())
+}
+
+/// A kept chart sheet being written: its `<sheet>` entry's fields and its new relationship id.
+pub struct KeptSheet {
+    before: usize,
+    name: String,
+    visibility: Visibility,
+    rid: String,
+    sheet_id: u32,
+}
+
+/// The `sheetId`s of the written sheets: each keeps the one the file gave it, unless another
+/// sheet took it first (a copied sheet) or it has none (a new sheet), and those get the next id
+/// that no sheet asks for.
+pub struct SheetIds {
+    wanted: HashSet<u32>,
+    given: HashSet<u32>,
+    next: u32,
+}
+
+impl SheetIds {
+    pub fn new(wb: &Workbook, kept: &WorkbookKept) -> SheetIds {
+        let wanted: HashSet<u32> = wb.sheets.iter().map(|s| s.file_id).chain(kept.sheets.iter().map(|s| s.sheet_id)).filter(|&id| id != 0).collect();
+        SheetIds { wanted, given: HashSet::new(), next: 1 }
+    }
+
+    pub fn take(&mut self, wanted: u32) -> u32 {
+        if wanted != 0 && self.given.insert(wanted) {
+            return wanted;
+        }
+        while self.wanted.contains(&self.next) || self.given.contains(&self.next) {
+            self.next += 1;
+        }
+        self.given.insert(self.next);
+        self.next
+    }
+}
+
+/// The workbook's kept content as written.
+#[derive(Default)]
+pub struct WorkbookKept {
+    /// Workbook XML elements that go right after `<sheets>` (`<externalReferences>`).
+    pub elements: String,
+    sheets: Vec<KeptSheet>,
+}
+
+impl WorkbookKept {
+    /// Where the model's sheet `i` is in the file's sheet list: chart sheets come between worksheets.
+    pub fn file_index(&self, i: usize) -> usize {
+        i + self.sheets.iter().filter(|s| s.before <= i).count()
+    }
+
+    /// The `<sheet>` entries of the chart sheets that go right before the model's sheet `i`
+    /// (`i` = the number of sheets for those that come last), with their ids from `ids`.
+    pub fn sheet_entries(&self, i: usize, last: bool, ids: &mut SheetIds) -> String {
+        let mut x = String::new();
+        for s in self.sheets.iter().filter(|s| if last { s.before >= i } else { s.before == i }) {
+            let state = match s.visibility {
+                Visibility::Visible => "",
+                Visibility::Hidden => " state=\"hidden\"",
+                Visibility::VeryHidden => " state=\"veryHidden\"",
+            };
+            let name: String = s.name.chars().take(31).collect();
+            let id = ids.take(s.sheet_id);
+            let _ = write!(x, "<sheet name=\"{}\" sheetId=\"{id}\"{state} r:id=\"{}\"/>", esc_attr(&name), esc_attr(&s.rid));
+        }
+        x
+    }
+}
+
+/// The part names reachable from `root` through kept parts' relationships (normalized).
+fn reachable(p: &Preserved, root: &PreservedRel) -> HashSet<String> {
+    let by_name: HashMap<String, &PreservedPart> = p.parts.iter().map(|q| (normalize(&q.name), q)).collect();
+    let mut seen = HashSet::new();
+    let mut queue = VecDeque::from([normalize(&root.target)]);
+    while let Some(n) = queue.pop_front() {
+        if !seen.insert(n.clone()) {
+            continue;
+        }
+        if let Some(q) = by_name.get(&n) {
+            queue.extend(q.rels.iter().filter(|r| !r.external).map(|r| normalize(&r.target)));
+        }
+    }
+    seen
+}
+
+/// Every formula (`<c:f>`) of a chart part, depth first.
+fn chart_formulas(el: &xml::El, out: &mut Vec<String>) {
+    if el.name == "f" && !el.text.trim().is_empty() {
+        out.push(el.text.trim().to_string());
+    }
+    for c in &el.children {
+        chart_formulas(c, out);
+    }
+}
+
+/// The sheet names a formula such as `'My Sheet'!$A$1:$A$9,Data!$B$1` refers to. References to
+/// other workbooks (`[1]Sheet!A1`) are not sheets of this one and are left out.
+pub(crate) fn sheet_names_in(formula: &str) -> Vec<String> {
+    let mut names = vec![];
+    let chars: Vec<char> = formula.chars().collect();
+    let at = |i: usize| chars.get(i).copied();
+    let mut i = 0;
+    while let Some(c) = at(i) {
+        let mut name = String::new();
+        let start = i;
+        if c == '\'' {
+            i += 1;
+            while let Some(c) = at(i) {
+                if c == '\'' {
+                    if at(i + 1) == Some('\'') {
+                        name.push('\'');
+                        i += 2;
+                        continue;
+                    }
+                    break;
+                }
+                name.push(c);
+                i += 1;
+            }
+            i += 1;
+        } else {
+            while let Some(c) = at(i).filter(|c| !matches!(c, '!' | ',' | '(' | ')' | '\'' | ' ')) {
+                name.push(c);
+                i += 1;
+            }
+        }
+        if at(i) == Some('!') {
+            if !name.is_empty() && !name.starts_with('[') {
+                names.push(name);
+            }
+            i += 1;
+        } else if i == start {
+            i += 1;
+        }
+    }
+    names
+}
+
+/// Whether a kept chart sheet can be written back: its chart's series must still refer to sheets
+/// that exist under the same names (the chart is kept as it was, so a series on a deleted or
+/// renamed sheet would be left pointing at nothing), and no worksheet may have taken its name.
+fn chart_sheet_usable(wb: &Workbook, p: &Preserved, s: &PreservedSheet) -> bool {
+    let same = |a: &str, b: &str| a.chars().take(31).collect::<String>().eq_ignore_ascii_case(&b.chars().take(31).collect::<String>());
+    if wb.sheets.iter().any(|w| same(&w.name, &s.name)) {
+        return false;
+    }
+    let Some(root) = p.rels.iter().find(|r| r.id == s.rel_id) else { return false };
+    let parts = reachable(p, root);
+    let mut formulas = vec![];
+    for q in p.parts.iter().filter(|q| parts.contains(&normalize(&q.name)) && q.content_type.contains("chart")) {
+        if let Ok(x) = xml::parse(&q.data) {
+            chart_formulas(&x, &mut formulas);
+        }
+    }
+    formulas.iter().flat_map(|f| sheet_names_in(f)).all(|n| wb.sheets.iter().any(|w| same(&w.name, &n)))
+}
+
+/// Writes the workbook's kept parts and relationships. Chart sheets that can't be written back
+/// (see [`chart_sheet_usable`]) are left out with the parts only they reach.
+pub fn write_workbook(wb: &Workbook, wb_rels: &mut Rels, out: &mut Out) -> WorkbookKept {
+    let Some(p) = wb.preserved.as_deref() else { return WorkbookKept::default() };
+    let (live, dropped): (Vec<&PreservedSheet>, Vec<&PreservedSheet>) = p.sheets.iter().partition(|s| chart_sheet_usable(wb, p, s));
+    let root_of = |s: &PreservedSheet| p.rels.iter().find(|r| r.id == s.rel_id);
+    let dropped_ids: HashSet<&str> = dropped.iter().map(|s| s.rel_id.as_str()).collect();
+    // Parts reached only by dropped chart sheets go with them.
+    let mut gone: HashSet<String> = dropped.iter().filter_map(|s| root_of(s)).flat_map(|r| reachable(p, r)).collect();
+    if !gone.is_empty() {
+        let others = p.rels.iter().filter(|r| !dropped_ids.contains(r.id.as_str())).flat_map(|r| reachable(p, r));
+        for n in others {
+            gone.remove(&n);
+        }
+    }
+    let parts: Vec<PreservedPart> = p.parts.iter().filter(|q| !gone.contains(&normalize(&q.name))).cloned().collect();
+    let rels: Vec<PreservedRel> = p.rels.iter().filter(|r| !dropped_ids.contains(r.id.as_str())).cloned().collect();
+    let names = write_parts(out, &parts);
+    let ids = attach(wb_rels, &rels, &names);
+    for r in &p.package_rels {
+        if let Some(target) = rel_target(r, &names) {
+            out.kept.root.push((r.rel_type.clone(), target, r.external));
+        }
+    }
+    WorkbookKept {
+        elements: p.elements.iter().filter(|e| e.slot == "externalReferences").filter_map(|e| remap(&e.xml, &ids)).collect(),
+        sheets: live
+            .iter()
+            .filter_map(|s| {
+                Some(KeptSheet {
+                    before: s.before,
+                    name: s.name.clone(),
+                    visibility: s.visibility,
+                    rid: ids.get(&s.rel_id)?.clone(),
+                    sheet_id: s.sheet_id,
+                })
+            })
+            .collect(),
+    }
+}
+
+/// The workbook's kept elements of `slot` that refer to no part (`fileVersion`, `ext`).
+pub fn workbook_elements(wb: &Workbook, slot: &str) -> String {
+    let Some(p) = wb.preserved.as_deref() else { return String::new() };
+    p.elements.iter().filter(|e| e.slot == slot).map(|e| e.xml.as_str()).collect()
+}
+
+/// Adds the kept package-root relationships (custom properties…) to `_rels/.rels`.
+pub fn write_package_rels(root: &mut Rels, out: &mut Out) {
+    for (ty, target, external) in std::mem::take(&mut out.kept.root) {
+        root.add_raw(&ty, &target, external);
+    }
+}

From af54396e645ded7947f65d13cd458c9e4f20c801 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:15:23 +0000
Subject: [PATCH 64/76] refactor(xlsx): move sheet_write.rs items to
 sheet_write/

---
 crates/xlsx/src/sheet_write.rs       | 616 +--------------------------
 crates/xlsx/src/sheet_write/parts.rs | 373 ++++++++++++++++
 crates/xlsx/src/sheet_write/rules.rs | 238 +++++++++++
 3 files changed, 618 insertions(+), 609 deletions(-)
 create mode 100644 crates/xlsx/src/sheet_write/parts.rs
 create mode 100644 crates/xlsx/src/sheet_write/rules.rs

diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs
index 52dc979e6..aeca78123 100644
--- a/crates/xlsx/src/sheet_write.rs
+++ b/crates/xlsx/src/sheet_write.rs
@@ -18,58 +18,17 @@ use crate::write::{
 };
 use crate::xml::{encode_xstring, esc, esc_attr, num};
 
+mod parts;
+mod rules;
+
+pub(crate) use parts::password_attrs;
+use parts::{autofilter_xml, comments_xml, protected_ranges_xml, table_columns, table_name, table_xml, thread_ids, threaded_xml, vml_xml};
+use rules::{cf_rule_xml, solid_bar_id, validation_xml, x14_cfvo};
+
 fn sqref(ranges: &[RangeRef]) -> String {
     ranges.iter().map(|r| r.a1()).collect::<Vec<_>>().join(" ")
 }
 
-fn cf_op_name(op: CfOperator) -> &'static str {
-    match op {
-        CfOperator::Between => "between",
-        CfOperator::NotBetween => "notBetween",
-        CfOperator::Equal => "equal",
-        CfOperator::NotEqual => "notEqual",
-        CfOperator::Greater => "greaterThan",
-        CfOperator::Less => "lessThan",
-        CfOperator::GreaterOrEqual => "greaterThanOrEqual",
-        CfOperator::LessOrEqual => "lessThanOrEqual",
-    }
-}
-
-/// Valid table name: letters, digits, `_` and `.`, starting with a letter, `_` or `\`
-/// (Microsoft "Names in formulas" rules).
-fn table_name(name: &str, used: &mut HashSet<String>, n: u32) -> String {
-    let mut s: String =
-        name.chars().enumerate().map(|(i, c)| if c.is_alphanumeric() || c == '_' || c == '.' || (i == 0 && c == '\\') { c } else { '_' }).collect();
-    if s.is_empty() || !s.starts_with(|c: char| c.is_alphabetic() || c == '_' || c == '\\') || gridcraft_core::CellRef::parse(&s).is_some() {
-        s = format!("Table{n}");
-    }
-    let mut out = s.clone();
-    let mut k = 2;
-    while !used.insert(out.to_ascii_lowercase()) {
-        out = format!("{s}{k}");
-        k += 1;
-    }
-    out
-}
-
-/// Column names for a table: one per column of its range, unique and non-empty.
-fn table_columns(t: &Table) -> Vec<String> {
-    let w = t.range.width() as usize;
-    let mut used = HashSet::new();
-    (0..w)
-        .map(|i| {
-            let base = t.columns.get(i).map(|c| c.name.clone()).filter(|n| !n.trim().is_empty()).unwrap_or_else(|| format!("Column{}", i + 1));
-            let mut name = base.clone();
-            let mut k = 2;
-            while !used.insert(name.to_lowercase()) {
-                name = format!("{base}{k}");
-                k += 1;
-            }
-            name
-        })
-        .collect()
-}
-
 pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (String, Rels) {
     let mut rels = Rels::default();
     let Some(sheet) = wb.sheet(si) else { return (String::new(), rels) };
@@ -768,537 +727,9 @@ fn write_cell(
     }
 }
 
-fn cfvo_xml(v: &CfValueKind) -> String {
-    match v {
-        CfValueKind::Min => "<cfvo type=\"min\"/>".into(),
-        CfValueKind::Max => "<cfvo type=\"max\"/>".into(),
-        CfValueKind::Number(n) => format!("<cfvo type=\"num\" val=\"{}\"/>", num(*n)),
-        CfValueKind::Percent(n) => format!("<cfvo type=\"percent\" val=\"{}\"/>", num(*n)),
-        CfValueKind::Percentile(n) => format!("<cfvo type=\"percentile\" val=\"{}\"/>", num(*n)),
-        CfValueKind::Formula(f) => format!("<cfvo type=\"formula\" val=\"{}\"/>", esc_attr(&text_to_file(f))),
-    }
-}
-
-fn quote(t: &str) -> String {
-    format!("\"{}\"", t.replace('"', "\"\""))
-}
-
 const X14_NS: &str = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
 const XM_NS: &str = "http://schemas.microsoft.com/office/excel/2006/main";
 
-/// The id linking a solid data bar's `cfRule` to its x14 extension; unique per sheet because priorities are.
-fn solid_bar_id(priority: u32) -> String {
-    format!("{{00000000-0000-0000-0000-{priority:012}}}")
-}
-
-/// The `cfRule` extension that points a solid data bar at its x14 rule.
-fn solid_bar_ext(priority: u32) -> String {
-    let id = solid_bar_id(priority);
-    format!("<extLst><ext uri=\"{{B025F937-C7B1-47D3-B67F-A62EFF666E3E}}\" xmlns:x14=\"{X14_NS}\"><x14:id>{id}</x14:id></ext></extLst>")
-}
-
-/// An x14 `cfvo`: unlike the 2006 one it has no `val` attribute, the value is an `xm:f` child.
-fn x14_cfvo(v: &CfValueKind) -> String {
-    let (ty, val) = match v {
-        CfValueKind::Min => return "<x14:cfvo type=\"min\"/>".into(),
-        CfValueKind::Max => return "<x14:cfvo type=\"max\"/>".into(),
-        CfValueKind::Number(n) => ("num", num(*n)),
-        CfValueKind::Percent(n) => ("percent", num(*n)),
-        CfValueKind::Percentile(n) => ("percentile", num(*n)),
-        CfValueKind::Formula(f) => ("formula", text_to_file(f)),
-    };
-    format!("<x14:cfvo type=\"{ty}\"><xm:f>{}</xm:f></x14:cfvo>", esc(&val))
-}
-
-fn cf_rule_xml(cf: &CondFormat, priority: u32, out: &mut Out) -> String {
-    let tl = cf.ranges.first().map(|r| r.start.a1()).unwrap_or_else(|| "A1".into());
-    let stop = if cf.stop_if_true { " stopIfTrue=\"1\"" } else { "" };
-    let mut dxf = |st: &Style| dxf_id(&mut out.dxfs, st);
-    let f = |x: &str| format!("<formula>{}</formula>", esc(&text_to_file(x)));
-    let simple = |ty: &str, st: &Style, extra: &str, body: String, dxf: &mut dyn FnMut(&Style) -> u32| {
-        format!("<cfRule type=\"{ty}\" dxfId=\"{}\" priority=\"{priority}\"{stop}{extra}>{body}</cfRule>", dxf(st))
-    };
-    match &cf.rule {
-        CfRule::CellIs { op, a, b, style } => {
-            let mut body = f(a);
-            if let Some(b) = b {
-                body.push_str(&f(b));
-            }
-            simple("cellIs", style, &format!(" operator=\"{}\"", cf_op_name(*op)), body, &mut dxf)
-        }
-        CfRule::Expression { formula, style } => simple("expression", style, "", f(formula), &mut dxf),
-        CfRule::ContainsText { text, style } => simple(
-            "containsText",
-            style,
-            &format!(" operator=\"containsText\" text=\"{}\"", esc_attr(text)),
-            f(&format!("NOT(ISERROR(SEARCH({},{tl})))", quote(text))),
-            &mut dxf,
-        ),
-        CfRule::NotContainsText { text, style } => simple(
-            "notContainsText",
-            style,
-            &format!(" operator=\"notContains\" text=\"{}\"", esc_attr(text)),
-            f(&format!("ISERROR(SEARCH({},{tl}))", quote(text))),
-            &mut dxf,
-        ),
-        CfRule::BeginsWith { text, style } => simple(
-            "beginsWith",
-            style,
-            &format!(" operator=\"beginsWith\" text=\"{}\"", esc_attr(text)),
-            f(&format!("LEFT({tl},LEN({0}))={0}", quote(text))),
-            &mut dxf,
-        ),
-        CfRule::EndsWith { text, style } => simple(
-            "endsWith",
-            style,
-            &format!(" operator=\"endsWith\" text=\"{}\"", esc_attr(text)),
-            f(&format!("RIGHT({tl},LEN({0}))={0}", quote(text))),
-            &mut dxf,
-        ),
-        CfRule::Blanks { style } => simple("containsBlanks", style, "", f(&format!("LEN(TRIM({tl}))=0")), &mut dxf),
-        CfRule::NoBlanks { style } => simple("notContainsBlanks", style, "", f(&format!("LEN(TRIM({tl}))>0")), &mut dxf),
-        CfRule::Errors { style } => simple("containsErrors", style, "", f(&format!("ISERROR({tl})")), &mut dxf),
-        CfRule::NoErrors { style } => simple("notContainsErrors", style, "", f(&format!("NOT(ISERROR({tl}))")), &mut dxf),
-        CfRule::Duplicate { style } => simple("duplicateValues", style, "", String::new(), &mut dxf),
-        CfRule::Unique { style } => simple("uniqueValues", style, "", String::new(), &mut dxf),
-        CfRule::Top10 { bottom, percent, rank, style } => {
-            let extra = format!("{}{} rank=\"{}\"", if *percent { " percent=\"1\"" } else { "" }, if *bottom { " bottom=\"1\"" } else { "" }, rank);
-            simple("top10", style, &extra, String::new(), &mut dxf)
-        }
-        CfRule::AboveAverage { below, equal, std_dev, style } => {
-            let mut extra = String::new();
-            if *below {
-                extra.push_str(" aboveAverage=\"0\"");
-            }
-            if *equal {
-                extra.push_str(" equalAverage=\"1\"");
-            }
-            if *std_dev > 0 {
-                let _ = write!(extra, " stdDev=\"{std_dev}\"");
-            }
-            simple("aboveAverage", style, &extra, String::new(), &mut dxf)
-        }
-        CfRule::TimePeriod { period, style } => {
-            let d = format!("FLOOR({tl},1)");
-            let body = match period.as_str() {
-                "yesterday" => format!("{d}=TODAY()-1"),
-                "tomorrow" => format!("{d}=TODAY()+1"),
-                "last7Days" => format!("AND(TODAY()-{d}<=6,{d}<=TODAY())"),
-                "thisMonth" => format!("AND(MONTH({tl})=MONTH(TODAY()),YEAR({tl})=YEAR(TODAY()))"),
-                "lastMonth" => format!("AND(MONTH({tl})=MONTH(EDATE(TODAY(),0-1)),YEAR({tl})=YEAR(EDATE(TODAY(),0-1)))"),
-                "nextMonth" => format!("AND(MONTH({tl})=MONTH(EDATE(TODAY(),0+1)),YEAR({tl})=YEAR(EDATE(TODAY(),0+1)))"),
-                "thisWeek" => format!("AND(TODAY()-ROUNDDOWN({tl},0)<=WEEKDAY(TODAY())-1,ROUNDDOWN({tl},0)-TODAY()<=7-WEEKDAY(TODAY()))"),
-                "lastWeek" => format!("AND(TODAY()-ROUNDDOWN({tl},0)>=(WEEKDAY(TODAY())),TODAY()-ROUNDDOWN({tl},0)<(WEEKDAY(TODAY())+7))"),
-                "nextWeek" => format!("AND(ROUNDDOWN({tl},0)-TODAY()>(7-WEEKDAY(TODAY())),ROUNDDOWN({tl},0)-TODAY()<(15-WEEKDAY(TODAY())))"),
-                _ => format!("{d}=TODAY()"),
-            };
-            simple("timePeriod", style, &format!(" timePeriod=\"{}\"", esc_attr(period)), f(&body), &mut dxf)
-        }
-        CfRule::ColorScale { stops } => {
-            let mut b = String::from("<colorScale>");
-            for (v, _) in stops {
-                b.push_str(&cfvo_xml(v));
-            }
-            for (_, c) in stops {
-                let _ = write!(b, "<color {}/>", color_attrs(c));
-            }
-            b.push_str("</colorScale>");
-            format!("<cfRule type=\"colorScale\" priority=\"{priority}\"{stop}>{b}</cfRule>")
-        }
-        CfRule::DataBar { min, max, color, show_value, gradient } => format!(
-            "<cfRule type=\"dataBar\" priority=\"{priority}\"{stop}><dataBar{}>{}{}<color {}/></dataBar>{}</cfRule>",
-            if *show_value { "" } else { " showValue=\"0\"" },
-            cfvo_xml(min),
-            cfvo_xml(max),
-            if *color == Color::Auto { "rgb=\"FF638EC6\"".to_string() } else { color_attrs(color) },
-            if *gradient { String::new() } else { solid_bar_ext(priority) }
-        ),
-        CfRule::IconSet { set, thresholds, reverse, show_value } => {
-            let mut b = format!("<iconSet iconSet=\"{}\"", esc_attr(set));
-            if *reverse {
-                b.push_str(" reverse=\"1\"");
-            }
-            if !*show_value {
-                b.push_str(" showValue=\"0\"");
-            }
-            b.push('>');
-            // CT_IconSet needs one cfvo per icon (minOccurs 2); the first is the lower bound.
-            let k = icon_count(set);
-            let defaults = default_icon_thresholds(set);
-            let cfvos: Vec<&CfValueKind> = match thresholds.len() {
-                n if n == k => thresholds.iter().collect(),
-                n if n + 1 == k => defaults.iter().take(1).chain(thresholds).collect(),
-                _ => defaults.iter().collect(),
-            };
-            for t in cfvos {
-                b.push_str(&cfvo_xml(t));
-            }
-            b.push_str("</iconSet>");
-            format!("<cfRule type=\"iconSet\" priority=\"{priority}\"{stop}>{b}</cfRule>")
-        }
-    }
-}
-
-fn validation_formula(f: &str) -> String {
-    let f = f.trim();
-    if f.starts_with('"') {
-        return esc(f);
-    }
-    esc(&text_to_file(f.strip_prefix('=').unwrap_or(f)))
-}
-
-fn validation_xml(v: &Validation) -> String {
-    let ty = match v.kind {
-        ValidationKind::Any => "none",
-        ValidationKind::Whole => "whole",
-        ValidationKind::Decimal => "decimal",
-        ValidationKind::List => "list",
-        ValidationKind::Date => "date",
-        ValidationKind::Time => "time",
-        ValidationKind::TextLength => "textLength",
-        ValidationKind::Custom => "custom",
-    };
-    let mut s = format!("<dataValidation type=\"{ty}\"");
-    match v.error_style {
-        ErrorStyle::Stop => {}
-        ErrorStyle::Warning => s.push_str(" errorStyle=\"warning\""),
-        ErrorStyle::Information => s.push_str(" errorStyle=\"information\""),
-    }
-    if v.op != CfOperator::Between && !matches!(v.kind, ValidationKind::List | ValidationKind::Custom | ValidationKind::Any) {
-        let _ = write!(s, " operator=\"{}\"", cf_op_name(v.op));
-    }
-    if v.allow_blank {
-        s.push_str(" allowBlank=\"1\"");
-    }
-    if !v.in_cell_dropdown {
-        s.push_str(" showDropDown=\"1\"");
-    }
-    if v.show_input {
-        s.push_str(" showInputMessage=\"1\"");
-    }
-    if v.show_error {
-        s.push_str(" showErrorMessage=\"1\"");
-    }
-    for (a, t) in [("errorTitle", &v.error_title), ("error", &v.error_message), ("promptTitle", &v.input_title), ("prompt", &v.input_message)] {
-        if !t.is_empty() {
-            let _ = write!(s, " {a}=\"{}\"", esc_attr(t));
-        }
-    }
-    let _ = write!(s, " sqref=\"{}\">", sqref(&v.ranges));
-    if !v.f1.is_empty() {
-        let _ = write!(s, "<formula1>{}</formula1>", validation_formula(&v.f1));
-    }
-    if let Some(f2) = v.f2.as_ref().filter(|f| !f.is_empty()) {
-        let _ = write!(s, "<formula2>{}</formula2>", validation_formula(f2));
-    }
-    s.push_str("</dataValidation>");
-    s
-}
-
-fn filter_operator(op: &str) -> &'static str {
-    match op.trim() {
-        "<" => " operator=\"lessThan\"",
-        "<=" => " operator=\"lessThanOrEqual\"",
-        "<>" => " operator=\"notEqual\"",
-        ">=" => " operator=\"greaterThanOrEqual\"",
-        ">" => " operator=\"greaterThan\"",
-        _ => "",
-    }
-}
-
-fn autofilter_xml(range: RangeRef, criteria: &[(u32, FilterCriterion)], out: &mut Out) -> String {
-    let mut s = format!("<autoFilter ref=\"{}\"", range.a1());
-    if criteria.is_empty() {
-        s.push_str("/>");
-        return s;
-    }
-    s.push('>');
-    for (col, c) in criteria {
-        let _ = write!(s, "<filterColumn colId=\"{col}\">");
-        match c {
-            FilterCriterion::Values { values, blanks } => {
-                let _ = write!(s, "<filters{}>", if *blanks { " blank=\"1\"" } else { "" });
-                for v in values {
-                    let _ = write!(s, "<filter val=\"{}\"/>", esc_attr(v));
-                }
-                s.push_str("</filters>");
-            }
-            FilterCriterion::Custom { a, b, and } => {
-                let _ = write!(s, "<customFilters{}>", if *and { " and=\"1\"" } else { "" });
-                for (op, v) in std::iter::once(a).chain(b.iter()) {
-                    let _ = write!(s, "<customFilter{} val=\"{}\"/>", filter_operator(op), esc_attr(v));
-                }
-                s.push_str("</customFilters>");
-            }
-            FilterCriterion::Top10 { bottom, percent, count } => {
-                let _ =
-                    write!(s, "<top10{}{} val=\"{count}\"/>", if *bottom { " top=\"0\"" } else { "" }, if *percent { " percent=\"1\"" } else { "" });
-            }
-            FilterCriterion::AboveAverage(above) => {
-                let _ = write!(s, "<dynamicFilter type=\"{}\"/>", if *above { "aboveAverage" } else { "belowAverage" });
-            }
-            FilterCriterion::FillColor(c) => {
-                let st = Style { fill: gridcraft_model::Fill::solid(*c), ..Default::default() };
-                let _ = write!(s, "<colorFilter dxfId=\"{}\"/>", dxf_id(&mut out.dxfs, &st));
-            }
-            FilterCriterion::FontColor(c) => {
-                let mut st = Style::default();
-                st.font.color = *c;
-                let _ = write!(s, "<colorFilter dxfId=\"{}\" cellColor=\"0\"/>", dxf_id(&mut out.dxfs, &st));
-            }
-            FilterCriterion::Icon { set, id } => {
-                let _ = write!(s, "<iconFilter iconSet=\"{}\"", esc_attr(set));
-                if let Some(id) = id {
-                    let _ = write!(s, " iconId=\"{id}\"");
-                }
-                s.push_str("/>");
-            }
-        }
-        s.push_str("</filterColumn>");
-    }
-    s.push_str("</autoFilter>");
-    s
-}
-
-fn table_xml(t: &Table, cols: &[String], name: &str, id: u32, out: &mut Out) -> String {
-    let mut s =
-        format!("{XML_DECL}<table xmlns=\"{NS_MAIN}\" id=\"{id}\" name=\"{0}\" displayName=\"{0}\" ref=\"{1}\"", esc_attr(name), t.range.a1());
-    if !t.header_row {
-        s.push_str(" headerRowCount=\"0\"");
-    }
-    if t.totals_row {
-        s.push_str(" totalsRowCount=\"1\"");
-    } else {
-        s.push_str(" totalsRowShown=\"0\"");
-    }
-    if let Some(ty) = &t.table_type {
-        let _ = write!(s, " tableType=\"{}\"", esc_attr(ty));
-    }
-    if let Some(c) = t.connection_id {
-        let _ = write!(s, " connectionId=\"{c}\"");
-    }
-    s.push('>');
-    if t.header_row && t.filter_button {
-        let end_row = if t.totals_row { t.range.end.row.saturating_sub(1).max(t.range.start.row) } else { t.range.end.row };
-        let r = RangeRef::new(t.range.start, CellRef::new(end_row, t.range.end.col));
-        s.push_str(&autofilter_xml(r, &t.filter, out));
-    }
-    let _ = write!(s, "<tableColumns count=\"{}\">", cols.len());
-    for (i, name) in cols.iter().enumerate() {
-        let col = t.columns.get(i);
-        let _ = write!(s, "<tableColumn id=\"{}\"", i + 1);
-        if let Some(u) = col.and_then(|c| c.unique_name.as_ref()) {
-            let _ = write!(s, " uniqueName=\"{}\"", esc_attr(u));
-        }
-        let _ = write!(s, " name=\"{}\"", esc_attr(&encode_xstring(name)));
-        let totals = col.map(|c| c.totals).unwrap_or_default();
-        if t.totals_row {
-            let f = match totals {
-                TotalsFn::None => None,
-                TotalsFn::Average => Some("average"),
-                TotalsFn::Count => Some("count"),
-                TotalsFn::CountNums => Some("countNums"),
-                TotalsFn::Max => Some("max"),
-                TotalsFn::Min => Some("min"),
-                TotalsFn::Sum => Some("sum"),
-                TotalsFn::StdDev => Some("stdDev"),
-                TotalsFn::Var => Some("var"),
-                TotalsFn::Custom => Some("custom"),
-            };
-            if let Some(f) = f {
-                let _ = write!(s, " totalsRowFunction=\"{f}\"");
-            } else if let Some(l) = col.and_then(|c| c.totals_label.as_ref()) {
-                let _ = write!(s, " totalsRowLabel=\"{}\"", esc_attr(l));
-            }
-        }
-        let calc = col.and_then(|c| c.formula.as_ref()).filter(|f| !f.is_empty());
-        let custom = if t.totals_row && totals == TotalsFn::Custom { col.and_then(|c| c.totals_label.as_ref()) } else { None };
-        let xml = col.and_then(|c| c.xml.as_ref());
-        if calc.is_none() && custom.is_none() && xml.is_none() {
-            s.push_str("/>");
-            continue;
-        }
-        s.push('>');
-        if let Some(f) = calc {
-            let _ = write!(s, "<calculatedColumnFormula>{}</calculatedColumnFormula>", esc(&text_to_file(f)));
-        }
-        if let Some(f) = custom {
-            let _ = write!(s, "<totalsRowFormula>{}</totalsRowFormula>", esc(&text_to_file(f)));
-        }
-        if let Some(x) = xml {
-            let _ = write!(s, "<xmlColumnPr mapId=\"{}\" xpath=\"{}\"", x.map_id, esc_attr(&x.xpath));
-            if x.denormalized {
-                s.push_str(" denormalized=\"1\"");
-            }
-            let _ = write!(s, " xmlDataType=\"{}\"/>", esc_attr(&x.data_type));
-        }
-        s.push_str("</tableColumn>");
-    }
-    s.push_str("</tableColumns>");
-    let style = if t.style.is_empty() { "TableStyleMedium2" } else { &t.style };
-    let _ = write!(
-        s,
-        "<tableStyleInfo name=\"{}\" showFirstColumn=\"{}\" showLastColumn=\"{}\" showRowStripes=\"{}\" showColumnStripes=\"{}\"/></table>",
-        esc_attr(style),
-        t.first_col as u8,
-        t.last_col as u8,
-        t.banded_rows as u8,
-        t.banded_cols as u8
-    );
-    s
-}
-
-/// Ids of the threaded comments of sheet `si`: the thread's id, then one per reply. GUID-shaped
-/// and deterministic; they only need to be unique within the file.
-fn thread_ids(sheet: &Sheet, si: usize) -> BTreeMap<CellRef, Vec<String>> {
-    let mut seq: u64 = 0;
-    let mut ids = BTreeMap::new();
-    for (cell, c) in sheet.comments.iter().filter(|(_, c)| c.threaded) {
-        let v: Vec<String> = (0..=c.replies.len())
-            .map(|_| {
-                seq += 1;
-                format!("{{{:08X}-0000-4000-8001-{:012X}}}", si as u64 & 0xFFFF_FFFF, seq & 0xFFFF_FFFF_FFFF)
-            })
-            .collect();
-        ids.insert(*cell, v);
-    }
-    ids
-}
-
-fn comments_xml(sheet: &Sheet, ids: &BTreeMap<CellRef, Vec<String>>) -> String {
-    // A threaded comment's legacy note is authored by `tc={thread id}`.
-    let author_of = |cell: &CellRef, c: &gridcraft_model::Comment| match ids.get(cell).and_then(|v| v.first()) {
-        Some(id) => format!("tc={id}"),
-        None => c.author.clone(),
-    };
-    let mut authors: Vec<String> = vec![];
-    for (cell, c) in &sheet.comments {
-        let a = author_of(cell, c);
-        if !authors.contains(&a) {
-            authors.push(a);
-        }
-    }
-    let mut s = if ids.is_empty() {
-        format!("{XML_DECL}<comments xmlns=\"{NS_MAIN}\"><authors>")
-    } else {
-        format!(
-            "{XML_DECL}<comments xmlns=\"{NS_MAIN}\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"xr\" xmlns:xr=\"http://schemas.microsoft.com/office/spreadsheetml/2014/revision\"><authors>"
-        )
-    };
-    for a in &authors {
-        let _ = write!(s, "<author>{}</author>", esc(a));
-    }
-    s.push_str("</authors><commentList>");
-    for (cell, c) in &sheet.comments {
-        let a = author_of(cell, c);
-        let aid = authors.iter().position(|x| *x == a).unwrap_or(0);
-        let mut text = c.text.clone();
-        // Threaded replies are kept as text lines.
-        for (who, reply) in &c.replies {
-            let _ = write!(text, "\n{who}: {reply}");
-        }
-        let link = match ids.get(cell).and_then(|v| v.first()) {
-            Some(id) => format!(" shapeId=\"0\" xr:uid=\"{id}\""),
-            None => String::new(),
-        };
-        let _ = write!(s, "<comment ref=\"{}\" authorId=\"{aid}\"{link}><text><r>{}</r></text></comment>", cell.a1(), crate::xml::t_el(&text));
-    }
-    s.push_str("</commentList></comments>");
-    s
-}
-
-/// `2024-05-01T09:30:00` with optional fraction and zone: what `dT` (xsd:dateTime) accepts.
-/// Anything else is left out rather than written into the file.
-fn iso_datetime(d: &str) -> bool {
-    let b = d.as_bytes();
-    let digits = |r: std::ops::Range<usize>| b.get(r).is_some_and(|s| s.iter().all(u8::is_ascii_digit));
-    d.len() <= 40
-        && digits(0..4)
-        && b.get(4) == Some(&b'-')
-        && digits(5..7)
-        && b.get(7) == Some(&b'-')
-        && digits(8..10)
-        && b.get(10) == Some(&b'T')
-        && digits(11..13)
-        && b.get(13) == Some(&b':')
-        && digits(14..16)
-        && b.get(16) == Some(&b':')
-        && digits(17..19)
-        && b.get(19..).is_some_and(|rest| rest.iter().all(|c| c.is_ascii_digit() || b".:+-Z".contains(c)))
-}
-
-/// `xl/threadedComments/threadedCommentN.xml`: each thread, then its replies (`parentId`).
-fn threaded_xml(sheet: &Sheet, ids: &BTreeMap<CellRef, Vec<String>>, persons: &mut Vec<String>) -> String {
-    let mut person = |name: &str| {
-        let i = persons.iter().position(|p| p == name).unwrap_or_else(|| {
-            persons.push(name.to_string());
-            persons.len() - 1
-        });
-        crate::write::person_guid(i)
-    };
-    let mut s = format!("{XML_DECL}<ThreadedComments xmlns=\"{NS_THREADED}\" xmlns:x=\"{NS_MAIN}\">");
-    for (cell, id) in ids {
-        let Some(c) = sheet.comments.get(cell) else { continue };
-        let entries = std::iter::once((&c.author, &c.text)).chain(c.replies.iter().map(|(a, t)| (a, t)));
-        for (k, ((author, text), own)) in entries.zip(id).enumerate() {
-            let date = match c.dates.get(k).filter(|d| iso_datetime(d)) {
-                Some(d) => format!(" dT=\"{}\"", esc_attr(d)),
-                None => String::new(),
-            };
-            let tail = match (k, id.first()) {
-                (0, _) if c.resolved => " done=\"1\"".to_string(),
-                (0, _) | (_, None) => String::new(),
-                (_, Some(parent)) => format!(" parentId=\"{parent}\""),
-            };
-            let _ = write!(
-                s,
-                "<threadedComment ref=\"{}\"{date} personId=\"{}\" id=\"{own}\"{tail}><text>{}</text></threadedComment>",
-                cell.a1(),
-                person(author),
-                esc(text)
-            );
-        }
-    }
-    s.push_str("</ThreadedComments>");
-    s
-}
-
-/// A protection password hash as attributes, each name preceded by `prefix` (see
-/// [`crate::sheet_read::read_password`]).
-pub(crate) fn password_attrs(h: &gridcraft_model::PasswordHash, prefix: &str) -> String {
-    let name = |base: &str| crate::sheet_read::password_attr(prefix, base);
-    match h {
-        gridcraft_model::PasswordHash::Legacy(h) => format!(" {}=\"{h:04X}\"", name("password")),
-        gridcraft_model::PasswordHash::Iterated { algorithm, hash, salt, spin_count } => format!(
-            " {}=\"{}\" {}=\"{}\" {}=\"{}\" {}=\"{spin_count}\"",
-            name("algorithmName"),
-            esc_attr(algorithm),
-            name("hashValue"),
-            esc_attr(hash),
-            name("saltValue"),
-            esc_attr(salt),
-            name("spinCount")
-        ),
-    }
-}
-
-/// Allow Edit Ranges: `<protectedRanges>` (after `sheetProtection`).
-fn protected_ranges_xml(sheet: &Sheet) -> String {
-    let mut s = String::new();
-    for r in sheet.edit_ranges.iter().filter(|r| !r.ranges.is_empty()) {
-        let sqref: Vec<String> = r.ranges.iter().map(|x| x.a1()).collect();
-        let _ = write!(s, "<protectedRange name=\"{}\" sqref=\"{}\"", esc_attr(&r.title), sqref.join(" "));
-        if let Some(h) = &r.password {
-            s.push_str(&password_attrs(h, ""));
-        }
-        if let Some(sd) = &r.security_descriptor {
-            let _ = write!(s, " securityDescriptor=\"{}\"", esc_attr(sd));
-        }
-        s.push_str("/>");
-    }
-    if s.is_empty() { s } else { format!("<protectedRanges>{s}</protectedRanges>") }
-}
-
 /// The box a note made here gets: two columns right of its cell, four rows tall, 108 x 59.25 pt.
 /// A box read from a file that equals it is kept as `None`, so a note's model survives a save.
 pub(crate) const DEFAULT_NOTE_BOX: NoteBox = NoteBox {
@@ -1307,36 +738,3 @@ pub(crate) const DEFAULT_NOTE_BOX: NoteBox = NoteBox {
     size_pt: Some(DEFAULT_NOTE_SIZE_PT),
 };
 const DEFAULT_NOTE_SIZE_PT: (f64, f64) = (108.0, 59.25);
-
-/// A note box's `<x:Anchor>` text and its width and height in points: the box read from the file
-/// or [`DEFAULT_NOTE_BOX`], its corners moved with the note's `cell` and kept on the sheet.
-fn note_anchor(cell: CellRef, b: Option<&NoteBox>) -> (String, (f64, f64)) {
-    let b = b.unwrap_or(&DEFAULT_NOTE_BOX);
-    let at = |base: u32, d: i64, max: u32| (i64::from(base) + d).clamp(0, i64::from(max) - 1);
-    let corner = |k: &NoteCorner| format!("{}, {}, {}, {}", at(cell.col, k.col, MAX_COLS), k.col_px, at(cell.row, k.row, MAX_ROWS), k.row_px);
-    (format!("{}, {}", corner(&b.from), corner(&b.to)), b.size_pt.unwrap_or(DEFAULT_NOTE_SIZE_PT))
-}
-
-/// Legacy VML shapes Excel uses to display notes.
-fn vml_xml(sheet: &Sheet, n: u32) -> String {
-    let mut s = format!(
-        "<xml xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:x=\"urn:schemas-microsoft-com:office:excel\"><o:shapelayout v:ext=\"edit\"><o:idmap v:ext=\"edit\" data=\"{n}\"/></o:shapelayout><v:shapetype id=\"_x0000_t202\" coordsize=\"21600,21600\" o:spt=\"202\" path=\"m,l,21600r21600,l21600,xe\"><v:stroke joinstyle=\"miter\"/><v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/></v:shapetype>"
-    );
-    for (i, (cell, c)) in sheet.comments.iter().enumerate() {
-        let id = n as u64 * 1024 + 1 + i as u64;
-        let vis = if c.visible { "visible" } else { "hidden" };
-        let (anchor, (w, h)) = note_anchor(*cell, c.note_box.as_ref());
-        let _ = write!(
-            s,
-            "<v:shape id=\"_x0000_s{id}\" type=\"#_x0000_t202\" style=\"position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:{}pt;height:{}pt;z-index:{};visibility:{vis}\" fillcolor=\"#ffffe1\" o:insetmode=\"auto\"><v:fill color2=\"#ffffe1\"/><v:shadow on=\"t\" color=\"black\" obscured=\"t\"/><v:path o:connecttype=\"none\"/><v:textbox style=\"mso-direction-alt:auto\"><div style=\"text-align:left\"></div></v:textbox><x:ClientData ObjectType=\"Note\"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>{anchor}</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>{}</x:Row><x:Column>{}</x:Column>{}</x:ClientData></v:shape>",
-            num(w),
-            num(h),
-            i + 1,
-            cell.row,
-            cell.col,
-            if c.visible { "<x:Visible/>" } else { "" }
-        );
-    }
-    s.push_str("</xml>");
-    s
-}
diff --git a/crates/xlsx/src/sheet_write/parts.rs b/crates/xlsx/src/sheet_write/parts.rs
new file mode 100644
index 000000000..2e40d0b26
--- /dev/null
+++ b/crates/xlsx/src/sheet_write/parts.rs
@@ -0,0 +1,373 @@
+use super::*;
+
+/// Valid table name: letters, digits, `_` and `.`, starting with a letter, `_` or `\`
+/// (Microsoft "Names in formulas" rules).
+pub(super) fn table_name(name: &str, used: &mut HashSet<String>, n: u32) -> String {
+    let mut s: String =
+        name.chars().enumerate().map(|(i, c)| if c.is_alphanumeric() || c == '_' || c == '.' || (i == 0 && c == '\\') { c } else { '_' }).collect();
+    if s.is_empty() || !s.starts_with(|c: char| c.is_alphabetic() || c == '_' || c == '\\') || gridcraft_core::CellRef::parse(&s).is_some() {
+        s = format!("Table{n}");
+    }
+    let mut out = s.clone();
+    let mut k = 2;
+    while !used.insert(out.to_ascii_lowercase()) {
+        out = format!("{s}{k}");
+        k += 1;
+    }
+    out
+}
+
+/// Column names for a table: one per column of its range, unique and non-empty.
+pub(super) fn table_columns(t: &Table) -> Vec<String> {
+    let w = t.range.width() as usize;
+    let mut used = HashSet::new();
+    (0..w)
+        .map(|i| {
+            let base = t.columns.get(i).map(|c| c.name.clone()).filter(|n| !n.trim().is_empty()).unwrap_or_else(|| format!("Column{}", i + 1));
+            let mut name = base.clone();
+            let mut k = 2;
+            while !used.insert(name.to_lowercase()) {
+                name = format!("{base}{k}");
+                k += 1;
+            }
+            name
+        })
+        .collect()
+}
+
+fn filter_operator(op: &str) -> &'static str {
+    match op.trim() {
+        "<" => " operator=\"lessThan\"",
+        "<=" => " operator=\"lessThanOrEqual\"",
+        "<>" => " operator=\"notEqual\"",
+        ">=" => " operator=\"greaterThanOrEqual\"",
+        ">" => " operator=\"greaterThan\"",
+        _ => "",
+    }
+}
+
+pub(super) fn autofilter_xml(range: RangeRef, criteria: &[(u32, FilterCriterion)], out: &mut Out) -> String {
+    let mut s = format!("<autoFilter ref=\"{}\"", range.a1());
+    if criteria.is_empty() {
+        s.push_str("/>");
+        return s;
+    }
+    s.push('>');
+    for (col, c) in criteria {
+        let _ = write!(s, "<filterColumn colId=\"{col}\">");
+        match c {
+            FilterCriterion::Values { values, blanks } => {
+                let _ = write!(s, "<filters{}>", if *blanks { " blank=\"1\"" } else { "" });
+                for v in values {
+                    let _ = write!(s, "<filter val=\"{}\"/>", esc_attr(v));
+                }
+                s.push_str("</filters>");
+            }
+            FilterCriterion::Custom { a, b, and } => {
+                let _ = write!(s, "<customFilters{}>", if *and { " and=\"1\"" } else { "" });
+                for (op, v) in std::iter::once(a).chain(b.iter()) {
+                    let _ = write!(s, "<customFilter{} val=\"{}\"/>", filter_operator(op), esc_attr(v));
+                }
+                s.push_str("</customFilters>");
+            }
+            FilterCriterion::Top10 { bottom, percent, count } => {
+                let _ =
+                    write!(s, "<top10{}{} val=\"{count}\"/>", if *bottom { " top=\"0\"" } else { "" }, if *percent { " percent=\"1\"" } else { "" });
+            }
+            FilterCriterion::AboveAverage(above) => {
+                let _ = write!(s, "<dynamicFilter type=\"{}\"/>", if *above { "aboveAverage" } else { "belowAverage" });
+            }
+            FilterCriterion::FillColor(c) => {
+                let st = Style { fill: gridcraft_model::Fill::solid(*c), ..Default::default() };
+                let _ = write!(s, "<colorFilter dxfId=\"{}\"/>", dxf_id(&mut out.dxfs, &st));
+            }
+            FilterCriterion::FontColor(c) => {
+                let mut st = Style::default();
+                st.font.color = *c;
+                let _ = write!(s, "<colorFilter dxfId=\"{}\" cellColor=\"0\"/>", dxf_id(&mut out.dxfs, &st));
+            }
+            FilterCriterion::Icon { set, id } => {
+                let _ = write!(s, "<iconFilter iconSet=\"{}\"", esc_attr(set));
+                if let Some(id) = id {
+                    let _ = write!(s, " iconId=\"{id}\"");
+                }
+                s.push_str("/>");
+            }
+        }
+        s.push_str("</filterColumn>");
+    }
+    s.push_str("</autoFilter>");
+    s
+}
+
+pub(super) fn table_xml(t: &Table, cols: &[String], name: &str, id: u32, out: &mut Out) -> String {
+    let mut s =
+        format!("{XML_DECL}<table xmlns=\"{NS_MAIN}\" id=\"{id}\" name=\"{0}\" displayName=\"{0}\" ref=\"{1}\"", esc_attr(name), t.range.a1());
+    if !t.header_row {
+        s.push_str(" headerRowCount=\"0\"");
+    }
+    if t.totals_row {
+        s.push_str(" totalsRowCount=\"1\"");
+    } else {
+        s.push_str(" totalsRowShown=\"0\"");
+    }
+    if let Some(ty) = &t.table_type {
+        let _ = write!(s, " tableType=\"{}\"", esc_attr(ty));
+    }
+    if let Some(c) = t.connection_id {
+        let _ = write!(s, " connectionId=\"{c}\"");
+    }
+    s.push('>');
+    if t.header_row && t.filter_button {
+        let end_row = if t.totals_row { t.range.end.row.saturating_sub(1).max(t.range.start.row) } else { t.range.end.row };
+        let r = RangeRef::new(t.range.start, CellRef::new(end_row, t.range.end.col));
+        s.push_str(&autofilter_xml(r, &t.filter, out));
+    }
+    let _ = write!(s, "<tableColumns count=\"{}\">", cols.len());
+    for (i, name) in cols.iter().enumerate() {
+        let col = t.columns.get(i);
+        let _ = write!(s, "<tableColumn id=\"{}\"", i + 1);
+        if let Some(u) = col.and_then(|c| c.unique_name.as_ref()) {
+            let _ = write!(s, " uniqueName=\"{}\"", esc_attr(u));
+        }
+        let _ = write!(s, " name=\"{}\"", esc_attr(&encode_xstring(name)));
+        let totals = col.map(|c| c.totals).unwrap_or_default();
+        if t.totals_row {
+            let f = match totals {
+                TotalsFn::None => None,
+                TotalsFn::Average => Some("average"),
+                TotalsFn::Count => Some("count"),
+                TotalsFn::CountNums => Some("countNums"),
+                TotalsFn::Max => Some("max"),
+                TotalsFn::Min => Some("min"),
+                TotalsFn::Sum => Some("sum"),
+                TotalsFn::StdDev => Some("stdDev"),
+                TotalsFn::Var => Some("var"),
+                TotalsFn::Custom => Some("custom"),
+            };
+            if let Some(f) = f {
+                let _ = write!(s, " totalsRowFunction=\"{f}\"");
+            } else if let Some(l) = col.and_then(|c| c.totals_label.as_ref()) {
+                let _ = write!(s, " totalsRowLabel=\"{}\"", esc_attr(l));
+            }
+        }
+        let calc = col.and_then(|c| c.formula.as_ref()).filter(|f| !f.is_empty());
+        let custom = if t.totals_row && totals == TotalsFn::Custom { col.and_then(|c| c.totals_label.as_ref()) } else { None };
+        let xml = col.and_then(|c| c.xml.as_ref());
+        if calc.is_none() && custom.is_none() && xml.is_none() {
+            s.push_str("/>");
+            continue;
+        }
+        s.push('>');
+        if let Some(f) = calc {
+            let _ = write!(s, "<calculatedColumnFormula>{}</calculatedColumnFormula>", esc(&text_to_file(f)));
+        }
+        if let Some(f) = custom {
+            let _ = write!(s, "<totalsRowFormula>{}</totalsRowFormula>", esc(&text_to_file(f)));
+        }
+        if let Some(x) = xml {
+            let _ = write!(s, "<xmlColumnPr mapId=\"{}\" xpath=\"{}\"", x.map_id, esc_attr(&x.xpath));
+            if x.denormalized {
+                s.push_str(" denormalized=\"1\"");
+            }
+            let _ = write!(s, " xmlDataType=\"{}\"/>", esc_attr(&x.data_type));
+        }
+        s.push_str("</tableColumn>");
+    }
+    s.push_str("</tableColumns>");
+    let style = if t.style.is_empty() { "TableStyleMedium2" } else { &t.style };
+    let _ = write!(
+        s,
+        "<tableStyleInfo name=\"{}\" showFirstColumn=\"{}\" showLastColumn=\"{}\" showRowStripes=\"{}\" showColumnStripes=\"{}\"/></table>",
+        esc_attr(style),
+        t.first_col as u8,
+        t.last_col as u8,
+        t.banded_rows as u8,
+        t.banded_cols as u8
+    );
+    s
+}
+
+/// Ids of the threaded comments of sheet `si`: the thread's id, then one per reply. GUID-shaped
+/// and deterministic; they only need to be unique within the file.
+pub(super) fn thread_ids(sheet: &Sheet, si: usize) -> BTreeMap<CellRef, Vec<String>> {
+    let mut seq: u64 = 0;
+    let mut ids = BTreeMap::new();
+    for (cell, c) in sheet.comments.iter().filter(|(_, c)| c.threaded) {
+        let v: Vec<String> = (0..=c.replies.len())
+            .map(|_| {
+                seq += 1;
+                format!("{{{:08X}-0000-4000-8001-{:012X}}}", si as u64 & 0xFFFF_FFFF, seq & 0xFFFF_FFFF_FFFF)
+            })
+            .collect();
+        ids.insert(*cell, v);
+    }
+    ids
+}
+
+pub(super) fn comments_xml(sheet: &Sheet, ids: &BTreeMap<CellRef, Vec<String>>) -> String {
+    // A threaded comment's legacy note is authored by `tc={thread id}`.
+    let author_of = |cell: &CellRef, c: &gridcraft_model::Comment| match ids.get(cell).and_then(|v| v.first()) {
+        Some(id) => format!("tc={id}"),
+        None => c.author.clone(),
+    };
+    let mut authors: Vec<String> = vec![];
+    for (cell, c) in &sheet.comments {
+        let a = author_of(cell, c);
+        if !authors.contains(&a) {
+            authors.push(a);
+        }
+    }
+    let mut s = if ids.is_empty() {
+        format!("{XML_DECL}<comments xmlns=\"{NS_MAIN}\"><authors>")
+    } else {
+        format!(
+            "{XML_DECL}<comments xmlns=\"{NS_MAIN}\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"xr\" xmlns:xr=\"http://schemas.microsoft.com/office/spreadsheetml/2014/revision\"><authors>"
+        )
+    };
+    for a in &authors {
+        let _ = write!(s, "<author>{}</author>", esc(a));
+    }
+    s.push_str("</authors><commentList>");
+    for (cell, c) in &sheet.comments {
+        let a = author_of(cell, c);
+        let aid = authors.iter().position(|x| *x == a).unwrap_or(0);
+        let mut text = c.text.clone();
+        // Threaded replies are kept as text lines.
+        for (who, reply) in &c.replies {
+            let _ = write!(text, "\n{who}: {reply}");
+        }
+        let link = match ids.get(cell).and_then(|v| v.first()) {
+            Some(id) => format!(" shapeId=\"0\" xr:uid=\"{id}\""),
+            None => String::new(),
+        };
+        let _ = write!(s, "<comment ref=\"{}\" authorId=\"{aid}\"{link}><text><r>{}</r></text></comment>", cell.a1(), crate::xml::t_el(&text));
+    }
+    s.push_str("</commentList></comments>");
+    s
+}
+
+/// `2024-05-01T09:30:00` with optional fraction and zone: what `dT` (xsd:dateTime) accepts.
+/// Anything else is left out rather than written into the file.
+fn iso_datetime(d: &str) -> bool {
+    let b = d.as_bytes();
+    let digits = |r: std::ops::Range<usize>| b.get(r).is_some_and(|s| s.iter().all(u8::is_ascii_digit));
+    d.len() <= 40
+        && digits(0..4)
+        && b.get(4) == Some(&b'-')
+        && digits(5..7)
+        && b.get(7) == Some(&b'-')
+        && digits(8..10)
+        && b.get(10) == Some(&b'T')
+        && digits(11..13)
+        && b.get(13) == Some(&b':')
+        && digits(14..16)
+        && b.get(16) == Some(&b':')
+        && digits(17..19)
+        && b.get(19..).is_some_and(|rest| rest.iter().all(|c| c.is_ascii_digit() || b".:+-Z".contains(c)))
+}
+
+/// `xl/threadedComments/threadedCommentN.xml`: each thread, then its replies (`parentId`).
+pub(super) fn threaded_xml(sheet: &Sheet, ids: &BTreeMap<CellRef, Vec<String>>, persons: &mut Vec<String>) -> String {
+    let mut person = |name: &str| {
+        let i = persons.iter().position(|p| p == name).unwrap_or_else(|| {
+            persons.push(name.to_string());
+            persons.len() - 1
+        });
+        crate::write::person_guid(i)
+    };
+    let mut s = format!("{XML_DECL}<ThreadedComments xmlns=\"{NS_THREADED}\" xmlns:x=\"{NS_MAIN}\">");
+    for (cell, id) in ids {
+        let Some(c) = sheet.comments.get(cell) else { continue };
+        let entries = std::iter::once((&c.author, &c.text)).chain(c.replies.iter().map(|(a, t)| (a, t)));
+        for (k, ((author, text), own)) in entries.zip(id).enumerate() {
+            let date = match c.dates.get(k).filter(|d| iso_datetime(d)) {
+                Some(d) => format!(" dT=\"{}\"", esc_attr(d)),
+                None => String::new(),
+            };
+            let tail = match (k, id.first()) {
+                (0, _) if c.resolved => " done=\"1\"".to_string(),
+                (0, _) | (_, None) => String::new(),
+                (_, Some(parent)) => format!(" parentId=\"{parent}\""),
+            };
+            let _ = write!(
+                s,
+                "<threadedComment ref=\"{}\"{date} personId=\"{}\" id=\"{own}\"{tail}><text>{}</text></threadedComment>",
+                cell.a1(),
+                person(author),
+                esc(text)
+            );
+        }
+    }
+    s.push_str("</ThreadedComments>");
+    s
+}
+
+/// A protection password hash as attributes, each name preceded by `prefix` (see
+/// [`crate::sheet_read::read_password`]).
+pub(crate) fn password_attrs(h: &gridcraft_model::PasswordHash, prefix: &str) -> String {
+    let name = |base: &str| crate::sheet_read::password_attr(prefix, base);
+    match h {
+        gridcraft_model::PasswordHash::Legacy(h) => format!(" {}=\"{h:04X}\"", name("password")),
+        gridcraft_model::PasswordHash::Iterated { algorithm, hash, salt, spin_count } => format!(
+            " {}=\"{}\" {}=\"{}\" {}=\"{}\" {}=\"{spin_count}\"",
+            name("algorithmName"),
+            esc_attr(algorithm),
+            name("hashValue"),
+            esc_attr(hash),
+            name("saltValue"),
+            esc_attr(salt),
+            name("spinCount")
+        ),
+    }
+}
+
+/// Allow Edit Ranges: `<protectedRanges>` (after `sheetProtection`).
+pub(super) fn protected_ranges_xml(sheet: &Sheet) -> String {
+    let mut s = String::new();
+    for r in sheet.edit_ranges.iter().filter(|r| !r.ranges.is_empty()) {
+        let sqref: Vec<String> = r.ranges.iter().map(|x| x.a1()).collect();
+        let _ = write!(s, "<protectedRange name=\"{}\" sqref=\"{}\"", esc_attr(&r.title), sqref.join(" "));
+        if let Some(h) = &r.password {
+            s.push_str(&password_attrs(h, ""));
+        }
+        if let Some(sd) = &r.security_descriptor {
+            let _ = write!(s, " securityDescriptor=\"{}\"", esc_attr(sd));
+        }
+        s.push_str("/>");
+    }
+    if s.is_empty() { s } else { format!("<protectedRanges>{s}</protectedRanges>") }
+}
+
+/// A note box's `<x:Anchor>` text and its width and height in points: the box read from the file
+/// or [`DEFAULT_NOTE_BOX`], its corners moved with the note's `cell` and kept on the sheet.
+fn note_anchor(cell: CellRef, b: Option<&NoteBox>) -> (String, (f64, f64)) {
+    let b = b.unwrap_or(&DEFAULT_NOTE_BOX);
+    let at = |base: u32, d: i64, max: u32| (i64::from(base) + d).clamp(0, i64::from(max) - 1);
+    let corner = |k: &NoteCorner| format!("{}, {}, {}, {}", at(cell.col, k.col, MAX_COLS), k.col_px, at(cell.row, k.row, MAX_ROWS), k.row_px);
+    (format!("{}, {}", corner(&b.from), corner(&b.to)), b.size_pt.unwrap_or(DEFAULT_NOTE_SIZE_PT))
+}
+
+/// Legacy VML shapes Excel uses to display notes.
+pub(super) fn vml_xml(sheet: &Sheet, n: u32) -> String {
+    let mut s = format!(
+        "<xml xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:x=\"urn:schemas-microsoft-com:office:excel\"><o:shapelayout v:ext=\"edit\"><o:idmap v:ext=\"edit\" data=\"{n}\"/></o:shapelayout><v:shapetype id=\"_x0000_t202\" coordsize=\"21600,21600\" o:spt=\"202\" path=\"m,l,21600r21600,l21600,xe\"><v:stroke joinstyle=\"miter\"/><v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/></v:shapetype>"
+    );
+    for (i, (cell, c)) in sheet.comments.iter().enumerate() {
+        let id = n as u64 * 1024 + 1 + i as u64;
+        let vis = if c.visible { "visible" } else { "hidden" };
+        let (anchor, (w, h)) = note_anchor(*cell, c.note_box.as_ref());
+        let _ = write!(
+            s,
+            "<v:shape id=\"_x0000_s{id}\" type=\"#_x0000_t202\" style=\"position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:{}pt;height:{}pt;z-index:{};visibility:{vis}\" fillcolor=\"#ffffe1\" o:insetmode=\"auto\"><v:fill color2=\"#ffffe1\"/><v:shadow on=\"t\" color=\"black\" obscured=\"t\"/><v:path o:connecttype=\"none\"/><v:textbox style=\"mso-direction-alt:auto\"><div style=\"text-align:left\"></div></v:textbox><x:ClientData ObjectType=\"Note\"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>{anchor}</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>{}</x:Row><x:Column>{}</x:Column>{}</x:ClientData></v:shape>",
+            num(w),
+            num(h),
+            i + 1,
+            cell.row,
+            cell.col,
+            if c.visible { "<x:Visible/>" } else { "" }
+        );
+    }
+    s.push_str("</xml>");
+    s
+}
diff --git a/crates/xlsx/src/sheet_write/rules.rs b/crates/xlsx/src/sheet_write/rules.rs
new file mode 100644
index 000000000..821ec4cef
--- /dev/null
+++ b/crates/xlsx/src/sheet_write/rules.rs
@@ -0,0 +1,238 @@
+use super::*;
+
+fn cf_op_name(op: CfOperator) -> &'static str {
+    match op {
+        CfOperator::Between => "between",
+        CfOperator::NotBetween => "notBetween",
+        CfOperator::Equal => "equal",
+        CfOperator::NotEqual => "notEqual",
+        CfOperator::Greater => "greaterThan",
+        CfOperator::Less => "lessThan",
+        CfOperator::GreaterOrEqual => "greaterThanOrEqual",
+        CfOperator::LessOrEqual => "lessThanOrEqual",
+    }
+}
+
+fn cfvo_xml(v: &CfValueKind) -> String {
+    match v {
+        CfValueKind::Min => "<cfvo type=\"min\"/>".into(),
+        CfValueKind::Max => "<cfvo type=\"max\"/>".into(),
+        CfValueKind::Number(n) => format!("<cfvo type=\"num\" val=\"{}\"/>", num(*n)),
+        CfValueKind::Percent(n) => format!("<cfvo type=\"percent\" val=\"{}\"/>", num(*n)),
+        CfValueKind::Percentile(n) => format!("<cfvo type=\"percentile\" val=\"{}\"/>", num(*n)),
+        CfValueKind::Formula(f) => format!("<cfvo type=\"formula\" val=\"{}\"/>", esc_attr(&text_to_file(f))),
+    }
+}
+
+fn quote(t: &str) -> String {
+    format!("\"{}\"", t.replace('"', "\"\""))
+}
+
+/// The id linking a solid data bar's `cfRule` to its x14 extension; unique per sheet because priorities are.
+pub(super) fn solid_bar_id(priority: u32) -> String {
+    format!("{{00000000-0000-0000-0000-{priority:012}}}")
+}
+
+/// The `cfRule` extension that points a solid data bar at its x14 rule.
+fn solid_bar_ext(priority: u32) -> String {
+    let id = solid_bar_id(priority);
+    format!("<extLst><ext uri=\"{{B025F937-C7B1-47D3-B67F-A62EFF666E3E}}\" xmlns:x14=\"{X14_NS}\"><x14:id>{id}</x14:id></ext></extLst>")
+}
+
+/// An x14 `cfvo`: unlike the 2006 one it has no `val` attribute, the value is an `xm:f` child.
+pub(super) fn x14_cfvo(v: &CfValueKind) -> String {
+    let (ty, val) = match v {
+        CfValueKind::Min => return "<x14:cfvo type=\"min\"/>".into(),
+        CfValueKind::Max => return "<x14:cfvo type=\"max\"/>".into(),
+        CfValueKind::Number(n) => ("num", num(*n)),
+        CfValueKind::Percent(n) => ("percent", num(*n)),
+        CfValueKind::Percentile(n) => ("percentile", num(*n)),
+        CfValueKind::Formula(f) => ("formula", text_to_file(f)),
+    };
+    format!("<x14:cfvo type=\"{ty}\"><xm:f>{}</xm:f></x14:cfvo>", esc(&val))
+}
+
+pub(super) fn cf_rule_xml(cf: &CondFormat, priority: u32, out: &mut Out) -> String {
+    let tl = cf.ranges.first().map(|r| r.start.a1()).unwrap_or_else(|| "A1".into());
+    let stop = if cf.stop_if_true { " stopIfTrue=\"1\"" } else { "" };
+    let mut dxf = |st: &Style| dxf_id(&mut out.dxfs, st);
+    let f = |x: &str| format!("<formula>{}</formula>", esc(&text_to_file(x)));
+    let simple = |ty: &str, st: &Style, extra: &str, body: String, dxf: &mut dyn FnMut(&Style) -> u32| {
+        format!("<cfRule type=\"{ty}\" dxfId=\"{}\" priority=\"{priority}\"{stop}{extra}>{body}</cfRule>", dxf(st))
+    };
+    match &cf.rule {
+        CfRule::CellIs { op, a, b, style } => {
+            let mut body = f(a);
+            if let Some(b) = b {
+                body.push_str(&f(b));
+            }
+            simple("cellIs", style, &format!(" operator=\"{}\"", cf_op_name(*op)), body, &mut dxf)
+        }
+        CfRule::Expression { formula, style } => simple("expression", style, "", f(formula), &mut dxf),
+        CfRule::ContainsText { text, style } => simple(
+            "containsText",
+            style,
+            &format!(" operator=\"containsText\" text=\"{}\"", esc_attr(text)),
+            f(&format!("NOT(ISERROR(SEARCH({},{tl})))", quote(text))),
+            &mut dxf,
+        ),
+        CfRule::NotContainsText { text, style } => simple(
+            "notContainsText",
+            style,
+            &format!(" operator=\"notContains\" text=\"{}\"", esc_attr(text)),
+            f(&format!("ISERROR(SEARCH({},{tl}))", quote(text))),
+            &mut dxf,
+        ),
+        CfRule::BeginsWith { text, style } => simple(
+            "beginsWith",
+            style,
+            &format!(" operator=\"beginsWith\" text=\"{}\"", esc_attr(text)),
+            f(&format!("LEFT({tl},LEN({0}))={0}", quote(text))),
+            &mut dxf,
+        ),
+        CfRule::EndsWith { text, style } => simple(
+            "endsWith",
+            style,
+            &format!(" operator=\"endsWith\" text=\"{}\"", esc_attr(text)),
+            f(&format!("RIGHT({tl},LEN({0}))={0}", quote(text))),
+            &mut dxf,
+        ),
+        CfRule::Blanks { style } => simple("containsBlanks", style, "", f(&format!("LEN(TRIM({tl}))=0")), &mut dxf),
+        CfRule::NoBlanks { style } => simple("notContainsBlanks", style, "", f(&format!("LEN(TRIM({tl}))>0")), &mut dxf),
+        CfRule::Errors { style } => simple("containsErrors", style, "", f(&format!("ISERROR({tl})")), &mut dxf),
+        CfRule::NoErrors { style } => simple("notContainsErrors", style, "", f(&format!("NOT(ISERROR({tl}))")), &mut dxf),
+        CfRule::Duplicate { style } => simple("duplicateValues", style, "", String::new(), &mut dxf),
+        CfRule::Unique { style } => simple("uniqueValues", style, "", String::new(), &mut dxf),
+        CfRule::Top10 { bottom, percent, rank, style } => {
+            let extra = format!("{}{} rank=\"{}\"", if *percent { " percent=\"1\"" } else { "" }, if *bottom { " bottom=\"1\"" } else { "" }, rank);
+            simple("top10", style, &extra, String::new(), &mut dxf)
+        }
+        CfRule::AboveAverage { below, equal, std_dev, style } => {
+            let mut extra = String::new();
+            if *below {
+                extra.push_str(" aboveAverage=\"0\"");
+            }
+            if *equal {
+                extra.push_str(" equalAverage=\"1\"");
+            }
+            if *std_dev > 0 {
+                let _ = write!(extra, " stdDev=\"{std_dev}\"");
+            }
+            simple("aboveAverage", style, &extra, String::new(), &mut dxf)
+        }
+        CfRule::TimePeriod { period, style } => {
+            let d = format!("FLOOR({tl},1)");
+            let body = match period.as_str() {
+                "yesterday" => format!("{d}=TODAY()-1"),
+                "tomorrow" => format!("{d}=TODAY()+1"),
+                "last7Days" => format!("AND(TODAY()-{d}<=6,{d}<=TODAY())"),
+                "thisMonth" => format!("AND(MONTH({tl})=MONTH(TODAY()),YEAR({tl})=YEAR(TODAY()))"),
+                "lastMonth" => format!("AND(MONTH({tl})=MONTH(EDATE(TODAY(),0-1)),YEAR({tl})=YEAR(EDATE(TODAY(),0-1)))"),
+                "nextMonth" => format!("AND(MONTH({tl})=MONTH(EDATE(TODAY(),0+1)),YEAR({tl})=YEAR(EDATE(TODAY(),0+1)))"),
+                "thisWeek" => format!("AND(TODAY()-ROUNDDOWN({tl},0)<=WEEKDAY(TODAY())-1,ROUNDDOWN({tl},0)-TODAY()<=7-WEEKDAY(TODAY()))"),
+                "lastWeek" => format!("AND(TODAY()-ROUNDDOWN({tl},0)>=(WEEKDAY(TODAY())),TODAY()-ROUNDDOWN({tl},0)<(WEEKDAY(TODAY())+7))"),
+                "nextWeek" => format!("AND(ROUNDDOWN({tl},0)-TODAY()>(7-WEEKDAY(TODAY())),ROUNDDOWN({tl},0)-TODAY()<(15-WEEKDAY(TODAY())))"),
+                _ => format!("{d}=TODAY()"),
+            };
+            simple("timePeriod", style, &format!(" timePeriod=\"{}\"", esc_attr(period)), f(&body), &mut dxf)
+        }
+        CfRule::ColorScale { stops } => {
+            let mut b = String::from("<colorScale>");
+            for (v, _) in stops {
+                b.push_str(&cfvo_xml(v));
+            }
+            for (_, c) in stops {
+                let _ = write!(b, "<color {}/>", color_attrs(c));
+            }
+            b.push_str("</colorScale>");
+            format!("<cfRule type=\"colorScale\" priority=\"{priority}\"{stop}>{b}</cfRule>")
+        }
+        CfRule::DataBar { min, max, color, show_value, gradient } => format!(
+            "<cfRule type=\"dataBar\" priority=\"{priority}\"{stop}><dataBar{}>{}{}<color {}/></dataBar>{}</cfRule>",
+            if *show_value { "" } else { " showValue=\"0\"" },
+            cfvo_xml(min),
+            cfvo_xml(max),
+            if *color == Color::Auto { "rgb=\"FF638EC6\"".to_string() } else { color_attrs(color) },
+            if *gradient { String::new() } else { solid_bar_ext(priority) }
+        ),
+        CfRule::IconSet { set, thresholds, reverse, show_value } => {
+            let mut b = format!("<iconSet iconSet=\"{}\"", esc_attr(set));
+            if *reverse {
+                b.push_str(" reverse=\"1\"");
+            }
+            if !*show_value {
+                b.push_str(" showValue=\"0\"");
+            }
+            b.push('>');
+            // CT_IconSet needs one cfvo per icon (minOccurs 2); the first is the lower bound.
+            let k = icon_count(set);
+            let defaults = default_icon_thresholds(set);
+            let cfvos: Vec<&CfValueKind> = match thresholds.len() {
+                n if n == k => thresholds.iter().collect(),
+                n if n + 1 == k => defaults.iter().take(1).chain(thresholds).collect(),
+                _ => defaults.iter().collect(),
+            };
+            for t in cfvos {
+                b.push_str(&cfvo_xml(t));
+            }
+            b.push_str("</iconSet>");
+            format!("<cfRule type=\"iconSet\" priority=\"{priority}\"{stop}>{b}</cfRule>")
+        }
+    }
+}
+
+fn validation_formula(f: &str) -> String {
+    let f = f.trim();
+    if f.starts_with('"') {
+        return esc(f);
+    }
+    esc(&text_to_file(f.strip_prefix('=').unwrap_or(f)))
+}
+
+pub(super) fn validation_xml(v: &Validation) -> String {
+    let ty = match v.kind {
+        ValidationKind::Any => "none",
+        ValidationKind::Whole => "whole",
+        ValidationKind::Decimal => "decimal",
+        ValidationKind::List => "list",
+        ValidationKind::Date => "date",
+        ValidationKind::Time => "time",
+        ValidationKind::TextLength => "textLength",
+        ValidationKind::Custom => "custom",
+    };
+    let mut s = format!("<dataValidation type=\"{ty}\"");
+    match v.error_style {
+        ErrorStyle::Stop => {}
+        ErrorStyle::Warning => s.push_str(" errorStyle=\"warning\""),
+        ErrorStyle::Information => s.push_str(" errorStyle=\"information\""),
+    }
+    if v.op != CfOperator::Between && !matches!(v.kind, ValidationKind::List | ValidationKind::Custom | ValidationKind::Any) {
+        let _ = write!(s, " operator=\"{}\"", cf_op_name(v.op));
+    }
+    if v.allow_blank {
+        s.push_str(" allowBlank=\"1\"");
+    }
+    if !v.in_cell_dropdown {
+        s.push_str(" showDropDown=\"1\"");
+    }
+    if v.show_input {
+        s.push_str(" showInputMessage=\"1\"");
+    }
+    if v.show_error {
+        s.push_str(" showErrorMessage=\"1\"");
+    }
+    for (a, t) in [("errorTitle", &v.error_title), ("error", &v.error_message), ("promptTitle", &v.input_title), ("prompt", &v.input_message)] {
+        if !t.is_empty() {
+            let _ = write!(s, " {a}=\"{}\"", esc_attr(t));
+        }
+    }
+    let _ = write!(s, " sqref=\"{}\">", sqref(&v.ranges));
+    if !v.f1.is_empty() {
+        let _ = write!(s, "<formula1>{}</formula1>", validation_formula(&v.f1));
+    }
+    if let Some(f2) = v.f2.as_ref().filter(|f| !f.is_empty()) {
+        let _ = write!(s, "<formula2>{}</formula2>", validation_formula(f2));
+    }
+    s.push_str("</dataValidation>");
+    s
+}

From 7f1ccf2e81b5f736069adc139ef754709e22ced4 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:17:05 +0000
Subject: [PATCH 65/76] refactor(xlsx): move sheet_read.rs items to sheet_read/

---
 crates/xlsx/src/sheet_read.rs       | 453 +---------------------------
 crates/xlsx/src/sheet_read/parts.rs | 270 +++++++++++++++++
 crates/xlsx/src/sheet_read/rules.rs | 178 +++++++++++
 3 files changed, 455 insertions(+), 446 deletions(-)
 create mode 100644 crates/xlsx/src/sheet_read/parts.rs
 create mode 100644 crates/xlsx/src/sheet_read/rules.rs

diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs
index aadd1141e..57b5ac7e3 100644
--- a/crates/xlsx/src/sheet_read.rs
+++ b/crates/xlsx/src/sheet_read.rs
@@ -20,6 +20,13 @@ use crate::styles::read_color;
 use crate::tables::{col_width_to_px, paper_name, pt_to_px};
 use crate::xml::{self, El};
 
+mod parts;
+mod rules;
+
+pub use parts::{read_autofilter, read_table};
+use parts::{read_comments, read_hyperlinks, read_note_shapes, read_threaded};
+use rules::{read_cf, read_validation};
+
 struct Shared {
     anchor: CellRef,
     expr: Option<Expr>,
@@ -615,452 +622,6 @@ pub fn parse_sqref(s: Option<&str>) -> Vec<RangeRef> {
     s.unwrap_or("").split_whitespace().filter_map(RangeRef::parse).collect()
 }
 
-fn cf_op(s: Option<&str>) -> CfOperator {
-    match s.unwrap_or("between") {
-        "notBetween" => CfOperator::NotBetween,
-        "equal" => CfOperator::Equal,
-        "notEqual" => CfOperator::NotEqual,
-        "greaterThan" => CfOperator::Greater,
-        "lessThan" => CfOperator::Less,
-        "greaterThanOrEqual" => CfOperator::GreaterOrEqual,
-        "lessThanOrEqual" => CfOperator::LessOrEqual,
-        _ => CfOperator::Between,
-    }
-}
-
-fn cfvo(e: &El) -> CfValueKind {
-    let val = e.attr("val").unwrap_or("");
-    let n = val.trim().parse::<f64>().ok().filter(|v| v.is_finite());
-    match e.attr("type").unwrap_or("num") {
-        "min" | "autoMin" => CfValueKind::Min,
-        "max" | "autoMax" => CfValueKind::Max,
-        "percent" => n.map(CfValueKind::Percent).unwrap_or_else(|| CfValueKind::Formula(from_file(val))),
-        "percentile" => n.map(CfValueKind::Percentile).unwrap_or_else(|| CfValueKind::Formula(from_file(val))),
-        "formula" => CfValueKind::Formula(from_file(val)),
-        _ => n.map(CfValueKind::Number).unwrap_or_else(|| CfValueKind::Formula(from_file(val))),
-    }
-}
-
-/// `cfvo` elements: plain children, or x14 ones with the value in an `xm:f` child.
-fn cfvos(e: &El) -> Vec<CfValueKind> {
-    e.kids("cfvo")
-        .map(|c| {
-            if c.attr("val").is_none()
-                && let Some(f) = c.child("f")
-            {
-                let mut c2 = c.clone();
-                c2.attrs.push(("val".into(), f.text.clone()));
-                return cfvo(&c2);
-            }
-            cfvo(c)
-        })
-        .collect()
-}
-
-fn read_cf(cx: &mut Ctx<'_>, e: &El, sheet: &mut Sheet) {
-    let ranges = parse_sqref(e.attr("sqref"));
-    if ranges.is_empty() {
-        return;
-    }
-    for r in e.kids("cfRule") {
-        let style = Box::new(r.attr_u32("dxfId").and_then(|i| cx.dxfs.get(i as usize)).cloned().unwrap_or_default());
-        let formulas: Vec<String> = r.kids("formula").map(|f| from_file(f.text.trim())).collect();
-        let f0 = formulas.first().cloned().unwrap_or_default();
-        let text = r.attr("text").unwrap_or("").to_string();
-        // The x14 id that links a data bar to its Excel 2010 extension (solid fill lives there).
-        let ext_id =
-            r.child("extLst").and_then(|l| l.kids("ext").find_map(|x| x.child("id"))).map(|i| i.text.trim().to_string()).filter(|i| !i.is_empty());
-        let rule = match r.attr("type").unwrap_or("") {
-            "cellIs" => CfRule::CellIs { op: cf_op(r.attr("operator")), a: f0, b: formulas.get(1).cloned(), style },
-            "expression" => CfRule::Expression { formula: f0, style },
-            "containsText" => CfRule::ContainsText { text, style },
-            "notContainsText" => CfRule::NotContainsText { text, style },
-            "beginsWith" => CfRule::BeginsWith { text, style },
-            "endsWith" => CfRule::EndsWith { text, style },
-            "containsBlanks" => CfRule::Blanks { style },
-            "notContainsBlanks" => CfRule::NoBlanks { style },
-            "containsErrors" => CfRule::Errors { style },
-            "notContainsErrors" => CfRule::NoErrors { style },
-            "duplicateValues" => CfRule::Duplicate { style },
-            "uniqueValues" => CfRule::Unique { style },
-            "top10" => {
-                CfRule::Top10 { bottom: r.flag("bottom", false), percent: r.flag("percent", false), rank: r.attr_u32("rank").unwrap_or(10), style }
-            }
-            "aboveAverage" => CfRule::AboveAverage {
-                below: !r.flag("aboveAverage", true),
-                equal: r.flag("equalAverage", false),
-                std_dev: r.attr_u32("stdDev").unwrap_or(0).min(3) as u8,
-                style,
-            },
-            "timePeriod" => CfRule::TimePeriod { period: r.attr("timePeriod").unwrap_or("today").to_string(), style },
-            "colorScale" => {
-                let Some(cs) = r.child("colorScale") else { continue };
-                let colors = cs.kids("color").map(|c| read_color(c, &cx.palette));
-                CfRule::ColorScale { stops: cfvos(cs).into_iter().zip(colors).collect() }
-            }
-            "dataBar" => {
-                let Some(db) = r.child("dataBar") else { continue };
-                let v = cfvos(db);
-                CfRule::DataBar {
-                    min: v.first().cloned().unwrap_or(CfValueKind::Min),
-                    max: v.get(1).cloned().unwrap_or(CfValueKind::Max),
-                    color: db.child("color").map(|c| read_color(c, &cx.palette)).unwrap_or_default(),
-                    gradient: true,
-                    show_value: db.flag("showValue", true),
-                }
-            }
-            "iconSet" => {
-                let Some(is) = r.child("iconSet") else { continue };
-                CfRule::IconSet {
-                    set: is.attr("iconSet").unwrap_or("3TrafficLights1").to_string(),
-                    thresholds: cfvos(is),
-                    reverse: is.flag("reverse", false),
-                    show_value: is.flag("showValue", true),
-                }
-            }
-            other => {
-                cx.warn(format!("conditional format type \"{other}\" is not supported"));
-                continue;
-            }
-        };
-        if let Some(id) = ext_id {
-            cx.cf_ext_ids.push((id, sheet.cond_formats.len()));
-        }
-        let rules = sheet.cond_formats.len();
-        let area = ranges.iter().map(RangeRef::count).sum::<u64>().saturating_mul(1 + rules as u64);
-        if area > MAX_COND_CELLS {
-            cx.warn(format!("conditional formats past {MAX_COND_CELLS} kept range cells were dropped"));
-            break;
-        }
-        sheet.cond_formats.push(CondFormat {
-            ranges: ranges.clone(),
-            rule,
-            priority: r.attr_u32("priority").unwrap_or(0),
-            stop_if_true: r.flag("stopIfTrue", false),
-        });
-    }
-}
-
-/// A `dataValidation` (main namespace, or x14 with `xm:f` formulas and an `xm:sqref` child).
-fn read_validation(v: &El) -> Option<Validation> {
-    let sq = v.attr("sqref").map(str::to_string).or_else(|| v.child("sqref").map(|s| s.text.clone()));
-    let ranges = parse_sqref(sq.as_deref());
-    if ranges.is_empty() {
-        return None;
-    }
-    let formula = |n: &str| -> Option<String> {
-        let f = v.child(n)?;
-        let t = f.child("f").map(|x| x.text.as_str()).unwrap_or(f.text.as_str()).trim();
-        if t.is_empty() { None } else { Some(t.to_string()) }
-    };
-    let kind = match v.attr("type").unwrap_or("none") {
-        "whole" => ValidationKind::Whole,
-        "decimal" => ValidationKind::Decimal,
-        "list" => ValidationKind::List,
-        "date" => ValidationKind::Date,
-        "time" => ValidationKind::Time,
-        "textLength" => ValidationKind::TextLength,
-        "custom" => ValidationKind::Custom,
-        _ => ValidationKind::Any,
-    };
-    let mut f1 = formula("formula1").unwrap_or_default();
-    if kind == ValidationKind::List && !f1.is_empty() && !f1.starts_with('"') {
-        f1 = format!("={}", from_file(&f1));
-    } else if !f1.starts_with('"') && !f1.is_empty() {
-        f1 = from_file(&f1);
-    }
-    Some(Validation {
-        ranges,
-        kind,
-        op: cf_op(v.attr("operator")),
-        f1,
-        f2: formula("formula2").map(|f| from_file(&f)),
-        allow_blank: v.flag("allowBlank", false),
-        // `showDropDown="1"` *hides* the in-cell list arrow.
-        in_cell_dropdown: !v.flag("showDropDown", false),
-        input_title: v.attr("promptTitle").unwrap_or("").to_string(),
-        input_message: v.attr("prompt").unwrap_or("").to_string(),
-        show_input: v.flag("showInputMessage", false),
-        error_title: v.attr("errorTitle").unwrap_or("").to_string(),
-        error_message: v.attr("error").unwrap_or("").to_string(),
-        error_style: match v.attr("errorStyle") {
-            Some("warning") => ErrorStyle::Warning,
-            Some("information") => ErrorStyle::Information,
-            _ => ErrorStyle::Stop,
-        },
-        show_error: v.flag("showErrorMessage", false),
-    })
-}
-
-fn read_hyperlinks(cx: &mut Ctx<'_>, name: &str, e: &El, rels: &[Rel], sheet: &mut Sheet) {
-    let mut cells = 0u64;
-    let mut bytes = 0u64;
-    for h in e.kids("hyperlink") {
-        let Some(range) = h.attr("ref").and_then(RangeRef::parse) else { continue };
-        let mut target = h.attr("id").and_then(|id| rels.iter().find(|r| r.id == id)).map(|r| r.target.clone()).unwrap_or_default();
-        // A relationship is a file or web page; a bare `location` is a place in this workbook.
-        let external = !target.is_empty();
-        if let Some(loc) = h.attr("location").filter(|l| !l.is_empty()) {
-            if target.is_empty() {
-                target = loc.trim_start_matches('#').to_string();
-            } else {
-                target = format!("{target}#{loc}");
-            }
-        }
-        if target.is_empty() {
-            continue;
-        }
-        let link = Hyperlink { target: target.clone(), tooltip: h.attr("tooltip").map(str::to_string), external };
-        let link_bytes = (target.len() + link.tooltip.as_ref().map_or(0, |t| t.len())) as u64;
-        for c in range.iter() {
-            if cells >= MAX_HYPERLINK_CELLS {
-                cx.warn(format!("sheet \"{name}\": hyperlinks past the first {MAX_HYPERLINK_CELLS} cells were dropped"));
-                return;
-            }
-            if bytes.saturating_add(link_bytes) > MAX_HYPERLINK_BYTES {
-                cx.warn(format!("sheet \"{name}\": hyperlink targets past {MAX_HYPERLINK_BYTES} bytes were dropped"));
-                return;
-            }
-            cells += 1;
-            bytes += link_bytes;
-            sheet.hyperlinks.insert(c, link.clone());
-        }
-    }
-}
-
-fn filter_op(s: Option<&str>) -> &'static str {
-    match s.unwrap_or("equal") {
-        "lessThan" => "<",
-        "lessThanOrEqual" => "<=",
-        "notEqual" => "<>",
-        "greaterThanOrEqual" => ">=",
-        "greaterThan" => ">",
-        _ => "=",
-    }
-}
-
-pub fn read_autofilter(cx: &mut Ctx<'_>, e: &El) -> Option<AutoFilter> {
-    let range = e.attr("ref").and_then(RangeRef::parse)?;
-    let mut criteria = vec![];
-    for fc in e.kids("filterColumn") {
-        let Some(col) = fc.attr_u32("colId") else { continue };
-        let crit = if let Some(f) = fc.child("filters") {
-            FilterCriterion::Values {
-                values: f.kids("filter").filter_map(|x| x.attr("val")).map(str::to_string).collect(),
-                blanks: f.flag("blank", false),
-            }
-        } else if let Some(cf) = fc.child("customFilters") {
-            let mut it = cf.kids("customFilter").map(|c| (filter_op(c.attr("operator")).to_string(), c.attr("val").unwrap_or("").to_string()));
-            let Some(a) = it.next() else { continue };
-            FilterCriterion::Custom { a, b: it.next(), and: cf.flag("and", false) }
-        } else if let Some(t) = fc.child("top10") {
-            FilterCriterion::Top10 {
-                bottom: !t.flag("top", true),
-                percent: t.flag("percent", false),
-                count: t.attr_f64("val").unwrap_or(10.0).clamp(0.0, 1e9) as u32,
-            }
-        } else if let Some(d) = fc.child("dynamicFilter") {
-            match d.attr("type") {
-                Some("aboveAverage") => FilterCriterion::AboveAverage(true),
-                Some("belowAverage") => FilterCriterion::AboveAverage(false),
-                _ => {
-                    cx.warn("date filters in AutoFilters are not supported");
-                    continue;
-                }
-            }
-        } else if let Some(c) = fc.child("colorFilter") {
-            let Some(dxf) = c.attr_u32("dxfId").and_then(|i| cx.dxfs.get(i as usize)) else { continue };
-            if c.flag("cellColor", true) { FilterCriterion::FillColor(dxf.fill.fg) } else { FilterCriterion::FontColor(dxf.font.color) }
-        } else if let Some(i) = fc.child("iconFilter") {
-            let Some(set) = i.attr("iconSet") else { continue };
-            FilterCriterion::Icon { set: set.to_string(), id: i.attr_u32("iconId") }
-        } else {
-            continue;
-        };
-        criteria.push((col, crit));
-    }
-    Some(AutoFilter { range, criteria })
-}
-
-pub fn read_table(cx: &mut Ctx<'_>, x: &El) -> Option<Table> {
-    let range = x.attr("ref").and_then(RangeRef::parse)?;
-    let name = x.attr("displayName").or_else(|| x.attr("name")).unwrap_or("Table").to_string();
-    let header_row = x.attr_u32("headerRowCount").unwrap_or(1) > 0;
-    let totals_row = x.attr_u32("totalsRowCount").unwrap_or(0) > 0;
-    let columns = x
-        .child("tableColumns")
-        .map(|tc| {
-            tc.kids("tableColumn")
-                .map(|c| {
-                    let totals = match c.attr("totalsRowFunction").unwrap_or("none") {
-                        "average" => TotalsFn::Average,
-                        "count" => TotalsFn::Count,
-                        "countNums" => TotalsFn::CountNums,
-                        "max" => TotalsFn::Max,
-                        "min" => TotalsFn::Min,
-                        "sum" => TotalsFn::Sum,
-                        "stdDev" => TotalsFn::StdDev,
-                        "var" => TotalsFn::Var,
-                        "custom" => TotalsFn::Custom,
-                        _ => TotalsFn::None,
-                    };
-                    let totals_label = if totals == TotalsFn::Custom {
-                        c.child("totalsRowFormula").map(|f| from_file(f.text.trim()))
-                    } else {
-                        c.attr("totalsRowLabel").map(str::to_string)
-                    };
-                    TableColumn {
-                        name: xml::decode_xstring(c.attr("name").unwrap_or("")),
-                        totals,
-                        totals_label,
-                        formula: c.child("calculatedColumnFormula").map(|f| from_file(f.text.trim())),
-                        unique_name: c.attr("uniqueName").map(str::to_string),
-                        xml: c.child("xmlColumnPr").and_then(|x| {
-                            Some(XmlColumnPr {
-                                map_id: x.attr_u32("mapId")?,
-                                xpath: x.attr("xpath")?.to_string(),
-                                data_type: x.attr("xmlDataType").unwrap_or("string").to_string(),
-                                denormalized: x.flag("denormalized", false),
-                            })
-                        }),
-                    }
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-    let si = x.child("tableStyleInfo");
-    // Only XML tables are kept as such: a query table's definition hangs off the table part, which
-    // is rewritten, so it would lose it.
-    let xml_table = x.attr("tableType") == Some("xml");
-    Some(Table {
-        id: x.attr_u32("id").unwrap_or(0),
-        name,
-        range,
-        header_row,
-        totals_row,
-        columns,
-        style: si.and_then(|s| s.attr("name")).unwrap_or("").to_string(),
-        banded_rows: si.is_some_and(|s| s.flag("showRowStripes", false)),
-        banded_cols: si.is_some_and(|s| s.flag("showColumnStripes", false)),
-        first_col: si.is_some_and(|s| s.flag("showFirstColumn", false)),
-        last_col: si.is_some_and(|s| s.flag("showLastColumn", false)),
-        filter_button: x.child("autoFilter").is_some(),
-        filter: x.child("autoFilter").and_then(|e| read_autofilter(cx, e)).map(|af| af.criteria).unwrap_or_default(),
-        table_type: xml_table.then(|| "xml".to_string()),
-        connection_id: x.attr_u32("connectionId").filter(|_| xml_table),
-    })
-}
-
-fn read_comments(x: &El, sheet: &mut Sheet) {
-    let authors: Vec<String> = x.child("authors").map(|a| a.kids("author").map(|a| a.text.clone()).collect()).unwrap_or_default();
-    let Some(list) = x.child("commentList") else { return };
-    for c in list.kids("comment") {
-        let Some(cell) = c.attr("ref").and_then(CellRef::parse) else { continue };
-        let author = c.attr_u32("authorId").and_then(|i| authors.get(i as usize)).cloned().unwrap_or_default();
-        let mut text = c.child("text").map(xml::rich_text).unwrap_or_default();
-        // Excel starts a note with a bold "Author:" line.
-        if !author.is_empty()
-            && let Some(rest) = text.strip_prefix(&format!("{author}:"))
-        {
-            text = rest.strip_prefix('\n').unwrap_or(rest).to_string();
-        }
-        sheet
-            .comments
-            .insert(cell, Comment { author, text, replies: vec![], threaded: false, resolved: false, visible: false, dates: vec![], note_box: None });
-    }
-}
-
-/// Reads the notes' VML shapes: a shape carrying `<x:Visible/>` marks its note as shown, and its
-/// `<x:Anchor>` and style size become the note's box. Shapes may sit in groups.
-fn read_note_shapes(x: &El, sheet: &mut Sheet, depth: usize) {
-    if depth > xml::MAX_DEPTH {
-        return;
-    }
-    for e in &x.children {
-        if e.name != "shape" {
-            read_note_shapes(e, sheet, depth + 1);
-            continue;
-        }
-        let Some(cd) = e.child("ClientData").filter(|cd| cd.attr("ObjectType") == Some("Note")) else { continue };
-        let num = |k: &str| cd.child(k).and_then(|v| v.text.trim().parse::<u32>().ok());
-        let (Some(row), Some(col)) = (num("Row"), num("Column")) else { continue };
-        let cell = CellRef::new(row, col);
-        let Some(c) = sheet.comments.get_mut(&cell) else { continue };
-        if cd.child("Visible").is_some() && !c.threaded {
-            c.visible = true;
-        }
-        if let Some(anchor) = cd.child("Anchor") {
-            c.note_box = note_box(&anchor.text, e.attr("style").unwrap_or(""), cell).filter(|b| *b != crate::sheet_write::DEFAULT_NOTE_BOX);
-        }
-    }
-}
-
-/// A note's box from its VML `<x:Anchor>` (`LeftColumn, LeftOffset, TopRow, TopOffset,
-/// RightColumn, RightOffset, BottomRow, BottomOffset`; offsets in pixels) and its shape's style,
-/// the corners made relative to the note's `cell`. `None` when the anchor isn't eight in-sheet
-/// numbers.
-fn note_box(anchor: &str, style: &str, cell: CellRef) -> Option<NoteBox> {
-    let v: Vec<u32> = anchor.split(',').map(|p| p.trim().parse::<u32>().ok()).collect::<Option<_>>()?;
-    let [c1, dx1, r1, dy1, c2, dx2, r2, dy2] = <[u32; 8]>::try_from(v).ok()?;
-    if c1.max(c2) >= MAX_COLS || r1.max(r2) >= MAX_ROWS {
-        return None;
-    }
-    let corner = |c: u32, dx: u32, r: u32, dy: u32| NoteCorner {
-        col: i64::from(c) - i64::from(cell.col),
-        col_px: dx,
-        row: i64::from(r) - i64::from(cell.row),
-        row_px: dy,
-    };
-    let pt = |key: &str| {
-        style
-            .split(';')
-            .filter_map(|d| d.split_once(':'))
-            .find(|(k, _)| k.trim().eq_ignore_ascii_case(key))
-            .and_then(|(_, v)| v.trim().strip_suffix("pt")?.trim().parse::<f64>().ok().filter(|n| n.is_finite() && *n > 0.0 && *n < 1e6))
-    };
-    Some(NoteBox { from: corner(c1, dx1, r1, dy1), to: corner(c2, dx2, r2, dy2), size_pt: pt("width").zip(pt("height")) })
-}
-
-fn read_threaded(cx: &Ctx<'_>, x: &El, sheet: &mut Sheet) {
-    let mut by_id: HashMap<String, CellRef> = HashMap::new();
-    let mut replies: Vec<(String, String, String, String)> = vec![];
-    for t in x.kids("threadedComment") {
-        let Some(cell) = t.attr("ref").and_then(CellRef::parse) else { continue };
-        let author = t.attr("personId").and_then(|p| cx.persons.get(p)).cloned().unwrap_or_default();
-        let text = t.child("text").map(|e| e.text.clone()).unwrap_or_default();
-        let date = t.attr("dT").unwrap_or("").to_string();
-        match t.attr("parentId") {
-            Some(p) => replies.push((p.to_string(), author, text, date)),
-            None => {
-                if let Some(id) = t.attr("id") {
-                    by_id.insert(id.to_string(), cell);
-                }
-                let dates = if date.is_empty() { vec![] } else { vec![date] };
-                sheet.comments.insert(
-                    cell,
-                    Comment { author, text, replies: vec![], threaded: true, resolved: t.flag("done", false), visible: false, dates, note_box: None },
-                );
-            }
-        }
-    }
-    // Replies in file order; ones whose thread is missing are dropped.
-    for (parent, author, text, date) in replies {
-        if let Some(c) = by_id.get(&parent)
-            && let Some(cm) = sheet.comments.get_mut(c)
-        {
-            if !date.is_empty() {
-                // `dates[0]` is the thread, `dates[i + 1]` reply i; unknown dates stay empty.
-                let at = cm.replies.len() + 1;
-                if cm.dates.len() < at {
-                    cm.dates.resize(at, String::new());
-                }
-                cm.dates.push(date);
-            }
-            cm.replies.push((author, text));
-        }
-    }
-}
-
 /// Worksheet extensions: x14 data validations and sparklines.
 fn read_ext(cx: &mut Ctx<'_>, e: &El, sheet: &mut Sheet) {
     for ext in e.kids("ext") {
diff --git a/crates/xlsx/src/sheet_read/parts.rs b/crates/xlsx/src/sheet_read/parts.rs
new file mode 100644
index 000000000..c7626e6e9
--- /dev/null
+++ b/crates/xlsx/src/sheet_read/parts.rs
@@ -0,0 +1,270 @@
+use super::*;
+
+pub(super) fn read_hyperlinks(cx: &mut Ctx<'_>, name: &str, e: &El, rels: &[Rel], sheet: &mut Sheet) {
+    let mut cells = 0u64;
+    let mut bytes = 0u64;
+    for h in e.kids("hyperlink") {
+        let Some(range) = h.attr("ref").and_then(RangeRef::parse) else { continue };
+        let mut target = h.attr("id").and_then(|id| rels.iter().find(|r| r.id == id)).map(|r| r.target.clone()).unwrap_or_default();
+        // A relationship is a file or web page; a bare `location` is a place in this workbook.
+        let external = !target.is_empty();
+        if let Some(loc) = h.attr("location").filter(|l| !l.is_empty()) {
+            if target.is_empty() {
+                target = loc.trim_start_matches('#').to_string();
+            } else {
+                target = format!("{target}#{loc}");
+            }
+        }
+        if target.is_empty() {
+            continue;
+        }
+        let link = Hyperlink { target: target.clone(), tooltip: h.attr("tooltip").map(str::to_string), external };
+        let link_bytes = (target.len() + link.tooltip.as_ref().map_or(0, |t| t.len())) as u64;
+        for c in range.iter() {
+            if cells >= MAX_HYPERLINK_CELLS {
+                cx.warn(format!("sheet \"{name}\": hyperlinks past the first {MAX_HYPERLINK_CELLS} cells were dropped"));
+                return;
+            }
+            if bytes.saturating_add(link_bytes) > MAX_HYPERLINK_BYTES {
+                cx.warn(format!("sheet \"{name}\": hyperlink targets past {MAX_HYPERLINK_BYTES} bytes were dropped"));
+                return;
+            }
+            cells += 1;
+            bytes += link_bytes;
+            sheet.hyperlinks.insert(c, link.clone());
+        }
+    }
+}
+
+fn filter_op(s: Option<&str>) -> &'static str {
+    match s.unwrap_or("equal") {
+        "lessThan" => "<",
+        "lessThanOrEqual" => "<=",
+        "notEqual" => "<>",
+        "greaterThanOrEqual" => ">=",
+        "greaterThan" => ">",
+        _ => "=",
+    }
+}
+
+pub fn read_autofilter(cx: &mut Ctx<'_>, e: &El) -> Option<AutoFilter> {
+    let range = e.attr("ref").and_then(RangeRef::parse)?;
+    let mut criteria = vec![];
+    for fc in e.kids("filterColumn") {
+        let Some(col) = fc.attr_u32("colId") else { continue };
+        let crit = if let Some(f) = fc.child("filters") {
+            FilterCriterion::Values {
+                values: f.kids("filter").filter_map(|x| x.attr("val")).map(str::to_string).collect(),
+                blanks: f.flag("blank", false),
+            }
+        } else if let Some(cf) = fc.child("customFilters") {
+            let mut it = cf.kids("customFilter").map(|c| (filter_op(c.attr("operator")).to_string(), c.attr("val").unwrap_or("").to_string()));
+            let Some(a) = it.next() else { continue };
+            FilterCriterion::Custom { a, b: it.next(), and: cf.flag("and", false) }
+        } else if let Some(t) = fc.child("top10") {
+            FilterCriterion::Top10 {
+                bottom: !t.flag("top", true),
+                percent: t.flag("percent", false),
+                count: t.attr_f64("val").unwrap_or(10.0).clamp(0.0, 1e9) as u32,
+            }
+        } else if let Some(d) = fc.child("dynamicFilter") {
+            match d.attr("type") {
+                Some("aboveAverage") => FilterCriterion::AboveAverage(true),
+                Some("belowAverage") => FilterCriterion::AboveAverage(false),
+                _ => {
+                    cx.warn("date filters in AutoFilters are not supported");
+                    continue;
+                }
+            }
+        } else if let Some(c) = fc.child("colorFilter") {
+            let Some(dxf) = c.attr_u32("dxfId").and_then(|i| cx.dxfs.get(i as usize)) else { continue };
+            if c.flag("cellColor", true) { FilterCriterion::FillColor(dxf.fill.fg) } else { FilterCriterion::FontColor(dxf.font.color) }
+        } else if let Some(i) = fc.child("iconFilter") {
+            let Some(set) = i.attr("iconSet") else { continue };
+            FilterCriterion::Icon { set: set.to_string(), id: i.attr_u32("iconId") }
+        } else {
+            continue;
+        };
+        criteria.push((col, crit));
+    }
+    Some(AutoFilter { range, criteria })
+}
+
+pub fn read_table(cx: &mut Ctx<'_>, x: &El) -> Option<Table> {
+    let range = x.attr("ref").and_then(RangeRef::parse)?;
+    let name = x.attr("displayName").or_else(|| x.attr("name")).unwrap_or("Table").to_string();
+    let header_row = x.attr_u32("headerRowCount").unwrap_or(1) > 0;
+    let totals_row = x.attr_u32("totalsRowCount").unwrap_or(0) > 0;
+    let columns = x
+        .child("tableColumns")
+        .map(|tc| {
+            tc.kids("tableColumn")
+                .map(|c| {
+                    let totals = match c.attr("totalsRowFunction").unwrap_or("none") {
+                        "average" => TotalsFn::Average,
+                        "count" => TotalsFn::Count,
+                        "countNums" => TotalsFn::CountNums,
+                        "max" => TotalsFn::Max,
+                        "min" => TotalsFn::Min,
+                        "sum" => TotalsFn::Sum,
+                        "stdDev" => TotalsFn::StdDev,
+                        "var" => TotalsFn::Var,
+                        "custom" => TotalsFn::Custom,
+                        _ => TotalsFn::None,
+                    };
+                    let totals_label = if totals == TotalsFn::Custom {
+                        c.child("totalsRowFormula").map(|f| from_file(f.text.trim()))
+                    } else {
+                        c.attr("totalsRowLabel").map(str::to_string)
+                    };
+                    TableColumn {
+                        name: xml::decode_xstring(c.attr("name").unwrap_or("")),
+                        totals,
+                        totals_label,
+                        formula: c.child("calculatedColumnFormula").map(|f| from_file(f.text.trim())),
+                        unique_name: c.attr("uniqueName").map(str::to_string),
+                        xml: c.child("xmlColumnPr").and_then(|x| {
+                            Some(XmlColumnPr {
+                                map_id: x.attr_u32("mapId")?,
+                                xpath: x.attr("xpath")?.to_string(),
+                                data_type: x.attr("xmlDataType").unwrap_or("string").to_string(),
+                                denormalized: x.flag("denormalized", false),
+                            })
+                        }),
+                    }
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    let si = x.child("tableStyleInfo");
+    // Only XML tables are kept as such: a query table's definition hangs off the table part, which
+    // is rewritten, so it would lose it.
+    let xml_table = x.attr("tableType") == Some("xml");
+    Some(Table {
+        id: x.attr_u32("id").unwrap_or(0),
+        name,
+        range,
+        header_row,
+        totals_row,
+        columns,
+        style: si.and_then(|s| s.attr("name")).unwrap_or("").to_string(),
+        banded_rows: si.is_some_and(|s| s.flag("showRowStripes", false)),
+        banded_cols: si.is_some_and(|s| s.flag("showColumnStripes", false)),
+        first_col: si.is_some_and(|s| s.flag("showFirstColumn", false)),
+        last_col: si.is_some_and(|s| s.flag("showLastColumn", false)),
+        filter_button: x.child("autoFilter").is_some(),
+        filter: x.child("autoFilter").and_then(|e| read_autofilter(cx, e)).map(|af| af.criteria).unwrap_or_default(),
+        table_type: xml_table.then(|| "xml".to_string()),
+        connection_id: x.attr_u32("connectionId").filter(|_| xml_table),
+    })
+}
+
+pub(super) fn read_comments(x: &El, sheet: &mut Sheet) {
+    let authors: Vec<String> = x.child("authors").map(|a| a.kids("author").map(|a| a.text.clone()).collect()).unwrap_or_default();
+    let Some(list) = x.child("commentList") else { return };
+    for c in list.kids("comment") {
+        let Some(cell) = c.attr("ref").and_then(CellRef::parse) else { continue };
+        let author = c.attr_u32("authorId").and_then(|i| authors.get(i as usize)).cloned().unwrap_or_default();
+        let mut text = c.child("text").map(xml::rich_text).unwrap_or_default();
+        // Excel starts a note with a bold "Author:" line.
+        if !author.is_empty()
+            && let Some(rest) = text.strip_prefix(&format!("{author}:"))
+        {
+            text = rest.strip_prefix('\n').unwrap_or(rest).to_string();
+        }
+        sheet
+            .comments
+            .insert(cell, Comment { author, text, replies: vec![], threaded: false, resolved: false, visible: false, dates: vec![], note_box: None });
+    }
+}
+
+/// Reads the notes' VML shapes: a shape carrying `<x:Visible/>` marks its note as shown, and its
+/// `<x:Anchor>` and style size become the note's box. Shapes may sit in groups.
+pub(super) fn read_note_shapes(x: &El, sheet: &mut Sheet, depth: usize) {
+    if depth > xml::MAX_DEPTH {
+        return;
+    }
+    for e in &x.children {
+        if e.name != "shape" {
+            read_note_shapes(e, sheet, depth + 1);
+            continue;
+        }
+        let Some(cd) = e.child("ClientData").filter(|cd| cd.attr("ObjectType") == Some("Note")) else { continue };
+        let num = |k: &str| cd.child(k).and_then(|v| v.text.trim().parse::<u32>().ok());
+        let (Some(row), Some(col)) = (num("Row"), num("Column")) else { continue };
+        let cell = CellRef::new(row, col);
+        let Some(c) = sheet.comments.get_mut(&cell) else { continue };
+        if cd.child("Visible").is_some() && !c.threaded {
+            c.visible = true;
+        }
+        if let Some(anchor) = cd.child("Anchor") {
+            c.note_box = note_box(&anchor.text, e.attr("style").unwrap_or(""), cell).filter(|b| *b != crate::sheet_write::DEFAULT_NOTE_BOX);
+        }
+    }
+}
+
+/// A note's box from its VML `<x:Anchor>` (`LeftColumn, LeftOffset, TopRow, TopOffset,
+/// RightColumn, RightOffset, BottomRow, BottomOffset`; offsets in pixels) and its shape's style,
+/// the corners made relative to the note's `cell`. `None` when the anchor isn't eight in-sheet
+/// numbers.
+fn note_box(anchor: &str, style: &str, cell: CellRef) -> Option<NoteBox> {
+    let v: Vec<u32> = anchor.split(',').map(|p| p.trim().parse::<u32>().ok()).collect::<Option<_>>()?;
+    let [c1, dx1, r1, dy1, c2, dx2, r2, dy2] = <[u32; 8]>::try_from(v).ok()?;
+    if c1.max(c2) >= MAX_COLS || r1.max(r2) >= MAX_ROWS {
+        return None;
+    }
+    let corner = |c: u32, dx: u32, r: u32, dy: u32| NoteCorner {
+        col: i64::from(c) - i64::from(cell.col),
+        col_px: dx,
+        row: i64::from(r) - i64::from(cell.row),
+        row_px: dy,
+    };
+    let pt = |key: &str| {
+        style
+            .split(';')
+            .filter_map(|d| d.split_once(':'))
+            .find(|(k, _)| k.trim().eq_ignore_ascii_case(key))
+            .and_then(|(_, v)| v.trim().strip_suffix("pt")?.trim().parse::<f64>().ok().filter(|n| n.is_finite() && *n > 0.0 && *n < 1e6))
+    };
+    Some(NoteBox { from: corner(c1, dx1, r1, dy1), to: corner(c2, dx2, r2, dy2), size_pt: pt("width").zip(pt("height")) })
+}
+
+pub(super) fn read_threaded(cx: &Ctx<'_>, x: &El, sheet: &mut Sheet) {
+    let mut by_id: HashMap<String, CellRef> = HashMap::new();
+    let mut replies: Vec<(String, String, String, String)> = vec![];
+    for t in x.kids("threadedComment") {
+        let Some(cell) = t.attr("ref").and_then(CellRef::parse) else { continue };
+        let author = t.attr("personId").and_then(|p| cx.persons.get(p)).cloned().unwrap_or_default();
+        let text = t.child("text").map(|e| e.text.clone()).unwrap_or_default();
+        let date = t.attr("dT").unwrap_or("").to_string();
+        match t.attr("parentId") {
+            Some(p) => replies.push((p.to_string(), author, text, date)),
+            None => {
+                if let Some(id) = t.attr("id") {
+                    by_id.insert(id.to_string(), cell);
+                }
+                let dates = if date.is_empty() { vec![] } else { vec![date] };
+                sheet.comments.insert(
+                    cell,
+                    Comment { author, text, replies: vec![], threaded: true, resolved: t.flag("done", false), visible: false, dates, note_box: None },
+                );
+            }
+        }
+    }
+    // Replies in file order; ones whose thread is missing are dropped.
+    for (parent, author, text, date) in replies {
+        if let Some(c) = by_id.get(&parent)
+            && let Some(cm) = sheet.comments.get_mut(c)
+        {
+            if !date.is_empty() {
+                // `dates[0]` is the thread, `dates[i + 1]` reply i; unknown dates stay empty.
+                let at = cm.replies.len() + 1;
+                if cm.dates.len() < at {
+                    cm.dates.resize(at, String::new());
+                }
+                cm.dates.push(date);
+            }
+            cm.replies.push((author, text));
+        }
+    }
+}
diff --git a/crates/xlsx/src/sheet_read/rules.rs b/crates/xlsx/src/sheet_read/rules.rs
new file mode 100644
index 000000000..e0ad3129f
--- /dev/null
+++ b/crates/xlsx/src/sheet_read/rules.rs
@@ -0,0 +1,178 @@
+use super::*;
+
+fn cf_op(s: Option<&str>) -> CfOperator {
+    match s.unwrap_or("between") {
+        "notBetween" => CfOperator::NotBetween,
+        "equal" => CfOperator::Equal,
+        "notEqual" => CfOperator::NotEqual,
+        "greaterThan" => CfOperator::Greater,
+        "lessThan" => CfOperator::Less,
+        "greaterThanOrEqual" => CfOperator::GreaterOrEqual,
+        "lessThanOrEqual" => CfOperator::LessOrEqual,
+        _ => CfOperator::Between,
+    }
+}
+
+fn cfvo(e: &El) -> CfValueKind {
+    let val = e.attr("val").unwrap_or("");
+    let n = val.trim().parse::<f64>().ok().filter(|v| v.is_finite());
+    match e.attr("type").unwrap_or("num") {
+        "min" | "autoMin" => CfValueKind::Min,
+        "max" | "autoMax" => CfValueKind::Max,
+        "percent" => n.map(CfValueKind::Percent).unwrap_or_else(|| CfValueKind::Formula(from_file(val))),
+        "percentile" => n.map(CfValueKind::Percentile).unwrap_or_else(|| CfValueKind::Formula(from_file(val))),
+        "formula" => CfValueKind::Formula(from_file(val)),
+        _ => n.map(CfValueKind::Number).unwrap_or_else(|| CfValueKind::Formula(from_file(val))),
+    }
+}
+
+/// `cfvo` elements: plain children, or x14 ones with the value in an `xm:f` child.
+fn cfvos(e: &El) -> Vec<CfValueKind> {
+    e.kids("cfvo")
+        .map(|c| {
+            if c.attr("val").is_none()
+                && let Some(f) = c.child("f")
+            {
+                let mut c2 = c.clone();
+                c2.attrs.push(("val".into(), f.text.clone()));
+                return cfvo(&c2);
+            }
+            cfvo(c)
+        })
+        .collect()
+}
+
+pub(super) fn read_cf(cx: &mut Ctx<'_>, e: &El, sheet: &mut Sheet) {
+    let ranges = parse_sqref(e.attr("sqref"));
+    if ranges.is_empty() {
+        return;
+    }
+    for r in e.kids("cfRule") {
+        let style = Box::new(r.attr_u32("dxfId").and_then(|i| cx.dxfs.get(i as usize)).cloned().unwrap_or_default());
+        let formulas: Vec<String> = r.kids("formula").map(|f| from_file(f.text.trim())).collect();
+        let f0 = formulas.first().cloned().unwrap_or_default();
+        let text = r.attr("text").unwrap_or("").to_string();
+        // The x14 id that links a data bar to its Excel 2010 extension (solid fill lives there).
+        let ext_id =
+            r.child("extLst").and_then(|l| l.kids("ext").find_map(|x| x.child("id"))).map(|i| i.text.trim().to_string()).filter(|i| !i.is_empty());
+        let rule = match r.attr("type").unwrap_or("") {
+            "cellIs" => CfRule::CellIs { op: cf_op(r.attr("operator")), a: f0, b: formulas.get(1).cloned(), style },
+            "expression" => CfRule::Expression { formula: f0, style },
+            "containsText" => CfRule::ContainsText { text, style },
+            "notContainsText" => CfRule::NotContainsText { text, style },
+            "beginsWith" => CfRule::BeginsWith { text, style },
+            "endsWith" => CfRule::EndsWith { text, style },
+            "containsBlanks" => CfRule::Blanks { style },
+            "notContainsBlanks" => CfRule::NoBlanks { style },
+            "containsErrors" => CfRule::Errors { style },
+            "notContainsErrors" => CfRule::NoErrors { style },
+            "duplicateValues" => CfRule::Duplicate { style },
+            "uniqueValues" => CfRule::Unique { style },
+            "top10" => {
+                CfRule::Top10 { bottom: r.flag("bottom", false), percent: r.flag("percent", false), rank: r.attr_u32("rank").unwrap_or(10), style }
+            }
+            "aboveAverage" => CfRule::AboveAverage {
+                below: !r.flag("aboveAverage", true),
+                equal: r.flag("equalAverage", false),
+                std_dev: r.attr_u32("stdDev").unwrap_or(0).min(3) as u8,
+                style,
+            },
+            "timePeriod" => CfRule::TimePeriod { period: r.attr("timePeriod").unwrap_or("today").to_string(), style },
+            "colorScale" => {
+                let Some(cs) = r.child("colorScale") else { continue };
+                let colors = cs.kids("color").map(|c| read_color(c, &cx.palette));
+                CfRule::ColorScale { stops: cfvos(cs).into_iter().zip(colors).collect() }
+            }
+            "dataBar" => {
+                let Some(db) = r.child("dataBar") else { continue };
+                let v = cfvos(db);
+                CfRule::DataBar {
+                    min: v.first().cloned().unwrap_or(CfValueKind::Min),
+                    max: v.get(1).cloned().unwrap_or(CfValueKind::Max),
+                    color: db.child("color").map(|c| read_color(c, &cx.palette)).unwrap_or_default(),
+                    gradient: true,
+                    show_value: db.flag("showValue", true),
+                }
+            }
+            "iconSet" => {
+                let Some(is) = r.child("iconSet") else { continue };
+                CfRule::IconSet {
+                    set: is.attr("iconSet").unwrap_or("3TrafficLights1").to_string(),
+                    thresholds: cfvos(is),
+                    reverse: is.flag("reverse", false),
+                    show_value: is.flag("showValue", true),
+                }
+            }
+            other => {
+                cx.warn(format!("conditional format type \"{other}\" is not supported"));
+                continue;
+            }
+        };
+        if let Some(id) = ext_id {
+            cx.cf_ext_ids.push((id, sheet.cond_formats.len()));
+        }
+        let rules = sheet.cond_formats.len();
+        let area = ranges.iter().map(RangeRef::count).sum::<u64>().saturating_mul(1 + rules as u64);
+        if area > MAX_COND_CELLS {
+            cx.warn(format!("conditional formats past {MAX_COND_CELLS} kept range cells were dropped"));
+            break;
+        }
+        sheet.cond_formats.push(CondFormat {
+            ranges: ranges.clone(),
+            rule,
+            priority: r.attr_u32("priority").unwrap_or(0),
+            stop_if_true: r.flag("stopIfTrue", false),
+        });
+    }
+}
+
+/// A `dataValidation` (main namespace, or x14 with `xm:f` formulas and an `xm:sqref` child).
+pub(super) fn read_validation(v: &El) -> Option<Validation> {
+    let sq = v.attr("sqref").map(str::to_string).or_else(|| v.child("sqref").map(|s| s.text.clone()));
+    let ranges = parse_sqref(sq.as_deref());
+    if ranges.is_empty() {
+        return None;
+    }
+    let formula = |n: &str| -> Option<String> {
+        let f = v.child(n)?;
+        let t = f.child("f").map(|x| x.text.as_str()).unwrap_or(f.text.as_str()).trim();
+        if t.is_empty() { None } else { Some(t.to_string()) }
+    };
+    let kind = match v.attr("type").unwrap_or("none") {
+        "whole" => ValidationKind::Whole,
+        "decimal" => ValidationKind::Decimal,
+        "list" => ValidationKind::List,
+        "date" => ValidationKind::Date,
+        "time" => ValidationKind::Time,
+        "textLength" => ValidationKind::TextLength,
+        "custom" => ValidationKind::Custom,
+        _ => ValidationKind::Any,
+    };
+    let mut f1 = formula("formula1").unwrap_or_default();
+    if kind == ValidationKind::List && !f1.is_empty() && !f1.starts_with('"') {
+        f1 = format!("={}", from_file(&f1));
+    } else if !f1.starts_with('"') && !f1.is_empty() {
+        f1 = from_file(&f1);
+    }
+    Some(Validation {
+        ranges,
+        kind,
+        op: cf_op(v.attr("operator")),
+        f1,
+        f2: formula("formula2").map(|f| from_file(&f)),
+        allow_blank: v.flag("allowBlank", false),
+        // `showDropDown="1"` *hides* the in-cell list arrow.
+        in_cell_dropdown: !v.flag("showDropDown", false),
+        input_title: v.attr("promptTitle").unwrap_or("").to_string(),
+        input_message: v.attr("prompt").unwrap_or("").to_string(),
+        show_input: v.flag("showInputMessage", false),
+        error_title: v.attr("errorTitle").unwrap_or("").to_string(),
+        error_message: v.attr("error").unwrap_or("").to_string(),
+        error_style: match v.attr("errorStyle") {
+            Some("warning") => ErrorStyle::Warning,
+            Some("information") => ErrorStyle::Information,
+            _ => ErrorStyle::Stop,
+        },
+        show_error: v.flag("showErrorMessage", false),
+    })
+}

From bbb570dc32fe81f7219208cdbf7f2f2b0a9c7189 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:24:58 +0000
Subject: [PATCH 66/76] refactor(model): move features.rs items to features/

---
 crates/model/src/features.rs       | 396 +----------------------------
 crates/model/src/features/pivot.rs | 176 +++++++++++++
 crates/model/src/features/print.rs | 216 ++++++++++++++++
 3 files changed, 398 insertions(+), 390 deletions(-)
 create mode 100644 crates/model/src/features/pivot.rs
 create mode 100644 crates/model/src/features/print.rs

diff --git a/crates/model/src/features.rs b/crates/model/src/features.rs
index 00db5e879..2394319c3 100644
--- a/crates/model/src/features.rs
+++ b/crates/model/src/features.rs
@@ -6,6 +6,12 @@ use serde::{Deserialize, Serialize};
 
 use crate::style::{Color, Style};
 
+mod pivot;
+mod print;
+
+pub use pivot::{PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout, PivotShowAs, PivotSort, PivotTable, PivotValue};
+pub use print::{EditRange, HfPage, LineInfo, Orientation, PrintSettings, SheetProtection, password_hash};
+
 // ---------------------------------------------------------------- tables
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -716,396 +722,6 @@ pub struct Slicer {
     pub columns: u32,
 }
 
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Orientation {
-    #[default]
-    Portrait,
-    Landscape,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct PrintSettings {
-    pub orientation: Orientation,
-    /// Paper size name (`Letter`, `A4`, `Legal`…).
-    pub paper: String,
-    /// Margins in inches: left, right, top, bottom, header, footer.
-    pub margins: [f32; 6],
-    pub print_area: Option<RangeRef>,
-    pub title_rows: Option<(u32, u32)>,
-    pub title_cols: Option<(u32, u32)>,
-    /// Percent scale, or fit to pages (wide, tall).
-    pub scale: u16,
-    pub fit_to: Option<(u16, u16)>,
-    pub gridlines: bool,
-    pub headings: bool,
-    pub center_h: bool,
-    pub center_v: bool,
-    /// The header and footer of odd pages, and of every page unless the variants below apply.
-    pub header: String,
-    pub footer: String,
-    pub row_breaks: Vec<u32>,
-    pub col_breaks: Vec<u32>,
-    /// Different First Page: the sheet's first printed page uses `first_header`/`first_footer`.
-    #[serde(default)]
-    pub different_first: bool,
-    /// Different Odd & Even Pages: even-numbered pages use `even_header`/`even_footer`.
-    #[serde(default)]
-    pub different_odd_even: bool,
-    #[serde(default)]
-    pub first_header: String,
-    #[serde(default)]
-    pub first_footer: String,
-    #[serde(default)]
-    pub even_header: String,
-    #[serde(default)]
-    pub even_footer: String,
-    /// Scale with Document / Align with Page Margins (both on unless a file turned them off).
-    #[serde(default = "yes")]
-    pub hf_scale_with_doc: bool,
-    #[serde(default = "yes")]
-    pub hf_align_with_margins: bool,
-}
-
-fn yes() -> bool {
-    true
-}
-
-/// Which header/footer pair a printed page uses.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum HfPage {
-    Odd,
-    Even,
-    First,
-}
-
-impl HfPage {
-    pub fn id(self) -> &'static str {
-        match self {
-            HfPage::Odd => "odd",
-            HfPage::Even => "even",
-            HfPage::First => "first",
-        }
-    }
-    pub fn parse(id: &str) -> Option<HfPage> {
-        match id {
-            "odd" | "all" => Some(HfPage::Odd),
-            "even" => Some(HfPage::Even),
-            "first" => Some(HfPage::First),
-            _ => None,
-        }
-    }
-}
-
-impl PrintSettings {
-    /// The pair used by page `number` (1-based, as `&P` prints it); `first` is the sheet's first page.
-    pub fn hf_page(&self, first: bool, number: usize) -> HfPage {
-        if self.different_first && first {
-            HfPage::First
-        } else if self.different_odd_even && number.is_multiple_of(2) {
-            HfPage::Even
-        } else {
-            HfPage::Odd
-        }
-    }
-    /// The header (`footer` false) or footer of a page kind.
-    pub fn hf(&self, page: HfPage, footer: bool) -> &String {
-        match (page, footer) {
-            (HfPage::Odd, false) => &self.header,
-            (HfPage::Odd, true) => &self.footer,
-            (HfPage::Even, false) => &self.even_header,
-            (HfPage::Even, true) => &self.even_footer,
-            (HfPage::First, false) => &self.first_header,
-            (HfPage::First, true) => &self.first_footer,
-        }
-    }
-    pub fn hf_mut(&mut self, page: HfPage, footer: bool) -> &mut String {
-        match (page, footer) {
-            (HfPage::Odd, false) => &mut self.header,
-            (HfPage::Odd, true) => &mut self.footer,
-            (HfPage::Even, false) => &mut self.even_header,
-            (HfPage::Even, true) => &mut self.even_footer,
-            (HfPage::First, false) => &mut self.first_header,
-            (HfPage::First, true) => &mut self.first_footer,
-        }
-    }
-    /// Any header or footer text at all (on any kind of page).
-    pub fn has_header_footer(&self) -> bool {
-        [&self.header, &self.footer, &self.first_header, &self.first_footer, &self.even_header, &self.even_footer].iter().any(|t| !t.is_empty())
-    }
-}
-
-impl Default for PrintSettings {
-    fn default() -> Self {
-        PrintSettings {
-            orientation: Orientation::Portrait,
-            paper: "Letter".into(),
-            margins: [0.7, 0.7, 0.75, 0.75, 0.3, 0.3],
-            print_area: None,
-            title_rows: None,
-            title_cols: None,
-            scale: 100,
-            fit_to: None,
-            gridlines: false,
-            headings: false,
-            center_h: false,
-            center_v: false,
-            header: String::new(),
-            footer: String::new(),
-            row_breaks: vec![],
-            col_breaks: vec![],
-            different_first: false,
-            different_odd_even: false,
-            first_header: String::new(),
-            first_footer: String::new(),
-            even_header: String::new(),
-            even_footer: String::new(),
-            hf_scale_with_doc: true,
-            hf_align_with_margins: true,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct SheetProtection {
-    /// Hash of the password (Excel-compatible, written to XLSX `sheetProtection`; never the
-    /// password itself).
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub password: Option<crate::PasswordHash>,
-    /// The internal hash older GridCraft JSON workbooks stored ([`password_hash`]); still
-    /// verified when unprotecting, never written for new passwords.
-    #[serde(rename = "password_hash", default, skip_serializing_if = "Option::is_none")]
-    pub legacy_password_hash: Option<u64>,
-    pub select_locked: bool,
-    pub select_unlocked: bool,
-    pub format_cells: bool,
-    pub format_columns: bool,
-    pub format_rows: bool,
-    pub insert_columns: bool,
-    pub insert_rows: bool,
-    pub delete_columns: bool,
-    pub delete_rows: bool,
-    pub sort: bool,
-    pub autofilter: bool,
-}
-
-/// Review › Allow Edit Ranges: cells that stay editable on a protected sheet, with or without a
-/// password (XLSX `<protectedRange>`).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct EditRange {
-    pub title: String,
-    pub ranges: Vec<RangeRef>,
-    pub password: Option<crate::PasswordHash>,
-    /// Windows permissions (`securityDescriptor`), kept as read from the file.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub security_descriptor: Option<String>,
-}
-
-impl EditRange {
-    pub fn contains(&self, c: CellRef) -> bool {
-        self.ranges.iter().any(|r| r.contains(c))
-    }
-}
-
-/// The non-cryptographic password hash older GridCraft versions stored for sheet protection
-/// (only verified now, see [`SheetProtection::legacy_password_hash`]).
-pub fn password_hash(pw: &str) -> u64 {
-    let mut h: u64 = 0xcbf29ce484222325 ^ 0x5348_4545_5443;
-    for b in pw.bytes() {
-        h ^= b as u64;
-        h = h.wrapping_mul(0x100000001b3);
-    }
-    h
-}
-
-/// Outline grouping info for a row or column.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct LineInfo {
-    /// Size in pixels at 96 dpi; `None` = default (rows auto-fit to content).
-    pub size: Option<f32>,
-    pub hidden: bool,
-    pub outline: u8,
-    pub collapsed: bool,
-    pub style: Option<crate::style::StyleId>,
-    /// The size was set by the user (rows): automatic heights follow the content.
-    #[serde(default)]
-    pub custom: bool,
-}
-
-// ---------------------------------------------------------------- pivot tables
-
-/// How a PivotTable lays out its row fields.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PivotLayout {
-    /// All row fields in one column, inner items indented ("Row Labels" header).
-    #[default]
-    Compact,
-    /// One column per row field; each item on its own row.
-    Outline,
-    /// One column per row field; inner items start on their parent's row, totals below.
-    Tabular,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PivotSort {
-    #[default]
-    Asc,
-    Desc,
-    /// Source order (first appearance).
-    None,
-}
-
-/// Grouping of a date field (values are date serials).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PivotDateGroup {
-    #[default]
-    None,
-    Years,
-    Quarters,
-    Months,
-    Days,
-}
-
-/// A field placed in the Rows or Columns area.
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct PivotField {
-    /// Source column header name.
-    pub source_col: String,
-    pub sort: PivotSort,
-    pub date_group: PivotDateGroup,
-    /// Item labels whose detail is hidden (collapsed).
-    pub collapsed_items: Vec<String>,
-}
-
-/// Summarize-values-by function.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PivotFunc {
-    #[default]
-    Sum,
-    Count,
-    Average,
-    Max,
-    Min,
-    Product,
-    CountNumbers,
-    StdDev,
-    StdDevP,
-    Var,
-    VarP,
-}
-
-/// Show-values-as transform.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PivotShowAs {
-    #[default]
-    Normal,
-    PercentOfGrandTotal,
-    PercentOfColumnTotal,
-    PercentOfRowTotal,
-    /// Running total in the first row field.
-    RunningTotal,
-    /// Rank largest to smallest among sibling row items.
-    Rank,
-}
-
-/// A field in the Values area.
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct PivotValue {
-    pub source_col: String,
-    pub func: PivotFunc,
-    /// Caption, e.g. "Sum of Sales".
-    pub name: String,
-    pub show_as: PivotShowAs,
-    pub number_format: Option<String>,
-}
-
-/// A report filter (or, for a field also in Rows/Columns, its hidden-items filter).
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct PivotFilter {
-    pub source_col: String,
-    /// Item labels shown; `None` = all.
-    pub selected: Option<Vec<String>>,
-}
-
-/// A PivotTable: its definition plus where its output was last written. The output itself is
-/// static cell values and styles on the sheet, rewritten on every refresh.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct PivotTable {
-    pub id: u32,
-    pub name: String,
-    /// Source: range formula text (`Sheet1!$A$1:$E$200`), a table name or a defined name.
-    pub source: String,
-    /// Top-left of the output body on the pivot's sheet.
-    pub anchor: CellRef,
-    pub rows: Vec<PivotField>,
-    pub columns: Vec<PivotField>,
-    pub values: Vec<PivotValue>,
-    pub filters: Vec<PivotFilter>,
-    pub layout: PivotLayout,
-    /// PivotTable Options › Data › Enable show details: Show Details lists a value cell's
-    /// source records only while this is on.
-    pub enable_show_details: bool,
-    /// Grand total for each row (the "Grand Total" column), like Excel's "On for Rows".
-    pub grand_totals_rows: bool,
-    /// Grand total for each column (the "Grand Total" row), like Excel's "On for Columns".
-    pub grand_totals_cols: bool,
-    pub subtotals: bool,
-    /// Subtotals at the top of each group (Compact/Outline); otherwise below it.
-    pub subtotals_top: bool,
-    pub style: String,
-    pub show_headers: bool,
-    /// Area written by the last refresh.
-    pub last_range: Option<RangeRef>,
-    /// Calculated fields, usable in the Values area by name.
-    pub calculated_fields: Vec<PivotCalcField>,
-    /// The Σ Values pseudo-field (it exists with two or more value fields) sits in Rows rather
-    /// than Columns (Excel's "values on rows").
-    pub values_on_rows: bool,
-    /// Position of Σ Values among the row fields (`None` = after the last). Only used with
-    /// `values_on_rows`: in Columns Σ Values always comes after the last column field.
-    pub values_position: Option<usize>,
-}
-
-/// A calculated field: a formula over other fields (`=Sales*0.1`, `='Unit Price'*Units`). As in
-/// Excel, it is evaluated on the sums of the fields it names for each report cell, not per record.
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct PivotCalcField {
-    pub name: String,
-    /// Formula text, starting with `=`.
-    pub formula: String,
-}
-
-impl Default for PivotTable {
-    fn default() -> Self {
-        PivotTable {
-            id: 0,
-            name: "PivotTable1".into(),
-            source: String::new(),
-            anchor: CellRef::default(),
-            rows: vec![],
-            columns: vec![],
-            values: vec![],
-            filters: vec![],
-            layout: PivotLayout::Compact,
-            enable_show_details: true,
-            grand_totals_rows: true,
-            grand_totals_cols: true,
-            subtotals: true,
-            subtotals_top: true,
-            style: "PivotStyleLight16".into(),
-            show_headers: true,
-            last_range: None,
-            calculated_fields: vec![],
-            values_on_rows: false,
-            values_position: None,
-        }
-    }
-}
-
 #[cfg(test)]
 mod trendline_forecast_tests {
     use super::Trendline;
diff --git a/crates/model/src/features/pivot.rs b/crates/model/src/features/pivot.rs
new file mode 100644
index 000000000..368aa1f53
--- /dev/null
+++ b/crates/model/src/features/pivot.rs
@@ -0,0 +1,176 @@
+use super::*;
+
+// ---------------------------------------------------------------- pivot tables
+
+/// How a PivotTable lays out its row fields.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PivotLayout {
+    /// All row fields in one column, inner items indented ("Row Labels" header).
+    #[default]
+    Compact,
+    /// One column per row field; each item on its own row.
+    Outline,
+    /// One column per row field; inner items start on their parent's row, totals below.
+    Tabular,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PivotSort {
+    #[default]
+    Asc,
+    Desc,
+    /// Source order (first appearance).
+    None,
+}
+
+/// Grouping of a date field (values are date serials).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PivotDateGroup {
+    #[default]
+    None,
+    Years,
+    Quarters,
+    Months,
+    Days,
+}
+
+/// A field placed in the Rows or Columns area.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PivotField {
+    /// Source column header name.
+    pub source_col: String,
+    pub sort: PivotSort,
+    pub date_group: PivotDateGroup,
+    /// Item labels whose detail is hidden (collapsed).
+    pub collapsed_items: Vec<String>,
+}
+
+/// Summarize-values-by function.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PivotFunc {
+    #[default]
+    Sum,
+    Count,
+    Average,
+    Max,
+    Min,
+    Product,
+    CountNumbers,
+    StdDev,
+    StdDevP,
+    Var,
+    VarP,
+}
+
+/// Show-values-as transform.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PivotShowAs {
+    #[default]
+    Normal,
+    PercentOfGrandTotal,
+    PercentOfColumnTotal,
+    PercentOfRowTotal,
+    /// Running total in the first row field.
+    RunningTotal,
+    /// Rank largest to smallest among sibling row items.
+    Rank,
+}
+
+/// A field in the Values area.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PivotValue {
+    pub source_col: String,
+    pub func: PivotFunc,
+    /// Caption, e.g. "Sum of Sales".
+    pub name: String,
+    pub show_as: PivotShowAs,
+    pub number_format: Option<String>,
+}
+
+/// A report filter (or, for a field also in Rows/Columns, its hidden-items filter).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PivotFilter {
+    pub source_col: String,
+    /// Item labels shown; `None` = all.
+    pub selected: Option<Vec<String>>,
+}
+
+/// A PivotTable: its definition plus where its output was last written. The output itself is
+/// static cell values and styles on the sheet, rewritten on every refresh.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PivotTable {
+    pub id: u32,
+    pub name: String,
+    /// Source: range formula text (`Sheet1!$A$1:$E$200`), a table name or a defined name.
+    pub source: String,
+    /// Top-left of the output body on the pivot's sheet.
+    pub anchor: CellRef,
+    pub rows: Vec<PivotField>,
+    pub columns: Vec<PivotField>,
+    pub values: Vec<PivotValue>,
+    pub filters: Vec<PivotFilter>,
+    pub layout: PivotLayout,
+    /// PivotTable Options › Data › Enable show details: Show Details lists a value cell's
+    /// source records only while this is on.
+    pub enable_show_details: bool,
+    /// Grand total for each row (the "Grand Total" column), like Excel's "On for Rows".
+    pub grand_totals_rows: bool,
+    /// Grand total for each column (the "Grand Total" row), like Excel's "On for Columns".
+    pub grand_totals_cols: bool,
+    pub subtotals: bool,
+    /// Subtotals at the top of each group (Compact/Outline); otherwise below it.
+    pub subtotals_top: bool,
+    pub style: String,
+    pub show_headers: bool,
+    /// Area written by the last refresh.
+    pub last_range: Option<RangeRef>,
+    /// Calculated fields, usable in the Values area by name.
+    pub calculated_fields: Vec<PivotCalcField>,
+    /// The Σ Values pseudo-field (it exists with two or more value fields) sits in Rows rather
+    /// than Columns (Excel's "values on rows").
+    pub values_on_rows: bool,
+    /// Position of Σ Values among the row fields (`None` = after the last). Only used with
+    /// `values_on_rows`: in Columns Σ Values always comes after the last column field.
+    pub values_position: Option<usize>,
+}
+
+/// A calculated field: a formula over other fields (`=Sales*0.1`, `='Unit Price'*Units`). As in
+/// Excel, it is evaluated on the sums of the fields it names for each report cell, not per record.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PivotCalcField {
+    pub name: String,
+    /// Formula text, starting with `=`.
+    pub formula: String,
+}
+
+impl Default for PivotTable {
+    fn default() -> Self {
+        PivotTable {
+            id: 0,
+            name: "PivotTable1".into(),
+            source: String::new(),
+            anchor: CellRef::default(),
+            rows: vec![],
+            columns: vec![],
+            values: vec![],
+            filters: vec![],
+            layout: PivotLayout::Compact,
+            enable_show_details: true,
+            grand_totals_rows: true,
+            grand_totals_cols: true,
+            subtotals: true,
+            subtotals_top: true,
+            style: "PivotStyleLight16".into(),
+            show_headers: true,
+            last_range: None,
+            calculated_fields: vec![],
+            values_on_rows: false,
+            values_position: None,
+        }
+    }
+}
diff --git a/crates/model/src/features/print.rs b/crates/model/src/features/print.rs
new file mode 100644
index 000000000..6a4ab0be0
--- /dev/null
+++ b/crates/model/src/features/print.rs
@@ -0,0 +1,216 @@
+use super::*;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Orientation {
+    #[default]
+    Portrait,
+    Landscape,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrintSettings {
+    pub orientation: Orientation,
+    /// Paper size name (`Letter`, `A4`, `Legal`…).
+    pub paper: String,
+    /// Margins in inches: left, right, top, bottom, header, footer.
+    pub margins: [f32; 6],
+    pub print_area: Option<RangeRef>,
+    pub title_rows: Option<(u32, u32)>,
+    pub title_cols: Option<(u32, u32)>,
+    /// Percent scale, or fit to pages (wide, tall).
+    pub scale: u16,
+    pub fit_to: Option<(u16, u16)>,
+    pub gridlines: bool,
+    pub headings: bool,
+    pub center_h: bool,
+    pub center_v: bool,
+    /// The header and footer of odd pages, and of every page unless the variants below apply.
+    pub header: String,
+    pub footer: String,
+    pub row_breaks: Vec<u32>,
+    pub col_breaks: Vec<u32>,
+    /// Different First Page: the sheet's first printed page uses `first_header`/`first_footer`.
+    #[serde(default)]
+    pub different_first: bool,
+    /// Different Odd & Even Pages: even-numbered pages use `even_header`/`even_footer`.
+    #[serde(default)]
+    pub different_odd_even: bool,
+    #[serde(default)]
+    pub first_header: String,
+    #[serde(default)]
+    pub first_footer: String,
+    #[serde(default)]
+    pub even_header: String,
+    #[serde(default)]
+    pub even_footer: String,
+    /// Scale with Document / Align with Page Margins (both on unless a file turned them off).
+    #[serde(default = "yes")]
+    pub hf_scale_with_doc: bool,
+    #[serde(default = "yes")]
+    pub hf_align_with_margins: bool,
+}
+
+fn yes() -> bool {
+    true
+}
+
+/// Which header/footer pair a printed page uses.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HfPage {
+    Odd,
+    Even,
+    First,
+}
+
+impl HfPage {
+    pub fn id(self) -> &'static str {
+        match self {
+            HfPage::Odd => "odd",
+            HfPage::Even => "even",
+            HfPage::First => "first",
+        }
+    }
+    pub fn parse(id: &str) -> Option<HfPage> {
+        match id {
+            "odd" | "all" => Some(HfPage::Odd),
+            "even" => Some(HfPage::Even),
+            "first" => Some(HfPage::First),
+            _ => None,
+        }
+    }
+}
+
+impl PrintSettings {
+    /// The pair used by page `number` (1-based, as `&P` prints it); `first` is the sheet's first page.
+    pub fn hf_page(&self, first: bool, number: usize) -> HfPage {
+        if self.different_first && first {
+            HfPage::First
+        } else if self.different_odd_even && number.is_multiple_of(2) {
+            HfPage::Even
+        } else {
+            HfPage::Odd
+        }
+    }
+    /// The header (`footer` false) or footer of a page kind.
+    pub fn hf(&self, page: HfPage, footer: bool) -> &String {
+        match (page, footer) {
+            (HfPage::Odd, false) => &self.header,
+            (HfPage::Odd, true) => &self.footer,
+            (HfPage::Even, false) => &self.even_header,
+            (HfPage::Even, true) => &self.even_footer,
+            (HfPage::First, false) => &self.first_header,
+            (HfPage::First, true) => &self.first_footer,
+        }
+    }
+    pub fn hf_mut(&mut self, page: HfPage, footer: bool) -> &mut String {
+        match (page, footer) {
+            (HfPage::Odd, false) => &mut self.header,
+            (HfPage::Odd, true) => &mut self.footer,
+            (HfPage::Even, false) => &mut self.even_header,
+            (HfPage::Even, true) => &mut self.even_footer,
+            (HfPage::First, false) => &mut self.first_header,
+            (HfPage::First, true) => &mut self.first_footer,
+        }
+    }
+    /// Any header or footer text at all (on any kind of page).
+    pub fn has_header_footer(&self) -> bool {
+        [&self.header, &self.footer, &self.first_header, &self.first_footer, &self.even_header, &self.even_footer].iter().any(|t| !t.is_empty())
+    }
+}
+
+impl Default for PrintSettings {
+    fn default() -> Self {
+        PrintSettings {
+            orientation: Orientation::Portrait,
+            paper: "Letter".into(),
+            margins: [0.7, 0.7, 0.75, 0.75, 0.3, 0.3],
+            print_area: None,
+            title_rows: None,
+            title_cols: None,
+            scale: 100,
+            fit_to: None,
+            gridlines: false,
+            headings: false,
+            center_h: false,
+            center_v: false,
+            header: String::new(),
+            footer: String::new(),
+            row_breaks: vec![],
+            col_breaks: vec![],
+            different_first: false,
+            different_odd_even: false,
+            first_header: String::new(),
+            first_footer: String::new(),
+            even_header: String::new(),
+            even_footer: String::new(),
+            hf_scale_with_doc: true,
+            hf_align_with_margins: true,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct SheetProtection {
+    /// Hash of the password (Excel-compatible, written to XLSX `sheetProtection`; never the
+    /// password itself).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<crate::PasswordHash>,
+    /// The internal hash older GridCraft JSON workbooks stored ([`password_hash`]); still
+    /// verified when unprotecting, never written for new passwords.
+    #[serde(rename = "password_hash", default, skip_serializing_if = "Option::is_none")]
+    pub legacy_password_hash: Option<u64>,
+    pub select_locked: bool,
+    pub select_unlocked: bool,
+    pub format_cells: bool,
+    pub format_columns: bool,
+    pub format_rows: bool,
+    pub insert_columns: bool,
+    pub insert_rows: bool,
+    pub delete_columns: bool,
+    pub delete_rows: bool,
+    pub sort: bool,
+    pub autofilter: bool,
+}
+
+/// Review › Allow Edit Ranges: cells that stay editable on a protected sheet, with or without a
+/// password (XLSX `<protectedRange>`).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EditRange {
+    pub title: String,
+    pub ranges: Vec<RangeRef>,
+    pub password: Option<crate::PasswordHash>,
+    /// Windows permissions (`securityDescriptor`), kept as read from the file.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub security_descriptor: Option<String>,
+}
+
+impl EditRange {
+    pub fn contains(&self, c: CellRef) -> bool {
+        self.ranges.iter().any(|r| r.contains(c))
+    }
+}
+
+/// The non-cryptographic password hash older GridCraft versions stored for sheet protection
+/// (only verified now, see [`SheetProtection::legacy_password_hash`]).
+pub fn password_hash(pw: &str) -> u64 {
+    let mut h: u64 = 0xcbf29ce484222325 ^ 0x5348_4545_5443;
+    for b in pw.bytes() {
+        h ^= b as u64;
+        h = h.wrapping_mul(0x100000001b3);
+    }
+    h
+}
+
+/// Outline grouping info for a row or column.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct LineInfo {
+    /// Size in pixels at 96 dpi; `None` = default (rows auto-fit to content).
+    pub size: Option<f32>,
+    pub hidden: bool,
+    pub outline: u8,
+    pub collapsed: bool,
+    pub style: Option<crate::style::StyleId>,
+    /// The size was set by the user (rows): automatic heights follow the content.
+    #[serde(default)]
+    pub custom: bool,
+}

From da0cb382ae94824047ccf310722d3a600c329509 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:27:03 +0000
Subject: [PATCH 67/76] refactor(gridcraft-cli): move check.rs items to check/

---
 apps/gridcraft-cli/src/check.rs          | 1024 +---------------------
 apps/gridcraft-cli/src/check/calc.rs     |  237 +++++
 apps/gridcraft-cli/src/check/fidelity.rs |  185 ++++
 apps/gridcraft-cli/src/check/package.rs  |  329 +++++++
 apps/gridcraft-cli/src/check/report.rs   |  264 ++++++
 5 files changed, 1034 insertions(+), 1005 deletions(-)
 create mode 100644 apps/gridcraft-cli/src/check/calc.rs
 create mode 100644 apps/gridcraft-cli/src/check/fidelity.rs
 create mode 100644 apps/gridcraft-cli/src/check/package.rs
 create mode 100644 apps/gridcraft-cli/src/check/report.rs

diff --git a/apps/gridcraft-cli/src/check.rs b/apps/gridcraft-cli/src/check.rs
index 318b43aad..5fc37b14c 100644
--- a/apps/gridcraft-cli/src/check.rs
+++ b/apps/gridcraft-cli/src/check.rs
@@ -26,22 +26,31 @@ use serde_json::{Value as Json, json};
 
 use super::{Args, USAGE, number_text, pretty};
 
+mod calc;
+mod fidelity;
+mod package;
+mod report;
+
+pub use calc::oracle;
+#[cfg(test)]
+use calc::volatile_names;
+#[cfg(test)]
+use calc::{bool_cached_as_number, values_match};
+#[cfg(test)]
+use fidelity::diff_workbooks;
+pub use fidelity::round_trip;
+use package::full_calc_on_load;
+#[cfg(test)]
+use package::validate_package;
+use report::print_human;
+pub use report::report_json;
+
 /// Version tag of the `--json` output; bumped when a field changes meaning or disappears.
 pub const SCHEMA: &str = "gridcraft-check/1";
-
-/// Functions whose result depends on the clock, a random generator or the environment.
-const VOLATILE: [&str; 6] = ["RAND", "RANDARRAY", "RANDBETWEEN", "NOW", "TODAY", "INFO"];
 /// Directory recursion limit (symlink loops end here).
 const MAX_DEPTH: usize = 32;
 /// Most files collected from the inputs.
 const MAX_FILES: usize = 100_000;
-/// Largest package part read while validating a written package.
-const MAX_XML_PART: u64 = 64 * 1024 * 1024;
-/// Most zip entries looked at while validating a written package.
-const MAX_ENTRIES: usize = 200_000;
-/// Relationship kinds (lower case) whose absence after a save isn't a loss: the calculation chain is
-/// a cache Excel rebuilds, and GridCraft never writes it.
-const REBUILT_KINDS: [&str; 1] = ["calcchain"];
 
 #[derive(Clone, Copy, Debug)]
 pub struct Options {
@@ -357,1000 +366,5 @@ fn check_inner(path: &str, bytes: &[u8], opts: &Options) -> FileReport {
     report
 }
 
-// ---------------------------------------------------------------- calc oracle
-
-fn functions_of(e: &Expr) -> Vec<String> {
-    let mut set = BTreeSet::new();
-    e.walk(&mut |x| {
-        if let Expr::Call(n, _) = x {
-            set.insert(n.clone());
-        }
-    });
-    set.into_iter().collect()
-}
-
-fn is_volatile(e: &Expr, volatile_names: &HashSet<String>) -> bool {
-    let mut v = false;
-    e.walk(&mut |x| match x {
-        Expr::Call(n, args) => {
-            let filename = n == "CELL" && matches!(args.first(), Some(Expr::Text(t)) if t.eq_ignore_ascii_case("filename"));
-            if filename || VOLATILE.contains(&n.as_str()) {
-                v = true;
-            }
-        }
-        Expr::Name(n) if volatile_names.contains(&n.to_ascii_uppercase()) => v = true,
-        _ => {}
-    });
-    v
-}
-
-/// Upper-cased defined names whose formula is volatile, directly or through other names.
-fn volatile_names(wb: &Workbook) -> HashSet<String> {
-    let parsed: Vec<(String, Option<Expr>)> =
-        wb.names.iter().map(|n| (n.name.to_ascii_uppercase(), gridcraft_engine::formula::parse(&n.formula).ok())).collect();
-    let mut set = HashSet::new();
-    // Each round adds at least one name or stops, so `len + 1` rounds reach the fixed point.
-    for _ in 0..=parsed.len() {
-        let before = set.len();
-        for (name, e) in &parsed {
-            if !set.contains(name) && e.as_ref().is_some_and(|e| is_volatile(e, &set)) {
-                set.insert(name.clone());
-            }
-        }
-        if set.len() == before {
-            break;
-        }
-    }
-    set
-}
-
-/// The formula as the formula bar shows it.
-fn formula_text(cell: &Cell) -> String {
-    cell.bar_text()
-}
-
-fn cell_name(wb: &Workbook, (sheet, c): Key) -> String {
-    let name = wb.sheet(sheet).map(|s| s.name.as_str()).unwrap_or("?");
-    format!("{}!{}", quote_sheet(name), c.a1())
-}
-
-/// Whether the producer cached GridCraft's logical result as the number 1 or 0. Excel types a
-/// logical result `t="b"`; a writer that leaves the type out (`<c><f>TRUE()</f><v>1</v></c>`, as
-/// Business Central's "Open in Excel" exports do) stores the same value, read back as a number.
-pub fn bool_cached_as_number(expected: &Value, actual: &Value) -> bool {
-    matches!((expected, actual), (Value::Number(n), Value::Bool(b)) if *n == if *b { 1.0 } else { 0.0 })
-}
-
-/// Whether GridCraft's `actual` agrees with the producer's `expected`.
-pub fn values_match(expected: &Value, actual: &Value, tolerance: f64) -> bool {
-    match (expected, actual) {
-        (Value::Number(a), Value::Number(b)) => (a - b).abs() <= tolerance * a.abs().max(b.abs()).max(1.0),
-        (Value::Text(a), Value::Text(b)) => a == b,
-        (Value::Bool(a), Value::Bool(b)) => a == b,
-        (Value::Error(a), Value::Error(b)) => a == b,
-        _ => false,
-    }
-}
-
-fn type_name(v: &Value) -> &'static str {
-    match v {
-        Value::Empty => "blank",
-        Value::Number(_) => "number",
-        Value::Text(_) => "text",
-        Value::Bool(_) => "bool",
-        Value::Error(e) => e.as_str(),
-        Value::Array(_) => "array",
-    }
-}
-
-fn mismatch_kind(expected: &Value, actual: &Value) -> &'static str {
-    match (expected, actual) {
-        (_, Value::Empty) => "blank",
-        (Value::Number(_), Value::Number(_)) => "numeric",
-        (Value::Text(_), Value::Text(_)) => "text",
-        (Value::Bool(_), Value::Bool(_)) => "bool",
-        (Value::Error(_), _) | (_, Value::Error(_)) => "error",
-        _ => "type",
-    }
-}
-
-/// Mismatched cells indexed by (sheet, column) → rows, for precedent-area queries.
-struct MismatchIndex {
-    cols: HashMap<(usize, u32), BTreeSet<u32>>,
-    /// Columns with mismatches per sheet (for very wide areas).
-    sheet_cols: HashMap<usize, BTreeSet<u32>>,
-}
-
-impl MismatchIndex {
-    fn new(keys: &[Key]) -> MismatchIndex {
-        let mut cols: HashMap<(usize, u32), BTreeSet<u32>> = HashMap::new();
-        let mut sheet_cols: HashMap<usize, BTreeSet<u32>> = HashMap::new();
-        for &(s, c) in keys {
-            cols.entry((s, c.col)).or_default().insert(c.row);
-            sheet_cols.entry(s).or_default().insert(c.col);
-        }
-        MismatchIndex { cols, sheet_cols }
-    }
-    /// Whether a mismatched cell other than `own` lies in the area.
-    fn any_in(&self, sheet: usize, r0: u32, r1: u32, c0: u32, c1: u32, own: Key) -> bool {
-        let Some(cols) = self.sheet_cols.get(&sheet) else { return false };
-        cols.range(c0..=c1)
-            .any(|&col| self.cols.get(&(sheet, col)).is_some_and(|rows| rows.range(r0..=r1).any(|&row| (sheet, CellRef::new(row, col)) != own)))
-    }
-}
-
-/// Compares every formula cell of `cached` (as the producer saved it) with `fresh` (recalculated
-/// by GridCraft). Without `trust_cache` nothing is compared (see [`CalcReport::stale_cache`]).
-pub fn oracle(cached: &Workbook, fresh: &Workbook, calc: &Calc, trust_cache: bool, opts: &Options) -> CalcReport {
-    let mut r = CalcReport { stale_cache: !trust_cache, ..Default::default() };
-    let vnames = volatile_names(cached);
-    let mut volatile: HashSet<Key> = HashSet::new();
-    for (si, sh) in cached.sheets.iter().enumerate() {
-        for (c, cell) in sh.cells.iter() {
-            if let Some(f) = &cell.formula {
-                r.formula_cells += 1;
-                if f.expr_arc().is_some_and(|e| is_volatile(&e, &vnames)) {
-                    volatile.insert((si, c));
-                }
-            }
-        }
-    }
-    // Everything downstream of a volatile formula is volatile too; each key is pushed once.
-    let mut stack: Vec<Key> = volatile.iter().copied().collect();
-    let mut deps = Vec::new();
-    while let Some((s, c)) = stack.pop() {
-        deps.clear();
-        calc.graph.dependents(s, c, &mut deps);
-        if let Some(range) = fresh.sheet(s).and_then(|sh| sh.spill_ranges.get(&c)) {
-            calc.graph.dependents_of_range(s, *range, &mut deps);
-        }
-        for k in deps.drain(..) {
-            if volatile.insert(k) {
-                stack.push(k);
-            }
-        }
-    }
-
-    let mut bad: Vec<(Key, Vec<String>)> = Vec::new();
-    for (si, sh) in cached.sheets.iter().enumerate() {
-        for (c, cell) in sh.cells.iter() {
-            let Some(f) = &cell.formula else { continue };
-            if volatile.contains(&(si, c)) {
-                r.volatile += 1;
-                continue;
-            }
-            if cell.value.is_empty() || !trust_cache {
-                r.no_oracle += 1;
-                continue;
-            }
-            r.checked += 1;
-            let actual = fresh.sheet(si).and_then(|s| s.cell(c)).map(|x| x.value.scalar()).unwrap_or_default();
-            let funcs = match f.expr_arc() {
-                Some(e) => {
-                    let names = functions_of(&e);
-                    if names.is_empty() { vec!["(no function)".to_string()] } else { names }
-                }
-                None => vec!["(unparsed)".to_string()],
-            };
-            let bool_as_number = bool_cached_as_number(&cell.value, &actual);
-            let ok = bool_as_number || values_match(&cell.value, &actual, opts.tolerance);
-            if bool_as_number {
-                r.bool_as_number += 1;
-            }
-            for n in &funcs {
-                let st = r.functions.entry(n.clone()).or_default();
-                st.checked += 1;
-                if !ok {
-                    st.mismatched += 1;
-                }
-            }
-            if ok {
-                r.matched += 1;
-            } else {
-                r.mismatched += 1;
-                *r.signatures.entry(format!("{} → {}", type_name(&cell.value), type_name(&actual))).or_default() += 1;
-                bad.push(((si, c), funcs));
-            }
-        }
-    }
-
-    // A mismatch is primary when none of its precedent cells mismatch.
-    let keys: Vec<Key> = bad.iter().map(|(k, _)| *k).collect();
-    let index = MismatchIndex::new(&keys);
-    let mut listed: Vec<(bool, Key, Vec<String>)> = Vec::with_capacity(bad.len());
-    for (k, funcs) in bad {
-        let upstream = calc
-            .graph
-            .precedents_of(k)
-            .iter()
-            .any(|a| index.any_in(a.sheet, a.range.start.row, a.range.end.row, a.range.start.col, a.range.end.col, k));
-        if !upstream {
-            for n in &funcs {
-                r.functions.entry(n.clone()).or_default().primary += 1;
-            }
-        }
-        listed.push((!upstream, k, funcs));
-    }
-    // Primary mismatches first, each group in sheet then row-major order (already sorted).
-    listed.sort_by_key(|(primary, _, _)| !*primary);
-    for (primary, k, functions) in listed.into_iter().take(opts.max_report) {
-        let cell = cached.sheet(k.0).and_then(|s| s.cell(k.1));
-        let expected = cell.map(|c| c.value.clone()).unwrap_or_default();
-        let actual = fresh.sheet(k.0).and_then(|s| s.cell(k.1)).map(|x| x.value.scalar()).unwrap_or_default();
-        r.mismatches.push(Mismatch {
-            cell: cell_name(cached, k),
-            formula: cell.map(formula_text).unwrap_or_default(),
-            kind: mismatch_kind(&expected, &actual),
-            expected,
-            actual,
-            functions,
-            primary,
-        });
-    }
-    r
-}
-
-// ---------------------------------------------------------------- round trip
-
-/// Writes `wb` with GridCraft's XLSX writer, validates the package against itself and against
-/// `source` (the file `wb` was read from), reads it back and compares.
-pub fn round_trip(wb: &Workbook, source: &[u8], opts: &Options) -> RoundTrip {
-    let bytes = match gridcraft_engine::io::save_bytes(wb, "roundtrip.xlsx") {
-        Ok(b) => b,
-        Err(e) => return RoundTrip { error: Some(format!("write failed: {e}")), categories: vec![] },
-    };
-    let mut package = Diffs::new("package", opts.max_report);
-    match validate_package(&bytes) {
-        Ok(issues) => issues.into_iter().for_each(|i| package.push(|| i)),
-        Err(e) => package.push(|| e),
-    }
-    if let (Ok(before), Ok(after)) = (relationship_kinds(source), relationship_kinds(&bytes)) {
-        for (key, kind) in &before {
-            if !after.contains_key(key) && !REBUILT_KINDS.contains(&key.as_str()) {
-                package.push(|| format!("lost relationship {kind}"));
-            }
-        }
-    }
-    let back = match gridcraft_engine::io::open_bytes("roundtrip.xlsx", &bytes) {
-        Ok((b, _)) => b,
-        Err(e) => return RoundTrip { error: Some(format!("reading the written file failed: {e}")), categories: vec![package.done()] },
-    };
-    let mut categories = diff_workbooks(wb, &back, opts);
-    categories.push(package.done());
-    RoundTrip { error: None, categories }
-}
-
-fn value_show(v: &Value) -> String {
-    match v {
-        Value::Empty => "(blank)".to_string(),
-        Value::Text(t) => serde_json::to_string(t.as_ref()).unwrap_or_default(),
-        Value::Number(n) => number_text(*n),
-        Value::Bool(b) => if *b { "TRUE" } else { "FALSE" }.to_string(),
-        Value::Error(e) => e.as_str().to_string(),
-        Value::Array(_) => v.scalar().display(),
-    }
-}
-
-fn opt_formula(c: Option<&Cell>) -> String {
-    c.filter(|c| c.formula.is_some()).map(formula_text).unwrap_or_default()
-}
-
-/// Per-sheet comparison of two lists, reporting what one side has and the other lacks.
-fn diff_sets(d: &mut Diffs, sheet: &str, a: &BTreeSet<String>, b: &BTreeSet<String>) {
-    for x in a.difference(b) {
-        d.push(|| format!("{sheet}: lost {x}"));
-    }
-    for x in b.difference(a) {
-        d.push(|| format!("{sheet}: gained {x}"));
-    }
-}
-
-/// A sheet's conditional-format rules in precedence order, as comparable text. The priority number
-/// itself is left out, so renumbering without changing the order isn't a difference.
-fn cond_format_list(s: &Sheet) -> Vec<String> {
-    let mut cfs: Vec<_> = s.cond_formats.iter().collect();
-    cfs.sort_by_key(|c| c.priority);
-    cfs.iter().map(|c| format!("{:?} {:?} stopIfTrue={}", c.ranges, c.rule, c.stop_if_true)).collect()
-}
-
-fn diff_count(d: &mut Diffs, sheet: &str, a: usize, b: usize) {
-    if a != b {
-        d.push(|| format!("{sheet}: {a} → {b}"));
-    }
-}
-
-/// A value as the file format can hold it: `#SPILL!`/`#CALC!` are cached as `#VALUE!` and an
-/// unresolved circular reference as 0 (what Excel writes), so those aren't round-trip losses.
-fn as_cached(v: Value) -> Value {
-    match v {
-        Value::Error(CellError::Spill | CellError::Calc) => Value::Error(CellError::Value),
-        Value::Error(CellError::Circ) => Value::Number(0.0),
-        v => v,
-    }
-}
-
-fn num_fmt<'a>(wb: &'a Workbook, c: Option<&Cell>) -> &'a str {
-    wb.styles.get(c.map(|c| c.style).unwrap_or_default()).num_fmt.as_str()
-}
-
-/// Feature-by-feature comparison of a workbook (`a`) with what reading it back gave (`b`). Sheets
-/// are paired by position.
-pub fn diff_workbooks(a: &Workbook, b: &Workbook, opts: &Options) -> Vec<Category> {
-    let m = opts.max_report;
-    let mut sheets = Diffs::new("sheets", m);
-    let (an, bn): (Vec<&str>, Vec<&str>) = (a.sheets.iter().map(|s| s.name.as_str()).collect(), b.sheets.iter().map(|s| s.name.as_str()).collect());
-    if an != bn {
-        sheets.push(|| format!("{an:?} → {bn:?}"));
-    }
-    let mut values = Diffs::new("values", m);
-    let mut formulas = Diffs::new("formulas", m);
-    let mut num_fmts = Diffs::new("numFmts", m);
-    let mut merges = Diffs::new("merges", m);
-    let mut tables = Diffs::new("tables", m);
-    let mut cond_formats = Diffs::new("condFormats", m);
-    let mut validations = Diffs::new("validations", m);
-    let mut charts = Diffs::new("charts", m);
-    let mut comments = Diffs::new("comments", m);
-    let mut hyperlinks = Diffs::new("hyperlinks", m);
-    let mut pivots = Diffs::new("pivots", m);
-    for (sa, sb) in a.sheets.iter().zip(b.sheets.iter()) {
-        let name = quote_sheet(&sa.name);
-        let mut cell = |c: CellRef, ca: Option<&Cell>, cb: Option<&Cell>| {
-            let cached = |x: Option<&Cell>| as_cached(x.map(|x| x.value.scalar()).unwrap_or_default());
-            let (va, vb) = (cached(ca), cached(cb));
-            if va != vb {
-                values.push(|| format!("{name}!{}: {} → {}", c.a1(), value_show(&va), value_show(&vb)));
-            }
-            let (fa, fb) = (opt_formula(ca), opt_formula(cb));
-            if fa != fb {
-                formulas.push(|| format!("{name}!{}: {fa} → {fb}", c.a1()));
-            }
-            let (na, nb) = (num_fmt(a, ca), num_fmt(b, cb));
-            if na != nb {
-                num_fmts.push(|| format!("{name}!{}: {na} → {nb}", c.a1()));
-            }
-        };
-        for (c, ca) in sa.cells.iter() {
-            cell(c, Some(ca), sb.cell(c));
-        }
-        for (c, cb) in sb.cells.iter() {
-            if sa.cell(c).is_none() {
-                cell(c, None, Some(cb));
-            }
-        }
-        let set = |f: &dyn Fn(&Sheet) -> Vec<String>, s: &Sheet| f(s).into_iter().collect::<BTreeSet<String>>();
-        let merge_list = |s: &Sheet| -> Vec<String> { s.merges.iter().map(|r| r.a1()).collect() };
-        diff_sets(&mut merges, &name, &set(&merge_list, sa), &set(&merge_list, sb));
-        let table_list = |s: &Sheet| -> Vec<String> {
-            s.tables
-                .iter()
-                .map(|t| format!("{} {} [{}]", t.name, t.range.a1(), t.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>().join(", ")))
-                .collect()
-        };
-        diff_sets(&mut tables, &name, &set(&table_list, sa), &set(&table_list, sb));
-        let (cfa, cfb) = (cond_format_list(sa), cond_format_list(sb));
-        if cfa.len() != cfb.len() {
-            cond_formats.push(|| format!("{name}: {} → {}", cfa.len(), cfb.len()));
-        } else if let Some((x, y)) = cfa.iter().zip(&cfb).find(|(x, y)| x != y) {
-            cond_formats.push(|| format!("{name}: {x} → {y}"));
-        }
-        diff_count(&mut validations, &name, sa.validations.len(), sb.validations.len());
-        let chart_list = |s: &Sheet| s.charts.iter().map(|c| format!("{:?} ({} series)", c.kind, c.series.len())).collect::<Vec<_>>();
-        let (ca, cb) = (chart_list(sa), chart_list(sb));
-        if ca != cb {
-            charts.push(|| format!("{name}: {ca:?} → {cb:?}"));
-        }
-        diff_count(&mut comments, &name, sa.comments.len(), sb.comments.len());
-        diff_count(&mut hyperlinks, &name, sa.hyperlinks.len(), sb.hyperlinks.len());
-        diff_count(&mut pivots, &name, sa.pivots.len(), sb.pivots.len());
-    }
-    let mut names = Diffs::new("names", m);
-    let name_list = |wb: &Workbook| -> BTreeSet<String> {
-        wb.names
-            .iter()
-            .map(|n| {
-                let scope = n.scope.map(|i| format!("{}!", quote_sheet(wb.sheet(i).map(|s| s.name.as_str()).unwrap_or("?")))).unwrap_or_default();
-                format!("{scope}{}={}", n.name, n.formula)
-            })
-            .collect()
-    };
-    diff_sets(&mut names, "workbook", &name_list(a), &name_list(b));
-    vec![
-        sheets.done(),
-        values.done(),
-        formulas.done(),
-        num_fmts.done(),
-        merges.done(),
-        names.done(),
-        tables.done(),
-        cond_formats.done(),
-        validations.done(),
-        charts.done(),
-        comments.done(),
-        hyperlinks.done(),
-        pivots.done(),
-    ]
-}
-
-// ---------------------------------------------------------------- package validation
-
-fn local_name(name: &[u8]) -> &[u8] {
-    match name.iter().rposition(|&b| b == b':') {
-        Some(i) => name.get(i + 1..).unwrap_or(name),
-        None => name,
-    }
-}
-
-/// `(element local name, attributes)` for every start/empty element of an XML part.
-fn xml_elements(xml: &[u8]) -> Result<Vec<(String, Vec<(String, String)>)>, String> {
-    use quick_xml::events::Event;
-    let mut reader = quick_xml::Reader::from_reader(xml);
-    let mut buf = Vec::new();
-    let mut out = Vec::new();
-    loop {
-        match reader.read_event_into(&mut buf) {
-            Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
-                let attrs = e
-                    .attributes()
-                    .with_checks(false)
-                    .flatten()
-                    .map(|a| {
-                        let v = match a.normalized_value(quick_xml::XmlVersion::Explicit1_0) {
-                            Ok(v) => v.into_owned(),
-                            Err(_) => String::from_utf8_lossy(&a.value).into_owned(),
-                        };
-                        (String::from_utf8_lossy(local_name(a.key.as_ref())).into_owned(), v)
-                    })
-                    .collect();
-                out.push((String::from_utf8_lossy(local_name(e.name().as_ref())).into_owned(), attrs));
-            }
-            Ok(Event::Eof) => break,
-            Ok(_) => {}
-            Err(e) => return Err(format!("invalid XML: {e}")),
-        }
-        buf.clear();
-    }
-    Ok(out)
-}
-
-fn attr<'a>(attrs: &'a [(String, String)], k: &str) -> Option<&'a str> {
-    attrs.iter().find(|(n, _)| n == k).map(|(_, v)| v.as_str())
-}
-
-/// Lower-cased part name without a leading slash: OPC part names compare case-insensitively.
-fn part_key(name: &str) -> String {
-    name.trim_start_matches('/').to_ascii_lowercase()
-}
-
-/// `%XX` escapes in a relationship target.
-fn percent_decode(s: &str) -> String {
-    let b = s.as_bytes();
-    let mut out = Vec::with_capacity(b.len());
-    let mut i = 0;
-    while let Some(&c) = b.get(i) {
-        let hex = |j: usize| b.get(j).and_then(|h| (*h as char).to_digit(16));
-        match (c, hex(i + 1), hex(i + 2)) {
-            (b'%', Some(h), Some(l)) => {
-                out.push((h * 16 + l) as u8);
-                i += 3;
-            }
-            _ => {
-                out.push(c);
-                i += 1;
-            }
-        }
-    }
-    String::from_utf8_lossy(&out).into_owned()
-}
-
-/// Resolves a relationship target against the source part's directory.
-fn resolve_target(source_dir: &str, target: &str) -> String {
-    let target = percent_decode(target.split('#').next().unwrap_or(target));
-    let joined = match target.strip_prefix('/') {
-        Some(abs) => abs.to_string(),
-        None if source_dir.is_empty() => target,
-        None => format!("{source_dir}/{target}"),
-    };
-    let mut parts: Vec<&str> = Vec::new();
-    for seg in joined.split('/') {
-        match seg {
-            "" | "." => {}
-            ".." => {
-                parts.pop();
-            }
-            s => parts.push(s),
-        }
-    }
-    parts.join("/")
-}
-
-type Zip<'a> = zip::ZipArchive<Cursor<&'a [u8]>>;
-
-fn zip_names(zip: &mut Zip<'_>) -> Vec<String> {
-    (0..zip.len().min(MAX_ENTRIES)).filter_map(|i| zip.by_index_raw(i).ok().filter(|f| !f.is_dir()).map(|f| f.name().to_string())).collect()
-}
-
-fn read_zip_part(zip: &mut Zip<'_>, name: &str) -> Result<Vec<u8>, String> {
-    let f = zip.by_name(name).map_err(|e| format!("{name}: {e}"))?;
-    let mut buf = Vec::new();
-    f.take(MAX_XML_PART).read_to_end(&mut buf).map_err(|e| format!("{name}: {e}"))?;
-    Ok(buf)
-}
-
-/// Whether the producer flagged its cached results as stale with `<calcPr fullCalcOnLoad="1">`:
-/// libraries that don't calculate write it, and store 0 or nothing as every formula's value.
-fn full_calc_on_load(bytes: &[u8]) -> bool {
-    let Ok(mut zip) = zip::ZipArchive::new(Cursor::new(bytes)) else { return false };
-    let names = zip_names(&mut zip);
-    let find = |key: &str| names.iter().find(|n| part_key(n) == key).cloned();
-    let mut workbook = "xl/workbook.xml".to_string();
-    if let Some(rels) = find("_rels/.rels")
-        && let Ok(xml) = read_zip_part(&mut zip, &rels)
-        && let Ok(els) = xml_elements(&xml)
-        && let Some(target) = els
-            .iter()
-            .find(|(e, a)| e == "Relationship" && attr(a, "Type").is_some_and(|t| t.ends_with("/officeDocument")))
-            .and_then(|(_, a)| attr(a, "Target"))
-    {
-        workbook = resolve_target("", target);
-    }
-    let Some(name) = find(&part_key(&workbook)) else { return false };
-    let Ok(xml) = read_zip_part(&mut zip, &name) else { return false };
-    xml_elements(&xml)
-        .ok()
-        .into_iter()
-        .flatten()
-        .any(|(e, a)| e == "calcPr" && attr(&a, "fullCalcOnLoad").is_some_and(|v| v == "1" || v.eq_ignore_ascii_case("true")))
-}
-
-/// Problems Excel would repair in a written package: parts without a content type, content-type
-/// overrides for missing parts, relationship files for missing parts, duplicate relationship ids
-/// and internal relationships pointing at missing parts. `Err` when the package can't be read.
-pub fn validate_package(bytes: &[u8]) -> Result<Vec<String>, String> {
-    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| format!("not a zip package: {e}"))?;
-    let names = zip_names(&mut zip);
-    let parts: HashSet<String> = names.iter().map(|n| part_key(n)).collect();
-    let mut read_part = |name: &str| read_zip_part(&mut zip, name);
-    let mut issues = Vec::new();
-    let ct_name = names.iter().find(|n| part_key(n) == "[content_types].xml").cloned();
-    let (mut defaults, mut overrides) = (HashSet::new(), HashSet::new());
-    match ct_name {
-        None => issues.push("no [Content_Types].xml".to_string()),
-        Some(n) => {
-            for (el, attrs) in xml_elements(&read_part(&n)?).map_err(|e| format!("[Content_Types].xml: {e}"))? {
-                match el.as_str() {
-                    "Default" => {
-                        if let Some(x) = attr(&attrs, "Extension") {
-                            defaults.insert(x.to_ascii_lowercase());
-                        }
-                    }
-                    "Override" => {
-                        if let Some(p) = attr(&attrs, "PartName") {
-                            overrides.insert(part_key(p));
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-    let mut sorted: Vec<&String> = names.iter().collect();
-    sorted.sort();
-    for n in &sorted {
-        let key = part_key(n);
-        if key == "[content_types].xml" {
-            continue;
-        }
-        let ext = key.rsplit('/').next().and_then(|f| f.rsplit_once('.')).map(|(_, e)| e.to_string());
-        if !overrides.contains(&key) && !ext.is_some_and(|e| defaults.contains(&e)) {
-            issues.push(format!("part {n} has no content type"));
-        }
-    }
-    let mut missing_overrides: Vec<&String> = overrides.iter().filter(|p| !parts.contains(*p)).collect();
-    missing_overrides.sort();
-    for p in missing_overrides {
-        issues.push(format!("content type override for missing part /{p}"));
-    }
-    for n in sorted {
-        let key = part_key(n);
-        let Some(rels_file) = key.strip_suffix(".rels") else { continue };
-        // `dir/_rels/name.rels` describes `dir/name`; `_rels/.rels` the package itself.
-        let (dir, file) = match rels_file.rsplit_once('/') {
-            Some((d, f)) => (d, f),
-            None => continue,
-        };
-        let Some(src_dir) = dir.strip_suffix("_rels").map(|d| d.trim_end_matches('/')) else { continue };
-        let source = if src_dir.is_empty() { file.to_string() } else { format!("{src_dir}/{file}") };
-        if !source.is_empty() && !parts.contains(&source) {
-            issues.push(format!("{n} describes missing part {source}"));
-        }
-        let mut ids = HashSet::new();
-        for (el, attrs) in xml_elements(&read_part(n)?).map_err(|e| format!("{n}: {e}"))? {
-            if el != "Relationship" {
-                continue;
-            }
-            let id = attr(&attrs, "Id").unwrap_or("");
-            if !ids.insert(id.to_string()) {
-                issues.push(format!("{n}: duplicate relationship id {id}"));
-            }
-            if attr(&attrs, "TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External")) {
-                continue;
-            }
-            let target = attr(&attrs, "Target").unwrap_or("");
-            let resolved = resolve_target(src_dir, target);
-            if !parts.contains(&resolved.to_ascii_lowercase()) {
-                let kind = attr(&attrs, "Type").and_then(|t| t.rsplit('/').next()).unwrap_or("?");
-                issues.push(format!("{n}: {id} ({kind}) targets missing part {resolved}"));
-            }
-        }
-    }
-    Ok(issues)
-}
-
-/// Every relationship kind (last segment of the type, the same in the transitional and strict
-/// namespaces) in the package's relationship parts, keyed in lower case. Relationships that carry
-/// nothing are left out, as a save may rightly drop them: a link to a place in the workbook
-/// (`#Sheet1!A1`, written as a cell's `location`) and a target part with nothing in it.
-fn relationship_kinds(bytes: &[u8]) -> Result<BTreeMap<String, String>, String> {
-    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| format!("not a zip package: {e}"))?;
-    let names = zip_names(&mut zip);
-    let by_key: HashMap<String, &String> = names.iter().map(|n| (part_key(n), n)).collect();
-    // Several relationships name the same part; each fresh check decompressed it again, so
-    // repeated references to one highly compressible part multiplied the work. The verdict is
-    // remembered per (part, named content) and the decompression the package can cause is
-    // budgeted as a whole (finding: repeated decompression).
-    let mut verdicts: HashMap<(String, &'static str), bool> = HashMap::new();
-    let mut budget: u64 = 512 * 1024 * 1024;
-    let mut kinds = BTreeMap::new();
-    for n in names.iter().filter(|n| part_key(n).ends_with(".rels")) {
-        let Some(src_dir) = rels_source_dir(&part_key(n)) else { continue };
-        let Ok(els) = read_zip_part(&mut zip, n).and_then(|xml| xml_elements(&xml)) else { continue };
-        for (_, attrs) in els.iter().filter(|(el, _)| el == "Relationship") {
-            let Some(kind) = attr(attrs, "Type").and_then(|t| t.rsplit('/').next()) else { continue };
-            let target = attr(attrs, "Target").unwrap_or("");
-            if kind.eq_ignore_ascii_case("hyperlink") && target.starts_with('#') {
-                continue;
-            }
-            let external = attr(attrs, "TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External"));
-            if !external
-                && let Some(part) = by_key.get(&resolve_target(&src_dir, target).to_ascii_lowercase())
-                && !holds_something(&mut zip, part, kind, &mut verdicts, &mut budget)
-            {
-                continue;
-            }
-            kinds.entry(kind.to_ascii_lowercase()).or_insert_with(|| kind.to_string());
-        }
-    }
-    Ok(kinds)
-}
-
-/// The directory of the part a rels part describes: `xl` for `xl/_rels/workbook.xml.rels`, the
-/// empty string for the package's `_rels/.rels`.
-fn rels_source_dir(key: &str) -> Option<String> {
-    let (dir, _) = key.strip_suffix(".rels")?.rsplit_once('/')?;
-    Some(dir.strip_suffix("_rels")?.trim_end_matches('/').to_string())
-}
-
-/// Whether a part has content: an element under its root, or for comments (whose authors list
-/// comes first) a comment, for VML a shape. Read only as far as needed; an unreadable part counts.
-/// `verdicts` remembers the answer per (part, named content); `budget` is the decompression this
-/// package's remaining checks may cause, and once it is spent the part counts as having content.
-fn holds_something(zip: &mut Zip<'_>, name: &str, kind: &str, verdicts: &mut HashMap<(String, &'static str), bool>, budget: &mut u64) -> bool {
-    let wanted: Option<&'static [u8]> = match kind.to_ascii_lowercase().as_str() {
-        "comments" => Some(b"comment"),
-        "vmldrawing" => Some(b"shape"),
-        _ => None,
-    };
-    let marker = match wanted {
-        Some(b"comment") => "comment",
-        Some(_) => "shape",
-        None => "any",
-    };
-    if let Some(v) = verdicts.get(&(name.to_ascii_lowercase(), marker)) {
-        return *v;
-    }
-    let v = holds_something_uncached(zip, name, marker, budget);
-    verdicts.insert((name.to_ascii_lowercase(), marker), v);
-    v
-}
-
-fn holds_something_uncached(zip: &mut Zip<'_>, name: &str, marker: &'static str, budget: &mut u64) -> bool {
-    use quick_xml::events::Event;
-    let Ok(f) = zip.by_name(name) else { return true };
-    if *budget == 0 {
-        return true;
-    }
-    let take = f.size().min(MAX_XML_PART).min(*budget);
-    *budget -= take;
-    let mut reader = quick_xml::Reader::from_reader(std::io::BufReader::new(f.take(take)));
-    let wanted: Option<&'static [u8]> = match marker {
-        "comment" => Some(b"comment"),
-        "shape" => Some(b"shape"),
-        _ => None,
-    };
-    let mut buf = Vec::new();
-    let mut in_root = false;
-    loop {
-        match reader.read_event_into(&mut buf) {
-            Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
-                let found = match wanted {
-                    Some(w) => local_name(e.name().as_ref()) == w,
-                    None => in_root,
-                };
-                if found {
-                    return true;
-                }
-                in_root = true;
-            }
-            Ok(Event::Eof) => return false,
-            Ok(_) => {}
-            Err(_) => return true,
-        }
-        buf.clear();
-    }
-}
-
-// ---------------------------------------------------------------- output
-
-#[derive(Default)]
-struct Totals {
-    files: usize,
-    opened: usize,
-    failed: usize,
-    formula_cells: usize,
-    checked: usize,
-    matched: usize,
-    mismatched: usize,
-    no_oracle: usize,
-    volatile: usize,
-    bool_as_number: usize,
-    round_trip_failed: usize,
-    round_trip_differing: usize,
-    categories: BTreeMap<&'static str, usize>,
-    functions: BTreeMap<String, FnStat>,
-    signatures: BTreeMap<String, usize>,
-}
-
-fn totals(reports: &[FileReport]) -> Totals {
-    let mut t = Totals { files: reports.len(), ..Default::default() };
-    for r in reports {
-        if r.error.is_some() {
-            t.failed += 1;
-            continue;
-        }
-        t.opened += 1;
-        t.formula_cells += r.calc.formula_cells;
-        t.checked += r.calc.checked;
-        t.matched += r.calc.matched;
-        t.mismatched += r.calc.mismatched;
-        t.no_oracle += r.calc.no_oracle;
-        t.volatile += r.calc.volatile;
-        t.bool_as_number += r.calc.bool_as_number;
-        if r.round_trip.error.is_some() {
-            t.round_trip_failed += 1;
-        }
-        if !r.round_trip.is_clean() {
-            t.round_trip_differing += 1;
-        }
-        for c in r.round_trip.differing() {
-            *t.categories.entry(c).or_default() += 1;
-        }
-        for (n, s) in &r.calc.functions {
-            t.functions.entry(n.clone()).or_default().add(s);
-        }
-        for (sig, n) in &r.calc.signatures {
-            *t.signatures.entry(sig.clone()).or_default() += n;
-        }
-    }
-    t
-}
-
-/// Functions with mismatches, worst first: most primary mismatches, then most mismatches.
-fn ranked(functions: &BTreeMap<String, FnStat>) -> Vec<(&String, &FnStat)> {
-    let mut v: Vec<(&String, &FnStat)> = functions.iter().filter(|(_, s)| s.mismatched > 0).collect();
-    v.sort_by(|a, b| b.1.primary.cmp(&a.1.primary).then(b.1.mismatched.cmp(&a.1.mismatched)).then(a.0.cmp(b.0)));
-    v
-}
-
-fn functions_json(functions: &BTreeMap<String, FnStat>) -> Json {
-    let mut v: Vec<(&String, &FnStat)> = functions.iter().collect();
-    v.sort_by(|a, b| b.1.primary.cmp(&a.1.primary).then(b.1.mismatched.cmp(&a.1.mismatched)).then(a.0.cmp(b.0)));
-    Json::Array(v.into_iter().map(|(n, s)| json!({"name": n, "checked": s.checked, "mismatched": s.mismatched, "primary": s.primary})).collect())
-}
-
-pub fn report_json(reports: &[FileReport], opts: &Options) -> Json {
-    let files: Vec<Json> = reports
-        .iter()
-        .map(|r| {
-            let c = &r.calc;
-            let mismatches: Vec<Json> = c
-                .mismatches
-                .iter()
-                .map(|m| {
-                    json!({
-                        "cell": m.cell, "formula": m.formula, "expected": value_json(&m.expected), "actual": value_json(&m.actual),
-                        "kind": m.kind, "functions": m.functions, "primary": m.primary,
-                    })
-                })
-                .collect();
-            let categories: serde_json::Map<String, Json> = r
-                .round_trip
-                .categories
-                .iter()
-                .map(|cat| (cat.name.to_string(), json!({"equal": cat.diffs == 0, "diffs": cat.diffs, "examples": cat.examples})))
-                .collect();
-            json!({
-                "path": r.path,
-                "opened": r.error.is_none(),
-                "error": r.error,
-                "warnings": r.warnings,
-                "calc": {
-                    "formulaCells": c.formula_cells, "checked": c.checked, "matched": c.matched, "mismatched": c.mismatched,
-                    "noOracle": c.no_oracle, "staleCache": c.stale_cache, "volatile": c.volatile, "boolAsNumber": c.bool_as_number,
-                    "mismatches": mismatches, "functions": functions_json(&c.functions),
-                    "signatures": c.signatures,
-                },
-                "roundTrip": {"error": r.round_trip.error, "differing": r.round_trip.differing(), "categories": categories},
-            })
-        })
-        .collect();
-    let t = totals(reports);
-    json!({
-        "schema": SCHEMA,
-        "tolerance": opts.tolerance,
-        "files": files,
-        "totals": {
-            "files": t.files, "opened": t.opened, "failedToOpen": t.failed, "formulaCells": t.formula_cells, "checked": t.checked,
-            "matched": t.matched, "mismatched": t.mismatched, "noOracle": t.no_oracle, "volatile": t.volatile, "boolAsNumber": t.bool_as_number,
-            "roundTripFailed": t.round_trip_failed, "roundTripDiffering": t.round_trip_differing, "categoriesDiffering": t.categories,
-        },
-        "functions": functions_json(&t.functions),
-        "signatures": t.signatures,
-    })
-}
-
-/// One report line: line breaks and tabs shown escaped so that they stay visible as differences.
-fn one_line(s: &str) -> String {
-    s.replace('\n', "\\n").replace('\r', "\\r").replace('\t', "\\t")
-}
-
-/// `…tail` of a long label.
-fn fit(s: &str, w: usize) -> String {
-    let n = s.chars().count();
-    if n <= w { s.to_string() } else { format!("…{}", s.chars().skip(n + 1 - w).collect::<String>()) }
-}
-
-fn print_human(reports: &[FileReport], opts: &Options) {
-    for r in reports {
-        outln!("== {}", r.path);
-        if let Some(e) = &r.error {
-            outln!("  can't open: {e}");
-            continue;
-        }
-        let c = &r.calc;
-        outln!(
-            "  formulas {}: {} checked, {} matched, {} mismatched, {} no oracle, {} volatile",
-            c.formula_cells,
-            c.checked,
-            c.matched,
-            c.mismatched,
-            c.no_oracle,
-            c.volatile
-        );
-        if c.stale_cache {
-            outln!("  (the producer asked for a full recalculation on load: its cached values aren't results)");
-        }
-        if c.bool_as_number > 0 {
-            outln!("  ({} matched TRUE/FALSE results were saved by the producer as 1/0, without t=\"b\")", c.bool_as_number);
-        }
-        for m in &c.mismatches {
-            let tag = if m.primary { "mismatch" } else { "  (downstream)" };
-            outln!(
-                "  {tag} {}  {}  expected {}  got {}  [{}]",
-                m.cell,
-                one_line(&m.formula),
-                value_show(&m.expected),
-                value_show(&m.actual),
-                m.functions.join(" ")
-            );
-        }
-        if c.mismatched > c.mismatches.len() {
-            outln!("  … {} more mismatches", c.mismatched - c.mismatches.len());
-        }
-        let rt = &r.round_trip;
-        if let Some(e) = &rt.error {
-            outln!("  round trip: {e}");
-        }
-        let differing: Vec<&Category> = rt.categories.iter().filter(|c| c.diffs > 0).collect();
-        if differing.is_empty() && rt.error.is_none() {
-            outln!("  round trip: all equal");
-        }
-        for cat in differing {
-            outln!("  round trip {}: {} difference(s)", cat.name, cat.diffs);
-            for e in &cat.examples {
-                outln!("    {}", one_line(e));
-            }
-            if cat.diffs > cat.examples.len() {
-                outln!("    … {} more", cat.diffs - cat.examples.len());
-            }
-        }
-    }
-    outln!("");
-    let w = reports.iter().map(|r| r.path.chars().count()).max().unwrap_or(4).clamp(4, 50);
-    outln!(
-        "{:<w$}  {:>8}  {:>8}  {:>8}  {:>8}  {:>9}  {:>8}  round trip",
-        "file",
-        "formulas",
-        "checked",
-        "matched",
-        "mismatch",
-        "no-oracle",
-        "volatile"
-    );
-    for r in reports {
-        let label = fit(&r.path, w);
-        if let Some(e) = &r.error {
-            outln!("{label:<w$}  can't open: {}", one_line(&fit(e, 100)));
-            continue;
-        }
-        let c = &r.calc;
-        let rt = match (&r.round_trip.error, r.round_trip.differing()) {
-            (Some(_), _) => "FAILED".to_string(),
-            (None, d) if d.is_empty() => "ok".to_string(),
-            (None, d) => d.join(","),
-        };
-        outln!(
-            "{label:<w$}  {:>8}  {:>8}  {:>8}  {:>8}  {:>9}  {:>8}  {rt}",
-            c.formula_cells,
-            c.checked,
-            c.matched,
-            c.mismatched,
-            c.no_oracle,
-            c.volatile
-        );
-    }
-    let t = totals(reports);
-    let top = ranked(&t.functions);
-    if !top.is_empty() {
-        outln!("");
-        outln!("top mismatching functions (primary = no mismatching precedent):");
-        outln!("  {:<20}  {:>8}  {:>10}  {:>8}", "function", "primary", "mismatched", "checked");
-        for (n, s) in top.iter().take(opts.max_report.max(1)) {
-            outln!("  {:<20}  {:>8}  {:>10}  {:>8}", n, s.primary, s.mismatched, s.checked);
-        }
-    }
-    let mut sigs: Vec<(&String, &usize)> = t.signatures.iter().collect();
-    sigs.sort_by(|a, b| b.1.cmp(a.1).then(a.0.cmp(b.0)));
-    if !sigs.is_empty() {
-        outln!("");
-        outln!("mismatch signatures (expected → GridCraft):");
-        for (sig, n) in sigs.iter().take(opts.max_report.max(1)) {
-            outln!("  {n:>8}  {sig}");
-        }
-    }
-    outln!("");
-    outln!("files: {} ({} opened, {} failed to open)", t.files, t.opened, t.failed);
-    outln!(
-        "formula cells: {} ({} checked: {} matched, {} mismatched; {} no oracle; {} volatile)",
-        t.formula_cells,
-        t.checked,
-        t.matched,
-        t.mismatched,
-        t.no_oracle,
-        t.volatile
-    );
-    if t.bool_as_number > 0 {
-        outln!("booleans saved as 1/0 by the producer: {} (counted as matched)", t.bool_as_number);
-    }
-    let cats: Vec<String> = t.categories.iter().map(|(c, n)| format!("{c} {n}")).collect();
-    outln!(
-        "round trip: {} of {} files differ{}{}",
-        t.round_trip_differing,
-        t.opened,
-        if t.round_trip_failed > 0 { format!(" ({} failed)", t.round_trip_failed) } else { String::new() },
-        if cats.is_empty() { String::new() } else { format!("; categories (files): {}", cats.join(", ")) }
-    );
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/apps/gridcraft-cli/src/check/calc.rs b/apps/gridcraft-cli/src/check/calc.rs
new file mode 100644
index 000000000..a3f33d296
--- /dev/null
+++ b/apps/gridcraft-cli/src/check/calc.rs
@@ -0,0 +1,237 @@
+use super::*;
+
+/// Functions whose result depends on the clock, a random generator or the environment.
+const VOLATILE: [&str; 6] = ["RAND", "RANDARRAY", "RANDBETWEEN", "NOW", "TODAY", "INFO"];
+
+// ---------------------------------------------------------------- calc oracle
+
+fn functions_of(e: &Expr) -> Vec<String> {
+    let mut set = BTreeSet::new();
+    e.walk(&mut |x| {
+        if let Expr::Call(n, _) = x {
+            set.insert(n.clone());
+        }
+    });
+    set.into_iter().collect()
+}
+
+fn is_volatile(e: &Expr, volatile_names: &HashSet<String>) -> bool {
+    let mut v = false;
+    e.walk(&mut |x| match x {
+        Expr::Call(n, args) => {
+            let filename = n == "CELL" && matches!(args.first(), Some(Expr::Text(t)) if t.eq_ignore_ascii_case("filename"));
+            if filename || VOLATILE.contains(&n.as_str()) {
+                v = true;
+            }
+        }
+        Expr::Name(n) if volatile_names.contains(&n.to_ascii_uppercase()) => v = true,
+        _ => {}
+    });
+    v
+}
+
+/// Upper-cased defined names whose formula is volatile, directly or through other names.
+pub(super) fn volatile_names(wb: &Workbook) -> HashSet<String> {
+    let parsed: Vec<(String, Option<Expr>)> =
+        wb.names.iter().map(|n| (n.name.to_ascii_uppercase(), gridcraft_engine::formula::parse(&n.formula).ok())).collect();
+    let mut set = HashSet::new();
+    // Each round adds at least one name or stops, so `len + 1` rounds reach the fixed point.
+    for _ in 0..=parsed.len() {
+        let before = set.len();
+        for (name, e) in &parsed {
+            if !set.contains(name) && e.as_ref().is_some_and(|e| is_volatile(e, &set)) {
+                set.insert(name.clone());
+            }
+        }
+        if set.len() == before {
+            break;
+        }
+    }
+    set
+}
+
+/// The formula as the formula bar shows it.
+pub(super) fn formula_text(cell: &Cell) -> String {
+    cell.bar_text()
+}
+
+fn cell_name(wb: &Workbook, (sheet, c): Key) -> String {
+    let name = wb.sheet(sheet).map(|s| s.name.as_str()).unwrap_or("?");
+    format!("{}!{}", quote_sheet(name), c.a1())
+}
+
+/// Whether the producer cached GridCraft's logical result as the number 1 or 0. Excel types a
+/// logical result `t="b"`; a writer that leaves the type out (`<c><f>TRUE()</f><v>1</v></c>`, as
+/// Business Central's "Open in Excel" exports do) stores the same value, read back as a number.
+pub fn bool_cached_as_number(expected: &Value, actual: &Value) -> bool {
+    matches!((expected, actual), (Value::Number(n), Value::Bool(b)) if *n == if *b { 1.0 } else { 0.0 })
+}
+
+/// Whether GridCraft's `actual` agrees with the producer's `expected`.
+pub fn values_match(expected: &Value, actual: &Value, tolerance: f64) -> bool {
+    match (expected, actual) {
+        (Value::Number(a), Value::Number(b)) => (a - b).abs() <= tolerance * a.abs().max(b.abs()).max(1.0),
+        (Value::Text(a), Value::Text(b)) => a == b,
+        (Value::Bool(a), Value::Bool(b)) => a == b,
+        (Value::Error(a), Value::Error(b)) => a == b,
+        _ => false,
+    }
+}
+
+fn type_name(v: &Value) -> &'static str {
+    match v {
+        Value::Empty => "blank",
+        Value::Number(_) => "number",
+        Value::Text(_) => "text",
+        Value::Bool(_) => "bool",
+        Value::Error(e) => e.as_str(),
+        Value::Array(_) => "array",
+    }
+}
+
+fn mismatch_kind(expected: &Value, actual: &Value) -> &'static str {
+    match (expected, actual) {
+        (_, Value::Empty) => "blank",
+        (Value::Number(_), Value::Number(_)) => "numeric",
+        (Value::Text(_), Value::Text(_)) => "text",
+        (Value::Bool(_), Value::Bool(_)) => "bool",
+        (Value::Error(_), _) | (_, Value::Error(_)) => "error",
+        _ => "type",
+    }
+}
+
+/// Mismatched cells indexed by (sheet, column) → rows, for precedent-area queries.
+struct MismatchIndex {
+    cols: HashMap<(usize, u32), BTreeSet<u32>>,
+    /// Columns with mismatches per sheet (for very wide areas).
+    sheet_cols: HashMap<usize, BTreeSet<u32>>,
+}
+
+impl MismatchIndex {
+    fn new(keys: &[Key]) -> MismatchIndex {
+        let mut cols: HashMap<(usize, u32), BTreeSet<u32>> = HashMap::new();
+        let mut sheet_cols: HashMap<usize, BTreeSet<u32>> = HashMap::new();
+        for &(s, c) in keys {
+            cols.entry((s, c.col)).or_default().insert(c.row);
+            sheet_cols.entry(s).or_default().insert(c.col);
+        }
+        MismatchIndex { cols, sheet_cols }
+    }
+    /// Whether a mismatched cell other than `own` lies in the area.
+    fn any_in(&self, sheet: usize, r0: u32, r1: u32, c0: u32, c1: u32, own: Key) -> bool {
+        let Some(cols) = self.sheet_cols.get(&sheet) else { return false };
+        cols.range(c0..=c1)
+            .any(|&col| self.cols.get(&(sheet, col)).is_some_and(|rows| rows.range(r0..=r1).any(|&row| (sheet, CellRef::new(row, col)) != own)))
+    }
+}
+
+/// Compares every formula cell of `cached` (as the producer saved it) with `fresh` (recalculated
+/// by GridCraft). Without `trust_cache` nothing is compared (see [`CalcReport::stale_cache`]).
+pub fn oracle(cached: &Workbook, fresh: &Workbook, calc: &Calc, trust_cache: bool, opts: &Options) -> CalcReport {
+    let mut r = CalcReport { stale_cache: !trust_cache, ..Default::default() };
+    let vnames = volatile_names(cached);
+    let mut volatile: HashSet<Key> = HashSet::new();
+    for (si, sh) in cached.sheets.iter().enumerate() {
+        for (c, cell) in sh.cells.iter() {
+            if let Some(f) = &cell.formula {
+                r.formula_cells += 1;
+                if f.expr_arc().is_some_and(|e| is_volatile(&e, &vnames)) {
+                    volatile.insert((si, c));
+                }
+            }
+        }
+    }
+    // Everything downstream of a volatile formula is volatile too; each key is pushed once.
+    let mut stack: Vec<Key> = volatile.iter().copied().collect();
+    let mut deps = Vec::new();
+    while let Some((s, c)) = stack.pop() {
+        deps.clear();
+        calc.graph.dependents(s, c, &mut deps);
+        if let Some(range) = fresh.sheet(s).and_then(|sh| sh.spill_ranges.get(&c)) {
+            calc.graph.dependents_of_range(s, *range, &mut deps);
+        }
+        for k in deps.drain(..) {
+            if volatile.insert(k) {
+                stack.push(k);
+            }
+        }
+    }
+
+    let mut bad: Vec<(Key, Vec<String>)> = Vec::new();
+    for (si, sh) in cached.sheets.iter().enumerate() {
+        for (c, cell) in sh.cells.iter() {
+            let Some(f) = &cell.formula else { continue };
+            if volatile.contains(&(si, c)) {
+                r.volatile += 1;
+                continue;
+            }
+            if cell.value.is_empty() || !trust_cache {
+                r.no_oracle += 1;
+                continue;
+            }
+            r.checked += 1;
+            let actual = fresh.sheet(si).and_then(|s| s.cell(c)).map(|x| x.value.scalar()).unwrap_or_default();
+            let funcs = match f.expr_arc() {
+                Some(e) => {
+                    let names = functions_of(&e);
+                    if names.is_empty() { vec!["(no function)".to_string()] } else { names }
+                }
+                None => vec!["(unparsed)".to_string()],
+            };
+            let bool_as_number = bool_cached_as_number(&cell.value, &actual);
+            let ok = bool_as_number || values_match(&cell.value, &actual, opts.tolerance);
+            if bool_as_number {
+                r.bool_as_number += 1;
+            }
+            for n in &funcs {
+                let st = r.functions.entry(n.clone()).or_default();
+                st.checked += 1;
+                if !ok {
+                    st.mismatched += 1;
+                }
+            }
+            if ok {
+                r.matched += 1;
+            } else {
+                r.mismatched += 1;
+                *r.signatures.entry(format!("{} → {}", type_name(&cell.value), type_name(&actual))).or_default() += 1;
+                bad.push(((si, c), funcs));
+            }
+        }
+    }
+
+    // A mismatch is primary when none of its precedent cells mismatch.
+    let keys: Vec<Key> = bad.iter().map(|(k, _)| *k).collect();
+    let index = MismatchIndex::new(&keys);
+    let mut listed: Vec<(bool, Key, Vec<String>)> = Vec::with_capacity(bad.len());
+    for (k, funcs) in bad {
+        let upstream = calc
+            .graph
+            .precedents_of(k)
+            .iter()
+            .any(|a| index.any_in(a.sheet, a.range.start.row, a.range.end.row, a.range.start.col, a.range.end.col, k));
+        if !upstream {
+            for n in &funcs {
+                r.functions.entry(n.clone()).or_default().primary += 1;
+            }
+        }
+        listed.push((!upstream, k, funcs));
+    }
+    // Primary mismatches first, each group in sheet then row-major order (already sorted).
+    listed.sort_by_key(|(primary, _, _)| !*primary);
+    for (primary, k, functions) in listed.into_iter().take(opts.max_report) {
+        let cell = cached.sheet(k.0).and_then(|s| s.cell(k.1));
+        let expected = cell.map(|c| c.value.clone()).unwrap_or_default();
+        let actual = fresh.sheet(k.0).and_then(|s| s.cell(k.1)).map(|x| x.value.scalar()).unwrap_or_default();
+        r.mismatches.push(Mismatch {
+            cell: cell_name(cached, k),
+            formula: cell.map(formula_text).unwrap_or_default(),
+            kind: mismatch_kind(&expected, &actual),
+            expected,
+            actual,
+            functions,
+            primary,
+        });
+    }
+    r
+}
diff --git a/apps/gridcraft-cli/src/check/fidelity.rs b/apps/gridcraft-cli/src/check/fidelity.rs
new file mode 100644
index 000000000..446a8949a
--- /dev/null
+++ b/apps/gridcraft-cli/src/check/fidelity.rs
@@ -0,0 +1,185 @@
+use super::calc::formula_text;
+use super::package::{REBUILT_KINDS, relationship_kinds, validate_package};
+use super::*;
+
+// ---------------------------------------------------------------- round trip
+
+/// Writes `wb` with GridCraft's XLSX writer, validates the package against itself and against
+/// `source` (the file `wb` was read from), reads it back and compares.
+pub fn round_trip(wb: &Workbook, source: &[u8], opts: &Options) -> RoundTrip {
+    let bytes = match gridcraft_engine::io::save_bytes(wb, "roundtrip.xlsx") {
+        Ok(b) => b,
+        Err(e) => return RoundTrip { error: Some(format!("write failed: {e}")), categories: vec![] },
+    };
+    let mut package = Diffs::new("package", opts.max_report);
+    match validate_package(&bytes) {
+        Ok(issues) => issues.into_iter().for_each(|i| package.push(|| i)),
+        Err(e) => package.push(|| e),
+    }
+    if let (Ok(before), Ok(after)) = (relationship_kinds(source), relationship_kinds(&bytes)) {
+        for (key, kind) in &before {
+            if !after.contains_key(key) && !REBUILT_KINDS.contains(&key.as_str()) {
+                package.push(|| format!("lost relationship {kind}"));
+            }
+        }
+    }
+    let back = match gridcraft_engine::io::open_bytes("roundtrip.xlsx", &bytes) {
+        Ok((b, _)) => b,
+        Err(e) => return RoundTrip { error: Some(format!("reading the written file failed: {e}")), categories: vec![package.done()] },
+    };
+    let mut categories = diff_workbooks(wb, &back, opts);
+    categories.push(package.done());
+    RoundTrip { error: None, categories }
+}
+
+pub(super) fn value_show(v: &Value) -> String {
+    match v {
+        Value::Empty => "(blank)".to_string(),
+        Value::Text(t) => serde_json::to_string(t.as_ref()).unwrap_or_default(),
+        Value::Number(n) => number_text(*n),
+        Value::Bool(b) => if *b { "TRUE" } else { "FALSE" }.to_string(),
+        Value::Error(e) => e.as_str().to_string(),
+        Value::Array(_) => v.scalar().display(),
+    }
+}
+
+fn opt_formula(c: Option<&Cell>) -> String {
+    c.filter(|c| c.formula.is_some()).map(formula_text).unwrap_or_default()
+}
+
+/// Per-sheet comparison of two lists, reporting what one side has and the other lacks.
+fn diff_sets(d: &mut Diffs, sheet: &str, a: &BTreeSet<String>, b: &BTreeSet<String>) {
+    for x in a.difference(b) {
+        d.push(|| format!("{sheet}: lost {x}"));
+    }
+    for x in b.difference(a) {
+        d.push(|| format!("{sheet}: gained {x}"));
+    }
+}
+
+/// A sheet's conditional-format rules in precedence order, as comparable text. The priority number
+/// itself is left out, so renumbering without changing the order isn't a difference.
+fn cond_format_list(s: &Sheet) -> Vec<String> {
+    let mut cfs: Vec<_> = s.cond_formats.iter().collect();
+    cfs.sort_by_key(|c| c.priority);
+    cfs.iter().map(|c| format!("{:?} {:?} stopIfTrue={}", c.ranges, c.rule, c.stop_if_true)).collect()
+}
+
+fn diff_count(d: &mut Diffs, sheet: &str, a: usize, b: usize) {
+    if a != b {
+        d.push(|| format!("{sheet}: {a} → {b}"));
+    }
+}
+
+/// A value as the file format can hold it: `#SPILL!`/`#CALC!` are cached as `#VALUE!` and an
+/// unresolved circular reference as 0 (what Excel writes), so those aren't round-trip losses.
+fn as_cached(v: Value) -> Value {
+    match v {
+        Value::Error(CellError::Spill | CellError::Calc) => Value::Error(CellError::Value),
+        Value::Error(CellError::Circ) => Value::Number(0.0),
+        v => v,
+    }
+}
+
+fn num_fmt<'a>(wb: &'a Workbook, c: Option<&Cell>) -> &'a str {
+    wb.styles.get(c.map(|c| c.style).unwrap_or_default()).num_fmt.as_str()
+}
+
+/// Feature-by-feature comparison of a workbook (`a`) with what reading it back gave (`b`). Sheets
+/// are paired by position.
+pub fn diff_workbooks(a: &Workbook, b: &Workbook, opts: &Options) -> Vec<Category> {
+    let m = opts.max_report;
+    let mut sheets = Diffs::new("sheets", m);
+    let (an, bn): (Vec<&str>, Vec<&str>) = (a.sheets.iter().map(|s| s.name.as_str()).collect(), b.sheets.iter().map(|s| s.name.as_str()).collect());
+    if an != bn {
+        sheets.push(|| format!("{an:?} → {bn:?}"));
+    }
+    let mut values = Diffs::new("values", m);
+    let mut formulas = Diffs::new("formulas", m);
+    let mut num_fmts = Diffs::new("numFmts", m);
+    let mut merges = Diffs::new("merges", m);
+    let mut tables = Diffs::new("tables", m);
+    let mut cond_formats = Diffs::new("condFormats", m);
+    let mut validations = Diffs::new("validations", m);
+    let mut charts = Diffs::new("charts", m);
+    let mut comments = Diffs::new("comments", m);
+    let mut hyperlinks = Diffs::new("hyperlinks", m);
+    let mut pivots = Diffs::new("pivots", m);
+    for (sa, sb) in a.sheets.iter().zip(b.sheets.iter()) {
+        let name = quote_sheet(&sa.name);
+        let mut cell = |c: CellRef, ca: Option<&Cell>, cb: Option<&Cell>| {
+            let cached = |x: Option<&Cell>| as_cached(x.map(|x| x.value.scalar()).unwrap_or_default());
+            let (va, vb) = (cached(ca), cached(cb));
+            if va != vb {
+                values.push(|| format!("{name}!{}: {} → {}", c.a1(), value_show(&va), value_show(&vb)));
+            }
+            let (fa, fb) = (opt_formula(ca), opt_formula(cb));
+            if fa != fb {
+                formulas.push(|| format!("{name}!{}: {fa} → {fb}", c.a1()));
+            }
+            let (na, nb) = (num_fmt(a, ca), num_fmt(b, cb));
+            if na != nb {
+                num_fmts.push(|| format!("{name}!{}: {na} → {nb}", c.a1()));
+            }
+        };
+        for (c, ca) in sa.cells.iter() {
+            cell(c, Some(ca), sb.cell(c));
+        }
+        for (c, cb) in sb.cells.iter() {
+            if sa.cell(c).is_none() {
+                cell(c, None, Some(cb));
+            }
+        }
+        let set = |f: &dyn Fn(&Sheet) -> Vec<String>, s: &Sheet| f(s).into_iter().collect::<BTreeSet<String>>();
+        let merge_list = |s: &Sheet| -> Vec<String> { s.merges.iter().map(|r| r.a1()).collect() };
+        diff_sets(&mut merges, &name, &set(&merge_list, sa), &set(&merge_list, sb));
+        let table_list = |s: &Sheet| -> Vec<String> {
+            s.tables
+                .iter()
+                .map(|t| format!("{} {} [{}]", t.name, t.range.a1(), t.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>().join(", ")))
+                .collect()
+        };
+        diff_sets(&mut tables, &name, &set(&table_list, sa), &set(&table_list, sb));
+        let (cfa, cfb) = (cond_format_list(sa), cond_format_list(sb));
+        if cfa.len() != cfb.len() {
+            cond_formats.push(|| format!("{name}: {} → {}", cfa.len(), cfb.len()));
+        } else if let Some((x, y)) = cfa.iter().zip(&cfb).find(|(x, y)| x != y) {
+            cond_formats.push(|| format!("{name}: {x} → {y}"));
+        }
+        diff_count(&mut validations, &name, sa.validations.len(), sb.validations.len());
+        let chart_list = |s: &Sheet| s.charts.iter().map(|c| format!("{:?} ({} series)", c.kind, c.series.len())).collect::<Vec<_>>();
+        let (ca, cb) = (chart_list(sa), chart_list(sb));
+        if ca != cb {
+            charts.push(|| format!("{name}: {ca:?} → {cb:?}"));
+        }
+        diff_count(&mut comments, &name, sa.comments.len(), sb.comments.len());
+        diff_count(&mut hyperlinks, &name, sa.hyperlinks.len(), sb.hyperlinks.len());
+        diff_count(&mut pivots, &name, sa.pivots.len(), sb.pivots.len());
+    }
+    let mut names = Diffs::new("names", m);
+    let name_list = |wb: &Workbook| -> BTreeSet<String> {
+        wb.names
+            .iter()
+            .map(|n| {
+                let scope = n.scope.map(|i| format!("{}!", quote_sheet(wb.sheet(i).map(|s| s.name.as_str()).unwrap_or("?")))).unwrap_or_default();
+                format!("{scope}{}={}", n.name, n.formula)
+            })
+            .collect()
+    };
+    diff_sets(&mut names, "workbook", &name_list(a), &name_list(b));
+    vec![
+        sheets.done(),
+        values.done(),
+        formulas.done(),
+        num_fmts.done(),
+        merges.done(),
+        names.done(),
+        tables.done(),
+        cond_formats.done(),
+        validations.done(),
+        charts.done(),
+        comments.done(),
+        hyperlinks.done(),
+        pivots.done(),
+    ]
+}
diff --git a/apps/gridcraft-cli/src/check/package.rs b/apps/gridcraft-cli/src/check/package.rs
new file mode 100644
index 000000000..bcbbef10f
--- /dev/null
+++ b/apps/gridcraft-cli/src/check/package.rs
@@ -0,0 +1,329 @@
+use super::*;
+
+/// Largest package part read while validating a written package.
+const MAX_XML_PART: u64 = 64 * 1024 * 1024;
+
+/// Most zip entries looked at while validating a written package.
+const MAX_ENTRIES: usize = 200_000;
+
+/// Relationship kinds (lower case) whose absence after a save isn't a loss: the calculation chain is
+/// a cache Excel rebuilds, and GridCraft never writes it.
+pub(super) const REBUILT_KINDS: [&str; 1] = ["calcchain"];
+
+// ---------------------------------------------------------------- package validation
+
+fn local_name(name: &[u8]) -> &[u8] {
+    match name.iter().rposition(|&b| b == b':') {
+        Some(i) => name.get(i + 1..).unwrap_or(name),
+        None => name,
+    }
+}
+
+/// `(element local name, attributes)` for every start/empty element of an XML part.
+fn xml_elements(xml: &[u8]) -> Result<Vec<(String, Vec<(String, String)>)>, String> {
+    use quick_xml::events::Event;
+    let mut reader = quick_xml::Reader::from_reader(xml);
+    let mut buf = Vec::new();
+    let mut out = Vec::new();
+    loop {
+        match reader.read_event_into(&mut buf) {
+            Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
+                let attrs = e
+                    .attributes()
+                    .with_checks(false)
+                    .flatten()
+                    .map(|a| {
+                        let v = match a.normalized_value(quick_xml::XmlVersion::Explicit1_0) {
+                            Ok(v) => v.into_owned(),
+                            Err(_) => String::from_utf8_lossy(&a.value).into_owned(),
+                        };
+                        (String::from_utf8_lossy(local_name(a.key.as_ref())).into_owned(), v)
+                    })
+                    .collect();
+                out.push((String::from_utf8_lossy(local_name(e.name().as_ref())).into_owned(), attrs));
+            }
+            Ok(Event::Eof) => break,
+            Ok(_) => {}
+            Err(e) => return Err(format!("invalid XML: {e}")),
+        }
+        buf.clear();
+    }
+    Ok(out)
+}
+
+fn attr<'a>(attrs: &'a [(String, String)], k: &str) -> Option<&'a str> {
+    attrs.iter().find(|(n, _)| n == k).map(|(_, v)| v.as_str())
+}
+
+/// Lower-cased part name without a leading slash: OPC part names compare case-insensitively.
+fn part_key(name: &str) -> String {
+    name.trim_start_matches('/').to_ascii_lowercase()
+}
+
+/// `%XX` escapes in a relationship target.
+fn percent_decode(s: &str) -> String {
+    let b = s.as_bytes();
+    let mut out = Vec::with_capacity(b.len());
+    let mut i = 0;
+    while let Some(&c) = b.get(i) {
+        let hex = |j: usize| b.get(j).and_then(|h| (*h as char).to_digit(16));
+        match (c, hex(i + 1), hex(i + 2)) {
+            (b'%', Some(h), Some(l)) => {
+                out.push((h * 16 + l) as u8);
+                i += 3;
+            }
+            _ => {
+                out.push(c);
+                i += 1;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// Resolves a relationship target against the source part's directory.
+fn resolve_target(source_dir: &str, target: &str) -> String {
+    let target = percent_decode(target.split('#').next().unwrap_or(target));
+    let joined = match target.strip_prefix('/') {
+        Some(abs) => abs.to_string(),
+        None if source_dir.is_empty() => target,
+        None => format!("{source_dir}/{target}"),
+    };
+    let mut parts: Vec<&str> = Vec::new();
+    for seg in joined.split('/') {
+        match seg {
+            "" | "." => {}
+            ".." => {
+                parts.pop();
+            }
+            s => parts.push(s),
+        }
+    }
+    parts.join("/")
+}
+
+type Zip<'a> = zip::ZipArchive<Cursor<&'a [u8]>>;
+
+fn zip_names(zip: &mut Zip<'_>) -> Vec<String> {
+    (0..zip.len().min(MAX_ENTRIES)).filter_map(|i| zip.by_index_raw(i).ok().filter(|f| !f.is_dir()).map(|f| f.name().to_string())).collect()
+}
+
+fn read_zip_part(zip: &mut Zip<'_>, name: &str) -> Result<Vec<u8>, String> {
+    let f = zip.by_name(name).map_err(|e| format!("{name}: {e}"))?;
+    let mut buf = Vec::new();
+    f.take(MAX_XML_PART).read_to_end(&mut buf).map_err(|e| format!("{name}: {e}"))?;
+    Ok(buf)
+}
+
+/// Whether the producer flagged its cached results as stale with `<calcPr fullCalcOnLoad="1">`:
+/// libraries that don't calculate write it, and store 0 or nothing as every formula's value.
+pub(super) fn full_calc_on_load(bytes: &[u8]) -> bool {
+    let Ok(mut zip) = zip::ZipArchive::new(Cursor::new(bytes)) else { return false };
+    let names = zip_names(&mut zip);
+    let find = |key: &str| names.iter().find(|n| part_key(n) == key).cloned();
+    let mut workbook = "xl/workbook.xml".to_string();
+    if let Some(rels) = find("_rels/.rels")
+        && let Ok(xml) = read_zip_part(&mut zip, &rels)
+        && let Ok(els) = xml_elements(&xml)
+        && let Some(target) = els
+            .iter()
+            .find(|(e, a)| e == "Relationship" && attr(a, "Type").is_some_and(|t| t.ends_with("/officeDocument")))
+            .and_then(|(_, a)| attr(a, "Target"))
+    {
+        workbook = resolve_target("", target);
+    }
+    let Some(name) = find(&part_key(&workbook)) else { return false };
+    let Ok(xml) = read_zip_part(&mut zip, &name) else { return false };
+    xml_elements(&xml)
+        .ok()
+        .into_iter()
+        .flatten()
+        .any(|(e, a)| e == "calcPr" && attr(&a, "fullCalcOnLoad").is_some_and(|v| v == "1" || v.eq_ignore_ascii_case("true")))
+}
+
+/// Problems Excel would repair in a written package: parts without a content type, content-type
+/// overrides for missing parts, relationship files for missing parts, duplicate relationship ids
+/// and internal relationships pointing at missing parts. `Err` when the package can't be read.
+pub fn validate_package(bytes: &[u8]) -> Result<Vec<String>, String> {
+    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| format!("not a zip package: {e}"))?;
+    let names = zip_names(&mut zip);
+    let parts: HashSet<String> = names.iter().map(|n| part_key(n)).collect();
+    let mut read_part = |name: &str| read_zip_part(&mut zip, name);
+    let mut issues = Vec::new();
+    let ct_name = names.iter().find(|n| part_key(n) == "[content_types].xml").cloned();
+    let (mut defaults, mut overrides) = (HashSet::new(), HashSet::new());
+    match ct_name {
+        None => issues.push("no [Content_Types].xml".to_string()),
+        Some(n) => {
+            for (el, attrs) in xml_elements(&read_part(&n)?).map_err(|e| format!("[Content_Types].xml: {e}"))? {
+                match el.as_str() {
+                    "Default" => {
+                        if let Some(x) = attr(&attrs, "Extension") {
+                            defaults.insert(x.to_ascii_lowercase());
+                        }
+                    }
+                    "Override" => {
+                        if let Some(p) = attr(&attrs, "PartName") {
+                            overrides.insert(part_key(p));
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    let mut sorted: Vec<&String> = names.iter().collect();
+    sorted.sort();
+    for n in &sorted {
+        let key = part_key(n);
+        if key == "[content_types].xml" {
+            continue;
+        }
+        let ext = key.rsplit('/').next().and_then(|f| f.rsplit_once('.')).map(|(_, e)| e.to_string());
+        if !overrides.contains(&key) && !ext.is_some_and(|e| defaults.contains(&e)) {
+            issues.push(format!("part {n} has no content type"));
+        }
+    }
+    let mut missing_overrides: Vec<&String> = overrides.iter().filter(|p| !parts.contains(*p)).collect();
+    missing_overrides.sort();
+    for p in missing_overrides {
+        issues.push(format!("content type override for missing part /{p}"));
+    }
+    for n in sorted {
+        let key = part_key(n);
+        let Some(rels_file) = key.strip_suffix(".rels") else { continue };
+        // `dir/_rels/name.rels` describes `dir/name`; `_rels/.rels` the package itself.
+        let (dir, file) = match rels_file.rsplit_once('/') {
+            Some((d, f)) => (d, f),
+            None => continue,
+        };
+        let Some(src_dir) = dir.strip_suffix("_rels").map(|d| d.trim_end_matches('/')) else { continue };
+        let source = if src_dir.is_empty() { file.to_string() } else { format!("{src_dir}/{file}") };
+        if !source.is_empty() && !parts.contains(&source) {
+            issues.push(format!("{n} describes missing part {source}"));
+        }
+        let mut ids = HashSet::new();
+        for (el, attrs) in xml_elements(&read_part(n)?).map_err(|e| format!("{n}: {e}"))? {
+            if el != "Relationship" {
+                continue;
+            }
+            let id = attr(&attrs, "Id").unwrap_or("");
+            if !ids.insert(id.to_string()) {
+                issues.push(format!("{n}: duplicate relationship id {id}"));
+            }
+            if attr(&attrs, "TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External")) {
+                continue;
+            }
+            let target = attr(&attrs, "Target").unwrap_or("");
+            let resolved = resolve_target(src_dir, target);
+            if !parts.contains(&resolved.to_ascii_lowercase()) {
+                let kind = attr(&attrs, "Type").and_then(|t| t.rsplit('/').next()).unwrap_or("?");
+                issues.push(format!("{n}: {id} ({kind}) targets missing part {resolved}"));
+            }
+        }
+    }
+    Ok(issues)
+}
+
+/// Every relationship kind (last segment of the type, the same in the transitional and strict
+/// namespaces) in the package's relationship parts, keyed in lower case. Relationships that carry
+/// nothing are left out, as a save may rightly drop them: a link to a place in the workbook
+/// (`#Sheet1!A1`, written as a cell's `location`) and a target part with nothing in it.
+pub(super) fn relationship_kinds(bytes: &[u8]) -> Result<BTreeMap<String, String>, String> {
+    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| format!("not a zip package: {e}"))?;
+    let names = zip_names(&mut zip);
+    let by_key: HashMap<String, &String> = names.iter().map(|n| (part_key(n), n)).collect();
+    // Several relationships name the same part; each fresh check decompressed it again, so
+    // repeated references to one highly compressible part multiplied the work. The verdict is
+    // remembered per (part, named content) and the decompression the package can cause is
+    // budgeted as a whole (finding: repeated decompression).
+    let mut verdicts: HashMap<(String, &'static str), bool> = HashMap::new();
+    let mut budget: u64 = 512 * 1024 * 1024;
+    let mut kinds = BTreeMap::new();
+    for n in names.iter().filter(|n| part_key(n).ends_with(".rels")) {
+        let Some(src_dir) = rels_source_dir(&part_key(n)) else { continue };
+        let Ok(els) = read_zip_part(&mut zip, n).and_then(|xml| xml_elements(&xml)) else { continue };
+        for (_, attrs) in els.iter().filter(|(el, _)| el == "Relationship") {
+            let Some(kind) = attr(attrs, "Type").and_then(|t| t.rsplit('/').next()) else { continue };
+            let target = attr(attrs, "Target").unwrap_or("");
+            if kind.eq_ignore_ascii_case("hyperlink") && target.starts_with('#') {
+                continue;
+            }
+            let external = attr(attrs, "TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External"));
+            if !external
+                && let Some(part) = by_key.get(&resolve_target(&src_dir, target).to_ascii_lowercase())
+                && !holds_something(&mut zip, part, kind, &mut verdicts, &mut budget)
+            {
+                continue;
+            }
+            kinds.entry(kind.to_ascii_lowercase()).or_insert_with(|| kind.to_string());
+        }
+    }
+    Ok(kinds)
+}
+
+/// The directory of the part a rels part describes: `xl` for `xl/_rels/workbook.xml.rels`, the
+/// empty string for the package's `_rels/.rels`.
+fn rels_source_dir(key: &str) -> Option<String> {
+    let (dir, _) = key.strip_suffix(".rels")?.rsplit_once('/')?;
+    Some(dir.strip_suffix("_rels")?.trim_end_matches('/').to_string())
+}
+
+/// Whether a part has content: an element under its root, or for comments (whose authors list
+/// comes first) a comment, for VML a shape. Read only as far as needed; an unreadable part counts.
+/// `verdicts` remembers the answer per (part, named content); `budget` is the decompression this
+/// package's remaining checks may cause, and once it is spent the part counts as having content.
+fn holds_something(zip: &mut Zip<'_>, name: &str, kind: &str, verdicts: &mut HashMap<(String, &'static str), bool>, budget: &mut u64) -> bool {
+    let wanted: Option<&'static [u8]> = match kind.to_ascii_lowercase().as_str() {
+        "comments" => Some(b"comment"),
+        "vmldrawing" => Some(b"shape"),
+        _ => None,
+    };
+    let marker = match wanted {
+        Some(b"comment") => "comment",
+        Some(_) => "shape",
+        None => "any",
+    };
+    if let Some(v) = verdicts.get(&(name.to_ascii_lowercase(), marker)) {
+        return *v;
+    }
+    let v = holds_something_uncached(zip, name, marker, budget);
+    verdicts.insert((name.to_ascii_lowercase(), marker), v);
+    v
+}
+
+fn holds_something_uncached(zip: &mut Zip<'_>, name: &str, marker: &'static str, budget: &mut u64) -> bool {
+    use quick_xml::events::Event;
+    let Ok(f) = zip.by_name(name) else { return true };
+    if *budget == 0 {
+        return true;
+    }
+    let take = f.size().min(MAX_XML_PART).min(*budget);
+    *budget -= take;
+    let mut reader = quick_xml::Reader::from_reader(std::io::BufReader::new(f.take(take)));
+    let wanted: Option<&'static [u8]> = match marker {
+        "comment" => Some(b"comment"),
+        "shape" => Some(b"shape"),
+        _ => None,
+    };
+    let mut buf = Vec::new();
+    let mut in_root = false;
+    loop {
+        match reader.read_event_into(&mut buf) {
+            Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
+                let found = match wanted {
+                    Some(w) => local_name(e.name().as_ref()) == w,
+                    None => in_root,
+                };
+                if found {
+                    return true;
+                }
+                in_root = true;
+            }
+            Ok(Event::Eof) => return false,
+            Ok(_) => {}
+            Err(_) => return true,
+        }
+        buf.clear();
+    }
+}
diff --git a/apps/gridcraft-cli/src/check/report.rs b/apps/gridcraft-cli/src/check/report.rs
new file mode 100644
index 000000000..54227e797
--- /dev/null
+++ b/apps/gridcraft-cli/src/check/report.rs
@@ -0,0 +1,264 @@
+use super::fidelity::value_show;
+use super::*;
+
+// ---------------------------------------------------------------- output
+
+#[derive(Default)]
+struct Totals {
+    files: usize,
+    opened: usize,
+    failed: usize,
+    formula_cells: usize,
+    checked: usize,
+    matched: usize,
+    mismatched: usize,
+    no_oracle: usize,
+    volatile: usize,
+    bool_as_number: usize,
+    round_trip_failed: usize,
+    round_trip_differing: usize,
+    categories: BTreeMap<&'static str, usize>,
+    functions: BTreeMap<String, FnStat>,
+    signatures: BTreeMap<String, usize>,
+}
+
+fn totals(reports: &[FileReport]) -> Totals {
+    let mut t = Totals { files: reports.len(), ..Default::default() };
+    for r in reports {
+        if r.error.is_some() {
+            t.failed += 1;
+            continue;
+        }
+        t.opened += 1;
+        t.formula_cells += r.calc.formula_cells;
+        t.checked += r.calc.checked;
+        t.matched += r.calc.matched;
+        t.mismatched += r.calc.mismatched;
+        t.no_oracle += r.calc.no_oracle;
+        t.volatile += r.calc.volatile;
+        t.bool_as_number += r.calc.bool_as_number;
+        if r.round_trip.error.is_some() {
+            t.round_trip_failed += 1;
+        }
+        if !r.round_trip.is_clean() {
+            t.round_trip_differing += 1;
+        }
+        for c in r.round_trip.differing() {
+            *t.categories.entry(c).or_default() += 1;
+        }
+        for (n, s) in &r.calc.functions {
+            t.functions.entry(n.clone()).or_default().add(s);
+        }
+        for (sig, n) in &r.calc.signatures {
+            *t.signatures.entry(sig.clone()).or_default() += n;
+        }
+    }
+    t
+}
+
+/// Functions with mismatches, worst first: most primary mismatches, then most mismatches.
+fn ranked(functions: &BTreeMap<String, FnStat>) -> Vec<(&String, &FnStat)> {
+    let mut v: Vec<(&String, &FnStat)> = functions.iter().filter(|(_, s)| s.mismatched > 0).collect();
+    v.sort_by(|a, b| b.1.primary.cmp(&a.1.primary).then(b.1.mismatched.cmp(&a.1.mismatched)).then(a.0.cmp(b.0)));
+    v
+}
+
+fn functions_json(functions: &BTreeMap<String, FnStat>) -> Json {
+    let mut v: Vec<(&String, &FnStat)> = functions.iter().collect();
+    v.sort_by(|a, b| b.1.primary.cmp(&a.1.primary).then(b.1.mismatched.cmp(&a.1.mismatched)).then(a.0.cmp(b.0)));
+    Json::Array(v.into_iter().map(|(n, s)| json!({"name": n, "checked": s.checked, "mismatched": s.mismatched, "primary": s.primary})).collect())
+}
+
+pub fn report_json(reports: &[FileReport], opts: &Options) -> Json {
+    let files: Vec<Json> = reports
+        .iter()
+        .map(|r| {
+            let c = &r.calc;
+            let mismatches: Vec<Json> = c
+                .mismatches
+                .iter()
+                .map(|m| {
+                    json!({
+                        "cell": m.cell, "formula": m.formula, "expected": value_json(&m.expected), "actual": value_json(&m.actual),
+                        "kind": m.kind, "functions": m.functions, "primary": m.primary,
+                    })
+                })
+                .collect();
+            let categories: serde_json::Map<String, Json> = r
+                .round_trip
+                .categories
+                .iter()
+                .map(|cat| (cat.name.to_string(), json!({"equal": cat.diffs == 0, "diffs": cat.diffs, "examples": cat.examples})))
+                .collect();
+            json!({
+                "path": r.path,
+                "opened": r.error.is_none(),
+                "error": r.error,
+                "warnings": r.warnings,
+                "calc": {
+                    "formulaCells": c.formula_cells, "checked": c.checked, "matched": c.matched, "mismatched": c.mismatched,
+                    "noOracle": c.no_oracle, "staleCache": c.stale_cache, "volatile": c.volatile, "boolAsNumber": c.bool_as_number,
+                    "mismatches": mismatches, "functions": functions_json(&c.functions),
+                    "signatures": c.signatures,
+                },
+                "roundTrip": {"error": r.round_trip.error, "differing": r.round_trip.differing(), "categories": categories},
+            })
+        })
+        .collect();
+    let t = totals(reports);
+    json!({
+        "schema": SCHEMA,
+        "tolerance": opts.tolerance,
+        "files": files,
+        "totals": {
+            "files": t.files, "opened": t.opened, "failedToOpen": t.failed, "formulaCells": t.formula_cells, "checked": t.checked,
+            "matched": t.matched, "mismatched": t.mismatched, "noOracle": t.no_oracle, "volatile": t.volatile, "boolAsNumber": t.bool_as_number,
+            "roundTripFailed": t.round_trip_failed, "roundTripDiffering": t.round_trip_differing, "categoriesDiffering": t.categories,
+        },
+        "functions": functions_json(&t.functions),
+        "signatures": t.signatures,
+    })
+}
+
+/// One report line: line breaks and tabs shown escaped so that they stay visible as differences.
+fn one_line(s: &str) -> String {
+    s.replace('\n', "\\n").replace('\r', "\\r").replace('\t', "\\t")
+}
+
+/// `…tail` of a long label.
+fn fit(s: &str, w: usize) -> String {
+    let n = s.chars().count();
+    if n <= w { s.to_string() } else { format!("…{}", s.chars().skip(n + 1 - w).collect::<String>()) }
+}
+
+pub(super) fn print_human(reports: &[FileReport], opts: &Options) {
+    for r in reports {
+        outln!("== {}", r.path);
+        if let Some(e) = &r.error {
+            outln!("  can't open: {e}");
+            continue;
+        }
+        let c = &r.calc;
+        outln!(
+            "  formulas {}: {} checked, {} matched, {} mismatched, {} no oracle, {} volatile",
+            c.formula_cells,
+            c.checked,
+            c.matched,
+            c.mismatched,
+            c.no_oracle,
+            c.volatile
+        );
+        if c.stale_cache {
+            outln!("  (the producer asked for a full recalculation on load: its cached values aren't results)");
+        }
+        if c.bool_as_number > 0 {
+            outln!("  ({} matched TRUE/FALSE results were saved by the producer as 1/0, without t=\"b\")", c.bool_as_number);
+        }
+        for m in &c.mismatches {
+            let tag = if m.primary { "mismatch" } else { "  (downstream)" };
+            outln!(
+                "  {tag} {}  {}  expected {}  got {}  [{}]",
+                m.cell,
+                one_line(&m.formula),
+                value_show(&m.expected),
+                value_show(&m.actual),
+                m.functions.join(" ")
+            );
+        }
+        if c.mismatched > c.mismatches.len() {
+            outln!("  … {} more mismatches", c.mismatched - c.mismatches.len());
+        }
+        let rt = &r.round_trip;
+        if let Some(e) = &rt.error {
+            outln!("  round trip: {e}");
+        }
+        let differing: Vec<&Category> = rt.categories.iter().filter(|c| c.diffs > 0).collect();
+        if differing.is_empty() && rt.error.is_none() {
+            outln!("  round trip: all equal");
+        }
+        for cat in differing {
+            outln!("  round trip {}: {} difference(s)", cat.name, cat.diffs);
+            for e in &cat.examples {
+                outln!("    {}", one_line(e));
+            }
+            if cat.diffs > cat.examples.len() {
+                outln!("    … {} more", cat.diffs - cat.examples.len());
+            }
+        }
+    }
+    outln!("");
+    let w = reports.iter().map(|r| r.path.chars().count()).max().unwrap_or(4).clamp(4, 50);
+    outln!(
+        "{:<w$}  {:>8}  {:>8}  {:>8}  {:>8}  {:>9}  {:>8}  round trip",
+        "file",
+        "formulas",
+        "checked",
+        "matched",
+        "mismatch",
+        "no-oracle",
+        "volatile"
+    );
+    for r in reports {
+        let label = fit(&r.path, w);
+        if let Some(e) = &r.error {
+            outln!("{label:<w$}  can't open: {}", one_line(&fit(e, 100)));
+            continue;
+        }
+        let c = &r.calc;
+        let rt = match (&r.round_trip.error, r.round_trip.differing()) {
+            (Some(_), _) => "FAILED".to_string(),
+            (None, d) if d.is_empty() => "ok".to_string(),
+            (None, d) => d.join(","),
+        };
+        outln!(
+            "{label:<w$}  {:>8}  {:>8}  {:>8}  {:>8}  {:>9}  {:>8}  {rt}",
+            c.formula_cells,
+            c.checked,
+            c.matched,
+            c.mismatched,
+            c.no_oracle,
+            c.volatile
+        );
+    }
+    let t = totals(reports);
+    let top = ranked(&t.functions);
+    if !top.is_empty() {
+        outln!("");
+        outln!("top mismatching functions (primary = no mismatching precedent):");
+        outln!("  {:<20}  {:>8}  {:>10}  {:>8}", "function", "primary", "mismatched", "checked");
+        for (n, s) in top.iter().take(opts.max_report.max(1)) {
+            outln!("  {:<20}  {:>8}  {:>10}  {:>8}", n, s.primary, s.mismatched, s.checked);
+        }
+    }
+    let mut sigs: Vec<(&String, &usize)> = t.signatures.iter().collect();
+    sigs.sort_by(|a, b| b.1.cmp(a.1).then(a.0.cmp(b.0)));
+    if !sigs.is_empty() {
+        outln!("");
+        outln!("mismatch signatures (expected → GridCraft):");
+        for (sig, n) in sigs.iter().take(opts.max_report.max(1)) {
+            outln!("  {n:>8}  {sig}");
+        }
+    }
+    outln!("");
+    outln!("files: {} ({} opened, {} failed to open)", t.files, t.opened, t.failed);
+    outln!(
+        "formula cells: {} ({} checked: {} matched, {} mismatched; {} no oracle; {} volatile)",
+        t.formula_cells,
+        t.checked,
+        t.matched,
+        t.mismatched,
+        t.no_oracle,
+        t.volatile
+    );
+    if t.bool_as_number > 0 {
+        outln!("booleans saved as 1/0 by the producer: {} (counted as matched)", t.bool_as_number);
+    }
+    let cats: Vec<String> = t.categories.iter().map(|(c, n)| format!("{c} {n}")).collect();
+    outln!(
+        "round trip: {} of {} files differ{}{}",
+        t.round_trip_differing,
+        t.opened,
+        if t.round_trip_failed > 0 { format!(" ({} failed)", t.round_trip_failed) } else { String::new() },
+        if cats.is_empty() { String::new() } else { format!("; categories (files): {}", cats.join(", ")) }
+    );
+}

From b36ec74f13cc41c159d637dfab61ff8a8b7dedcb Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:40:45 +0000
Subject: [PATCH 68/76] refactor(ui-egui): move ribbon.rs items to ribbon/

---
 crates/ui-egui/src/ribbon.rs             | 2824 +---------------------
 crates/ui-egui/src/ribbon/automate.rs    |   33 +
 crates/ui-egui/src/ribbon/contextual.rs  |  183 ++
 crates/ui-egui/src/ribbon/controls.rs    |  270 +++
 crates/ui-egui/src/ribbon/data.rs        |  139 ++
 crates/ui-egui/src/ribbon/formulas.rs    |  202 ++
 crates/ui-egui/src/ribbon/galleries.rs   |  145 ++
 crates/ui-egui/src/ribbon/home.rs        |  813 +++++++
 crates/ui-egui/src/ribbon/insert.rs      |  245 ++
 crates/ui-egui/src/ribbon/page_layout.rs |  158 ++
 crates/ui-egui/src/ribbon/review.rs      |   82 +
 crates/ui-egui/src/ribbon/shortcuts.rs   |  112 +
 crates/ui-egui/src/ribbon/title_bar.rs   |  274 +++
 crates/ui-egui/src/ribbon/view.rs        |  182 ++
 14 files changed, 2868 insertions(+), 2794 deletions(-)
 create mode 100644 crates/ui-egui/src/ribbon/automate.rs
 create mode 100644 crates/ui-egui/src/ribbon/contextual.rs
 create mode 100644 crates/ui-egui/src/ribbon/controls.rs
 create mode 100644 crates/ui-egui/src/ribbon/data.rs
 create mode 100644 crates/ui-egui/src/ribbon/formulas.rs
 create mode 100644 crates/ui-egui/src/ribbon/galleries.rs
 create mode 100644 crates/ui-egui/src/ribbon/home.rs
 create mode 100644 crates/ui-egui/src/ribbon/insert.rs
 create mode 100644 crates/ui-egui/src/ribbon/page_layout.rs
 create mode 100644 crates/ui-egui/src/ribbon/review.rs
 create mode 100644 crates/ui-egui/src/ribbon/shortcuts.rs
 create mode 100644 crates/ui-egui/src/ribbon/title_bar.rs
 create mode 100644 crates/ui-egui/src/ribbon/view.rs

diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index 37cb2a844..49aba2b0e 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -10,207 +10,39 @@ use crate::keytips::keytip_table;
 use crate::theme::{self, Cat, Tokens};
 use crate::widgets::{big_button, big_split_button, color_palette, icon_button, small_button, small_split_button, split_button, toggle_button};
 
+mod automate;
+mod contextual;
+mod controls;
+mod data;
+mod formulas;
+mod galleries;
+mod home;
+mod insert;
+mod page_layout;
+mod review;
+mod shortcuts;
+mod title_bar;
+mod view;
+
+use automate::automate;
+use contextual::{chart_design, table_design};
+pub(crate) use controls::{ComboResult, editable_combo};
+use controls::{act, keytip};
+use data::data;
+use formulas::formulas;
+pub use home::FONTS;
+use home::home;
+use insert::{draw, insert};
+use page_layout::page_layout;
+use review::review;
+pub use shortcuts::shortcut;
+pub use title_bar::{MAC_CONTENT_LEFT, MAC_TITLE_BAR, TITLE_LEFT_PAD, title_bar};
+use title_bar::{TITLE_BAR_H, TITLE_CONTROL_H};
+use view::view;
+
 pub const TABS: &[&str] = &["Home", "Insert", "Draw", "Page Layout", "Formulas", "Data", "Review", "View", "Automate"];
-
-/// macOS draws the window into the title bar (`with_fullsize_content_view`) and AppKit paints the
-/// traffic lights itself, centred in its standard 28 pt title-bar band. Moving them would take
-/// AppKit calls (`unsafe`, forbidden here), so on macOS the title bar is that band: the lights sit
-/// vertically centred in it, with the controls beside them (#170).
-const MAC: bool = cfg!(target_os = "macos");
-pub const MAC_TITLE_BAR: f32 = 28.0;
-/// The traffic lights as AppKit lays them out: button diameter, centre-to-centre pitch and the
-/// first button's left edge (8–10 pt depending on the macOS version; the larger value keeps the
-/// gap after them from shrinking).
-const MAC_LIGHT: f32 = 12.0;
-const MAC_LIGHT_PITCH: f32 = 20.0;
-const MAC_LIGHTS_LEFT: f32 = 10.0;
-/// Where title-bar content starts on macOS: the end of the three lights plus the gap the lights
-/// keep from the top of the window.
-pub const MAC_CONTENT_LEFT: f32 = MAC_LIGHTS_LEFT + 2.0 * MAC_LIGHT_PITCH + MAC_LIGHT + (MAC_TITLE_BAR - MAC_LIGHT) / 2.0;
-
-/// Leave room for the macOS traffic lights when the content extends into the title bar.
-pub const TITLE_LEFT_PAD: f32 = if MAC { MAC_CONTENT_LEFT } else { 8.0 };
-const TITLE_BAR_H: f32 = if MAC { MAC_TITLE_BAR } else { 38.0 };
-/// The tallest title-bar controls, smaller on macOS to keep a margin in the shorter bar.
-const TITLE_CONTROL_H: f32 = if MAC { 22.0 } else { 26.0 };
 const _: () = assert!(TITLE_CONTROL_H < TITLE_BAR_H, "title-bar controls keep a margin above and below");
 
-/// Draws the title bar: drag/maximize, AutoSave toggle, Home/Save/Undo/Redo/More, search, share, comments and theme controls, with a centered truncated title.
-pub fn title_bar(app: &mut SheetApp, ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    let ch = TITLE_CONTROL_H;
-    egui::Panel::top("title_bar").exact_size(TITLE_BAR_H).frame(egui::Frame::NONE.fill(t.window)).show(ui, |ui| {
-        let rect = ui.max_rect();
-        // Dragging the empty title area moves the window.
-        let bg = ui.interact(rect, ui.scope_id().with("drag_title"), Sense::click_and_drag());
-        if bg.drag_started() {
-            ui.ctx().send_viewport_cmd(egui::ViewportCommand::StartDrag);
-        }
-        if bg.double_clicked() {
-            let max = ui.ctx().input(|i| i.viewport().maximized.unwrap_or(false));
-            ui.ctx().send_viewport_cmd(egui::ViewportCommand::Maximized(!max));
-        }
-        ui.horizontal_centered(|ui| {
-            ui.add_space(TITLE_LEFT_PAD);
-            // AutoSave toggle (saves after each change when the workbook has a file).
-            ui.label(egui::RichText::new(app.ui.language.tr("AutoSave")).font(theme::ui_font(12.5)).color(t.text_dim));
-            let on = app.ui.autosave;
-            let (r, resp) = ui.allocate_exact_size(vec2(30.0, 16.0), Sense::click());
-            ui.painter().rect_filled(r, 8.0, if on { t.accent } else { Color32::TRANSPARENT });
-            ui.painter().rect_stroke(r, 8.0, Stroke::new(1.0, if on { t.accent } else { t.text_dim }), StrokeKind::Inside);
-            let knob = if on { pos2(r.right() - 8.0, r.center().y) } else { pos2(r.left() + 8.0, r.center().y) };
-            ui.painter().circle_filled(knob, 5.0, if on { t.on_accent } else { t.text_dim });
-            if resp.on_hover_text(app.ui.language.tr("AutoSave: save after every change (workbooks saved to a file)")).clicked() {
-                app.toggle_autosave();
-            }
-            ui.add_space(6.0);
-            let __k = icon_button(ui, Icon::Home, t.text_dim, "Home", vec2(26.0, ch));
-            control_keytip(app, ui, &__k, "start");
-            if __k.clicked() {
-                app.open_dialog("start", json!({}));
-            }
-            if icon_button(ui, Icon::Save, t.text_dim, "Save", vec2(26.0, ch)).clicked()
-                // File operations must include the cell the user is still editing (as the File > Save menu item already does).
-                && app.commit_edit(0, 0, false, false)
-            {
-                app.run_or_alert("file.save", json!({}));
-            }
-            // The commands' own availability: there must be a step, and no undo group may be open on
-            // the document (an action that spans several calls is still running).
-            let can_undo = gridcraft_engine::cmd::can_undo(&app.session).is_ok();
-            let can_redo = gridcraft_engine::cmd::can_redo(&app.session).is_ok();
-            // Named and marked enabled or not for assistive technology (and the UI tests).
-            let undo = icon_button(ui, Icon::Undo, if can_undo { t.text_dim } else { t.text_disabled }, "Undo", vec2(26.0, ch));
-            undo.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, can_undo, "Undo"));
-            if undo.clicked() && can_undo {
-                app.run_or_alert("edit.undo", json!({}));
-            }
-            let undo_list = icon_button(ui, Icon::Chevron, t.text_dim, "Undo list", vec2(14.0, ch));
-            egui::Popup::menu(&undo_list).show(|ui| {
-                let labels: Vec<String> = if can_undo {
-                    app.session.active().map(|d| d.undo.iter().rev().take(20).map(|e| e.label.clone()).collect()).unwrap_or_default()
-                } else {
-                    Vec::new()
-                };
-                if labels.is_empty() {
-                    ui.label("Can't Undo");
-                }
-                for (i, l) in labels.iter().enumerate() {
-                    if ui.button(format!("Undo {l}")).clicked() {
-                        app.run_or_alert("edit.undo", json!({"steps": i + 1}));
-                    }
-                }
-            });
-            let redo = icon_button(ui, Icon::Redo, if can_redo { t.text_dim } else { t.text_disabled }, "Redo", vec2(26.0, ch));
-            redo.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, can_redo, "Redo"));
-            if redo.clicked() && can_redo {
-                app.run_or_alert("edit.redo", json!({}));
-            }
-            let more = icon_button(ui, Icon::More, t.text_dim, "More commands", vec2(26.0, ch));
-            egui::Popup::menu(&more).show(|ui| {
-                for (label, id) in [
-                    ("New Workbook", "file.new"),
-                    ("Open…", "file.open"),
-                    ("Save As…", "file.saveAs"),
-                    ("Sort A to Z", "data.sortAscending"),
-                    ("Calculate Now", "formulas.calculateNow"),
-                ] {
-                    if ui.button(label).clicked() {
-                        app.run_or_alert(id, json!({}));
-                    }
-                }
-                if ui.button("Print…").clicked() {
-                    app.print_now(json!({}));
-                }
-            });
-            let left_end = ui.min_rect().right();
-            let right = ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                ui.add_space(8.0);
-                let __k = icon_button(ui, Icon::Search, t.text_dim, "Search commands", vec2(28.0, ch));
-                control_keytip(app, ui, &__k, "commandSearch");
-                if __k.clicked() {
-                    app.open_dialog("commandSearch", json!({}));
-                }
-                let share = small_button(ui, Icon::Share, "Share", "Share: export or save a copy", true);
-                egui::Popup::menu(&share).show(|ui| {
-                    if ui.button("Export as PDF…").clicked() {
-                        app.run_or_alert("file.exportPdf", json!({}));
-                    }
-                    for (label, fmt) in
-                        [("Save a Copy as Excel Workbook (.xlsx)…", "xlsx"), ("Export as CSV…", "csv"), ("Export as Web Page (.html)…", "html")]
-                    {
-                        if ui.button(label).clicked() {
-                            app.open_dialog("saveCopy", json!({"format": fmt}));
-                        }
-                    }
-                });
-                let __k = icon_button(ui, Icon::Comment, t.text_dim, "Comments", vec2(28.0, ch));
-                control_keytip(app, ui, &__k, "comments");
-                if __k.clicked() {
-                    app.open_dialog("comments", json!({}));
-                }
-                // Quick light/dark switch (#194); right-click offers System as well. The same
-                // choice lives in File › Display theme and the View tab.
-                let lang = app.ui.language;
-                let theme = icon_button(ui, Icon::Appearance, t.text_dim, "Dark Mode", vec2(28.0, 26.0));
-                let dark = ui.ctx().theme() == egui::Theme::Dark;
-                theme.widget_info(|| egui::WidgetInfo::selected(egui::Role::CheckBox, true, dark, lang.tr("Dark Mode")));
-                if theme.clicked() {
-                    act(app, "view.darkMode", json!({}));
-                }
-                theme.context_menu(|ui| theme_choices(app, ui));
-                ui.min_rect().left()
-            });
-            // Centred title, cut with "…" so it never runs under the controls on either side.
-            let title = app.session.active().map(|d| d.display_title()).unwrap_or_default();
-            let dirty = app.session.active().is_some_and(|d| d.is_dirty());
-            let max_w = title_max_width(rect.center().x, left_end, right.inner);
-            paint_title(ui, rect.center(), &title, dirty, max_w, t.text);
-        });
-    });
-}
-
-/// Lay out the title truncated to fit `max_w` together with the unsaved marker (when `dirty`).
-fn title_galleys(
-    painter: &egui::Painter,
-    title: &str,
-    dirty: bool,
-    max_w: f32,
-    color: Color32,
-) -> (std::sync::Arc<egui::Galley>, Option<std::sync::Arc<egui::Galley>>) {
-    let font = theme::ui_bold(13.0);
-    let dot = dirty.then(|| painter.layout_no_wrap(" •".to_string(), font.clone(), color));
-    let dot_w = dot.as_ref().map_or(0.0, |g| g.size().x);
-    let mut job = egui::text::LayoutJob::simple_singleline(title.to_string(), font, color);
-    job.wrap = egui::text::TextWrapping::truncate_at_width((max_w - dot_w).max(0.0));
-    (painter.layout_job(job), dot)
-}
-
-/// Gap kept between the title and the controls beside it.
-const TITLE_GAP: f32 = 12.0;
-
-/// The widest the centred title may be without reaching the controls that end at `left_end` or
-/// start at `right_start`.
-fn title_max_width(center_x: f32, left_end: f32, right_start: f32) -> f32 {
-    let half = (center_x - left_end).min(right_start - center_x) - TITLE_GAP;
-    (2.0 * half).max(0.0)
-}
-
-/// Paint the workbook title centred on `center`, truncated with "…" to `max_w`. The unsaved
-/// marker stays visible however short the title gets.
-fn paint_title(ui: &Ui, center: egui::Pos2, title: &str, dirty: bool, max_w: f32, color: Color32) {
-    let (galley, dot) = title_galleys(ui.painter(), title, dirty, max_w, color);
-    let dot_w = dot.as_ref().map_or(0.0, |g| g.size().x);
-    let w = galley.size().x + dot_w;
-    let left = center.x - w / 2.0;
-    let top = center.y - galley.size().y / 2.0;
-    let galley_w = galley.size().x;
-    ui.painter().galley(pos2(left, top), galley, color);
-    if let Some(dot) = dot {
-        ui.painter().galley(pos2(left + galley_w, top), dot, color);
-    }
-}
-
 /// Draws the ribbon tabs and the active tab's horizontally scrollable card, resetting an unavailable contextual tab to Home.
 pub fn show(app: &mut SheetApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
@@ -459,2599 +291,3 @@ fn contextual_tabs(app: &SheetApp) -> Vec<&'static str> {
     }
     v
 }
-
-fn sep(ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    let (r, _) = ui.allocate_exact_size(vec2(13.0, 72.0), Sense::hover());
-    ui.painter().line_segment([pos2(r.center().x, r.top() + 6.0), pos2(r.center().x, r.bottom() - 6.0)], Stroke::new(1.0, t.separator));
-}
-
-fn active_style(app: &SheetApp) -> Style {
-    app.session
-        .active()
-        .and_then(|d| {
-            let sh = d.wb.active()?;
-            Some(d.wb.styles.get(sh.style_id(d.selection.active)).clone())
-        })
-        .unwrap_or_default()
-}
-
-fn theme_colors(app: &SheetApp) -> [u32; 12] {
-    app.session.active().map(|d| d.wb.theme.colors).unwrap_or(gridcraft_engine::model::Theme::default().colors)
-}
-
-/// Runs a command from a ribbon click (menu-style: no params may open a dialog).
-fn act(app: &mut SheetApp, id: &str, params: serde_json::Value) {
-    app.run_or_alert(id, params);
-}
-
-/// How many cells Formulas › Error Checking › Circular References lists.
-const CIRCULAR_MENU_LIMIT: usize = 100;
-
-/// The cell listed for each circular reference, for the Circular References submenu: each once, in the order
-/// the calculation found them, as (sheet index, cell, "Sheet!A1").
-fn circular_references(app: &SheetApp) -> Vec<(usize, String, String)> {
-    let Some(d) = app.session.active() else { return Vec::new() };
-    let mut seen = std::collections::HashSet::new();
-    d.calc
-        .circular
-        .iter()
-        .filter(|k| seen.insert(**k))
-        .filter_map(|(si, c)| d.wb.sheet(*si).map(|sh| (*si, c.a1(), format!("{}!{}", gridcraft_engine::formula::quote_sheet(&sh.name), c.a1()))))
-        .take(CIRCULAR_MENU_LIMIT)
-        .collect()
-}
-
-/// Keytips are painted, not focusable widgets: the grid retains keyboard focus.
-fn keytip(app: &SheetApp, ui: &Ui, sequence: &str, at: egui::Pos2) {
-    let Some(rest) = app.keytips.prefix().and_then(|prefix| sequence.strip_prefix(prefix)).filter(|s| !s.is_empty()) else { return };
-    let t = Tokens::get(ui.ctx());
-    let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("ribbon_keytips"))).with_clip_rect(ui.clip_rect());
-    let text = painter.layout_no_wrap(rest.into(), theme::ui_bold(10.5), t.text);
-    let rect = Rect::from_center_size(at, text.size() + vec2(7.0, 3.0));
-    painter.rect_filled(rect, 2.0, t.input_bg);
-    painter.rect_stroke(rect, 2.0, Stroke::new(1.0, t.text_dim), StrokeKind::Inside);
-    painter.galley(rect.min + vec2(3.5, 1.5), text, t.text);
-}
-
-/// Paint the badge for a control that runs command `id`, when the armed prefix matches.
-fn control_keytip(app: &SheetApp, ui: &Ui, response: &egui::Response, id: &str) {
-    if let Some(sequence) = keytip_table::control_badge(app.keytips.prefix().unwrap_or_default(), id) {
-        keytip(app, ui, sequence, response.rect.center_bottom());
-    }
-}
-
-/// Paint the single badge for a menu anchor whose popup items run `targets`.
-fn anchor_keytip(app: &SheetApp, ui: &Ui, response: &egui::Response, targets: &[&str]) {
-    if let Some(sequence) = keytip_table::anchor_badge(app.keytips.prefix().unwrap_or_default(), targets) {
-        keytip(app, ui, sequence, response.rect.center_bottom());
-    }
-}
-
-/// The `on` value for a ribbon checkbox command. A click has already flipped the checkbox bool, so
-/// it is sent as is; a key tip leaves the bool untouched, so the command gets the opposite.
-fn checkbox_on(clicked: bool, shown: bool) -> bool {
-    shown == clicked
-}
-
-/// Consume a one-shot keytip request for control `id` (set by `Action::Control`).
-fn invoke(app: &mut SheetApp, id: &str) -> bool {
-    if app.ui.keytip_invoke == Some(id) {
-        app.ui.keytip_invoke = None;
-        true
-    } else {
-        false
-    }
-}
-
-/// Force-open command for a popup: either a keytip invoke (open it) or a click (toggle).
-fn popup_command(forced: bool, clicked: bool) -> Option<egui::SetOpenCommand> {
-    if forced { Some(egui::SetOpenCommand::Bool(true)) } else { clicked.then_some(egui::SetOpenCommand::Toggle) }
-}
-
-/// Per-control state of an [`editable_combo`]: the filter text and highlighted row.
-#[derive(Clone, Default)]
-struct ComboState {
-    text: String,
-    sel: i32,
-    was_open: bool,
-}
-
-/// What the user did with an [`editable_combo`].
-pub(crate) enum ComboResult {
-    None,
-    /// A row was applied: clicked or Enter on the highlighted row.
-    Picked(String),
-}
-
-/// Excel-style dropdown: a filter field (type to narrow the list) plus arrow/Enter selection.
-/// `items` are `(value, display)`; the value is what comes back. When `forced` (keytip invoke)
-/// or clicked, the popup opens, focuses the filter field, and selects its text.
-pub(crate) fn editable_combo(
-    ui: &mut Ui,
-    anchor: &egui::Response,
-    salt: &'static str,
-    current_value: &str,
-    items: &[(&str, String)],
-    forced: bool,
-) -> ComboResult {
-    combo_popup(ui, anchor, salt, current_value, items, forced, true, None)
-}
-
-/// The dropdown of [`editable_combo`] without the filter field: the whole list, picked by click or
-/// arrows and Enter. It drops directly below `under` and is as wide as it, like Excel's Font Size
-/// list under its box.
-fn list_combo(ui: &mut Ui, anchor: &egui::Response, under: Rect, salt: &'static str, current_value: &str, items: &[(&str, String)]) -> ComboResult {
-    combo_popup(ui, anchor, salt, current_value, items, false, false, Some(under))
-}
-
-fn combo_popup(
-    ui: &mut Ui,
-    anchor: &egui::Response,
-    salt: &'static str,
-    current_value: &str,
-    items: &[(&str, String)],
-    forced: bool,
-    filter: bool,
-    under: Option<Rect>,
-) -> ComboResult {
-    let popup_id = anchor.id.with("popup");
-    let state_id = anchor.id.with(salt).with("__combo_state");
-    let mut st = ui.data_mut(|d| d.get_temp::<ComboState>(state_id)).unwrap_or_default();
-    let open_now = egui::Popup::is_id_open(ui.ctx(), popup_id);
-    if open_now && !st.was_open {
-        st.text = String::new();
-        st.sel = items.iter().position(|(v, _)| *v == current_value).map(|i| i as i32).unwrap_or(0);
-        // The reset lands on the frame AFTER the popup opens, which usually has no input of
-        // its own — without a repaint request the stale filtered list stays on screen.
-        ui.ctx().request_repaint();
-    }
-    st.was_open = open_now;
-    let mut result = ComboResult::None;
-    let mut popup = egui::Popup::menu(anchor).open_memory(popup_command(forced, anchor.clicked()));
-    if let Some(r) = under {
-        popup = popup.anchor(r).align(egui::RectAlign::BOTTOM_START).width(r.width());
-    }
-    let row_w = under.map_or(220.0, |r| r.width() - 12.0);
-    popup.show(|ui| {
-        // Arrows and Enter navigate the list, not the filter field's cursor. Capture them and
-        // strip them from the input so the TextEdit never sees them.
-        let (mut down, mut up, mut enter) = (false, false, false);
-        ui.input(|i| {
-            down = i.key_pressed(egui::Key::ArrowDown);
-            up = i.key_pressed(egui::Key::ArrowUp);
-            enter = i.key_pressed(egui::Key::Enter);
-        });
-        if down || up || enter {
-            ui.ctx().input_mut(|i| {
-                i.events.retain(|e| {
-                    !matches!(e, egui::Event::Key { key: egui::Key::ArrowDown | egui::Key::ArrowUp | egui::Key::Enter, pressed: true, .. })
-                });
-            });
-        }
-        if filter {
-            let text_id = anchor.id.with(salt).with("__combo_text");
-            let te = ui.add(egui::TextEdit::singleline(&mut st.text).id(text_id).desired_width(220.0).hint_text("Type to filter…"));
-            if open_now && !te.has_focus() {
-                ui.ctx().memory_mut(|m| m.request_focus(text_id));
-                // Select all once focus lands so typing replaces the filter.
-                if let Some(mut s) = egui::text_edit::TextEditState::load(ui.ctx(), text_id) {
-                    let len = st.text.chars().count();
-                    s.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(len))));
-                    s.store(ui.ctx(), text_id);
-                }
-            }
-        }
-        let lower = st.text.to_lowercase();
-        let filtered: Vec<usize> = items.iter().enumerate().filter(|(_, (_, d))| d.to_lowercase().contains(&lower)).map(|(i, _)| i).collect();
-        if !filtered.is_empty() {
-            let n = filtered.len() as i32;
-            st.sel = st.sel.clamp(0, n - 1);
-            if down {
-                st.sel = (st.sel + 1).rem_euclid(n);
-            }
-            if up {
-                st.sel = (st.sel - 1).rem_euclid(n);
-            }
-        }
-        if enter && !filtered.is_empty() {
-            let idx = filtered[st.sel.clamp(0, filtered.len() as i32 - 1) as usize];
-            result = ComboResult::Picked(items[idx].0.to_string());
-        }
-        if filter {
-            ui.separator();
-        }
-        let button_h = ui.spacing().interact_size.y.max(20.0);
-        let spacing = ui.spacing().item_spacing.y;
-        let n = filtered.len() as f32;
-
-        let content_h = n * button_h + (n - 1.0).max(0.0) * spacing;
-
-        let max_rows = 9.0_f32;
-        let max_h = max_rows * button_h + (max_rows - 1.0) * spacing;
-
-        let desired_h = content_h.min(max_h);
-
-        ui.set_min_height(desired_h);
-
-        egui::ScrollArea::vertical().max_height(desired_h).show(ui, |ui| {
-            for (pos, i) in filtered.iter().enumerate() {
-                let (value, disp) = &items[*i];
-
-                let row = ui.add(egui::Button::selectable(pos as i32 == st.sel, egui::RichText::new(disp)).min_size(vec2(row_w, 20.0)));
-
-                if (down || up) && pos as i32 == st.sel && !ui.clip_rect().contains_rect(row.rect) {
-                    row.scroll_to_me(Some(if down { egui::Align::Max } else { egui::Align::Min }));
-                }
-
-                if row.clicked() {
-                    result = ComboResult::Picked(value.to_string());
-                }
-
-                if row.hovered() {
-                    st.sel = pos as i32;
-                }
-            }
-        });
-        if !matches!(result, ComboResult::None) {
-            ui.close();
-        }
-    });
-    ui.data_mut(|d| d.insert_temp(state_id, st));
-    result
-}
-
-/// The Accounting Number Format dropdown: label and the code Excel applies for that symbol.
-const ACCOUNTING_SYMBOLS: &[(&str, &str)] = &[
-    ("$ English (United States)", "_(\"$\"* #,##0.00_);_(\"$\"* \\(#,##0.00\\);_(\"$\"* \"-\"??_);_(@_)"),
-    ("£ English (United Kingdom)", "_-[$£-809]* #,##0.00_-;-[$£-809]* #,##0.00_-;_-[$£-809]* \"-\"??_-;_-@_-"),
-    ("€ Euro", "_-[$€-x-euro2] * #,##0.00_-;-[$€-x-euro2] * #,##0.00_-;_-[$€-x-euro2] * \"-\"??_-;_-@_-"),
-    ("¥ Japanese", "_-[$¥-411]* #,##0_-;-[$¥-411]* #,##0_-;_-[$¥-411]* \"-\"_-;_-@_-"),
-    ("¥ Chinese (PRC)", "_-[$¥-804]* #,##0.00_-;-[$¥-804]* #,##0.00_-;_-[$¥-804]* \"-\"??_-;_-@_-"),
-    ("₹ English (India)", "_-[$₹-4009]* #,##0.00_-;-[$₹-4009]* #,##0.00_-;_-[$₹-4009]* \"-\"??_-;_-@_-"),
-    ("CHF German (Switzerland)", "_-[$CHF-807]* #,##0.00_-;-[$CHF-807]* #,##0.00_-;_-[$CHF-807]* \"-\"??_-;_-@_-"),
-    ("Rp Indonesian", "_-[$Rp-421]* #,##0.00_-;-[$Rp-421]* #,##0.00_-;_-[$Rp-421]* \"-\"??_-;_-@_-"),
-    ("₩ Korean", "_-[$₩-412]* #,##0_-;-[$₩-412]* #,##0_-;_-[$₩-412]* \"-\"_-;_-@_-"),
-    ("R$ Portuguese (Brazil)", "_-[$R$-416]* #,##0.00_-;-[$R$-416]* #,##0.00_-;_-[$R$-416]* \"-\"??_-;_-@_-"),
-    ("₽ Russian", "_-[$₽-419]* #,##0.00_-;-[$₽-419]* #,##0.00_-;_-[$₽-419]* \"-\"??_-;_-@_-"),
-];
-
-fn menu_items(app: &mut SheetApp, ui: &mut Ui, items: &[(&str, &str, serde_json::Value)]) {
-    for (label, id, p) in items {
-        if *label == "-" {
-            ui.separator();
-            continue;
-        }
-        let lang = app.ui.language;
-        let response = ui.add(egui::Button::new(lang.tr(label)).frame_when_inactive(false).min_size(vec2(220.0, 22.0)));
-        if let Some(sequence) = keytip_table::item_letter(app.keytips.prefix().unwrap_or_default(), id) {
-            keytip(app, ui, sequence, pos2(response.rect.right() - 10.0, response.rect.center().y));
-        }
-        if response.clicked() {
-            if let Some(d) = id.strip_prefix("dialog:") {
-                app.open_dialog(d, p.clone());
-            } else if *id == "edit.paste" {
-                app.paste_from_clipboard();
-            } else {
-                act(app, id, p.clone());
-            }
-        }
-    }
-}
-
-/// Draws the Home tab: clipboard/paste menu, font, alignment, number, style, cell and editing commands with keytips.
-fn home(app: &mut SheetApp, ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    let st = active_style(app);
-    // Clipboard
-    let paste = big_button(ui, Icon::Paste, "Paste", "Paste", true);
-    paste.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Paste"));
-    for sequence in
-        keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["edit.paste", "edit.pasteSpecial", "dialog:pasteSpecial"])
-    {
-        keytip(app, ui, sequence, paste.rect.center_bottom());
-    }
-    if paste.clicked() {
-        app.paste_from_clipboard();
-    }
-    let paste_keys = matches!(app.keytips.prefix(), Some("HV" | "E"));
-    // Keep a keyboard-opened menu anchored to the button when a pointer click
-    // cancels keytips, so its items remain in place and can still be clicked.
-    let anchor_id = paste.id.with("keytip_anchor");
-    // Query response state before taking the egui context write lock.
-    // Calling secondary_clicked() inside data_mut can deadlock.
-    let paste_secondary_clicked = paste.secondary_clicked();
-    let anchored = ui.ctx().data_mut(|data| {
-        let anchored = if paste_keys {
-            true
-        } else if paste_secondary_clicked {
-            false
-        } else {
-            data.get_temp::<bool>(anchor_id).unwrap_or(false)
-        };
-        data.insert_temp(anchor_id, anchored);
-        anchored
-    });
-    let mut paste_popup = egui::Popup::context_menu(&paste);
-    if anchored {
-        paste_popup = paste_popup.anchor(&paste);
-    }
-    if paste_keys {
-        paste_popup = paste_popup.open_memory(egui::SetOpenCommand::Bool(true));
-    }
-    paste_popup.show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Paste", "edit.paste", json!({})),
-                ("Paste Values", "edit.pasteSpecial", json!({"what": "values"})),
-                ("Paste Formulas", "edit.pasteSpecial", json!({"what": "formulas"})),
-                ("Paste Formatting", "edit.pasteSpecial", json!({"what": "formats"})),
-                ("Transpose", "edit.pasteSpecial", json!({"what": "all", "transpose": true})),
-                ("Paste Link", "edit.pasteSpecial", json!({"what": "all", "link": true})),
-                ("-", "", json!(null)),
-                ("Paste Special…", "dialog:pasteSpecial", json!({})),
-            ],
-        );
-    });
-    ui.vertical(|ui| {
-        let __k = icon_button(ui, Icon::Cut, t.text, "Cut", vec2(26.0, 23.0));
-        control_keytip(app, ui, &__k, "edit.cut");
-        if __k.clicked() {
-            app.copy_to_clipboard(ui.ctx(), "edit.cut");
-        }
-        let __k = icon_button(ui, Icon::Copy, t.text, "Copy", vec2(26.0, 23.0));
-        control_keytip(app, ui, &__k, "edit.copy");
-        if __k.clicked() {
-            app.copy_to_clipboard(ui.ctx(), "edit.copy");
-        }
-        let fp_on = app.session.format_painter.is_some();
-        let fp = toggle_button(ui, Icon::Brush, fp_on, "Format Painter (double-click to keep it on)");
-        fp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), fp_on, "Format Painter"));
-        control_keytip(app, ui, &fp, "edit.formatPainter");
-        if fp.double_clicked() {
-            act(app, "edit.formatPainter", json!({"sticky": true}));
-        } else if fp.clicked() {
-            if fp_on {
-                app.session.format_painter = None;
-            } else {
-                act(app, "edit.formatPainter", json!({}));
-            }
-        }
-    });
-    sep(ui);
-    // Font
-    ui.vertical(|ui| {
-        ui.horizontal(|ui| {
-            font_combo(app, ui, &st);
-            size_combo(app, ui, &st);
-            let __k = icon_button(ui, Icon::Plus, t.text, "Increase Font Size", vec2(22.0, 23.0));
-            control_keytip(app, ui, &__k, "home.increaseFontSize");
-            if __k.clicked() {
-                act(app, "home.increaseFontSize", json!({}));
-            }
-            let __k = icon_button(ui, Icon::Minus, t.text, "Decrease Font Size", vec2(22.0, 23.0));
-            control_keytip(app, ui, &__k, "home.decreaseFontSize");
-            if __k.clicked() {
-                act(app, "home.decreaseFontSize", json!({}));
-            }
-        });
-        ui.horizontal(|ui| {
-            let __k = toggle_button(ui, Icon::Bold, st.font.bold, "Bold");
-            control_keytip(app, ui, &__k, "home.bold");
-            if __k.clicked() {
-                act(app, "home.bold", json!({}));
-            }
-            let __k = toggle_button(ui, Icon::Italic, st.font.italic, "Italic");
-            control_keytip(app, ui, &__k, "home.italic");
-            if __k.clicked() {
-                act(app, "home.italic", json!({}));
-            }
-            let (u, ua) = split_button(ui, Icon::Underline, None, "Underline");
-            control_keytip(app, ui, &ua, "home.underline");
-            if u {
-                act(app, "home.underline", json!({}));
-            }
-            egui::Popup::menu(&ua).show(|ui| {
-                menu_items(
-                    app,
-                    ui,
-                    &[
-                        ("Underline", "home.underline", json!({"style": "single"})),
-                        ("Double Underline", "home.underline", json!({"style": "double"})),
-                    ],
-                );
-            });
-            let __k = toggle_button(ui, Icon::Strike, st.font.strike, "Strikethrough");
-            control_keytip(app, ui, &__k, "home.strikethrough");
-            if __k.clicked() {
-                act(app, "home.strikethrough", json!({}));
-            }
-            let (b, ba) = split_button(ui, Icon::Borders, None, "Borders");
-            control_keytip(app, ui, &ba, "home.borders");
-            if b {
-                act(app, "home.borders", json!({"preset": app.grid.last_border.clone()}));
-            }
-            ba.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Border presets"));
-            egui::Popup::menu(&ba).show(|ui| {
-                for (label, preset) in [
-                    ("Bottom Border", "bottom"),
-                    ("Top Border", "top"),
-                    ("Left Border", "left"),
-                    ("Right Border", "right"),
-                    ("No Border", "none"),
-                    ("All Borders", "all"),
-                    ("Outside Borders", "outside"),
-                    ("Thick Outside Borders", "thickOutside"),
-                    ("Bottom Double Border", "doubleBottom"),
-                    ("Thick Bottom Border", "thickBottom"),
-                    ("Top and Bottom Border", "topBottom"),
-                    ("Top and Thick Bottom Border", "topThickBottom"),
-                    ("Top and Double Bottom Border", "topDoubleBottom"),
-                    ("Inside Borders", "inside"),
-                ] {
-                    if crate::border_preview::preset_button(ui, label, preset).clicked() {
-                        app.grid.last_border = preset.to_string();
-                        act(app, "home.borders", json!({"preset": preset}));
-                    }
-                }
-                ui.separator();
-                if ui.button("More Borders…").clicked() {
-                    app.open_dialog("formatCells", json!({"tab": "Border"}));
-                }
-            });
-            let fill = app.grid.last_fill.clone();
-            let fill_c = gridcraft_engine::model::Color::from_hex(&fill).and_then(|c| c.resolve(&Default::default())).map(theme::color32);
-            let (f, fa) = split_button(ui, Icon::Fill, fill_c, "Fill Color");
-            control_keytip(app, ui, &fa, "home.fillColor");
-            if f {
-                act(app, "home.fillColor", json!({"color": fill}));
-            }
-            let forced = invoke(app, "home.fillColor");
-            egui::Popup::menu(&fa)
-                .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
-                .open_memory(popup_command(forced, fa.clicked()))
-                .show(|ui| {
-                    if let Some(c) = color_palette(ui, &theme_colors(app), "No Fill") {
-                        if c != "none" {
-                            app.grid.last_fill = c.clone();
-                        }
-                        act(app, "home.fillColor", json!({"color": c}));
-                        ui.close();
-                    }
-                });
-            let fc = app.grid.last_font_color.clone();
-            let fc_c = gridcraft_engine::model::Color::from_hex(&fc).and_then(|c| c.resolve(&Default::default())).map(theme::color32);
-            let (c, ca) = split_button(ui, Icon::FontColor, fc_c, "Font Color");
-            control_keytip(app, ui, &ca, "home.fontColor");
-            if c {
-                act(app, "home.fontColor", json!({"color": fc}));
-            }
-            let forced = invoke(app, "home.fontColor");
-            egui::Popup::menu(&ca)
-                .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
-                .open_memory(popup_command(forced, ca.clicked()))
-                .show(|ui| {
-                    if let Some(c) = color_palette(ui, &theme_colors(app), "Automatic") {
-                        if c != "none" {
-                            app.grid.last_font_color = c.clone();
-                        }
-                        act(app, "home.fontColor", json!({"color": if c == "none" { "auto".to_string() } else { c }}));
-                        ui.close();
-                    }
-                });
-        });
-    });
-    sep(ui);
-    // Alignment
-    ui.vertical(|ui| {
-        ui.horizontal(|ui| {
-            for (icon, v, id, tip) in [
-                (Icon::AlignTop, VAlign::Top, "home.alignTop", "Top Align"),
-                (Icon::AlignMiddle, VAlign::Center, "home.alignMiddle", "Middle Align"),
-                (Icon::AlignBottom, VAlign::Bottom, "home.alignBottom", "Bottom Align"),
-            ] {
-                let __k = toggle_button(ui, icon, st.align.v == v, tip);
-                control_keytip(app, ui, &__k, id);
-                if __k.clicked() {
-                    act(app, id, json!({}));
-                }
-            }
-            let o = small_button(ui, Icon::Orientation, "", "Orientation", true);
-            control_keytip(app, ui, &o, "home.orientation");
-            let forced_o = invoke(app, "home.orientation");
-            egui::Popup::menu(&o).open_memory(popup_command(forced_o, o.clicked())).show(|ui| {
-                menu_items(
-                    app,
-                    ui,
-                    &[
-                        ("Angle Counterclockwise", "home.orientation", json!({"angle": "counterclockwise"})),
-                        ("Angle Clockwise", "home.orientation", json!({"angle": "clockwise"})),
-                        ("Vertical Text", "home.orientation", json!({"angle": "vertical"})),
-                        ("Rotate Text Up", "home.orientation", json!({"angle": "up"})),
-                        ("Rotate Text Down", "home.orientation", json!({"angle": "down"})),
-                        ("Horizontal", "home.orientation", json!({"angle": 0})),
-                        ("-", "", json!(null)),
-                        ("Format Cell Alignment…", "dialog:formatCells", json!({"tab": "Alignment"})),
-                    ],
-                );
-            });
-            let wrap = toggle_button(ui, Icon::Wrap, st.align.wrap, "Wrap Text");
-            control_keytip(app, ui, &wrap, "home.wrapText");
-            if wrap.clicked() {
-                act(app, "home.wrapText", json!({}));
-            }
-            ui.label(egui::RichText::new(app.ui.language.tr("Wrap Text")).font(theme::ui_font(12.5)));
-        });
-        ui.horizontal(|ui| {
-            for (icon, h, id, tip) in [
-                (Icon::AlignLeft, HAlign::Left, "home.alignLeft", "Align Left"),
-                (Icon::AlignCenter, HAlign::Center, "home.alignCenter", "Center"),
-                (Icon::AlignRight, HAlign::Right, "home.alignRight", "Align Right"),
-            ] {
-                let response = toggle_button(ui, icon, st.align.h == h, tip);
-                for sequence in keytip_table::control_badges(app.keytips.prefix().unwrap_or_default(), id) {
-                    keytip(app, ui, sequence, response.rect.center_bottom());
-                }
-                if response.clicked() {
-                    act(app, id, json!({}));
-                }
-            }
-            let __k = icon_button(ui, Icon::IndentDec, t.text, "Decrease Indent", vec2(24.0, 23.0));
-            control_keytip(app, ui, &__k, "home.decreaseIndent");
-            if __k.clicked() {
-                act(app, "home.decreaseIndent", json!({}));
-            }
-            let __k = icon_button(ui, Icon::IndentInc, t.text, "Increase Indent", vec2(24.0, 23.0));
-            control_keytip(app, ui, &__k, "home.increaseIndent");
-            if __k.clicked() {
-                act(app, "home.increaseIndent", json!({}));
-            }
-            let (m, ma) = split_button(ui, Icon::Merge, None, "Merge & Center");
-            control_keytip(app, ui, &ma, "home.mergeCenter");
-            if m {
-                act(app, "home.mergeCenter", json!({}));
-            }
-            ui.label(egui::RichText::new(app.ui.language.tr("Merge & Center")).font(theme::ui_font(12.5)));
-            egui::Popup::menu(&ma).show(|ui| {
-                menu_items(
-                    app,
-                    ui,
-                    &[
-                        ("Merge & Center", "home.mergeCenter", json!({})),
-                        ("Merge Across", "home.mergeAcross", json!({})),
-                        ("Merge Cells", "home.mergeCells", json!({})),
-                        ("Unmerge Cells", "home.unmergeCells", json!({})),
-                    ],
-                );
-            });
-        });
-    });
-    sep(ui);
-    // Number
-    ui.vertical(|ui| {
-        number_combo(app, ui, &st);
-        ui.horizontal(|ui| {
-            let (c, ca) = split_button(ui, Icon::Currency, None, "Accounting Number Format");
-            control_keytip(app, ui, &ca, "home.accounting");
-            if c {
-                act(app, "home.accounting", json!({}));
-            }
-            egui::Popup::menu(&ca).show(|ui| {
-                let mut items: Vec<_> = ACCOUNTING_SYMBOLS.iter().map(|(label, code)| (*label, "home.numberFormat", json!({"code": code}))).collect();
-                items.push(("-", "", json!(null)));
-                items.push(("More Accounting Formats…", "dialog:formatCells", json!({"tab": "Number"})));
-                menu_items(app, ui, &items);
-            });
-            let __k = icon_button(ui, Icon::Percent, t.text, "Percent Style", vec2(24.0, 23.0));
-            control_keytip(app, ui, &__k, "home.percent");
-            if __k.clicked() {
-                act(app, "home.percent", json!({}));
-            }
-            let __k = icon_button(ui, Icon::Comma, t.text, "Comma Style", vec2(24.0, 23.0));
-            control_keytip(app, ui, &__k, "home.comma");
-            if __k.clicked() {
-                act(app, "home.comma", json!({}));
-            }
-            let __k = icon_button(ui, Icon::DecInc, t.text, "Increase Decimal", vec2(26.0, 23.0));
-            control_keytip(app, ui, &__k, "home.increaseDecimal");
-            if __k.clicked() {
-                act(app, "home.increaseDecimal", json!({}));
-            }
-            let __k = icon_button(ui, Icon::DecDec, t.text, "Decrease Decimal", vec2(26.0, 23.0));
-            control_keytip(app, ui, &__k, "home.decreaseDecimal");
-            if __k.clicked() {
-                act(app, "home.decreaseDecimal", json!({}));
-            }
-        });
-    });
-    sep(ui);
-    // Styles
-    let cf = big_button(ui, Icon::CondFormat, "Conditional\nFormatting", "Conditional Formatting", true);
-    anchor_keytip(app, ui, &cf, &["home.conditionalFormat", "home.manageRules", "home.clearRules"]);
-    egui::Popup::menu(&cf).show(|ui| cf_menu(app, ui));
-    let ft = big_button(ui, Icon::FormatTable, "Format\nas Table", "Format as Table", true);
-    anchor_keytip(app, ui, &ft, &["table.style"]);
-    egui::Popup::menu(&ft).show(|ui| table_gallery(app, ui, "home.formatAsTable"));
-    let cs = big_button(ui, Icon::CellStyles, "Cell\nStyles", "Cell Styles", true);
-    anchor_keytip(app, ui, &cs, &["home.newCellStyle"]);
-    egui::Popup::menu(&cs).show(|ui| cell_style_gallery(app, ui));
-    sep(ui);
-    // Cells
-    ui.vertical(|ui| {
-        let ins = small_button(ui, Icon::Insert, "Insert", "Insert", true);
-        for sequence in keytip_table::group_extension(
-            app.keytips.prefix().unwrap_or_default(),
-            &["dialog:insertCells", "home.insertRows", "home.insertColumns", "home.insertSheet"],
-        ) {
-            keytip(app, ui, sequence, ins.rect.center_bottom());
-        }
-        egui::Popup::menu(&ins).show(|ui| {
-            menu_items(
-                app,
-                ui,
-                &[
-                    ("Insert Cells…", "dialog:insertCells", json!({})),
-                    ("Insert Sheet Rows", "home.insertRows", json!({})),
-                    ("Insert Sheet Columns", "home.insertColumns", json!({})),
-                    ("Insert Sheet", "home.insertSheet", json!({})),
-                ],
-            );
-        });
-        let del = small_button(ui, Icon::Delete, "Delete", "Delete", true);
-        for sequence in keytip_table::group_extension(
-            app.keytips.prefix().unwrap_or_default(),
-            &["dialog:deleteCells", "home.deleteRows", "home.deleteColumns", "home.deleteSheet"],
-        ) {
-            keytip(app, ui, sequence, del.rect.center_bottom());
-        }
-        egui::Popup::menu(&del).show(|ui| {
-            menu_items(
-                app,
-                ui,
-                &[
-                    ("Delete Cells…", "dialog:deleteCells", json!({})),
-                    ("Delete Sheet Rows", "home.deleteRows", json!({})),
-                    ("Delete Sheet Columns", "home.deleteColumns", json!({})),
-                    ("Delete Sheet", "home.deleteSheet", json!({})),
-                ],
-            );
-        });
-        let fmt = small_button(ui, Icon::Format, "Format", "Format", true);
-        for sequence in keytip_table::group_extension(
-            app.keytips.prefix().unwrap_or_default(),
-            &[
-                "dialog:rowHeight",
-                "home.autofitRowHeight",
-                "dialog:columnWidth",
-                "home.autofitColumnWidth",
-                "dialog:defaultWidth",
-                "home.hideRows",
-                "home.hideColumns",
-                "home.unhideRows",
-                "home.unhideColumns",
-                "sheet.hide",
-                "sheet.unhide",
-                "dialog:renameSheet",
-                "dialog:moveSheet",
-                "dialog:protectSheet",
-                "home.lockCell",
-                "dialog:formatCells",
-            ],
-        ) {
-            keytip(app, ui, sequence, fmt.rect.center_bottom());
-        }
-        let format_keys = matches!(app.keytips.prefix(), Some("HO" | "OC"));
-        let mut format_popup = egui::Popup::menu(&fmt);
-        if format_keys {
-            format_popup = format_popup.open_memory(egui::SetOpenCommand::Bool(true));
-        }
-        let protect_label = if app.active_sheet_protected() { "Unprotect Sheet…" } else { "Protect Sheet…" };
-        format_popup.show(|ui| {
-            menu_items(
-                app,
-                ui,
-                &[
-                    ("Row Height…", "dialog:rowHeight", json!({})),
-                    ("AutoFit Row Height", "home.autofitRowHeight", json!({})),
-                    ("Column Width…", "dialog:columnWidth", json!({})),
-                    ("AutoFit Column Width", "home.autofitColumnWidth", json!({})),
-                    ("Default Width…", "dialog:defaultWidth", json!({})),
-                    ("-", "", json!(null)),
-                    ("Hide Rows", "home.hideRows", json!({})),
-                    ("Hide Columns", "home.hideColumns", json!({})),
-                    ("Unhide Rows", "home.unhideRows", json!({})),
-                    ("Unhide Columns", "home.unhideColumns", json!({})),
-                    ("Hide Sheet", "sheet.hide", json!({})),
-                    ("Unhide Sheet…", "sheet.unhide", json!({})),
-                    ("-", "", json!(null)),
-                    ("Rename Sheet", "dialog:renameSheet", json!({})),
-                    ("Move or Copy Sheet…", "dialog:moveSheet", json!({})),
-                    ("-", "", json!(null)),
-                    (protect_label, "dialog:protectSheet", json!({})),
-                    ("Lock Cell", "home.lockCell", json!({})),
-                    ("Format Cells…", "dialog:formatCells", json!({})),
-                ],
-            );
-        });
-    });
-    sep(ui);
-    // Editing
-    ui.vertical(|ui| {
-        ui.horizontal(|ui| {
-            let (s, sa) = split_button(ui, Icon::Sum, None, "AutoSum");
-            control_keytip(app, ui, &sa, "formulas.autoSum");
-            if s {
-                act(app, "formulas.autoSum", json!({}));
-            }
-            egui::Popup::menu(&sa).show(|ui| autosum_menu(app, ui));
-        });
-        let fill = small_button(ui, Icon::FillDown, "", "Fill", true);
-        for sequence in keytip_table::group_extension(
-            app.keytips.prefix().unwrap_or_default(),
-            &["edit.fillDown", "edit.fillRight", "edit.fillUp", "edit.fillLeft", "dialog:series", "edit.flashFill"],
-        ) {
-            keytip(app, ui, sequence, fill.rect.center_bottom());
-        }
-        egui::Popup::menu(&fill).show(|ui| {
-            menu_items(
-                app,
-                ui,
-                &[
-                    ("Down", "edit.fillDown", json!({})),
-                    ("Right", "edit.fillRight", json!({})),
-                    ("Up", "edit.fillUp", json!({})),
-                    ("Left", "edit.fillLeft", json!({})),
-                    ("Series…", "dialog:series", json!({})),
-                    ("Flash Fill", "edit.flashFill", json!({})),
-                ],
-            );
-        });
-        let clear = small_button(ui, Icon::Eraser, "", "Clear", true);
-        for sequence in keytip_table::group_extension(
-            app.keytips.prefix().unwrap_or_default(),
-            &["edit.clearAll", "edit.clearFormats", "edit.clearContents", "edit.clearComments", "edit.clearHyperlinks"],
-        ) {
-            keytip(app, ui, sequence, clear.rect.center_bottom());
-        }
-        egui::Popup::menu(&clear).show(|ui| {
-            menu_items(
-                app,
-                ui,
-                &[
-                    ("Clear All", "edit.clearAll", json!({})),
-                    ("Clear Formats", "edit.clearFormats", json!({})),
-                    ("Clear Contents", "edit.clearContents", json!({})),
-                    ("Clear Comments and Notes", "edit.clearComments", json!({})),
-                    ("Clear Hyperlinks", "edit.clearHyperlinks", json!({})),
-                ],
-            );
-        });
-    });
-    let sf = big_button(ui, Icon::SortFilter, "Sort &\nFilter", "Sort & Filter", true);
-    for sequence in keytip_table::group_extension(
-        app.keytips.prefix().unwrap_or_default(),
-        &["data.sortAscending", "data.sortDescending", "dialog:sort", "data.filter", "data.clearFilter", "data.reapply"],
-    ) {
-        keytip(app, ui, sequence, sf.rect.center_bottom());
-    }
-    egui::Popup::menu(&sf).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Sort A to Z", "data.sortAscending", json!({})),
-                ("Sort Z to A", "data.sortDescending", json!({})),
-                ("Custom Sort…", "dialog:sort", json!({})),
-                ("-", "", json!(null)),
-                ("Filter", "data.filter", json!({})),
-                ("Clear", "data.clearFilter", json!({})),
-                ("Reapply", "data.reapply", json!({})),
-            ],
-        );
-    });
-    let fs = big_button(ui, Icon::Find, "Find &\nSelect", "Find & Select", true);
-    for sequence in keytip_table::group_extension(
-        app.keytips.prefix().unwrap_or_default(),
-        &["dialog:find", "dialog:goTo", "dialog:goToSpecial", "edit.goToSpecial"],
-    ) {
-        keytip(app, ui, sequence, fs.rect.center_bottom());
-    }
-    egui::Popup::menu(&fs).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Find…", "dialog:find", json!({})),
-                ("Replace…", "dialog:find", json!({"replace": true})),
-                ("Go To…", "dialog:goTo", json!({})),
-                ("Go To Special…", "dialog:goToSpecial", json!({})),
-                ("-", "", json!(null)),
-                ("Formulas", "edit.goToSpecial", json!({"kind": "formulas"})),
-                ("Notes", "edit.goToSpecial", json!({"kind": "notes"})),
-                ("Conditional Formatting", "edit.goToSpecial", json!({"kind": "conditionalFormats"})),
-                ("Constants", "edit.goToSpecial", json!({"kind": "constants"})),
-                ("Data Validation", "edit.goToSpecial", json!({"kind": "dataValidation"})),
-            ],
-        );
-    });
-}
-
-/// The AutoSum menu (Home › Editing and Formulas › Function Library): a function, or the Insert
-/// Function dialog.
-fn autosum_menu(app: &mut SheetApp, ui: &mut Ui) {
-    for f in ["SUM", "AVERAGE", "COUNT", "MAX", "MIN"] {
-        if ui.button(f).clicked() {
-            act(app, "formulas.autoSum", json!({"function": f}));
-        }
-    }
-    ui.separator();
-    if ui.button("More Functions…").clicked() {
-        app.open_dialog("insertFunction", json!({}));
-    }
-}
-
-fn font_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
-    let name = st.font.name.clone();
-    let resp = ui.add_sized([150.0, 24.0], egui::Button::new(egui::RichText::new(&name).font(theme::ui_font(12.5))));
-    control_keytip(app, ui, &resp, "home.fontName");
-    let forced = invoke(app, "home.fontName");
-    let items: Vec<(&str, String)> = FONTS.iter().map(|f| (*f, f.to_string())).collect();
-    if let ComboResult::Picked(value) = editable_combo(ui, &resp, "font", &name, &items, forced) {
-        act(app, "home.fontName", json!({"name": value}));
-    }
-}
-
-pub const FONTS: &[&str] = &[
-    "Aptos",
-    "Aptos Narrow",
-    "Arial",
-    "Calibri",
-    "Cambria",
-    "Candara",
-    "Consolas",
-    "Courier New",
-    "Garamond",
-    "Georgia",
-    "Helvetica",
-    "Helvetica Neue",
-    "Segoe UI",
-    "Tahoma",
-    "Times New Roman",
-    "Trebuchet MS",
-    "Verdana",
-];
-
-/// Excel's size box: type a size and press Enter to apply exactly that number (the command refuses
-/// sizes outside 1 to 409), Escape or clicking away reverts; the arrow opens the standard sizes.
-fn size_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
-    let t = Tokens::get(ui.ctx());
-    let size = st.font.size;
-    let current = if size.fract() == 0.0 { format!("{}", size as i32) } else { format!("{size}") };
-    let field = egui::Id::unique("gridcraft.font_size_box");
-    let draft = field.with("draft");
-    let mut text = ui.data_mut(|d| d.get_temp::<String>(draft)).unwrap_or_else(|| current.clone());
-    // One frame like the Font name box beside it (same fill, border, height and corners), with the
-    // text field and the dropdown arrow inside it, as in Excel.
-    let (frame, _) = ui.allocate_exact_size(vec2(52.0, 24.0), egui::Sense::hover());
-    // Painted once the field's focus and hover are known, but beneath the field and the arrow.
-    let bg = ui.painter().add(egui::Shape::Noop);
-    let text_rect = Rect::from_min_max(frame.min, egui::pos2(frame.right() - 16.0, frame.bottom()));
-    let arrow_rect = Rect::from_min_max(egui::pos2(frame.right() - 16.0, frame.top() + 1.0), egui::pos2(frame.right() - 1.0, frame.bottom() - 1.0));
-    let mut field_ui =
-        ui.new_child(egui::UiBuilder::new().max_rect(text_rect.shrink2(vec2(6.0, 0.0))).layout(egui::Layout::left_to_right(egui::Align::Center)));
-    let out = egui::TextEdit::singleline(&mut text)
-        .id(field)
-        .font(theme::ui_font(12.5))
-        .frame(egui::Frame::NONE)
-        .desired_width(text_rect.width() - 12.0)
-        .show(&mut field_ui);
-    let resp = out.response;
-    ui.ctx().accesskit_node_builder(resp.id, |node| node.set_label(app.ui.language.tr("Font Size")));
-    control_keytip(app, ui, &resp, "home.fontSize");
-    if invoke(app, "home.fontSize") {
-        ui.memory_mut(|m| m.request_focus(field));
-    }
-    if resp.gained_focus() {
-        // Typing replaces the size, as in Excel, whether the box was clicked or reached by keytip.
-        let mut state = out.state;
-        state.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(text.chars().count()))));
-        state.store(ui.ctx(), field);
-    }
-    if resp.lost_focus() {
-        ui.data_mut(|d| d.remove::<String>(draft));
-        // Consume the Enter so the grid behind does not also move the active cell down.
-        if ui.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Enter))
-            && let Some(v) = text.trim().parse::<f64>().ok().filter(|v| v.is_finite())
-        {
-            act(app, "home.fontSize", json!({"size": v}));
-        }
-    } else if resp.has_focus() {
-        ui.data_mut(|d| d.insert_temp(draft, text));
-    } else {
-        ui.data_mut(|d| d.remove::<String>(draft));
-    }
-    let mut arrow_ui = ui.new_child(egui::UiBuilder::new().max_rect(arrow_rect));
-    let arrow = icon_button(&mut arrow_ui, Icon::Chevron, t.text_dim, "Font Size", arrow_rect.size());
-    let visuals = ui.style().visuals.clone();
-    let looks = if resp.has_focus() || ui.rect_contains_pointer(frame) { &visuals.widgets.hovered } else { &visuals.widgets.inactive };
-    let stroke = if resp.has_focus() { visuals.selection.stroke } else { looks.bg_stroke };
-    ui.painter().set(bg, egui::epaint::RectShape::new(frame, looks.corner_radius, looks.weak_bg_fill, stroke, egui::StrokeKind::Inside));
-    arrow.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Font Size"));
-    let sizes = [8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 36.0, 48.0, 72.0];
-    let labels: Vec<String> = sizes.iter().map(|s| format!("{}", *s as i32)).collect();
-    let items: Vec<(&str, String)> = labels.iter().map(|s| (s.as_str(), s.clone())).collect();
-    if let ComboResult::Picked(value) = list_combo(ui, &arrow, frame, "size", &current, &items)
-        && let Ok(v) = value.parse::<f32>()
-    {
-        act(app, "home.fontSize", json!({"size": v}));
-    }
-}
-
-fn number_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
-    let code = st.num_fmt.as_str().to_string();
-    let kind = gridcraft_engine::display::number_format(&code).kind();
-    let current = format!("{kind:?}");
-    let lang = app.ui.language;
-    let sample = app.session.active().and_then(|d| d.wb.active().map(|sh| sh.value(d.selection.active))).unwrap_or_default();
-    let resp = ui.add_sized([150.0, 24.0], egui::Button::new(egui::RichText::new(lang.tr(&current)).font(theme::ui_font(12.5))));
-    control_keytip(app, ui, &resp, "home.numberFormat");
-    let forced = invoke(app, "home.numberFormat");
-    let names = ["General", "Number", "Currency", "Accounting", "Short Date", "Long Date", "Time", "Percentage", "Fraction", "Scientific", "Text"];
-    let items: Vec<(&str, String)> = names
-        .iter()
-        .map(|n| {
-            let code = gridcraft_engine::cmd::format::format_code_for(n);
-            let preview = app.session.active().map(|d| gridcraft_engine::display::format(&sample, code, &d.wb).text).unwrap_or_default();
-            (*n, format!("{:<12}   {preview}", lang.tr(n)))
-        })
-        .chain(std::iter::once(("__more", format!("{:>12}", lang.tr("More Number Formats…")))))
-        .collect();
-    if let ComboResult::Picked(value) = editable_combo(ui, &resp, "number", &current, &items, forced) {
-        match value.as_str() {
-            "__more" => app.open_dialog("formatCells", json!({"tab": "Number"})),
-            n => act(app, "home.numberFormat", json!({"format": n})),
-        }
-    }
-}
-
-fn cf_menu(app: &mut SheetApp, ui: &mut Ui) {
-    ui.menu_button("Highlight Cells Rules", |ui| {
-        for (label, op) in [("Greater Than…", "greater"), ("Less Than…", "less"), ("Between…", "between"), ("Equal To…", "equal")] {
-            if ui.button(label).clicked() {
-                app.open_dialog("cfQuick", json!({"type": "cellIs", "operator": op, "title": label}));
-            }
-        }
-        if ui.button("Text that Contains…").clicked() {
-            app.open_dialog("cfQuick", json!({"type": "containsText", "title": "Text that Contains"}));
-        }
-        if ui.button("A Date Occurring…").clicked() {
-            app.open_dialog("cfQuick", json!({"type": "timePeriod", "title": "A Date Occurring"}));
-        }
-        if ui.button("Duplicate Values…").clicked() {
-            act(app, "home.conditionalFormat", json!({"rule": {"type": "duplicate"}}));
-        }
-    });
-    ui.menu_button("Top/Bottom Rules", |ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Top 10 Items", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10}})),
-                ("Top 10%", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10, "percent": true}})),
-                ("Bottom 10 Items", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10, "bottom": true}})),
-                ("Bottom 10%", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10, "bottom": true, "percent": true}})),
-                ("Above Average", "home.conditionalFormat", json!({"rule": {"type": "aboveAverage"}})),
-                ("Below Average", "home.conditionalFormat", json!({"rule": {"type": "aboveAverage", "below": true}})),
-            ],
-        );
-    });
-    ui.menu_button("Data Bars", |ui| {
-        for (label, c) in
-            [("Blue", "#638EC6"), ("Green", "#63BE7B"), ("Red", "#F8696B"), ("Orange", "#FFB628"), ("Light Blue", "#008AEF"), ("Purple", "#D6007B")]
-        {
-            if ui.button(label).clicked() {
-                act(app, "home.conditionalFormat", json!({"rule": {"type": "dataBar", "color": c}}));
-            }
-        }
-    });
-    ui.menu_button("Color Scales", |ui| {
-        for (label, cols) in [
-            ("Green - Yellow - Red", vec!["#63BE7B", "#FFEB84", "#F8696B"]),
-            ("Red - Yellow - Green", vec!["#F8696B", "#FFEB84", "#63BE7B"]),
-            ("Green - White - Red", vec!["#63BE7B", "#FCFCFF", "#F8696B"]),
-            ("Blue - White - Red", vec!["#5A8AC6", "#FCFCFF", "#F8696B"]),
-            ("White - Green", vec!["#FCFCFF", "#63BE7B"]),
-            ("White - Red", vec!["#FCFCFF", "#F8696B"]),
-        ] {
-            if ui.button(label).clicked() {
-                act(app, "home.conditionalFormat", json!({"rule": {"type": "colorScale", "colors": cols}}));
-            }
-        }
-    });
-    ui.menu_button("Icon Sets", |ui| {
-        for (label, set) in [
-            ("3 Arrows", "3Arrows"),
-            ("3 Traffic Lights", "3TrafficLights1"),
-            ("3 Symbols", "3Symbols"),
-            ("4 Ratings", "4Rating"),
-            ("5 Arrows", "5Arrows"),
-            ("5 Quarters", "5Quarters"),
-        ] {
-            if ui.button(label).clicked() {
-                act(app, "home.conditionalFormat", json!({"rule": {"type": "iconSet", "set": set}}));
-            }
-        }
-    });
-    ui.separator();
-    if ui.button("New Rule…").clicked() {
-        app.open_dialog("cfQuick", json!({"type": "expression", "title": "New Formatting Rule"}));
-    }
-    ui.menu_button("Clear Rules", |ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Clear Rules from Selected Cells", "home.clearRules", json!({})),
-                ("Clear Rules from Entire Sheet", "home.clearRules", json!({"sheet": true})),
-            ],
-        );
-    });
-    if ui.button("Manage Rules…").clicked() {
-        app.open_dialog("manageRules", json!({}));
-    }
-}
-
-/// A gallery of table styles drawn as mini tables.
-fn table_gallery(app: &mut SheetApp, ui: &mut Ui, cmd: &str) {
-    ui.set_width(430.0);
-    let Some(wb) = app.session.active().map(|d| d.wb.clone()) else { return };
-    for (fam, n) in [("Light", 21u32), ("Medium", 28), ("Dark", 11)] {
-        ui.label(egui::RichText::new(fam).strong());
-        egui::Grid::new(("tg", fam)).spacing(vec2(4.0, 4.0)).show(ui, |ui| {
-            for i in 1..=n {
-                let name = format!("TableStyle{fam}{i}");
-                let (r, resp) = ui.allocate_exact_size(vec2(54.0, 38.0), Sense::click());
-                paint_table_swatch(ui, r, &wb, &name);
-                if resp.hovered() {
-                    ui.painter().rect_stroke(r.expand(1.5), 2.0, Stroke::new(2.0, Tokens::get(ui.ctx()).cat(Cat::Orange)), StrokeKind::Outside);
-                }
-                if resp.on_hover_text(&name).clicked() {
-                    act(app, cmd, json!({"style": name}));
-                    ui.close();
-                }
-                if i % 7 == 0 {
-                    ui.end_row();
-                }
-            }
-        });
-    }
-}
-
-fn paint_table_swatch(ui: &Ui, r: Rect, wb: &gridcraft_engine::model::Workbook, style: &str) {
-    let lk = gridcraft_engine::tables::look(style);
-    let res = |c: Option<gridcraft_engine::model::Color>| c.and_then(|c| c.resolve(&wb.theme)).map(theme::color32);
-    let p = ui.painter();
-    let t = Tokens::get(ui.ctx());
-    p.rect_filled(r, 0.0, t.grid_bg);
-    let rows = 5;
-    let rh = r.height() / rows as f32;
-    for i in 0..rows {
-        let rr = Rect::from_min_size(pos2(r.left(), r.top() + i as f32 * rh), vec2(r.width(), rh));
-        let fill = if i == 0 {
-            res(lk.header_fill)
-        } else if i % 2 == 1 {
-            res(lk.band_fill)
-        } else {
-            res(lk.body_fill)
-        };
-        if let Some(f) = fill {
-            p.rect_filled(rr, 0.0, f);
-        }
-        if let Some(l) = res(lk.line) {
-            p.line_segment([rr.left_bottom(), rr.right_bottom()], Stroke::new(1.0, l));
-        }
-        for k in 0..3 {
-            let x = rr.left() + 4.0 + k as f32 * (r.width() - 8.0) / 3.0;
-            let col = if i == 0 { res(Some(lk.header_font)).unwrap_or(t.cell_text) } else { t.sheet_control_border };
-            p.line_segment([pos2(x, rr.center().y), pos2(x + 10.0, rr.center().y)], Stroke::new(1.0, col));
-        }
-    }
-    p.rect_stroke(r, 0.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
-}
-
-fn cell_style_gallery(app: &mut SheetApp, ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    ui.set_width(520.0);
-    let Some(wb) = app.session.active().map(|d| d.wb.clone()) else { return };
-    let groups: &[(&str, &[&str])] = &[
-        ("Good, Bad and Neutral", &["Normal", "Bad", "Good", "Neutral"]),
-        ("Data and Model", &["Calculation", "Check Cell", "Explanatory Text", "Input", "Linked Cell", "Note", "Output", "Warning Text"]),
-        ("Titles and Headings", &["Heading 1", "Heading 2", "Heading 3", "Heading 4", "Title", "Total"]),
-        (
-            "Themed Cell Styles",
-            &[
-                "20% - Accent1",
-                "20% - Accent2",
-                "20% - Accent3",
-                "20% - Accent4",
-                "20% - Accent5",
-                "20% - Accent6",
-                "40% - Accent1",
-                "40% - Accent2",
-                "40% - Accent3",
-                "40% - Accent4",
-                "40% - Accent5",
-                "40% - Accent6",
-                "60% - Accent1",
-                "60% - Accent2",
-                "60% - Accent3",
-                "60% - Accent4",
-                "60% - Accent5",
-                "60% - Accent6",
-                "Accent1",
-                "Accent2",
-                "Accent3",
-                "Accent4",
-                "Accent5",
-                "Accent6",
-            ],
-        ),
-        ("Number Format", &["Comma", "Comma [0]", "Currency", "Currency [0]", "Percent"]),
-    ];
-    for (g, names) in groups {
-        ui.label(egui::RichText::new(*g).strong());
-        egui::Grid::new(("csg", *g)).spacing(vec2(4.0, 4.0)).show(ui, |ui| {
-            for (i, n) in names.iter().enumerate() {
-                let st = gridcraft_engine::cmd::format::builtin_cell_style(n, &wb.theme).unwrap_or_default();
-                let (r, resp) = ui.allocate_exact_size(vec2(82.0, 24.0), Sense::click());
-                let fill = st
-                    .fill
-                    .fg
-                    .resolve(&wb.theme)
-                    .filter(|_| st.fill.pattern != gridcraft_engine::model::PatternType::None)
-                    .map(theme::color32)
-                    .unwrap_or(t.grid_bg);
-                ui.painter().rect_filled(r, 0.0, fill);
-                ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
-                if !st.borders.bottom.is_none() {
-                    let c = st.borders.bottom.color.resolve(&wb.theme).map(theme::color32).unwrap_or(t.cell_text);
-                    ui.painter().line_segment(
-                        [r.left_bottom() + vec2(0.0, -1.5), r.right_bottom() + vec2(0.0, -1.5)],
-                        Stroke::new(st.borders.bottom.style.width(), c),
-                    );
-                }
-                let col = st.font.color.resolve(&wb.theme).map(theme::color32).unwrap_or(t.cell_text);
-                let fam = theme::cell_family(&st.font.name, st.font.bold, st.font.italic);
-                ui.painter().text(
-                    r.left_center() + vec2(4.0, 0.0),
-                    Align2::LEFT_CENTER,
-                    *n,
-                    egui::FontId::new((st.font.size).clamp(10.0, 15.0), fam),
-                    col,
-                );
-                if resp.hovered() {
-                    ui.painter().rect_stroke(r.expand(1.5), 2.0, Stroke::new(2.0, Tokens::get(ui.ctx()).cat(Cat::Orange)), StrokeKind::Outside);
-                }
-                if resp.clicked() {
-                    act(app, "home.cellStyle", json!({"name": n}));
-                    ui.close();
-                }
-                if (i + 1) % 6 == 0 {
-                    ui.end_row();
-                }
-            }
-        });
-    }
-}
-
-/// Draws the Insert tab: PivotTable, Table, Pictures, Shapes, Icons, charts, slicer, sparklines, checkbox, links, comments, text box, header/footer and symbols.
-fn insert(app: &mut SheetApp, ui: &mut Ui) {
-    let __k = big_button(ui, Icon::PivotTable, "PivotTable", "PivotTable", false);
-    control_keytip(app, ui, &__k, "insert.pivotTable");
-    if __k.clicked() {
-        act(app, "insert.pivotTable", json!({}));
-    }
-    let __k = big_button(ui, Icon::Table, "Table", "Table", false);
-    control_keytip(app, ui, &__k, "insert.table");
-    if __k.clicked() {
-        act(app, "insert.table", json!({}));
-    }
-    sep(ui);
-    let pic = big_button(ui, Icon::Picture, "Pictures", "Insert a picture", true);
-    anchor_keytip(app, ui, &pic, &["insert.picture"]);
-    pic.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Pictures"));
-    egui::Popup::menu(&pic).show(|ui| {
-        for (label, placement) in [("Place in Cell", "cell"), ("Place over Cells", "overCells")] {
-            if ui.button(label).clicked() {
-                app.open_dialog("insertPicture", json!({"placement": placement}));
-                ui.close();
-            }
-        }
-    });
-    let shapes = big_button(ui, Icon::Shapes, "Shapes", "Shapes", true);
-    anchor_keytip(app, ui, &shapes, &["insert.shape"]);
-    egui::Popup::menu(&shapes).show(|ui| {
-        for (label, kind) in [
-            ("Rectangle", "rectangle"),
-            ("Rounded Rectangle", "roundedRectangle"),
-            ("Oval", "ellipse"),
-            ("Triangle", "triangle"),
-            ("Line", "line"),
-            ("Arrow", "arrow"),
-            ("Text Box", "textBox"),
-        ] {
-            if ui.button(label).clicked() {
-                act(app, "insert.shape", json!({"kind": kind}));
-            }
-        }
-    });
-    let icn = big_button(ui, Icon::Theme, "Icons", "Insert an icon", true);
-    anchor_keytip(app, ui, &icn, &["insert.icons"]);
-    egui::Popup::menu(&icn).show(|ui| {
-        ui.set_width(260.0);
-        egui::Grid::new("icon_lib").show(ui, |ui| {
-            for (i, (name, icon)) in icons::LIBRARY.iter().enumerate() {
-                let (r, resp) = ui.allocate_exact_size(vec2(36.0, 36.0), Sense::click());
-                if resp.hovered() {
-                    ui.painter().rect_filled(r, 4.0, Tokens::get(ui.ctx()).hover);
-                }
-                icons::paint(ui.painter(), r.shrink(6.0), *icon, Tokens::get(ui.ctx()).text);
-                if resp.on_hover_text(*name).clicked() {
-                    act(app, "insert.icons", json!({"name": name}));
-                    ui.close();
-                }
-                if (i + 1) % 6 == 0 {
-                    ui.end_row();
-                }
-            }
-        });
-    });
-    sep(ui);
-    let __k = big_button(ui, Icon::Chart, "Recommended\nCharts", "Recommended Charts", false);
-    control_keytip(app, ui, &__k, "insert.recommendedCharts");
-    if __k.clicked() {
-        // Menu-style: with no chart type, run_or_alert opens the Insert Chart dialog.
-        act(app, "insert.recommendedCharts", json!({}));
-    }
-    ui.vertical(|ui| {
-        ui.horizontal(|ui| {
-            for (icon, tip, cid, subs) in [
-                (
-                    Icon::ChartBar,
-                    "Column or Bar",
-                    "insert.chart.column",
-                    vec![
-                        ("Clustered Column", "column", ""),
-                        ("Stacked Column", "column", "stacked"),
-                        ("100% Stacked Column", "column", "stacked100"),
-                        ("Clustered Bar", "bar", ""),
-                        ("Stacked Bar", "bar", "stacked"),
-                        ("100% Stacked Bar", "bar", "stacked100"),
-                    ],
-                ),
-                (
-                    Icon::ChartLine,
-                    "Line or Area",
-                    "insert.chart.line",
-                    vec![
-                        ("Line", "line", ""),
-                        ("Line with Markers", "line", "markers"),
-                        ("Stacked Line", "line", "stacked"),
-                        ("Area", "area", ""),
-                        ("Stacked Area", "area", "stacked"),
-                        ("100% Stacked Area", "area", "stacked100"),
-                    ],
-                ),
-                (Icon::ChartPie, "Pie or Doughnut", "insert.chart.pie", vec![("Pie", "pie", ""), ("Doughnut", "doughnut", "")]),
-            ] {
-                let r = small_button(ui, icon, "", tip, true);
-                control_keytip(app, ui, &r, cid);
-                let forced_c = invoke(app, cid);
-                egui::Popup::menu(&r).open_memory(popup_command(forced_c, r.clicked())).show(|ui| {
-                    for (label, k, s) in &subs {
-                        if ui.button(*label).clicked() {
-                            act(app, "insert.chart", json!({"type": k, "subtype": s}));
-                        }
-                    }
-                });
-            }
-        });
-        ui.horizontal(|ui| {
-            for (icon, tip, cid, subs) in [
-                (
-                    Icon::ChartScatter,
-                    "Scatter or Bubble",
-                    "insert.chart.scatter",
-                    vec![("Scatter", "scatter", ""), ("Scatter with Lines", "scatter", "lines"), ("Bubble", "bubble", "")],
-                ),
-                (Icon::Chart, "Statistic", "insert.chart.statistic", vec![("Histogram", "histogram", ""), ("Box & Whisker", "boxWhisker", "")]),
-                (
-                    Icon::Theme,
-                    "Hierarchy & more",
-                    "insert.chart.hierarchy",
-                    vec![
-                        ("Treemap", "treemap", ""),
-                        ("Sunburst", "sunburst", ""),
-                        ("Waterfall", "waterfall", ""),
-                        ("Funnel", "funnel", ""),
-                        ("Radar", "radar", ""),
-                        ("Stock", "stock", ""),
-                        ("Combo", "combo", ""),
-                    ],
-                ),
-            ] {
-                let r = small_button(ui, icon, "", tip, true);
-                control_keytip(app, ui, &r, cid);
-                let forced_c = invoke(app, cid);
-                egui::Popup::menu(&r).open_memory(popup_command(forced_c, r.clicked())).show(|ui| {
-                    for (label, k, s) in &subs {
-                        if ui.button(*label).clicked() {
-                            act(app, "insert.chart", json!({"type": k, "subtype": s}));
-                        }
-                    }
-                });
-            }
-        });
-    });
-    sep(ui);
-    if big_button(ui, Icon::Filter, "Slicer", "Insert a slicer to filter a table", false).clicked() {
-        act(app, "insert.slicer", json!({}));
-    }
-    sep(ui);
-    let sp = big_button(ui, Icon::Sparkline, "Sparklines", "Sparklines", true);
-    anchor_keytip(app, ui, &sp, &["dialog:sparkline"]);
-    egui::Popup::menu(&sp).show(|ui| {
-        for (label, kind) in [("Line", "line"), ("Column", "column"), ("Win/Loss", "winLoss")] {
-            if ui.button(label).clicked() {
-                app.open_dialog("sparkline", json!({"type": kind}));
-            }
-        }
-    });
-    sep(ui);
-    // Cell Controls.
-    if big_button(ui, Icon::Checkbox, "Checkbox", "Insert checkboxes in the selected cells", false).clicked() {
-        act(app, "insert.checkbox", json!({}));
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::Link, "Link", "Insert Link", false);
-    control_keytip(app, ui, &__k, "dialog:insertLink");
-    if __k.clicked() {
-        app.open_dialog("insertLink", json!({}));
-    }
-    let __k = big_button(ui, Icon::Comment, "Comment", "New Comment", false);
-    control_keytip(app, ui, &__k, "dialog:comment");
-    if __k.clicked() {
-        app.open_dialog("comment", json!({"threaded": true}));
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::TextBox, "Text\nBox", "Text Box", false);
-    control_keytip(app, ui, &__k, "insert.textBox");
-    if __k.clicked() {
-        act(app, "insert.textBox", json!({}));
-    }
-    let __k = big_button(ui, Icon::PageLayout, "Header &\nFooter", "Header & Footer", false);
-    control_keytip(app, ui, &__k, "dialog:headerFooter");
-    if __k.clicked() {
-        // As in Excel: Page Layout view, editing the header in place (the dialog is under Page Setup).
-        crate::paper_view::start_editing(app);
-    }
-    let sym = big_button(ui, Icon::Symbol, "Symbol", "Symbol", true);
-    control_keytip(app, ui, &sym, "insert.symbol");
-    egui::Popup::menu(&sym).show(|ui| {
-        ui.set_width(260.0);
-        ui.horizontal_wrapped(|ui| {
-            for ch in [
-                "€", "£", "¥", "©", "®", "™", "±", "≠", "≤", "≥", "÷", "×", "∞", "µ", "α", "β", "π", "Σ", "Ω", "°", "•", "…", "→", "←", "↑", "↓",
-                "✓", "★", "½", "¼",
-            ] {
-                // No bundled face has ✓: the button paints a code-drawn check instead of a tofu box.
-                if crate::widgets::glyph_button(ui, ch.chars().next().unwrap_or('?'), &format!("Insert {ch}")).clicked() {
-                    act(app, "insert.symbol", json!({"char": ch}));
-                }
-            }
-        });
-    });
-}
-
-fn draw(app: &mut SheetApp, ui: &mut Ui) {
-    let tool = app.session.draw_tool.clone();
-    let __k = big_button(ui, Icon::Shapes, "Select\nObjects", "Select and move ink and shapes", false);
-    control_keytip(app, ui, &__k, "draw.lasso");
-    if __k.clicked() {
-        act(app, "draw.lasso", json!({}));
-    }
-    sep(ui);
-    for (label, color) in [("Pen\nBlue", "#1F5FC9"), ("Pen\nBlack", "#000000"), ("Pen\nRed", "#D13B2F"), ("Highlighter", "#F2E33A")] {
-        let on = tool == "pen" && app.session.draw_color.eq_ignore_ascii_case(color);
-        let r = big_button(ui, Icon::Pen, label, "Draw with ink", false);
-        if on {
-            ui.painter().rect_stroke(r.rect, 5.0, Stroke::new(2.0, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
-        }
-        if r.clicked() {
-            let width = if label == "Highlighter" { 12.0 } else { 2.0 };
-            act(app, "draw.pen", json!({"on": !on, "color": color, "width": width}));
-        }
-    }
-    let er = big_button(ui, Icon::Eraser, "Eraser", "Erase ink strokes", false);
-    if tool == "eraser" {
-        ui.painter().rect_stroke(er.rect, 5.0, Stroke::new(2.0, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
-    }
-    if er.clicked() {
-        act(app, "draw.eraser", json!({}));
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::Shapes, "Ink to\nShape", "Convert the last ink stroke to a shape", false);
-    control_keytip(app, ui, &__k, "draw.inkToShape");
-    if __k.clicked() {
-        act(app, "draw.inkToShape", json!({}));
-    }
-}
-
-fn page_layout(app: &mut SheetApp, ui: &mut Ui) {
-    let th = big_button(ui, Icon::Theme, "Themes", "Themes", true);
-    anchor_keytip(app, ui, &th, &["pageLayout.theme"]);
-    egui::Popup::menu(&th).show(|ui| {
-        for (name, colors) in gridcraft_engine::cmd::view::themes() {
-            ui.horizontal(|ui| {
-                for c in colors.iter().skip(4).take(6) {
-                    let (r, _) = ui.allocate_exact_size(vec2(12.0, 12.0), Sense::hover());
-                    ui.painter().rect_filled(r, 1.0, Color32::from_rgb((c >> 16) as u8, (c >> 8) as u8, *c as u8));
-                }
-                if ui.button(name).clicked() {
-                    act(app, "pageLayout.theme", json!({"name": name}));
-                }
-            });
-        }
-    });
-    sep(ui);
-    let m = big_button(ui, Icon::Margins, "Margins", "Margins", true);
-    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["pageLayout.margins", "dialog:pageSetup"]) {
-        keytip(app, ui, sequence, m.rect.center_bottom());
-    }
-    egui::Popup::menu(&m).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Normal", "pageLayout.margins", json!({"preset": "normal"})),
-                ("Wide", "pageLayout.margins", json!({"preset": "wide"})),
-                ("Narrow", "pageLayout.margins", json!({"preset": "narrow"})),
-                ("Custom Margins…", "dialog:pageSetup", json!({})),
-            ],
-        );
-    });
-    let o = big_button(ui, Icon::Orient, "Page Layout|Orientation", "Page Layout|Orientation", true);
-    control_keytip(app, ui, &o, "pageLayout.orientation");
-    egui::Popup::menu(&o).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Portrait", "pageLayout.orientation", json!({"orientation": "portrait"})),
-                ("Landscape", "pageLayout.orientation", json!({"orientation": "landscape"})),
-            ],
-        );
-    });
-    let s = big_button(ui, Icon::Paper, "Size", "Paper Size", true);
-    control_keytip(app, ui, &s, "pageLayout.size");
-    egui::Popup::menu(&s).show(|ui| {
-        // B4/B5/B6 are the JIS sizes Japanese Excel uses; the ISO ones stay selectable by name.
-        for p in [
-            "Letter",
-            "Legal",
-            "Tabloid",
-            "Executive",
-            "A3",
-            "A4",
-            "A5",
-            "A6",
-            "B4",
-            "B5",
-            "B6",
-            "Japanese Postcard",
-            "Japanese Double Postcard",
-            "Japanese Envelope #3",
-            "Japanese Envelope #4",
-            "Japanese Envelope Kaku #2",
-            "Japanese Envelope Kaku #3",
-            "B4 (ISO)",
-            "B5 (ISO)",
-            "B6 (ISO)",
-        ] {
-            if ui.button(p).clicked() {
-                act(app, "pageLayout.size", json!({"paper": p}));
-            }
-        }
-    });
-    let pa = big_button(ui, Icon::PrintArea, "Print\nArea", "Print Area", true);
-    anchor_keytip(app, ui, &pa, &["pageLayout.printArea"]);
-    egui::Popup::menu(&pa).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[("Set Print Area", "pageLayout.printArea", json!({})), ("Clear Print Area", "pageLayout.printArea", json!({"clear": true}))],
-        );
-    });
-    let br = big_button(ui, Icon::PageBreak, "Breaks", "Page Breaks", true);
-    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["pageLayout.breaks"]) {
-        keytip(app, ui, sequence, br.rect.center_bottom());
-    }
-    egui::Popup::menu(&br).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Insert Page Break", "pageLayout.breaks", json!({"insert": true})),
-                ("Remove Page Break", "pageLayout.breaks", json!({"remove": true})),
-                ("Reset All Page Breaks", "pageLayout.breaks", json!({"reset": true})),
-            ],
-        );
-    });
-    let __k = big_button(ui, Icon::Sheet, "Print\nTitles", "Print Titles", false);
-    control_keytip(app, ui, &__k, "pageLayout.printTitles");
-    if __k.clicked() {
-        app.open_dialog("pageSetup", json!({"tab": "Sheet"}));
-    }
-    sep(ui);
-    let sh = app
-        .session
-        .active()
-        .and_then(|d| d.wb.active().map(|s| (s.show_gridlines, s.show_headings, s.print.gridlines, s.print.headings)))
-        .unwrap_or((true, true, false, false));
-    // These two checkboxes mean the screen view vs. the printed page. English shows "View" (as in
-    // Excel), but the key is distinct from the "View" tab so languages can word them apart.
-    let screen = app.ui.language.tr("Sheet Options|View");
-    let print = app.ui.language.tr("Print");
-    ui.vertical(|ui| {
-        ui.label(egui::RichText::new(app.ui.language.tr("Gridlines")).strong().small());
-        let mut v = sh.0;
-        let resp = ui.checkbox(&mut v, screen);
-        control_keytip(app, ui, &resp, "view.gridlines");
-        if resp.changed() || invoke(app, "view.gridlines") {
-            act(app, "view.gridlines", json!({"on": checkbox_on(resp.changed(), v)}));
-        }
-        let mut p = sh.2;
-        let resp = ui.checkbox(&mut p, print);
-        control_keytip(app, ui, &resp, "pageLayout.printGridlines");
-        if resp.changed() || invoke(app, "pageLayout.printGridlines") {
-            act(app, "pageLayout.printGridlines", json!({"on": checkbox_on(resp.changed(), p)}));
-        }
-    });
-    ui.vertical(|ui| {
-        ui.label(egui::RichText::new(app.ui.language.tr("Headings")).strong().small());
-        let mut v = sh.1;
-        let resp = ui.checkbox(&mut v, screen);
-        control_keytip(app, ui, &resp, "view.headings");
-        if resp.changed() || invoke(app, "view.headings") {
-            act(app, "view.headings", json!({"on": checkbox_on(resp.changed(), v)}));
-        }
-        let mut p = sh.3;
-        let resp = ui.checkbox(&mut p, print);
-        control_keytip(app, ui, &resp, "pageLayout.printHeadings");
-        if resp.changed() || invoke(app, "pageLayout.printHeadings") {
-            act(app, "pageLayout.printHeadings", json!({"on": checkbox_on(resp.changed(), p)}));
-        }
-    });
-    let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
-    let r = big_button(ui, Icon::SheetRtl, "Sheet\nRight-to-Left", "Sheet Right-to-Left", false);
-    if rtl {
-        let t = Tokens::get(ui.ctx());
-        ui.painter().rect_stroke(r.rect, 5.0, egui::Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
-    }
-    if r.clicked() {
-        act(app, "view.rightToLeft", json!({"on": !rtl}));
-    }
-}
-
-/// The Formulas tab: Insert Function, AutoSum, the function-category menus (names in the formula
-/// language, descriptions in the interface language), defined names, auditing and calculation.
-fn formulas(app: &mut SheetApp, ui: &mut Ui) {
-    let __k = big_button(ui, Icon::Function, "Insert\nFunction", "Insert Function (⇧F3)", false);
-    control_keytip(app, ui, &__k, "dialog:insertFunction");
-    if __k.clicked() {
-        app.open_dialog("insertFunction", json!({}));
-    }
-    let (s, sa) = big_split_button(ui, Icon::Sum, "AutoSum", "AutoSum");
-    control_keytip(app, ui, &sa, "formulas.autoSum");
-    if s.clicked() {
-        act(app, "formulas.autoSum", json!({}));
-    }
-    egui::Popup::menu(&sa).show(|ui| autosum_menu(app, ui));
-    for (label, cat, cid) in [
-        ("Financial", "Financial", "formulas.financial"),
-        ("Logical", "Logical", "formulas.logical"),
-        ("Text", "Text", "formulas.text"),
-        ("Date &\nTime", "DateTime", "formulas.dateTime"),
-        ("Lookup &\nReference", "Lookup", "formulas.lookup"),
-        ("Math &\nTrig", "MathTrig", "formulas.mathTrig"),
-        ("More\nFunctions", "Statistical", "formulas.moreFunctions"),
-    ] {
-        let r = big_button(ui, Icon::Book, label, label, true);
-        control_keytip(app, ui, &r, cid);
-        let forced_c = invoke(app, cid);
-        egui::Popup::menu(&r).open_memory(popup_command(forced_c, r.clicked())).show(|ui| {
-            ui.set_max_height(420.0);
-            egui::ScrollArea::vertical().show(ui, |ui| {
-                for f in gridcraft_engine::cmd::formulas::function_list() {
-                    if f["category"].as_str() == Some(cat)
-                        && let Some(n) = f["name"].as_str()
-                    {
-                        let locale = app.ui.language.formula_locale();
-                        let name =
-                            app.session.active().map(|d| crate::formula_locale::completion_name(n, locale, &d.wb, d.wb.active_sheet())).unwrap_or(n);
-                        let desc = crate::formula_locale::description(n, locale, app.ui.language).unwrap_or_default();
-                        if ui.button(name).on_hover_text(desc).clicked() {
-                            app.run_or_alert("formulas.insertFunction", json!({"name": n}));
-                            ui.close();
-                        }
-                    }
-                }
-            });
-        });
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::Name, "Name\nManager", "Name Manager", false);
-    control_keytip(app, ui, &__k, "dialog:nameManager");
-    if __k.clicked() {
-        app.open_dialog("nameManager", json!({}));
-    }
-    ui.vertical(|ui| {
-        let __k = small_button(ui, Icon::Name, "Define Name", "Define Name", false);
-        control_keytip(app, ui, &__k, "dialog:defineName");
-        if __k.clicked() {
-            app.open_dialog("defineName", json!({}));
-        }
-        let use_in = small_button(ui, Icon::Function, "Use in Formula", "Use in Formula", true);
-        anchor_keytip(app, ui, &use_in, &["dialog:pasteName"]);
-        egui::Popup::menu(&use_in).show(|ui| {
-            // The menu lists the names Paste Names lists; clicking one runs `formulas.useInFormula`, which puts it at the caret.
-            // Listed when the menu opens, and again only after the workbook changes.
-            let cache = egui::Id::unique("gridcraft.use_in_formula_names");
-            let key = app.session.active().map(|d| (d.uid, d.revision, d.wb.active_sheet()));
-            let cached = ui.ctx().data(|m| m.get_temp::<(Option<(u64, u64, usize)>, std::sync::Arc<Vec<String>>)>(cache)).filter(|(k, _)| *k == key);
-            let names = match cached {
-                Some((_, names)) => names,
-                None => {
-                    let names: std::sync::Arc<Vec<String>> = std::sync::Arc::new(
-                        app.session
-                            .active()
-                            .map(|d| gridcraft_engine::cmd::formulas::pasteable_names(&d.wb).into_iter().map(|(n, _)| n).collect())
-                            .unwrap_or_default(),
-                    );
-                    ui.ctx().data_mut(|m| m.insert_temp(cache, (key, names.clone())));
-                    names
-                }
-            };
-            for n in names.iter() {
-                if ui.button(n).clicked() {
-                    app.run_or_alert("formulas.useInFormula", json!({"name": n}));
-                }
-            }
-            if !names.is_empty() {
-                ui.separator();
-            }
-            if ui.button(app.ui.language.tr("Paste Names…")).clicked() {
-                app.open_dialog("pasteName", json!({}));
-            }
-        });
-        let __k = small_button(ui, Icon::Table, "Create from Selection", "Create from Selection", false);
-        control_keytip(app, ui, &__k, "formulas.createFromSelection");
-        if __k.clicked() {
-            act(app, "formulas.createFromSelection", json!({}));
-        }
-    });
-    sep(ui);
-    ui.vertical(|ui| {
-        if small_button(ui, Icon::Trace, "Trace Precedents", "Trace Precedents", false).clicked()
-            && let Ok(r) = app.run("formulas.tracePrecedents", json!({}))
-        {
-            app.grid.trace = crate::grid::Trace::new(app, r);
-        }
-        if small_button(ui, Icon::Trace, "Trace Dependents", "Trace Dependents", false).clicked()
-            && let Ok(r) = app.run("formulas.traceDependents", json!({}))
-        {
-            app.grid.trace = crate::grid::Trace::new(app, r);
-        }
-        if small_button(ui, Icon::Close, "Remove Arrows", "Remove Arrows", false).clicked() {
-            app.grid.trace = None;
-        }
-    });
-    ui.vertical(|ui| {
-        let __k = small_button(ui, Icon::Fx, "Show Formulas", "Show Formulas", false);
-        control_keytip(app, ui, &__k, "formulas.showFormulas");
-        if __k.clicked() {
-            act(app, "formulas.showFormulas", json!({}));
-        }
-        let (ec, ec_arrow) = small_split_button(ui, Icon::Validation, "Error Checking", "Error Checking");
-        control_keytip(app, ui, &ec, "dialog:errorChecking");
-        if ec.clicked() {
-            app.open_dialog("errorChecking", json!({}));
-        }
-        egui::Popup::menu(&ec_arrow).show(|ui| {
-            let lang = app.ui.language;
-            if ui.button(format!("{}…", lang.tr("Error Checking"))).clicked() {
-                app.open_dialog("errorChecking", json!({}));
-            }
-            let circular = circular_references(app);
-            ui.add_enabled_ui(!circular.is_empty(), |ui| {
-                ui.menu_button(lang.tr("Circular References"), |ui| {
-                    egui::ScrollArea::vertical().id_salt("circular_references").max_height(400.0).show(ui, |ui| {
-                        for (sheet, cell, label) in circular {
-                            if ui.button(label).clicked() {
-                                act(app, "selection.set", json!({"range": cell, "sheet": sheet}));
-                                app.grid.ensure_visible = true;
-                            }
-                        }
-                    });
-                });
-            });
-        });
-        let __k = small_button(ui, Icon::Calc, "Evaluate Formula", "Evaluate Formula", false);
-        control_keytip(app, ui, &__k, "dialog:evaluateFormula");
-        if __k.clicked() {
-            app.open_dialog("evaluateFormula", json!({}));
-        }
-    });
-    if big_button(ui, Icon::Search, "Watch\nWindow", "Watch Window", false).clicked() {
-        app.grid.pane = Some("watch".into());
-    }
-    sep(ui);
-    let co = big_button(ui, Icon::Calc, "Calculation\nOptions", "Calculation Options", true);
-    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["formulas.calculationOptions"]) {
-        keytip(app, ui, sequence, co.rect.center_bottom());
-    }
-    egui::Popup::menu(&co).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Automatic", "formulas.calculationOptions", json!({"mode": "automatic"})),
-                ("Automatic Except for Data Tables", "formulas.calculationOptions", json!({"mode": "automaticExceptTables"})),
-                ("Manual", "formulas.calculationOptions", json!({"mode": "manual"})),
-            ],
-        );
-    });
-    ui.vertical(|ui| {
-        let __k = small_button(ui, Icon::Calc, "Calculate Now", "Calculate Now (F9)", false);
-        control_keytip(app, ui, &__k, "formulas.calculateNow");
-        if __k.clicked() {
-            act(app, "formulas.calculateNow", json!({}));
-        }
-        let __k = small_button(ui, Icon::Sheet, "Calculate Sheet", "Calculate Sheet (⇧F9)", false);
-        control_keytip(app, ui, &__k, "formulas.calculateSheet");
-        if __k.clicked() {
-            act(app, "formulas.calculateSheet", json!({}));
-        }
-    });
-}
-
-fn data(app: &mut SheetApp, ui: &mut Ui) {
-    let gd = big_button(ui, Icon::Folder, "Get Data\n(Text/CSV)", "Import a text or CSV file", false);
-    control_keytip(app, ui, &gd, "data.getData");
-    if gd.clicked() {
-        app.open_dialog("open", json!({}));
-    }
-    sep(ui);
-    ui.vertical(|ui| {
-        let __k = small_button(ui, Icon::SortAsc, "", "Sort A to Z", false);
-        control_keytip(app, ui, &__k, "data.sortAscending");
-        if __k.clicked() {
-            act(app, "data.sortAscending", json!({}));
-        }
-        let __k = small_button(ui, Icon::SortDesc, "", "Sort Z to A", false);
-        control_keytip(app, ui, &__k, "data.sortDescending");
-        if __k.clicked() {
-            act(app, "data.sortDescending", json!({}));
-        }
-    });
-    let __k = big_button(ui, Icon::SortFilter, "Sort", "Custom Sort", false);
-    control_keytip(app, ui, &__k, "dialog:sort");
-    if __k.clicked() {
-        app.open_dialog("sort", json!({}));
-    }
-    let __k = big_button(ui, Icon::Filter, "Filter", "Filter", false);
-    control_keytip(app, ui, &__k, "data.filter");
-    if __k.clicked() {
-        act(app, "data.filter", json!({}));
-    }
-    ui.vertical(|ui| {
-        let __k = small_button(ui, Icon::Eraser, "Clear", "Clear Filter", false);
-        control_keytip(app, ui, &__k, "data.clearFilter");
-        if __k.clicked() {
-            act(app, "data.clearFilter", json!({}));
-        }
-        let __k = small_button(ui, Icon::Redo, "Reapply", "Reapply", false);
-        control_keytip(app, ui, &__k, "data.reapply");
-        if __k.clicked() {
-            act(app, "data.reapply", json!({}));
-        }
-        let __k = small_button(ui, Icon::Filter, "Advanced", "Advanced Filter", false);
-        control_keytip(app, ui, &__k, "dialog:advancedFilter");
-        if __k.clicked() {
-            app.open_dialog("advancedFilter", json!({}));
-        }
-    });
-    sep(ui);
-    let __k = big_button(ui, Icon::TextColumns, "Text to\nColumns", "Text to Columns", false);
-    control_keytip(app, ui, &__k, "dialog:textToColumns");
-    if __k.clicked() {
-        app.open_dialog("textToColumns", json!({}));
-    }
-    let __k = big_button(ui, Icon::FillDown, "Flash\nFill", "Flash Fill", false);
-    control_keytip(app, ui, &__k, "edit.flashFill");
-    if __k.clicked() {
-        act(app, "edit.flashFill", json!({}));
-    }
-    let __k = big_button(ui, Icon::Duplicates, "Remove\nDuplicates", "Remove Duplicates", false);
-    control_keytip(app, ui, &__k, "dialog:removeDuplicates");
-    if __k.clicked() {
-        app.open_dialog("removeDuplicates", json!({}));
-    }
-    let dv = big_button(ui, Icon::Validation, "Data\nValidation", "Data Validation", true);
-    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["data.validation", "data.circleInvalid"]) {
-        keytip(app, ui, sequence, dv.rect.center_bottom());
-    }
-    egui::Popup::menu(&dv).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Data Validation…", "dialog:dataValidation", json!({})),
-                ("Circle Invalid Data", "data.circleInvalid", json!({})),
-                ("Clear Validation", "data.validation", json!({"clear": true})),
-            ],
-        );
-    });
-    sep(ui);
-    let wi = big_button(ui, Icon::Calc, "What-If\nAnalysis", "What-If Analysis", true);
-    for sequence in
-        keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["dialog:goalSeek", "data.scenarioManager", "data.dataTable"])
-    {
-        keytip(app, ui, sequence, wi.rect.center_bottom());
-    }
-    egui::Popup::menu(&wi).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Goal Seek…", "dialog:goalSeek", json!({})),
-                ("Scenario Manager…", "data.scenarioManager", json!({})),
-                ("Data Table…", "data.dataTable", json!({})),
-            ],
-        );
-    });
-    if big_button(ui, Icon::ChartLine, "Forecast\nSheet", "Forecast Sheet", false).clicked() {
-        app.open_dialog("forecastSheet", json!({}));
-    }
-    sep(ui);
-    ui.vertical(|ui| {
-        let __k = small_button(ui, Icon::Group, "Group", "Group", false);
-        control_keytip(app, ui, &__k, "data.group");
-        if __k.clicked() {
-            act(app, "data.group", json!({}));
-        }
-        let __k = small_button(ui, Icon::Ungroup, "Ungroup", "Ungroup", false);
-        control_keytip(app, ui, &__k, "data.ungroup");
-        if __k.clicked() {
-            act(app, "data.ungroup", json!({}));
-        }
-        let __k = small_button(ui, Icon::Subtotal, "Subtotal", "Subtotal", false);
-        control_keytip(app, ui, &__k, "dialog:subtotal");
-        if __k.clicked() {
-            app.open_dialog("subtotal", json!({}));
-        }
-    });
-    ui.vertical(|ui| {
-        if small_button(ui, Icon::Plus, "Show Detail", "Show Detail", false).clicked() {
-            act(app, "data.showDetail", json!({}));
-        }
-        if small_button(ui, Icon::Minus, "Hide Detail", "Hide Detail", false).clicked() {
-            act(app, "data.hideDetail", json!({}));
-        }
-        if small_button(ui, Icon::Settings, "Settings", "Outline Settings", false).clicked() {
-            app.open_dialog("outlineSettings", json!({}));
-        }
-    });
-    sep(ui);
-    if big_button(ui, Icon::ChartBar, "Data\nAnalysis", "Data Analysis", false).clicked() {
-        app.open_dialog("analysisToolPak", json!({}));
-    }
-    sep(ui);
-    if big_button(ui, Icon::Function, "Solver", "Solver", false).clicked() {
-        app.open_dialog("solver", json!({}));
-    }
-}
-
-fn review(app: &mut SheetApp, ui: &mut Ui) {
-    let __k = big_button(ui, Icon::Spell, "Spelling", "Spelling (F7)", false);
-    control_keytip(app, ui, &__k, "dialog:spelling");
-    if __k.clicked() {
-        app.open_dialog("spelling", json!({}));
-    }
-    let __k = big_button(ui, Icon::Calc, "Workbook\nStatistics", "Workbook Statistics", false);
-    control_keytip(app, ui, &__k, "statistics");
-    if __k.clicked() {
-        app.open_dialog("statistics", json!({}));
-    }
-    let __k = big_button(ui, Icon::Validation, "Check\nAccessibility", "Check Accessibility", false);
-    control_keytip(app, ui, &__k, "dialog:accessibility");
-    if __k.clicked() {
-        app.open_dialog("accessibility", json!({}));
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::Comment, "New\nComment", "New Comment", false);
-    control_keytip(app, ui, &__k, "dialog:comment");
-    if __k.clicked() {
-        app.open_dialog("comment", json!({"threaded": true}));
-    }
-    let __k = big_button(ui, Icon::Delete, "Delete", "Delete Comment", false);
-    control_keytip(app, ui, &__k, "review.deleteComment");
-    if __k.clicked() {
-        act(app, "review.deleteComment", json!({}));
-    }
-    ui.vertical(|ui| {
-        for (icon, label, tip, id) in
-            [(Icon::Left, "Previous", "Previous Comment", "review.previousComment"), (Icon::Right, "Next", "Next Comment", "review.nextComment")]
-        {
-            if small_button(ui, icon, label, tip, false).clicked() {
-                act(app, id, json!({}));
-                app.grid.ensure_visible = true;
-            }
-        }
-    });
-    let shown = app.session.comments_pane;
-    let r = big_button(ui, Icon::Comment, "Show\nComments", "Comments pane", false);
-    if shown {
-        ui.painter().rect_stroke(r.rect, 5.0, Stroke::new(2.0, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
-    }
-    if r.clicked() {
-        act(app, "review.showComments", json!({"on": !shown}));
-        if app.session.comments_pane {
-            app.grid.pane = None;
-        }
-    }
-    let notes = big_button(ui, Icon::Note, "Notes", "Notes", true);
-    anchor_keytip(app, ui, &notes, &["review.nextComment"]);
-    egui::Popup::menu(&notes).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("New Note", "dialog:comment", json!({"threaded": false})),
-                ("Show/Hide Note", "review.showNote", json!({})),
-                ("Show All Notes", "review.showAllNotes", json!({})),
-                ("-", "", json!({})),
-                ("Convert to Comments", "review.convertToComments", json!({})),
-            ],
-        );
-    });
-    sep(ui);
-    let protected = app.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false);
-    let __k = big_button(ui, Icon::Lock, if protected { "Unprotect\nSheet" } else { "Protect\nSheet" }, "Protect Sheet", false);
-    control_keytip(app, ui, &__k, "dialog:protectSheet");
-    if __k.clicked() {
-        app.open_dialog("protectSheet", json!({}));
-    }
-    let __k = big_button(ui, Icon::Book, "Protect\nWorkbook", "Protect Workbook structure", false);
-    control_keytip(app, ui, &__k, "review.protectWorkbook");
-    if __k.clicked() {
-        crate::backstage::protect_workbook(app);
-    }
-    if big_button(ui, Icon::Validation, "Allow Edit\nRanges", "Allow Edit Ranges", false).clicked() {
-        app.open_dialog("allowEditRanges", json!({}));
-    }
-}
-
-/// Draws the View tab: view modes, ruler/gridlines/formula-bar/headings toggles, zoom, freeze panes, theme, animations, interface size and language.
-fn view(app: &mut SheetApp, ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    let _ = t;
-    for (icon, label, cmd) in [
-        (Icon::Normal, "Normal", "view.normal"),
-        (Icon::PageBreak, "Page Break\nPreview", "view.pageBreakPreview"),
-        (Icon::PageLayout, "Page\nLayout", "view.pageLayout"),
-    ] {
-        let __k = big_button(ui, icon, label, label, false);
-        control_keytip(app, ui, &__k, cmd);
-        if __k.clicked() {
-            act(app, cmd, json!({}));
-        }
-    }
-    sep(ui);
-    let s = app.session.active().and_then(|d| d.wb.active().map(|s| (s.show_gridlines, s.show_headings))).unwrap_or((true, true));
-    let lang = app.ui.language;
-    let page_layout =
-        app.session.active().and_then(|d| d.wb.active().map(|s| s.view == gridcraft_engine::model::SheetViewMode::PageLayout)).unwrap_or(false);
-    // Two columns of two, as in Excel's Show group: four stacked rows overflow the ribbon body.
-    ui.vertical(|ui| {
-        // Rulers exist only in Page Layout view.
-        let mut ruler = !app.session.hide_ruler;
-        let ruler_resp = ui.add_enabled(page_layout, egui::Checkbox::new(&mut ruler, lang.tr("Ruler")));
-        control_keytip(app, ui, &ruler_resp, "view.ruler");
-        if ruler_resp.changed() {
-            act(app, "view.ruler", json!({"on": ruler}));
-        }
-        let mut g = s.0;
-        let resp = ui.checkbox(&mut g, lang.tr("Gridlines"));
-        control_keytip(app, ui, &resp, "view.gridlines");
-        if resp.changed() {
-            act(app, "view.gridlines", json!({"on": g}));
-        }
-    });
-    ui.add_space(6.0);
-    ui.vertical(|ui| {
-        let mut fb = app.session.prefs.formula_bar;
-        let resp = ui.checkbox(&mut fb, lang.tr("Formula Bar"));
-        control_keytip(app, ui, &resp, "view.formulaBar");
-        if resp.changed() || invoke(app, "view.formulaBar") {
-            act(app, "view.formulaBar", json!({"on": checkbox_on(resp.changed(), fb)}));
-        }
-        let mut h = s.1;
-        let resp = ui.checkbox(&mut h, lang.tr("Headings"));
-        control_keytip(app, ui, &resp, "view.headings");
-        if resp.changed() {
-            act(app, "view.headings", json!({"on": h}));
-        }
-    });
-    sep(ui);
-    let __k = big_button(ui, Icon::Zoom, "Zoom", "Zoom…", false);
-    control_keytip(app, ui, &__k, "dialog:zoom");
-    if __k.clicked() {
-        app.open_dialog("zoom", json!({}));
-    }
-    let __k = big_button(ui, Icon::Search, "100%", "Zoom to 100%", false);
-    control_keytip(app, ui, &__k, "view.zoom");
-    if __k.clicked() || invoke(app, "view.zoom") {
-        act(app, "view.zoom", json!({"percent": 100}));
-    }
-    let __k = big_button(ui, Icon::Zoom, "Zoom to\nSelection", "Zoom to Selection", false);
-    control_keytip(app, ui, &__k, "view.zoomToSelection");
-    if __k.clicked() {
-        let r = app.grid.cells_rect.unwrap_or(Rect::from_min_size(pos2(0.0, 0.0), vec2(1200.0, 700.0)));
-        act(app, "view.zoomToSelection", json!({"viewWidth": r.width(), "viewHeight": r.height()}));
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::NewFile, "New\nWindow", "New Window", false);
-    control_keytip(app, ui, &__k, "view.newWindow");
-    if __k.clicked() {
-        act(app, "view.newWindow", json!({}));
-    }
-    let __k = big_button(ui, Icon::Table, "Arrange\nAll", "Arrange All", false);
-    control_keytip(app, ui, &__k, "view.arrangeAll");
-    if __k.clicked() {
-        app.open_dialog("arrangeAll", json!({}));
-    }
-    let fp = big_button(ui, Icon::Freeze, "Freeze\nPanes", "Freeze Panes", true);
-    for sequence in
-        keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["view.freezePanes", "view.freezeTopRow", "view.freezeFirstColumn"])
-    {
-        keytip(app, ui, sequence, fp.rect.center_bottom());
-    }
-    egui::Popup::menu(&fp).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Freeze Panes", "view.freezePanes", json!({})),
-                ("Freeze Top Row", "view.freezeTopRow", json!({})),
-                ("Freeze First Column", "view.freezeFirstColumn", json!({})),
-                ("Unfreeze Panes", "view.unfreezePanes", json!({})),
-            ],
-        );
-    });
-    switch_windows(app, ui);
-    ui.vertical(|ui| {
-        let label_response = ui.label(lang.tr("Display theme"));
-        let mode = app.ui.theme_mode();
-        let label = match mode {
-            "system" => "System",
-            "dark" => "Dark",
-            _ => "Light",
-        };
-        egui::ComboBox::from_id_salt("display_theme")
-            .selected_text(lang.tr(label))
-            .width(88.0)
-            .show_ui(ui, |ui| {
-                for (value, label) in [("system", "System"), ("light", "Light"), ("dark", "Dark")] {
-                    if ui.selectable_label(mode == value, lang.tr(label)).clicked() {
-                        act(app, "view.theme", json!({"mode": value}));
-                    }
-                }
-            })
-            .response
-            .labelled_by(label_response.id);
-        let mut animations = app.ui.animations;
-        let hint = lang.tr("Glide the selection outline to the cell you move to instead of jumping there");
-        if ui.checkbox(&mut animations, lang.tr("Animations")).on_hover_text(hint).changed() {
-            act(app, "view.animations", json!({"on": animations}));
-        }
-    });
-    sep(ui);
-    // Interface size (issue #230): scales the whole window on top of the desktop's scale.
-    ui.vertical(|ui| {
-        let label = ui.label(egui::RichText::new(lang.tr("Interface size")).font(theme::ui_font(11.5)).color(t.text_dim));
-        let current = app.ui.interface_scale;
-        let text = |v: u16| if v == 100 { lang.tr("Auto").to_string() } else { format!("{v}%") };
-        egui::ComboBox::from_id_salt("ui_interface_size")
-            .width(120.0)
-            .selected_text(egui::RichText::new(text(current)).font(theme::ui_font(12.5)))
-            .show_ui(ui, |ui| {
-                for v in [100, 75, 90, 110, 125, 150, 175, 200] {
-                    if ui.selectable_label(v == current, text(v)).clicked() {
-                        act(app, "view.interfaceScale", json!({"percent": v}));
-                    }
-                }
-            })
-            .response
-            .labelled_by(label.id);
-    });
-    // Interface language: settings live in the View tab, like Excel's Options. The label follows
-    // the current language so it stays readable; the choices are always shown in their own script.
-    ui.vertical(|ui| {
-        let label = ui.label(egui::RichText::new(lang.tr("Interface language")).font(theme::ui_font(11.5)).color(t.text_dim));
-        egui::ComboBox::from_id_salt("ui_language")
-            .width(120.0)
-            .selected_text(egui::RichText::new(lang.name()).font(theme::ui_font(12.5)))
-            .show_ui(ui, |ui| {
-                for l in crate::i18n::Language::ALL {
-                    if ui.selectable_label(l == lang, l.name()).clicked() {
-                        act(app, "app.language.set", json!({"language": l.code()}));
-                    }
-                }
-            })
-            .response
-            .labelled_by(label.id);
-    });
-}
-
-/// View › Switch Windows: the open workbooks, the active one checked and unsaved ones marked;
-/// choosing one brings it forward.
-fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
-    let anchor = big_button(ui, Icon::Book, "Switch\nWindows", "Switch Windows", true);
-    anchor.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Switch Windows"));
-    control_keytip(app, ui, &anchor, "view.switchWindows");
-    let forced = std::mem::take(&mut app.open_switch_windows) | invoke(app, "view.switchWindows");
-    egui::Popup::menu(&anchor).open_memory(popup_command(forced, anchor.clicked())).show(|ui| {
-        for w in app.open_windows() {
-            let label = theme::available_text(ui, &format!("{}{}", if w.active { "✓ " } else { "    " }, w.label()));
-            if ui.add(egui::Button::selectable(w.active, label).min_size(vec2(220.0, 22.0))).clicked() {
-                act(app, "view.switchWindows", json!({"window": w.window}));
-                ui.close();
-            }
-        }
-    });
-}
-
-fn automate(app: &mut SheetApp, ui: &mut Ui) {
-    if big_button(ui, Icon::Script, "Macros", "Macros and scripts in this workbook (Alt+F8)", false).clicked() {
-        app.open_dialog("macros", json!({}));
-    }
-    let __k = big_button(ui, Icon::Script, "Command\nPalette", "Search and run any command", false);
-    control_keytip(app, ui, &__k, "commandSearch");
-    if __k.clicked() {
-        app.open_dialog("commandSearch", json!({}));
-    }
-    let __k = big_button(ui, Icon::Script, "Agent\nControl", "How agents drive GridCraft (MCP / control channel)", false);
-    control_keytip(app, ui, &__k, "agents");
-    if __k.clicked() {
-        app.open_dialog("agents", json!({}));
-    }
-    let __k = big_button(ui, Icon::Script, "Action\nJournal", "Every command run in this session (replayable)", false);
-    control_keytip(app, ui, &__k, "journal");
-    if __k.clicked() {
-        app.open_dialog("journal", json!({}));
-    }
-    let __k = big_button(ui, Icon::Script, "Check for\nUpdates…", "Look for a newer GridCraft release", false);
-    control_keytip(app, ui, &__k, "checkForUpdates");
-    if __k.clicked() {
-        app.run_or_alert("app.checkForUpdates", json!({}));
-    }
-    let __k = big_button(ui, Icon::Script, "About\nGridCraft", "Version, contributors and the AI models that helped", false);
-    control_keytip(app, ui, &__k, "about");
-    if __k.clicked() {
-        app.open_dialog("about", json!({}));
-    }
-}
-
-/// Draws the Table Design tab: rename, resize, remove duplicates, convert to range, slicer, table options and the style strip.
-fn table_design(app: &mut SheetApp, ui: &mut Ui) {
-    let Some((tname, header, totals, banded, banded_c, first, last, filter, style)) = app.session.active().and_then(|d| {
-        let sh = d.wb.active()?;
-        let t = sh.table_at(d.selection.active)?;
-        Some((t.name.clone(), t.header_row, t.totals_row, t.banded_rows, t.banded_cols, t.first_col, t.last_col, t.filter_button, t.style.clone()))
-    }) else {
-        return;
-    };
-    ui.vertical(|ui| {
-        ui.label(egui::RichText::new("Table Name:").small());
-        let field = egui::Id::unique(("gridcraft.table_name", &tname));
-        if let Some(name) = crate::widgets::committed_text(ui, field, &tname, Some(120.0))
-            && name != tname
-        {
-            act(app, "table.rename", json!({"table": tname, "name": name}));
-        }
-    });
-    let __k = big_button(ui, Icon::Table, "Resize\nTable", "Resize Table", false);
-    control_keytip(app, ui, &__k, "dialog:tableResize");
-    if __k.clicked() {
-        app.open_dialog("tableResize", json!({}));
-    }
-    sep(ui);
-    let __k = big_button(ui, Icon::Duplicates, "Remove\nDuplicates", "Remove Duplicates", false);
-    control_keytip(app, ui, &__k, "data.removeDuplicates");
-    if __k.clicked() {
-        act(app, "data.removeDuplicates", json!({}));
-    }
-    let __k = big_button(ui, Icon::Table, "Convert\nto Range", "Convert to Range", false);
-    control_keytip(app, ui, &__k, "table.convertToRange");
-    if __k.clicked() {
-        act(app, "table.convertToRange", json!({"table": tname}));
-    }
-    sep(ui);
-    if big_button(ui, Icon::Filter, "Insert\nSlicer", "Insert Slicer", false).clicked() {
-        act(app, "table.insertSlicer", json!({"table": tname}));
-    }
-    sep(ui);
-    ui.vertical(|ui| {
-        for (label, cmd, v) in [
-            ("Header Row", "table.headerRow", header && filter),
-            ("Total Row", "table.totalRow", totals),
-            ("Banded Rows", "table.bandedRows", banded),
-        ] {
-            let mut on = v;
-            if ui.checkbox(&mut on, label).changed() {
-                act(app, cmd, json!({"table": tname, "on": on}));
-            }
-        }
-    });
-    ui.vertical(|ui| {
-        for (label, cmd, v) in [
-            ("First Column", "table.firstColumn", first),
-            ("Last Column", "table.lastColumn", last),
-            ("Banded Columns", "table.bandedColumns", banded_c),
-        ] {
-            let mut on = v;
-            if ui.checkbox(&mut on, label).changed() {
-                act(app, cmd, json!({"table": tname, "on": on}));
-            }
-        }
-    });
-    sep(ui);
-    table_style_strip(app, ui, &tname, &style);
-}
-
-/// The first page of Excel's Table Styles gallery, drawn in the ribbon. The More arrow opens the
-/// full gallery (Light, Medium, Dark) as a popup.
-const RIBBON_TABLE_STYLES: [&str; 7] =
-    ["TableStyleLight1", "TableStyleLight2", "TableStyleLight3", "TableStyleLight4", "TableStyleLight5", "TableStyleLight6", "TableStyleLight7"];
-
-fn table_style_strip(app: &mut SheetApp, ui: &mut Ui, tname: &str, current: &str) {
-    let t = Tokens::get(ui.ctx());
-    ui.add_space(12.0);
-    ui.horizontal(|ui| {
-        ui.spacing_mut().item_spacing.x = 3.0;
-        // Borrow the workbook only while painting; the session must be free for `act` afterwards.
-        let clicked = {
-            let Some(d) = app.session.active() else { return };
-            let wb = &d.wb;
-            let mut clicked = None;
-            for name in RIBBON_TABLE_STYLES {
-                let (r, resp) = ui.allocate_exact_size(vec2(52.0, 40.0), Sense::click());
-                paint_table_swatch(ui, r, wb, name);
-                if name == current {
-                    ui.painter().rect_stroke(r.expand(2.5), 2.0, Stroke::new(2.0, t.accent), StrokeKind::Outside);
-                }
-                if resp.hovered() {
-                    ui.painter().rect_stroke(r.expand(1.0), 2.0, Stroke::new(2.0, Color32::from_rgb(0xE8, 0x7D, 0x2B)), StrokeKind::Outside);
-                }
-                if resp.on_hover_text(name).clicked() {
-                    clicked = Some(name);
-                }
-            }
-            clicked
-        };
-        if let Some(name) = clicked {
-            act(app, "table.style", json!({"table": tname, "style": name}));
-        }
-        let more = icon_button(ui, Icon::Chevron, t.text_dim, "More Table Styles", vec2(18.0, 40.0));
-        anchor_keytip(app, ui, &more, &["table.style"]);
-        egui::Popup::menu(&more).show(|ui| table_gallery(app, ui, "table.style"));
-    });
-}
-
-fn chart_design(app: &mut SheetApp, ui: &mut Ui) {
-    let Some(id) = app.selected_chart else { return };
-    let ae = big_button(ui, Icon::Chart, "Add Chart\nElement", "Add Chart Element", true);
-    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["chart.set"]) {
-        keytip(app, ui, sequence, ae.rect.center_bottom());
-    }
-    egui::Popup::menu(&ae).show(|ui| {
-        menu_items(
-            app,
-            ui,
-            &[
-                ("Legend: Bottom", "chart.set", json!({"chart": id, "legend": "bottom"})),
-                ("Legend: Right", "chart.set", json!({"chart": id, "legend": "right"})),
-                ("Legend: Top", "chart.set", json!({"chart": id, "legend": "top"})),
-                ("Legend: None", "chart.set", json!({"chart": id, "legend": "none"})),
-                ("-", "", json!(null)),
-                ("Data Labels: Show", "chart.set", json!({"chart": id, "dataLabels": true})),
-                ("Data Labels: None", "chart.set", json!({"chart": id, "dataLabels": false})),
-                ("Gridlines: Show", "chart.set", json!({"chart": id, "gridlines": true})),
-                ("Gridlines: None", "chart.set", json!({"chart": id, "gridlines": false})),
-            ],
-        );
-    });
-    let __k = big_button(ui, Icon::Redo, "Switch\nRow/Column", "Switch Row/Column", false);
-    control_keytip(app, ui, &__k, "chart.switchRowColumn");
-    if __k.clicked() {
-        act(app, "chart.switchRowColumn", json!({"chart": id}));
-    }
-    if big_button(ui, Icon::Table, "Select\nData", "Select Data", false).clicked() {
-        app.open_dialog("selectData", json!({"chart": id}));
-    }
-    let ct = big_button(ui, Icon::ChartBar, "Change\nChart Type", "Change Chart Type", true);
-    for sequence in keytip_table::group_extension(
-        app.keytips.prefix().unwrap_or_default(),
-        &["column", "bar", "line", "area", "pie", "doughnut", "scatter", "radar", "waterfall", "funnel", "treemap"],
-    ) {
-        keytip(app, ui, sequence, ct.rect.center_bottom());
-    }
-    egui::Popup::menu(&ct).show(|ui| {
-        for (label, k, s) in [
-            ("Clustered Column", "column", ""),
-            ("Stacked Column", "column", "stacked"),
-            ("Bar", "bar", ""),
-            ("Line", "line", "markers"),
-            ("Area", "area", ""),
-            ("Pie", "pie", ""),
-            ("Doughnut", "doughnut", ""),
-            ("Scatter", "scatter", ""),
-            ("Radar", "radar", ""),
-            ("Waterfall", "waterfall", ""),
-            ("Funnel", "funnel", ""),
-            ("Treemap", "treemap", ""),
-        ] {
-            if ui.button(label).clicked() {
-                act(app, "chart.set", json!({"chart": id, "type": k, "subtype": s}));
-            }
-        }
-    });
-    if big_button(ui, Icon::Settings, "Format\nPane", "Format Chart pane", false).clicked() {
-        app.grid.pane = Some("formatChart".into());
-    }
-    let __k = big_button(ui, Icon::TextBox, "Chart\nTitle", "Edit chart title", false);
-    control_keytip(app, ui, &__k, "chartTitle");
-    if __k.clicked() {
-        app.open_dialog("chartTitle", json!({"chart": id}));
-    }
-    let __k = big_button(ui, Icon::Delete, "Delete\nChart", "Delete chart", false);
-    control_keytip(app, ui, &__k, "chart.delete");
-    if __k.clicked() {
-        act(app, "chart.delete", json!({"chart": id}));
-        app.selected_chart = None;
-    }
-}
-
-/// Command-key shortcuts when the grid has focus.
-pub fn shortcut(app: &mut SheetApp, key: Key, m: Modifiers) {
-    let shift = m.shift;
-    let id: Option<(&str, serde_json::Value)> = match key {
-        Key::B => Some(("home.bold", json!({}))),
-        Key::I => Some(("home.italic", json!({}))),
-        Key::U => Some(("home.underline", json!({}))),
-        Key::Z if shift => Some(("edit.redo", json!({}))),
-        Key::Z => Some(("edit.undo", json!({}))),
-        Key::Y => Some(("edit.redo", json!({}))),
-        Key::A => Some(("edit.selectAll", json!({}))),
-        Key::D => Some(("edit.fillDown", json!({}))),
-        Key::R => Some(("edit.fillRight", json!({}))),
-        Key::S if shift => Some(("file.saveAs", json!({}))),
-        Key::S => Some(("file.save", json!({}))),
-        Key::O => Some(("file.open", json!({}))),
-        Key::N => Some(("file.new", json!({}))),
-        Key::W => Some(("file.close", json!({}))),
-        Key::P => {
-            app.print_now(json!({}));
-            None
-        }
-        Key::K => {
-            app.open_dialog("insertLink", json!({}));
-            None
-        }
-        Key::F if shift => Some(("data.filter", json!({}))),
-        Key::F => {
-            app.open_dialog("find", json!({}));
-            None
-        }
-        Key::H => {
-            app.open_dialog("find", json!({"replace": true}));
-            None
-        }
-        Key::G => {
-            app.open_dialog("goTo", json!({}));
-            None
-        }
-        Key::T if shift => Some(("formulas.autoSum", json!({}))),
-        Key::T => Some(("insert.table", json!({}))),
-        Key::E => Some(("edit.flashFill", json!({}))),
-        Key::Num1 => {
-            app.open_dialog("formatCells", json!({}));
-            None
-        }
-        Key::Num9 if shift => Some(("home.unhideRows", json!({}))),
-        Key::Num9 => Some(("home.hideRows", json!({}))),
-        Key::Num0 if shift => Some(("home.unhideColumns", json!({}))),
-        Key::Num0 => Some(("home.hideColumns", json!({}))),
-        // As in Excel: with whole rows or whole columns selected, Ctrl+Shift+= / Ctrl+- insert or
-        // delete them at once; any other selection asks which way to shift.
-        Key::Minus => match whole_lines(app) {
-            Some(true) => Some(("home.deleteRows", json!({}))),
-            Some(false) => Some(("home.deleteColumns", json!({}))),
-            None => {
-                app.open_dialog("deleteCells", json!({}));
-                None
-            }
-        },
-        // Insert works on one area at a time, so several areas still go through the dialog.
-        Key::Plus | Key::Equals if shift => match whole_lines(app).filter(|_| single_area(app)) {
-            Some(true) => Some(("home.insertRows", json!({}))),
-            Some(false) => Some(("home.insertColumns", json!({}))),
-            None => {
-                app.open_dialog("insertCells", json!({}));
-                None
-            }
-        },
-        Key::Semicolon => {
-            // Insert today's date.
-            let text = app
-                .session
-                .active()
-                .map(|d| {
-                    let today = gridcraft_engine::core::date::serial_in_system(d.wb.date_system, gridcraft_engine::calc::now_serial()).floor();
-                    gridcraft_engine::display::format(&gridcraft_engine::core::Value::Number(today), "m/d/yyyy", &d.wb).text
-                })
-                .unwrap_or_default();
-            app.begin_edit(Some(text), false);
-            None
-        }
-        Key::Backtick => Some(("formulas.showFormulas", json!({}))),
-        _ => None,
-    };
-    if let Some((id, p)) = id {
-        app.run_or_alert(id, p);
-        app.grid.ensure_visible = true;
-    }
-}
-
-#[cfg(test)]
-mod title_bar_tests {
-    use super::*;
-
-    #[test]
-    fn mac_title_bar_centres_and_clears_the_traffic_lights() {
-        // The lights are centred in the bar, and content keeps the same gap after them.
-        let margin = (MAC_TITLE_BAR - MAC_LIGHT) / 2.0;
-        let lights_end = MAC_LIGHTS_LEFT + 2.0 * MAC_LIGHT_PITCH + MAC_LIGHT;
-        assert_eq!(MAC_CONTENT_LEFT - lights_end, margin);
-    }
-
-    #[test]
-    fn title_fits_between_the_controls() {
-        // Room limited by the nearer side, symmetric about the centre.
-        assert_eq!(title_max_width(500.0, 300.0, 900.0), 2.0 * (200.0 - TITLE_GAP));
-        assert_eq!(title_max_width(500.0, 100.0, 650.0), 2.0 * (150.0 - TITLE_GAP));
-        // Controls overlapping the centre leave no room rather than a negative width.
-        assert_eq!(title_max_width(500.0, 520.0, 900.0), 0.0);
-    }
-
-    /// Lay out a title in a real egui frame, returning (title text, title width, dot width).
-    fn layout_title(title: &str, dirty: bool, max_w: f32) -> (String, f32, f32) {
-        let ctx = egui::Context::default();
-        ctx.set_fonts(theme::font_definitions());
-        let mut out = (String::new(), 0.0, 0.0);
-        let mut frame = ctx.run_ui(egui::RawInput::default(), |ui| {
-            let (galley, dot) = title_galleys(ui.painter(), title, dirty, max_w, Color32::WHITE);
-            // The glyphs actually drawn: `galley.text()` is the untruncated source.
-            let shown = galley.rows.iter().flat_map(|r| r.glyphs.iter().map(|g| g.chr)).collect();
-            out = (shown, galley.size().x, dot.map_or(0.0, |d| d.size().x));
-        });
-        frame.textures_delta.clear(); // nothing consumes the atlas in a headless test
-        out
-    }
-
-    #[test]
-    fn long_title_is_truncated_with_an_ellipsis() {
-        let long = format!("upload-{}-cleaned (1).xlsx", "3FMyNTYg2gDaANiAAACq20AAAAQMBqug".repeat(4));
-        let (text, w, _) = layout_title(&long, false, 300.0);
-        assert!(text.ends_with('…'), "truncated title ends with an ellipsis: {text:?}");
-        assert!(text.chars().count() < long.chars().count());
-        assert!(w <= 300.0, "title stays within its room: {w}");
-    }
-
-    #[test]
-    fn short_title_is_left_whole() {
-        let (text, _, _) = layout_title("Book1.xlsx", false, 300.0);
-        assert_eq!(text, "Book1.xlsx");
-    }
-
-    #[test]
-    fn unsaved_dot_survives_truncation() {
-        let long = "a very long workbook name ".repeat(20);
-        let (text, w, dot_w) = layout_title(&long, true, 200.0);
-        assert!(dot_w > 0.0, "the unsaved marker is laid out");
-        assert!(text.ends_with('…'));
-        assert!(w + dot_w <= 200.0, "title and marker fit together: {}", w + dot_w);
-    }
-
-    #[test]
-    fn no_room_draws_nothing_but_does_not_crash() {
-        let (_, w, _) = layout_title("Book1.xlsx", true, 0.0);
-        assert!(w <= 20.0, "a zero-width slot leaves at most the ellipsis: {w}");
-    }
-}
-
-#[cfg(test)]
-mod checkbox_on_tests {
-    use super::*;
-
-    #[test]
-    fn click_sends_the_new_checkbox_value_and_key_tip_the_opposite() {
-        // Click: the checkbox bool already holds the new choice.
-        assert!(!checkbox_on(true, false));
-        assert!(checkbox_on(true, true));
-        // Key tip: the bool still holds the current setting, so toggle it.
-        assert!(checkbox_on(false, false));
-        assert!(!checkbox_on(false, true));
-    }
-}
-
-/// Whether the selection is a single area.
-fn single_area(app: &SheetApp) -> bool {
-    app.session.active().is_some_and(|d| d.selection.ranges.len() == 1)
-}
-
-/// `Some(true)` when every selected area is whole rows, `Some(false)` when every one is whole
-/// columns, `None` otherwise (including the whole sheet).
-fn whole_lines(app: &SheetApp) -> Option<bool> {
-    let sel = &app.session.active()?.selection;
-    let rows = sel.ranges.iter().all(|r| r.is_full_rows() && !r.is_full_cols());
-    let cols = sel.ranges.iter().all(|r| r.is_full_cols() && !r.is_full_rows());
-    if rows {
-        Some(true)
-    } else if cols {
-        Some(false)
-    } else {
-        None
-    }
-}
-
-#[cfg(test)]
-mod accounting_symbol_tests {
-    use super::*;
-    use gridcraft_engine::core::{DateSystem, Value};
-    use gridcraft_engine::numfmt::{NumberFormat, format_value};
-
-    #[test]
-    fn accounting_dropdown_offers_the_issue_currencies_with_excel_codes() {
-        // #1063: label, Excel's [$symbol-LCID] tag, and 1234.5 as Excel shows it (fill and the
-        // `_-` padding aside). The yen and won have no minor unit, so their codes show no decimals.
-        for (label, tag, shown) in [
-            ("Rp Indonesian", "[$Rp-421]", "Rp1,234.50"),
-            ("₹ English (India)", "[$₹-4009]", "₹1,234.50"),
-            ("₩ Korean", "[$₩-412]", "₩1,235"),
-            ("¥ Chinese (PRC)", "[$¥-804]", "¥1,234.50"),
-            ("¥ Japanese", "[$¥-411]", "¥1,235"),
-        ] {
-            let code = ACCOUNTING_SYMBOLS.iter().find(|(l, _)| *l == label).map(|(_, c)| *c);
-            let Some(code) = code else { panic!("{label} is not in the Accounting dropdown") };
-            assert!(code.split(';').take(3).all(|section| section.contains(tag)), "{label}: {code}");
-            let out = format_value(&Value::Number(1234.5), &NumberFormat::parse(code), DateSystem::D1900);
-            assert_eq!(out.text.trim(), shown, "{label}");
-            let symbol = tag.trim_start_matches("[$").split('-').next().unwrap_or_default();
-            assert_eq!(out.fill.map(|(c, at)| (c, out.text[..at].trim_start())), Some((' ', symbol)), "{label}");
-        }
-    }
-}
diff --git a/crates/ui-egui/src/ribbon/automate.rs b/crates/ui-egui/src/ribbon/automate.rs
new file mode 100644
index 000000000..5a9de6b50
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/automate.rs
@@ -0,0 +1,33 @@
+use super::controls::control_keytip;
+use super::*;
+
+pub(super) fn automate(app: &mut SheetApp, ui: &mut Ui) {
+    if big_button(ui, Icon::Script, "Macros", "Macros and scripts in this workbook (Alt+F8)", false).clicked() {
+        app.open_dialog("macros", json!({}));
+    }
+    let __k = big_button(ui, Icon::Script, "Command\nPalette", "Search and run any command", false);
+    control_keytip(app, ui, &__k, "commandSearch");
+    if __k.clicked() {
+        app.open_dialog("commandSearch", json!({}));
+    }
+    let __k = big_button(ui, Icon::Script, "Agent\nControl", "How agents drive GridCraft (MCP / control channel)", false);
+    control_keytip(app, ui, &__k, "agents");
+    if __k.clicked() {
+        app.open_dialog("agents", json!({}));
+    }
+    let __k = big_button(ui, Icon::Script, "Action\nJournal", "Every command run in this session (replayable)", false);
+    control_keytip(app, ui, &__k, "journal");
+    if __k.clicked() {
+        app.open_dialog("journal", json!({}));
+    }
+    let __k = big_button(ui, Icon::Script, "Check for\nUpdates…", "Look for a newer GridCraft release", false);
+    control_keytip(app, ui, &__k, "checkForUpdates");
+    if __k.clicked() {
+        app.run_or_alert("app.checkForUpdates", json!({}));
+    }
+    let __k = big_button(ui, Icon::Script, "About\nGridCraft", "Version, contributors and the AI models that helped", false);
+    control_keytip(app, ui, &__k, "about");
+    if __k.clicked() {
+        app.open_dialog("about", json!({}));
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/contextual.rs b/crates/ui-egui/src/ribbon/contextual.rs
new file mode 100644
index 000000000..497480191
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/contextual.rs
@@ -0,0 +1,183 @@
+use super::controls::{act, anchor_keytip, control_keytip, keytip, menu_items, sep};
+use super::galleries::{paint_table_swatch, table_gallery};
+use super::*;
+
+/// Draws the Table Design tab: rename, resize, remove duplicates, convert to range, slicer, table options and the style strip.
+pub(super) fn table_design(app: &mut SheetApp, ui: &mut Ui) {
+    let Some((tname, header, totals, banded, banded_c, first, last, filter, style)) = app.session.active().and_then(|d| {
+        let sh = d.wb.active()?;
+        let t = sh.table_at(d.selection.active)?;
+        Some((t.name.clone(), t.header_row, t.totals_row, t.banded_rows, t.banded_cols, t.first_col, t.last_col, t.filter_button, t.style.clone()))
+    }) else {
+        return;
+    };
+    ui.vertical(|ui| {
+        ui.label(egui::RichText::new("Table Name:").small());
+        let field = egui::Id::unique(("gridcraft.table_name", &tname));
+        if let Some(name) = crate::widgets::committed_text(ui, field, &tname, Some(120.0))
+            && name != tname
+        {
+            act(app, "table.rename", json!({"table": tname, "name": name}));
+        }
+    });
+    let __k = big_button(ui, Icon::Table, "Resize\nTable", "Resize Table", false);
+    control_keytip(app, ui, &__k, "dialog:tableResize");
+    if __k.clicked() {
+        app.open_dialog("tableResize", json!({}));
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::Duplicates, "Remove\nDuplicates", "Remove Duplicates", false);
+    control_keytip(app, ui, &__k, "data.removeDuplicates");
+    if __k.clicked() {
+        act(app, "data.removeDuplicates", json!({}));
+    }
+    let __k = big_button(ui, Icon::Table, "Convert\nto Range", "Convert to Range", false);
+    control_keytip(app, ui, &__k, "table.convertToRange");
+    if __k.clicked() {
+        act(app, "table.convertToRange", json!({"table": tname}));
+    }
+    sep(ui);
+    if big_button(ui, Icon::Filter, "Insert\nSlicer", "Insert Slicer", false).clicked() {
+        act(app, "table.insertSlicer", json!({"table": tname}));
+    }
+    sep(ui);
+    ui.vertical(|ui| {
+        for (label, cmd, v) in [
+            ("Header Row", "table.headerRow", header && filter),
+            ("Total Row", "table.totalRow", totals),
+            ("Banded Rows", "table.bandedRows", banded),
+        ] {
+            let mut on = v;
+            if ui.checkbox(&mut on, label).changed() {
+                act(app, cmd, json!({"table": tname, "on": on}));
+            }
+        }
+    });
+    ui.vertical(|ui| {
+        for (label, cmd, v) in [
+            ("First Column", "table.firstColumn", first),
+            ("Last Column", "table.lastColumn", last),
+            ("Banded Columns", "table.bandedColumns", banded_c),
+        ] {
+            let mut on = v;
+            if ui.checkbox(&mut on, label).changed() {
+                act(app, cmd, json!({"table": tname, "on": on}));
+            }
+        }
+    });
+    sep(ui);
+    table_style_strip(app, ui, &tname, &style);
+}
+
+/// The first page of Excel's Table Styles gallery, drawn in the ribbon. The More arrow opens the
+/// full gallery (Light, Medium, Dark) as a popup.
+const RIBBON_TABLE_STYLES: [&str; 7] =
+    ["TableStyleLight1", "TableStyleLight2", "TableStyleLight3", "TableStyleLight4", "TableStyleLight5", "TableStyleLight6", "TableStyleLight7"];
+
+fn table_style_strip(app: &mut SheetApp, ui: &mut Ui, tname: &str, current: &str) {
+    let t = Tokens::get(ui.ctx());
+    ui.add_space(12.0);
+    ui.horizontal(|ui| {
+        ui.spacing_mut().item_spacing.x = 3.0;
+        // Borrow the workbook only while painting; the session must be free for `act` afterwards.
+        let clicked = {
+            let Some(d) = app.session.active() else { return };
+            let wb = &d.wb;
+            let mut clicked = None;
+            for name in RIBBON_TABLE_STYLES {
+                let (r, resp) = ui.allocate_exact_size(vec2(52.0, 40.0), Sense::click());
+                paint_table_swatch(ui, r, wb, name);
+                if name == current {
+                    ui.painter().rect_stroke(r.expand(2.5), 2.0, Stroke::new(2.0, t.accent), StrokeKind::Outside);
+                }
+                if resp.hovered() {
+                    ui.painter().rect_stroke(r.expand(1.0), 2.0, Stroke::new(2.0, Color32::from_rgb(0xE8, 0x7D, 0x2B)), StrokeKind::Outside);
+                }
+                if resp.on_hover_text(name).clicked() {
+                    clicked = Some(name);
+                }
+            }
+            clicked
+        };
+        if let Some(name) = clicked {
+            act(app, "table.style", json!({"table": tname, "style": name}));
+        }
+        let more = icon_button(ui, Icon::Chevron, t.text_dim, "More Table Styles", vec2(18.0, 40.0));
+        anchor_keytip(app, ui, &more, &["table.style"]);
+        egui::Popup::menu(&more).show(|ui| table_gallery(app, ui, "table.style"));
+    });
+}
+
+pub(super) fn chart_design(app: &mut SheetApp, ui: &mut Ui) {
+    let Some(id) = app.selected_chart else { return };
+    let ae = big_button(ui, Icon::Chart, "Add Chart\nElement", "Add Chart Element", true);
+    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["chart.set"]) {
+        keytip(app, ui, sequence, ae.rect.center_bottom());
+    }
+    egui::Popup::menu(&ae).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Legend: Bottom", "chart.set", json!({"chart": id, "legend": "bottom"})),
+                ("Legend: Right", "chart.set", json!({"chart": id, "legend": "right"})),
+                ("Legend: Top", "chart.set", json!({"chart": id, "legend": "top"})),
+                ("Legend: None", "chart.set", json!({"chart": id, "legend": "none"})),
+                ("-", "", json!(null)),
+                ("Data Labels: Show", "chart.set", json!({"chart": id, "dataLabels": true})),
+                ("Data Labels: None", "chart.set", json!({"chart": id, "dataLabels": false})),
+                ("Gridlines: Show", "chart.set", json!({"chart": id, "gridlines": true})),
+                ("Gridlines: None", "chart.set", json!({"chart": id, "gridlines": false})),
+            ],
+        );
+    });
+    let __k = big_button(ui, Icon::Redo, "Switch\nRow/Column", "Switch Row/Column", false);
+    control_keytip(app, ui, &__k, "chart.switchRowColumn");
+    if __k.clicked() {
+        act(app, "chart.switchRowColumn", json!({"chart": id}));
+    }
+    if big_button(ui, Icon::Table, "Select\nData", "Select Data", false).clicked() {
+        app.open_dialog("selectData", json!({"chart": id}));
+    }
+    let ct = big_button(ui, Icon::ChartBar, "Change\nChart Type", "Change Chart Type", true);
+    for sequence in keytip_table::group_extension(
+        app.keytips.prefix().unwrap_or_default(),
+        &["column", "bar", "line", "area", "pie", "doughnut", "scatter", "radar", "waterfall", "funnel", "treemap"],
+    ) {
+        keytip(app, ui, sequence, ct.rect.center_bottom());
+    }
+    egui::Popup::menu(&ct).show(|ui| {
+        for (label, k, s) in [
+            ("Clustered Column", "column", ""),
+            ("Stacked Column", "column", "stacked"),
+            ("Bar", "bar", ""),
+            ("Line", "line", "markers"),
+            ("Area", "area", ""),
+            ("Pie", "pie", ""),
+            ("Doughnut", "doughnut", ""),
+            ("Scatter", "scatter", ""),
+            ("Radar", "radar", ""),
+            ("Waterfall", "waterfall", ""),
+            ("Funnel", "funnel", ""),
+            ("Treemap", "treemap", ""),
+        ] {
+            if ui.button(label).clicked() {
+                act(app, "chart.set", json!({"chart": id, "type": k, "subtype": s}));
+            }
+        }
+    });
+    if big_button(ui, Icon::Settings, "Format\nPane", "Format Chart pane", false).clicked() {
+        app.grid.pane = Some("formatChart".into());
+    }
+    let __k = big_button(ui, Icon::TextBox, "Chart\nTitle", "Edit chart title", false);
+    control_keytip(app, ui, &__k, "chartTitle");
+    if __k.clicked() {
+        app.open_dialog("chartTitle", json!({"chart": id}));
+    }
+    let __k = big_button(ui, Icon::Delete, "Delete\nChart", "Delete chart", false);
+    control_keytip(app, ui, &__k, "chart.delete");
+    if __k.clicked() {
+        act(app, "chart.delete", json!({"chart": id}));
+        app.selected_chart = None;
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/controls.rs b/crates/ui-egui/src/ribbon/controls.rs
new file mode 100644
index 000000000..e77e583a6
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/controls.rs
@@ -0,0 +1,270 @@
+use super::*;
+
+pub(super) fn sep(ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    let (r, _) = ui.allocate_exact_size(vec2(13.0, 72.0), Sense::hover());
+    ui.painter().line_segment([pos2(r.center().x, r.top() + 6.0), pos2(r.center().x, r.bottom() - 6.0)], Stroke::new(1.0, t.separator));
+}
+
+pub(super) fn active_style(app: &SheetApp) -> Style {
+    app.session
+        .active()
+        .and_then(|d| {
+            let sh = d.wb.active()?;
+            Some(d.wb.styles.get(sh.style_id(d.selection.active)).clone())
+        })
+        .unwrap_or_default()
+}
+
+pub(super) fn theme_colors(app: &SheetApp) -> [u32; 12] {
+    app.session.active().map(|d| d.wb.theme.colors).unwrap_or(gridcraft_engine::model::Theme::default().colors)
+}
+
+/// Runs a command from a ribbon click (menu-style: no params may open a dialog).
+pub(super) fn act(app: &mut SheetApp, id: &str, params: serde_json::Value) {
+    app.run_or_alert(id, params);
+}
+
+/// Keytips are painted, not focusable widgets: the grid retains keyboard focus.
+pub(super) fn keytip(app: &SheetApp, ui: &Ui, sequence: &str, at: egui::Pos2) {
+    let Some(rest) = app.keytips.prefix().and_then(|prefix| sequence.strip_prefix(prefix)).filter(|s| !s.is_empty()) else { return };
+    let t = Tokens::get(ui.ctx());
+    let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("ribbon_keytips"))).with_clip_rect(ui.clip_rect());
+    let text = painter.layout_no_wrap(rest.into(), theme::ui_bold(10.5), t.text);
+    let rect = Rect::from_center_size(at, text.size() + vec2(7.0, 3.0));
+    painter.rect_filled(rect, 2.0, t.input_bg);
+    painter.rect_stroke(rect, 2.0, Stroke::new(1.0, t.text_dim), StrokeKind::Inside);
+    painter.galley(rect.min + vec2(3.5, 1.5), text, t.text);
+}
+
+/// Paint the badge for a control that runs command `id`, when the armed prefix matches.
+pub(super) fn control_keytip(app: &SheetApp, ui: &Ui, response: &egui::Response, id: &str) {
+    if let Some(sequence) = keytip_table::control_badge(app.keytips.prefix().unwrap_or_default(), id) {
+        keytip(app, ui, sequence, response.rect.center_bottom());
+    }
+}
+
+/// Paint the single badge for a menu anchor whose popup items run `targets`.
+pub(super) fn anchor_keytip(app: &SheetApp, ui: &Ui, response: &egui::Response, targets: &[&str]) {
+    if let Some(sequence) = keytip_table::anchor_badge(app.keytips.prefix().unwrap_or_default(), targets) {
+        keytip(app, ui, sequence, response.rect.center_bottom());
+    }
+}
+
+/// The `on` value for a ribbon checkbox command. A click has already flipped the checkbox bool, so
+/// it is sent as is; a key tip leaves the bool untouched, so the command gets the opposite.
+pub(super) fn checkbox_on(clicked: bool, shown: bool) -> bool {
+    shown == clicked
+}
+
+/// Consume a one-shot keytip request for control `id` (set by `Action::Control`).
+pub(super) fn invoke(app: &mut SheetApp, id: &str) -> bool {
+    if app.ui.keytip_invoke == Some(id) {
+        app.ui.keytip_invoke = None;
+        true
+    } else {
+        false
+    }
+}
+
+/// Force-open command for a popup: either a keytip invoke (open it) or a click (toggle).
+pub(super) fn popup_command(forced: bool, clicked: bool) -> Option<egui::SetOpenCommand> {
+    if forced { Some(egui::SetOpenCommand::Bool(true)) } else { clicked.then_some(egui::SetOpenCommand::Toggle) }
+}
+
+/// Per-control state of an [`editable_combo`]: the filter text and highlighted row.
+#[derive(Clone, Default)]
+struct ComboState {
+    text: String,
+    sel: i32,
+    was_open: bool,
+}
+
+/// What the user did with an [`editable_combo`].
+pub(crate) enum ComboResult {
+    None,
+    /// A row was applied: clicked or Enter on the highlighted row.
+    Picked(String),
+}
+
+/// Excel-style dropdown: a filter field (type to narrow the list) plus arrow/Enter selection.
+/// `items` are `(value, display)`; the value is what comes back. When `forced` (keytip invoke)
+/// or clicked, the popup opens, focuses the filter field, and selects its text.
+pub(crate) fn editable_combo(
+    ui: &mut Ui,
+    anchor: &egui::Response,
+    salt: &'static str,
+    current_value: &str,
+    items: &[(&str, String)],
+    forced: bool,
+) -> ComboResult {
+    combo_popup(ui, anchor, salt, current_value, items, forced, true, None)
+}
+
+/// The dropdown of [`editable_combo`] without the filter field: the whole list, picked by click or
+/// arrows and Enter. It drops directly below `under` and is as wide as it, like Excel's Font Size
+/// list under its box.
+pub(super) fn list_combo(
+    ui: &mut Ui,
+    anchor: &egui::Response,
+    under: Rect,
+    salt: &'static str,
+    current_value: &str,
+    items: &[(&str, String)],
+) -> ComboResult {
+    combo_popup(ui, anchor, salt, current_value, items, false, false, Some(under))
+}
+
+fn combo_popup(
+    ui: &mut Ui,
+    anchor: &egui::Response,
+    salt: &'static str,
+    current_value: &str,
+    items: &[(&str, String)],
+    forced: bool,
+    filter: bool,
+    under: Option<Rect>,
+) -> ComboResult {
+    let popup_id = anchor.id.with("popup");
+    let state_id = anchor.id.with(salt).with("__combo_state");
+    let mut st = ui.data_mut(|d| d.get_temp::<ComboState>(state_id)).unwrap_or_default();
+    let open_now = egui::Popup::is_id_open(ui.ctx(), popup_id);
+    if open_now && !st.was_open {
+        st.text = String::new();
+        st.sel = items.iter().position(|(v, _)| *v == current_value).map(|i| i as i32).unwrap_or(0);
+        // The reset lands on the frame AFTER the popup opens, which usually has no input of
+        // its own — without a repaint request the stale filtered list stays on screen.
+        ui.ctx().request_repaint();
+    }
+    st.was_open = open_now;
+    let mut result = ComboResult::None;
+    let mut popup = egui::Popup::menu(anchor).open_memory(popup_command(forced, anchor.clicked()));
+    if let Some(r) = under {
+        popup = popup.anchor(r).align(egui::RectAlign::BOTTOM_START).width(r.width());
+    }
+    let row_w = under.map_or(220.0, |r| r.width() - 12.0);
+    popup.show(|ui| {
+        // Arrows and Enter navigate the list, not the filter field's cursor. Capture them and
+        // strip them from the input so the TextEdit never sees them.
+        let (mut down, mut up, mut enter) = (false, false, false);
+        ui.input(|i| {
+            down = i.key_pressed(egui::Key::ArrowDown);
+            up = i.key_pressed(egui::Key::ArrowUp);
+            enter = i.key_pressed(egui::Key::Enter);
+        });
+        if down || up || enter {
+            ui.ctx().input_mut(|i| {
+                i.events.retain(|e| {
+                    !matches!(e, egui::Event::Key { key: egui::Key::ArrowDown | egui::Key::ArrowUp | egui::Key::Enter, pressed: true, .. })
+                });
+            });
+        }
+        if filter {
+            let text_id = anchor.id.with(salt).with("__combo_text");
+            let te = ui.add(egui::TextEdit::singleline(&mut st.text).id(text_id).desired_width(220.0).hint_text("Type to filter…"));
+            if open_now && !te.has_focus() {
+                ui.ctx().memory_mut(|m| m.request_focus(text_id));
+                // Select all once focus lands so typing replaces the filter.
+                if let Some(mut s) = egui::text_edit::TextEditState::load(ui.ctx(), text_id) {
+                    let len = st.text.chars().count();
+                    s.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(len))));
+                    s.store(ui.ctx(), text_id);
+                }
+            }
+        }
+        let lower = st.text.to_lowercase();
+        let filtered: Vec<usize> = items.iter().enumerate().filter(|(_, (_, d))| d.to_lowercase().contains(&lower)).map(|(i, _)| i).collect();
+        if !filtered.is_empty() {
+            let n = filtered.len() as i32;
+            st.sel = st.sel.clamp(0, n - 1);
+            if down {
+                st.sel = (st.sel + 1).rem_euclid(n);
+            }
+            if up {
+                st.sel = (st.sel - 1).rem_euclid(n);
+            }
+        }
+        if enter && !filtered.is_empty() {
+            let idx = filtered[st.sel.clamp(0, filtered.len() as i32 - 1) as usize];
+            result = ComboResult::Picked(items[idx].0.to_string());
+        }
+        if filter {
+            ui.separator();
+        }
+        let button_h = ui.spacing().interact_size.y.max(20.0);
+        let spacing = ui.spacing().item_spacing.y;
+        let n = filtered.len() as f32;
+
+        let content_h = n * button_h + (n - 1.0).max(0.0) * spacing;
+
+        let max_rows = 9.0_f32;
+        let max_h = max_rows * button_h + (max_rows - 1.0) * spacing;
+
+        let desired_h = content_h.min(max_h);
+
+        ui.set_min_height(desired_h);
+
+        egui::ScrollArea::vertical().max_height(desired_h).show(ui, |ui| {
+            for (pos, i) in filtered.iter().enumerate() {
+                let (value, disp) = &items[*i];
+
+                let row = ui.add(egui::Button::selectable(pos as i32 == st.sel, egui::RichText::new(disp)).min_size(vec2(row_w, 20.0)));
+
+                if (down || up) && pos as i32 == st.sel && !ui.clip_rect().contains_rect(row.rect) {
+                    row.scroll_to_me(Some(if down { egui::Align::Max } else { egui::Align::Min }));
+                }
+
+                if row.clicked() {
+                    result = ComboResult::Picked(value.to_string());
+                }
+
+                if row.hovered() {
+                    st.sel = pos as i32;
+                }
+            }
+        });
+        if !matches!(result, ComboResult::None) {
+            ui.close();
+        }
+    });
+    ui.data_mut(|d| d.insert_temp(state_id, st));
+    result
+}
+
+pub(super) fn menu_items(app: &mut SheetApp, ui: &mut Ui, items: &[(&str, &str, serde_json::Value)]) {
+    for (label, id, p) in items {
+        if *label == "-" {
+            ui.separator();
+            continue;
+        }
+        let lang = app.ui.language;
+        let response = ui.add(egui::Button::new(lang.tr(label)).frame_when_inactive(false).min_size(vec2(220.0, 22.0)));
+        if let Some(sequence) = keytip_table::item_letter(app.keytips.prefix().unwrap_or_default(), id) {
+            keytip(app, ui, sequence, pos2(response.rect.right() - 10.0, response.rect.center().y));
+        }
+        if response.clicked() {
+            if let Some(d) = id.strip_prefix("dialog:") {
+                app.open_dialog(d, p.clone());
+            } else if *id == "edit.paste" {
+                app.paste_from_clipboard();
+            } else {
+                act(app, id, p.clone());
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod checkbox_on_tests {
+    use super::*;
+
+    #[test]
+    fn click_sends_the_new_checkbox_value_and_key_tip_the_opposite() {
+        // Click: the checkbox bool already holds the new choice.
+        assert!(!checkbox_on(true, false));
+        assert!(checkbox_on(true, true));
+        // Key tip: the bool still holds the current setting, so toggle it.
+        assert!(checkbox_on(false, false));
+        assert!(!checkbox_on(false, true));
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/data.rs b/crates/ui-egui/src/ribbon/data.rs
new file mode 100644
index 000000000..52f6669f0
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/data.rs
@@ -0,0 +1,139 @@
+use super::controls::{act, control_keytip, keytip, menu_items, sep};
+use super::*;
+
+pub(super) fn data(app: &mut SheetApp, ui: &mut Ui) {
+    let gd = big_button(ui, Icon::Folder, "Get Data\n(Text/CSV)", "Import a text or CSV file", false);
+    control_keytip(app, ui, &gd, "data.getData");
+    if gd.clicked() {
+        app.open_dialog("open", json!({}));
+    }
+    sep(ui);
+    ui.vertical(|ui| {
+        let __k = small_button(ui, Icon::SortAsc, "", "Sort A to Z", false);
+        control_keytip(app, ui, &__k, "data.sortAscending");
+        if __k.clicked() {
+            act(app, "data.sortAscending", json!({}));
+        }
+        let __k = small_button(ui, Icon::SortDesc, "", "Sort Z to A", false);
+        control_keytip(app, ui, &__k, "data.sortDescending");
+        if __k.clicked() {
+            act(app, "data.sortDescending", json!({}));
+        }
+    });
+    let __k = big_button(ui, Icon::SortFilter, "Sort", "Custom Sort", false);
+    control_keytip(app, ui, &__k, "dialog:sort");
+    if __k.clicked() {
+        app.open_dialog("sort", json!({}));
+    }
+    let __k = big_button(ui, Icon::Filter, "Filter", "Filter", false);
+    control_keytip(app, ui, &__k, "data.filter");
+    if __k.clicked() {
+        act(app, "data.filter", json!({}));
+    }
+    ui.vertical(|ui| {
+        let __k = small_button(ui, Icon::Eraser, "Clear", "Clear Filter", false);
+        control_keytip(app, ui, &__k, "data.clearFilter");
+        if __k.clicked() {
+            act(app, "data.clearFilter", json!({}));
+        }
+        let __k = small_button(ui, Icon::Redo, "Reapply", "Reapply", false);
+        control_keytip(app, ui, &__k, "data.reapply");
+        if __k.clicked() {
+            act(app, "data.reapply", json!({}));
+        }
+        let __k = small_button(ui, Icon::Filter, "Advanced", "Advanced Filter", false);
+        control_keytip(app, ui, &__k, "dialog:advancedFilter");
+        if __k.clicked() {
+            app.open_dialog("advancedFilter", json!({}));
+        }
+    });
+    sep(ui);
+    let __k = big_button(ui, Icon::TextColumns, "Text to\nColumns", "Text to Columns", false);
+    control_keytip(app, ui, &__k, "dialog:textToColumns");
+    if __k.clicked() {
+        app.open_dialog("textToColumns", json!({}));
+    }
+    let __k = big_button(ui, Icon::FillDown, "Flash\nFill", "Flash Fill", false);
+    control_keytip(app, ui, &__k, "edit.flashFill");
+    if __k.clicked() {
+        act(app, "edit.flashFill", json!({}));
+    }
+    let __k = big_button(ui, Icon::Duplicates, "Remove\nDuplicates", "Remove Duplicates", false);
+    control_keytip(app, ui, &__k, "dialog:removeDuplicates");
+    if __k.clicked() {
+        app.open_dialog("removeDuplicates", json!({}));
+    }
+    let dv = big_button(ui, Icon::Validation, "Data\nValidation", "Data Validation", true);
+    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["data.validation", "data.circleInvalid"]) {
+        keytip(app, ui, sequence, dv.rect.center_bottom());
+    }
+    egui::Popup::menu(&dv).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Data Validation…", "dialog:dataValidation", json!({})),
+                ("Circle Invalid Data", "data.circleInvalid", json!({})),
+                ("Clear Validation", "data.validation", json!({"clear": true})),
+            ],
+        );
+    });
+    sep(ui);
+    let wi = big_button(ui, Icon::Calc, "What-If\nAnalysis", "What-If Analysis", true);
+    for sequence in
+        keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["dialog:goalSeek", "data.scenarioManager", "data.dataTable"])
+    {
+        keytip(app, ui, sequence, wi.rect.center_bottom());
+    }
+    egui::Popup::menu(&wi).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Goal Seek…", "dialog:goalSeek", json!({})),
+                ("Scenario Manager…", "data.scenarioManager", json!({})),
+                ("Data Table…", "data.dataTable", json!({})),
+            ],
+        );
+    });
+    if big_button(ui, Icon::ChartLine, "Forecast\nSheet", "Forecast Sheet", false).clicked() {
+        app.open_dialog("forecastSheet", json!({}));
+    }
+    sep(ui);
+    ui.vertical(|ui| {
+        let __k = small_button(ui, Icon::Group, "Group", "Group", false);
+        control_keytip(app, ui, &__k, "data.group");
+        if __k.clicked() {
+            act(app, "data.group", json!({}));
+        }
+        let __k = small_button(ui, Icon::Ungroup, "Ungroup", "Ungroup", false);
+        control_keytip(app, ui, &__k, "data.ungroup");
+        if __k.clicked() {
+            act(app, "data.ungroup", json!({}));
+        }
+        let __k = small_button(ui, Icon::Subtotal, "Subtotal", "Subtotal", false);
+        control_keytip(app, ui, &__k, "dialog:subtotal");
+        if __k.clicked() {
+            app.open_dialog("subtotal", json!({}));
+        }
+    });
+    ui.vertical(|ui| {
+        if small_button(ui, Icon::Plus, "Show Detail", "Show Detail", false).clicked() {
+            act(app, "data.showDetail", json!({}));
+        }
+        if small_button(ui, Icon::Minus, "Hide Detail", "Hide Detail", false).clicked() {
+            act(app, "data.hideDetail", json!({}));
+        }
+        if small_button(ui, Icon::Settings, "Settings", "Outline Settings", false).clicked() {
+            app.open_dialog("outlineSettings", json!({}));
+        }
+    });
+    sep(ui);
+    if big_button(ui, Icon::ChartBar, "Data\nAnalysis", "Data Analysis", false).clicked() {
+        app.open_dialog("analysisToolPak", json!({}));
+    }
+    sep(ui);
+    if big_button(ui, Icon::Function, "Solver", "Solver", false).clicked() {
+        app.open_dialog("solver", json!({}));
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/formulas.rs b/crates/ui-egui/src/ribbon/formulas.rs
new file mode 100644
index 000000000..caac2da01
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/formulas.rs
@@ -0,0 +1,202 @@
+use super::controls::{act, anchor_keytip, control_keytip, invoke, keytip, menu_items, popup_command, sep};
+use super::home::autosum_menu;
+use super::*;
+
+/// How many cells Formulas › Error Checking › Circular References lists.
+const CIRCULAR_MENU_LIMIT: usize = 100;
+
+/// The cell listed for each circular reference, for the Circular References submenu: each once, in the order
+/// the calculation found them, as (sheet index, cell, "Sheet!A1").
+fn circular_references(app: &SheetApp) -> Vec<(usize, String, String)> {
+    let Some(d) = app.session.active() else { return Vec::new() };
+    let mut seen = std::collections::HashSet::new();
+    d.calc
+        .circular
+        .iter()
+        .filter(|k| seen.insert(**k))
+        .filter_map(|(si, c)| d.wb.sheet(*si).map(|sh| (*si, c.a1(), format!("{}!{}", gridcraft_engine::formula::quote_sheet(&sh.name), c.a1()))))
+        .take(CIRCULAR_MENU_LIMIT)
+        .collect()
+}
+
+/// The Formulas tab: Insert Function, AutoSum, the function-category menus (names in the formula
+/// language, descriptions in the interface language), defined names, auditing and calculation.
+pub(super) fn formulas(app: &mut SheetApp, ui: &mut Ui) {
+    let __k = big_button(ui, Icon::Function, "Insert\nFunction", "Insert Function (⇧F3)", false);
+    control_keytip(app, ui, &__k, "dialog:insertFunction");
+    if __k.clicked() {
+        app.open_dialog("insertFunction", json!({}));
+    }
+    let (s, sa) = big_split_button(ui, Icon::Sum, "AutoSum", "AutoSum");
+    control_keytip(app, ui, &sa, "formulas.autoSum");
+    if s.clicked() {
+        act(app, "formulas.autoSum", json!({}));
+    }
+    egui::Popup::menu(&sa).show(|ui| autosum_menu(app, ui));
+    for (label, cat, cid) in [
+        ("Financial", "Financial", "formulas.financial"),
+        ("Logical", "Logical", "formulas.logical"),
+        ("Text", "Text", "formulas.text"),
+        ("Date &\nTime", "DateTime", "formulas.dateTime"),
+        ("Lookup &\nReference", "Lookup", "formulas.lookup"),
+        ("Math &\nTrig", "MathTrig", "formulas.mathTrig"),
+        ("More\nFunctions", "Statistical", "formulas.moreFunctions"),
+    ] {
+        let r = big_button(ui, Icon::Book, label, label, true);
+        control_keytip(app, ui, &r, cid);
+        let forced_c = invoke(app, cid);
+        egui::Popup::menu(&r).open_memory(popup_command(forced_c, r.clicked())).show(|ui| {
+            ui.set_max_height(420.0);
+            egui::ScrollArea::vertical().show(ui, |ui| {
+                for f in gridcraft_engine::cmd::formulas::function_list() {
+                    if f["category"].as_str() == Some(cat)
+                        && let Some(n) = f["name"].as_str()
+                    {
+                        let locale = app.ui.language.formula_locale();
+                        let name =
+                            app.session.active().map(|d| crate::formula_locale::completion_name(n, locale, &d.wb, d.wb.active_sheet())).unwrap_or(n);
+                        let desc = crate::formula_locale::description(n, locale, app.ui.language).unwrap_or_default();
+                        if ui.button(name).on_hover_text(desc).clicked() {
+                            app.run_or_alert("formulas.insertFunction", json!({"name": n}));
+                            ui.close();
+                        }
+                    }
+                }
+            });
+        });
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::Name, "Name\nManager", "Name Manager", false);
+    control_keytip(app, ui, &__k, "dialog:nameManager");
+    if __k.clicked() {
+        app.open_dialog("nameManager", json!({}));
+    }
+    ui.vertical(|ui| {
+        let __k = small_button(ui, Icon::Name, "Define Name", "Define Name", false);
+        control_keytip(app, ui, &__k, "dialog:defineName");
+        if __k.clicked() {
+            app.open_dialog("defineName", json!({}));
+        }
+        let use_in = small_button(ui, Icon::Function, "Use in Formula", "Use in Formula", true);
+        anchor_keytip(app, ui, &use_in, &["dialog:pasteName"]);
+        egui::Popup::menu(&use_in).show(|ui| {
+            // The menu lists the names Paste Names lists; clicking one runs `formulas.useInFormula`, which puts it at the caret.
+            // Listed when the menu opens, and again only after the workbook changes.
+            let cache = egui::Id::unique("gridcraft.use_in_formula_names");
+            let key = app.session.active().map(|d| (d.uid, d.revision, d.wb.active_sheet()));
+            let cached = ui.ctx().data(|m| m.get_temp::<(Option<(u64, u64, usize)>, std::sync::Arc<Vec<String>>)>(cache)).filter(|(k, _)| *k == key);
+            let names = match cached {
+                Some((_, names)) => names,
+                None => {
+                    let names: std::sync::Arc<Vec<String>> = std::sync::Arc::new(
+                        app.session
+                            .active()
+                            .map(|d| gridcraft_engine::cmd::formulas::pasteable_names(&d.wb).into_iter().map(|(n, _)| n).collect())
+                            .unwrap_or_default(),
+                    );
+                    ui.ctx().data_mut(|m| m.insert_temp(cache, (key, names.clone())));
+                    names
+                }
+            };
+            for n in names.iter() {
+                if ui.button(n).clicked() {
+                    app.run_or_alert("formulas.useInFormula", json!({"name": n}));
+                }
+            }
+            if !names.is_empty() {
+                ui.separator();
+            }
+            if ui.button(app.ui.language.tr("Paste Names…")).clicked() {
+                app.open_dialog("pasteName", json!({}));
+            }
+        });
+        let __k = small_button(ui, Icon::Table, "Create from Selection", "Create from Selection", false);
+        control_keytip(app, ui, &__k, "formulas.createFromSelection");
+        if __k.clicked() {
+            act(app, "formulas.createFromSelection", json!({}));
+        }
+    });
+    sep(ui);
+    ui.vertical(|ui| {
+        if small_button(ui, Icon::Trace, "Trace Precedents", "Trace Precedents", false).clicked()
+            && let Ok(r) = app.run("formulas.tracePrecedents", json!({}))
+        {
+            app.grid.trace = crate::grid::Trace::new(app, r);
+        }
+        if small_button(ui, Icon::Trace, "Trace Dependents", "Trace Dependents", false).clicked()
+            && let Ok(r) = app.run("formulas.traceDependents", json!({}))
+        {
+            app.grid.trace = crate::grid::Trace::new(app, r);
+        }
+        if small_button(ui, Icon::Close, "Remove Arrows", "Remove Arrows", false).clicked() {
+            app.grid.trace = None;
+        }
+    });
+    ui.vertical(|ui| {
+        let __k = small_button(ui, Icon::Fx, "Show Formulas", "Show Formulas", false);
+        control_keytip(app, ui, &__k, "formulas.showFormulas");
+        if __k.clicked() {
+            act(app, "formulas.showFormulas", json!({}));
+        }
+        let (ec, ec_arrow) = small_split_button(ui, Icon::Validation, "Error Checking", "Error Checking");
+        control_keytip(app, ui, &ec, "dialog:errorChecking");
+        if ec.clicked() {
+            app.open_dialog("errorChecking", json!({}));
+        }
+        egui::Popup::menu(&ec_arrow).show(|ui| {
+            let lang = app.ui.language;
+            if ui.button(format!("{}…", lang.tr("Error Checking"))).clicked() {
+                app.open_dialog("errorChecking", json!({}));
+            }
+            let circular = circular_references(app);
+            ui.add_enabled_ui(!circular.is_empty(), |ui| {
+                ui.menu_button(lang.tr("Circular References"), |ui| {
+                    egui::ScrollArea::vertical().id_salt("circular_references").max_height(400.0).show(ui, |ui| {
+                        for (sheet, cell, label) in circular {
+                            if ui.button(label).clicked() {
+                                act(app, "selection.set", json!({"range": cell, "sheet": sheet}));
+                                app.grid.ensure_visible = true;
+                            }
+                        }
+                    });
+                });
+            });
+        });
+        let __k = small_button(ui, Icon::Calc, "Evaluate Formula", "Evaluate Formula", false);
+        control_keytip(app, ui, &__k, "dialog:evaluateFormula");
+        if __k.clicked() {
+            app.open_dialog("evaluateFormula", json!({}));
+        }
+    });
+    if big_button(ui, Icon::Search, "Watch\nWindow", "Watch Window", false).clicked() {
+        app.grid.pane = Some("watch".into());
+    }
+    sep(ui);
+    let co = big_button(ui, Icon::Calc, "Calculation\nOptions", "Calculation Options", true);
+    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["formulas.calculationOptions"]) {
+        keytip(app, ui, sequence, co.rect.center_bottom());
+    }
+    egui::Popup::menu(&co).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Automatic", "formulas.calculationOptions", json!({"mode": "automatic"})),
+                ("Automatic Except for Data Tables", "formulas.calculationOptions", json!({"mode": "automaticExceptTables"})),
+                ("Manual", "formulas.calculationOptions", json!({"mode": "manual"})),
+            ],
+        );
+    });
+    ui.vertical(|ui| {
+        let __k = small_button(ui, Icon::Calc, "Calculate Now", "Calculate Now (F9)", false);
+        control_keytip(app, ui, &__k, "formulas.calculateNow");
+        if __k.clicked() {
+            act(app, "formulas.calculateNow", json!({}));
+        }
+        let __k = small_button(ui, Icon::Sheet, "Calculate Sheet", "Calculate Sheet (⇧F9)", false);
+        control_keytip(app, ui, &__k, "formulas.calculateSheet");
+        if __k.clicked() {
+            act(app, "formulas.calculateSheet", json!({}));
+        }
+    });
+}
diff --git a/crates/ui-egui/src/ribbon/galleries.rs b/crates/ui-egui/src/ribbon/galleries.rs
new file mode 100644
index 000000000..085ba0dc5
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/galleries.rs
@@ -0,0 +1,145 @@
+use super::controls::act;
+use super::*;
+
+/// A gallery of table styles drawn as mini tables.
+pub(super) fn table_gallery(app: &mut SheetApp, ui: &mut Ui, cmd: &str) {
+    ui.set_width(430.0);
+    let Some(wb) = app.session.active().map(|d| d.wb.clone()) else { return };
+    for (fam, n) in [("Light", 21u32), ("Medium", 28), ("Dark", 11)] {
+        ui.label(egui::RichText::new(fam).strong());
+        egui::Grid::new(("tg", fam)).spacing(vec2(4.0, 4.0)).show(ui, |ui| {
+            for i in 1..=n {
+                let name = format!("TableStyle{fam}{i}");
+                let (r, resp) = ui.allocate_exact_size(vec2(54.0, 38.0), Sense::click());
+                paint_table_swatch(ui, r, &wb, &name);
+                if resp.hovered() {
+                    ui.painter().rect_stroke(r.expand(1.5), 2.0, Stroke::new(2.0, Tokens::get(ui.ctx()).cat(Cat::Orange)), StrokeKind::Outside);
+                }
+                if resp.on_hover_text(&name).clicked() {
+                    act(app, cmd, json!({"style": name}));
+                    ui.close();
+                }
+                if i % 7 == 0 {
+                    ui.end_row();
+                }
+            }
+        });
+    }
+}
+
+pub(super) fn paint_table_swatch(ui: &Ui, r: Rect, wb: &gridcraft_engine::model::Workbook, style: &str) {
+    let lk = gridcraft_engine::tables::look(style);
+    let res = |c: Option<gridcraft_engine::model::Color>| c.and_then(|c| c.resolve(&wb.theme)).map(theme::color32);
+    let p = ui.painter();
+    let t = Tokens::get(ui.ctx());
+    p.rect_filled(r, 0.0, t.grid_bg);
+    let rows = 5;
+    let rh = r.height() / rows as f32;
+    for i in 0..rows {
+        let rr = Rect::from_min_size(pos2(r.left(), r.top() + i as f32 * rh), vec2(r.width(), rh));
+        let fill = if i == 0 {
+            res(lk.header_fill)
+        } else if i % 2 == 1 {
+            res(lk.band_fill)
+        } else {
+            res(lk.body_fill)
+        };
+        if let Some(f) = fill {
+            p.rect_filled(rr, 0.0, f);
+        }
+        if let Some(l) = res(lk.line) {
+            p.line_segment([rr.left_bottom(), rr.right_bottom()], Stroke::new(1.0, l));
+        }
+        for k in 0..3 {
+            let x = rr.left() + 4.0 + k as f32 * (r.width() - 8.0) / 3.0;
+            let col = if i == 0 { res(Some(lk.header_font)).unwrap_or(t.cell_text) } else { t.sheet_control_border };
+            p.line_segment([pos2(x, rr.center().y), pos2(x + 10.0, rr.center().y)], Stroke::new(1.0, col));
+        }
+    }
+    p.rect_stroke(r, 0.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
+}
+
+pub(super) fn cell_style_gallery(app: &mut SheetApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    ui.set_width(520.0);
+    let Some(wb) = app.session.active().map(|d| d.wb.clone()) else { return };
+    let groups: &[(&str, &[&str])] = &[
+        ("Good, Bad and Neutral", &["Normal", "Bad", "Good", "Neutral"]),
+        ("Data and Model", &["Calculation", "Check Cell", "Explanatory Text", "Input", "Linked Cell", "Note", "Output", "Warning Text"]),
+        ("Titles and Headings", &["Heading 1", "Heading 2", "Heading 3", "Heading 4", "Title", "Total"]),
+        (
+            "Themed Cell Styles",
+            &[
+                "20% - Accent1",
+                "20% - Accent2",
+                "20% - Accent3",
+                "20% - Accent4",
+                "20% - Accent5",
+                "20% - Accent6",
+                "40% - Accent1",
+                "40% - Accent2",
+                "40% - Accent3",
+                "40% - Accent4",
+                "40% - Accent5",
+                "40% - Accent6",
+                "60% - Accent1",
+                "60% - Accent2",
+                "60% - Accent3",
+                "60% - Accent4",
+                "60% - Accent5",
+                "60% - Accent6",
+                "Accent1",
+                "Accent2",
+                "Accent3",
+                "Accent4",
+                "Accent5",
+                "Accent6",
+            ],
+        ),
+        ("Number Format", &["Comma", "Comma [0]", "Currency", "Currency [0]", "Percent"]),
+    ];
+    for (g, names) in groups {
+        ui.label(egui::RichText::new(*g).strong());
+        egui::Grid::new(("csg", *g)).spacing(vec2(4.0, 4.0)).show(ui, |ui| {
+            for (i, n) in names.iter().enumerate() {
+                let st = gridcraft_engine::cmd::format::builtin_cell_style(n, &wb.theme).unwrap_or_default();
+                let (r, resp) = ui.allocate_exact_size(vec2(82.0, 24.0), Sense::click());
+                let fill = st
+                    .fill
+                    .fg
+                    .resolve(&wb.theme)
+                    .filter(|_| st.fill.pattern != gridcraft_engine::model::PatternType::None)
+                    .map(theme::color32)
+                    .unwrap_or(t.grid_bg);
+                ui.painter().rect_filled(r, 0.0, fill);
+                ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
+                if !st.borders.bottom.is_none() {
+                    let c = st.borders.bottom.color.resolve(&wb.theme).map(theme::color32).unwrap_or(t.cell_text);
+                    ui.painter().line_segment(
+                        [r.left_bottom() + vec2(0.0, -1.5), r.right_bottom() + vec2(0.0, -1.5)],
+                        Stroke::new(st.borders.bottom.style.width(), c),
+                    );
+                }
+                let col = st.font.color.resolve(&wb.theme).map(theme::color32).unwrap_or(t.cell_text);
+                let fam = theme::cell_family(&st.font.name, st.font.bold, st.font.italic);
+                ui.painter().text(
+                    r.left_center() + vec2(4.0, 0.0),
+                    Align2::LEFT_CENTER,
+                    *n,
+                    egui::FontId::new((st.font.size).clamp(10.0, 15.0), fam),
+                    col,
+                );
+                if resp.hovered() {
+                    ui.painter().rect_stroke(r.expand(1.5), 2.0, Stroke::new(2.0, Tokens::get(ui.ctx()).cat(Cat::Orange)), StrokeKind::Outside);
+                }
+                if resp.clicked() {
+                    act(app, "home.cellStyle", json!({"name": n}));
+                    ui.close();
+                }
+                if (i + 1) % 6 == 0 {
+                    ui.end_row();
+                }
+            }
+        });
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/home.rs b/crates/ui-egui/src/ribbon/home.rs
new file mode 100644
index 000000000..b6886b02c
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/home.rs
@@ -0,0 +1,813 @@
+use super::controls::{
+    ComboResult, act, active_style, anchor_keytip, control_keytip, editable_combo, invoke, keytip, list_combo, menu_items, popup_command, sep,
+    theme_colors,
+};
+use super::galleries::{cell_style_gallery, table_gallery};
+use super::*;
+
+/// The Accounting Number Format dropdown: label and the code Excel applies for that symbol.
+const ACCOUNTING_SYMBOLS: &[(&str, &str)] = &[
+    ("$ English (United States)", "_(\"$\"* #,##0.00_);_(\"$\"* \\(#,##0.00\\);_(\"$\"* \"-\"??_);_(@_)"),
+    ("£ English (United Kingdom)", "_-[$£-809]* #,##0.00_-;-[$£-809]* #,##0.00_-;_-[$£-809]* \"-\"??_-;_-@_-"),
+    ("€ Euro", "_-[$€-x-euro2] * #,##0.00_-;-[$€-x-euro2] * #,##0.00_-;_-[$€-x-euro2] * \"-\"??_-;_-@_-"),
+    ("¥ Japanese", "_-[$¥-411]* #,##0_-;-[$¥-411]* #,##0_-;_-[$¥-411]* \"-\"_-;_-@_-"),
+    ("¥ Chinese (PRC)", "_-[$¥-804]* #,##0.00_-;-[$¥-804]* #,##0.00_-;_-[$¥-804]* \"-\"??_-;_-@_-"),
+    ("₹ English (India)", "_-[$₹-4009]* #,##0.00_-;-[$₹-4009]* #,##0.00_-;_-[$₹-4009]* \"-\"??_-;_-@_-"),
+    ("CHF German (Switzerland)", "_-[$CHF-807]* #,##0.00_-;-[$CHF-807]* #,##0.00_-;_-[$CHF-807]* \"-\"??_-;_-@_-"),
+    ("Rp Indonesian", "_-[$Rp-421]* #,##0.00_-;-[$Rp-421]* #,##0.00_-;_-[$Rp-421]* \"-\"??_-;_-@_-"),
+    ("₩ Korean", "_-[$₩-412]* #,##0_-;-[$₩-412]* #,##0_-;_-[$₩-412]* \"-\"_-;_-@_-"),
+    ("R$ Portuguese (Brazil)", "_-[$R$-416]* #,##0.00_-;-[$R$-416]* #,##0.00_-;_-[$R$-416]* \"-\"??_-;_-@_-"),
+    ("₽ Russian", "_-[$₽-419]* #,##0.00_-;-[$₽-419]* #,##0.00_-;_-[$₽-419]* \"-\"??_-;_-@_-"),
+];
+
+/// Draws the Home tab: clipboard/paste menu, font, alignment, number, style, cell and editing commands with keytips.
+pub(super) fn home(app: &mut SheetApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    let st = active_style(app);
+    // Clipboard
+    let paste = big_button(ui, Icon::Paste, "Paste", "Paste", true);
+    paste.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Paste"));
+    for sequence in
+        keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["edit.paste", "edit.pasteSpecial", "dialog:pasteSpecial"])
+    {
+        keytip(app, ui, sequence, paste.rect.center_bottom());
+    }
+    if paste.clicked() {
+        app.paste_from_clipboard();
+    }
+    let paste_keys = matches!(app.keytips.prefix(), Some("HV" | "E"));
+    // Keep a keyboard-opened menu anchored to the button when a pointer click
+    // cancels keytips, so its items remain in place and can still be clicked.
+    let anchor_id = paste.id.with("keytip_anchor");
+    // Query response state before taking the egui context write lock.
+    // Calling secondary_clicked() inside data_mut can deadlock.
+    let paste_secondary_clicked = paste.secondary_clicked();
+    let anchored = ui.ctx().data_mut(|data| {
+        let anchored = if paste_keys {
+            true
+        } else if paste_secondary_clicked {
+            false
+        } else {
+            data.get_temp::<bool>(anchor_id).unwrap_or(false)
+        };
+        data.insert_temp(anchor_id, anchored);
+        anchored
+    });
+    let mut paste_popup = egui::Popup::context_menu(&paste);
+    if anchored {
+        paste_popup = paste_popup.anchor(&paste);
+    }
+    if paste_keys {
+        paste_popup = paste_popup.open_memory(egui::SetOpenCommand::Bool(true));
+    }
+    paste_popup.show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Paste", "edit.paste", json!({})),
+                ("Paste Values", "edit.pasteSpecial", json!({"what": "values"})),
+                ("Paste Formulas", "edit.pasteSpecial", json!({"what": "formulas"})),
+                ("Paste Formatting", "edit.pasteSpecial", json!({"what": "formats"})),
+                ("Transpose", "edit.pasteSpecial", json!({"what": "all", "transpose": true})),
+                ("Paste Link", "edit.pasteSpecial", json!({"what": "all", "link": true})),
+                ("-", "", json!(null)),
+                ("Paste Special…", "dialog:pasteSpecial", json!({})),
+            ],
+        );
+    });
+    ui.vertical(|ui| {
+        let __k = icon_button(ui, Icon::Cut, t.text, "Cut", vec2(26.0, 23.0));
+        control_keytip(app, ui, &__k, "edit.cut");
+        if __k.clicked() {
+            app.copy_to_clipboard(ui.ctx(), "edit.cut");
+        }
+        let __k = icon_button(ui, Icon::Copy, t.text, "Copy", vec2(26.0, 23.0));
+        control_keytip(app, ui, &__k, "edit.copy");
+        if __k.clicked() {
+            app.copy_to_clipboard(ui.ctx(), "edit.copy");
+        }
+        let fp_on = app.session.format_painter.is_some();
+        let fp = toggle_button(ui, Icon::Brush, fp_on, "Format Painter (double-click to keep it on)");
+        fp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), fp_on, "Format Painter"));
+        control_keytip(app, ui, &fp, "edit.formatPainter");
+        if fp.double_clicked() {
+            act(app, "edit.formatPainter", json!({"sticky": true}));
+        } else if fp.clicked() {
+            if fp_on {
+                app.session.format_painter = None;
+            } else {
+                act(app, "edit.formatPainter", json!({}));
+            }
+        }
+    });
+    sep(ui);
+    // Font
+    ui.vertical(|ui| {
+        ui.horizontal(|ui| {
+            font_combo(app, ui, &st);
+            size_combo(app, ui, &st);
+            let __k = icon_button(ui, Icon::Plus, t.text, "Increase Font Size", vec2(22.0, 23.0));
+            control_keytip(app, ui, &__k, "home.increaseFontSize");
+            if __k.clicked() {
+                act(app, "home.increaseFontSize", json!({}));
+            }
+            let __k = icon_button(ui, Icon::Minus, t.text, "Decrease Font Size", vec2(22.0, 23.0));
+            control_keytip(app, ui, &__k, "home.decreaseFontSize");
+            if __k.clicked() {
+                act(app, "home.decreaseFontSize", json!({}));
+            }
+        });
+        ui.horizontal(|ui| {
+            let __k = toggle_button(ui, Icon::Bold, st.font.bold, "Bold");
+            control_keytip(app, ui, &__k, "home.bold");
+            if __k.clicked() {
+                act(app, "home.bold", json!({}));
+            }
+            let __k = toggle_button(ui, Icon::Italic, st.font.italic, "Italic");
+            control_keytip(app, ui, &__k, "home.italic");
+            if __k.clicked() {
+                act(app, "home.italic", json!({}));
+            }
+            let (u, ua) = split_button(ui, Icon::Underline, None, "Underline");
+            control_keytip(app, ui, &ua, "home.underline");
+            if u {
+                act(app, "home.underline", json!({}));
+            }
+            egui::Popup::menu(&ua).show(|ui| {
+                menu_items(
+                    app,
+                    ui,
+                    &[
+                        ("Underline", "home.underline", json!({"style": "single"})),
+                        ("Double Underline", "home.underline", json!({"style": "double"})),
+                    ],
+                );
+            });
+            let __k = toggle_button(ui, Icon::Strike, st.font.strike, "Strikethrough");
+            control_keytip(app, ui, &__k, "home.strikethrough");
+            if __k.clicked() {
+                act(app, "home.strikethrough", json!({}));
+            }
+            let (b, ba) = split_button(ui, Icon::Borders, None, "Borders");
+            control_keytip(app, ui, &ba, "home.borders");
+            if b {
+                act(app, "home.borders", json!({"preset": app.grid.last_border.clone()}));
+            }
+            ba.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Border presets"));
+            egui::Popup::menu(&ba).show(|ui| {
+                for (label, preset) in [
+                    ("Bottom Border", "bottom"),
+                    ("Top Border", "top"),
+                    ("Left Border", "left"),
+                    ("Right Border", "right"),
+                    ("No Border", "none"),
+                    ("All Borders", "all"),
+                    ("Outside Borders", "outside"),
+                    ("Thick Outside Borders", "thickOutside"),
+                    ("Bottom Double Border", "doubleBottom"),
+                    ("Thick Bottom Border", "thickBottom"),
+                    ("Top and Bottom Border", "topBottom"),
+                    ("Top and Thick Bottom Border", "topThickBottom"),
+                    ("Top and Double Bottom Border", "topDoubleBottom"),
+                    ("Inside Borders", "inside"),
+                ] {
+                    if crate::border_preview::preset_button(ui, label, preset).clicked() {
+                        app.grid.last_border = preset.to_string();
+                        act(app, "home.borders", json!({"preset": preset}));
+                    }
+                }
+                ui.separator();
+                if ui.button("More Borders…").clicked() {
+                    app.open_dialog("formatCells", json!({"tab": "Border"}));
+                }
+            });
+            let fill = app.grid.last_fill.clone();
+            let fill_c = gridcraft_engine::model::Color::from_hex(&fill).and_then(|c| c.resolve(&Default::default())).map(theme::color32);
+            let (f, fa) = split_button(ui, Icon::Fill, fill_c, "Fill Color");
+            control_keytip(app, ui, &fa, "home.fillColor");
+            if f {
+                act(app, "home.fillColor", json!({"color": fill}));
+            }
+            let forced = invoke(app, "home.fillColor");
+            egui::Popup::menu(&fa)
+                .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
+                .open_memory(popup_command(forced, fa.clicked()))
+                .show(|ui| {
+                    if let Some(c) = color_palette(ui, &theme_colors(app), "No Fill") {
+                        if c != "none" {
+                            app.grid.last_fill = c.clone();
+                        }
+                        act(app, "home.fillColor", json!({"color": c}));
+                        ui.close();
+                    }
+                });
+            let fc = app.grid.last_font_color.clone();
+            let fc_c = gridcraft_engine::model::Color::from_hex(&fc).and_then(|c| c.resolve(&Default::default())).map(theme::color32);
+            let (c, ca) = split_button(ui, Icon::FontColor, fc_c, "Font Color");
+            control_keytip(app, ui, &ca, "home.fontColor");
+            if c {
+                act(app, "home.fontColor", json!({"color": fc}));
+            }
+            let forced = invoke(app, "home.fontColor");
+            egui::Popup::menu(&ca)
+                .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
+                .open_memory(popup_command(forced, ca.clicked()))
+                .show(|ui| {
+                    if let Some(c) = color_palette(ui, &theme_colors(app), "Automatic") {
+                        if c != "none" {
+                            app.grid.last_font_color = c.clone();
+                        }
+                        act(app, "home.fontColor", json!({"color": if c == "none" { "auto".to_string() } else { c }}));
+                        ui.close();
+                    }
+                });
+        });
+    });
+    sep(ui);
+    // Alignment
+    ui.vertical(|ui| {
+        ui.horizontal(|ui| {
+            for (icon, v, id, tip) in [
+                (Icon::AlignTop, VAlign::Top, "home.alignTop", "Top Align"),
+                (Icon::AlignMiddle, VAlign::Center, "home.alignMiddle", "Middle Align"),
+                (Icon::AlignBottom, VAlign::Bottom, "home.alignBottom", "Bottom Align"),
+            ] {
+                let __k = toggle_button(ui, icon, st.align.v == v, tip);
+                control_keytip(app, ui, &__k, id);
+                if __k.clicked() {
+                    act(app, id, json!({}));
+                }
+            }
+            let o = small_button(ui, Icon::Orientation, "", "Orientation", true);
+            control_keytip(app, ui, &o, "home.orientation");
+            let forced_o = invoke(app, "home.orientation");
+            egui::Popup::menu(&o).open_memory(popup_command(forced_o, o.clicked())).show(|ui| {
+                menu_items(
+                    app,
+                    ui,
+                    &[
+                        ("Angle Counterclockwise", "home.orientation", json!({"angle": "counterclockwise"})),
+                        ("Angle Clockwise", "home.orientation", json!({"angle": "clockwise"})),
+                        ("Vertical Text", "home.orientation", json!({"angle": "vertical"})),
+                        ("Rotate Text Up", "home.orientation", json!({"angle": "up"})),
+                        ("Rotate Text Down", "home.orientation", json!({"angle": "down"})),
+                        ("Horizontal", "home.orientation", json!({"angle": 0})),
+                        ("-", "", json!(null)),
+                        ("Format Cell Alignment…", "dialog:formatCells", json!({"tab": "Alignment"})),
+                    ],
+                );
+            });
+            let wrap = toggle_button(ui, Icon::Wrap, st.align.wrap, "Wrap Text");
+            control_keytip(app, ui, &wrap, "home.wrapText");
+            if wrap.clicked() {
+                act(app, "home.wrapText", json!({}));
+            }
+            ui.label(egui::RichText::new(app.ui.language.tr("Wrap Text")).font(theme::ui_font(12.5)));
+        });
+        ui.horizontal(|ui| {
+            for (icon, h, id, tip) in [
+                (Icon::AlignLeft, HAlign::Left, "home.alignLeft", "Align Left"),
+                (Icon::AlignCenter, HAlign::Center, "home.alignCenter", "Center"),
+                (Icon::AlignRight, HAlign::Right, "home.alignRight", "Align Right"),
+            ] {
+                let response = toggle_button(ui, icon, st.align.h == h, tip);
+                for sequence in keytip_table::control_badges(app.keytips.prefix().unwrap_or_default(), id) {
+                    keytip(app, ui, sequence, response.rect.center_bottom());
+                }
+                if response.clicked() {
+                    act(app, id, json!({}));
+                }
+            }
+            let __k = icon_button(ui, Icon::IndentDec, t.text, "Decrease Indent", vec2(24.0, 23.0));
+            control_keytip(app, ui, &__k, "home.decreaseIndent");
+            if __k.clicked() {
+                act(app, "home.decreaseIndent", json!({}));
+            }
+            let __k = icon_button(ui, Icon::IndentInc, t.text, "Increase Indent", vec2(24.0, 23.0));
+            control_keytip(app, ui, &__k, "home.increaseIndent");
+            if __k.clicked() {
+                act(app, "home.increaseIndent", json!({}));
+            }
+            let (m, ma) = split_button(ui, Icon::Merge, None, "Merge & Center");
+            control_keytip(app, ui, &ma, "home.mergeCenter");
+            if m {
+                act(app, "home.mergeCenter", json!({}));
+            }
+            ui.label(egui::RichText::new(app.ui.language.tr("Merge & Center")).font(theme::ui_font(12.5)));
+            egui::Popup::menu(&ma).show(|ui| {
+                menu_items(
+                    app,
+                    ui,
+                    &[
+                        ("Merge & Center", "home.mergeCenter", json!({})),
+                        ("Merge Across", "home.mergeAcross", json!({})),
+                        ("Merge Cells", "home.mergeCells", json!({})),
+                        ("Unmerge Cells", "home.unmergeCells", json!({})),
+                    ],
+                );
+            });
+        });
+    });
+    sep(ui);
+    // Number
+    ui.vertical(|ui| {
+        number_combo(app, ui, &st);
+        ui.horizontal(|ui| {
+            let (c, ca) = split_button(ui, Icon::Currency, None, "Accounting Number Format");
+            control_keytip(app, ui, &ca, "home.accounting");
+            if c {
+                act(app, "home.accounting", json!({}));
+            }
+            egui::Popup::menu(&ca).show(|ui| {
+                let mut items: Vec<_> = ACCOUNTING_SYMBOLS.iter().map(|(label, code)| (*label, "home.numberFormat", json!({"code": code}))).collect();
+                items.push(("-", "", json!(null)));
+                items.push(("More Accounting Formats…", "dialog:formatCells", json!({"tab": "Number"})));
+                menu_items(app, ui, &items);
+            });
+            let __k = icon_button(ui, Icon::Percent, t.text, "Percent Style", vec2(24.0, 23.0));
+            control_keytip(app, ui, &__k, "home.percent");
+            if __k.clicked() {
+                act(app, "home.percent", json!({}));
+            }
+            let __k = icon_button(ui, Icon::Comma, t.text, "Comma Style", vec2(24.0, 23.0));
+            control_keytip(app, ui, &__k, "home.comma");
+            if __k.clicked() {
+                act(app, "home.comma", json!({}));
+            }
+            let __k = icon_button(ui, Icon::DecInc, t.text, "Increase Decimal", vec2(26.0, 23.0));
+            control_keytip(app, ui, &__k, "home.increaseDecimal");
+            if __k.clicked() {
+                act(app, "home.increaseDecimal", json!({}));
+            }
+            let __k = icon_button(ui, Icon::DecDec, t.text, "Decrease Decimal", vec2(26.0, 23.0));
+            control_keytip(app, ui, &__k, "home.decreaseDecimal");
+            if __k.clicked() {
+                act(app, "home.decreaseDecimal", json!({}));
+            }
+        });
+    });
+    sep(ui);
+    // Styles
+    let cf = big_button(ui, Icon::CondFormat, "Conditional\nFormatting", "Conditional Formatting", true);
+    anchor_keytip(app, ui, &cf, &["home.conditionalFormat", "home.manageRules", "home.clearRules"]);
+    egui::Popup::menu(&cf).show(|ui| cf_menu(app, ui));
+    let ft = big_button(ui, Icon::FormatTable, "Format\nas Table", "Format as Table", true);
+    anchor_keytip(app, ui, &ft, &["table.style"]);
+    egui::Popup::menu(&ft).show(|ui| table_gallery(app, ui, "home.formatAsTable"));
+    let cs = big_button(ui, Icon::CellStyles, "Cell\nStyles", "Cell Styles", true);
+    anchor_keytip(app, ui, &cs, &["home.newCellStyle"]);
+    egui::Popup::menu(&cs).show(|ui| cell_style_gallery(app, ui));
+    sep(ui);
+    // Cells
+    ui.vertical(|ui| {
+        let ins = small_button(ui, Icon::Insert, "Insert", "Insert", true);
+        for sequence in keytip_table::group_extension(
+            app.keytips.prefix().unwrap_or_default(),
+            &["dialog:insertCells", "home.insertRows", "home.insertColumns", "home.insertSheet"],
+        ) {
+            keytip(app, ui, sequence, ins.rect.center_bottom());
+        }
+        egui::Popup::menu(&ins).show(|ui| {
+            menu_items(
+                app,
+                ui,
+                &[
+                    ("Insert Cells…", "dialog:insertCells", json!({})),
+                    ("Insert Sheet Rows", "home.insertRows", json!({})),
+                    ("Insert Sheet Columns", "home.insertColumns", json!({})),
+                    ("Insert Sheet", "home.insertSheet", json!({})),
+                ],
+            );
+        });
+        let del = small_button(ui, Icon::Delete, "Delete", "Delete", true);
+        for sequence in keytip_table::group_extension(
+            app.keytips.prefix().unwrap_or_default(),
+            &["dialog:deleteCells", "home.deleteRows", "home.deleteColumns", "home.deleteSheet"],
+        ) {
+            keytip(app, ui, sequence, del.rect.center_bottom());
+        }
+        egui::Popup::menu(&del).show(|ui| {
+            menu_items(
+                app,
+                ui,
+                &[
+                    ("Delete Cells…", "dialog:deleteCells", json!({})),
+                    ("Delete Sheet Rows", "home.deleteRows", json!({})),
+                    ("Delete Sheet Columns", "home.deleteColumns", json!({})),
+                    ("Delete Sheet", "home.deleteSheet", json!({})),
+                ],
+            );
+        });
+        let fmt = small_button(ui, Icon::Format, "Format", "Format", true);
+        for sequence in keytip_table::group_extension(
+            app.keytips.prefix().unwrap_or_default(),
+            &[
+                "dialog:rowHeight",
+                "home.autofitRowHeight",
+                "dialog:columnWidth",
+                "home.autofitColumnWidth",
+                "dialog:defaultWidth",
+                "home.hideRows",
+                "home.hideColumns",
+                "home.unhideRows",
+                "home.unhideColumns",
+                "sheet.hide",
+                "sheet.unhide",
+                "dialog:renameSheet",
+                "dialog:moveSheet",
+                "dialog:protectSheet",
+                "home.lockCell",
+                "dialog:formatCells",
+            ],
+        ) {
+            keytip(app, ui, sequence, fmt.rect.center_bottom());
+        }
+        let format_keys = matches!(app.keytips.prefix(), Some("HO" | "OC"));
+        let mut format_popup = egui::Popup::menu(&fmt);
+        if format_keys {
+            format_popup = format_popup.open_memory(egui::SetOpenCommand::Bool(true));
+        }
+        let protect_label = if app.active_sheet_protected() { "Unprotect Sheet…" } else { "Protect Sheet…" };
+        format_popup.show(|ui| {
+            menu_items(
+                app,
+                ui,
+                &[
+                    ("Row Height…", "dialog:rowHeight", json!({})),
+                    ("AutoFit Row Height", "home.autofitRowHeight", json!({})),
+                    ("Column Width…", "dialog:columnWidth", json!({})),
+                    ("AutoFit Column Width", "home.autofitColumnWidth", json!({})),
+                    ("Default Width…", "dialog:defaultWidth", json!({})),
+                    ("-", "", json!(null)),
+                    ("Hide Rows", "home.hideRows", json!({})),
+                    ("Hide Columns", "home.hideColumns", json!({})),
+                    ("Unhide Rows", "home.unhideRows", json!({})),
+                    ("Unhide Columns", "home.unhideColumns", json!({})),
+                    ("Hide Sheet", "sheet.hide", json!({})),
+                    ("Unhide Sheet…", "sheet.unhide", json!({})),
+                    ("-", "", json!(null)),
+                    ("Rename Sheet", "dialog:renameSheet", json!({})),
+                    ("Move or Copy Sheet…", "dialog:moveSheet", json!({})),
+                    ("-", "", json!(null)),
+                    (protect_label, "dialog:protectSheet", json!({})),
+                    ("Lock Cell", "home.lockCell", json!({})),
+                    ("Format Cells…", "dialog:formatCells", json!({})),
+                ],
+            );
+        });
+    });
+    sep(ui);
+    // Editing
+    ui.vertical(|ui| {
+        ui.horizontal(|ui| {
+            let (s, sa) = split_button(ui, Icon::Sum, None, "AutoSum");
+            control_keytip(app, ui, &sa, "formulas.autoSum");
+            if s {
+                act(app, "formulas.autoSum", json!({}));
+            }
+            egui::Popup::menu(&sa).show(|ui| autosum_menu(app, ui));
+        });
+        let fill = small_button(ui, Icon::FillDown, "", "Fill", true);
+        for sequence in keytip_table::group_extension(
+            app.keytips.prefix().unwrap_or_default(),
+            &["edit.fillDown", "edit.fillRight", "edit.fillUp", "edit.fillLeft", "dialog:series", "edit.flashFill"],
+        ) {
+            keytip(app, ui, sequence, fill.rect.center_bottom());
+        }
+        egui::Popup::menu(&fill).show(|ui| {
+            menu_items(
+                app,
+                ui,
+                &[
+                    ("Down", "edit.fillDown", json!({})),
+                    ("Right", "edit.fillRight", json!({})),
+                    ("Up", "edit.fillUp", json!({})),
+                    ("Left", "edit.fillLeft", json!({})),
+                    ("Series…", "dialog:series", json!({})),
+                    ("Flash Fill", "edit.flashFill", json!({})),
+                ],
+            );
+        });
+        let clear = small_button(ui, Icon::Eraser, "", "Clear", true);
+        for sequence in keytip_table::group_extension(
+            app.keytips.prefix().unwrap_or_default(),
+            &["edit.clearAll", "edit.clearFormats", "edit.clearContents", "edit.clearComments", "edit.clearHyperlinks"],
+        ) {
+            keytip(app, ui, sequence, clear.rect.center_bottom());
+        }
+        egui::Popup::menu(&clear).show(|ui| {
+            menu_items(
+                app,
+                ui,
+                &[
+                    ("Clear All", "edit.clearAll", json!({})),
+                    ("Clear Formats", "edit.clearFormats", json!({})),
+                    ("Clear Contents", "edit.clearContents", json!({})),
+                    ("Clear Comments and Notes", "edit.clearComments", json!({})),
+                    ("Clear Hyperlinks", "edit.clearHyperlinks", json!({})),
+                ],
+            );
+        });
+    });
+    let sf = big_button(ui, Icon::SortFilter, "Sort &\nFilter", "Sort & Filter", true);
+    for sequence in keytip_table::group_extension(
+        app.keytips.prefix().unwrap_or_default(),
+        &["data.sortAscending", "data.sortDescending", "dialog:sort", "data.filter", "data.clearFilter", "data.reapply"],
+    ) {
+        keytip(app, ui, sequence, sf.rect.center_bottom());
+    }
+    egui::Popup::menu(&sf).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Sort A to Z", "data.sortAscending", json!({})),
+                ("Sort Z to A", "data.sortDescending", json!({})),
+                ("Custom Sort…", "dialog:sort", json!({})),
+                ("-", "", json!(null)),
+                ("Filter", "data.filter", json!({})),
+                ("Clear", "data.clearFilter", json!({})),
+                ("Reapply", "data.reapply", json!({})),
+            ],
+        );
+    });
+    let fs = big_button(ui, Icon::Find, "Find &\nSelect", "Find & Select", true);
+    for sequence in keytip_table::group_extension(
+        app.keytips.prefix().unwrap_or_default(),
+        &["dialog:find", "dialog:goTo", "dialog:goToSpecial", "edit.goToSpecial"],
+    ) {
+        keytip(app, ui, sequence, fs.rect.center_bottom());
+    }
+    egui::Popup::menu(&fs).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Find…", "dialog:find", json!({})),
+                ("Replace…", "dialog:find", json!({"replace": true})),
+                ("Go To…", "dialog:goTo", json!({})),
+                ("Go To Special…", "dialog:goToSpecial", json!({})),
+                ("-", "", json!(null)),
+                ("Formulas", "edit.goToSpecial", json!({"kind": "formulas"})),
+                ("Notes", "edit.goToSpecial", json!({"kind": "notes"})),
+                ("Conditional Formatting", "edit.goToSpecial", json!({"kind": "conditionalFormats"})),
+                ("Constants", "edit.goToSpecial", json!({"kind": "constants"})),
+                ("Data Validation", "edit.goToSpecial", json!({"kind": "dataValidation"})),
+            ],
+        );
+    });
+}
+
+/// The AutoSum menu (Home › Editing and Formulas › Function Library): a function, or the Insert
+/// Function dialog.
+pub(super) fn autosum_menu(app: &mut SheetApp, ui: &mut Ui) {
+    for f in ["SUM", "AVERAGE", "COUNT", "MAX", "MIN"] {
+        if ui.button(f).clicked() {
+            act(app, "formulas.autoSum", json!({"function": f}));
+        }
+    }
+    ui.separator();
+    if ui.button("More Functions…").clicked() {
+        app.open_dialog("insertFunction", json!({}));
+    }
+}
+
+fn font_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
+    let name = st.font.name.clone();
+    let resp = ui.add_sized([150.0, 24.0], egui::Button::new(egui::RichText::new(&name).font(theme::ui_font(12.5))));
+    control_keytip(app, ui, &resp, "home.fontName");
+    let forced = invoke(app, "home.fontName");
+    let items: Vec<(&str, String)> = FONTS.iter().map(|f| (*f, f.to_string())).collect();
+    if let ComboResult::Picked(value) = editable_combo(ui, &resp, "font", &name, &items, forced) {
+        act(app, "home.fontName", json!({"name": value}));
+    }
+}
+
+pub const FONTS: &[&str] = &[
+    "Aptos",
+    "Aptos Narrow",
+    "Arial",
+    "Calibri",
+    "Cambria",
+    "Candara",
+    "Consolas",
+    "Courier New",
+    "Garamond",
+    "Georgia",
+    "Helvetica",
+    "Helvetica Neue",
+    "Segoe UI",
+    "Tahoma",
+    "Times New Roman",
+    "Trebuchet MS",
+    "Verdana",
+];
+
+/// Excel's size box: type a size and press Enter to apply exactly that number (the command refuses
+/// sizes outside 1 to 409), Escape or clicking away reverts; the arrow opens the standard sizes.
+fn size_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
+    let t = Tokens::get(ui.ctx());
+    let size = st.font.size;
+    let current = if size.fract() == 0.0 { format!("{}", size as i32) } else { format!("{size}") };
+    let field = egui::Id::unique("gridcraft.font_size_box");
+    let draft = field.with("draft");
+    let mut text = ui.data_mut(|d| d.get_temp::<String>(draft)).unwrap_or_else(|| current.clone());
+    // One frame like the Font name box beside it (same fill, border, height and corners), with the
+    // text field and the dropdown arrow inside it, as in Excel.
+    let (frame, _) = ui.allocate_exact_size(vec2(52.0, 24.0), egui::Sense::hover());
+    // Painted once the field's focus and hover are known, but beneath the field and the arrow.
+    let bg = ui.painter().add(egui::Shape::Noop);
+    let text_rect = Rect::from_min_max(frame.min, egui::pos2(frame.right() - 16.0, frame.bottom()));
+    let arrow_rect = Rect::from_min_max(egui::pos2(frame.right() - 16.0, frame.top() + 1.0), egui::pos2(frame.right() - 1.0, frame.bottom() - 1.0));
+    let mut field_ui =
+        ui.new_child(egui::UiBuilder::new().max_rect(text_rect.shrink2(vec2(6.0, 0.0))).layout(egui::Layout::left_to_right(egui::Align::Center)));
+    let out = egui::TextEdit::singleline(&mut text)
+        .id(field)
+        .font(theme::ui_font(12.5))
+        .frame(egui::Frame::NONE)
+        .desired_width(text_rect.width() - 12.0)
+        .show(&mut field_ui);
+    let resp = out.response;
+    ui.ctx().accesskit_node_builder(resp.id, |node| node.set_label(app.ui.language.tr("Font Size")));
+    control_keytip(app, ui, &resp, "home.fontSize");
+    if invoke(app, "home.fontSize") {
+        ui.memory_mut(|m| m.request_focus(field));
+    }
+    if resp.gained_focus() {
+        // Typing replaces the size, as in Excel, whether the box was clicked or reached by keytip.
+        let mut state = out.state;
+        state.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(text.chars().count()))));
+        state.store(ui.ctx(), field);
+    }
+    if resp.lost_focus() {
+        ui.data_mut(|d| d.remove::<String>(draft));
+        // Consume the Enter so the grid behind does not also move the active cell down.
+        if ui.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Enter))
+            && let Some(v) = text.trim().parse::<f64>().ok().filter(|v| v.is_finite())
+        {
+            act(app, "home.fontSize", json!({"size": v}));
+        }
+    } else if resp.has_focus() {
+        ui.data_mut(|d| d.insert_temp(draft, text));
+    } else {
+        ui.data_mut(|d| d.remove::<String>(draft));
+    }
+    let mut arrow_ui = ui.new_child(egui::UiBuilder::new().max_rect(arrow_rect));
+    let arrow = icon_button(&mut arrow_ui, Icon::Chevron, t.text_dim, "Font Size", arrow_rect.size());
+    let visuals = ui.style().visuals.clone();
+    let looks = if resp.has_focus() || ui.rect_contains_pointer(frame) { &visuals.widgets.hovered } else { &visuals.widgets.inactive };
+    let stroke = if resp.has_focus() { visuals.selection.stroke } else { looks.bg_stroke };
+    ui.painter().set(bg, egui::epaint::RectShape::new(frame, looks.corner_radius, looks.weak_bg_fill, stroke, egui::StrokeKind::Inside));
+    arrow.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Font Size"));
+    let sizes = [8.0, 9.0, 10.0, 11.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 36.0, 48.0, 72.0];
+    let labels: Vec<String> = sizes.iter().map(|s| format!("{}", *s as i32)).collect();
+    let items: Vec<(&str, String)> = labels.iter().map(|s| (s.as_str(), s.clone())).collect();
+    if let ComboResult::Picked(value) = list_combo(ui, &arrow, frame, "size", &current, &items)
+        && let Ok(v) = value.parse::<f32>()
+    {
+        act(app, "home.fontSize", json!({"size": v}));
+    }
+}
+
+fn number_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
+    let code = st.num_fmt.as_str().to_string();
+    let kind = gridcraft_engine::display::number_format(&code).kind();
+    let current = format!("{kind:?}");
+    let lang = app.ui.language;
+    let sample = app.session.active().and_then(|d| d.wb.active().map(|sh| sh.value(d.selection.active))).unwrap_or_default();
+    let resp = ui.add_sized([150.0, 24.0], egui::Button::new(egui::RichText::new(lang.tr(&current)).font(theme::ui_font(12.5))));
+    control_keytip(app, ui, &resp, "home.numberFormat");
+    let forced = invoke(app, "home.numberFormat");
+    let names = ["General", "Number", "Currency", "Accounting", "Short Date", "Long Date", "Time", "Percentage", "Fraction", "Scientific", "Text"];
+    let items: Vec<(&str, String)> = names
+        .iter()
+        .map(|n| {
+            let code = gridcraft_engine::cmd::format::format_code_for(n);
+            let preview = app.session.active().map(|d| gridcraft_engine::display::format(&sample, code, &d.wb).text).unwrap_or_default();
+            (*n, format!("{:<12}   {preview}", lang.tr(n)))
+        })
+        .chain(std::iter::once(("__more", format!("{:>12}", lang.tr("More Number Formats…")))))
+        .collect();
+    if let ComboResult::Picked(value) = editable_combo(ui, &resp, "number", &current, &items, forced) {
+        match value.as_str() {
+            "__more" => app.open_dialog("formatCells", json!({"tab": "Number"})),
+            n => act(app, "home.numberFormat", json!({"format": n})),
+        }
+    }
+}
+
+fn cf_menu(app: &mut SheetApp, ui: &mut Ui) {
+    ui.menu_button("Highlight Cells Rules", |ui| {
+        for (label, op) in [("Greater Than…", "greater"), ("Less Than…", "less"), ("Between…", "between"), ("Equal To…", "equal")] {
+            if ui.button(label).clicked() {
+                app.open_dialog("cfQuick", json!({"type": "cellIs", "operator": op, "title": label}));
+            }
+        }
+        if ui.button("Text that Contains…").clicked() {
+            app.open_dialog("cfQuick", json!({"type": "containsText", "title": "Text that Contains"}));
+        }
+        if ui.button("A Date Occurring…").clicked() {
+            app.open_dialog("cfQuick", json!({"type": "timePeriod", "title": "A Date Occurring"}));
+        }
+        if ui.button("Duplicate Values…").clicked() {
+            act(app, "home.conditionalFormat", json!({"rule": {"type": "duplicate"}}));
+        }
+    });
+    ui.menu_button("Top/Bottom Rules", |ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Top 10 Items", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10}})),
+                ("Top 10%", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10, "percent": true}})),
+                ("Bottom 10 Items", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10, "bottom": true}})),
+                ("Bottom 10%", "home.conditionalFormat", json!({"rule": {"type": "top10", "rank": 10, "bottom": true, "percent": true}})),
+                ("Above Average", "home.conditionalFormat", json!({"rule": {"type": "aboveAverage"}})),
+                ("Below Average", "home.conditionalFormat", json!({"rule": {"type": "aboveAverage", "below": true}})),
+            ],
+        );
+    });
+    ui.menu_button("Data Bars", |ui| {
+        for (label, c) in
+            [("Blue", "#638EC6"), ("Green", "#63BE7B"), ("Red", "#F8696B"), ("Orange", "#FFB628"), ("Light Blue", "#008AEF"), ("Purple", "#D6007B")]
+        {
+            if ui.button(label).clicked() {
+                act(app, "home.conditionalFormat", json!({"rule": {"type": "dataBar", "color": c}}));
+            }
+        }
+    });
+    ui.menu_button("Color Scales", |ui| {
+        for (label, cols) in [
+            ("Green - Yellow - Red", vec!["#63BE7B", "#FFEB84", "#F8696B"]),
+            ("Red - Yellow - Green", vec!["#F8696B", "#FFEB84", "#63BE7B"]),
+            ("Green - White - Red", vec!["#63BE7B", "#FCFCFF", "#F8696B"]),
+            ("Blue - White - Red", vec!["#5A8AC6", "#FCFCFF", "#F8696B"]),
+            ("White - Green", vec!["#FCFCFF", "#63BE7B"]),
+            ("White - Red", vec!["#FCFCFF", "#F8696B"]),
+        ] {
+            if ui.button(label).clicked() {
+                act(app, "home.conditionalFormat", json!({"rule": {"type": "colorScale", "colors": cols}}));
+            }
+        }
+    });
+    ui.menu_button("Icon Sets", |ui| {
+        for (label, set) in [
+            ("3 Arrows", "3Arrows"),
+            ("3 Traffic Lights", "3TrafficLights1"),
+            ("3 Symbols", "3Symbols"),
+            ("4 Ratings", "4Rating"),
+            ("5 Arrows", "5Arrows"),
+            ("5 Quarters", "5Quarters"),
+        ] {
+            if ui.button(label).clicked() {
+                act(app, "home.conditionalFormat", json!({"rule": {"type": "iconSet", "set": set}}));
+            }
+        }
+    });
+    ui.separator();
+    if ui.button("New Rule…").clicked() {
+        app.open_dialog("cfQuick", json!({"type": "expression", "title": "New Formatting Rule"}));
+    }
+    ui.menu_button("Clear Rules", |ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Clear Rules from Selected Cells", "home.clearRules", json!({})),
+                ("Clear Rules from Entire Sheet", "home.clearRules", json!({"sheet": true})),
+            ],
+        );
+    });
+    if ui.button("Manage Rules…").clicked() {
+        app.open_dialog("manageRules", json!({}));
+    }
+}
+
+#[cfg(test)]
+mod accounting_symbol_tests {
+    use super::*;
+    use gridcraft_engine::core::{DateSystem, Value};
+    use gridcraft_engine::numfmt::{NumberFormat, format_value};
+
+    #[test]
+    fn accounting_dropdown_offers_the_issue_currencies_with_excel_codes() {
+        // #1063: label, Excel's [$symbol-LCID] tag, and 1234.5 as Excel shows it (fill and the
+        // `_-` padding aside). The yen and won have no minor unit, so their codes show no decimals.
+        for (label, tag, shown) in [
+            ("Rp Indonesian", "[$Rp-421]", "Rp1,234.50"),
+            ("₹ English (India)", "[$₹-4009]", "₹1,234.50"),
+            ("₩ Korean", "[$₩-412]", "₩1,235"),
+            ("¥ Chinese (PRC)", "[$¥-804]", "¥1,234.50"),
+            ("¥ Japanese", "[$¥-411]", "¥1,235"),
+        ] {
+            let code = ACCOUNTING_SYMBOLS.iter().find(|(l, _)| *l == label).map(|(_, c)| *c);
+            let Some(code) = code else { panic!("{label} is not in the Accounting dropdown") };
+            assert!(code.split(';').take(3).all(|section| section.contains(tag)), "{label}: {code}");
+            let out = format_value(&Value::Number(1234.5), &NumberFormat::parse(code), DateSystem::D1900);
+            assert_eq!(out.text.trim(), shown, "{label}");
+            let symbol = tag.trim_start_matches("[$").split('-').next().unwrap_or_default();
+            assert_eq!(out.fill.map(|(c, at)| (c, out.text[..at].trim_start())), Some((' ', symbol)), "{label}");
+        }
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/insert.rs b/crates/ui-egui/src/ribbon/insert.rs
new file mode 100644
index 000000000..9319b23c5
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/insert.rs
@@ -0,0 +1,245 @@
+use super::controls::{act, anchor_keytip, control_keytip, invoke, popup_command, sep};
+use super::*;
+
+/// Draws the Insert tab: PivotTable, Table, Pictures, Shapes, Icons, charts, slicer, sparklines, checkbox, links, comments, text box, header/footer and symbols.
+pub(super) fn insert(app: &mut SheetApp, ui: &mut Ui) {
+    let __k = big_button(ui, Icon::PivotTable, "PivotTable", "PivotTable", false);
+    control_keytip(app, ui, &__k, "insert.pivotTable");
+    if __k.clicked() {
+        act(app, "insert.pivotTable", json!({}));
+    }
+    let __k = big_button(ui, Icon::Table, "Table", "Table", false);
+    control_keytip(app, ui, &__k, "insert.table");
+    if __k.clicked() {
+        act(app, "insert.table", json!({}));
+    }
+    sep(ui);
+    let pic = big_button(ui, Icon::Picture, "Pictures", "Insert a picture", true);
+    anchor_keytip(app, ui, &pic, &["insert.picture"]);
+    pic.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Pictures"));
+    egui::Popup::menu(&pic).show(|ui| {
+        for (label, placement) in [("Place in Cell", "cell"), ("Place over Cells", "overCells")] {
+            if ui.button(label).clicked() {
+                app.open_dialog("insertPicture", json!({"placement": placement}));
+                ui.close();
+            }
+        }
+    });
+    let shapes = big_button(ui, Icon::Shapes, "Shapes", "Shapes", true);
+    anchor_keytip(app, ui, &shapes, &["insert.shape"]);
+    egui::Popup::menu(&shapes).show(|ui| {
+        for (label, kind) in [
+            ("Rectangle", "rectangle"),
+            ("Rounded Rectangle", "roundedRectangle"),
+            ("Oval", "ellipse"),
+            ("Triangle", "triangle"),
+            ("Line", "line"),
+            ("Arrow", "arrow"),
+            ("Text Box", "textBox"),
+        ] {
+            if ui.button(label).clicked() {
+                act(app, "insert.shape", json!({"kind": kind}));
+            }
+        }
+    });
+    let icn = big_button(ui, Icon::Theme, "Icons", "Insert an icon", true);
+    anchor_keytip(app, ui, &icn, &["insert.icons"]);
+    egui::Popup::menu(&icn).show(|ui| {
+        ui.set_width(260.0);
+        egui::Grid::new("icon_lib").show(ui, |ui| {
+            for (i, (name, icon)) in icons::LIBRARY.iter().enumerate() {
+                let (r, resp) = ui.allocate_exact_size(vec2(36.0, 36.0), Sense::click());
+                if resp.hovered() {
+                    ui.painter().rect_filled(r, 4.0, Tokens::get(ui.ctx()).hover);
+                }
+                icons::paint(ui.painter(), r.shrink(6.0), *icon, Tokens::get(ui.ctx()).text);
+                if resp.on_hover_text(*name).clicked() {
+                    act(app, "insert.icons", json!({"name": name}));
+                    ui.close();
+                }
+                if (i + 1) % 6 == 0 {
+                    ui.end_row();
+                }
+            }
+        });
+    });
+    sep(ui);
+    let __k = big_button(ui, Icon::Chart, "Recommended\nCharts", "Recommended Charts", false);
+    control_keytip(app, ui, &__k, "insert.recommendedCharts");
+    if __k.clicked() {
+        // Menu-style: with no chart type, run_or_alert opens the Insert Chart dialog.
+        act(app, "insert.recommendedCharts", json!({}));
+    }
+    ui.vertical(|ui| {
+        ui.horizontal(|ui| {
+            for (icon, tip, cid, subs) in [
+                (
+                    Icon::ChartBar,
+                    "Column or Bar",
+                    "insert.chart.column",
+                    vec![
+                        ("Clustered Column", "column", ""),
+                        ("Stacked Column", "column", "stacked"),
+                        ("100% Stacked Column", "column", "stacked100"),
+                        ("Clustered Bar", "bar", ""),
+                        ("Stacked Bar", "bar", "stacked"),
+                        ("100% Stacked Bar", "bar", "stacked100"),
+                    ],
+                ),
+                (
+                    Icon::ChartLine,
+                    "Line or Area",
+                    "insert.chart.line",
+                    vec![
+                        ("Line", "line", ""),
+                        ("Line with Markers", "line", "markers"),
+                        ("Stacked Line", "line", "stacked"),
+                        ("Area", "area", ""),
+                        ("Stacked Area", "area", "stacked"),
+                        ("100% Stacked Area", "area", "stacked100"),
+                    ],
+                ),
+                (Icon::ChartPie, "Pie or Doughnut", "insert.chart.pie", vec![("Pie", "pie", ""), ("Doughnut", "doughnut", "")]),
+            ] {
+                let r = small_button(ui, icon, "", tip, true);
+                control_keytip(app, ui, &r, cid);
+                let forced_c = invoke(app, cid);
+                egui::Popup::menu(&r).open_memory(popup_command(forced_c, r.clicked())).show(|ui| {
+                    for (label, k, s) in &subs {
+                        if ui.button(*label).clicked() {
+                            act(app, "insert.chart", json!({"type": k, "subtype": s}));
+                        }
+                    }
+                });
+            }
+        });
+        ui.horizontal(|ui| {
+            for (icon, tip, cid, subs) in [
+                (
+                    Icon::ChartScatter,
+                    "Scatter or Bubble",
+                    "insert.chart.scatter",
+                    vec![("Scatter", "scatter", ""), ("Scatter with Lines", "scatter", "lines"), ("Bubble", "bubble", "")],
+                ),
+                (Icon::Chart, "Statistic", "insert.chart.statistic", vec![("Histogram", "histogram", ""), ("Box & Whisker", "boxWhisker", "")]),
+                (
+                    Icon::Theme,
+                    "Hierarchy & more",
+                    "insert.chart.hierarchy",
+                    vec![
+                        ("Treemap", "treemap", ""),
+                        ("Sunburst", "sunburst", ""),
+                        ("Waterfall", "waterfall", ""),
+                        ("Funnel", "funnel", ""),
+                        ("Radar", "radar", ""),
+                        ("Stock", "stock", ""),
+                        ("Combo", "combo", ""),
+                    ],
+                ),
+            ] {
+                let r = small_button(ui, icon, "", tip, true);
+                control_keytip(app, ui, &r, cid);
+                let forced_c = invoke(app, cid);
+                egui::Popup::menu(&r).open_memory(popup_command(forced_c, r.clicked())).show(|ui| {
+                    for (label, k, s) in &subs {
+                        if ui.button(*label).clicked() {
+                            act(app, "insert.chart", json!({"type": k, "subtype": s}));
+                        }
+                    }
+                });
+            }
+        });
+    });
+    sep(ui);
+    if big_button(ui, Icon::Filter, "Slicer", "Insert a slicer to filter a table", false).clicked() {
+        act(app, "insert.slicer", json!({}));
+    }
+    sep(ui);
+    let sp = big_button(ui, Icon::Sparkline, "Sparklines", "Sparklines", true);
+    anchor_keytip(app, ui, &sp, &["dialog:sparkline"]);
+    egui::Popup::menu(&sp).show(|ui| {
+        for (label, kind) in [("Line", "line"), ("Column", "column"), ("Win/Loss", "winLoss")] {
+            if ui.button(label).clicked() {
+                app.open_dialog("sparkline", json!({"type": kind}));
+            }
+        }
+    });
+    sep(ui);
+    // Cell Controls.
+    if big_button(ui, Icon::Checkbox, "Checkbox", "Insert checkboxes in the selected cells", false).clicked() {
+        act(app, "insert.checkbox", json!({}));
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::Link, "Link", "Insert Link", false);
+    control_keytip(app, ui, &__k, "dialog:insertLink");
+    if __k.clicked() {
+        app.open_dialog("insertLink", json!({}));
+    }
+    let __k = big_button(ui, Icon::Comment, "Comment", "New Comment", false);
+    control_keytip(app, ui, &__k, "dialog:comment");
+    if __k.clicked() {
+        app.open_dialog("comment", json!({"threaded": true}));
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::TextBox, "Text\nBox", "Text Box", false);
+    control_keytip(app, ui, &__k, "insert.textBox");
+    if __k.clicked() {
+        act(app, "insert.textBox", json!({}));
+    }
+    let __k = big_button(ui, Icon::PageLayout, "Header &\nFooter", "Header & Footer", false);
+    control_keytip(app, ui, &__k, "dialog:headerFooter");
+    if __k.clicked() {
+        // As in Excel: Page Layout view, editing the header in place (the dialog is under Page Setup).
+        crate::paper_view::start_editing(app);
+    }
+    let sym = big_button(ui, Icon::Symbol, "Symbol", "Symbol", true);
+    control_keytip(app, ui, &sym, "insert.symbol");
+    egui::Popup::menu(&sym).show(|ui| {
+        ui.set_width(260.0);
+        ui.horizontal_wrapped(|ui| {
+            for ch in [
+                "€", "£", "¥", "©", "®", "™", "±", "≠", "≤", "≥", "÷", "×", "∞", "µ", "α", "β", "π", "Σ", "Ω", "°", "•", "…", "→", "←", "↑", "↓",
+                "✓", "★", "½", "¼",
+            ] {
+                // No bundled face has ✓: the button paints a code-drawn check instead of a tofu box.
+                if crate::widgets::glyph_button(ui, ch.chars().next().unwrap_or('?'), &format!("Insert {ch}")).clicked() {
+                    act(app, "insert.symbol", json!({"char": ch}));
+                }
+            }
+        });
+    });
+}
+
+pub(super) fn draw(app: &mut SheetApp, ui: &mut Ui) {
+    let tool = app.session.draw_tool.clone();
+    let __k = big_button(ui, Icon::Shapes, "Select\nObjects", "Select and move ink and shapes", false);
+    control_keytip(app, ui, &__k, "draw.lasso");
+    if __k.clicked() {
+        act(app, "draw.lasso", json!({}));
+    }
+    sep(ui);
+    for (label, color) in [("Pen\nBlue", "#1F5FC9"), ("Pen\nBlack", "#000000"), ("Pen\nRed", "#D13B2F"), ("Highlighter", "#F2E33A")] {
+        let on = tool == "pen" && app.session.draw_color.eq_ignore_ascii_case(color);
+        let r = big_button(ui, Icon::Pen, label, "Draw with ink", false);
+        if on {
+            ui.painter().rect_stroke(r.rect, 5.0, Stroke::new(2.0, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
+        }
+        if r.clicked() {
+            let width = if label == "Highlighter" { 12.0 } else { 2.0 };
+            act(app, "draw.pen", json!({"on": !on, "color": color, "width": width}));
+        }
+    }
+    let er = big_button(ui, Icon::Eraser, "Eraser", "Erase ink strokes", false);
+    if tool == "eraser" {
+        ui.painter().rect_stroke(er.rect, 5.0, Stroke::new(2.0, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
+    }
+    if er.clicked() {
+        act(app, "draw.eraser", json!({}));
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::Shapes, "Ink to\nShape", "Convert the last ink stroke to a shape", false);
+    control_keytip(app, ui, &__k, "draw.inkToShape");
+    if __k.clicked() {
+        act(app, "draw.inkToShape", json!({}));
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/page_layout.rs b/crates/ui-egui/src/ribbon/page_layout.rs
new file mode 100644
index 000000000..b8651b0f4
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/page_layout.rs
@@ -0,0 +1,158 @@
+use super::controls::{act, anchor_keytip, checkbox_on, control_keytip, invoke, keytip, menu_items, sep};
+use super::*;
+
+pub(super) fn page_layout(app: &mut SheetApp, ui: &mut Ui) {
+    let th = big_button(ui, Icon::Theme, "Themes", "Themes", true);
+    anchor_keytip(app, ui, &th, &["pageLayout.theme"]);
+    egui::Popup::menu(&th).show(|ui| {
+        for (name, colors) in gridcraft_engine::cmd::view::themes() {
+            ui.horizontal(|ui| {
+                for c in colors.iter().skip(4).take(6) {
+                    let (r, _) = ui.allocate_exact_size(vec2(12.0, 12.0), Sense::hover());
+                    ui.painter().rect_filled(r, 1.0, Color32::from_rgb((c >> 16) as u8, (c >> 8) as u8, *c as u8));
+                }
+                if ui.button(name).clicked() {
+                    act(app, "pageLayout.theme", json!({"name": name}));
+                }
+            });
+        }
+    });
+    sep(ui);
+    let m = big_button(ui, Icon::Margins, "Margins", "Margins", true);
+    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["pageLayout.margins", "dialog:pageSetup"]) {
+        keytip(app, ui, sequence, m.rect.center_bottom());
+    }
+    egui::Popup::menu(&m).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Normal", "pageLayout.margins", json!({"preset": "normal"})),
+                ("Wide", "pageLayout.margins", json!({"preset": "wide"})),
+                ("Narrow", "pageLayout.margins", json!({"preset": "narrow"})),
+                ("Custom Margins…", "dialog:pageSetup", json!({})),
+            ],
+        );
+    });
+    let o = big_button(ui, Icon::Orient, "Page Layout|Orientation", "Page Layout|Orientation", true);
+    control_keytip(app, ui, &o, "pageLayout.orientation");
+    egui::Popup::menu(&o).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Portrait", "pageLayout.orientation", json!({"orientation": "portrait"})),
+                ("Landscape", "pageLayout.orientation", json!({"orientation": "landscape"})),
+            ],
+        );
+    });
+    let s = big_button(ui, Icon::Paper, "Size", "Paper Size", true);
+    control_keytip(app, ui, &s, "pageLayout.size");
+    egui::Popup::menu(&s).show(|ui| {
+        // B4/B5/B6 are the JIS sizes Japanese Excel uses; the ISO ones stay selectable by name.
+        for p in [
+            "Letter",
+            "Legal",
+            "Tabloid",
+            "Executive",
+            "A3",
+            "A4",
+            "A5",
+            "A6",
+            "B4",
+            "B5",
+            "B6",
+            "Japanese Postcard",
+            "Japanese Double Postcard",
+            "Japanese Envelope #3",
+            "Japanese Envelope #4",
+            "Japanese Envelope Kaku #2",
+            "Japanese Envelope Kaku #3",
+            "B4 (ISO)",
+            "B5 (ISO)",
+            "B6 (ISO)",
+        ] {
+            if ui.button(p).clicked() {
+                act(app, "pageLayout.size", json!({"paper": p}));
+            }
+        }
+    });
+    let pa = big_button(ui, Icon::PrintArea, "Print\nArea", "Print Area", true);
+    anchor_keytip(app, ui, &pa, &["pageLayout.printArea"]);
+    egui::Popup::menu(&pa).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[("Set Print Area", "pageLayout.printArea", json!({})), ("Clear Print Area", "pageLayout.printArea", json!({"clear": true}))],
+        );
+    });
+    let br = big_button(ui, Icon::PageBreak, "Breaks", "Page Breaks", true);
+    for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["pageLayout.breaks"]) {
+        keytip(app, ui, sequence, br.rect.center_bottom());
+    }
+    egui::Popup::menu(&br).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Insert Page Break", "pageLayout.breaks", json!({"insert": true})),
+                ("Remove Page Break", "pageLayout.breaks", json!({"remove": true})),
+                ("Reset All Page Breaks", "pageLayout.breaks", json!({"reset": true})),
+            ],
+        );
+    });
+    let __k = big_button(ui, Icon::Sheet, "Print\nTitles", "Print Titles", false);
+    control_keytip(app, ui, &__k, "pageLayout.printTitles");
+    if __k.clicked() {
+        app.open_dialog("pageSetup", json!({"tab": "Sheet"}));
+    }
+    sep(ui);
+    let sh = app
+        .session
+        .active()
+        .and_then(|d| d.wb.active().map(|s| (s.show_gridlines, s.show_headings, s.print.gridlines, s.print.headings)))
+        .unwrap_or((true, true, false, false));
+    // These two checkboxes mean the screen view vs. the printed page. English shows "View" (as in
+    // Excel), but the key is distinct from the "View" tab so languages can word them apart.
+    let screen = app.ui.language.tr("Sheet Options|View");
+    let print = app.ui.language.tr("Print");
+    ui.vertical(|ui| {
+        ui.label(egui::RichText::new(app.ui.language.tr("Gridlines")).strong().small());
+        let mut v = sh.0;
+        let resp = ui.checkbox(&mut v, screen);
+        control_keytip(app, ui, &resp, "view.gridlines");
+        if resp.changed() || invoke(app, "view.gridlines") {
+            act(app, "view.gridlines", json!({"on": checkbox_on(resp.changed(), v)}));
+        }
+        let mut p = sh.2;
+        let resp = ui.checkbox(&mut p, print);
+        control_keytip(app, ui, &resp, "pageLayout.printGridlines");
+        if resp.changed() || invoke(app, "pageLayout.printGridlines") {
+            act(app, "pageLayout.printGridlines", json!({"on": checkbox_on(resp.changed(), p)}));
+        }
+    });
+    ui.vertical(|ui| {
+        ui.label(egui::RichText::new(app.ui.language.tr("Headings")).strong().small());
+        let mut v = sh.1;
+        let resp = ui.checkbox(&mut v, screen);
+        control_keytip(app, ui, &resp, "view.headings");
+        if resp.changed() || invoke(app, "view.headings") {
+            act(app, "view.headings", json!({"on": checkbox_on(resp.changed(), v)}));
+        }
+        let mut p = sh.3;
+        let resp = ui.checkbox(&mut p, print);
+        control_keytip(app, ui, &resp, "pageLayout.printHeadings");
+        if resp.changed() || invoke(app, "pageLayout.printHeadings") {
+            act(app, "pageLayout.printHeadings", json!({"on": checkbox_on(resp.changed(), p)}));
+        }
+    });
+    let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
+    let r = big_button(ui, Icon::SheetRtl, "Sheet\nRight-to-Left", "Sheet Right-to-Left", false);
+    if rtl {
+        let t = Tokens::get(ui.ctx());
+        ui.painter().rect_stroke(r.rect, 5.0, egui::Stroke::new(1.0, t.separator), egui::StrokeKind::Inside);
+    }
+    if r.clicked() {
+        act(app, "view.rightToLeft", json!({"on": !rtl}));
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/review.rs b/crates/ui-egui/src/ribbon/review.rs
new file mode 100644
index 000000000..c8998531e
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/review.rs
@@ -0,0 +1,82 @@
+use super::controls::{act, anchor_keytip, control_keytip, menu_items, sep};
+use super::*;
+
+pub(super) fn review(app: &mut SheetApp, ui: &mut Ui) {
+    let __k = big_button(ui, Icon::Spell, "Spelling", "Spelling (F7)", false);
+    control_keytip(app, ui, &__k, "dialog:spelling");
+    if __k.clicked() {
+        app.open_dialog("spelling", json!({}));
+    }
+    let __k = big_button(ui, Icon::Calc, "Workbook\nStatistics", "Workbook Statistics", false);
+    control_keytip(app, ui, &__k, "statistics");
+    if __k.clicked() {
+        app.open_dialog("statistics", json!({}));
+    }
+    let __k = big_button(ui, Icon::Validation, "Check\nAccessibility", "Check Accessibility", false);
+    control_keytip(app, ui, &__k, "dialog:accessibility");
+    if __k.clicked() {
+        app.open_dialog("accessibility", json!({}));
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::Comment, "New\nComment", "New Comment", false);
+    control_keytip(app, ui, &__k, "dialog:comment");
+    if __k.clicked() {
+        app.open_dialog("comment", json!({"threaded": true}));
+    }
+    let __k = big_button(ui, Icon::Delete, "Delete", "Delete Comment", false);
+    control_keytip(app, ui, &__k, "review.deleteComment");
+    if __k.clicked() {
+        act(app, "review.deleteComment", json!({}));
+    }
+    ui.vertical(|ui| {
+        for (icon, label, tip, id) in
+            [(Icon::Left, "Previous", "Previous Comment", "review.previousComment"), (Icon::Right, "Next", "Next Comment", "review.nextComment")]
+        {
+            if small_button(ui, icon, label, tip, false).clicked() {
+                act(app, id, json!({}));
+                app.grid.ensure_visible = true;
+            }
+        }
+    });
+    let shown = app.session.comments_pane;
+    let r = big_button(ui, Icon::Comment, "Show\nComments", "Comments pane", false);
+    if shown {
+        ui.painter().rect_stroke(r.rect, 5.0, Stroke::new(2.0, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
+    }
+    if r.clicked() {
+        act(app, "review.showComments", json!({"on": !shown}));
+        if app.session.comments_pane {
+            app.grid.pane = None;
+        }
+    }
+    let notes = big_button(ui, Icon::Note, "Notes", "Notes", true);
+    anchor_keytip(app, ui, &notes, &["review.nextComment"]);
+    egui::Popup::menu(&notes).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("New Note", "dialog:comment", json!({"threaded": false})),
+                ("Show/Hide Note", "review.showNote", json!({})),
+                ("Show All Notes", "review.showAllNotes", json!({})),
+                ("-", "", json!({})),
+                ("Convert to Comments", "review.convertToComments", json!({})),
+            ],
+        );
+    });
+    sep(ui);
+    let protected = app.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false);
+    let __k = big_button(ui, Icon::Lock, if protected { "Unprotect\nSheet" } else { "Protect\nSheet" }, "Protect Sheet", false);
+    control_keytip(app, ui, &__k, "dialog:protectSheet");
+    if __k.clicked() {
+        app.open_dialog("protectSheet", json!({}));
+    }
+    let __k = big_button(ui, Icon::Book, "Protect\nWorkbook", "Protect Workbook structure", false);
+    control_keytip(app, ui, &__k, "review.protectWorkbook");
+    if __k.clicked() {
+        crate::backstage::protect_workbook(app);
+    }
+    if big_button(ui, Icon::Validation, "Allow Edit\nRanges", "Allow Edit Ranges", false).clicked() {
+        app.open_dialog("allowEditRanges", json!({}));
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/shortcuts.rs b/crates/ui-egui/src/ribbon/shortcuts.rs
new file mode 100644
index 000000000..7edf4c58c
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/shortcuts.rs
@@ -0,0 +1,112 @@
+use super::*;
+
+/// Command-key shortcuts when the grid has focus.
+pub fn shortcut(app: &mut SheetApp, key: Key, m: Modifiers) {
+    let shift = m.shift;
+    let id: Option<(&str, serde_json::Value)> = match key {
+        Key::B => Some(("home.bold", json!({}))),
+        Key::I => Some(("home.italic", json!({}))),
+        Key::U => Some(("home.underline", json!({}))),
+        Key::Z if shift => Some(("edit.redo", json!({}))),
+        Key::Z => Some(("edit.undo", json!({}))),
+        Key::Y => Some(("edit.redo", json!({}))),
+        Key::A => Some(("edit.selectAll", json!({}))),
+        Key::D => Some(("edit.fillDown", json!({}))),
+        Key::R => Some(("edit.fillRight", json!({}))),
+        Key::S if shift => Some(("file.saveAs", json!({}))),
+        Key::S => Some(("file.save", json!({}))),
+        Key::O => Some(("file.open", json!({}))),
+        Key::N => Some(("file.new", json!({}))),
+        Key::W => Some(("file.close", json!({}))),
+        Key::P => {
+            app.print_now(json!({}));
+            None
+        }
+        Key::K => {
+            app.open_dialog("insertLink", json!({}));
+            None
+        }
+        Key::F if shift => Some(("data.filter", json!({}))),
+        Key::F => {
+            app.open_dialog("find", json!({}));
+            None
+        }
+        Key::H => {
+            app.open_dialog("find", json!({"replace": true}));
+            None
+        }
+        Key::G => {
+            app.open_dialog("goTo", json!({}));
+            None
+        }
+        Key::T if shift => Some(("formulas.autoSum", json!({}))),
+        Key::T => Some(("insert.table", json!({}))),
+        Key::E => Some(("edit.flashFill", json!({}))),
+        Key::Num1 => {
+            app.open_dialog("formatCells", json!({}));
+            None
+        }
+        Key::Num9 if shift => Some(("home.unhideRows", json!({}))),
+        Key::Num9 => Some(("home.hideRows", json!({}))),
+        Key::Num0 if shift => Some(("home.unhideColumns", json!({}))),
+        Key::Num0 => Some(("home.hideColumns", json!({}))),
+        // As in Excel: with whole rows or whole columns selected, Ctrl+Shift+= / Ctrl+- insert or
+        // delete them at once; any other selection asks which way to shift.
+        Key::Minus => match whole_lines(app) {
+            Some(true) => Some(("home.deleteRows", json!({}))),
+            Some(false) => Some(("home.deleteColumns", json!({}))),
+            None => {
+                app.open_dialog("deleteCells", json!({}));
+                None
+            }
+        },
+        // Insert works on one area at a time, so several areas still go through the dialog.
+        Key::Plus | Key::Equals if shift => match whole_lines(app).filter(|_| single_area(app)) {
+            Some(true) => Some(("home.insertRows", json!({}))),
+            Some(false) => Some(("home.insertColumns", json!({}))),
+            None => {
+                app.open_dialog("insertCells", json!({}));
+                None
+            }
+        },
+        Key::Semicolon => {
+            // Insert today's date.
+            let text = app
+                .session
+                .active()
+                .map(|d| {
+                    let today = gridcraft_engine::core::date::serial_in_system(d.wb.date_system, gridcraft_engine::calc::now_serial()).floor();
+                    gridcraft_engine::display::format(&gridcraft_engine::core::Value::Number(today), "m/d/yyyy", &d.wb).text
+                })
+                .unwrap_or_default();
+            app.begin_edit(Some(text), false);
+            None
+        }
+        Key::Backtick => Some(("formulas.showFormulas", json!({}))),
+        _ => None,
+    };
+    if let Some((id, p)) = id {
+        app.run_or_alert(id, p);
+        app.grid.ensure_visible = true;
+    }
+}
+
+/// Whether the selection is a single area.
+fn single_area(app: &SheetApp) -> bool {
+    app.session.active().is_some_and(|d| d.selection.ranges.len() == 1)
+}
+
+/// `Some(true)` when every selected area is whole rows, `Some(false)` when every one is whole
+/// columns, `None` otherwise (including the whole sheet).
+fn whole_lines(app: &SheetApp) -> Option<bool> {
+    let sel = &app.session.active()?.selection;
+    let rows = sel.ranges.iter().all(|r| r.is_full_rows() && !r.is_full_cols());
+    let cols = sel.ranges.iter().all(|r| r.is_full_cols() && !r.is_full_rows());
+    if rows {
+        Some(true)
+    } else if cols {
+        Some(false)
+    } else {
+        None
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/title_bar.rs b/crates/ui-egui/src/ribbon/title_bar.rs
new file mode 100644
index 000000000..eb243149f
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/title_bar.rs
@@ -0,0 +1,274 @@
+use super::controls::{act, control_keytip};
+use super::*;
+
+/// macOS draws the window into the title bar (`with_fullsize_content_view`) and AppKit paints the
+/// traffic lights itself, centred in its standard 28 pt title-bar band. Moving them would take
+/// AppKit calls (`unsafe`, forbidden here), so on macOS the title bar is that band: the lights sit
+/// vertically centred in it, with the controls beside them (#170).
+const MAC: bool = cfg!(target_os = "macos");
+
+pub const MAC_TITLE_BAR: f32 = 28.0;
+
+/// The traffic lights as AppKit lays them out: button diameter, centre-to-centre pitch and the
+/// first button's left edge (8–10 pt depending on the macOS version; the larger value keeps the
+/// gap after them from shrinking).
+const MAC_LIGHT: f32 = 12.0;
+
+const MAC_LIGHT_PITCH: f32 = 20.0;
+
+const MAC_LIGHTS_LEFT: f32 = 10.0;
+
+/// Where title-bar content starts on macOS: the end of the three lights plus the gap the lights
+/// keep from the top of the window.
+pub const MAC_CONTENT_LEFT: f32 = MAC_LIGHTS_LEFT + 2.0 * MAC_LIGHT_PITCH + MAC_LIGHT + (MAC_TITLE_BAR - MAC_LIGHT) / 2.0;
+
+/// Leave room for the macOS traffic lights when the content extends into the title bar.
+pub const TITLE_LEFT_PAD: f32 = if MAC { MAC_CONTENT_LEFT } else { 8.0 };
+
+pub(super) const TITLE_BAR_H: f32 = if MAC { MAC_TITLE_BAR } else { 38.0 };
+
+/// The tallest title-bar controls, smaller on macOS to keep a margin in the shorter bar.
+pub(super) const TITLE_CONTROL_H: f32 = if MAC { 22.0 } else { 26.0 };
+
+/// Draws the title bar: drag/maximize, AutoSave toggle, Home/Save/Undo/Redo/More, search, share, comments and theme controls, with a centered truncated title.
+pub fn title_bar(app: &mut SheetApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    let ch = TITLE_CONTROL_H;
+    egui::Panel::top("title_bar").exact_size(TITLE_BAR_H).frame(egui::Frame::NONE.fill(t.window)).show(ui, |ui| {
+        let rect = ui.max_rect();
+        // Dragging the empty title area moves the window.
+        let bg = ui.interact(rect, ui.scope_id().with("drag_title"), Sense::click_and_drag());
+        if bg.drag_started() {
+            ui.ctx().send_viewport_cmd(egui::ViewportCommand::StartDrag);
+        }
+        if bg.double_clicked() {
+            let max = ui.ctx().input(|i| i.viewport().maximized.unwrap_or(false));
+            ui.ctx().send_viewport_cmd(egui::ViewportCommand::Maximized(!max));
+        }
+        ui.horizontal_centered(|ui| {
+            ui.add_space(TITLE_LEFT_PAD);
+            // AutoSave toggle (saves after each change when the workbook has a file).
+            ui.label(egui::RichText::new(app.ui.language.tr("AutoSave")).font(theme::ui_font(12.5)).color(t.text_dim));
+            let on = app.ui.autosave;
+            let (r, resp) = ui.allocate_exact_size(vec2(30.0, 16.0), Sense::click());
+            ui.painter().rect_filled(r, 8.0, if on { t.accent } else { Color32::TRANSPARENT });
+            ui.painter().rect_stroke(r, 8.0, Stroke::new(1.0, if on { t.accent } else { t.text_dim }), StrokeKind::Inside);
+            let knob = if on { pos2(r.right() - 8.0, r.center().y) } else { pos2(r.left() + 8.0, r.center().y) };
+            ui.painter().circle_filled(knob, 5.0, if on { t.on_accent } else { t.text_dim });
+            if resp.on_hover_text(app.ui.language.tr("AutoSave: save after every change (workbooks saved to a file)")).clicked() {
+                app.toggle_autosave();
+            }
+            ui.add_space(6.0);
+            let __k = icon_button(ui, Icon::Home, t.text_dim, "Home", vec2(26.0, ch));
+            control_keytip(app, ui, &__k, "start");
+            if __k.clicked() {
+                app.open_dialog("start", json!({}));
+            }
+            if icon_button(ui, Icon::Save, t.text_dim, "Save", vec2(26.0, ch)).clicked()
+                // File operations must include the cell the user is still editing (as the File > Save menu item already does).
+                && app.commit_edit(0, 0, false, false)
+            {
+                app.run_or_alert("file.save", json!({}));
+            }
+            // The commands' own availability: there must be a step, and no undo group may be open on
+            // the document (an action that spans several calls is still running).
+            let can_undo = gridcraft_engine::cmd::can_undo(&app.session).is_ok();
+            let can_redo = gridcraft_engine::cmd::can_redo(&app.session).is_ok();
+            // Named and marked enabled or not for assistive technology (and the UI tests).
+            let undo = icon_button(ui, Icon::Undo, if can_undo { t.text_dim } else { t.text_disabled }, "Undo", vec2(26.0, ch));
+            undo.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, can_undo, "Undo"));
+            if undo.clicked() && can_undo {
+                app.run_or_alert("edit.undo", json!({}));
+            }
+            let undo_list = icon_button(ui, Icon::Chevron, t.text_dim, "Undo list", vec2(14.0, ch));
+            egui::Popup::menu(&undo_list).show(|ui| {
+                let labels: Vec<String> = if can_undo {
+                    app.session.active().map(|d| d.undo.iter().rev().take(20).map(|e| e.label.clone()).collect()).unwrap_or_default()
+                } else {
+                    Vec::new()
+                };
+                if labels.is_empty() {
+                    ui.label("Can't Undo");
+                }
+                for (i, l) in labels.iter().enumerate() {
+                    if ui.button(format!("Undo {l}")).clicked() {
+                        app.run_or_alert("edit.undo", json!({"steps": i + 1}));
+                    }
+                }
+            });
+            let redo = icon_button(ui, Icon::Redo, if can_redo { t.text_dim } else { t.text_disabled }, "Redo", vec2(26.0, ch));
+            redo.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, can_redo, "Redo"));
+            if redo.clicked() && can_redo {
+                app.run_or_alert("edit.redo", json!({}));
+            }
+            let more = icon_button(ui, Icon::More, t.text_dim, "More commands", vec2(26.0, ch));
+            egui::Popup::menu(&more).show(|ui| {
+                for (label, id) in [
+                    ("New Workbook", "file.new"),
+                    ("Open…", "file.open"),
+                    ("Save As…", "file.saveAs"),
+                    ("Sort A to Z", "data.sortAscending"),
+                    ("Calculate Now", "formulas.calculateNow"),
+                ] {
+                    if ui.button(label).clicked() {
+                        app.run_or_alert(id, json!({}));
+                    }
+                }
+                if ui.button("Print…").clicked() {
+                    app.print_now(json!({}));
+                }
+            });
+            let left_end = ui.min_rect().right();
+            let right = ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                ui.add_space(8.0);
+                let __k = icon_button(ui, Icon::Search, t.text_dim, "Search commands", vec2(28.0, ch));
+                control_keytip(app, ui, &__k, "commandSearch");
+                if __k.clicked() {
+                    app.open_dialog("commandSearch", json!({}));
+                }
+                let share = small_button(ui, Icon::Share, "Share", "Share: export or save a copy", true);
+                egui::Popup::menu(&share).show(|ui| {
+                    if ui.button("Export as PDF…").clicked() {
+                        app.run_or_alert("file.exportPdf", json!({}));
+                    }
+                    for (label, fmt) in
+                        [("Save a Copy as Excel Workbook (.xlsx)…", "xlsx"), ("Export as CSV…", "csv"), ("Export as Web Page (.html)…", "html")]
+                    {
+                        if ui.button(label).clicked() {
+                            app.open_dialog("saveCopy", json!({"format": fmt}));
+                        }
+                    }
+                });
+                let __k = icon_button(ui, Icon::Comment, t.text_dim, "Comments", vec2(28.0, ch));
+                control_keytip(app, ui, &__k, "comments");
+                if __k.clicked() {
+                    app.open_dialog("comments", json!({}));
+                }
+                // Quick light/dark switch (#194); right-click offers System as well. The same
+                // choice lives in File › Display theme and the View tab.
+                let lang = app.ui.language;
+                let theme = icon_button(ui, Icon::Appearance, t.text_dim, "Dark Mode", vec2(28.0, 26.0));
+                let dark = ui.ctx().theme() == egui::Theme::Dark;
+                theme.widget_info(|| egui::WidgetInfo::selected(egui::Role::CheckBox, true, dark, lang.tr("Dark Mode")));
+                if theme.clicked() {
+                    act(app, "view.darkMode", json!({}));
+                }
+                theme.context_menu(|ui| theme_choices(app, ui));
+                ui.min_rect().left()
+            });
+            // Centred title, cut with "…" so it never runs under the controls on either side.
+            let title = app.session.active().map(|d| d.display_title()).unwrap_or_default();
+            let dirty = app.session.active().is_some_and(|d| d.is_dirty());
+            let max_w = title_max_width(rect.center().x, left_end, right.inner);
+            paint_title(ui, rect.center(), &title, dirty, max_w, t.text);
+        });
+    });
+}
+
+/// Lay out the title truncated to fit `max_w` together with the unsaved marker (when `dirty`).
+fn title_galleys(
+    painter: &egui::Painter,
+    title: &str,
+    dirty: bool,
+    max_w: f32,
+    color: Color32,
+) -> (std::sync::Arc<egui::Galley>, Option<std::sync::Arc<egui::Galley>>) {
+    let font = theme::ui_bold(13.0);
+    let dot = dirty.then(|| painter.layout_no_wrap(" •".to_string(), font.clone(), color));
+    let dot_w = dot.as_ref().map_or(0.0, |g| g.size().x);
+    let mut job = egui::text::LayoutJob::simple_singleline(title.to_string(), font, color);
+    job.wrap = egui::text::TextWrapping::truncate_at_width((max_w - dot_w).max(0.0));
+    (painter.layout_job(job), dot)
+}
+
+/// Gap kept between the title and the controls beside it.
+const TITLE_GAP: f32 = 12.0;
+
+/// The widest the centred title may be without reaching the controls that end at `left_end` or
+/// start at `right_start`.
+fn title_max_width(center_x: f32, left_end: f32, right_start: f32) -> f32 {
+    let half = (center_x - left_end).min(right_start - center_x) - TITLE_GAP;
+    (2.0 * half).max(0.0)
+}
+
+/// Paint the workbook title centred on `center`, truncated with "…" to `max_w`. The unsaved
+/// marker stays visible however short the title gets.
+fn paint_title(ui: &Ui, center: egui::Pos2, title: &str, dirty: bool, max_w: f32, color: Color32) {
+    let (galley, dot) = title_galleys(ui.painter(), title, dirty, max_w, color);
+    let dot_w = dot.as_ref().map_or(0.0, |g| g.size().x);
+    let w = galley.size().x + dot_w;
+    let left = center.x - w / 2.0;
+    let top = center.y - galley.size().y / 2.0;
+    let galley_w = galley.size().x;
+    ui.painter().galley(pos2(left, top), galley, color);
+    if let Some(dot) = dot {
+        ui.painter().galley(pos2(left + galley_w, top), dot, color);
+    }
+}
+
+#[cfg(test)]
+mod title_bar_tests {
+    use super::*;
+
+    #[test]
+    fn mac_title_bar_centres_and_clears_the_traffic_lights() {
+        // The lights are centred in the bar, and content keeps the same gap after them.
+        let margin = (MAC_TITLE_BAR - MAC_LIGHT) / 2.0;
+        let lights_end = MAC_LIGHTS_LEFT + 2.0 * MAC_LIGHT_PITCH + MAC_LIGHT;
+        assert_eq!(MAC_CONTENT_LEFT - lights_end, margin);
+    }
+
+    #[test]
+    fn title_fits_between_the_controls() {
+        // Room limited by the nearer side, symmetric about the centre.
+        assert_eq!(title_max_width(500.0, 300.0, 900.0), 2.0 * (200.0 - TITLE_GAP));
+        assert_eq!(title_max_width(500.0, 100.0, 650.0), 2.0 * (150.0 - TITLE_GAP));
+        // Controls overlapping the centre leave no room rather than a negative width.
+        assert_eq!(title_max_width(500.0, 520.0, 900.0), 0.0);
+    }
+
+    /// Lay out a title in a real egui frame, returning (title text, title width, dot width).
+    fn layout_title(title: &str, dirty: bool, max_w: f32) -> (String, f32, f32) {
+        let ctx = egui::Context::default();
+        ctx.set_fonts(theme::font_definitions());
+        let mut out = (String::new(), 0.0, 0.0);
+        let mut frame = ctx.run_ui(egui::RawInput::default(), |ui| {
+            let (galley, dot) = title_galleys(ui.painter(), title, dirty, max_w, Color32::WHITE);
+            // The glyphs actually drawn: `galley.text()` is the untruncated source.
+            let shown = galley.rows.iter().flat_map(|r| r.glyphs.iter().map(|g| g.chr)).collect();
+            out = (shown, galley.size().x, dot.map_or(0.0, |d| d.size().x));
+        });
+        frame.textures_delta.clear(); // nothing consumes the atlas in a headless test
+        out
+    }
+
+    #[test]
+    fn long_title_is_truncated_with_an_ellipsis() {
+        let long = format!("upload-{}-cleaned (1).xlsx", "3FMyNTYg2gDaANiAAACq20AAAAQMBqug".repeat(4));
+        let (text, w, _) = layout_title(&long, false, 300.0);
+        assert!(text.ends_with('…'), "truncated title ends with an ellipsis: {text:?}");
+        assert!(text.chars().count() < long.chars().count());
+        assert!(w <= 300.0, "title stays within its room: {w}");
+    }
+
+    #[test]
+    fn short_title_is_left_whole() {
+        let (text, _, _) = layout_title("Book1.xlsx", false, 300.0);
+        assert_eq!(text, "Book1.xlsx");
+    }
+
+    #[test]
+    fn unsaved_dot_survives_truncation() {
+        let long = "a very long workbook name ".repeat(20);
+        let (text, w, dot_w) = layout_title(&long, true, 200.0);
+        assert!(dot_w > 0.0, "the unsaved marker is laid out");
+        assert!(text.ends_with('…'));
+        assert!(w + dot_w <= 200.0, "title and marker fit together: {}", w + dot_w);
+    }
+
+    #[test]
+    fn no_room_draws_nothing_but_does_not_crash() {
+        let (_, w, _) = layout_title("Book1.xlsx", true, 0.0);
+        assert!(w <= 20.0, "a zero-width slot leaves at most the ellipsis: {w}");
+    }
+}
diff --git a/crates/ui-egui/src/ribbon/view.rs b/crates/ui-egui/src/ribbon/view.rs
new file mode 100644
index 000000000..da278ad31
--- /dev/null
+++ b/crates/ui-egui/src/ribbon/view.rs
@@ -0,0 +1,182 @@
+use super::controls::{act, checkbox_on, control_keytip, invoke, keytip, menu_items, popup_command, sep};
+use super::*;
+
+/// Draws the View tab: view modes, ruler/gridlines/formula-bar/headings toggles, zoom, freeze panes, theme, animations, interface size and language.
+pub(super) fn view(app: &mut SheetApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    let _ = t;
+    for (icon, label, cmd) in [
+        (Icon::Normal, "Normal", "view.normal"),
+        (Icon::PageBreak, "Page Break\nPreview", "view.pageBreakPreview"),
+        (Icon::PageLayout, "Page\nLayout", "view.pageLayout"),
+    ] {
+        let __k = big_button(ui, icon, label, label, false);
+        control_keytip(app, ui, &__k, cmd);
+        if __k.clicked() {
+            act(app, cmd, json!({}));
+        }
+    }
+    sep(ui);
+    let s = app.session.active().and_then(|d| d.wb.active().map(|s| (s.show_gridlines, s.show_headings))).unwrap_or((true, true));
+    let lang = app.ui.language;
+    let page_layout =
+        app.session.active().and_then(|d| d.wb.active().map(|s| s.view == gridcraft_engine::model::SheetViewMode::PageLayout)).unwrap_or(false);
+    // Two columns of two, as in Excel's Show group: four stacked rows overflow the ribbon body.
+    ui.vertical(|ui| {
+        // Rulers exist only in Page Layout view.
+        let mut ruler = !app.session.hide_ruler;
+        let ruler_resp = ui.add_enabled(page_layout, egui::Checkbox::new(&mut ruler, lang.tr("Ruler")));
+        control_keytip(app, ui, &ruler_resp, "view.ruler");
+        if ruler_resp.changed() {
+            act(app, "view.ruler", json!({"on": ruler}));
+        }
+        let mut g = s.0;
+        let resp = ui.checkbox(&mut g, lang.tr("Gridlines"));
+        control_keytip(app, ui, &resp, "view.gridlines");
+        if resp.changed() {
+            act(app, "view.gridlines", json!({"on": g}));
+        }
+    });
+    ui.add_space(6.0);
+    ui.vertical(|ui| {
+        let mut fb = app.session.prefs.formula_bar;
+        let resp = ui.checkbox(&mut fb, lang.tr("Formula Bar"));
+        control_keytip(app, ui, &resp, "view.formulaBar");
+        if resp.changed() || invoke(app, "view.formulaBar") {
+            act(app, "view.formulaBar", json!({"on": checkbox_on(resp.changed(), fb)}));
+        }
+        let mut h = s.1;
+        let resp = ui.checkbox(&mut h, lang.tr("Headings"));
+        control_keytip(app, ui, &resp, "view.headings");
+        if resp.changed() {
+            act(app, "view.headings", json!({"on": h}));
+        }
+    });
+    sep(ui);
+    let __k = big_button(ui, Icon::Zoom, "Zoom", "Zoom…", false);
+    control_keytip(app, ui, &__k, "dialog:zoom");
+    if __k.clicked() {
+        app.open_dialog("zoom", json!({}));
+    }
+    let __k = big_button(ui, Icon::Search, "100%", "Zoom to 100%", false);
+    control_keytip(app, ui, &__k, "view.zoom");
+    if __k.clicked() || invoke(app, "view.zoom") {
+        act(app, "view.zoom", json!({"percent": 100}));
+    }
+    let __k = big_button(ui, Icon::Zoom, "Zoom to\nSelection", "Zoom to Selection", false);
+    control_keytip(app, ui, &__k, "view.zoomToSelection");
+    if __k.clicked() {
+        let r = app.grid.cells_rect.unwrap_or(Rect::from_min_size(pos2(0.0, 0.0), vec2(1200.0, 700.0)));
+        act(app, "view.zoomToSelection", json!({"viewWidth": r.width(), "viewHeight": r.height()}));
+    }
+    sep(ui);
+    let __k = big_button(ui, Icon::NewFile, "New\nWindow", "New Window", false);
+    control_keytip(app, ui, &__k, "view.newWindow");
+    if __k.clicked() {
+        act(app, "view.newWindow", json!({}));
+    }
+    let __k = big_button(ui, Icon::Table, "Arrange\nAll", "Arrange All", false);
+    control_keytip(app, ui, &__k, "view.arrangeAll");
+    if __k.clicked() {
+        app.open_dialog("arrangeAll", json!({}));
+    }
+    let fp = big_button(ui, Icon::Freeze, "Freeze\nPanes", "Freeze Panes", true);
+    for sequence in
+        keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["view.freezePanes", "view.freezeTopRow", "view.freezeFirstColumn"])
+    {
+        keytip(app, ui, sequence, fp.rect.center_bottom());
+    }
+    egui::Popup::menu(&fp).show(|ui| {
+        menu_items(
+            app,
+            ui,
+            &[
+                ("Freeze Panes", "view.freezePanes", json!({})),
+                ("Freeze Top Row", "view.freezeTopRow", json!({})),
+                ("Freeze First Column", "view.freezeFirstColumn", json!({})),
+                ("Unfreeze Panes", "view.unfreezePanes", json!({})),
+            ],
+        );
+    });
+    switch_windows(app, ui);
+    ui.vertical(|ui| {
+        let label_response = ui.label(lang.tr("Display theme"));
+        let mode = app.ui.theme_mode();
+        let label = match mode {
+            "system" => "System",
+            "dark" => "Dark",
+            _ => "Light",
+        };
+        egui::ComboBox::from_id_salt("display_theme")
+            .selected_text(lang.tr(label))
+            .width(88.0)
+            .show_ui(ui, |ui| {
+                for (value, label) in [("system", "System"), ("light", "Light"), ("dark", "Dark")] {
+                    if ui.selectable_label(mode == value, lang.tr(label)).clicked() {
+                        act(app, "view.theme", json!({"mode": value}));
+                    }
+                }
+            })
+            .response
+            .labelled_by(label_response.id);
+        let mut animations = app.ui.animations;
+        let hint = lang.tr("Glide the selection outline to the cell you move to instead of jumping there");
+        if ui.checkbox(&mut animations, lang.tr("Animations")).on_hover_text(hint).changed() {
+            act(app, "view.animations", json!({"on": animations}));
+        }
+    });
+    sep(ui);
+    // Interface size (issue #230): scales the whole window on top of the desktop's scale.
+    ui.vertical(|ui| {
+        let label = ui.label(egui::RichText::new(lang.tr("Interface size")).font(theme::ui_font(11.5)).color(t.text_dim));
+        let current = app.ui.interface_scale;
+        let text = |v: u16| if v == 100 { lang.tr("Auto").to_string() } else { format!("{v}%") };
+        egui::ComboBox::from_id_salt("ui_interface_size")
+            .width(120.0)
+            .selected_text(egui::RichText::new(text(current)).font(theme::ui_font(12.5)))
+            .show_ui(ui, |ui| {
+                for v in [100, 75, 90, 110, 125, 150, 175, 200] {
+                    if ui.selectable_label(v == current, text(v)).clicked() {
+                        act(app, "view.interfaceScale", json!({"percent": v}));
+                    }
+                }
+            })
+            .response
+            .labelled_by(label.id);
+    });
+    // Interface language: settings live in the View tab, like Excel's Options. The label follows
+    // the current language so it stays readable; the choices are always shown in their own script.
+    ui.vertical(|ui| {
+        let label = ui.label(egui::RichText::new(lang.tr("Interface language")).font(theme::ui_font(11.5)).color(t.text_dim));
+        egui::ComboBox::from_id_salt("ui_language")
+            .width(120.0)
+            .selected_text(egui::RichText::new(lang.name()).font(theme::ui_font(12.5)))
+            .show_ui(ui, |ui| {
+                for l in crate::i18n::Language::ALL {
+                    if ui.selectable_label(l == lang, l.name()).clicked() {
+                        act(app, "app.language.set", json!({"language": l.code()}));
+                    }
+                }
+            })
+            .response
+            .labelled_by(label.id);
+    });
+}
+
+/// View › Switch Windows: the open workbooks, the active one checked and unsaved ones marked;
+/// choosing one brings it forward.
+fn switch_windows(app: &mut SheetApp, ui: &mut Ui) {
+    let anchor = big_button(ui, Icon::Book, "Switch\nWindows", "Switch Windows", true);
+    anchor.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), "Switch Windows"));
+    control_keytip(app, ui, &anchor, "view.switchWindows");
+    let forced = std::mem::take(&mut app.open_switch_windows) | invoke(app, "view.switchWindows");
+    egui::Popup::menu(&anchor).open_memory(popup_command(forced, anchor.clicked())).show(|ui| {
+        for w in app.open_windows() {
+            let label = theme::available_text(ui, &format!("{}{}", if w.active { "✓ " } else { "    " }, w.label()));
+            if ui.add(egui::Button::selectable(w.active, label).min_size(vec2(220.0, 22.0))).clicked() {
+                act(app, "view.switchWindows", json!({"window": w.window}));
+                ui.close();
+            }
+        }
+    });
+}

From d840d55c4b1fa2cdc93b625b42c65007a27ab074 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:45:20 +0000
Subject: [PATCH 69/76] refactor(ui-egui): move theme.rs items to theme/

---
 crates/ui-egui/src/theme.rs               | 893 +---------------------
 crates/ui-egui/src/theme/font_fallback.rs | 296 +++++++
 crates/ui-egui/src/theme/font_setup.rs    | 598 +++++++++++++++
 3 files changed, 909 insertions(+), 878 deletions(-)
 create mode 100644 crates/ui-egui/src/theme/font_fallback.rs
 create mode 100644 crates/ui-egui/src/theme/font_setup.rs

diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index 28dc465e2..0adb1563c 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -20,27 +20,22 @@ use std::sync::Arc;
 use egui::epaint::text::Blob;
 use egui::{Color32, FontData, FontDefinitions, FontFamily, FontId, Stroke, Visuals};
 
-/// A font from the optional craft-fonts build input (`CRAFT_FONTS_DIR` at build time; see
-/// <https://github.com/storytold/craft-fonts> and its `docs/integration.md`). The slice is empty
-/// when the app is built without the checkout; nothing is downloaded and no font is in this repo.
-#[derive(Debug)]
-pub struct CraftFont {
-    pub family: &'static str,
-    pub style: &'static str,
-    /// ISO 15924 scripts the family is intended for, from the craft-fonts manifest.
-    pub scripts: &'static [&'static str],
-    pub bytes: &'static [u8],
-}
+mod font_fallback;
+mod font_setup;
 
-mod craft_fonts {
-    use super::CraftFont;
-    include!(concat!(env!("OUT_DIR"), "/craft_fonts.rs"));
-}
-
-/// The light or dark value of a colour, by mode.
-fn pick<T>(dark: bool, light: T, dark_value: T) -> T {
-    if dark { dark_value } else { light }
-}
+pub use font_fallback::symbol_face_installed;
+#[cfg(test)]
+use font_fallback::{cjk_han_japanese, cjk_han_simplified, cjk_hangul, fallback_faces, hebrew, lao, symbols_more, thai};
+use font_setup::pick;
+pub use font_setup::{
+    CELL, CELL_BOLD, CELL_BOLD_ITALIC, CELL_ITALIC, CraftFont, HanOrder, MONO, SERIF, UI, UI_BOLD, available_text, cell_family, cell_text_width,
+    chinese_font_loaded, craft_font_scripts, craft_fonts_cover, craft_fonts_loaded, craft_fonts_required, font_definitions,
+    font_definitions_for_language, font_definitions_with, pinned_font_definitions, symbol_fallback, ui_bold, ui_font,
+};
+#[cfg(test)]
+use font_setup::{candidates, craft_font_faces, try_load};
+#[cfg(test)]
+pub(crate) use font_setup::{drop_unparseable_fonts, font_parses};
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Tokens {
@@ -261,816 +256,6 @@ pub fn contrast(a: Color32, b: Color32) -> f32 {
     (la.max(lb) + 0.05) / (la.min(lb) + 0.05)
 }
 
-pub const UI: &str = "ui";
-pub const UI_BOLD: &str = "ui-bold";
-pub const CELL: &str = "cell";
-pub const CELL_BOLD: &str = "cell-bold";
-pub const CELL_ITALIC: &str = "cell-italic";
-pub const CELL_BOLD_ITALIC: &str = "cell-bold-italic";
-pub const SERIF: &str = "serif";
-pub const MONO: &str = "mono";
-
-pub fn ui_font(size: f32) -> FontId {
-    FontId::new(size, FontFamily::Name(UI.into()))
-}
-pub fn ui_bold(size: f32) -> FontId {
-    FontId::new(size, FontFamily::Name(UI_BOLD.into()))
-}
-
-/// The font family to use for a cell font name and weight.
-///
-/// When the name is an installed font whose faces were bound by [`font_definitions`], that family
-/// is used; otherwise the name is bucketed to one of the built-in roles (mono/serif/cell). egui
-/// panics on a family that was never bound, so the installed branch is gated on
-/// [`crate::fonts::is_bound`] and never names a family egui hasn't been given.
-pub fn cell_family(name: &str, bold: bool, italic: bool) -> FontFamily {
-    let role = crate::fonts::role_key(name, bold, italic);
-    if crate::fonts::is_bound(&role) {
-        return FontFamily::Name(role.into());
-    }
-    let lower = name.to_ascii_lowercase();
-    if lower.contains("courier") || lower.contains("mono") || lower.contains("consolas") {
-        return FontFamily::Name(MONO.into());
-    }
-    if lower.contains("times")
-        || lower.contains("georgia")
-        || lower.contains("cambria")
-        || lower.contains("serif") && !lower.contains("sans")
-        || lower.contains("garamond")
-    {
-        return FontFamily::Name(SERIF.into());
-    }
-    FontFamily::Name(
-        match (bold, italic) {
-            (true, true) => CELL_BOLD_ITALIC,
-            (true, false) => CELL_BOLD,
-            (false, true) => CELL_ITALIC,
-            (false, false) => CELL,
-        }
-        .into(),
-    )
-}
-
-/// Width in points, at 100% zoom, of one line of cell text drawn as the grid draws it: in the
-/// face [`cell_family`] picks, which on a machine without the named font is a wider or narrower
-/// substitute (#1316). A family the active font set doesn't have yet (bound fonts apply from the
-/// next frame) falls back to the engine's estimate rather than letting egui panic on it.
-///
-/// `exact` lays the text out (a galley kept until the end of the frame); otherwise the glyph
-/// advances are summed without kerning, which is cheap and never narrower. This takes the
-/// Context lock (`fonts_mut`): never call it, or run a command, while an egui lock is held.
-pub fn cell_text_width(ctx: &egui::Context, text: &str, font: &gridcraft_engine::model::Font, exact: bool) -> f32 {
-    let family = cell_family(&font.name, font.bold, font.italic);
-    let id = FontId::new(font.size * 96.0 / 72.0, family);
-    ctx.fonts_mut(|f| {
-        f.families().contains(&id.family).then(|| {
-            if exact {
-                f.layout_no_wrap(text.to_owned(), id, Color32::PLACEHOLDER).size().x
-            } else {
-                // Half a point covers the galley's rounding of its width up to the pixel grid.
-                text.chars().map(|c| f.glyph_width(&id, c)).sum::<f32>() + 0.5
-            }
-        })
-    })
-    .unwrap_or_else(|| gridcraft_engine::cmd::format::approx_text_width(text, font.size, font.bold))
-}
-
-/// Whether epaint can open face `index` of this font file and it maps characters to glyphs.
-/// epaint panics (in `Context::set_fonts`, i.e. on startup) on a face it can't open, so every font
-/// file we did not ship is checked first with the same parser and the same call epaint makes
-/// (`skrifa::FontRef::from_index`): a corrupt file, something that is not an sfnt at all, or a
-/// collection index past the end is rejected instead of crashing the app (#226). A face whose
-/// character map is unreadable (a truncated file) would open but draw nothing, so it is refused
-/// too and the next candidate gets its turn.
-pub(crate) fn font_parses(bytes: &[u8], index: u32) -> bool {
-    use skrifa::MetadataProvider;
-    skrifa::FontRef::from_index(bytes, index).is_ok_and(|font| font.charmap().has_map())
-}
-
-/// Loads the first candidate that exists and parses. A file that exists but can't be parsed is
-/// skipped with a warning and the next candidate is tried.
-#[cfg(not(target_arch = "wasm32"))]
-fn try_load(paths: &[(&str, u32)]) -> Option<FontData> {
-    for (p, index) in paths {
-        if let Some(blob) = font_file(p, *index) {
-            return Some(FontData::from_blob(blob, *index));
-        }
-    }
-    None
-}
-
-/// The interface and script fallback font files, each read once per run and kept as a shared
-/// `Blob` for the rest of it. egui shares the blob instead of copying the file into its text
-/// engine, because every one of these files is loaded by every font rebuild for as long as the
-/// app runs. Only a file that parses is kept: a missing or broken one is looked for again next
-/// time.
-#[cfg(not(target_arch = "wasm32"))]
-fn font_file(path: &str, index: u32) -> Option<Blob> {
-    static FILES: std::sync::Mutex<std::collections::BTreeMap<String, Blob>> = std::sync::Mutex::new(std::collections::BTreeMap::new());
-    let mut files = FILES.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-    if let Some(blob) = files.get(path) {
-        let bytes: &[u8] = (**blob).as_ref();
-        return font_parses(bytes, index).then(|| std::sync::Arc::clone(blob));
-    }
-    let bytes = std::fs::read(path).ok()?;
-    if !font_parses(&bytes, index) {
-        log::warn!("skipping font {path} (face {index}): not a font file egui can read");
-        return None;
-    }
-    let blob: Blob = std::sync::Arc::new(bytes);
-    files.insert(path.to_string(), blob.clone());
-    Some(blob)
-}
-
-/// Last line of defence before [`FontDefinitions`] reach egui: drops every face epaint could not
-/// parse (and its key from every family), so a bad font costs a fallback, never a crash.
-pub(crate) fn drop_unparseable_fonts(fonts: &mut FontDefinitions) {
-    let bad: Vec<String> = fonts.font_data.iter().filter(|(_, fd)| !font_parses(fd.bytes(), fd.index)).map(|(k, _)| k.clone()).collect();
-    for key in &bad {
-        log::warn!("dropping font {key:?}: egui can't parse it");
-        fonts.font_data.remove(key);
-    }
-    if !bad.is_empty() {
-        for chain in fonts.families.values_mut() {
-            chain.retain(|k| !bad.contains(k));
-        }
-    }
-}
-
-/// egui's bundled monospace face, used as the last-resort symbol fallback (see `Hack-Regular.ttf`
-/// in `epaint_default_fonts`). It is present whenever egui is built with `default_fonts`.
-const HACK: &str = "Hack";
-
-/// The permitted craft-fonts faces with their `FontDefinitions` keys, in manifest order. Empty
-/// without a `CRAFT_FONTS_DIR` checkout at build time. The filter is repeated here so a stale
-/// generated table can never smuggle in a barred face or a web-build face outside the allowlist.
-fn craft_font_faces() -> Vec<(String, &'static CraftFont)> {
-    let wasm = cfg!(target_arch = "wasm32");
-    craft_fonts::CRAFT_FONTS
-        .iter()
-        .enumerate()
-        .filter(|(_, font)| !crate::craft_fonts_policy::barred(font.family))
-        .filter(|(_, font)| !wasm || crate::craft_fonts_policy::web_allowed(font.family, font.style))
-        .map(|(i, font)| (format!("craft-{i}-{}-{}", font.family, font.style), font))
-        .collect()
-}
-
-/// Adds the optional craft-fonts faces to `fonts` and returns their keys.
-fn add_craft_fonts(fonts: &mut FontDefinitions) -> Vec<String> {
-    let mut keys = Vec::new();
-    for (key, font) in craft_font_faces() {
-        fonts.font_data.insert(key.clone(), Arc::new(FontData::from_static(font.bytes)));
-        keys.push(key);
-    }
-    keys
-}
-
-/// Whether the optional craft-fonts input was embedded in this build.
-pub fn craft_fonts_loaded() -> bool {
-    !craft_fonts::CRAFT_FONTS.is_empty()
-}
-
-/// Whether the native-only Simplified Chinese craft face (LXGW WenKai Lite) was embedded. A web
-/// build or an older craft-fonts checkout without `fonts/simplified-chinese-manifest.txt` has none.
-pub fn chinese_font_loaded() -> bool {
-    craft_font_faces().iter().any(|(_, f)| f.family == "LXGW WenKai Lite" && f.style == "Regular")
-}
-
-/// Whether this build was made with `CRAFT_FONTS_REQUIRED=1`. Acceptance tests must fail rather
-/// than skip when this is true and the faces are absent.
-pub fn craft_fonts_required() -> bool {
-    craft_fonts::CRAFT_FONTS_REQUIRED
-}
-
-/// A bundled-face character with the same meaning as `c`, for interface chrome whose exact symbol
-/// no bundled face has (`✕`, `✓`, `⌃`). Document text still needs a real glyph; this is only a
-/// display fallback and never changes the characters a command inserts or stores.
-pub fn symbol_fallback(c: char) -> Option<char> {
-    match c {
-        '✕' => Some('×'),
-        '✓' => Some('✔'),
-        '⌃' => Some('^'),
-        _ => None,
-    }
-}
-
-/// `text` with every character the current font set cannot draw replaced by its semantic fallback
-/// (see [`symbol_fallback`]). Used by chrome tooltips so a host without symbol faces never paints
-/// a tofu box; it is not applied to workbook text.
-pub fn available_text(ui: &egui::Ui, text: &str) -> String {
-    let font = ui_font(13.0);
-    text.chars().map(|c| if ui.ctx().fonts_mut(|f| f.has_glyph(&font, c)) { c } else { symbol_fallback(c).unwrap_or(c) }).collect()
-}
-
-/// The family, style and scripts of every embedded craft-fonts face (empty without the input).
-pub fn craft_font_scripts() -> impl Iterator<Item = (&'static str, &'static str, &'static [&'static str])> {
-    craft_font_faces().into_iter().map(|(_, f)| (f.family, f.style, f.scripts))
-}
-
-/// Whether one embedded craft-fonts face maps every non-whitespace character in `text`. Tests use
-/// this to tell "the pinned fixture covers this script" from "this host has no face for it",
-/// without trusting a manifest script tag alone.
-pub fn craft_fonts_cover(text: &str) -> bool {
-    craft_font_faces().iter().any(|(_, f)| {
-        use skrifa::MetadataProvider;
-        let Ok(font) = skrifa::FontRef::from_index(f.bytes, 0) else {
-            return false;
-        };
-        let map = font.charmap();
-        text.chars().filter(|c| !c.is_whitespace()).all(|c| map.map(c).is_some())
-    })
-}
-
-#[cfg(target_arch = "wasm32")]
-fn try_load(_paths: &[(&str, u32)]) -> Option<FontData> {
-    None
-}
-
-fn home_fonts(file: &str) -> String {
-    let home = std::env::var("HOME").unwrap_or_default();
-    format!("{home}/Library/Fonts/{file}")
-}
-
-/// Every file in `files` under every directory in `dirs`, directory first, in the same order a
-/// nested loop over the directories would add them.
-fn in_dirs(dirs: &[&str], files: &[&str]) -> Vec<String> {
-    dirs.iter().flat_map(|d| files.iter().map(move |f| format!("{d}/{f}"))).collect()
-}
-
-/// Candidate font files per role, in preference order.
-fn candidates(role: &str) -> Vec<(String, u32)> {
-    let mac_sys = "/System/Library/Fonts";
-    let mac_sup = "/System/Library/Fonts/Supplemental";
-    let win = std::env::var("WINDIR").map(|w| format!("{w}\\Fonts")).unwrap_or_else(|_| "C:\\Windows\\Fonts".into());
-    // ChromeOS's Linux container (Crostini) mounts the host's fonts under `chromeos/` (#1762).
-    let lin = ["/usr/share/fonts/truetype", "/usr/share/fonts", "/usr/local/share/fonts", "/usr/share/fonts/TTF", "/usr/share/fonts/chromeos"];
-    let mut v: Vec<(String, u32)> = Vec::new();
-    let mut add = |s: String, i: u32| v.push((s, i));
-    match role {
-        "ui" => {
-            add(format!("{mac_sys}/SFNS.ttf"), 0);
-            add(format!("{mac_sys}/HelveticaNeue.ttc"), 0);
-            add(format!("{win}\\segoeui.ttf"), 0);
-            for p in in_dirs(
-                &lin,
-                &["cantarell/Cantarell-Regular.otf", "noto/NotoSans-Regular.ttf", "dejavu/DejaVuSans.ttf", "liberation/LiberationSans-Regular.ttf"],
-            ) {
-                add(p, 0);
-            }
-            // Fedora keeps each family in its own package folder (#54).
-            add("/usr/share/fonts/abattis-cantarell-fonts/Cantarell-Regular.otf".into(), 0);
-            add("/usr/share/fonts/google-noto/NotoSans-Regular.ttf".into(), 0);
-            add("/usr/share/fonts/dejavu-sans-fonts/DejaVuSans.ttf".into(), 0);
-            add("/usr/share/fonts/liberation-sans-fonts/LiberationSans-Regular.ttf".into(), 0);
-        }
-        "ui-bold" => {
-            add(format!("{mac_sys}/HelveticaNeue.ttc"), 1);
-            add(format!("{win}\\segoeuib.ttf"), 0);
-            for p in in_dirs(&lin, &["noto/NotoSans-Bold.ttf", "dejavu/DejaVuSans-Bold.ttf", "liberation/LiberationSans-Bold.ttf"]) {
-                add(p, 0);
-            }
-            add("/usr/share/fonts/google-noto/NotoSans-Bold.ttf".into(), 0);
-            add("/usr/share/fonts/dejavu-sans-fonts/DejaVuSans-Bold.ttf".into(), 0);
-            add("/usr/share/fonts/liberation-sans-fonts/LiberationSans-Bold.ttf".into(), 0);
-        }
-        "cell" | "cell-bold" | "cell-italic" | "cell-bold-italic" => {
-            let (carlito, calibri_win, calibri_mac, arial_mac, arial_win, lib, dejavu) = match role {
-                "cell" => {
-                    ("Carlito-Regular.ttf", "calibri.ttf", "Calibri.ttf", "Arial.ttf", "arial.ttf", "LiberationSans-Regular.ttf", "DejaVuSans.ttf")
-                }
-                "cell-bold" => (
-                    "Carlito-Bold.ttf",
-                    "calibrib.ttf",
-                    "Calibri Bold.ttf",
-                    "Arial Bold.ttf",
-                    "arialbd.ttf",
-                    "LiberationSans-Bold.ttf",
-                    "DejaVuSans-Bold.ttf",
-                ),
-                "cell-italic" => (
-                    "Carlito-Italic.ttf",
-                    "calibrii.ttf",
-                    "Calibri Italic.ttf",
-                    "Arial Italic.ttf",
-                    "ariali.ttf",
-                    "LiberationSans-Italic.ttf",
-                    "DejaVuSans-Oblique.ttf",
-                ),
-                _ => (
-                    "Carlito-BoldItalic.ttf",
-                    "calibriz.ttf",
-                    "Calibri Bold Italic.ttf",
-                    "Arial Bold Italic.ttf",
-                    "arialbi.ttf",
-                    "LiberationSans-BoldItalic.ttf",
-                    "DejaVuSans-BoldOblique.ttf",
-                ),
-            };
-            // Calibri if the user has it installed system-wide (never from an Office bundle).
-            add(format!("/Library/Fonts/{calibri_mac}"), 0);
-            add(home_fonts(calibri_mac), 0);
-            add(format!("{win}\\{calibri_win}"), 0);
-            for p in in_dirs(&lin, &[&format!("crosextra/{carlito}"), &format!("carlito/{carlito}")]) {
-                add(p, 0);
-            }
-            // Fedora keeps each family in its own package folder, as for the UI fonts (#54).
-            add(format!("/usr/share/fonts/google-carlito-fonts/{carlito}"), 0);
-            add(home_fonts(carlito), 0);
-            add(format!("{mac_sup}/{arial_mac}"), 0);
-            add(format!("{win}\\{arial_win}"), 0);
-            for p in in_dirs(&lin, &[&format!("liberation/{lib}"), &format!("dejavu/{dejavu}")]) {
-                add(p, 0);
-            }
-            add(format!("/usr/share/fonts/liberation-sans-fonts/{lib}"), 0);
-            add(format!("/usr/share/fonts/dejavu-sans-fonts/{dejavu}"), 0);
-        }
-        "serif" => {
-            add(format!("{mac_sup}/Times New Roman.ttf"), 0);
-            add(format!("{win}\\times.ttf"), 0);
-            for p in in_dirs(&lin, &["liberation/LiberationSerif-Regular.ttf", "dejavu/DejaVuSerif.ttf"]) {
-                add(p, 0);
-            }
-            add("/usr/share/fonts/liberation-serif-fonts/LiberationSerif-Regular.ttf".into(), 0);
-            add("/usr/share/fonts/dejavu-serif-fonts/DejaVuSerif.ttf".into(), 0);
-        }
-        "mono" => {
-            add(format!("{mac_sys}/SFNSMono.ttf"), 0);
-            add(format!("{mac_sys}/Menlo.ttc"), 0);
-            add(format!("{win}\\consola.ttf"), 0);
-            for p in in_dirs(&lin, &["dejavu/DejaVuSansMono.ttf"]) {
-                add(p, 0);
-            }
-            add("/usr/share/fonts/dejavu-sans-mono-fonts/DejaVuSansMono.ttf".into(), 0);
-            // Fedora installs DejaVu Sans Mono only on request. Liberation Mono comes with LibreOffice
-            // (in Workstation and KDE by default), Noto Sans Mono (variable, Regular by default) always.
-            for p in in_dirs(&lin, &["liberation/LiberationMono-Regular.ttf"]) {
-                add(p, 0);
-            }
-            add("/usr/share/fonts/liberation-mono-fonts/LiberationMono-Regular.ttf".into(), 0);
-            add("/usr/share/fonts/google-noto-vf/NotoSansMono[wght].ttf".into(), 0);
-        }
-        _ => {}
-    }
-    v
-}
-
-/// Builds the font set from system fonts (with egui's defaults as fallback), with the default
-/// (non-Japanese) Han order. Never reads the host locale, so tests and snapshots are stable.
-pub fn font_definitions() -> FontDefinitions {
-    font_definitions_for_language(crate::i18n::Language::En)
-}
-
-/// Which Han face leads the fallback chain. Both Han faces cover kana and most kanji, so this only
-/// decides glyph shapes (and which face catches a glyph the other lacks); switching between two
-/// languages with the same order needs no font rebuild.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum HanOrder {
-    /// Japanese glyph shapes first (the interface is Japanese).
-    Japanese,
-    /// Simplified Chinese first: the widest Han coverage, for every other interface language.
-    Chinese,
-}
-
-impl HanOrder {
-    pub fn of(language: crate::i18n::Language) -> Self {
-        if language == crate::i18n::Language::Ja { Self::Japanese } else { Self::Chinese }
-    }
-}
-
-/// Builds the font set with the Han fallback faces ordered for the interface language.
-pub fn font_definitions_for_language(language: crate::i18n::Language) -> FontDefinitions {
-    font_definitions_with(language, &[])
-}
-
-/// The bundled faces plus the pinned craft-fonts faces, with no system-font probing or installed
-/// workbook-font binding.
-///
-/// Integration tests use this through their shared harness, so a minimal CI image and a developer
-/// machine see the same font set. Craft-fonts remains a pinned build input rather than a repository
-/// asset; without it only egui's bundled faces are available, which is the documented no-font mode.
-pub fn pinned_font_definitions() -> FontDefinitions {
-    font_definitions_impl(crate::i18n::Language::En, &[], false)
-}
-
-/// [`font_definitions_for_language`] that also binds the workbook fonts in `used` that are
-/// installed, so cells set in them render with them; the rest fall back to the roles. The bound
-/// families are recorded in [`crate::fonts`] so [`cell_family`] only names a family egui has.
-pub fn font_definitions_with(language: crate::i18n::Language, used: &[String]) -> FontDefinitions {
-    font_definitions_impl(language, used, true)
-}
-
-/// Builds the role font chains, script fallbacks, installed workbook fonts and optional craft-font faces, drops unparseable data and records which families were bound.
-fn font_definitions_impl(language: crate::i18n::Language, used: &[String], system: bool) -> FontDefinitions {
-    let mut fonts = FontDefinitions::default();
-    let base_prop: Vec<String> = fonts.families.get(&FontFamily::Proportional).cloned().unwrap_or_default();
-    let base_mono: Vec<String> = fonts.families.get(&FontFamily::Monospace).cloned().unwrap_or_default();
-    let mut bound: Vec<String> = Vec::new();
-    // The non-Latin fallback faces have to sit at the end of each chain: a Latin font owns Latin,
-    // and epaint picks the first face that has the glyph, so they only catch their own scripts.
-    let fallback = if system { load_fallback(&mut fonts, HanOrder::of(language)) } else { Vec::new() };
-    let hack = fonts.font_data.contains_key(HACK).then_some(HACK);
-    for role in [UI, UI_BOLD, CELL, CELL_BOLD, CELL_ITALIC, CELL_BOLD_ITALIC, SERIF, MONO] {
-        let chain = build_role_chain(&mut fonts, role, &base_prop, &base_mono, &fallback, hack, system);
-        fonts.families.insert(FontFamily::Name(role.into()), chain);
-        bound.push(role.to_string());
-    }
-    // Installed workbook fonts, so a cell's chosen font actually renders in it.
-    if system {
-        for family in crate::fonts::installed_among(used) {
-            bound.extend(crate::fonts::bind_family(&mut fonts, &family));
-        }
-    }
-    // Interface text (formula bar, name box, dialogs) falls back to the cell font before the
-    // script faces: whatever a cell can draw, the formula bar can draw too, even where no script
-    // fallback face was found (#349: macOS UI font without Hebrew, cells in Arial with it).
-    bind_cell_fallback(&mut fonts, &fallback);
-    // Default proportional text in widgets uses the UI font.
-    if let Some(ui) = fonts.families.get(&FontFamily::Name(UI.into())).cloned() {
-        fonts.families.insert(FontFamily::Proportional, ui);
-    }
-    // The optional craft-fonts faces go at the very end of every family: a system or bundled face
-    // that has the script keeps its glyph shapes, while the permitted OFL faces cover scripts and
-    // symbols the host image lacks (Japanese, Korean, Thai, Arabic, Georgian and the UI symbols).
-    // Chinese comes from the native-only OFL LXGW face when embedded; a system Han face still
-    // leads, and the barred Noto CJK collection never enters.
-    append_craft_faces(&mut fonts);
-    drop_unparseable_fonts(&mut fonts);
-    // Only families egui still has data for count as bound (a dropped face can empty a chain).
-    bound.retain(|f| fonts.families.get(&FontFamily::Name(f.as_str().into())).is_some_and(|c| !c.is_empty()));
-    crate::fonts::set_bound(bound);
-    fonts
-}
-
-/// Builds one role family's chain: the loaded system face (or its role fallback), egui's bundled
-/// proportional/monospace base, Hack's symbols, then the script fallbacks. Keys without font data
-/// are dropped, as before.
-fn build_role_chain(
-    fonts: &mut FontDefinitions,
-    role: &str,
-    base_prop: &[String],
-    base_mono: &[String],
-    fallback: &[String],
-    hack: Option<&str>,
-    system: bool,
-) -> Vec<String> {
-    let paths = candidates(role);
-    let refs: Vec<(&str, u32)> = paths.iter().map(|(p, i)| (p.as_str(), *i)).collect();
-    let mut chain: Vec<String> = Vec::new();
-    let loaded = if system { try_load(&refs) } else { None };
-    if let Some(mut fd) = loaded {
-        // Helvetica Neue Bold's own TrueType hints close Cyrillic е into ө at 13 pt on a Retina
-        // screen (#1184). Core Text never runs them, so this draws it the way macOS does.
-        if cfg!(target_os = "macos") && role == UI_BOLD {
-            fd.tweak.hinting = Some(false);
-        }
-        let key = format!("sys-{role}");
-        fonts.font_data.insert(key.clone(), Arc::new(fd));
-        chain.push(key);
-    } else if role == UI_BOLD {
-        chain.push(format!("sys-{UI}"));
-    } else if role.starts_with("cell-") {
-        chain.push(format!("sys-{CELL}"));
-    }
-    chain.extend(if role == MONO { base_mono.to_vec() } else { base_prop.to_vec() });
-    // egui bundles Hack, a monospace face rich in arrows, triangles and keyboard symbols, but
-    // 0.37 only puts it in the Monospace family. The interface draws ↑, ▲, ▼, ▸, ▾ and ↳ as
-    // text (filter menus, ribbon, keytips), so add it behind the UI/cell and emoji faces; it
-    // only catches characters those do not have.
-    if let Some(hack) = hack
-        && !chain.iter().any(|k| k.as_str() == hack)
-    {
-        chain.push(hack.to_string());
-    }
-    chain.extend(fallback.iter().cloned());
-    chain.retain(|k| fonts.font_data.contains_key(k));
-    chain
-}
-
-/// Inserts the loaded cell face before the script fallbacks of the interface families, so the
-/// formula bar and dialogs can draw whatever a cell can (#349).
-fn bind_cell_fallback(fonts: &mut FontDefinitions, fallback: &[String]) {
-    let cell_key = format!("sys-{CELL}");
-    if !fonts.font_data.contains_key(&cell_key) {
-        return;
-    }
-    for role in [UI, UI_BOLD, SERIF, MONO] {
-        if let Some(chain) = fonts.families.get_mut(&FontFamily::Name(role.into()))
-            && !chain.contains(&cell_key)
-        {
-            let at = chain.iter().position(|k| fallback.contains(k)).unwrap_or(chain.len());
-            chain.insert(at, cell_key.clone());
-        }
-    }
-}
-
-/// Appends the permitted craft-fonts faces to every family, preserving the leading system or
-/// bundled face's glyph shapes.
-fn append_craft_faces(fonts: &mut FontDefinitions) {
-    let craft = add_craft_fonts(fonts);
-    if craft.is_empty() {
-        return;
-    }
-    for chain in fonts.families.values_mut() {
-        for key in &craft {
-            if !chain.contains(key) {
-                chain.push(key.clone());
-            }
-        }
-    }
-}
-
-/// Loads the system non-Latin fallback faces (one file per script family) and returns their keys so
-/// every family can carry them as fallback. egui's bundled fonts have no coverage beyond Latin, so
-/// without this a Thai, Hebrew, Japanese or Chinese workbook shows tofu boxes even though the text
-/// was read correctly. With a face installed those scripts get real glyphs instead of tofu; nothing
-/// is bundled, and a machine without the face keeps the old behaviour.
-#[cfg(not(target_arch = "wasm32"))]
-fn load_fallback(fonts: &mut FontDefinitions, han: HanOrder) -> Vec<String> {
-    let mut keys = Vec::new();
-    // Files already loaded as a fallback face. A file serves at most one key: the region-merged
-    // Noto Sans CJK .ttc found for Han also carries Hangul (and Tahoma carries both Thai and
-    // Hebrew), so loading it again for a later script would only duplicate tens of MB in memory.
-    let mut loaded: Vec<String> = Vec::new();
-    for (key, cands) in fallback_faces(han) {
-        for (path, index) in &cands {
-            if loaded.contains(path) {
-                break; // a face loaded for an earlier script already covers this one
-            }
-            if let Some(fd) = try_load(&[(path.as_str(), *index)]) {
-                fonts.font_data.insert(key.to_string(), Arc::new(fd));
-                keys.push(key.to_string());
-                loaded.push(path.clone());
-                break;
-            }
-        }
-    }
-    keys
-}
-
-#[cfg(target_arch = "wasm32")]
-fn load_fallback(_fonts: &mut FontDefinitions, _han: HanOrder) -> Vec<String> {
-    Vec::new()
-}
-
-/// Every fallback face we look for, in chain order: `(key, candidate files)`. One file per script
-/// family is enough — epaint picks the first face with the glyph, and a script's glyphs live in one
-/// file. Order only matters between faces that both cover a glyph (Japanese vs Chinese kanji), so
-/// the interface language reorders the two Han entries and nothing else.
-#[cfg(not(target_arch = "wasm32"))]
-fn fallback_faces(han: HanOrder) -> Vec<(&'static str, Vec<(String, u32)>)> {
-    let ja = ("sys-cjk-han-ja", cjk_han_japanese());
-    let zh = ("sys-cjk-han-zh", cjk_han_simplified());
-    let (first, second) = match han {
-        HanOrder::Japanese => (ja, zh),
-        HanOrder::Chinese => (zh, ja),
-    };
-    vec![
-        first,
-        second,
-        ("sys-cjk-hangul", cjk_hangul()),
-        ("sys-thai", thai()),
-        ("sys-lao", lao()),
-        ("sys-hebrew", hebrew()),
-        ("sys-symbols", symbols()),
-        ("sys-symbols-2", symbols_more()),
-    ]
-}
-
-/// Linux directories that hold CJK fonts across distributions: Debian/Ubuntu (`opentype/noto`,
-/// `truetype/wqy`), Fedora (`google-noto-cjk`), Arch (`noto-cjk`, `wenquanyi`), ChromeOS's Linux
-/// container (`chromeos/notocjk`, #1762), plus local and
-/// flat layouts. Flatpak exposes the same host layouts through read-only font mounts.
-#[cfg(not(target_arch = "wasm32"))]
-const LINUX_CJK_DIRS: [&str; 22] = [
-    // Flatpak mounts host fonts here without a broad filesystem permission. Keep the same
-    // distribution layouts as below; /usr/share/fonts inside the sandbox belongs to the runtime.
-    "/run/host/fonts/opentype/noto",
-    "/run/host/fonts/google-noto-cjk",
-    "/run/host/fonts/noto-cjk",
-    "/run/host/fonts/truetype/noto",
-    "/run/host/fonts/noto",
-    "/run/host/fonts/truetype",
-    "/run/host/fonts/TTF",
-    "/run/host/fonts",
-    "/run/host/local-fonts",
-    "/run/host/local-fonts/noto-cjk",
-    "/run/host/user-fonts",
-    "/usr/share/fonts/opentype/noto",
-    "/usr/share/fonts/google-noto-cjk",
-    "/usr/share/fonts/noto-cjk",
-    "/usr/share/fonts/truetype/noto",
-    "/usr/share/fonts/noto",
-    "/usr/share/fonts/truetype",
-    "/usr/share/fonts/TTF",
-    "/usr/share/fonts",
-    "/usr/local/share/fonts",
-    "/usr/local/share/fonts/noto-cjk",
-    "/usr/share/fonts/chromeos/notocjk",
-];
-
-/// The Windows fonts folder (`%WINDIR%\Fonts`, or the default install location).
-#[cfg(not(target_arch = "wasm32"))]
-fn windows_fonts() -> String {
-    std::env::var("WINDIR").map(|w| format!("{w}\\Fonts")).unwrap_or_else(|_| "C:\\Windows\\Fonts".into())
-}
-
-/// The Noto Sans CJK faces for one locale (`jp`, `sc`, `kr`): the per-locale OTF, then the
-/// region-merged TTC at `face`, in every Linux font directory.
-#[cfg(not(target_arch = "wasm32"))]
-fn noto_cjk(locale: &str, face: u32) -> Vec<(String, u32)> {
-    let mut v = Vec::new();
-    for d in LINUX_CJK_DIRS {
-        v.push((format!("{d}/NotoSansCJK{locale}-Regular.otf"), 0));
-        v.push((format!("{d}/NotoSansCJK-Regular.ttc"), face));
-    }
-    v
-}
-
-/// Japanese Han + Kana faces (Japanese kanji glyph shapes).
-///
-/// The region-merged `NotoSansCJK-Regular.ttc` holds one face per locale (JP 0, KR 1, SC 2, TC 3,
-/// HK 4) with the same glyph coverage, so the index only picks glyph shapes. Whichever Han list
-/// comes first loads it; [`load_fallback`] does not load the same file again for the other.
-#[cfg(not(target_arch = "wasm32"))]
-fn cjk_han_japanese() -> Vec<(String, u32)> {
-    let mac = "/System/Library/Fonts";
-    let win = windows_fonts();
-    let mut v: Vec<(String, u32)> = Vec::new();
-    v.push((format!("{win}\\YuGothR.ttc"), 0)); // Yu Gothic
-    v.push((format!("{win}\\msgothic.ttc"), 0)); // MS Gothic
-    v.push((format!("{mac}/ヒラギノ角ゴシック W3.ttc"), 0)); // Hiragino Sans
-    v.extend(noto_cjk("jp", 0));
-    v
-}
-
-/// Simplified Chinese Han faces. Loaded apart from the Japanese ones so a glyph one family lacks
-/// (simplified-only hanzi in a Japanese font) still falls through to a real glyph.
-#[cfg(not(target_arch = "wasm32"))]
-fn cjk_han_simplified() -> Vec<(String, u32)> {
-    let mac = "/System/Library/Fonts";
-    let win = windows_fonts();
-    let mut v: Vec<(String, u32)> = vec![
-        (format!("{win}\\msyh.ttc"), 0),            // Microsoft YaHei
-        (format!("{win}\\simsun.ttc"), 0),          // SimSun
-        (format!("{win}\\simhei.ttf"), 0),          // SimHei
-        (format!("{mac}/Hiragino Sans GB.ttc"), 0), // ships on every recent macOS
-        (format!("{mac}/PingFang.ttc"), 0),         // older macOS only; now a downloadable asset
-    ];
-    v.extend(noto_cjk("sc", 2));
-    for d in LINUX_CJK_DIRS {
-        v.push((format!("{d}/wqy/wqy-microhei.ttc"), 0));
-        v.push((format!("{d}/wenquanyi/wqy-microhei.ttc"), 0));
-        v.push((format!("{d}/wqy-microhei.ttc"), 0));
-    }
-    v
-}
-
-/// Hangul faces (Korean). The Han faces above that come from the region-merged Noto Sans CJK file
-/// already carry Hangul; [`load_fallback`] then skips this list rather than load the file twice.
-#[cfg(not(target_arch = "wasm32"))]
-fn cjk_hangul() -> Vec<(String, u32)> {
-    let mac = "/System/Library/Fonts";
-    let win = windows_fonts();
-    let mut v: Vec<(String, u32)> = Vec::new();
-    v.push((format!("{win}\\malgun.ttf"), 0)); // Malgun Gothic
-    v.push((format!("{mac}/AppleSDGothicNeo.ttc"), 0));
-    v.extend(noto_cjk("kr", 1));
-    v
-}
-
-/// Thai faces. Windows ships Leelawadee UI and Tahoma/Microsoft Sans Serif (both carry Thai);
-/// Linux font directories searched by the Thai and Hebrew faces, in priority order.
-#[cfg(not(target_arch = "wasm32"))]
-fn linux_noto_dirs() -> [&'static str; 5] {
-    [
-        "/usr/share/fonts/truetype/noto",
-        "/usr/share/fonts/opentype/noto",
-        "/usr/share/fonts/truetype",
-        "/usr/share/fonts",
-        "/usr/share/fonts/chromeos/noto", // ChromeOS's Linux container (#1762)
-    ]
-}
-
-/// Faces for one script: Windows files under `WINDIR\Fonts` first, then macOS paths, then the
-/// Noto/Linux files in every [`linux_noto_dirs`] directory, then the Fedora variable font.
-#[cfg(not(target_arch = "wasm32"))]
-fn script_fonts(win: &[&str], mac: &[&str], lin_files: &[&str], variable: &str) -> Vec<(String, u32)> {
-    let w = windows_fonts();
-    let mut v: Vec<(String, u32)> = win.iter().map(|f| (format!("{w}\\{f}"), 0)).collect();
-    v.extend(mac.iter().map(|p| (p.to_string(), 0)));
-    v.extend(in_dirs(&linux_noto_dirs(), lin_files).into_iter().map(|p| (p, 0)));
-    v.push((variable.into(), 0));
-    v
-}
-
-/// macOS has Thonburi; Linux usually has Noto Sans Thai or Garuda.
-#[cfg(not(target_arch = "wasm32"))]
-fn thai() -> Vec<(String, u32)> {
-    script_fonts(
-        // Leelawadee UI, Tahoma, Microsoft Sans Serif
-        &["LeelawUI.ttf", "tahoma.ttf", "micross.ttf"],
-        &["/System/Library/Fonts/Supplemental/Thonburi.ttc", "/System/Library/Fonts/SukhumvitSet.ttc"],
-        &["NotoSansThai-Regular.ttf", "tlwg/Garuda.ttf", "garuda/Garuda.ttf"],
-        // Fedora ships the variable Noto Sans Thai; its default instance is Regular.
-        "/usr/share/fonts/google-noto-vf/NotoSansThai[wght].ttf",
-    )
-}
-
-/// Lao faces. Windows ships Leelawadee UI (and DokChampa on older versions); macOS has Lao Sangam
-/// MN and Lao MN; Linux usually has Noto Sans Lao or Phetsarath OT.
-#[cfg(not(target_arch = "wasm32"))]
-fn lao() -> Vec<(String, u32)> {
-    let mac_sup = "/System/Library/Fonts/Supplemental";
-    let win = windows_fonts();
-    let lin = ["/usr/share/fonts/truetype/noto", "/usr/share/fonts/opentype/noto", "/usr/share/fonts/truetype", "/usr/share/fonts"];
-    let mut v: Vec<(String, u32)> = vec![
-        (format!("{win}\\LeelawUI.ttf"), 0), // Leelawadee UI
-        (format!("{win}\\dokchamp.ttf"), 0), // DokChampa
-        (format!("{mac_sup}/Lao Sangam MN.ttf"), 0),
-        (format!("{mac_sup}/Lao MN.ttc"), 0),
-    ];
-    for d in lin {
-        v.push((format!("{d}/NotoSansLao-Regular.ttf"), 0));
-        v.push((format!("{d}/lao/Phetsarath_OT.ttf"), 0));
-        v.push((format!("{d}/Phetsarath_OT.ttf"), 0));
-    }
-    v
-}
-
-/// Hebrew faces. Windows has David and FrankRuehl (and Tahoma/Courier New carry Hebrew); macOS has
-/// Arial Hebrew and David; Linux usually has Noto Sans Hebrew or DejaVu Sans.
-#[cfg(not(target_arch = "wasm32"))]
-fn hebrew() -> Vec<(String, u32)> {
-    script_fonts(
-        // David, FrankRuehl, Tahoma
-        &["david.ttf", "frank.ttf", "tahoma.ttf"],
-        &[
-            "/System/Library/Fonts/ArialHB.ttc",
-            "/System/Library/Fonts/SFHebrew.ttf",
-            "/System/Library/Fonts/Supplemental/Arial Hebrew.ttf",
-            "/System/Library/Fonts/Supplemental/David.ttf",
-            "/System/Library/Fonts/LucidaGrande.ttc",
-            "/System/Library/Fonts/Lucida Grande.ttc",
-        ],
-        &["NotoSansHebrew-Regular.ttf", "dejavu/DejaVuSans.ttf", "freefont/FreeSans.ttf"],
-        "/usr/share/fonts/google-noto-vf/NotoSansHebrew[wght].ttf",
-    )
-}
-
-/// Symbol faces behind the UI font. Interface fonts such as Noto Sans and Cantarell (and egui's
-/// built-in Ubuntu) lack arrows, check marks, geometric shapes and keyboard symbols (▾ ✓ ✕ ▲ ↳ ⇧),
-/// which then render as empty boxes (#197, #54). DejaVu Sans covers most of them; the paths cover
-/// Debian/Ubuntu, Fedora and Arch layouts. [`load_fallback`] skips the file if Hebrew already
-/// loaded it.
-#[cfg(not(target_arch = "wasm32"))]
-fn symbols() -> Vec<(String, u32)> {
-    let win = std::env::var("WINDIR").map(|w| format!("{w}\\Fonts")).unwrap_or_else(|_| "C:\\Windows\\Fonts".into());
-    let mut v: Vec<(String, u32)> = vec![(format!("{win}\\seguisym.ttf"), 0), ("/System/Library/Fonts/Apple Symbols.ttf".into(), 0)];
-    for d in [
-        "/usr/share/fonts/truetype/dejavu",
-        "/usr/share/fonts/dejavu-sans-fonts",
-        "/usr/share/fonts/TTF",
-        "/usr/share/fonts/dejavu",
-        "/usr/share/fonts/truetype/ttf-dejavu",
-        "/usr/local/share/fonts/dejavu",
-        "/usr/local/share/fonts",
-    ] {
-        v.push((format!("{d}/DejaVuSans.ttf"), 0));
-    }
-    v
-}
-
-/// A second symbol face for what the first lacks (⌘ and other technical symbols): Noto Sans
-/// Symbols 2 where it is installed, or Segoe UI Symbol behind Segoe UI.
-#[cfg(not(target_arch = "wasm32"))]
-fn symbols_more() -> Vec<(String, u32)> {
-    let mut v: Vec<(String, u32)> = Vec::new();
-    for d in [
-        "/usr/share/fonts/noto",
-        "/usr/share/fonts/truetype/noto",
-        "/usr/share/fonts/opentype/noto",
-        "/usr/share/fonts/google-noto-sans-symbols-2-fonts",
-        "/usr/share/fonts/google-noto",
-        "/usr/local/share/fonts/noto",
-        "/usr/share/fonts/chromeos/noto",
-    ] {
-        v.push((format!("{d}/NotoSansSymbols2-Regular.ttf"), 0));
-    }
-    v
-}
-
-/// Whether any symbol fallback face is installed (tests skip their glyph checks without one).
-pub fn symbol_face_installed() -> bool {
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        symbols().iter().chain(symbols_more().iter()).any(|(p, _)| std::path::Path::new(p).exists())
-    }
-    #[cfg(target_arch = "wasm32")]
-    {
-        false
-    }
-}
-
 /// Installs light and dark token visuals in both theme slots, keeps the 2-3 px widget and 8-10 px window/menu corner radii from 0.36, and sets spacing, text styles and the active theme.
 pub fn apply(ctx: &egui::Context, dark: bool) {
     // Install both palettes before System can switch between the style slots.
@@ -1120,54 +305,6 @@ pub fn color32(rgb: [u8; 3]) -> Color32 {
     Color32::from_rgb(rgb[0], rgb[1], rgb[2])
 }
 
-#[cfg(test)]
-mod font_binding_tests {
-    use super::*;
-
-    /// The families [`font_definitions`] always binds, whatever is installed.
-    fn always_bound() -> Vec<String> {
-        [UI, UI_BOLD, CELL, CELL_BOLD, CELL_ITALIC, CELL_BOLD_ITALIC, SERIF, MONO].iter().map(|s| s.to_string()).collect()
-    }
-
-    #[test]
-    fn a_name_that_is_not_an_installed_font_gets_a_built_in_role() {
-        let _g = crate::fonts::TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
-        // Nothing installed: every name buckets to a role that font_definitions bound.
-        crate::fonts::set_bound(always_bound());
-        for name in ["", "Calibri", "Courier New", "Times New Roman", "Grossly Missing Font", "\u{1F600}"] {
-            for (b, i) in [(false, false), (true, false), (false, true), (true, true)] {
-                let FontFamily::Name(fam) = cell_family(name, b, i) else { panic!("{name:?} should name a family") };
-                assert!(crate::fonts::is_bound(&fam), "{name:?} {b} {i} → unbound {fam:?}");
-            }
-        }
-    }
-
-    #[test]
-    fn a_bound_installed_font_is_used_by_name() {
-        let _g = crate::fonts::TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
-        let role = crate::fonts::role_key("Ubuntu", true, false);
-        crate::fonts::set_bound(always_bound().into_iter().chain([role.clone()]));
-        assert!(matches!(cell_family("Ubuntu", true, false), FontFamily::Name(f) if *f == *role));
-        // The same family in a style that wasn't bound falls back to a built-in role that is.
-        let FontFamily::Name(fallback) = cell_family("Ubuntu", false, true) else { panic!("should name a family") };
-        assert!(crate::fonts::is_bound(&fallback), "the fallback is a bound role");
-        crate::fonts::set_bound(always_bound());
-    }
-
-    #[test]
-    fn arbitrary_names_never_yield_an_unbound_family() {
-        let _g = crate::fonts::TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
-        // A workbook can hold any font name; none may name a family egui has no data for.
-        crate::fonts::set_bound(always_bound());
-        for seed in 0..500u32 {
-            let name: String =
-                (0..(seed % 40)).map(|k| char::from_u32(0x20 + (seed.wrapping_mul(31).wrapping_add(k) % 0x5F)).unwrap_or('x')).collect();
-            let FontFamily::Name(fam) = cell_family(&name, seed % 2 == 0, seed % 3 == 0) else { continue };
-            assert!(crate::fonts::is_bound(&fam), "{name:?} → unbound {fam:?}");
-        }
-    }
-}
-
 #[cfg(test)]
 mod contrast_tests {
     use super::*;
diff --git a/crates/ui-egui/src/theme/font_fallback.rs b/crates/ui-egui/src/theme/font_fallback.rs
new file mode 100644
index 000000000..940a871d5
--- /dev/null
+++ b/crates/ui-egui/src/theme/font_fallback.rs
@@ -0,0 +1,296 @@
+use super::font_setup::HanOrder;
+#[cfg(not(target_arch = "wasm32"))]
+use super::font_setup::{in_dirs, try_load};
+use super::*;
+
+/// Loads the system non-Latin fallback faces (one file per script family) and returns their keys so
+/// every family can carry them as fallback. egui's bundled fonts have no coverage beyond Latin, so
+/// without this a Thai, Hebrew, Japanese or Chinese workbook shows tofu boxes even though the text
+/// was read correctly. With a face installed those scripts get real glyphs instead of tofu; nothing
+/// is bundled, and a machine without the face keeps the old behaviour.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn load_fallback(fonts: &mut FontDefinitions, han: HanOrder) -> Vec<String> {
+    let mut keys = Vec::new();
+    // Files already loaded as a fallback face. A file serves at most one key: the region-merged
+    // Noto Sans CJK .ttc found for Han also carries Hangul (and Tahoma carries both Thai and
+    // Hebrew), so loading it again for a later script would only duplicate tens of MB in memory.
+    let mut loaded: Vec<String> = Vec::new();
+    for (key, cands) in fallback_faces(han) {
+        for (path, index) in &cands {
+            if loaded.contains(path) {
+                break; // a face loaded for an earlier script already covers this one
+            }
+            if let Some(fd) = try_load(&[(path.as_str(), *index)]) {
+                fonts.font_data.insert(key.to_string(), Arc::new(fd));
+                keys.push(key.to_string());
+                loaded.push(path.clone());
+                break;
+            }
+        }
+    }
+    keys
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(super) fn load_fallback(_fonts: &mut FontDefinitions, _han: HanOrder) -> Vec<String> {
+    Vec::new()
+}
+
+/// Every fallback face we look for, in chain order: `(key, candidate files)`. One file per script
+/// family is enough — epaint picks the first face with the glyph, and a script's glyphs live in one
+/// file. Order only matters between faces that both cover a glyph (Japanese vs Chinese kanji), so
+/// the interface language reorders the two Han entries and nothing else.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn fallback_faces(han: HanOrder) -> Vec<(&'static str, Vec<(String, u32)>)> {
+    let ja = ("sys-cjk-han-ja", cjk_han_japanese());
+    let zh = ("sys-cjk-han-zh", cjk_han_simplified());
+    let (first, second) = match han {
+        HanOrder::Japanese => (ja, zh),
+        HanOrder::Chinese => (zh, ja),
+    };
+    vec![
+        first,
+        second,
+        ("sys-cjk-hangul", cjk_hangul()),
+        ("sys-thai", thai()),
+        ("sys-lao", lao()),
+        ("sys-hebrew", hebrew()),
+        ("sys-symbols", symbols()),
+        ("sys-symbols-2", symbols_more()),
+    ]
+}
+
+/// Linux directories that hold CJK fonts across distributions: Debian/Ubuntu (`opentype/noto`,
+/// `truetype/wqy`), Fedora (`google-noto-cjk`), Arch (`noto-cjk`, `wenquanyi`), ChromeOS's Linux
+/// container (`chromeos/notocjk`, #1762), plus local and
+/// flat layouts. Flatpak exposes the same host layouts through read-only font mounts.
+#[cfg(not(target_arch = "wasm32"))]
+const LINUX_CJK_DIRS: [&str; 22] = [
+    // Flatpak mounts host fonts here without a broad filesystem permission. Keep the same
+    // distribution layouts as below; /usr/share/fonts inside the sandbox belongs to the runtime.
+    "/run/host/fonts/opentype/noto",
+    "/run/host/fonts/google-noto-cjk",
+    "/run/host/fonts/noto-cjk",
+    "/run/host/fonts/truetype/noto",
+    "/run/host/fonts/noto",
+    "/run/host/fonts/truetype",
+    "/run/host/fonts/TTF",
+    "/run/host/fonts",
+    "/run/host/local-fonts",
+    "/run/host/local-fonts/noto-cjk",
+    "/run/host/user-fonts",
+    "/usr/share/fonts/opentype/noto",
+    "/usr/share/fonts/google-noto-cjk",
+    "/usr/share/fonts/noto-cjk",
+    "/usr/share/fonts/truetype/noto",
+    "/usr/share/fonts/noto",
+    "/usr/share/fonts/truetype",
+    "/usr/share/fonts/TTF",
+    "/usr/share/fonts",
+    "/usr/local/share/fonts",
+    "/usr/local/share/fonts/noto-cjk",
+    "/usr/share/fonts/chromeos/notocjk",
+];
+
+/// The Windows fonts folder (`%WINDIR%\Fonts`, or the default install location).
+#[cfg(not(target_arch = "wasm32"))]
+fn windows_fonts() -> String {
+    std::env::var("WINDIR").map(|w| format!("{w}\\Fonts")).unwrap_or_else(|_| "C:\\Windows\\Fonts".into())
+}
+
+/// The Noto Sans CJK faces for one locale (`jp`, `sc`, `kr`): the per-locale OTF, then the
+/// region-merged TTC at `face`, in every Linux font directory.
+#[cfg(not(target_arch = "wasm32"))]
+fn noto_cjk(locale: &str, face: u32) -> Vec<(String, u32)> {
+    let mut v = Vec::new();
+    for d in LINUX_CJK_DIRS {
+        v.push((format!("{d}/NotoSansCJK{locale}-Regular.otf"), 0));
+        v.push((format!("{d}/NotoSansCJK-Regular.ttc"), face));
+    }
+    v
+}
+
+/// Japanese Han + Kana faces (Japanese kanji glyph shapes).
+///
+/// The region-merged `NotoSansCJK-Regular.ttc` holds one face per locale (JP 0, KR 1, SC 2, TC 3,
+/// HK 4) with the same glyph coverage, so the index only picks glyph shapes. Whichever Han list
+/// comes first loads it; [`load_fallback`] does not load the same file again for the other.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn cjk_han_japanese() -> Vec<(String, u32)> {
+    let mac = "/System/Library/Fonts";
+    let win = windows_fonts();
+    let mut v: Vec<(String, u32)> = Vec::new();
+    v.push((format!("{win}\\YuGothR.ttc"), 0)); // Yu Gothic
+    v.push((format!("{win}\\msgothic.ttc"), 0)); // MS Gothic
+    v.push((format!("{mac}/ヒラギノ角ゴシック W3.ttc"), 0)); // Hiragino Sans
+    v.extend(noto_cjk("jp", 0));
+    v
+}
+
+/// Simplified Chinese Han faces. Loaded apart from the Japanese ones so a glyph one family lacks
+/// (simplified-only hanzi in a Japanese font) still falls through to a real glyph.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn cjk_han_simplified() -> Vec<(String, u32)> {
+    let mac = "/System/Library/Fonts";
+    let win = windows_fonts();
+    let mut v: Vec<(String, u32)> = vec![
+        (format!("{win}\\msyh.ttc"), 0),            // Microsoft YaHei
+        (format!("{win}\\simsun.ttc"), 0),          // SimSun
+        (format!("{win}\\simhei.ttf"), 0),          // SimHei
+        (format!("{mac}/Hiragino Sans GB.ttc"), 0), // ships on every recent macOS
+        (format!("{mac}/PingFang.ttc"), 0),         // older macOS only; now a downloadable asset
+    ];
+    v.extend(noto_cjk("sc", 2));
+    for d in LINUX_CJK_DIRS {
+        v.push((format!("{d}/wqy/wqy-microhei.ttc"), 0));
+        v.push((format!("{d}/wenquanyi/wqy-microhei.ttc"), 0));
+        v.push((format!("{d}/wqy-microhei.ttc"), 0));
+    }
+    v
+}
+
+/// Hangul faces (Korean). The Han faces above that come from the region-merged Noto Sans CJK file
+/// already carry Hangul; [`load_fallback`] then skips this list rather than load the file twice.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn cjk_hangul() -> Vec<(String, u32)> {
+    let mac = "/System/Library/Fonts";
+    let win = windows_fonts();
+    let mut v: Vec<(String, u32)> = Vec::new();
+    v.push((format!("{win}\\malgun.ttf"), 0)); // Malgun Gothic
+    v.push((format!("{mac}/AppleSDGothicNeo.ttc"), 0));
+    v.extend(noto_cjk("kr", 1));
+    v
+}
+
+/// Thai faces. Windows ships Leelawadee UI and Tahoma/Microsoft Sans Serif (both carry Thai);
+/// Linux font directories searched by the Thai and Hebrew faces, in priority order.
+#[cfg(not(target_arch = "wasm32"))]
+fn linux_noto_dirs() -> [&'static str; 5] {
+    [
+        "/usr/share/fonts/truetype/noto",
+        "/usr/share/fonts/opentype/noto",
+        "/usr/share/fonts/truetype",
+        "/usr/share/fonts",
+        "/usr/share/fonts/chromeos/noto", // ChromeOS's Linux container (#1762)
+    ]
+}
+
+/// Faces for one script: Windows files under `WINDIR\Fonts` first, then macOS paths, then the
+/// Noto/Linux files in every [`linux_noto_dirs`] directory, then the Fedora variable font.
+#[cfg(not(target_arch = "wasm32"))]
+fn script_fonts(win: &[&str], mac: &[&str], lin_files: &[&str], variable: &str) -> Vec<(String, u32)> {
+    let w = windows_fonts();
+    let mut v: Vec<(String, u32)> = win.iter().map(|f| (format!("{w}\\{f}"), 0)).collect();
+    v.extend(mac.iter().map(|p| (p.to_string(), 0)));
+    v.extend(in_dirs(&linux_noto_dirs(), lin_files).into_iter().map(|p| (p, 0)));
+    v.push((variable.into(), 0));
+    v
+}
+
+/// macOS has Thonburi; Linux usually has Noto Sans Thai or Garuda.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn thai() -> Vec<(String, u32)> {
+    script_fonts(
+        // Leelawadee UI, Tahoma, Microsoft Sans Serif
+        &["LeelawUI.ttf", "tahoma.ttf", "micross.ttf"],
+        &["/System/Library/Fonts/Supplemental/Thonburi.ttc", "/System/Library/Fonts/SukhumvitSet.ttc"],
+        &["NotoSansThai-Regular.ttf", "tlwg/Garuda.ttf", "garuda/Garuda.ttf"],
+        // Fedora ships the variable Noto Sans Thai; its default instance is Regular.
+        "/usr/share/fonts/google-noto-vf/NotoSansThai[wght].ttf",
+    )
+}
+
+/// Lao faces. Windows ships Leelawadee UI (and DokChampa on older versions); macOS has Lao Sangam
+/// MN and Lao MN; Linux usually has Noto Sans Lao or Phetsarath OT.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn lao() -> Vec<(String, u32)> {
+    let mac_sup = "/System/Library/Fonts/Supplemental";
+    let win = windows_fonts();
+    let lin = ["/usr/share/fonts/truetype/noto", "/usr/share/fonts/opentype/noto", "/usr/share/fonts/truetype", "/usr/share/fonts"];
+    let mut v: Vec<(String, u32)> = vec![
+        (format!("{win}\\LeelawUI.ttf"), 0), // Leelawadee UI
+        (format!("{win}\\dokchamp.ttf"), 0), // DokChampa
+        (format!("{mac_sup}/Lao Sangam MN.ttf"), 0),
+        (format!("{mac_sup}/Lao MN.ttc"), 0),
+    ];
+    for d in lin {
+        v.push((format!("{d}/NotoSansLao-Regular.ttf"), 0));
+        v.push((format!("{d}/lao/Phetsarath_OT.ttf"), 0));
+        v.push((format!("{d}/Phetsarath_OT.ttf"), 0));
+    }
+    v
+}
+
+/// Hebrew faces. Windows has David and FrankRuehl (and Tahoma/Courier New carry Hebrew); macOS has
+/// Arial Hebrew and David; Linux usually has Noto Sans Hebrew or DejaVu Sans.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn hebrew() -> Vec<(String, u32)> {
+    script_fonts(
+        // David, FrankRuehl, Tahoma
+        &["david.ttf", "frank.ttf", "tahoma.ttf"],
+        &[
+            "/System/Library/Fonts/ArialHB.ttc",
+            "/System/Library/Fonts/SFHebrew.ttf",
+            "/System/Library/Fonts/Supplemental/Arial Hebrew.ttf",
+            "/System/Library/Fonts/Supplemental/David.ttf",
+            "/System/Library/Fonts/LucidaGrande.ttc",
+            "/System/Library/Fonts/Lucida Grande.ttc",
+        ],
+        &["NotoSansHebrew-Regular.ttf", "dejavu/DejaVuSans.ttf", "freefont/FreeSans.ttf"],
+        "/usr/share/fonts/google-noto-vf/NotoSansHebrew[wght].ttf",
+    )
+}
+
+/// Symbol faces behind the UI font. Interface fonts such as Noto Sans and Cantarell (and egui's
+/// built-in Ubuntu) lack arrows, check marks, geometric shapes and keyboard symbols (▾ ✓ ✕ ▲ ↳ ⇧),
+/// which then render as empty boxes (#197, #54). DejaVu Sans covers most of them; the paths cover
+/// Debian/Ubuntu, Fedora and Arch layouts. [`load_fallback`] skips the file if Hebrew already
+/// loaded it.
+#[cfg(not(target_arch = "wasm32"))]
+fn symbols() -> Vec<(String, u32)> {
+    let win = std::env::var("WINDIR").map(|w| format!("{w}\\Fonts")).unwrap_or_else(|_| "C:\\Windows\\Fonts".into());
+    let mut v: Vec<(String, u32)> = vec![(format!("{win}\\seguisym.ttf"), 0), ("/System/Library/Fonts/Apple Symbols.ttf".into(), 0)];
+    for d in [
+        "/usr/share/fonts/truetype/dejavu",
+        "/usr/share/fonts/dejavu-sans-fonts",
+        "/usr/share/fonts/TTF",
+        "/usr/share/fonts/dejavu",
+        "/usr/share/fonts/truetype/ttf-dejavu",
+        "/usr/local/share/fonts/dejavu",
+        "/usr/local/share/fonts",
+    ] {
+        v.push((format!("{d}/DejaVuSans.ttf"), 0));
+    }
+    v
+}
+
+/// A second symbol face for what the first lacks (⌘ and other technical symbols): Noto Sans
+/// Symbols 2 where it is installed, or Segoe UI Symbol behind Segoe UI.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn symbols_more() -> Vec<(String, u32)> {
+    let mut v: Vec<(String, u32)> = Vec::new();
+    for d in [
+        "/usr/share/fonts/noto",
+        "/usr/share/fonts/truetype/noto",
+        "/usr/share/fonts/opentype/noto",
+        "/usr/share/fonts/google-noto-sans-symbols-2-fonts",
+        "/usr/share/fonts/google-noto",
+        "/usr/local/share/fonts/noto",
+        "/usr/share/fonts/chromeos/noto",
+    ] {
+        v.push((format!("{d}/NotoSansSymbols2-Regular.ttf"), 0));
+    }
+    v
+}
+
+/// Whether any symbol fallback face is installed (tests skip their glyph checks without one).
+pub fn symbol_face_installed() -> bool {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        symbols().iter().chain(symbols_more().iter()).any(|(p, _)| std::path::Path::new(p).exists())
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        false
+    }
+}
diff --git a/crates/ui-egui/src/theme/font_setup.rs b/crates/ui-egui/src/theme/font_setup.rs
new file mode 100644
index 000000000..749079e71
--- /dev/null
+++ b/crates/ui-egui/src/theme/font_setup.rs
@@ -0,0 +1,598 @@
+use super::font_fallback::load_fallback;
+use super::*;
+
+/// A font from the optional craft-fonts build input (`CRAFT_FONTS_DIR` at build time; see
+/// <https://github.com/storytold/craft-fonts> and its `docs/integration.md`). The slice is empty
+/// when the app is built without the checkout; nothing is downloaded and no font is in this repo.
+#[derive(Debug)]
+pub struct CraftFont {
+    pub family: &'static str,
+    pub style: &'static str,
+    /// ISO 15924 scripts the family is intended for, from the craft-fonts manifest.
+    pub scripts: &'static [&'static str],
+    pub bytes: &'static [u8],
+}
+
+mod craft_fonts {
+    use super::CraftFont;
+    include!(concat!(env!("OUT_DIR"), "/craft_fonts.rs"));
+}
+
+/// The light or dark value of a colour, by mode.
+pub(super) fn pick<T>(dark: bool, light: T, dark_value: T) -> T {
+    if dark { dark_value } else { light }
+}
+
+pub const UI: &str = "ui";
+
+pub const UI_BOLD: &str = "ui-bold";
+
+pub const CELL: &str = "cell";
+
+pub const CELL_BOLD: &str = "cell-bold";
+
+pub const CELL_ITALIC: &str = "cell-italic";
+
+pub const CELL_BOLD_ITALIC: &str = "cell-bold-italic";
+
+pub const SERIF: &str = "serif";
+
+pub const MONO: &str = "mono";
+
+pub fn ui_font(size: f32) -> FontId {
+    FontId::new(size, FontFamily::Name(UI.into()))
+}
+
+pub fn ui_bold(size: f32) -> FontId {
+    FontId::new(size, FontFamily::Name(UI_BOLD.into()))
+}
+
+/// The font family to use for a cell font name and weight.
+///
+/// When the name is an installed font whose faces were bound by [`font_definitions`], that family
+/// is used; otherwise the name is bucketed to one of the built-in roles (mono/serif/cell). egui
+/// panics on a family that was never bound, so the installed branch is gated on
+/// [`crate::fonts::is_bound`] and never names a family egui hasn't been given.
+pub fn cell_family(name: &str, bold: bool, italic: bool) -> FontFamily {
+    let role = crate::fonts::role_key(name, bold, italic);
+    if crate::fonts::is_bound(&role) {
+        return FontFamily::Name(role.into());
+    }
+    let lower = name.to_ascii_lowercase();
+    if lower.contains("courier") || lower.contains("mono") || lower.contains("consolas") {
+        return FontFamily::Name(MONO.into());
+    }
+    if lower.contains("times")
+        || lower.contains("georgia")
+        || lower.contains("cambria")
+        || lower.contains("serif") && !lower.contains("sans")
+        || lower.contains("garamond")
+    {
+        return FontFamily::Name(SERIF.into());
+    }
+    FontFamily::Name(
+        match (bold, italic) {
+            (true, true) => CELL_BOLD_ITALIC,
+            (true, false) => CELL_BOLD,
+            (false, true) => CELL_ITALIC,
+            (false, false) => CELL,
+        }
+        .into(),
+    )
+}
+
+/// Width in points, at 100% zoom, of one line of cell text drawn as the grid draws it: in the
+/// face [`cell_family`] picks, which on a machine without the named font is a wider or narrower
+/// substitute (#1316). A family the active font set doesn't have yet (bound fonts apply from the
+/// next frame) falls back to the engine's estimate rather than letting egui panic on it.
+///
+/// `exact` lays the text out (a galley kept until the end of the frame); otherwise the glyph
+/// advances are summed without kerning, which is cheap and never narrower. This takes the
+/// Context lock (`fonts_mut`): never call it, or run a command, while an egui lock is held.
+pub fn cell_text_width(ctx: &egui::Context, text: &str, font: &gridcraft_engine::model::Font, exact: bool) -> f32 {
+    let family = cell_family(&font.name, font.bold, font.italic);
+    let id = FontId::new(font.size * 96.0 / 72.0, family);
+    ctx.fonts_mut(|f| {
+        f.families().contains(&id.family).then(|| {
+            if exact {
+                f.layout_no_wrap(text.to_owned(), id, Color32::PLACEHOLDER).size().x
+            } else {
+                // Half a point covers the galley's rounding of its width up to the pixel grid.
+                text.chars().map(|c| f.glyph_width(&id, c)).sum::<f32>() + 0.5
+            }
+        })
+    })
+    .unwrap_or_else(|| gridcraft_engine::cmd::format::approx_text_width(text, font.size, font.bold))
+}
+
+/// Whether epaint can open face `index` of this font file and it maps characters to glyphs.
+/// epaint panics (in `Context::set_fonts`, i.e. on startup) on a face it can't open, so every font
+/// file we did not ship is checked first with the same parser and the same call epaint makes
+/// (`skrifa::FontRef::from_index`): a corrupt file, something that is not an sfnt at all, or a
+/// collection index past the end is rejected instead of crashing the app (#226). A face whose
+/// character map is unreadable (a truncated file) would open but draw nothing, so it is refused
+/// too and the next candidate gets its turn.
+pub(crate) fn font_parses(bytes: &[u8], index: u32) -> bool {
+    use skrifa::MetadataProvider;
+    skrifa::FontRef::from_index(bytes, index).is_ok_and(|font| font.charmap().has_map())
+}
+
+/// Loads the first candidate that exists and parses. A file that exists but can't be parsed is
+/// skipped with a warning and the next candidate is tried.
+#[cfg(not(target_arch = "wasm32"))]
+pub(super) fn try_load(paths: &[(&str, u32)]) -> Option<FontData> {
+    for (p, index) in paths {
+        if let Some(blob) = font_file(p, *index) {
+            return Some(FontData::from_blob(blob, *index));
+        }
+    }
+    None
+}
+
+/// The interface and script fallback font files, each read once per run and kept as a shared
+/// `Blob` for the rest of it. egui shares the blob instead of copying the file into its text
+/// engine, because every one of these files is loaded by every font rebuild for as long as the
+/// app runs. Only a file that parses is kept: a missing or broken one is looked for again next
+/// time.
+#[cfg(not(target_arch = "wasm32"))]
+fn font_file(path: &str, index: u32) -> Option<Blob> {
+    static FILES: std::sync::Mutex<std::collections::BTreeMap<String, Blob>> = std::sync::Mutex::new(std::collections::BTreeMap::new());
+    let mut files = FILES.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    if let Some(blob) = files.get(path) {
+        let bytes: &[u8] = (**blob).as_ref();
+        return font_parses(bytes, index).then(|| std::sync::Arc::clone(blob));
+    }
+    let bytes = std::fs::read(path).ok()?;
+    if !font_parses(&bytes, index) {
+        log::warn!("skipping font {path} (face {index}): not a font file egui can read");
+        return None;
+    }
+    let blob: Blob = std::sync::Arc::new(bytes);
+    files.insert(path.to_string(), blob.clone());
+    Some(blob)
+}
+
+/// Last line of defence before [`FontDefinitions`] reach egui: drops every face epaint could not
+/// parse (and its key from every family), so a bad font costs a fallback, never a crash.
+pub(crate) fn drop_unparseable_fonts(fonts: &mut FontDefinitions) {
+    let bad: Vec<String> = fonts.font_data.iter().filter(|(_, fd)| !font_parses(fd.bytes(), fd.index)).map(|(k, _)| k.clone()).collect();
+    for key in &bad {
+        log::warn!("dropping font {key:?}: egui can't parse it");
+        fonts.font_data.remove(key);
+    }
+    if !bad.is_empty() {
+        for chain in fonts.families.values_mut() {
+            chain.retain(|k| !bad.contains(k));
+        }
+    }
+}
+
+/// egui's bundled monospace face, used as the last-resort symbol fallback (see `Hack-Regular.ttf`
+/// in `epaint_default_fonts`). It is present whenever egui is built with `default_fonts`.
+const HACK: &str = "Hack";
+
+/// The permitted craft-fonts faces with their `FontDefinitions` keys, in manifest order. Empty
+/// without a `CRAFT_FONTS_DIR` checkout at build time. The filter is repeated here so a stale
+/// generated table can never smuggle in a barred face or a web-build face outside the allowlist.
+pub(super) fn craft_font_faces() -> Vec<(String, &'static CraftFont)> {
+    let wasm = cfg!(target_arch = "wasm32");
+    craft_fonts::CRAFT_FONTS
+        .iter()
+        .enumerate()
+        .filter(|(_, font)| !crate::craft_fonts_policy::barred(font.family))
+        .filter(|(_, font)| !wasm || crate::craft_fonts_policy::web_allowed(font.family, font.style))
+        .map(|(i, font)| (format!("craft-{i}-{}-{}", font.family, font.style), font))
+        .collect()
+}
+
+/// Adds the optional craft-fonts faces to `fonts` and returns their keys.
+fn add_craft_fonts(fonts: &mut FontDefinitions) -> Vec<String> {
+    let mut keys = Vec::new();
+    for (key, font) in craft_font_faces() {
+        fonts.font_data.insert(key.clone(), Arc::new(FontData::from_static(font.bytes)));
+        keys.push(key);
+    }
+    keys
+}
+
+/// Whether the optional craft-fonts input was embedded in this build.
+pub fn craft_fonts_loaded() -> bool {
+    !craft_fonts::CRAFT_FONTS.is_empty()
+}
+
+/// Whether the native-only Simplified Chinese craft face (LXGW WenKai Lite) was embedded. A web
+/// build or an older craft-fonts checkout without `fonts/simplified-chinese-manifest.txt` has none.
+pub fn chinese_font_loaded() -> bool {
+    craft_font_faces().iter().any(|(_, f)| f.family == "LXGW WenKai Lite" && f.style == "Regular")
+}
+
+/// Whether this build was made with `CRAFT_FONTS_REQUIRED=1`. Acceptance tests must fail rather
+/// than skip when this is true and the faces are absent.
+pub fn craft_fonts_required() -> bool {
+    craft_fonts::CRAFT_FONTS_REQUIRED
+}
+
+/// A bundled-face character with the same meaning as `c`, for interface chrome whose exact symbol
+/// no bundled face has (`✕`, `✓`, `⌃`). Document text still needs a real glyph; this is only a
+/// display fallback and never changes the characters a command inserts or stores.
+pub fn symbol_fallback(c: char) -> Option<char> {
+    match c {
+        '✕' => Some('×'),
+        '✓' => Some('✔'),
+        '⌃' => Some('^'),
+        _ => None,
+    }
+}
+
+/// `text` with every character the current font set cannot draw replaced by its semantic fallback
+/// (see [`symbol_fallback`]). Used by chrome tooltips so a host without symbol faces never paints
+/// a tofu box; it is not applied to workbook text.
+pub fn available_text(ui: &egui::Ui, text: &str) -> String {
+    let font = ui_font(13.0);
+    text.chars().map(|c| if ui.ctx().fonts_mut(|f| f.has_glyph(&font, c)) { c } else { symbol_fallback(c).unwrap_or(c) }).collect()
+}
+
+/// The family, style and scripts of every embedded craft-fonts face (empty without the input).
+pub fn craft_font_scripts() -> impl Iterator<Item = (&'static str, &'static str, &'static [&'static str])> {
+    craft_font_faces().into_iter().map(|(_, f)| (f.family, f.style, f.scripts))
+}
+
+/// Whether one embedded craft-fonts face maps every non-whitespace character in `text`. Tests use
+/// this to tell "the pinned fixture covers this script" from "this host has no face for it",
+/// without trusting a manifest script tag alone.
+pub fn craft_fonts_cover(text: &str) -> bool {
+    craft_font_faces().iter().any(|(_, f)| {
+        use skrifa::MetadataProvider;
+        let Ok(font) = skrifa::FontRef::from_index(f.bytes, 0) else {
+            return false;
+        };
+        let map = font.charmap();
+        text.chars().filter(|c| !c.is_whitespace()).all(|c| map.map(c).is_some())
+    })
+}
+
+#[cfg(target_arch = "wasm32")]
+pub(super) fn try_load(_paths: &[(&str, u32)]) -> Option<FontData> {
+    None
+}
+
+fn home_fonts(file: &str) -> String {
+    let home = std::env::var("HOME").unwrap_or_default();
+    format!("{home}/Library/Fonts/{file}")
+}
+
+/// Every file in `files` under every directory in `dirs`, directory first, in the same order a
+/// nested loop over the directories would add them.
+pub(super) fn in_dirs(dirs: &[&str], files: &[&str]) -> Vec<String> {
+    dirs.iter().flat_map(|d| files.iter().map(move |f| format!("{d}/{f}"))).collect()
+}
+
+/// Candidate font files per role, in preference order.
+pub(super) fn candidates(role: &str) -> Vec<(String, u32)> {
+    let mac_sys = "/System/Library/Fonts";
+    let mac_sup = "/System/Library/Fonts/Supplemental";
+    let win = std::env::var("WINDIR").map(|w| format!("{w}\\Fonts")).unwrap_or_else(|_| "C:\\Windows\\Fonts".into());
+    // ChromeOS's Linux container (Crostini) mounts the host's fonts under `chromeos/` (#1762).
+    let lin = ["/usr/share/fonts/truetype", "/usr/share/fonts", "/usr/local/share/fonts", "/usr/share/fonts/TTF", "/usr/share/fonts/chromeos"];
+    let mut v: Vec<(String, u32)> = Vec::new();
+    let mut add = |s: String, i: u32| v.push((s, i));
+    match role {
+        "ui" => {
+            add(format!("{mac_sys}/SFNS.ttf"), 0);
+            add(format!("{mac_sys}/HelveticaNeue.ttc"), 0);
+            add(format!("{win}\\segoeui.ttf"), 0);
+            for p in in_dirs(
+                &lin,
+                &["cantarell/Cantarell-Regular.otf", "noto/NotoSans-Regular.ttf", "dejavu/DejaVuSans.ttf", "liberation/LiberationSans-Regular.ttf"],
+            ) {
+                add(p, 0);
+            }
+            // Fedora keeps each family in its own package folder (#54).
+            add("/usr/share/fonts/abattis-cantarell-fonts/Cantarell-Regular.otf".into(), 0);
+            add("/usr/share/fonts/google-noto/NotoSans-Regular.ttf".into(), 0);
+            add("/usr/share/fonts/dejavu-sans-fonts/DejaVuSans.ttf".into(), 0);
+            add("/usr/share/fonts/liberation-sans-fonts/LiberationSans-Regular.ttf".into(), 0);
+        }
+        "ui-bold" => {
+            add(format!("{mac_sys}/HelveticaNeue.ttc"), 1);
+            add(format!("{win}\\segoeuib.ttf"), 0);
+            for p in in_dirs(&lin, &["noto/NotoSans-Bold.ttf", "dejavu/DejaVuSans-Bold.ttf", "liberation/LiberationSans-Bold.ttf"]) {
+                add(p, 0);
+            }
+            add("/usr/share/fonts/google-noto/NotoSans-Bold.ttf".into(), 0);
+            add("/usr/share/fonts/dejavu-sans-fonts/DejaVuSans-Bold.ttf".into(), 0);
+            add("/usr/share/fonts/liberation-sans-fonts/LiberationSans-Bold.ttf".into(), 0);
+        }
+        "cell" | "cell-bold" | "cell-italic" | "cell-bold-italic" => {
+            let (carlito, calibri_win, calibri_mac, arial_mac, arial_win, lib, dejavu) = match role {
+                "cell" => {
+                    ("Carlito-Regular.ttf", "calibri.ttf", "Calibri.ttf", "Arial.ttf", "arial.ttf", "LiberationSans-Regular.ttf", "DejaVuSans.ttf")
+                }
+                "cell-bold" => (
+                    "Carlito-Bold.ttf",
+                    "calibrib.ttf",
+                    "Calibri Bold.ttf",
+                    "Arial Bold.ttf",
+                    "arialbd.ttf",
+                    "LiberationSans-Bold.ttf",
+                    "DejaVuSans-Bold.ttf",
+                ),
+                "cell-italic" => (
+                    "Carlito-Italic.ttf",
+                    "calibrii.ttf",
+                    "Calibri Italic.ttf",
+                    "Arial Italic.ttf",
+                    "ariali.ttf",
+                    "LiberationSans-Italic.ttf",
+                    "DejaVuSans-Oblique.ttf",
+                ),
+                _ => (
+                    "Carlito-BoldItalic.ttf",
+                    "calibriz.ttf",
+                    "Calibri Bold Italic.ttf",
+                    "Arial Bold Italic.ttf",
+                    "arialbi.ttf",
+                    "LiberationSans-BoldItalic.ttf",
+                    "DejaVuSans-BoldOblique.ttf",
+                ),
+            };
+            // Calibri if the user has it installed system-wide (never from an Office bundle).
+            add(format!("/Library/Fonts/{calibri_mac}"), 0);
+            add(home_fonts(calibri_mac), 0);
+            add(format!("{win}\\{calibri_win}"), 0);
+            for p in in_dirs(&lin, &[&format!("crosextra/{carlito}"), &format!("carlito/{carlito}")]) {
+                add(p, 0);
+            }
+            // Fedora keeps each family in its own package folder, as for the UI fonts (#54).
+            add(format!("/usr/share/fonts/google-carlito-fonts/{carlito}"), 0);
+            add(home_fonts(carlito), 0);
+            add(format!("{mac_sup}/{arial_mac}"), 0);
+            add(format!("{win}\\{arial_win}"), 0);
+            for p in in_dirs(&lin, &[&format!("liberation/{lib}"), &format!("dejavu/{dejavu}")]) {
+                add(p, 0);
+            }
+            add(format!("/usr/share/fonts/liberation-sans-fonts/{lib}"), 0);
+            add(format!("/usr/share/fonts/dejavu-sans-fonts/{dejavu}"), 0);
+        }
+        "serif" => {
+            add(format!("{mac_sup}/Times New Roman.ttf"), 0);
+            add(format!("{win}\\times.ttf"), 0);
+            for p in in_dirs(&lin, &["liberation/LiberationSerif-Regular.ttf", "dejavu/DejaVuSerif.ttf"]) {
+                add(p, 0);
+            }
+            add("/usr/share/fonts/liberation-serif-fonts/LiberationSerif-Regular.ttf".into(), 0);
+            add("/usr/share/fonts/dejavu-serif-fonts/DejaVuSerif.ttf".into(), 0);
+        }
+        "mono" => {
+            add(format!("{mac_sys}/SFNSMono.ttf"), 0);
+            add(format!("{mac_sys}/Menlo.ttc"), 0);
+            add(format!("{win}\\consola.ttf"), 0);
+            for p in in_dirs(&lin, &["dejavu/DejaVuSansMono.ttf"]) {
+                add(p, 0);
+            }
+            add("/usr/share/fonts/dejavu-sans-mono-fonts/DejaVuSansMono.ttf".into(), 0);
+            // Fedora installs DejaVu Sans Mono only on request. Liberation Mono comes with LibreOffice
+            // (in Workstation and KDE by default), Noto Sans Mono (variable, Regular by default) always.
+            for p in in_dirs(&lin, &["liberation/LiberationMono-Regular.ttf"]) {
+                add(p, 0);
+            }
+            add("/usr/share/fonts/liberation-mono-fonts/LiberationMono-Regular.ttf".into(), 0);
+            add("/usr/share/fonts/google-noto-vf/NotoSansMono[wght].ttf".into(), 0);
+        }
+        _ => {}
+    }
+    v
+}
+
+/// Builds the font set from system fonts (with egui's defaults as fallback), with the default
+/// (non-Japanese) Han order. Never reads the host locale, so tests and snapshots are stable.
+pub fn font_definitions() -> FontDefinitions {
+    font_definitions_for_language(crate::i18n::Language::En)
+}
+
+/// Which Han face leads the fallback chain. Both Han faces cover kana and most kanji, so this only
+/// decides glyph shapes (and which face catches a glyph the other lacks); switching between two
+/// languages with the same order needs no font rebuild.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HanOrder {
+    /// Japanese glyph shapes first (the interface is Japanese).
+    Japanese,
+    /// Simplified Chinese first: the widest Han coverage, for every other interface language.
+    Chinese,
+}
+
+impl HanOrder {
+    pub fn of(language: crate::i18n::Language) -> Self {
+        if language == crate::i18n::Language::Ja { Self::Japanese } else { Self::Chinese }
+    }
+}
+
+/// Builds the font set with the Han fallback faces ordered for the interface language.
+pub fn font_definitions_for_language(language: crate::i18n::Language) -> FontDefinitions {
+    font_definitions_with(language, &[])
+}
+
+/// The bundled faces plus the pinned craft-fonts faces, with no system-font probing or installed
+/// workbook-font binding.
+///
+/// Integration tests use this through their shared harness, so a minimal CI image and a developer
+/// machine see the same font set. Craft-fonts remains a pinned build input rather than a repository
+/// asset; without it only egui's bundled faces are available, which is the documented no-font mode.
+pub fn pinned_font_definitions() -> FontDefinitions {
+    font_definitions_impl(crate::i18n::Language::En, &[], false)
+}
+
+/// [`font_definitions_for_language`] that also binds the workbook fonts in `used` that are
+/// installed, so cells set in them render with them; the rest fall back to the roles. The bound
+/// families are recorded in [`crate::fonts`] so [`cell_family`] only names a family egui has.
+pub fn font_definitions_with(language: crate::i18n::Language, used: &[String]) -> FontDefinitions {
+    font_definitions_impl(language, used, true)
+}
+
+/// Builds the role font chains, script fallbacks, installed workbook fonts and optional craft-font faces, drops unparseable data and records which families were bound.
+fn font_definitions_impl(language: crate::i18n::Language, used: &[String], system: bool) -> FontDefinitions {
+    let mut fonts = FontDefinitions::default();
+    let base_prop: Vec<String> = fonts.families.get(&FontFamily::Proportional).cloned().unwrap_or_default();
+    let base_mono: Vec<String> = fonts.families.get(&FontFamily::Monospace).cloned().unwrap_or_default();
+    let mut bound: Vec<String> = Vec::new();
+    // The non-Latin fallback faces have to sit at the end of each chain: a Latin font owns Latin,
+    // and epaint picks the first face that has the glyph, so they only catch their own scripts.
+    let fallback = if system { load_fallback(&mut fonts, HanOrder::of(language)) } else { Vec::new() };
+    let hack = fonts.font_data.contains_key(HACK).then_some(HACK);
+    for role in [UI, UI_BOLD, CELL, CELL_BOLD, CELL_ITALIC, CELL_BOLD_ITALIC, SERIF, MONO] {
+        let chain = build_role_chain(&mut fonts, role, &base_prop, &base_mono, &fallback, hack, system);
+        fonts.families.insert(FontFamily::Name(role.into()), chain);
+        bound.push(role.to_string());
+    }
+    // Installed workbook fonts, so a cell's chosen font actually renders in it.
+    if system {
+        for family in crate::fonts::installed_among(used) {
+            bound.extend(crate::fonts::bind_family(&mut fonts, &family));
+        }
+    }
+    // Interface text (formula bar, name box, dialogs) falls back to the cell font before the
+    // script faces: whatever a cell can draw, the formula bar can draw too, even where no script
+    // fallback face was found (#349: macOS UI font without Hebrew, cells in Arial with it).
+    bind_cell_fallback(&mut fonts, &fallback);
+    // Default proportional text in widgets uses the UI font.
+    if let Some(ui) = fonts.families.get(&FontFamily::Name(UI.into())).cloned() {
+        fonts.families.insert(FontFamily::Proportional, ui);
+    }
+    // The optional craft-fonts faces go at the very end of every family: a system or bundled face
+    // that has the script keeps its glyph shapes, while the permitted OFL faces cover scripts and
+    // symbols the host image lacks (Japanese, Korean, Thai, Arabic, Georgian and the UI symbols).
+    // Chinese comes from the native-only OFL LXGW face when embedded; a system Han face still
+    // leads, and the barred Noto CJK collection never enters.
+    append_craft_faces(&mut fonts);
+    drop_unparseable_fonts(&mut fonts);
+    // Only families egui still has data for count as bound (a dropped face can empty a chain).
+    bound.retain(|f| fonts.families.get(&FontFamily::Name(f.as_str().into())).is_some_and(|c| !c.is_empty()));
+    crate::fonts::set_bound(bound);
+    fonts
+}
+
+/// Builds one role family's chain: the loaded system face (or its role fallback), egui's bundled
+/// proportional/monospace base, Hack's symbols, then the script fallbacks. Keys without font data
+/// are dropped, as before.
+fn build_role_chain(
+    fonts: &mut FontDefinitions,
+    role: &str,
+    base_prop: &[String],
+    base_mono: &[String],
+    fallback: &[String],
+    hack: Option<&str>,
+    system: bool,
+) -> Vec<String> {
+    let paths = candidates(role);
+    let refs: Vec<(&str, u32)> = paths.iter().map(|(p, i)| (p.as_str(), *i)).collect();
+    let mut chain: Vec<String> = Vec::new();
+    let loaded = if system { try_load(&refs) } else { None };
+    if let Some(mut fd) = loaded {
+        // Helvetica Neue Bold's own TrueType hints close Cyrillic е into ө at 13 pt on a Retina
+        // screen (#1184). Core Text never runs them, so this draws it the way macOS does.
+        if cfg!(target_os = "macos") && role == UI_BOLD {
+            fd.tweak.hinting = Some(false);
+        }
+        let key = format!("sys-{role}");
+        fonts.font_data.insert(key.clone(), Arc::new(fd));
+        chain.push(key);
+    } else if role == UI_BOLD {
+        chain.push(format!("sys-{UI}"));
+    } else if role.starts_with("cell-") {
+        chain.push(format!("sys-{CELL}"));
+    }
+    chain.extend(if role == MONO { base_mono.to_vec() } else { base_prop.to_vec() });
+    // egui bundles Hack, a monospace face rich in arrows, triangles and keyboard symbols, but
+    // 0.37 only puts it in the Monospace family. The interface draws ↑, ▲, ▼, ▸, ▾ and ↳ as
+    // text (filter menus, ribbon, keytips), so add it behind the UI/cell and emoji faces; it
+    // only catches characters those do not have.
+    if let Some(hack) = hack
+        && !chain.iter().any(|k| k.as_str() == hack)
+    {
+        chain.push(hack.to_string());
+    }
+    chain.extend(fallback.iter().cloned());
+    chain.retain(|k| fonts.font_data.contains_key(k));
+    chain
+}
+
+/// Inserts the loaded cell face before the script fallbacks of the interface families, so the
+/// formula bar and dialogs can draw whatever a cell can (#349).
+fn bind_cell_fallback(fonts: &mut FontDefinitions, fallback: &[String]) {
+    let cell_key = format!("sys-{CELL}");
+    if !fonts.font_data.contains_key(&cell_key) {
+        return;
+    }
+    for role in [UI, UI_BOLD, SERIF, MONO] {
+        if let Some(chain) = fonts.families.get_mut(&FontFamily::Name(role.into()))
+            && !chain.contains(&cell_key)
+        {
+            let at = chain.iter().position(|k| fallback.contains(k)).unwrap_or(chain.len());
+            chain.insert(at, cell_key.clone());
+        }
+    }
+}
+
+/// Appends the permitted craft-fonts faces to every family, preserving the leading system or
+/// bundled face's glyph shapes.
+fn append_craft_faces(fonts: &mut FontDefinitions) {
+    let craft = add_craft_fonts(fonts);
+    if craft.is_empty() {
+        return;
+    }
+    for chain in fonts.families.values_mut() {
+        for key in &craft {
+            if !chain.contains(key) {
+                chain.push(key.clone());
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod font_binding_tests {
+    use super::*;
+
+    /// The families [`font_definitions`] always binds, whatever is installed.
+    fn always_bound() -> Vec<String> {
+        [UI, UI_BOLD, CELL, CELL_BOLD, CELL_ITALIC, CELL_BOLD_ITALIC, SERIF, MONO].iter().map(|s| s.to_string()).collect()
+    }
+
+    #[test]
+    fn a_name_that_is_not_an_installed_font_gets_a_built_in_role() {
+        let _g = crate::fonts::TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        // Nothing installed: every name buckets to a role that font_definitions bound.
+        crate::fonts::set_bound(always_bound());
+        for name in ["", "Calibri", "Courier New", "Times New Roman", "Grossly Missing Font", "\u{1F600}"] {
+            for (b, i) in [(false, false), (true, false), (false, true), (true, true)] {
+                let FontFamily::Name(fam) = cell_family(name, b, i) else { panic!("{name:?} should name a family") };
+                assert!(crate::fonts::is_bound(&fam), "{name:?} {b} {i} → unbound {fam:?}");
+            }
+        }
+    }
+
+    #[test]
+    fn a_bound_installed_font_is_used_by_name() {
+        let _g = crate::fonts::TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let role = crate::fonts::role_key("Ubuntu", true, false);
+        crate::fonts::set_bound(always_bound().into_iter().chain([role.clone()]));
+        assert!(matches!(cell_family("Ubuntu", true, false), FontFamily::Name(f) if *f == *role));
+        // The same family in a style that wasn't bound falls back to a built-in role that is.
+        let FontFamily::Name(fallback) = cell_family("Ubuntu", false, true) else { panic!("should name a family") };
+        assert!(crate::fonts::is_bound(&fallback), "the fallback is a bound role");
+        crate::fonts::set_bound(always_bound());
+    }
+
+    #[test]
+    fn arbitrary_names_never_yield_an_unbound_family() {
+        let _g = crate::fonts::TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        // A workbook can hold any font name; none may name a family egui has no data for.
+        crate::fonts::set_bound(always_bound());
+        for seed in 0..500u32 {
+            let name: String =
+                (0..(seed % 40)).map(|k| char::from_u32(0x20 + (seed.wrapping_mul(31).wrapping_add(k) % 0x5F)).unwrap_or('x')).collect();
+            let FontFamily::Name(fam) = cell_family(&name, seed % 2 == 0, seed % 3 == 0) else { continue };
+            assert!(crate::fonts::is_bound(&fam), "{name:?} → unbound {fam:?}");
+        }
+    }
+}

From 41ab30678ccad009e7ec1af701e9b7cbb495f738 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:46:38 +0000
Subject: [PATCH 70/76] refactor(ui-egui): move control.rs items to control/

---
 crates/ui-egui/src/control.rs             | 889 +---------------------
 crates/ui-egui/src/control/screenshots.rs | 741 ++++++++++++++++++
 crates/ui-egui/src/control/synthetic.rs   | 145 ++++
 3 files changed, 901 insertions(+), 874 deletions(-)
 create mode 100644 crates/ui-egui/src/control/screenshots.rs
 create mode 100644 crates/ui-egui/src/control/synthetic.rs

diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 5e8be4945..190300c48 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -24,6 +24,21 @@ use serde_json::{Value as Json, json};
 
 use crate::SheetApp;
 
+mod screenshots;
+mod synthetic;
+
+pub use screenshots::{
+    CaptureGeometry, SCREENSHOT_DOCUMENT_CHANGED, SCREENSHOT_MAX_AGGREGATE_BYTES, SCREENSHOT_MAX_BASE64_BYTES, SCREENSHOT_MAX_ENCODING_BYTES,
+    SCREENSHOT_MAX_IMAGE_BYTES, SCREENSHOT_MAX_PEAK_BYTES, SCREENSHOT_MAX_REQUESTS, SCREENSHOT_MAX_RETRIES, SCREENSHOT_VIEWPORT_CHANGED, Shots,
+    UNKNOWN_CAPTURE_BYTES, drain_screenshots, encoding_working_bytes, issue_screenshots, save_image,
+};
+use screenshots::{Shot, check_encoding_budget, check_peak_budget, reject_shot};
+#[cfg(test)]
+use screenshots::{base64_len, png_worst_bytes, validate_image};
+pub(crate) use screenshots::{current_capture_geometry, note_capture_geometry};
+pub use synthetic::{MAX_QUEUED_SYNTHETIC_BYTES, MAX_QUEUED_SYNTHETIC_EVENTS, MAX_SYNTHETIC_TEXT_BYTES};
+use synthetic::{cell_center, key_from, modifiers, push_click, push_drag, push_key, push_move, push_text};
+
 pub type ControlResponse = Json;
 
 pub struct ControlRequest {
@@ -67,323 +82,6 @@ pub enum Outcome {
     Screenshot { path: Option<String> },
 }
 
-/// Most screenshots one client may have in flight or waiting for its reply at once.
-pub const SCREENSHOT_MAX_REQUESTS: usize = 4;
-/// Retained bytes for one screenshot image. The renderer's readback buffer is a separate
-/// transient allocation (recorded in peak RSS), not part of this reservation.
-pub const SCREENSHOT_MAX_IMAGE_BYTES: usize = 128 * 1024 * 1024;
-/// Aggregate bytes reserved by every outstanding screenshot request.
-pub const SCREENSHOT_MAX_AGGREGATE_BYTES: usize = 256 * 1024 * 1024;
-/// Largest transient working set allowed while one capture is encoded. It covers the RGBA copy
-/// made from the retained `ColorImage`, the PNG stream and (for base64 replies) the encoded text.
-/// Admission checks this before a request is issued, so a large capture cannot make the process
-/// peak several times above its retained-image budget.
-pub const SCREENSHOT_MAX_ENCODING_BYTES: usize = 256 * 1024 * 1024;
-/// Largest base64 reply this client produces. The encoded length is checked before the string is
-/// allocated; at most [`SCREENSHOT_MAX_REQUESTS`] such replies can therefore wait in the channel,
-/// keeping queued base64 text bounded too.
-pub const SCREENSHOT_MAX_BASE64_BYTES: usize = 64 * 1024 * 1024;
-/// Hard bound on retained request images plus one capture's encoding working set. Admission,
-/// issuance and every retry reject a request that would push the process over this, so the
-/// aggregate reservation and the transient encoder peak together stay bounded.
-pub const SCREENSHOT_MAX_PEAK_BYTES: usize = 512 * 1024 * 1024;
-/// Capture retries allowed inside one request's deadline after a resize/DPI/zoom/surface change.
-pub const SCREENSHOT_MAX_RETRIES: u32 = 2;
-/// Reported once when the active document changes before a queued capture is issued or completed.
-pub const SCREENSHOT_DOCUMENT_CHANGED: &str = "screenshot failed: the document changed while the capture was queued";
-/// Reported once when a capture request or completion is not for the active viewport.
-pub const SCREENSHOT_VIEWPORT_CHANGED: &str = "screenshot failed: the capture belongs to another viewport";
-
-/// Reserved while the viewport has no capturable size yet (minimized, or not laid out at all):
-/// the largest single image the per-image limit allows. The real size replaces it at issuance.
-pub const UNKNOWN_CAPTURE_BYTES: usize = SCREENSHOT_MAX_IMAGE_BYTES;
-
-/// The viewport geometry a capture is admitted, issued and completed against.
-///
-/// `SheetApp` keeps a monotonic epoch (see [`crate::SheetApp::logic`]) that increments on any
-/// change of these values, so a resize back to the original size is still a mismatch: an image
-/// taken in another layout must never be combined with the current geometry. The viewport id,
-/// minimized/occluded state and visibility are part of the identity too: a minimize/restore or
-/// an occlusion transition at the same pixel size is a new surface generation, not a no-op.
-///
-/// The identity deliberately keeps `zoom`, `visible` and `occluded` even though interface zoom
-/// does not change the expected physical surface size. A capture is bound to one layout generation,
-/// so a zoom or occlusion transition during it is retried within [`SCREENSHOT_MAX_RETRIES`] and
-/// then reported as a bounded failure instead of risking pixels from another generation. The common
-/// wheel-zoom path is frozen while a capture is in flight; a non-glide zoom or a compositor
-/// occlusion flap can still exhaust the retries, which is accepted as a rare, explicit error.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct CaptureGeometry {
-    /// The viewport this capture belongs to.
-    pub viewport_id: egui::ViewportId,
-    /// Logical size of the content that is captured, or `None` when the window currently has no
-    /// capturable surface (minimized, or not laid out yet). A hidden-but-occluded window still
-    /// reports a size.
-    pub viewport: Option<egui::Vec2>,
-    pub pixels_per_point: f32,
-    pub zoom: f32,
-    /// Maximum physical width/height the surface/renderer can capture.
-    pub max_texture_side: usize,
-    pub minimized: Option<bool>,
-    pub occluded: Option<bool>,
-    pub visible: Option<bool>,
-}
-
-impl CaptureGeometry {
-    /// The geometry described by a native frame's fresh [`egui::RawInput`].
-    ///
-    /// `raw.screen_rect` is the authoritative content size when `ViewportInfo::inner_rect` is
-    /// absent (Wayland always omits it, and a minimized window can omit both). The fallback to the
-    /// last UI pass's rect is deliberately *not* used here: a logic-only tick after a resize or
-    /// minimize must record the new state (or the explicit unknown state), never the old layout.
-    pub fn from_raw_input(raw: &egui::RawInput, ctx: &egui::Context) -> Self {
-        let info = raw.viewports.get(&raw.viewport_id).cloned().unwrap_or_default();
-        Self::build(raw.viewport_id, &info, raw.screen_rect, raw.max_texture_side, ctx.zoom_factor(), ctx.pixels_per_point())
-    }
-
-    /// Builds a `CaptureGeometry` from fresh viewport information. A minimized window has no size; `inner_rect` falls back to the raw screen rect; native scale is multiplied by interface zoom, and a zero surface limit means uncapped.
-    fn build(
-        viewport_id: egui::ViewportId,
-        info: &egui::ViewportInfo,
-        screen_rect: Option<egui::Rect>,
-        max_texture_side: Option<usize>,
-        zoom: f32,
-        fallback_pixels_per_point: f32,
-    ) -> Self {
-        let minimized = info.minimized;
-        let visible = info.visible();
-        // A minimized window has no surface to capture even if the platform still reports the
-        // last inner rectangle. Both rectangles missing likewise means "unknown size", not a
-        // reason to re-use an earlier layout.
-        let viewport = if minimized == Some(true) {
-            None
-        } else {
-            info.inner_rect.map(|rect| rect.size()).filter(positive_size).or_else(|| screen_rect.map(|rect| rect.size()).filter(positive_size))
-        };
-        let pixels_per_point =
-            info.native_pixels_per_point.filter(|p| p.is_finite() && *p > 0.0).map_or(fallback_pixels_per_point, |native| native * zoom);
-        Self {
-            viewport_id,
-            viewport,
-            pixels_per_point,
-            zoom,
-            // Zero means "unreported" (a bare test context); `expected_size` treats it as no cap.
-            max_texture_side: max_texture_side.unwrap_or(0),
-            minimized,
-            occluded: info.occluded,
-            visible,
-        }
-    }
-
-    /// The geometry of egui's current input. This is a fallback for callers that do not run
-    /// [`crate::SheetApp::raw_input_hook`] (tests and embedders); native eframe always records the
-    /// fresh [`Self::from_raw_input`] value first, so issuance and drain never fall back here.
-    pub fn current(ctx: &egui::Context) -> Self {
-        let (viewport_id, info, screen_rect, max_texture_side, fallback_ppp) = ctx.input(|i| {
-            let viewport_id = i.raw.viewport_id;
-            let info = i.raw.viewports.get(&viewport_id).cloned().unwrap_or_default();
-            // `screen_rect` from the pass if one supplied it; otherwise egui's retained content
-            // rect (which is only fresh when this is called from a UI pass, never a logic tick).
-            let screen_rect = i.raw.screen_rect.or_else(|| Some(i.viewport_rect()));
-            (viewport_id, info, screen_rect, i.max_texture_side, i.pixels_per_point())
-        });
-        Self::build(viewport_id, &info, screen_rect, Some(max_texture_side), ctx.zoom_factor(), fallback_ppp)
-    }
-
-    /// Physical pixel size the screenshot should have, rounded and capped by the surface limit.
-    /// `None` when the viewport has no positive, finite size (minimized or not laid out yet).
-    pub fn expected_size(&self) -> Option<[usize; 2]> {
-        let viewport = self.viewport?;
-        let ppp = self.pixels_per_point;
-        if !viewport.x.is_finite() || !viewport.y.is_finite() || viewport.x <= 0.0 || viewport.y <= 0.0 {
-            return None;
-        }
-        if !ppp.is_finite() || ppp <= 0.0 {
-            return None;
-        }
-        // An unreported surface limit (0) must not cap every capture to one pixel.
-        let max = if self.max_texture_side == 0 { usize::MAX } else { self.max_texture_side };
-        let axis = |points: f32| -> Option<usize> {
-            let px = (f64::from(points) * f64::from(ppp)).round();
-            if !px.is_finite() || px <= 0.0 || px > usize::MAX as f64 {
-                return None;
-            }
-            Some((px as usize).min(max))
-        };
-        Some([axis(viewport.x)?, axis(viewport.y)?])
-    }
-
-    /// Checked `width * height * 4` bytes for the expected image, capped by the surface limit.
-    pub fn expected_bytes(&self) -> Option<usize> {
-        let [w, h] = self.expected_size()?;
-        w.checked_mul(h)?.checked_mul(4)
-    }
-
-    /// Checked bytes of the largest image [`validate_image`] accepts for this geometry: one
-    /// physical pixel of rounding per axis. Reservations and the slot's per-image bound both use
-    /// this, so the aggregate budget is strict for the bytes actually retained.
-    pub fn retained_bytes(&self) -> Option<usize> {
-        let [w, h] = self.expected_size()?;
-        let w = w.checked_add(1)?;
-        let h = h.checked_add(1)?;
-        w.checked_mul(h)?.checked_mul(4)
-    }
-}
-
-/// True only when both width and height are finite and positive.
-fn positive_size(size: &egui::Vec2) -> bool {
-    size.x.is_finite() && size.y.is_finite() && size.x > 0.0 && size.y > 0.0
-}
-
-/// Conservative worst-case size of the PNG stream for a `bytes`-sized RGBA image with `height`
-/// rows. PNG adds a filter byte per row and zlib framing; uncompressed blocks add a few bytes per
-/// 64 KiB. 1% + 64 KiB plus the row bytes is safely above the real encoder output.
-fn png_worst_bytes(bytes: usize, height: usize) -> Option<usize> {
-    bytes.checked_add(bytes / 100)?.checked_add(height.checked_mul(2)?)?.checked_add(64 * 1024)
-}
-
-/// Base64 length (with padding) for `len` bytes.
-fn base64_len(len: usize) -> Option<usize> {
-    len.checked_add(2)?.checked_div(3)?.checked_mul(4)
-}
-
-/// Worst transient bytes for encoding one expected capture: the retained `ColorImage` plus the
-/// RGBA copy made from it, then (for base64) the PNG stream and the encoded text. `None` on
-/// overflow. Admission rejects a request whose working set exceeds
-/// [`SCREENSHOT_MAX_ENCODING_BYTES`] before any slot or command exists.
-pub fn encoding_working_bytes(expected: [usize; 2], base64: bool) -> Option<usize> {
-    let [w, h] = expected;
-    let bytes = w.checked_mul(h)?.checked_mul(4)?;
-    let retained_and_copy = bytes.checked_mul(2)?;
-    if !base64 {
-        return Some(retained_and_copy);
-    }
-    let png = png_worst_bytes(bytes, h)?;
-    let encoded = base64_len(png)?;
-    Some(retained_and_copy.max(bytes.checked_add(png)?.checked_add(encoded)?))
-}
-
-/// Reject an expected capture whose encoding working set or base64 reply would exceed the
-/// explicit encoding limits. Checked before admission and again immediately before issuance.
-fn check_encoding_budget(expected: [usize; 2], base64: bool) -> Result<(), String> {
-    let [w, h] = expected;
-    let Some(bytes) = w.checked_mul(h).and_then(|p| p.checked_mul(4)) else {
-        return Err("screenshot failed: the window size overflows the screenshot budget".to_string());
-    };
-    let Some(working) = encoding_working_bytes(expected, base64) else {
-        return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
-    };
-    if working > SCREENSHOT_MAX_ENCODING_BYTES {
-        return Err(format!(
-            "screenshot encoding budget exceeded: {working} bytes of transient working memory for one {w}×{h} capture, over the {SCREENSHOT_MAX_ENCODING_BYTES}-byte encoding limit"
-        ));
-    }
-    if base64 {
-        let Some(png) = png_worst_bytes(bytes, h) else {
-            return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
-        };
-        let Some(encoded) = base64_len(png) else {
-            return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
-        };
-        if encoded > SCREENSHOT_MAX_BASE64_BYTES {
-            return Err(format!(
-                "screenshot base64 budget exceeded: the reply for one {w}×{h} capture could be {encoded} bytes, over the {SCREENSHOT_MAX_BASE64_BYTES}-byte base64 limit; request a path instead"
-            ));
-        }
-    }
-    Ok(())
-}
-
-/// Reject a request whose reserved retained bytes plus its encoding working set exceed
-/// [`SCREENSHOT_MAX_PEAK_BYTES`]. `reserved` already includes this request's own reservation.
-fn check_peak_budget(reserved: usize, expected: [usize; 2], base64: bool) -> Result<(), String> {
-    let Some(working) = encoding_working_bytes(expected, base64) else {
-        return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
-    };
-    let peak = reserved.saturating_add(working);
-    if peak > SCREENSHOT_MAX_PEAK_BYTES {
-        return Err(format!(
-            "screenshot peak-memory budget exceeded: {reserved} bytes retained plus {working} bytes encoding for one capture is over the {SCREENSHOT_MAX_PEAK_BYTES}-byte peak limit"
-        ));
-    }
-    Ok(())
-}
-
-/// One admitted `ui.screenshot` request. The slot owns the image and its viewport waker; the
-/// callback holds only a weak reference to it and never writes a file or sends a reply.
-struct Shot {
-    token: u64,
-    path: Option<String>,
-    reply: Sender<ControlResponse>,
-    /// Monotonic deadline for the whole request, including retries.
-    deadline: f64,
-    /// Settle time before the first issuance (the UI must be still).
-    ready_at: f64,
-    /// Real (non-discarded) UI passes counted towards settling.
-    frames: u32,
-    /// `cumulative_pass_nr` of the last pass counted in `frames`, so repeated `ui` calls in one
-    /// pass count once and a settled frame is never counted twice.
-    settle_pass: Option<u64>,
-    issued: bool,
-    retries: u32,
-    /// Geometry at admission, updated immediately before issuance.
-    geometry: CaptureGeometry,
-    /// The viewport this request was admitted for. A callback or slot from another viewport must
-    /// never fill this request.
-    viewport_id: egui::ViewportId,
-    /// The active document (`DocState::uid`) at admission. A queued capture is never rebound to a
-    /// document that became active later.
-    document: Option<u64>,
-    /// Monotonic geometry epoch at issuance; any later change rejects the image.
-    epoch: u64,
-    /// Physical size expected at issuance; `None` while the window has no capturable size.
-    expected: Option<[usize; 2]>,
-    /// Bytes reserved from the aggregate budget until the request completes or is dropped. This
-    /// is the largest image the request may retain (one pixel of rounding per axis included) and
-    /// is also the slot's per-image bound.
-    bytes: usize,
-    /// Created at issuance (and anew for every retry), never at admission: the bound must match
-    /// the geometry and reservation the command is issued against.
-    slot: Option<CaptureSlot>,
-}
-
-#[derive(Default)]
-pub struct Shots {
-    token: u64,
-    requests: Vec<Shot>,
-}
-
-impl Shots {
-    /// A screenshot was asked for and hasn't been delivered yet: animations hold still, so the
-    /// picture shows the settled state.
-    pub(crate) fn in_flight(&self) -> bool {
-        !self.requests.is_empty()
-    }
-
-    /// Whether a hidden window still needs `RequestPaintWhileHidden` to reach issuance. Only a
-    /// request that is admitted or settling with a capturable size needs a first `ui` pass; once
-    /// `issue_screenshots` has sent the `Screenshot` command, that command's own `wants_paint`
-    /// paints the hidden window. A minimized request has no capturable size, so requesting hidden
-    /// full frames for its whole wait cannot make progress (the restore pass issues it).
-    pub(crate) fn needs_hidden_paint(&self) -> bool {
-        self.requests.iter().any(|r| !r.issued && r.expected.is_some())
-    }
-
-    /// Bytes currently reserved by admitted requests.
-    fn reserved(&self) -> usize {
-        self.requests.iter().fold(0usize, |sum, r| sum.saturating_add(r.bytes))
-    }
-
-    /// Drop every outstanding request without a reply (app shutdown): callbacks become inert.
-    pub fn cancel_all(&mut self) {
-        for request in self.requests.drain(..) {
-            if let Some(slot) = request.slot {
-                slot.cancel();
-            }
-        }
-    }
-}
-
 fn ok(v: Json) -> Outcome {
     Outcome::Done(json!({"ok": true, "result": v}))
 }
@@ -461,148 +159,6 @@ pub fn inspect(app: &SheetApp, ctx: &egui::Context) -> Json {
     })
 }
 
-fn key_from(name: &str) -> Option<egui::Key> {
-    egui::Key::from_name(name).or(match name.to_ascii_lowercase().as_str() {
-        "enter" | "return" => Some(egui::Key::Enter),
-        "esc" | "escape" => Some(egui::Key::Escape),
-        "delete" | "del" => Some(egui::Key::Delete),
-        "backspace" => Some(egui::Key::Backspace),
-        "left" => Some(egui::Key::ArrowLeft),
-        "right" => Some(egui::Key::ArrowRight),
-        "up" => Some(egui::Key::ArrowUp),
-        "down" => Some(egui::Key::ArrowDown),
-        "space" => Some(egui::Key::Space),
-        "tab" => Some(egui::Key::Tab),
-        "pageup" => Some(egui::Key::PageUp),
-        "pagedown" => Some(egui::Key::PageDown),
-        "home" => Some(egui::Key::Home),
-        "end" => Some(egui::Key::End),
-        "f2" => Some(egui::Key::F2),
-        "f4" => Some(egui::Key::F4),
-        "f9" => Some(egui::Key::F9),
-        _ => None,
-    })
-}
-
-fn modifiers(p: &Json) -> egui::Modifiers {
-    let b = |n: &str| p.get(n).and_then(Json::as_bool).unwrap_or(false);
-    egui::Modifiers {
-        alt: b("alt"),
-        ctrl: b("ctrl"),
-        shift: b("shift"),
-        mac_cmd: b("cmd") && cfg!(target_os = "macos"),
-        command: b("cmd") || (b("ctrl") && !cfg!(target_os = "macos")),
-    }
-}
-
-fn cell_center(app: &SheetApp, c: CellRef) -> Option<egui::Pos2> {
-    let d = app.session.active()?;
-    let sh = d.wb.active()?;
-    let rect = app.grid.rect?;
-    let geo = crate::grid::Geo::new(sh, rect, app.view().scroll);
-    Some(geo.screen_cell_rect(sh, c).center())
-}
-
-/// Most synthetic events (pointer, key, text and move alike) a control client may keep queued at
-/// once. The queue offers one batch per UI pass, and a hidden logic-only frame keeps the same
-/// batch unapplied, so every producer must honour this budget.
-pub const MAX_QUEUED_SYNTHETIC_EVENTS: usize = 10_000;
-/// Most bytes of synthetic input queued at once: the `Event` storage plus every text payload.
-pub const MAX_QUEUED_SYNTHETIC_BYTES: usize = 8 * 1024 * 1024;
-/// Largest single `ui.text` string accepted (well below the control line limit; one paste-sized
-/// string is plenty for a spreadsheet cell and keeps a burst from exhausting memory).
-pub const MAX_SYNTHETIC_TEXT_BYTES: usize = 1024 * 1024;
-
-/// Bytes charged to one synthetic event: `size_of::<Event>()` plus the payload of a `Text` event.
-fn event_bytes(event: &egui::Event) -> usize {
-    std::mem::size_of::<egui::Event>()
-        + match event {
-            egui::Event::Text(text) => text.len(),
-            _ => 0,
-        }
-}
-
-/// Saturating totals of queued synthetic events and their charged bytes across every pending batch.
-fn synthetic_usage(app: &SheetApp) -> (usize, usize) {
-    app.synthetic
-        .iter()
-        .flat_map(|batch| batch.iter())
-        .fold((0usize, 0usize), |(events, bytes), event| (events.saturating_add(1), bytes.saturating_add(event_bytes(event))))
-}
-
-/// Refuses a request that would push the queued synthetic input past either limit; the queue is
-/// left unchanged.
-fn synthetic_budget(app: &SheetApp, extra_events: usize, extra_bytes: usize) -> Result<(), String> {
-    let (events, bytes) = synthetic_usage(app);
-    if events.saturating_add(extra_events) > MAX_QUEUED_SYNTHETIC_EVENTS {
-        return Err(format!("too many synthetic input events (limit {MAX_QUEUED_SYNTHETIC_EVENTS} queued at once)"));
-    }
-    if bytes.saturating_add(extra_bytes) > MAX_QUEUED_SYNTHETIC_BYTES {
-        return Err(format!("synthetic input exceeds the {MAX_QUEUED_SYNTHETIC_BYTES}-byte queue limit"));
-    }
-    Ok(())
-}
-
-/// Checks the synthetic-event budget, then queues one pointer move followed by `count` press/release pairs (`count` is at least one).
-fn push_click(app: &mut SheetApp, pos: egui::Pos2, button: egui::PointerButton, count: u32, m: egui::Modifiers) -> Result<(), String> {
-    let count = count.max(1) as usize;
-    let events = count.saturating_mul(2).saturating_add(1);
-    synthetic_budget(app, events, events.saturating_mul(std::mem::size_of::<egui::Event>()))?;
-    app.synthetic.push_back(vec![egui::Event::PointerMoved(pos)]);
-    let mut batch = Vec::with_capacity(count * 2);
-    for _ in 0..count {
-        batch.push(egui::Event::PointerButton { pos, button, pressed: true, modifiers: m });
-        batch.push(egui::Event::PointerButton { pos, button, pressed: false, modifiers: m });
-    }
-    app.synthetic.push_back(batch);
-    Ok(())
-}
-
-/// Checks the synthetic-event budget, then queues a move, a press, `steps` interpolated moves and a release.
-fn push_drag(app: &mut SheetApp, a: egui::Pos2, b: egui::Pos2, steps: usize, m: egui::Modifiers) -> Result<(), String> {
-    let steps = steps.max(1);
-    let events = steps.saturating_add(3);
-    synthetic_budget(app, events, events.saturating_mul(std::mem::size_of::<egui::Event>()))?;
-    app.synthetic.push_back(vec![egui::Event::PointerMoved(a)]);
-    app.synthetic.push_back(vec![egui::Event::PointerButton { pos: a, button: egui::PointerButton::Primary, pressed: true, modifiers: m }]);
-    for i in 1..=steps {
-        let t = i as f32 / steps as f32;
-        app.synthetic.push_back(vec![egui::Event::PointerMoved(a + (b - a) * t)]);
-    }
-    app.synthetic.push_back(vec![egui::Event::PointerButton { pos: b, button: egui::PointerButton::Primary, pressed: false, modifiers: m }]);
-    Ok(())
-}
-
-/// Checks the synthetic-event budget and queues one key press/release pair.
-fn push_key(app: &mut SheetApp, key: egui::Key, m: egui::Modifiers) -> Result<(), String> {
-    let events = 2;
-    synthetic_budget(app, events, events * std::mem::size_of::<egui::Event>())?;
-    app.synthetic.push_back(vec![
-        egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: m },
-        egui::Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers: m },
-    ]);
-    Ok(())
-}
-
-/// Rejects text longer than `MAX_SYNTHETIC_TEXT_BYTES`, then queues one `Text` event under the shared queue budget.
-fn push_text(app: &mut SheetApp, text: String) -> Result<(), String> {
-    if text.len() > MAX_SYNTHETIC_TEXT_BYTES {
-        return Err(format!("text input is {} bytes, over the {MAX_SYNTHETIC_TEXT_BYTES}-byte limit for one event", text.len()));
-    }
-    let event = egui::Event::Text(text);
-    synthetic_budget(app, 1, event_bytes(&event))?;
-    app.synthetic.push_back(vec![event]);
-    Ok(())
-}
-
-/// Queues one pointer-move event under the shared synthetic queue budget.
-fn push_move(app: &mut SheetApp, pos: egui::Pos2) -> Result<(), String> {
-    let event = egui::Event::PointerMoved(pos);
-    synthetic_budget(app, 1, event_bytes(&event))?;
-    app.synthetic.push_back(vec![event]);
-    Ok(())
-}
-
 /// Keeps the commands whose id, label or ribbon path contains `search` (case-insensitive); `None` keeps all.
 fn filter_commands(commands: Vec<Json>, search: Option<&str>) -> Vec<Json> {
     let Some(q) = search.map(str::to_ascii_lowercase) else { return commands };
@@ -883,11 +439,6 @@ pub fn poll(app: &mut SheetApp, ctx: &egui::Context) {
     }
 }
 
-/// Sends one screenshot rejection carrying the request token.
-fn reject_shot(reply: Sender<ControlResponse>, token: u64, message: impl std::fmt::Display) {
-    let _ = reply.send(json!({"ok": false, "error": message.to_string(), "request": token}));
-}
-
 /// Put the request token on every screenshot reply (success, rejection, timeout), so a client can
 /// correlate an asynchronous capture even when the reply order differs from the request order.
 fn with_token(mut reply: Json, token: u64) -> Json {
@@ -897,29 +448,6 @@ fn with_token(mut reply: Json, token: u64) -> Json {
     reply
 }
 
-/// The geometry to use for admission, issuance and drain.
-///
-/// Native eframe calls [`crate::SheetApp::raw_input_hook`] before every frame (including a
-/// logic-only tick), so the recorded value carries fresh `RawInput` geometry even when egui's
-/// last UI pass is stale. Tests and embedders that never call the hook fall back to egui's current
-/// input; that fallback is only used when no raw frame was seen.
-pub(crate) fn current_capture_geometry(app: &SheetApp, ctx: &egui::Context) -> CaptureGeometry {
-    if app.capture_geometry_from_raw { app.capture_geometry.unwrap_or_else(|| CaptureGeometry::current(ctx)) } else { CaptureGeometry::current(ctx) }
-}
-
-/// Record `geometry` as the layout captures are bound to and bump the epoch when it differs.
-///
-/// Issuance and drain use this instead of writing the fields separately: during a hidden
-/// logic-only tick the viewport info can be newer than the last UI pass, and the epoch must
-/// change together with the geometry or a valid image would be retried against its own epoch.
-pub(crate) fn note_capture_geometry(app: &mut SheetApp, geometry: CaptureGeometry) -> u64 {
-    if app.capture_geometry != Some(geometry) {
-        app.capture_geometry = Some(geometry);
-        app.capture_epoch = app.capture_epoch.wrapping_add(1);
-    }
-    app.capture_epoch
-}
-
 /// Returns the next screenshot token, wrapping and skipping zero.
 fn next_token(app: &mut SheetApp) -> u64 {
     let mut token = app.shots.token.wrapping_add(1);
@@ -1023,392 +551,5 @@ fn timeout_reply(message: &str, token: u64) -> Json {
     json!({"ok": false, "error": message, "request": token})
 }
 
-/// The bytes to reserve for one capture of `expected` against `geometry`, after checking the
-/// applicable limits. Issuance and retry both use this (admission keeps its own inline checks) so a
-/// retry cannot drift from the limits the first issuance applied. `expected` is `None` when the
-/// viewport has no capturable size yet: that reserves [`UNKNOWN_CAPTURE_BYTES`] and still checks
-/// the aggregate limit, while the per-image, encoding and peak checks only apply once a size is
-/// known.
-fn capture_bytes(app: &SheetApp, i: usize, geometry: CaptureGeometry, expected: Option<[usize; 2]>, base64: bool) -> Result<usize, String> {
-    let bytes = match expected {
-        Some(expected) => {
-            let bytes = geometry.retained_bytes().ok_or_else(|| "screenshot failed: the window size overflows the screenshot budget".to_string())?;
-            if bytes > SCREENSHOT_MAX_IMAGE_BYTES {
-                return Err(format!(
-                    "screenshot budget exceeded: {bytes} bytes for one {}×{} image, over the {SCREENSHOT_MAX_IMAGE_BYTES}-byte per-image limit",
-                    expected[0], expected[1]
-                ));
-            }
-            check_encoding_budget(expected, base64)?;
-            bytes
-        }
-        None => UNKNOWN_CAPTURE_BYTES,
-    };
-    let others = app.shots.requests.iter().enumerate().filter(|(j, _)| *j != i).fold(0usize, |sum, (_, r)| sum.saturating_add(r.bytes));
-    if others.saturating_add(bytes) > SCREENSHOT_MAX_AGGREGATE_BYTES {
-        return Err(format!(
-            "screenshot budget exceeded: {bytes} bytes for this image would exceed the {SCREENSHOT_MAX_AGGREGATE_BYTES}-byte aggregate limit"
-        ));
-    }
-    if let Some(expected) = expected {
-        check_peak_budget(others.saturating_add(bytes), expected, base64)?;
-    }
-    Ok(bytes)
-}
-
-/// Issued from `ui`: counts one real (non-discarded) settling pass per request, revalidates the
-/// geometry and reserves the exact retained bytes, then sends one
-/// `ViewportCommand::Screenshot(callback)` per request.
-///
-/// The slot is created here, not at admission. Its per-image bound is the same reservation the
-/// aggregate budget holds, so an image that would exceed the budget cannot be retained; a retry
-/// after a resize creates a fresh slot for the new geometry.
-pub fn issue_screenshots(app: &mut SheetApp, ctx: &egui::Context) {
-    let now = crate::monotonic_ms();
-    let pass = ctx.cumulative_pass_nr();
-    // A pass whose output is already going to be discarded is not a settling frame and its
-    // layout is not the one to capture. GridCraft requests no discard after this call.
-    let discard = ctx.will_discard();
-    let active_document = app.session.active().map(|d| d.uid);
-    let current_viewport = ctx.viewport_id();
-    let len = app.shots.requests.len();
-    let mut failures: Vec<(usize, String)> = Vec::new();
-    for i in 0..len {
-        let (issued, ready_at, settle_pass) = {
-            let r = &app.shots.requests[i];
-            (r.issued, r.ready_at, r.settle_pass)
-        };
-        if issued || discard || settle_pass == Some(pass) {
-            continue;
-        }
-        // One count per egui pass, however many times this `ui` runs in it.
-        let frames = {
-            let r = &mut app.shots.requests[i];
-            r.settle_pass = Some(pass);
-            r.frames = r.frames.saturating_add(1);
-            r.frames
-        };
-        if now < ready_at || frames < 3 {
-            continue;
-        }
-        // A queued capture belongs to the document and viewport it was admitted for. A switch
-        // before issuance is reported once and never rebound to the new document.
-        let (viewport_id, document, base64) = {
-            let r = &app.shots.requests[i];
-            (r.viewport_id, r.document, r.path.is_none())
-        };
-        if viewport_id != current_viewport {
-            failures.push((i, SCREENSHOT_VIEWPORT_CHANGED.into()));
-            continue;
-        }
-        if document != active_document {
-            failures.push((i, SCREENSHOT_DOCUMENT_CHANGED.into()));
-            continue;
-        }
-        let current = current_capture_geometry(app, ctx);
-        let Some(expected) = current.expected_size() else {
-            // Still minimized or not laid out: keep the request queued and try again on a later
-            // real pass; `drain_screenshots` reports the size-specific timeout if none arrives.
-            app.shots.requests[i].expected = None;
-            continue;
-        };
-        let bytes = match capture_bytes(app, i, current, Some(expected), base64) {
-            Ok(bytes) => bytes,
-            Err(message) => {
-                failures.push((i, message));
-                continue;
-            }
-        };
-        // Update the geometry and its epoch together, so the drain accepts exactly the layout the
-        // capture is issued against even when a hidden logic tick already saw the new viewport.
-        let epoch = note_capture_geometry(app, current);
-        let r = &mut app.shots.requests[i];
-        r.geometry = current;
-        r.expected = Some(expected);
-        r.bytes = bytes;
-        r.epoch = epoch;
-        if let Some(old) = r.slot.take() {
-            old.cancel();
-        }
-        let (slot, callback) = CaptureSlot::new(ctx, viewport_id, bytes);
-        r.slot = Some(slot);
-        ctx.send_viewport_cmd_to(viewport_id, egui::ViewportCommand::Screenshot(callback));
-        r.issued = true;
-    }
-    for (i, message) in failures.into_iter().rev() {
-        reject_shot_at(app, i, message);
-    }
-    if app.shots.in_flight() {
-        ctx.request_repaint_after(std::time::Duration::from_millis(16));
-    }
-}
-
-/// Checks that the image has the pixel count its dimensions imply, is within one pixel of the expected size on each axis, and keeps the expected aspect ratio within that rounding.
-fn validate_image(image: &egui::ColorImage, expected: [usize; 2]) -> Result<(), String> {
-    let [w, h] = image.size;
-    let [ew, eh] = expected;
-    let pixels = w.checked_mul(h).ok_or_else(|| "screenshot dimensions overflow".to_string())?;
-    if image.pixels.len() != pixels {
-        return Err(format!("screenshot has {} pixels for its {w}×{h} dimensions", image.pixels.len()));
-    }
-    // Allow one physical pixel of rounding per axis, but not independent distortion: an image
-    // that is one pixel wider and one pixel shorter has a different aspect and cannot be the
-    // recorded viewport. Rejecting it forces the retry/timeout path instead of saving skewed pixels.
-    if w.abs_diff(ew) > 1 || h.abs_diff(eh) > 1 {
-        return Err(format!("screenshot is {w}×{h} pixels, expected {ew}×{eh}: the window changed size while it was captured"));
-    }
-    // Keep the returned scale's aspect within the rounding error of the recorded logical viewport.
-    let cross = w.checked_mul(eh).and_then(|a| h.checked_mul(ew).map(|b| a.abs_diff(b)));
-    let Some(cross) = cross else {
-        return Err("screenshot dimensions overflow the aspect check".to_string());
-    };
-    if cross > ew.max(eh) {
-        return Err(format!("screenshot is {w}×{h} pixels, expected {ew}×{eh}: the aspect ratio changed while it was captured"));
-    }
-    Ok(())
-}
-
-/// What [`drain_screenshots`] must do with one request after inspecting it.
-enum DrainAction {
-    /// Still waiting; leave the request at the same index.
-    Keep,
-    /// Answer the request with this reply and remove it.
-    Remove(Json),
-    /// Re-arm the request for a fresh capture within its retry budget.
-    Restart,
-}
-
-/// Called from `logic`: takes each completed slot once, validates identity, size, geometry/epoch
-/// and **deadline** and only then encodes, writes and replies outside the slot. A stale, oversized
-/// or late image is dropped without writing a file.
-pub fn drain_screenshots(app: &mut SheetApp, ctx: &egui::Context) {
-    let now = crate::monotonic_ms();
-    let current_geometry = current_capture_geometry(app, ctx);
-    let epoch = note_capture_geometry(app, current_geometry);
-    let active_document = app.session.active().map(|d| d.uid);
-    let current_viewport = ctx.viewport_id();
-    let mut i = 0;
-    while i < app.shots.requests.len() {
-        match drain_action(app, i, now, current_geometry, epoch, active_document, current_viewport) {
-            DrainAction::Keep => i += 1,
-            DrainAction::Remove(reply) => finish_shot(app, i, reply),
-            DrainAction::Restart => match retry_capture(app, i, current_geometry, epoch, now) {
-                Ok(()) => i += 1,
-                Err(message) => reject_shot_at(app, i, message),
-            },
-        }
-    }
-    if app.shots.in_flight() {
-        ctx.request_repaint_after(std::time::Duration::from_millis(16));
-    }
-}
-
-/// Validates one request and decides whether it stays queued, is answered or is re-armed.
-fn drain_action(
-    app: &mut SheetApp,
-    i: usize,
-    now: f64,
-    current_geometry: CaptureGeometry,
-    epoch: u64,
-    active_document: Option<u64>,
-    current_viewport: egui::ViewportId,
-) -> DrainAction {
-    let r = &mut app.shots.requests[i];
-    // A document or viewport change is a definitive mismatch: cancel once, never retry and
-    // never write the pixels against the new identity.
-    if r.viewport_id != current_viewport {
-        cancel_shot(r);
-        return DrainAction::Remove(json!({"ok": false, "error": SCREENSHOT_VIEWPORT_CHANGED}));
-    }
-    if r.document != active_document {
-        cancel_shot(r);
-        return DrainAction::Remove(json!({"ok": false, "error": SCREENSHOT_DOCUMENT_CHANGED}));
-    }
-    if !r.issued {
-        return drain_unissued(r, now);
-    }
-    drain_completion(r, now, current_geometry, epoch)
-}
-
-/// A request that never issued a capture: keep waiting, or report the timeout that fits whether
-/// the window ever had a capturable size.
-fn drain_unissued(r: &mut Shot, now: f64) -> DrainAction {
-    if now < r.deadline {
-        return DrainAction::Keep;
-    }
-    cancel_shot(r);
-    let message = if r.expected.is_none() {
-        "screenshot timeout: the window never reported a capturable size (it may be minimized or not laid out)"
-    } else {
-        "no frame was presented before the screenshot timeout"
-    };
-    DrainAction::Remove(timeout_reply(message, r.token))
-}
-
-/// A request that issued a capture: inspect its slot once, then apply the deadline, validation
-/// and geometry checks in the same order as issuance.
-fn drain_completion(r: &mut Shot, now: f64, current_geometry: CaptureGeometry, epoch: u64) -> DrainAction {
-    match r.slot.as_ref().and_then(|slot| slot.take()) {
-        // A completion that arrives past the deadline is late even if the pixels are valid: the
-        // client was promised one answer within the deadline, so nothing is written for it.
-        Some(result) if now >= r.deadline => {
-            drop(result);
-            DrainAction::Remove(timeout_reply("screenshot timeout: the image completed after its deadline; no file was written", r.token))
-        }
-        Some(Ok(image)) => drain_image(r, image, now, current_geometry, epoch),
-        // The slot refused the image before `validate_image` saw it: an image larger than the
-        // reservation is as much evidence of a resize as a smaller one. Retry within the same
-        // bounded budget instead of failing only when the window grew. A non-resize fault still
-        // exhausts the retries and reports the slot's error, so this stays fail-closed.
-        Some(Err(_)) if retry_allowed(r, now) => DrainAction::Restart,
-        Some(Err(e)) => DrainAction::Remove(json!({"ok": false, "error": e.to_string()})),
-        None if now >= r.deadline => {
-            cancel_shot(r);
-            DrainAction::Remove(timeout_reply("no frame was presented before the screenshot timeout", r.token))
-        }
-        None => DrainAction::Keep,
-    }
-}
-
-/// Validates a completed image against the size recorded at issuance and the current
-/// geometry/epoch; only a valid image is saved, and only a retry that is still inside the
-/// request's deadline and retry budget gets a fresh attempt.
-fn drain_image(r: &mut Shot, image: std::sync::Arc<egui::ColorImage>, now: f64, current_geometry: CaptureGeometry, epoch: u64) -> DrainAction {
-    let validated = match r.expected {
-        Some(expected) => validate_image(&image, expected),
-        None => Err("screenshot has no expected size".to_string()),
-    };
-    match validated {
-        Err(_) if retry_allowed(r, now) => {
-            drop(image);
-            DrainAction::Restart
-        }
-        Err(message) => DrainAction::Remove(json!({"ok": false, "error": message})),
-        Ok(()) if epoch != r.epoch || current_geometry != r.geometry => {
-            if !retry_allowed(r, now) {
-                return DrainAction::Remove(json!({
-                    "ok": false,
-                    "error": "screenshot geometry changed while it was captured; no image was written"
-                }));
-            }
-            drop(image);
-            DrainAction::Restart
-        }
-        Ok(()) => DrainAction::Remove(save_image(image, r.path.as_deref())),
-    }
-}
-
-/// Whether this request may take another capture: both limits are fixed for the whole request.
-fn retry_allowed(r: &Shot, now: f64) -> bool {
-    r.retries < SCREENSHOT_MAX_RETRIES && now < r.deadline
-}
-
-/// Takes and cancels the request's capture slot, if it has one.
-fn cancel_shot(r: &mut Shot) {
-    if let Some(slot) = r.slot.take() {
-        slot.cancel();
-    }
-}
-
-/// Remove request `i`, cancel its slot and answer it once with a token-carrying reply.
-fn finish_shot(app: &mut SheetApp, i: usize, reply: Json) {
-    let request = app.shots.requests.remove(i);
-    if let Some(slot) = request.slot {
-        slot.cancel();
-    }
-    let _ = request.reply.send(with_token(reply, request.token));
-}
-
-/// Remove request `i`, cancel its slot and reject it with `message`.
-fn reject_shot_at(app: &mut SheetApp, i: usize, message: impl std::fmt::Display) {
-    let request = app.shots.requests.remove(i);
-    if let Some(slot) = request.slot {
-        slot.cancel();
-    }
-    reject_shot(request.reply, request.token, message);
-}
-
-/// Re-arm one request for a fresh issuance against `geometry`: a new reservation (the maximum
-/// retained image, or [`UNKNOWN_CAPTURE_BYTES`] while there is no size), a new epoch and no slot.
-/// A fresh slot and callback are created by [`issue_screenshots`]; the old image was dropped by
-/// the caller.
-fn retry_capture(app: &mut SheetApp, i: usize, geometry: CaptureGeometry, epoch: u64, now: f64) -> Result<(), String> {
-    let expected = geometry.expected_size();
-    let base64 = app.shots.requests.get(i).is_some_and(|r| r.path.is_none());
-    let bytes = capture_bytes(app, i, geometry, expected, base64)?;
-    let r = &mut app.shots.requests[i];
-    r.retries = r.retries.saturating_add(1);
-    r.issued = false;
-    r.frames = 3;
-    r.settle_pass = None;
-    r.ready_at = now;
-    r.expected = expected;
-    r.bytes = bytes;
-    r.geometry = geometry;
-    r.epoch = epoch;
-    if let Some(slot) = r.slot.take() {
-        slot.cancel();
-    }
-    Ok(())
-}
-
-/// Encodes a screenshot as PNG to `path`, or returns it as base64.
-///
-/// The retained `ColorImage` is released before encoding, and a path capture streams the PNG
-/// straight to the file. A base64 reply is length-checked against
-/// [`SCREENSHOT_MAX_BASE64_BYTES`] *before* the string is allocated, so one admitted capture cannot
-/// retain an unbounded reply alongside its image.
-pub fn save_image(image: std::sync::Arc<egui::ColorImage>, path: Option<&str>) -> Json {
-    use image::ImageEncoder as _;
-    let [w, h] = image.size;
-    let Some(capacity) = w.checked_mul(h).and_then(|p| p.checked_mul(4)) else { return json!({"ok": false, "error": "bad image"}) };
-    if image.pixels.len().checked_mul(4) != Some(capacity) {
-        return json!({"ok": false, "error": "bad image"});
-    }
-    let (Ok(width), Ok(height)) = (u32::try_from(w), u32::try_from(h)) else { return json!({"ok": false, "error": "bad image"}) };
-    // One RGBA copy is unavoidable with the `image` encoder API. Drop the retained image before
-    // encoding so the peak is the copy plus encoder buffers, not both images plus the PNG stream.
-    let mut rgba = Vec::with_capacity(capacity);
-    for p in &image.pixels {
-        rgba.extend_from_slice(&p.to_array());
-    }
-    drop(image);
-    match path {
-        Some(p) => match std::fs::File::create(p) {
-            Ok(file) => {
-                let encoder = image::codecs::png::PngEncoder::new(file);
-                match encoder.write_image(&rgba, width, height, image::ExtendedColorType::Rgba8) {
-                    Ok(()) => json!({"ok": true, "result": {"path": p, "width": w, "height": h}}),
-                    Err(e) => {
-                        // Do not leave a truncated PNG behind.
-                        let _ = std::fs::remove_file(p);
-                        json!({"ok": false, "error": e.to_string()})
-                    }
-                }
-            }
-            Err(e) => json!({"ok": false, "error": e.to_string()}),
-        },
-        None => {
-            let mut png = Vec::new();
-            let encoder = image::codecs::png::PngEncoder::new(&mut png);
-            if let Err(e) = encoder.write_image(&rgba, width, height, image::ExtendedColorType::Rgba8) {
-                return json!({"ok": false, "error": e.to_string()});
-            }
-            let Some(encoded_len) = base64_len(png.len()) else {
-                return json!({"ok": false, "error": "screenshot base64 length overflow"});
-            };
-            if encoded_len > SCREENSHOT_MAX_BASE64_BYTES {
-                return json!({
-                    "ok": false,
-                    "error": format!(
-                        "screenshot base64 budget exceeded: the {w}×{h} reply would be {encoded_len} bytes, over the {SCREENSHOT_MAX_BASE64_BYTES}-byte base64 limit; request a path instead"
-                    )
-                });
-            }
-            json!({"ok": true, "result": {"base64": gridcraft_engine::io::base64_encode(&png), "width": w, "height": h}})
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/crates/ui-egui/src/control/screenshots.rs b/crates/ui-egui/src/control/screenshots.rs
new file mode 100644
index 000000000..5cf9e999b
--- /dev/null
+++ b/crates/ui-egui/src/control/screenshots.rs
@@ -0,0 +1,741 @@
+use super::*;
+
+/// Most screenshots one client may have in flight or waiting for its reply at once.
+pub const SCREENSHOT_MAX_REQUESTS: usize = 4;
+
+/// Retained bytes for one screenshot image. The renderer's readback buffer is a separate
+/// transient allocation (recorded in peak RSS), not part of this reservation.
+pub const SCREENSHOT_MAX_IMAGE_BYTES: usize = 128 * 1024 * 1024;
+
+/// Aggregate bytes reserved by every outstanding screenshot request.
+pub const SCREENSHOT_MAX_AGGREGATE_BYTES: usize = 256 * 1024 * 1024;
+
+/// Largest transient working set allowed while one capture is encoded. It covers the RGBA copy
+/// made from the retained `ColorImage`, the PNG stream and (for base64 replies) the encoded text.
+/// Admission checks this before a request is issued, so a large capture cannot make the process
+/// peak several times above its retained-image budget.
+pub const SCREENSHOT_MAX_ENCODING_BYTES: usize = 256 * 1024 * 1024;
+
+/// Largest base64 reply this client produces. The encoded length is checked before the string is
+/// allocated; at most [`SCREENSHOT_MAX_REQUESTS`] such replies can therefore wait in the channel,
+/// keeping queued base64 text bounded too.
+pub const SCREENSHOT_MAX_BASE64_BYTES: usize = 64 * 1024 * 1024;
+
+/// Hard bound on retained request images plus one capture's encoding working set. Admission,
+/// issuance and every retry reject a request that would push the process over this, so the
+/// aggregate reservation and the transient encoder peak together stay bounded.
+pub const SCREENSHOT_MAX_PEAK_BYTES: usize = 512 * 1024 * 1024;
+
+/// Capture retries allowed inside one request's deadline after a resize/DPI/zoom/surface change.
+pub const SCREENSHOT_MAX_RETRIES: u32 = 2;
+
+/// Reported once when the active document changes before a queued capture is issued or completed.
+pub const SCREENSHOT_DOCUMENT_CHANGED: &str = "screenshot failed: the document changed while the capture was queued";
+
+/// Reported once when a capture request or completion is not for the active viewport.
+pub const SCREENSHOT_VIEWPORT_CHANGED: &str = "screenshot failed: the capture belongs to another viewport";
+
+/// Reserved while the viewport has no capturable size yet (minimized, or not laid out at all):
+/// the largest single image the per-image limit allows. The real size replaces it at issuance.
+pub const UNKNOWN_CAPTURE_BYTES: usize = SCREENSHOT_MAX_IMAGE_BYTES;
+
+/// The viewport geometry a capture is admitted, issued and completed against.
+///
+/// `SheetApp` keeps a monotonic epoch (see [`crate::SheetApp::logic`]) that increments on any
+/// change of these values, so a resize back to the original size is still a mismatch: an image
+/// taken in another layout must never be combined with the current geometry. The viewport id,
+/// minimized/occluded state and visibility are part of the identity too: a minimize/restore or
+/// an occlusion transition at the same pixel size is a new surface generation, not a no-op.
+///
+/// The identity deliberately keeps `zoom`, `visible` and `occluded` even though interface zoom
+/// does not change the expected physical surface size. A capture is bound to one layout generation,
+/// so a zoom or occlusion transition during it is retried within [`SCREENSHOT_MAX_RETRIES`] and
+/// then reported as a bounded failure instead of risking pixels from another generation. The common
+/// wheel-zoom path is frozen while a capture is in flight; a non-glide zoom or a compositor
+/// occlusion flap can still exhaust the retries, which is accepted as a rare, explicit error.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CaptureGeometry {
+    /// The viewport this capture belongs to.
+    pub viewport_id: egui::ViewportId,
+    /// Logical size of the content that is captured, or `None` when the window currently has no
+    /// capturable surface (minimized, or not laid out yet). A hidden-but-occluded window still
+    /// reports a size.
+    pub viewport: Option<egui::Vec2>,
+    pub pixels_per_point: f32,
+    pub zoom: f32,
+    /// Maximum physical width/height the surface/renderer can capture.
+    pub max_texture_side: usize,
+    pub minimized: Option<bool>,
+    pub occluded: Option<bool>,
+    pub visible: Option<bool>,
+}
+
+impl CaptureGeometry {
+    /// The geometry described by a native frame's fresh [`egui::RawInput`].
+    ///
+    /// `raw.screen_rect` is the authoritative content size when `ViewportInfo::inner_rect` is
+    /// absent (Wayland always omits it, and a minimized window can omit both). The fallback to the
+    /// last UI pass's rect is deliberately *not* used here: a logic-only tick after a resize or
+    /// minimize must record the new state (or the explicit unknown state), never the old layout.
+    pub fn from_raw_input(raw: &egui::RawInput, ctx: &egui::Context) -> Self {
+        let info = raw.viewports.get(&raw.viewport_id).cloned().unwrap_or_default();
+        Self::build(raw.viewport_id, &info, raw.screen_rect, raw.max_texture_side, ctx.zoom_factor(), ctx.pixels_per_point())
+    }
+
+    /// Builds a `CaptureGeometry` from fresh viewport information. A minimized window has no size; `inner_rect` falls back to the raw screen rect; native scale is multiplied by interface zoom, and a zero surface limit means uncapped.
+    fn build(
+        viewport_id: egui::ViewportId,
+        info: &egui::ViewportInfo,
+        screen_rect: Option<egui::Rect>,
+        max_texture_side: Option<usize>,
+        zoom: f32,
+        fallback_pixels_per_point: f32,
+    ) -> Self {
+        let minimized = info.minimized;
+        let visible = info.visible();
+        // A minimized window has no surface to capture even if the platform still reports the
+        // last inner rectangle. Both rectangles missing likewise means "unknown size", not a
+        // reason to re-use an earlier layout.
+        let viewport = if minimized == Some(true) {
+            None
+        } else {
+            info.inner_rect.map(|rect| rect.size()).filter(positive_size).or_else(|| screen_rect.map(|rect| rect.size()).filter(positive_size))
+        };
+        let pixels_per_point =
+            info.native_pixels_per_point.filter(|p| p.is_finite() && *p > 0.0).map_or(fallback_pixels_per_point, |native| native * zoom);
+        Self {
+            viewport_id,
+            viewport,
+            pixels_per_point,
+            zoom,
+            // Zero means "unreported" (a bare test context); `expected_size` treats it as no cap.
+            max_texture_side: max_texture_side.unwrap_or(0),
+            minimized,
+            occluded: info.occluded,
+            visible,
+        }
+    }
+
+    /// The geometry of egui's current input. This is a fallback for callers that do not run
+    /// [`crate::SheetApp::raw_input_hook`] (tests and embedders); native eframe always records the
+    /// fresh [`Self::from_raw_input`] value first, so issuance and drain never fall back here.
+    pub fn current(ctx: &egui::Context) -> Self {
+        let (viewport_id, info, screen_rect, max_texture_side, fallback_ppp) = ctx.input(|i| {
+            let viewport_id = i.raw.viewport_id;
+            let info = i.raw.viewports.get(&viewport_id).cloned().unwrap_or_default();
+            // `screen_rect` from the pass if one supplied it; otherwise egui's retained content
+            // rect (which is only fresh when this is called from a UI pass, never a logic tick).
+            let screen_rect = i.raw.screen_rect.or_else(|| Some(i.viewport_rect()));
+            (viewport_id, info, screen_rect, i.max_texture_side, i.pixels_per_point())
+        });
+        Self::build(viewport_id, &info, screen_rect, Some(max_texture_side), ctx.zoom_factor(), fallback_ppp)
+    }
+
+    /// Physical pixel size the screenshot should have, rounded and capped by the surface limit.
+    /// `None` when the viewport has no positive, finite size (minimized or not laid out yet).
+    pub fn expected_size(&self) -> Option<[usize; 2]> {
+        let viewport = self.viewport?;
+        let ppp = self.pixels_per_point;
+        if !viewport.x.is_finite() || !viewport.y.is_finite() || viewport.x <= 0.0 || viewport.y <= 0.0 {
+            return None;
+        }
+        if !ppp.is_finite() || ppp <= 0.0 {
+            return None;
+        }
+        // An unreported surface limit (0) must not cap every capture to one pixel.
+        let max = if self.max_texture_side == 0 { usize::MAX } else { self.max_texture_side };
+        let axis = |points: f32| -> Option<usize> {
+            let px = (f64::from(points) * f64::from(ppp)).round();
+            if !px.is_finite() || px <= 0.0 || px > usize::MAX as f64 {
+                return None;
+            }
+            Some((px as usize).min(max))
+        };
+        Some([axis(viewport.x)?, axis(viewport.y)?])
+    }
+
+    /// Checked `width * height * 4` bytes for the expected image, capped by the surface limit.
+    pub fn expected_bytes(&self) -> Option<usize> {
+        let [w, h] = self.expected_size()?;
+        w.checked_mul(h)?.checked_mul(4)
+    }
+
+    /// Checked bytes of the largest image [`validate_image`] accepts for this geometry: one
+    /// physical pixel of rounding per axis. Reservations and the slot's per-image bound both use
+    /// this, so the aggregate budget is strict for the bytes actually retained.
+    pub fn retained_bytes(&self) -> Option<usize> {
+        let [w, h] = self.expected_size()?;
+        let w = w.checked_add(1)?;
+        let h = h.checked_add(1)?;
+        w.checked_mul(h)?.checked_mul(4)
+    }
+}
+
+/// True only when both width and height are finite and positive.
+fn positive_size(size: &egui::Vec2) -> bool {
+    size.x.is_finite() && size.y.is_finite() && size.x > 0.0 && size.y > 0.0
+}
+
+/// Conservative worst-case size of the PNG stream for a `bytes`-sized RGBA image with `height`
+/// rows. PNG adds a filter byte per row and zlib framing; uncompressed blocks add a few bytes per
+/// 64 KiB. 1% + 64 KiB plus the row bytes is safely above the real encoder output.
+pub(super) fn png_worst_bytes(bytes: usize, height: usize) -> Option<usize> {
+    bytes.checked_add(bytes / 100)?.checked_add(height.checked_mul(2)?)?.checked_add(64 * 1024)
+}
+
+/// Base64 length (with padding) for `len` bytes.
+pub(super) fn base64_len(len: usize) -> Option<usize> {
+    len.checked_add(2)?.checked_div(3)?.checked_mul(4)
+}
+
+/// Worst transient bytes for encoding one expected capture: the retained `ColorImage` plus the
+/// RGBA copy made from it, then (for base64) the PNG stream and the encoded text. `None` on
+/// overflow. Admission rejects a request whose working set exceeds
+/// [`SCREENSHOT_MAX_ENCODING_BYTES`] before any slot or command exists.
+pub fn encoding_working_bytes(expected: [usize; 2], base64: bool) -> Option<usize> {
+    let [w, h] = expected;
+    let bytes = w.checked_mul(h)?.checked_mul(4)?;
+    let retained_and_copy = bytes.checked_mul(2)?;
+    if !base64 {
+        return Some(retained_and_copy);
+    }
+    let png = png_worst_bytes(bytes, h)?;
+    let encoded = base64_len(png)?;
+    Some(retained_and_copy.max(bytes.checked_add(png)?.checked_add(encoded)?))
+}
+
+/// Reject an expected capture whose encoding working set or base64 reply would exceed the
+/// explicit encoding limits. Checked before admission and again immediately before issuance.
+pub(super) fn check_encoding_budget(expected: [usize; 2], base64: bool) -> Result<(), String> {
+    let [w, h] = expected;
+    let Some(bytes) = w.checked_mul(h).and_then(|p| p.checked_mul(4)) else {
+        return Err("screenshot failed: the window size overflows the screenshot budget".to_string());
+    };
+    let Some(working) = encoding_working_bytes(expected, base64) else {
+        return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
+    };
+    if working > SCREENSHOT_MAX_ENCODING_BYTES {
+        return Err(format!(
+            "screenshot encoding budget exceeded: {working} bytes of transient working memory for one {w}×{h} capture, over the {SCREENSHOT_MAX_ENCODING_BYTES}-byte encoding limit"
+        ));
+    }
+    if base64 {
+        let Some(png) = png_worst_bytes(bytes, h) else {
+            return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
+        };
+        let Some(encoded) = base64_len(png) else {
+            return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
+        };
+        if encoded > SCREENSHOT_MAX_BASE64_BYTES {
+            return Err(format!(
+                "screenshot base64 budget exceeded: the reply for one {w}×{h} capture could be {encoded} bytes, over the {SCREENSHOT_MAX_BASE64_BYTES}-byte base64 limit; request a path instead"
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// Reject a request whose reserved retained bytes plus its encoding working set exceed
+/// [`SCREENSHOT_MAX_PEAK_BYTES`]. `reserved` already includes this request's own reservation.
+pub(super) fn check_peak_budget(reserved: usize, expected: [usize; 2], base64: bool) -> Result<(), String> {
+    let Some(working) = encoding_working_bytes(expected, base64) else {
+        return Err("screenshot failed: the window size overflows the screenshot encoding budget".to_string());
+    };
+    let peak = reserved.saturating_add(working);
+    if peak > SCREENSHOT_MAX_PEAK_BYTES {
+        return Err(format!(
+            "screenshot peak-memory budget exceeded: {reserved} bytes retained plus {working} bytes encoding for one capture is over the {SCREENSHOT_MAX_PEAK_BYTES}-byte peak limit"
+        ));
+    }
+    Ok(())
+}
+
+/// One admitted `ui.screenshot` request. The slot owns the image and its viewport waker; the
+/// callback holds only a weak reference to it and never writes a file or sends a reply.
+pub(super) struct Shot {
+    pub(super) token: u64,
+    pub(super) path: Option<String>,
+    pub(super) reply: Sender<ControlResponse>,
+    /// Monotonic deadline for the whole request, including retries.
+    pub(super) deadline: f64,
+    /// Settle time before the first issuance (the UI must be still).
+    pub(super) ready_at: f64,
+    /// Real (non-discarded) UI passes counted towards settling.
+    pub(super) frames: u32,
+    /// `cumulative_pass_nr` of the last pass counted in `frames`, so repeated `ui` calls in one
+    /// pass count once and a settled frame is never counted twice.
+    pub(super) settle_pass: Option<u64>,
+    pub(super) issued: bool,
+    pub(super) retries: u32,
+    /// Geometry at admission, updated immediately before issuance.
+    pub(super) geometry: CaptureGeometry,
+    /// The viewport this request was admitted for. A callback or slot from another viewport must
+    /// never fill this request.
+    pub(super) viewport_id: egui::ViewportId,
+    /// The active document (`DocState::uid`) at admission. A queued capture is never rebound to a
+    /// document that became active later.
+    pub(super) document: Option<u64>,
+    /// Monotonic geometry epoch at issuance; any later change rejects the image.
+    pub(super) epoch: u64,
+    /// Physical size expected at issuance; `None` while the window has no capturable size.
+    pub(super) expected: Option<[usize; 2]>,
+    /// Bytes reserved from the aggregate budget until the request completes or is dropped. This
+    /// is the largest image the request may retain (one pixel of rounding per axis included) and
+    /// is also the slot's per-image bound.
+    pub(super) bytes: usize,
+    /// Created at issuance (and anew for every retry), never at admission: the bound must match
+    /// the geometry and reservation the command is issued against.
+    pub(super) slot: Option<CaptureSlot>,
+}
+
+#[derive(Default)]
+pub struct Shots {
+    pub(super) token: u64,
+    pub(super) requests: Vec<Shot>,
+}
+
+impl Shots {
+    /// A screenshot was asked for and hasn't been delivered yet: animations hold still, so the
+    /// picture shows the settled state.
+    pub(crate) fn in_flight(&self) -> bool {
+        !self.requests.is_empty()
+    }
+
+    /// Whether a hidden window still needs `RequestPaintWhileHidden` to reach issuance. Only a
+    /// request that is admitted or settling with a capturable size needs a first `ui` pass; once
+    /// `issue_screenshots` has sent the `Screenshot` command, that command's own `wants_paint`
+    /// paints the hidden window. A minimized request has no capturable size, so requesting hidden
+    /// full frames for its whole wait cannot make progress (the restore pass issues it).
+    pub(crate) fn needs_hidden_paint(&self) -> bool {
+        self.requests.iter().any(|r| !r.issued && r.expected.is_some())
+    }
+
+    /// Bytes currently reserved by admitted requests.
+    pub(super) fn reserved(&self) -> usize {
+        self.requests.iter().fold(0usize, |sum, r| sum.saturating_add(r.bytes))
+    }
+
+    /// Drop every outstanding request without a reply (app shutdown): callbacks become inert.
+    pub fn cancel_all(&mut self) {
+        for request in self.requests.drain(..) {
+            if let Some(slot) = request.slot {
+                slot.cancel();
+            }
+        }
+    }
+}
+
+/// Sends one screenshot rejection carrying the request token.
+pub(super) fn reject_shot(reply: Sender<ControlResponse>, token: u64, message: impl std::fmt::Display) {
+    let _ = reply.send(json!({"ok": false, "error": message.to_string(), "request": token}));
+}
+
+/// The geometry to use for admission, issuance and drain.
+///
+/// Native eframe calls [`crate::SheetApp::raw_input_hook`] before every frame (including a
+/// logic-only tick), so the recorded value carries fresh `RawInput` geometry even when egui's
+/// last UI pass is stale. Tests and embedders that never call the hook fall back to egui's current
+/// input; that fallback is only used when no raw frame was seen.
+pub(crate) fn current_capture_geometry(app: &SheetApp, ctx: &egui::Context) -> CaptureGeometry {
+    if app.capture_geometry_from_raw { app.capture_geometry.unwrap_or_else(|| CaptureGeometry::current(ctx)) } else { CaptureGeometry::current(ctx) }
+}
+
+/// Record `geometry` as the layout captures are bound to and bump the epoch when it differs.
+///
+/// Issuance and drain use this instead of writing the fields separately: during a hidden
+/// logic-only tick the viewport info can be newer than the last UI pass, and the epoch must
+/// change together with the geometry or a valid image would be retried against its own epoch.
+pub(crate) fn note_capture_geometry(app: &mut SheetApp, geometry: CaptureGeometry) -> u64 {
+    if app.capture_geometry != Some(geometry) {
+        app.capture_geometry = Some(geometry);
+        app.capture_epoch = app.capture_epoch.wrapping_add(1);
+    }
+    app.capture_epoch
+}
+
+/// The bytes to reserve for one capture of `expected` against `geometry`, after checking the
+/// applicable limits. Issuance and retry both use this (admission keeps its own inline checks) so a
+/// retry cannot drift from the limits the first issuance applied. `expected` is `None` when the
+/// viewport has no capturable size yet: that reserves [`UNKNOWN_CAPTURE_BYTES`] and still checks
+/// the aggregate limit, while the per-image, encoding and peak checks only apply once a size is
+/// known.
+fn capture_bytes(app: &SheetApp, i: usize, geometry: CaptureGeometry, expected: Option<[usize; 2]>, base64: bool) -> Result<usize, String> {
+    let bytes = match expected {
+        Some(expected) => {
+            let bytes = geometry.retained_bytes().ok_or_else(|| "screenshot failed: the window size overflows the screenshot budget".to_string())?;
+            if bytes > SCREENSHOT_MAX_IMAGE_BYTES {
+                return Err(format!(
+                    "screenshot budget exceeded: {bytes} bytes for one {}×{} image, over the {SCREENSHOT_MAX_IMAGE_BYTES}-byte per-image limit",
+                    expected[0], expected[1]
+                ));
+            }
+            check_encoding_budget(expected, base64)?;
+            bytes
+        }
+        None => UNKNOWN_CAPTURE_BYTES,
+    };
+    let others = app.shots.requests.iter().enumerate().filter(|(j, _)| *j != i).fold(0usize, |sum, (_, r)| sum.saturating_add(r.bytes));
+    if others.saturating_add(bytes) > SCREENSHOT_MAX_AGGREGATE_BYTES {
+        return Err(format!(
+            "screenshot budget exceeded: {bytes} bytes for this image would exceed the {SCREENSHOT_MAX_AGGREGATE_BYTES}-byte aggregate limit"
+        ));
+    }
+    if let Some(expected) = expected {
+        check_peak_budget(others.saturating_add(bytes), expected, base64)?;
+    }
+    Ok(bytes)
+}
+
+/// Issued from `ui`: counts one real (non-discarded) settling pass per request, revalidates the
+/// geometry and reserves the exact retained bytes, then sends one
+/// `ViewportCommand::Screenshot(callback)` per request.
+///
+/// The slot is created here, not at admission. Its per-image bound is the same reservation the
+/// aggregate budget holds, so an image that would exceed the budget cannot be retained; a retry
+/// after a resize creates a fresh slot for the new geometry.
+pub fn issue_screenshots(app: &mut SheetApp, ctx: &egui::Context) {
+    let now = crate::monotonic_ms();
+    let pass = ctx.cumulative_pass_nr();
+    // A pass whose output is already going to be discarded is not a settling frame and its
+    // layout is not the one to capture. GridCraft requests no discard after this call.
+    let discard = ctx.will_discard();
+    let active_document = app.session.active().map(|d| d.uid);
+    let current_viewport = ctx.viewport_id();
+    let len = app.shots.requests.len();
+    let mut failures: Vec<(usize, String)> = Vec::new();
+    for i in 0..len {
+        let (issued, ready_at, settle_pass) = {
+            let r = &app.shots.requests[i];
+            (r.issued, r.ready_at, r.settle_pass)
+        };
+        if issued || discard || settle_pass == Some(pass) {
+            continue;
+        }
+        // One count per egui pass, however many times this `ui` runs in it.
+        let frames = {
+            let r = &mut app.shots.requests[i];
+            r.settle_pass = Some(pass);
+            r.frames = r.frames.saturating_add(1);
+            r.frames
+        };
+        if now < ready_at || frames < 3 {
+            continue;
+        }
+        // A queued capture belongs to the document and viewport it was admitted for. A switch
+        // before issuance is reported once and never rebound to the new document.
+        let (viewport_id, document, base64) = {
+            let r = &app.shots.requests[i];
+            (r.viewport_id, r.document, r.path.is_none())
+        };
+        if viewport_id != current_viewport {
+            failures.push((i, SCREENSHOT_VIEWPORT_CHANGED.into()));
+            continue;
+        }
+        if document != active_document {
+            failures.push((i, SCREENSHOT_DOCUMENT_CHANGED.into()));
+            continue;
+        }
+        let current = current_capture_geometry(app, ctx);
+        let Some(expected) = current.expected_size() else {
+            // Still minimized or not laid out: keep the request queued and try again on a later
+            // real pass; `drain_screenshots` reports the size-specific timeout if none arrives.
+            app.shots.requests[i].expected = None;
+            continue;
+        };
+        let bytes = match capture_bytes(app, i, current, Some(expected), base64) {
+            Ok(bytes) => bytes,
+            Err(message) => {
+                failures.push((i, message));
+                continue;
+            }
+        };
+        // Update the geometry and its epoch together, so the drain accepts exactly the layout the
+        // capture is issued against even when a hidden logic tick already saw the new viewport.
+        let epoch = note_capture_geometry(app, current);
+        let r = &mut app.shots.requests[i];
+        r.geometry = current;
+        r.expected = Some(expected);
+        r.bytes = bytes;
+        r.epoch = epoch;
+        if let Some(old) = r.slot.take() {
+            old.cancel();
+        }
+        let (slot, callback) = CaptureSlot::new(ctx, viewport_id, bytes);
+        r.slot = Some(slot);
+        ctx.send_viewport_cmd_to(viewport_id, egui::ViewportCommand::Screenshot(callback));
+        r.issued = true;
+    }
+    for (i, message) in failures.into_iter().rev() {
+        reject_shot_at(app, i, message);
+    }
+    if app.shots.in_flight() {
+        ctx.request_repaint_after(std::time::Duration::from_millis(16));
+    }
+}
+
+/// Checks that the image has the pixel count its dimensions imply, is within one pixel of the expected size on each axis, and keeps the expected aspect ratio within that rounding.
+pub(super) fn validate_image(image: &egui::ColorImage, expected: [usize; 2]) -> Result<(), String> {
+    let [w, h] = image.size;
+    let [ew, eh] = expected;
+    let pixels = w.checked_mul(h).ok_or_else(|| "screenshot dimensions overflow".to_string())?;
+    if image.pixels.len() != pixels {
+        return Err(format!("screenshot has {} pixels for its {w}×{h} dimensions", image.pixels.len()));
+    }
+    // Allow one physical pixel of rounding per axis, but not independent distortion: an image
+    // that is one pixel wider and one pixel shorter has a different aspect and cannot be the
+    // recorded viewport. Rejecting it forces the retry/timeout path instead of saving skewed pixels.
+    if w.abs_diff(ew) > 1 || h.abs_diff(eh) > 1 {
+        return Err(format!("screenshot is {w}×{h} pixels, expected {ew}×{eh}: the window changed size while it was captured"));
+    }
+    // Keep the returned scale's aspect within the rounding error of the recorded logical viewport.
+    let cross = w.checked_mul(eh).and_then(|a| h.checked_mul(ew).map(|b| a.abs_diff(b)));
+    let Some(cross) = cross else {
+        return Err("screenshot dimensions overflow the aspect check".to_string());
+    };
+    if cross > ew.max(eh) {
+        return Err(format!("screenshot is {w}×{h} pixels, expected {ew}×{eh}: the aspect ratio changed while it was captured"));
+    }
+    Ok(())
+}
+
+/// What [`drain_screenshots`] must do with one request after inspecting it.
+enum DrainAction {
+    /// Still waiting; leave the request at the same index.
+    Keep,
+    /// Answer the request with this reply and remove it.
+    Remove(Json),
+    /// Re-arm the request for a fresh capture within its retry budget.
+    Restart,
+}
+
+/// Called from `logic`: takes each completed slot once, validates identity, size, geometry/epoch
+/// and **deadline** and only then encodes, writes and replies outside the slot. A stale, oversized
+/// or late image is dropped without writing a file.
+pub fn drain_screenshots(app: &mut SheetApp, ctx: &egui::Context) {
+    let now = crate::monotonic_ms();
+    let current_geometry = current_capture_geometry(app, ctx);
+    let epoch = note_capture_geometry(app, current_geometry);
+    let active_document = app.session.active().map(|d| d.uid);
+    let current_viewport = ctx.viewport_id();
+    let mut i = 0;
+    while i < app.shots.requests.len() {
+        match drain_action(app, i, now, current_geometry, epoch, active_document, current_viewport) {
+            DrainAction::Keep => i += 1,
+            DrainAction::Remove(reply) => finish_shot(app, i, reply),
+            DrainAction::Restart => match retry_capture(app, i, current_geometry, epoch, now) {
+                Ok(()) => i += 1,
+                Err(message) => reject_shot_at(app, i, message),
+            },
+        }
+    }
+    if app.shots.in_flight() {
+        ctx.request_repaint_after(std::time::Duration::from_millis(16));
+    }
+}
+
+/// Validates one request and decides whether it stays queued, is answered or is re-armed.
+fn drain_action(
+    app: &mut SheetApp,
+    i: usize,
+    now: f64,
+    current_geometry: CaptureGeometry,
+    epoch: u64,
+    active_document: Option<u64>,
+    current_viewport: egui::ViewportId,
+) -> DrainAction {
+    let r = &mut app.shots.requests[i];
+    // A document or viewport change is a definitive mismatch: cancel once, never retry and
+    // never write the pixels against the new identity.
+    if r.viewport_id != current_viewport {
+        cancel_shot(r);
+        return DrainAction::Remove(json!({"ok": false, "error": SCREENSHOT_VIEWPORT_CHANGED}));
+    }
+    if r.document != active_document {
+        cancel_shot(r);
+        return DrainAction::Remove(json!({"ok": false, "error": SCREENSHOT_DOCUMENT_CHANGED}));
+    }
+    if !r.issued {
+        return drain_unissued(r, now);
+    }
+    drain_completion(r, now, current_geometry, epoch)
+}
+
+/// A request that never issued a capture: keep waiting, or report the timeout that fits whether
+/// the window ever had a capturable size.
+fn drain_unissued(r: &mut Shot, now: f64) -> DrainAction {
+    if now < r.deadline {
+        return DrainAction::Keep;
+    }
+    cancel_shot(r);
+    let message = if r.expected.is_none() {
+        "screenshot timeout: the window never reported a capturable size (it may be minimized or not laid out)"
+    } else {
+        "no frame was presented before the screenshot timeout"
+    };
+    DrainAction::Remove(timeout_reply(message, r.token))
+}
+
+/// A request that issued a capture: inspect its slot once, then apply the deadline, validation
+/// and geometry checks in the same order as issuance.
+fn drain_completion(r: &mut Shot, now: f64, current_geometry: CaptureGeometry, epoch: u64) -> DrainAction {
+    match r.slot.as_ref().and_then(|slot| slot.take()) {
+        // A completion that arrives past the deadline is late even if the pixels are valid: the
+        // client was promised one answer within the deadline, so nothing is written for it.
+        Some(result) if now >= r.deadline => {
+            drop(result);
+            DrainAction::Remove(timeout_reply("screenshot timeout: the image completed after its deadline; no file was written", r.token))
+        }
+        Some(Ok(image)) => drain_image(r, image, now, current_geometry, epoch),
+        // The slot refused the image before `validate_image` saw it: an image larger than the
+        // reservation is as much evidence of a resize as a smaller one. Retry within the same
+        // bounded budget instead of failing only when the window grew. A non-resize fault still
+        // exhausts the retries and reports the slot's error, so this stays fail-closed.
+        Some(Err(_)) if retry_allowed(r, now) => DrainAction::Restart,
+        Some(Err(e)) => DrainAction::Remove(json!({"ok": false, "error": e.to_string()})),
+        None if now >= r.deadline => {
+            cancel_shot(r);
+            DrainAction::Remove(timeout_reply("no frame was presented before the screenshot timeout", r.token))
+        }
+        None => DrainAction::Keep,
+    }
+}
+
+/// Validates a completed image against the size recorded at issuance and the current
+/// geometry/epoch; only a valid image is saved, and only a retry that is still inside the
+/// request's deadline and retry budget gets a fresh attempt.
+fn drain_image(r: &mut Shot, image: std::sync::Arc<egui::ColorImage>, now: f64, current_geometry: CaptureGeometry, epoch: u64) -> DrainAction {
+    let validated = match r.expected {
+        Some(expected) => validate_image(&image, expected),
+        None => Err("screenshot has no expected size".to_string()),
+    };
+    match validated {
+        Err(_) if retry_allowed(r, now) => {
+            drop(image);
+            DrainAction::Restart
+        }
+        Err(message) => DrainAction::Remove(json!({"ok": false, "error": message})),
+        Ok(()) if epoch != r.epoch || current_geometry != r.geometry => {
+            if !retry_allowed(r, now) {
+                return DrainAction::Remove(json!({
+                    "ok": false,
+                    "error": "screenshot geometry changed while it was captured; no image was written"
+                }));
+            }
+            drop(image);
+            DrainAction::Restart
+        }
+        Ok(()) => DrainAction::Remove(save_image(image, r.path.as_deref())),
+    }
+}
+
+/// Whether this request may take another capture: both limits are fixed for the whole request.
+fn retry_allowed(r: &Shot, now: f64) -> bool {
+    r.retries < SCREENSHOT_MAX_RETRIES && now < r.deadline
+}
+
+/// Takes and cancels the request's capture slot, if it has one.
+fn cancel_shot(r: &mut Shot) {
+    if let Some(slot) = r.slot.take() {
+        slot.cancel();
+    }
+}
+
+/// Remove request `i`, cancel its slot and answer it once with a token-carrying reply.
+fn finish_shot(app: &mut SheetApp, i: usize, reply: Json) {
+    let request = app.shots.requests.remove(i);
+    if let Some(slot) = request.slot {
+        slot.cancel();
+    }
+    let _ = request.reply.send(with_token(reply, request.token));
+}
+
+/// Remove request `i`, cancel its slot and reject it with `message`.
+fn reject_shot_at(app: &mut SheetApp, i: usize, message: impl std::fmt::Display) {
+    let request = app.shots.requests.remove(i);
+    if let Some(slot) = request.slot {
+        slot.cancel();
+    }
+    reject_shot(request.reply, request.token, message);
+}
+
+/// Re-arm one request for a fresh issuance against `geometry`: a new reservation (the maximum
+/// retained image, or [`UNKNOWN_CAPTURE_BYTES`] while there is no size), a new epoch and no slot.
+/// A fresh slot and callback are created by [`issue_screenshots`]; the old image was dropped by
+/// the caller.
+fn retry_capture(app: &mut SheetApp, i: usize, geometry: CaptureGeometry, epoch: u64, now: f64) -> Result<(), String> {
+    let expected = geometry.expected_size();
+    let base64 = app.shots.requests.get(i).is_some_and(|r| r.path.is_none());
+    let bytes = capture_bytes(app, i, geometry, expected, base64)?;
+    let r = &mut app.shots.requests[i];
+    r.retries = r.retries.saturating_add(1);
+    r.issued = false;
+    r.frames = 3;
+    r.settle_pass = None;
+    r.ready_at = now;
+    r.expected = expected;
+    r.bytes = bytes;
+    r.geometry = geometry;
+    r.epoch = epoch;
+    if let Some(slot) = r.slot.take() {
+        slot.cancel();
+    }
+    Ok(())
+}
+
+/// Encodes a screenshot as PNG to `path`, or returns it as base64.
+///
+/// The retained `ColorImage` is released before encoding, and a path capture streams the PNG
+/// straight to the file. A base64 reply is length-checked against
+/// [`SCREENSHOT_MAX_BASE64_BYTES`] *before* the string is allocated, so one admitted capture cannot
+/// retain an unbounded reply alongside its image.
+pub fn save_image(image: std::sync::Arc<egui::ColorImage>, path: Option<&str>) -> Json {
+    use image::ImageEncoder as _;
+    let [w, h] = image.size;
+    let Some(capacity) = w.checked_mul(h).and_then(|p| p.checked_mul(4)) else { return json!({"ok": false, "error": "bad image"}) };
+    if image.pixels.len().checked_mul(4) != Some(capacity) {
+        return json!({"ok": false, "error": "bad image"});
+    }
+    let (Ok(width), Ok(height)) = (u32::try_from(w), u32::try_from(h)) else { return json!({"ok": false, "error": "bad image"}) };
+    // One RGBA copy is unavoidable with the `image` encoder API. Drop the retained image before
+    // encoding so the peak is the copy plus encoder buffers, not both images plus the PNG stream.
+    let mut rgba = Vec::with_capacity(capacity);
+    for p in &image.pixels {
+        rgba.extend_from_slice(&p.to_array());
+    }
+    drop(image);
+    match path {
+        Some(p) => match std::fs::File::create(p) {
+            Ok(file) => {
+                let encoder = image::codecs::png::PngEncoder::new(file);
+                match encoder.write_image(&rgba, width, height, image::ExtendedColorType::Rgba8) {
+                    Ok(()) => json!({"ok": true, "result": {"path": p, "width": w, "height": h}}),
+                    Err(e) => {
+                        // Do not leave a truncated PNG behind.
+                        let _ = std::fs::remove_file(p);
+                        json!({"ok": false, "error": e.to_string()})
+                    }
+                }
+            }
+            Err(e) => json!({"ok": false, "error": e.to_string()}),
+        },
+        None => {
+            let mut png = Vec::new();
+            let encoder = image::codecs::png::PngEncoder::new(&mut png);
+            if let Err(e) = encoder.write_image(&rgba, width, height, image::ExtendedColorType::Rgba8) {
+                return json!({"ok": false, "error": e.to_string()});
+            }
+            let Some(encoded_len) = base64_len(png.len()) else {
+                return json!({"ok": false, "error": "screenshot base64 length overflow"});
+            };
+            if encoded_len > SCREENSHOT_MAX_BASE64_BYTES {
+                return json!({
+                    "ok": false,
+                    "error": format!(
+                        "screenshot base64 budget exceeded: the {w}×{h} reply would be {encoded_len} bytes, over the {SCREENSHOT_MAX_BASE64_BYTES}-byte base64 limit; request a path instead"
+                    )
+                });
+            }
+            json!({"ok": true, "result": {"base64": gridcraft_engine::io::base64_encode(&png), "width": w, "height": h}})
+        }
+    }
+}
diff --git a/crates/ui-egui/src/control/synthetic.rs b/crates/ui-egui/src/control/synthetic.rs
new file mode 100644
index 000000000..a169cba64
--- /dev/null
+++ b/crates/ui-egui/src/control/synthetic.rs
@@ -0,0 +1,145 @@
+use super::*;
+
+pub(super) fn key_from(name: &str) -> Option<egui::Key> {
+    egui::Key::from_name(name).or(match name.to_ascii_lowercase().as_str() {
+        "enter" | "return" => Some(egui::Key::Enter),
+        "esc" | "escape" => Some(egui::Key::Escape),
+        "delete" | "del" => Some(egui::Key::Delete),
+        "backspace" => Some(egui::Key::Backspace),
+        "left" => Some(egui::Key::ArrowLeft),
+        "right" => Some(egui::Key::ArrowRight),
+        "up" => Some(egui::Key::ArrowUp),
+        "down" => Some(egui::Key::ArrowDown),
+        "space" => Some(egui::Key::Space),
+        "tab" => Some(egui::Key::Tab),
+        "pageup" => Some(egui::Key::PageUp),
+        "pagedown" => Some(egui::Key::PageDown),
+        "home" => Some(egui::Key::Home),
+        "end" => Some(egui::Key::End),
+        "f2" => Some(egui::Key::F2),
+        "f4" => Some(egui::Key::F4),
+        "f9" => Some(egui::Key::F9),
+        _ => None,
+    })
+}
+
+pub(super) fn modifiers(p: &Json) -> egui::Modifiers {
+    let b = |n: &str| p.get(n).and_then(Json::as_bool).unwrap_or(false);
+    egui::Modifiers {
+        alt: b("alt"),
+        ctrl: b("ctrl"),
+        shift: b("shift"),
+        mac_cmd: b("cmd") && cfg!(target_os = "macos"),
+        command: b("cmd") || (b("ctrl") && !cfg!(target_os = "macos")),
+    }
+}
+
+pub(super) fn cell_center(app: &SheetApp, c: CellRef) -> Option<egui::Pos2> {
+    let d = app.session.active()?;
+    let sh = d.wb.active()?;
+    let rect = app.grid.rect?;
+    let geo = crate::grid::Geo::new(sh, rect, app.view().scroll);
+    Some(geo.screen_cell_rect(sh, c).center())
+}
+
+/// Most synthetic events (pointer, key, text and move alike) a control client may keep queued at
+/// once. The queue offers one batch per UI pass, and a hidden logic-only frame keeps the same
+/// batch unapplied, so every producer must honour this budget.
+pub const MAX_QUEUED_SYNTHETIC_EVENTS: usize = 10_000;
+
+/// Most bytes of synthetic input queued at once: the `Event` storage plus every text payload.
+pub const MAX_QUEUED_SYNTHETIC_BYTES: usize = 8 * 1024 * 1024;
+
+/// Largest single `ui.text` string accepted (well below the control line limit; one paste-sized
+/// string is plenty for a spreadsheet cell and keeps a burst from exhausting memory).
+pub const MAX_SYNTHETIC_TEXT_BYTES: usize = 1024 * 1024;
+
+/// Bytes charged to one synthetic event: `size_of::<Event>()` plus the payload of a `Text` event.
+fn event_bytes(event: &egui::Event) -> usize {
+    std::mem::size_of::<egui::Event>()
+        + match event {
+            egui::Event::Text(text) => text.len(),
+            _ => 0,
+        }
+}
+
+/// Saturating totals of queued synthetic events and their charged bytes across every pending batch.
+fn synthetic_usage(app: &SheetApp) -> (usize, usize) {
+    app.synthetic
+        .iter()
+        .flat_map(|batch| batch.iter())
+        .fold((0usize, 0usize), |(events, bytes), event| (events.saturating_add(1), bytes.saturating_add(event_bytes(event))))
+}
+
+/// Refuses a request that would push the queued synthetic input past either limit; the queue is
+/// left unchanged.
+fn synthetic_budget(app: &SheetApp, extra_events: usize, extra_bytes: usize) -> Result<(), String> {
+    let (events, bytes) = synthetic_usage(app);
+    if events.saturating_add(extra_events) > MAX_QUEUED_SYNTHETIC_EVENTS {
+        return Err(format!("too many synthetic input events (limit {MAX_QUEUED_SYNTHETIC_EVENTS} queued at once)"));
+    }
+    if bytes.saturating_add(extra_bytes) > MAX_QUEUED_SYNTHETIC_BYTES {
+        return Err(format!("synthetic input exceeds the {MAX_QUEUED_SYNTHETIC_BYTES}-byte queue limit"));
+    }
+    Ok(())
+}
+
+/// Checks the synthetic-event budget, then queues one pointer move followed by `count` press/release pairs (`count` is at least one).
+pub(super) fn push_click(app: &mut SheetApp, pos: egui::Pos2, button: egui::PointerButton, count: u32, m: egui::Modifiers) -> Result<(), String> {
+    let count = count.max(1) as usize;
+    let events = count.saturating_mul(2).saturating_add(1);
+    synthetic_budget(app, events, events.saturating_mul(std::mem::size_of::<egui::Event>()))?;
+    app.synthetic.push_back(vec![egui::Event::PointerMoved(pos)]);
+    let mut batch = Vec::with_capacity(count * 2);
+    for _ in 0..count {
+        batch.push(egui::Event::PointerButton { pos, button, pressed: true, modifiers: m });
+        batch.push(egui::Event::PointerButton { pos, button, pressed: false, modifiers: m });
+    }
+    app.synthetic.push_back(batch);
+    Ok(())
+}
+
+/// Checks the synthetic-event budget, then queues a move, a press, `steps` interpolated moves and a release.
+pub(super) fn push_drag(app: &mut SheetApp, a: egui::Pos2, b: egui::Pos2, steps: usize, m: egui::Modifiers) -> Result<(), String> {
+    let steps = steps.max(1);
+    let events = steps.saturating_add(3);
+    synthetic_budget(app, events, events.saturating_mul(std::mem::size_of::<egui::Event>()))?;
+    app.synthetic.push_back(vec![egui::Event::PointerMoved(a)]);
+    app.synthetic.push_back(vec![egui::Event::PointerButton { pos: a, button: egui::PointerButton::Primary, pressed: true, modifiers: m }]);
+    for i in 1..=steps {
+        let t = i as f32 / steps as f32;
+        app.synthetic.push_back(vec![egui::Event::PointerMoved(a + (b - a) * t)]);
+    }
+    app.synthetic.push_back(vec![egui::Event::PointerButton { pos: b, button: egui::PointerButton::Primary, pressed: false, modifiers: m }]);
+    Ok(())
+}
+
+/// Checks the synthetic-event budget and queues one key press/release pair.
+pub(super) fn push_key(app: &mut SheetApp, key: egui::Key, m: egui::Modifiers) -> Result<(), String> {
+    let events = 2;
+    synthetic_budget(app, events, events * std::mem::size_of::<egui::Event>())?;
+    app.synthetic.push_back(vec![
+        egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: m },
+        egui::Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers: m },
+    ]);
+    Ok(())
+}
+
+/// Rejects text longer than `MAX_SYNTHETIC_TEXT_BYTES`, then queues one `Text` event under the shared queue budget.
+pub(super) fn push_text(app: &mut SheetApp, text: String) -> Result<(), String> {
+    if text.len() > MAX_SYNTHETIC_TEXT_BYTES {
+        return Err(format!("text input is {} bytes, over the {MAX_SYNTHETIC_TEXT_BYTES}-byte limit for one event", text.len()));
+    }
+    let event = egui::Event::Text(text);
+    synthetic_budget(app, 1, event_bytes(&event))?;
+    app.synthetic.push_back(vec![event]);
+    Ok(())
+}
+
+/// Queues one pointer-move event under the shared synthetic queue budget.
+pub(super) fn push_move(app: &mut SheetApp, pos: egui::Pos2) -> Result<(), String> {
+    let event = egui::Event::PointerMoved(pos);
+    synthetic_budget(app, 1, event_bytes(&event))?;
+    app.synthetic.push_back(vec![event]);
+    Ok(())
+}

From 6b743e4622caff955ffb149926e36f6b77da8629 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 19:48:31 +0000
Subject: [PATCH 71/76] refactor(ui-egui): move backstage.rs items to
 backstage/

---
 crates/ui-egui/src/backstage.rs         | 349 +-----------------------
 crates/ui-egui/src/backstage/options.rs | 178 ++++++++++++
 crates/ui-egui/src/backstage/print.rs   | 168 ++++++++++++
 3 files changed, 352 insertions(+), 343 deletions(-)
 create mode 100644 crates/ui-egui/src/backstage/options.rs
 create mode 100644 crates/ui-egui/src/backstage/print.rs

diff --git a/crates/ui-egui/src/backstage.rs b/crates/ui-egui/src/backstage.rs
index f17d476ef..3f8706dec 100644
--- a/crates/ui-egui/src/backstage.rs
+++ b/crates/ui-egui/src/backstage.rs
@@ -20,6 +20,12 @@ use crate::i18n::{self, Language};
 use crate::icons::{self, Icon};
 use crate::theme::{self, Tokens};
 
+mod options;
+mod print;
+
+use options::{options, platform};
+use print::print;
+
 /// Width of the navigation column.
 const NAV_W: f32 = 196.0;
 /// Width of the content column (pages are left-aligned like a document, not stretched).
@@ -704,172 +710,6 @@ fn save_as(app: &mut SheetApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcom
     dim(ui, lang.tr("A CSV file, web page or PDF is a copy: the workbook keeps its own file."));
 }
 
-/// Builds the print scope and fit-to-page parameters, caches `file.printPreview` per document revision/options, and draws page thumbnails with navigation plus the print settings and Print action.
-fn print(app: &mut SheetApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcome) {
-    let t = Tokens::get(ui.ctx());
-    let lang = app.ui.language;
-    let Some((uid, revision)) = app.session.active().map(|d| (d.uid, d.revision)) else {
-        dim(ui, lang.tr("No workbook is open."));
-        return;
-    };
-    let mut params = json!({"sheets": if bs.print_all { "all" } else { "active" }});
-    if bs.fit_to_page {
-        params["fitToPage"] = json!(true);
-    }
-    let key = (uid, revision, bs.print_all, bs.fit_to_page);
-    if bs.preview.as_ref().is_none_or(|(k, _)| *k != key) {
-        let preview = app.session.run("file.printPreview", params.clone()).unwrap_or(Json::Null);
-        bs.preview = Some((key, preview));
-    }
-    let pages: Vec<Json> = bs.preview.as_ref().and_then(|(_, p)| p.get("pageList")).and_then(Json::as_array).cloned().unwrap_or_default();
-    ui.horizontal_top(|ui| {
-        ui.vertical(|ui| {
-            ui.set_width(250.0);
-            if let Some(discover) = &app.services.printers {
-                crate::printing::show(&mut app.printing, ui, discover, |label| lang.tr(label).to_owned());
-            }
-            let can_print = app.services.print_native.is_none() || app.printing.ready();
-            if ui.add_enabled_ui(can_print, |ui| square_button(ui, Icon::Print, lang.tr("Print"))).inner.clicked()
-                && app.commit_edit(0, 0, false, false)
-            {
-                app.print_now(params.clone());
-                out.close = app.services.print_native.is_none();
-            }
-            ui.add_space(16.0);
-            let scope = if bs.print_all { "Print Entire Workbook" } else { "Print Active Sheets" };
-            egui::ComboBox::from_id_salt("backstage_print_scope")
-                .width(230.0)
-                .selected_text(lang.tr(scope))
-                .show_ui(ui, |ui| {
-                    for (all, label) in [(false, "Print Active Sheets"), (true, "Print Entire Workbook")] {
-                        if ui.selectable_label(bs.print_all == all, lang.tr(label)).clicked() {
-                            bs.print_all = all;
-                            bs.preview_page = 0;
-                        }
-                    }
-                })
-                .response
-                .accessible_name(lang.tr("Print What"));
-            ui.add_space(8.0);
-            if ui.checkbox(&mut bs.fit_to_page, lang.tr("Fit Sheet on One Page")).changed() {
-                bs.preview_page = 0;
-            }
-            ui.add_space(8.0);
-            if ui.link(lang.tr("Page Setup…")).clicked() {
-                app.open_dialog("pageSetup", json!({}));
-            }
-        });
-        ui.add_space(24.0);
-        ui.vertical(|ui| {
-            if pages.is_empty() {
-                dim(ui, lang.tr("Nothing to print."));
-                return;
-            }
-            let last = pages.len().saturating_sub(1);
-            bs.preview_page = bs.preview_page.min(last);
-            let Some(page) = pages.get(bs.preview_page) else { return };
-            // Paper proportions from the preview (points); hostile sizes fall back to Letter.
-            let w = page.get("width").and_then(Json::as_f64).filter(|w| w.is_finite() && *w > 1.0).unwrap_or(612.0) as f32;
-            let h = page.get("height").and_then(Json::as_f64).filter(|h| h.is_finite() && *h > 1.0).unwrap_or(792.0) as f32;
-            let scale = (520.0 / h).min(440.0 / w);
-            let (rect, _) = ui.allocate_exact_size(vec2(w * scale, h * scale), Sense::hover());
-            let p = ui.painter();
-            p.rect_filled(rect.translate(vec2(2.0, 3.0)), 2.0, t.shadow);
-            p.rect_filled(rect, 2.0, t.grid_bg);
-            p.rect_stroke(rect, 2.0, Stroke::new(1.0, t.ribbon_border), StrokeKind::Inside);
-            if let Some(d) = app.session.active() {
-                paint_page(p, rect, w, page, &d.wb, &t);
-            }
-            let sheet = page.get("sheet").and_then(Json::as_str).unwrap_or("");
-            let range = page.get("range").and_then(Json::as_str).unwrap_or("");
-            ui.add_space(4.0);
-            dim(ui, &format!("{sheet} · {range}"));
-            ui.add_space(8.0);
-            ui.horizontal(|ui| {
-                if ui.add_enabled(bs.preview_page > 0, egui::Button::new("◀")).on_hover_text(lang.tr("Previous page")).clicked() {
-                    bs.preview_page = bs.preview_page.saturating_sub(1);
-                }
-                let text = lang
-                    .tr("Page {page} of {pages}")
-                    .replace("{page}", &(bs.preview_page + 1).to_string())
-                    .replace("{pages}", &pages.len().to_string());
-                ui.label(text);
-                if ui.add_enabled(bs.preview_page < last, egui::Button::new("▶")).on_hover_text(lang.tr("Next page")).clicked() {
-                    bs.preview_page = (bs.preview_page + 1).min(last);
-                }
-            });
-        });
-    });
-}
-
-/// Most rows and columns one preview page draws (a page holds far fewer at any readable scale).
-const PREVIEW_ROWS: u32 = 200;
-const PREVIEW_COLS: u32 = 60;
-
-/// Draws one printed page in miniature: the cells' displayed text at the page's print scale,
-/// inside the sheet's margins. `paper_w` is the page width in points.
-fn paint_page(p: &egui::Painter, rect: Rect, paper_w: f32, page: &Json, wb: &gridcraft_engine::model::Workbook, t: &Tokens) {
-    let Some(range) = page.get("range").and_then(Json::as_str).and_then(gridcraft_engine::core::RangeRef::parse) else { return };
-    let Some(sh) = page.get("sheet").and_then(Json::as_str).and_then(|n| wb.sheet_index(n)).and_then(|i| wb.sheets.get(i)) else { return };
-    // Preview pixels per point, and per sheet pixel (sheet geometry is 96 dpi: 0.75 pt per pixel).
-    let per_pt = rect.width() / paper_w;
-    let print_scale =
-        page.get("scale").and_then(Json::as_f64).filter(|s| s.is_finite() && *s > 0.0).map_or(1.0, |s| (s / 100.0) as f32).clamp(0.1, 4.0);
-    let per_px = per_pt * 0.75 * print_scale;
-    let margin =
-        |i: usize, default: f32| sh.print.margins.get(i).copied().filter(|m| m.is_finite()).unwrap_or(default).clamp(0.0, 3.0) * 72.0 * per_pt;
-    let body = Rect::from_min_max(
-        pos2(rect.left() + margin(0, 0.7), rect.top() + margin(2, 0.75)),
-        pos2(rect.right() - margin(1, 0.7), rect.bottom() - margin(3, 0.75)),
-    );
-    if !body.is_positive() {
-        return;
-    }
-    let font = theme::ui_font((11.0 * per_pt * print_scale).clamp(3.0, 14.0));
-    let last_row = range.end.row.min(range.start.row.saturating_add(PREVIEW_ROWS));
-    let last_col = range.end.col.min(range.start.col.saturating_add(PREVIEW_COLS));
-    let mut y = body.top();
-    for row in range.start.row..=last_row {
-        let h = sh.row_height(row) * per_px;
-        if h <= 0.0 {
-            continue;
-        }
-        if y >= body.bottom() {
-            break;
-        }
-        let mut x = body.left();
-        for col in range.start.col..=last_col {
-            let w = sh.col_width(col) * per_px;
-            if w <= 0.0 {
-                continue;
-            }
-            if x >= body.right() {
-                break;
-            }
-            let cell = gridcraft_engine::core::CellRef::new(row, col);
-            let text = gridcraft_engine::display::cell_text(wb, sh, cell);
-            if !text.is_empty() {
-                let numeric = sh.value(cell).as_f64().is_some();
-                // Text runs on over empty neighbours, as on the sheet; numbers stay in their cell.
-                let mut span = w;
-                if !numeric {
-                    let mut next = col.saturating_add(1);
-                    while next <= last_col && x + span < body.right() && sh.value(gridcraft_engine::core::CellRef::new(row, next)).is_empty() {
-                        span += sh.col_width(next) * per_px;
-                        next = next.saturating_add(1);
-                    }
-                }
-                let clip = Rect::from_min_size(pos2(x, y), vec2(span, h)).intersect(body);
-                let (anchor, at) =
-                    if numeric { (Align2::RIGHT_CENTER, pos2(x + w - 1.0, y + h / 2.0)) } else { (Align2::LEFT_CENTER, pos2(x + 1.0, y + h / 2.0)) };
-                p.with_clip_rect(clip).text(at, anchor, text, font.clone(), t.cell_text);
-            }
-            x += w;
-        }
-        y += h;
-    }
-}
-
 fn export(app: &mut SheetApp, ui: &mut Ui, out: &mut Outcome) {
     let lang = app.ui.language;
     if action_row(ui, Icon::Paper, lang.tr("Create PDF"), lang.tr("Save the sheet as a PDF document that keeps its page layout.")).clicked()
@@ -949,183 +789,6 @@ pub fn export_as(app: &mut SheetApp, fmt: &str) -> bool {
     }
 }
 
-/// Excel's File › Options page: General (display theme, interface language and Show formula bar),
-/// Editing (AutoComplete) and Save (the autosave checkbox toggling `app.ui.autosave`), plus Formulas
-/// (calculation mode and iterative calculation) when a document is active. Theme, language, formula
-/// bar, AutoComplete and calculation changes run their commands through `run_or_alert`; calculation
-/// settings are saved with the workbook.
-fn options(app: &mut SheetApp, ui: &mut Ui) {
-    let lang = app.ui.language;
-    section(ui, lang, "Options|General");
-    general_options(app, ui, lang);
-    ui.add_space(6.0);
-    let mut formula_bar = app.session.prefs.formula_bar;
-    if ui.checkbox(&mut formula_bar, lang.tr("Show formula bar")).changed() {
-        app.run_or_alert("view.formulaBar", json!({"on": formula_bar}));
-    }
-    ui.add_space(18.0);
-    section(ui, lang, "Options|Editing");
-    let mut autocomplete = app.ui.autocomplete;
-    if ui.checkbox(&mut autocomplete, lang.tr("Enable AutoComplete for cell values")).changed() {
-        app.run_or_alert("options.autoComplete", json!({"on": autocomplete}));
-    }
-    ui.add_space(18.0);
-    section(ui, lang, "Options|Save");
-    let mut autosave = app.ui.autosave;
-    if ui.checkbox(&mut autosave, lang.tr("Save .xlsx workbooks automatically after every change")).changed() {
-        app.toggle_autosave();
-    }
-    let Some(calc) = app.session.active().map(|d| d.wb.calc.clone()) else { return };
-    ui.add_space(18.0);
-    section(ui, lang, "Formulas");
-    ui.label(lang.tr("Workbook calculation"));
-    calc_options(app, ui, lang, &calc);
-    ui.add_space(6.0);
-    dim(ui, lang.tr("Calculation settings are saved with the workbook."));
-}
-
-/// The display theme and interface language controls of the General section.
-fn general_options(app: &mut SheetApp, ui: &mut Ui, lang: Language) {
-    egui::Grid::new("backstage_options_general").num_columns(2).spacing(vec2(18.0, 10.0)).show(ui, |ui| {
-        let label = ui.label(lang.tr("Display theme"));
-        let mode = app.ui.theme_mode();
-        let current = match mode {
-            "system" => "System",
-            "dark" => "Dark",
-            _ => "Light",
-        };
-        egui::ComboBox::from_id_salt("backstage_theme")
-            .width(160.0)
-            .selected_text(lang.tr(current))
-            .show_ui(ui, |ui| {
-                for (value, label) in [("system", "System"), ("light", "Light"), ("dark", "Dark")] {
-                    if ui.selectable_label(mode == value, lang.tr(label)).clicked() {
-                        app.run_or_alert("view.theme", json!({"mode": value}));
-                    }
-                }
-            })
-            .response
-            .labelled_by(label.id);
-        ui.end_row();
-        let label = ui.label(lang.tr("Interface language"));
-        egui::ComboBox::from_id_salt("backstage_language")
-            .width(160.0)
-            .selected_text(lang.name())
-            .show_ui(ui, |ui| {
-                for l in i18n::Language::for_picker() {
-                    if ui.selectable_label(l == lang, l.name()).clicked() {
-                        app.run_or_alert("app.language.set", json!({"language": l.code()}));
-                    }
-                }
-            })
-            .response
-            .labelled_by(label.id);
-        ui.end_row();
-    });
-}
-
-/// The calculation mode, and iterative calculation, of the active workbook.
-fn calc_options(app: &mut SheetApp, ui: &mut Ui, lang: Language, calc: &gridcraft_engine::model::CalcSettings) {
-    use gridcraft_engine::model::CalcMode;
-    for (mode, id, label) in [
-        (CalcMode::Automatic, "automatic", "Automatic"),
-        (CalcMode::AutomaticExceptTables, "automaticExceptTables", "Automatic Except for Data Tables"),
-        (CalcMode::Manual, "manual", "Manual"),
-    ] {
-        if ui.radio(calc.mode == mode, lang.tr(label)).clicked() && calc.mode != mode {
-            app.run_or_alert("formulas.calculationOptions", json!({"mode": id}));
-        }
-    }
-    ui.add_space(4.0);
-    let mut iterative = calc.iterative;
-    if ui.checkbox(&mut iterative, lang.tr("Enable iterative calculation")).changed() {
-        app.run_or_alert("formulas.calculationOptions", json!({"iterative": iterative}));
-    }
-    // Maximum Iterations and Maximum Change apply only while iteration is on, as in Excel.
-    iteration_options(app, ui, lang, calc, iterative);
-    // TODO: add "Set precision as displayed" here once `formulas.calculationOptions` takes
-    // `precisionAsDisplayed` (PR #1366); the model already stores it.
-}
-
-/// Maximum Iterations and Maximum Change, live only while iterative calculation is on.
-fn iteration_options(app: &mut SheetApp, ui: &mut Ui, lang: Language, calc: &gridcraft_engine::model::CalcSettings, iterative: bool) {
-    ui.add_enabled_ui(iterative, |ui| {
-        ui.horizontal(|ui| {
-            ui.add_space(24.0);
-            egui::Grid::new("backstage_options_iteration").num_columns(2).spacing(vec2(12.0, 6.0)).show(ui, |ui| {
-                let label = ui.label(lang.tr("Maximum Iterations:"));
-                let id = ui.make_persistent_id("backstage_max_iterations");
-                // Text left in the field when iteration is switched off (it loses focus) is dropped.
-                let committed = crate::widgets::committed_text(ui, id, &calc.max_iterations.to_string(), Some(80.0));
-                if let Some(response) = ui.ctx().read_response(id) {
-                    response.labelled_by(label.id);
-                }
-                if let Some(text) = committed.filter(|_| iterative) {
-                    match parse_max_iterations(&text) {
-                        Some(n) if n != calc.max_iterations => {
-                            app.run_or_alert("formulas.calculationOptions", json!({"maxIterations": n}));
-                        }
-                        Some(_) => {}
-                        None => refuse(app, ui, "Maximum Iterations must be a whole number from 1 to 32767."),
-                    }
-                }
-                ui.end_row();
-                let label = ui.label(lang.tr("Maximum Change:"));
-                let id = ui.make_persistent_id("backstage_max_change");
-                let committed = crate::widgets::committed_text(ui, id, &calc.max_change.to_string(), Some(80.0));
-                if let Some(response) = ui.ctx().read_response(id) {
-                    response.labelled_by(label.id);
-                }
-                if let Some(text) = committed.filter(|_| iterative) {
-                    match parse_max_change(&text, lang.formula_locale()) {
-                        Some(d) if d != calc.max_change => {
-                            app.run_or_alert("formulas.calculationOptions", json!({"maxChange": d}));
-                        }
-                        Some(_) => {}
-                        None => refuse(app, ui, "Maximum Change must be a number of 0 or more."),
-                    }
-                }
-                ui.end_row();
-            });
-        });
-    });
-}
-
-/// Refuses a typed setting with a message, leaving the workbook as it was. The Enter that
-/// committed the field is consumed so it doesn't also dismiss the message box in this frame.
-fn refuse(app: &mut SheetApp, ui: &mut Ui, text: &str) {
-    ui.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Enter));
-    app.message = Some(("GridCraft".into(), app.ui.language.tr(text).into()));
-}
-
-/// Maximum Iterations as typed: a whole number from 1 to 32767, or `None` (Excel refuses others).
-fn parse_max_iterations(text: &str) -> Option<u32> {
-    let n = text.trim().parse::<u32>().ok()?;
-    (1..=gridcraft_engine::model::CalcSettings::MAX_ITERATIONS).contains(&n).then_some(n)
-}
-
-/// Maximum Change as typed: a finite number of 0 or more, or `None`. The interface's decimal
-/// separator is accepted as well as a dot.
-fn parse_max_change(text: &str, locale: gridcraft_engine::formula::FormulaLocale) -> Option<f64> {
-    let d = text.trim().replace(locale.decimal_separator(), ".").parse::<f64>().ok()?;
-    (d.is_finite() && d >= 0.0).then_some(d)
-}
-
-/// The platform the app was built for, e.g. "macOS (aarch64)"; the web build reports "Web".
-fn platform() -> String {
-    let os = match std::env::consts::OS {
-        "macos" => "macOS",
-        "windows" => "Windows",
-        "linux" => "Linux",
-        "freebsd" => "FreeBSD",
-        "openbsd" => "OpenBSD",
-        "netbsd" => "NetBSD",
-        _ if cfg!(target_arch = "wasm32") => return "Web".into(),
-        other => other,
-    };
-    format!("{os} ({})", std::env::consts::ARCH)
-}
-
 /// Excel's File › Account: product information and the About window.
 fn account(app: &mut SheetApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
diff --git a/crates/ui-egui/src/backstage/options.rs b/crates/ui-egui/src/backstage/options.rs
new file mode 100644
index 000000000..5a772e093
--- /dev/null
+++ b/crates/ui-egui/src/backstage/options.rs
@@ -0,0 +1,178 @@
+use super::*;
+
+/// Excel's File › Options page: General (display theme, interface language and Show formula bar),
+/// Editing (AutoComplete) and Save (the autosave checkbox toggling `app.ui.autosave`), plus Formulas
+/// (calculation mode and iterative calculation) when a document is active. Theme, language, formula
+/// bar, AutoComplete and calculation changes run their commands through `run_or_alert`; calculation
+/// settings are saved with the workbook.
+pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) {
+    let lang = app.ui.language;
+    section(ui, lang, "Options|General");
+    general_options(app, ui, lang);
+    ui.add_space(6.0);
+    let mut formula_bar = app.session.prefs.formula_bar;
+    if ui.checkbox(&mut formula_bar, lang.tr("Show formula bar")).changed() {
+        app.run_or_alert("view.formulaBar", json!({"on": formula_bar}));
+    }
+    ui.add_space(18.0);
+    section(ui, lang, "Options|Editing");
+    let mut autocomplete = app.ui.autocomplete;
+    if ui.checkbox(&mut autocomplete, lang.tr("Enable AutoComplete for cell values")).changed() {
+        app.run_or_alert("options.autoComplete", json!({"on": autocomplete}));
+    }
+    ui.add_space(18.0);
+    section(ui, lang, "Options|Save");
+    let mut autosave = app.ui.autosave;
+    if ui.checkbox(&mut autosave, lang.tr("Save .xlsx workbooks automatically after every change")).changed() {
+        app.toggle_autosave();
+    }
+    let Some(calc) = app.session.active().map(|d| d.wb.calc.clone()) else { return };
+    ui.add_space(18.0);
+    section(ui, lang, "Formulas");
+    ui.label(lang.tr("Workbook calculation"));
+    calc_options(app, ui, lang, &calc);
+    ui.add_space(6.0);
+    dim(ui, lang.tr("Calculation settings are saved with the workbook."));
+}
+
+/// The display theme and interface language controls of the General section.
+fn general_options(app: &mut SheetApp, ui: &mut Ui, lang: Language) {
+    egui::Grid::new("backstage_options_general").num_columns(2).spacing(vec2(18.0, 10.0)).show(ui, |ui| {
+        let label = ui.label(lang.tr("Display theme"));
+        let mode = app.ui.theme_mode();
+        let current = match mode {
+            "system" => "System",
+            "dark" => "Dark",
+            _ => "Light",
+        };
+        egui::ComboBox::from_id_salt("backstage_theme")
+            .width(160.0)
+            .selected_text(lang.tr(current))
+            .show_ui(ui, |ui| {
+                for (value, label) in [("system", "System"), ("light", "Light"), ("dark", "Dark")] {
+                    if ui.selectable_label(mode == value, lang.tr(label)).clicked() {
+                        app.run_or_alert("view.theme", json!({"mode": value}));
+                    }
+                }
+            })
+            .response
+            .labelled_by(label.id);
+        ui.end_row();
+        let label = ui.label(lang.tr("Interface language"));
+        egui::ComboBox::from_id_salt("backstage_language")
+            .width(160.0)
+            .selected_text(lang.name())
+            .show_ui(ui, |ui| {
+                for l in i18n::Language::for_picker() {
+                    if ui.selectable_label(l == lang, l.name()).clicked() {
+                        app.run_or_alert("app.language.set", json!({"language": l.code()}));
+                    }
+                }
+            })
+            .response
+            .labelled_by(label.id);
+        ui.end_row();
+    });
+}
+
+/// The calculation mode, and iterative calculation, of the active workbook.
+fn calc_options(app: &mut SheetApp, ui: &mut Ui, lang: Language, calc: &gridcraft_engine::model::CalcSettings) {
+    use gridcraft_engine::model::CalcMode;
+    for (mode, id, label) in [
+        (CalcMode::Automatic, "automatic", "Automatic"),
+        (CalcMode::AutomaticExceptTables, "automaticExceptTables", "Automatic Except for Data Tables"),
+        (CalcMode::Manual, "manual", "Manual"),
+    ] {
+        if ui.radio(calc.mode == mode, lang.tr(label)).clicked() && calc.mode != mode {
+            app.run_or_alert("formulas.calculationOptions", json!({"mode": id}));
+        }
+    }
+    ui.add_space(4.0);
+    let mut iterative = calc.iterative;
+    if ui.checkbox(&mut iterative, lang.tr("Enable iterative calculation")).changed() {
+        app.run_or_alert("formulas.calculationOptions", json!({"iterative": iterative}));
+    }
+    // Maximum Iterations and Maximum Change apply only while iteration is on, as in Excel.
+    iteration_options(app, ui, lang, calc, iterative);
+    // TODO: add "Set precision as displayed" here once `formulas.calculationOptions` takes
+    // `precisionAsDisplayed` (PR #1366); the model already stores it.
+}
+
+/// Maximum Iterations and Maximum Change, live only while iterative calculation is on.
+fn iteration_options(app: &mut SheetApp, ui: &mut Ui, lang: Language, calc: &gridcraft_engine::model::CalcSettings, iterative: bool) {
+    ui.add_enabled_ui(iterative, |ui| {
+        ui.horizontal(|ui| {
+            ui.add_space(24.0);
+            egui::Grid::new("backstage_options_iteration").num_columns(2).spacing(vec2(12.0, 6.0)).show(ui, |ui| {
+                let label = ui.label(lang.tr("Maximum Iterations:"));
+                let id = ui.make_persistent_id("backstage_max_iterations");
+                // Text left in the field when iteration is switched off (it loses focus) is dropped.
+                let committed = crate::widgets::committed_text(ui, id, &calc.max_iterations.to_string(), Some(80.0));
+                if let Some(response) = ui.ctx().read_response(id) {
+                    response.labelled_by(label.id);
+                }
+                if let Some(text) = committed.filter(|_| iterative) {
+                    match parse_max_iterations(&text) {
+                        Some(n) if n != calc.max_iterations => {
+                            app.run_or_alert("formulas.calculationOptions", json!({"maxIterations": n}));
+                        }
+                        Some(_) => {}
+                        None => refuse(app, ui, "Maximum Iterations must be a whole number from 1 to 32767."),
+                    }
+                }
+                ui.end_row();
+                let label = ui.label(lang.tr("Maximum Change:"));
+                let id = ui.make_persistent_id("backstage_max_change");
+                let committed = crate::widgets::committed_text(ui, id, &calc.max_change.to_string(), Some(80.0));
+                if let Some(response) = ui.ctx().read_response(id) {
+                    response.labelled_by(label.id);
+                }
+                if let Some(text) = committed.filter(|_| iterative) {
+                    match parse_max_change(&text, lang.formula_locale()) {
+                        Some(d) if d != calc.max_change => {
+                            app.run_or_alert("formulas.calculationOptions", json!({"maxChange": d}));
+                        }
+                        Some(_) => {}
+                        None => refuse(app, ui, "Maximum Change must be a number of 0 or more."),
+                    }
+                }
+                ui.end_row();
+            });
+        });
+    });
+}
+
+/// Refuses a typed setting with a message, leaving the workbook as it was. The Enter that
+/// committed the field is consumed so it doesn't also dismiss the message box in this frame.
+fn refuse(app: &mut SheetApp, ui: &mut Ui, text: &str) {
+    ui.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Enter));
+    app.message = Some(("GridCraft".into(), app.ui.language.tr(text).into()));
+}
+
+/// Maximum Iterations as typed: a whole number from 1 to 32767, or `None` (Excel refuses others).
+fn parse_max_iterations(text: &str) -> Option<u32> {
+    let n = text.trim().parse::<u32>().ok()?;
+    (1..=gridcraft_engine::model::CalcSettings::MAX_ITERATIONS).contains(&n).then_some(n)
+}
+
+/// Maximum Change as typed: a finite number of 0 or more, or `None`. The interface's decimal
+/// separator is accepted as well as a dot.
+fn parse_max_change(text: &str, locale: gridcraft_engine::formula::FormulaLocale) -> Option<f64> {
+    let d = text.trim().replace(locale.decimal_separator(), ".").parse::<f64>().ok()?;
+    (d.is_finite() && d >= 0.0).then_some(d)
+}
+
+/// The platform the app was built for, e.g. "macOS (aarch64)"; the web build reports "Web".
+pub(super) fn platform() -> String {
+    let os = match std::env::consts::OS {
+        "macos" => "macOS",
+        "windows" => "Windows",
+        "linux" => "Linux",
+        "freebsd" => "FreeBSD",
+        "openbsd" => "OpenBSD",
+        "netbsd" => "NetBSD",
+        _ if cfg!(target_arch = "wasm32") => return "Web".into(),
+        other => other,
+    };
+    format!("{os} ({})", std::env::consts::ARCH)
+}
diff --git a/crates/ui-egui/src/backstage/print.rs b/crates/ui-egui/src/backstage/print.rs
new file mode 100644
index 000000000..ac0b183d6
--- /dev/null
+++ b/crates/ui-egui/src/backstage/print.rs
@@ -0,0 +1,168 @@
+use super::*;
+
+/// Builds the print scope and fit-to-page parameters, caches `file.printPreview` per document revision/options, and draws page thumbnails with navigation plus the print settings and Print action.
+pub(super) fn print(app: &mut SheetApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcome) {
+    let t = Tokens::get(ui.ctx());
+    let lang = app.ui.language;
+    let Some((uid, revision)) = app.session.active().map(|d| (d.uid, d.revision)) else {
+        dim(ui, lang.tr("No workbook is open."));
+        return;
+    };
+    let mut params = json!({"sheets": if bs.print_all { "all" } else { "active" }});
+    if bs.fit_to_page {
+        params["fitToPage"] = json!(true);
+    }
+    let key = (uid, revision, bs.print_all, bs.fit_to_page);
+    if bs.preview.as_ref().is_none_or(|(k, _)| *k != key) {
+        let preview = app.session.run("file.printPreview", params.clone()).unwrap_or(Json::Null);
+        bs.preview = Some((key, preview));
+    }
+    let pages: Vec<Json> = bs.preview.as_ref().and_then(|(_, p)| p.get("pageList")).and_then(Json::as_array).cloned().unwrap_or_default();
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(250.0);
+            if let Some(discover) = &app.services.printers {
+                crate::printing::show(&mut app.printing, ui, discover, |label| lang.tr(label).to_owned());
+            }
+            let can_print = app.services.print_native.is_none() || app.printing.ready();
+            if ui.add_enabled_ui(can_print, |ui| square_button(ui, Icon::Print, lang.tr("Print"))).inner.clicked()
+                && app.commit_edit(0, 0, false, false)
+            {
+                app.print_now(params.clone());
+                out.close = app.services.print_native.is_none();
+            }
+            ui.add_space(16.0);
+            let scope = if bs.print_all { "Print Entire Workbook" } else { "Print Active Sheets" };
+            egui::ComboBox::from_id_salt("backstage_print_scope")
+                .width(230.0)
+                .selected_text(lang.tr(scope))
+                .show_ui(ui, |ui| {
+                    for (all, label) in [(false, "Print Active Sheets"), (true, "Print Entire Workbook")] {
+                        if ui.selectable_label(bs.print_all == all, lang.tr(label)).clicked() {
+                            bs.print_all = all;
+                            bs.preview_page = 0;
+                        }
+                    }
+                })
+                .response
+                .accessible_name(lang.tr("Print What"));
+            ui.add_space(8.0);
+            if ui.checkbox(&mut bs.fit_to_page, lang.tr("Fit Sheet on One Page")).changed() {
+                bs.preview_page = 0;
+            }
+            ui.add_space(8.0);
+            if ui.link(lang.tr("Page Setup…")).clicked() {
+                app.open_dialog("pageSetup", json!({}));
+            }
+        });
+        ui.add_space(24.0);
+        ui.vertical(|ui| {
+            if pages.is_empty() {
+                dim(ui, lang.tr("Nothing to print."));
+                return;
+            }
+            let last = pages.len().saturating_sub(1);
+            bs.preview_page = bs.preview_page.min(last);
+            let Some(page) = pages.get(bs.preview_page) else { return };
+            // Paper proportions from the preview (points); hostile sizes fall back to Letter.
+            let w = page.get("width").and_then(Json::as_f64).filter(|w| w.is_finite() && *w > 1.0).unwrap_or(612.0) as f32;
+            let h = page.get("height").and_then(Json::as_f64).filter(|h| h.is_finite() && *h > 1.0).unwrap_or(792.0) as f32;
+            let scale = (520.0 / h).min(440.0 / w);
+            let (rect, _) = ui.allocate_exact_size(vec2(w * scale, h * scale), Sense::hover());
+            let p = ui.painter();
+            p.rect_filled(rect.translate(vec2(2.0, 3.0)), 2.0, t.shadow);
+            p.rect_filled(rect, 2.0, t.grid_bg);
+            p.rect_stroke(rect, 2.0, Stroke::new(1.0, t.ribbon_border), StrokeKind::Inside);
+            if let Some(d) = app.session.active() {
+                paint_page(p, rect, w, page, &d.wb, &t);
+            }
+            let sheet = page.get("sheet").and_then(Json::as_str).unwrap_or("");
+            let range = page.get("range").and_then(Json::as_str).unwrap_or("");
+            ui.add_space(4.0);
+            dim(ui, &format!("{sheet} · {range}"));
+            ui.add_space(8.0);
+            ui.horizontal(|ui| {
+                if ui.add_enabled(bs.preview_page > 0, egui::Button::new("◀")).on_hover_text(lang.tr("Previous page")).clicked() {
+                    bs.preview_page = bs.preview_page.saturating_sub(1);
+                }
+                let text = lang
+                    .tr("Page {page} of {pages}")
+                    .replace("{page}", &(bs.preview_page + 1).to_string())
+                    .replace("{pages}", &pages.len().to_string());
+                ui.label(text);
+                if ui.add_enabled(bs.preview_page < last, egui::Button::new("▶")).on_hover_text(lang.tr("Next page")).clicked() {
+                    bs.preview_page = (bs.preview_page + 1).min(last);
+                }
+            });
+        });
+    });
+}
+
+/// Most rows and columns one preview page draws (a page holds far fewer at any readable scale).
+const PREVIEW_ROWS: u32 = 200;
+
+const PREVIEW_COLS: u32 = 60;
+
+/// Draws one printed page in miniature: the cells' displayed text at the page's print scale,
+/// inside the sheet's margins. `paper_w` is the page width in points.
+fn paint_page(p: &egui::Painter, rect: Rect, paper_w: f32, page: &Json, wb: &gridcraft_engine::model::Workbook, t: &Tokens) {
+    let Some(range) = page.get("range").and_then(Json::as_str).and_then(gridcraft_engine::core::RangeRef::parse) else { return };
+    let Some(sh) = page.get("sheet").and_then(Json::as_str).and_then(|n| wb.sheet_index(n)).and_then(|i| wb.sheets.get(i)) else { return };
+    // Preview pixels per point, and per sheet pixel (sheet geometry is 96 dpi: 0.75 pt per pixel).
+    let per_pt = rect.width() / paper_w;
+    let print_scale =
+        page.get("scale").and_then(Json::as_f64).filter(|s| s.is_finite() && *s > 0.0).map_or(1.0, |s| (s / 100.0) as f32).clamp(0.1, 4.0);
+    let per_px = per_pt * 0.75 * print_scale;
+    let margin =
+        |i: usize, default: f32| sh.print.margins.get(i).copied().filter(|m| m.is_finite()).unwrap_or(default).clamp(0.0, 3.0) * 72.0 * per_pt;
+    let body = Rect::from_min_max(
+        pos2(rect.left() + margin(0, 0.7), rect.top() + margin(2, 0.75)),
+        pos2(rect.right() - margin(1, 0.7), rect.bottom() - margin(3, 0.75)),
+    );
+    if !body.is_positive() {
+        return;
+    }
+    let font = theme::ui_font((11.0 * per_pt * print_scale).clamp(3.0, 14.0));
+    let last_row = range.end.row.min(range.start.row.saturating_add(PREVIEW_ROWS));
+    let last_col = range.end.col.min(range.start.col.saturating_add(PREVIEW_COLS));
+    let mut y = body.top();
+    for row in range.start.row..=last_row {
+        let h = sh.row_height(row) * per_px;
+        if h <= 0.0 {
+            continue;
+        }
+        if y >= body.bottom() {
+            break;
+        }
+        let mut x = body.left();
+        for col in range.start.col..=last_col {
+            let w = sh.col_width(col) * per_px;
+            if w <= 0.0 {
+                continue;
+            }
+            if x >= body.right() {
+                break;
+            }
+            let cell = gridcraft_engine::core::CellRef::new(row, col);
+            let text = gridcraft_engine::display::cell_text(wb, sh, cell);
+            if !text.is_empty() {
+                let numeric = sh.value(cell).as_f64().is_some();
+                // Text runs on over empty neighbours, as on the sheet; numbers stay in their cell.
+                let mut span = w;
+                if !numeric {
+                    let mut next = col.saturating_add(1);
+                    while next <= last_col && x + span < body.right() && sh.value(gridcraft_engine::core::CellRef::new(row, next)).is_empty() {
+                        span += sh.col_width(next) * per_px;
+                        next = next.saturating_add(1);
+                    }
+                }
+                let clip = Rect::from_min_size(pos2(x, y), vec2(span, h)).intersect(body);
+                let (anchor, at) =
+                    if numeric { (Align2::RIGHT_CENTER, pos2(x + w - 1.0, y + h / 2.0)) } else { (Align2::LEFT_CENTER, pos2(x + 1.0, y + h / 2.0)) };
+                p.with_clip_rect(clip).text(at, anchor, text, font.clone(), t.cell_text);
+            }
+            x += w;
+        }
+        y += h;
+    }
+}

From e0211fbb4f55be482425624e6721cd3a5ce8fc02 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:03:59 +0000
Subject: [PATCH 72/76] refactor(ui-egui): move SheetApp methods and UI types
 out of lib.rs

---
 crates/ui-egui/src/app.rs      | 1754 +++++++++++++++++++++++++++++
 crates/ui-egui/src/clock.rs    |   25 +
 crates/ui-egui/src/lib.rs      | 1886 +-------------------------------
 crates/ui-egui/src/services.rs |   61 ++
 crates/ui-egui/src/state.rs    |   40 +
 5 files changed, 1889 insertions(+), 1877 deletions(-)
 create mode 100644 crates/ui-egui/src/app.rs
 create mode 100644 crates/ui-egui/src/clock.rs
 create mode 100644 crates/ui-egui/src/services.rs
 create mode 100644 crates/ui-egui/src/state.rs

diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
new file mode 100644
index 000000000..a524925ce
--- /dev/null
+++ b/crates/ui-egui/src/app.rs
@@ -0,0 +1,1754 @@
+use super::clock::now_ms;
+use super::services::{Chrome, Services};
+use super::state::{NoticeKind, OpenWindow, SaveAnswer, SheetView};
+use super::*;
+
+impl SheetApp {
+    /// Constructs a `SheetApp` with default UI, grid, printing, control and screenshot state and the caller's session and services.
+    pub fn new(session: Session, services: Services) -> SheetApp {
+        SheetApp {
+            session,
+            ui: UiState::default(),
+            chrome: Chrome::default(),
+            views: HashMap::new(),
+            editor: None,
+            text_box_editor: None,
+            dialog: None,
+            backstage: None,
+            message: None,
+            toast: None,
+            notice: None,
+            services,
+            printing: Default::default(),
+            print_feedback_seen: None,
+            synthetic: Default::default(),
+            synthetic_pending: false,
+            synthetic_injected_at_pass: None,
+            control_rx: None,
+            grid: grid::GridState {
+                last_border: "bottom".into(),
+                last_fill: "#FFFF00".into(),
+                last_font_color: "#C00000".into(),
+                ..Default::default()
+            },
+            perf: Perf::default(),
+            fonts_ready: false,
+            fonts_set: false,
+            prepared_fonts: false,
+            fonts_bound: Vec::new(),
+            fonts_seen: (0, 0),
+            fonts_rebind: false,
+            fonts_han: None,
+            effective_dark: false,
+            desktop_theme: desktop_theme::DesktopTheme::default(),
+            desktop_dark: None,
+            name_box: None,
+            keytips: keytips::KeyTips::default(),
+            shots: control::Shots::default(),
+            capture_epoch: 0,
+            capture_geometry: None,
+            capture_geometry_from_raw: false,
+            selected_chart: None,
+            clipboard_text_at_copy: None,
+            cut_text: None,
+            tab_run: None,
+            started: now_ms(),
+            allow_close: false,
+            open_switch_windows: false,
+            ui_window: None,
+            parked: HashMap::new(),
+            native_windows: false,
+            arrange_windows: None,
+            #[cfg(not(target_arch = "wasm32"))]
+            updates_rt: Default::default(),
+        }
+    }
+
+    /// One-time context setup: start cataloging the machine's fonts, then install the fonts and
+    /// visuals. Workbook-specific fonts are bound later, once the scan is done (see [`logic`]).
+    ///
+    /// [`logic`]: SheetApp::logic
+    pub fn setup_context(ctx: &egui::Context, dark: bool) {
+        fonts::start_scan();
+        Self::setup_context_for_language(ctx, dark, i18n::Language::En);
+    }
+
+    /// Sets up fonts and visuals for a specific persisted interface language.
+    pub fn setup_context_for_language(ctx: &egui::Context, dark: bool, language: i18n::Language) {
+        ctx.set_fonts(theme::font_definitions_for_language(language));
+        theme::apply(ctx, dark);
+    }
+
+    /// Test-harness setup: mark a deterministic font set (see
+    /// [`theme::pinned_font_definitions`]) as already installed, so the first `logic` pass neither
+    /// starts the host font scan nor replaces the harness's pinned set. Production uses
+    /// [`Self::setup_context`] instead.
+    #[doc(hidden)]
+    pub fn use_prepared_fonts(&mut self) {
+        self.prepared_fonts = true;
+        self.fonts_ready = true;
+        self.fonts_set = true;
+        self.fonts_rebind = false;
+        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
+        self.fonts_bound = self.used_fonts();
+        self.fonts_seen = self.fonts_key();
+    }
+
+    /// The font names the open workbooks use: every style's font plus the theme's heading/body
+    /// fonts. These are the families [`fonts`] binds an installed file for. Every workbook's, as
+    /// each may be showing in a window of its own.
+    pub fn used_fonts(&self) -> Vec<String> {
+        let mut names: Vec<String> = Vec::new();
+        for d in self.session.documents() {
+            names.extend(d.wb.styles.iter().map(|(_, s)| s.font.name.clone()));
+            names.push(d.wb.theme.major_font.clone());
+            names.push(d.wb.theme.minor_font.clone());
+            // Text boxes and shapes name their own typefaces.
+            names.extend(d.wb.sheets.iter().flat_map(|sh| sh.shapes.iter().filter_map(|s| s.format.font.clone())));
+        }
+        names
+    }
+
+    /// The open workbooks' (uid, revision), folded: [`Self::used_fonts`] changes only with it.
+    fn fonts_key(&self) -> (u64, u64) {
+        self.session
+            .documents()
+            .iter()
+            .fold((0u64, 0u64), |(uid, rev), d| (uid.wrapping_mul(31).wrapping_add(d.uid), rev.wrapping_mul(31).wrapping_add(d.revision)))
+    }
+
+    /// Runs an engine command (or a UI command) and handles UI requests it makes.
+    pub fn run(&mut self, id: &str, params: Json) -> Result<Json, String> {
+        let r = self.run_command(id, params);
+        // This copy leaves the system clipboard alone: note what it holds, so Paste can tell
+        // that GridCraft's copy is newer while that text is still there.
+        if matches!(id, "edit.copy" | "edit.cut") && r.is_ok() {
+            self.clipboard_text_at_copy = self.system_clipboard_text();
+            self.cut_text = if id == "edit.cut" { self.clipboard_text_at_copy.clone() } else { None };
+        }
+        r
+    }
+
+    fn run_command(&mut self, id: &str, params: Json) -> Result<Json, String> {
+        let switches_window = id.starts_with("window.")
+            || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
+            || (id == "view.switchWindows" && ["window", "doc"].iter().any(|k| params.get(*k).is_some_and(|d| !d.is_null())));
+        if id.starts_with("file.") || switches_window {
+            self.settle_drafts()?;
+        }
+        if matches!(id, "file.save" | "file.saveAs" | "file.saveBytes") {
+            self.store_view_state();
+        }
+        if matches!(
+            id,
+            "sheet.activate"
+                | "sheet.next"
+                | "sheet.previous"
+                | "sheet.move"
+                | "sheet.hide"
+                | "sheet.unhide"
+                | "home.insertSheet"
+                | "home.deleteSheet"
+                | "edit.undo"
+                | "edit.redo"
+                | "object.delete"
+                | "object.move"
+        ) {
+            self.commit_text_box_edit()?;
+        }
+        if let Some(r) = self.run_ui_command(id, &params) {
+            return r;
+        }
+        let before = self.session.active_window();
+        let r = self.session.run(id, params);
+        if id.starts_with("file.") && self.session.active_window() != before {
+            // File › New or Open from the Backstage view: the window it was in goes back to its sheet.
+            self.backstage = None;
+        }
+        // Requests the command made (a dialog, a draft) belong to the window it left active.
+        self.follow_active_window();
+        self.after_engine();
+        if id == "view.arrangeAll"
+            && self.native_windows
+            && let Ok(r) = &r
+        {
+            let arrange = r.get("arrange").and_then(Json::as_str).unwrap_or("tiled").to_string();
+            let windows = r.get("windows").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
+            self.arrange_windows = Some((arrange, windows));
+        }
+        // The new chart is selected, as after inserting any object, so Delete removes it, not its data.
+        if id == "insert.chart"
+            && let Ok(r) = &r
+            && let Some(chart) = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok())
+        {
+            self.selected_chart = Some(chart);
+        }
+        if id == "file.exportPdf"
+            && let Ok(r) = &r
+        {
+            self.deliver_pdf(r);
+        }
+        r
+    }
+
+    /// Copy or cut the selected cells to the system clipboard. Engine-only commands keep
+    /// their existing internal clipboard behavior and do not write to the host clipboard.
+    pub fn copy_to_clipboard(&mut self, ctx: &egui::Context, command: &str) {
+        // Only ask the engine for HTML when the host can publish it.
+        let result = match self.run_command(command, json!({"html": self.services.copy_html.is_some()})) {
+            Ok(result) => result,
+            Err(e) => return self.alert(e),
+        };
+        let Some(text) = result.get("text").and_then(Json::as_str) else { return };
+        // The system clipboard gets this copy, so its text decides what Paste pastes.
+        self.clipboard_text_at_copy = None;
+        self.cut_text = (command == "edit.cut").then(|| text.replace("\r\n", "\n"));
+        if let Some(html) = result.get("html").and_then(Json::as_str)
+            && let Some(copy_html) = &mut self.services.copy_html
+        {
+            match copy_html(html, text) {
+                Ok(()) => return,
+                Err(error) => log::warn!("HTML clipboard unavailable; copying plain text: {error}"),
+            }
+        }
+        ctx.copy_text(text.to_string());
+    }
+
+    /// Paste text that came from the system clipboard (Cmd/Ctrl+V, or the ribbon and menu Paste),
+    /// with the clipboard's HTML flavour when the host can read it.
+    ///
+    /// Excel pastes a cut once: after GridCraft's cut has been pasted, the system clipboard text
+    /// that came with it is not pasted again over the moved block; GridCraft's own (empty)
+    /// clipboard is pasted instead, which reports "Nothing to paste.". Other text means the
+    /// clipboard has moved on, so the cut's text is forgotten and pastes normally later.
+    pub fn paste_external(&mut self, text: String) {
+        if Self::same_clipboard_text(Some(&text), self.cut_text.as_deref()) {
+            if self.session.clipboard.is_none() {
+                return self.run_or_alert("edit.paste", json!({}));
+            }
+        } else {
+            self.cut_text = None;
+        }
+        let html = self.services.paste_html.as_mut().and_then(|read| read());
+        let params = match html {
+            Some(html) => json!({"text": text, "html": html}),
+            None => json!({"text": text}),
+        };
+        self.run_or_alert("edit.paste", params);
+    }
+
+    /// Ribbon and menu Paste: paste the text on the system clipboard, as Cmd/Ctrl+V does. With no
+    /// text there, no host clipboard (web), or the text that was there when GridCraft last copied
+    /// without publishing, GridCraft's own clipboard is pasted.
+    pub fn paste_from_clipboard(&mut self) {
+        match self.system_clipboard_text() {
+            Some(text) if self.session.clipboard.is_none() || self.clipboard_text_at_copy.as_ref() != Some(&text) => self.paste_external(text),
+            _ => self.run_or_alert("edit.paste", json!({})),
+        }
+    }
+
+    /// The system clipboard's plain text, with the line endings of egui's `Event::Paste` text.
+    /// `None` when it holds no text or the host can't read it.
+    fn system_clipboard_text(&mut self) -> Option<String> {
+        self.services.paste_text.as_mut().and_then(|read| read()).filter(|t| !t.is_empty()).map(|t| t.replace("\r\n", "\n"))
+    }
+
+    /// Whether two clipboard texts are the same copy: trailing line breaks don't count, as in the
+    /// engine's `edit.paste`, and CRLF matches LF (egui's `Event::Paste` text may keep the host's).
+    fn same_clipboard_text(a: Option<&str>, b: Option<&str>) -> bool {
+        fn chars(t: &str) -> impl Iterator<Item = char> + '_ {
+            t.trim_end_matches(['\r', '\n']).chars().filter(|c| *c != '\r')
+        }
+        match (a, b) {
+            (Some(a), Some(b)) => chars(a).eq(chars(b)),
+            _ => false,
+        }
+    }
+
+    /// Web: `file.exportPdf` without a path returns the PDF as base64; hand it to the browser as a download.
+    fn deliver_pdf(&self, result: &Json) {
+        if result.get("path").is_some() {
+            return;
+        }
+        if let Some(dl) = &self.services.download
+            && let Some(b) = result.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
+        {
+            let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
+            dl(&std::path::Path::new(&title).with_extension("pdf").to_string_lossy(), &b);
+        }
+    }
+
+    /// Runs a command and shows its error in a message box (for menu/ribbon clicks).
+    /// Follow the desktop's light/dark choice while the app runs (Linux; the desktop app calls
+    /// this once — tests and embedders don't start the watcher thread).
+    pub fn watch_desktop_theme(&mut self) {
+        self.desktop_theme = desktop_theme::DesktopTheme::start();
+    }
+
+    pub fn run_or_alert(&mut self, id: &str, params: Json) {
+        // A menu/shortcut opens the settings first; the Print page's button submits explicitly.
+        if id == "file.print" {
+            if self.services.print_native.is_some() {
+                self.open_backstage(backstage::Page::Print);
+                return;
+            }
+            return self.print_now(params);
+        }
+        // Menu-style Export as PDF with no file named: ask where to save, like Save As does.
+        // Programmatic callers use `run` and keep getting the PDF bytes back.
+        if id == "file.exportPdf" && self.services.pick_save.is_some() && params.get("path").and_then(Json::as_str).is_none_or(str::is_empty) {
+            return self.export_pdf_with_picker(params);
+        }
+        // Recommended Charts with no chart type named (ribbon button, keytip, command search) asks
+        // which chart to insert; programmatic callers of `run` still get the first recommendation.
+        if id == "insert.recommendedCharts" && params.get("type").is_none() {
+            return self.open_dialog("recommendedCharts", json!({}));
+        }
+        // Switch Windows with no window named (key tip, command search) opens the View tab's
+        // list to choose from; programmatic callers of `run` get the list back.
+        if id == "view.switchWindows" && ["window", "doc"].iter().all(|k| params.get(*k).is_none_or(Json::is_null)) {
+            self.ui.ribbon_tab = "View".into();
+            self.ui.ribbon_collapsed = false;
+            self.open_switch_windows = true;
+            return;
+        }
+        match self.run(id, params) {
+            // A refused cell draft already shows its own message (with the rule's title).
+            Err(e) if self.message.as_ref().is_some_and(|(_, m)| *m == e) => {}
+            Err(e) => self.alert(e),
+            Ok(_) => {}
+        }
+    }
+
+    /// Asks for a `.pdf` path with the save picker, then re-runs `file.exportPdf` with it. Other
+    /// params (range, sheets, fitToPage) are kept. A cancelled picker does nothing.
+    fn export_pdf_with_picker(&mut self, mut params: Json) {
+        if !self.commit_edit(0, 0, false, false) {
+            return;
+        }
+        let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
+        let stem = std::path::Path::new(&title).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Book1").to_string();
+        let Some(pick) = &self.services.pick_save else { return };
+        let Some(path) = pick(&format!("{stem}.pdf")) else { return };
+        // The picker may suggest a workbook extension; the export writes a PDF.
+        let path = std::path::Path::new(&path).with_extension("pdf").to_string_lossy().into_owned();
+        match &mut params {
+            Json::Object(map) => {
+                map.insert("path".into(), Json::String(path));
+            }
+            other => *other = json!({"path": path}),
+        }
+        if let Err(e) = self.run("file.exportPdf", params) {
+            self.alert(e);
+        }
+    }
+
+    /// Shows a command error: a toast for an unavailable command, else a message box.
+    fn alert(&mut self, e: String) {
+        // Shown in the window the user ends up in, also after a command that switched windows.
+        self.follow_active_window();
+        if e.contains("is not available right now") {
+            self.toast = Some((e, now_ms()));
+        } else {
+            self.message = Some(("GridCraft".into(), clean_error(&e)));
+        }
+    }
+
+    /// Builds the selected sheets' print-ready PDF and hands it to the desktop worker or the
+    /// browser. Rendering errors use the usual alert; asynchronous spooler errors stay visible
+    /// on the Print page. The engine command still returns PDF bytes without submitting.
+    pub fn print_now(&mut self, params: Json) {
+        if let Err(error) = self.submit_print(params) {
+            self.alert(error);
+        }
+    }
+
+    fn submit_print(&mut self, params: Json) -> Result<Json, String> {
+        if self.services.print_native.is_some() && !self.printing.ready() {
+            return Err("Select an available printer in File > Print before submitting.".into());
+        }
+        let pdf = self.run("file.print", params)?;
+        let encoded = pdf.get("base64").and_then(Json::as_str).ok_or("The print command did not produce a PDF.")?;
+        let bytes = gridcraft_engine::io::base64_decode(encoded).ok_or("Couldn't decode the generated PDF.")?;
+        let len = bytes.len();
+        if let Some(submit) = &self.services.print_native {
+            self.printing.begin(submit(bytes, self.printing.settings.clone())).map_err(|_| "A print job is already being submitted.".to_owned())?;
+            self.print_feedback_seen = None;
+        } else if let Some(print) = &self.services.print {
+            print(&bytes);
+        } else {
+            return Err("Printing is unavailable here; export a PDF instead.".into());
+        }
+        Ok(json!({"printing": true, "bytes": len, "pending": self.services.print_native.is_some()}))
+    }
+
+    /// UI-only commands (dialogs, view toggles that aren't saved in the file).
+    fn run_ui_command(&mut self, id: &str, p: &Json) -> Option<Result<Json, String>> {
+        let r = match id {
+            "app.checkForUpdates" | "help.checkForUpdates" => {
+                self.check_for_updates();
+                Ok(Json::Null)
+            }
+            "ui.printSettings" => printing::settings(&mut self.printing, p, self.services.printers.as_ref()),
+            "ui.printSubmit" => self.submit_print(p.clone()),
+            "ui.ribbonTab" => {
+                self.ui.ribbon_tab = p.get("tab").and_then(Json::as_str).unwrap_or("Home").to_string();
+                Ok(Json::Null)
+            }
+            "view.collapseRibbon" => {
+                self.ui.ribbon_collapsed = !self.ui.ribbon_collapsed;
+                Ok(Json::Null)
+            }
+            "view.expandFormulaBar" => {
+                self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded);
+                Ok(json!({"on": self.ui.formula_bar_expanded}))
+            }
+            "view.darkMode" => {
+                let current = if self.ui.system_theme { self.effective_dark } else { self.ui.dark };
+                self.ui.dark = p.get("on").and_then(Json::as_bool).unwrap_or(!current);
+                self.ui.system_theme = false;
+                Ok(json!({"on": self.ui.dark}))
+            }
+            "view.theme" => {
+                match p.get("mode").and_then(Json::as_str) {
+                    Some("system") => self.ui.system_theme = true,
+                    Some(mode @ ("light" | "dark")) => {
+                        self.ui.dark = mode == "dark";
+                        self.ui.system_theme = false;
+                    }
+                    _ => return Some(Err("theme mode must be system, light, or dark".into())),
+                }
+                Ok(json!({"mode": self.ui.theme_mode()}))
+            }
+            "view.animations" => {
+                self.ui.animations = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.animations);
+                Ok(json!({"on": self.ui.animations}))
+            }
+            "options.autoComplete" => {
+                self.ui.autocomplete = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.autocomplete);
+                Ok(json!({"on": self.ui.autocomplete}))
+            }
+            "view.interfaceScale" => {
+                // `{"percent": 125}` or `{"percent": "auto"}`; out-of-range values are clamped.
+                let percent = match p.get("percent") {
+                    Some(Json::String(s)) if s.eq_ignore_ascii_case("auto") => Some(100),
+                    Some(v) => v.as_f64().and_then(clamp_interface_scale),
+                    None => None,
+                };
+                match percent {
+                    Some(v) => {
+                        self.ui.interface_scale = v;
+                        Ok(json!({"percent": v}))
+                    }
+                    None => Err(format!("missing `percent` ({INTERFACE_SCALE_MIN}–{INTERFACE_SCALE_MAX}, or \"auto\")")),
+                }
+            }
+            "app.language.set" => {
+                // `{"language": "ja"}`; `code` is accepted as an alias.
+                let code = p.get("language").or_else(|| p.get("code")).and_then(Json::as_str).unwrap_or("");
+                match i18n::Language::parse(code) {
+                    Some(l) => {
+                        self.ui.language = l;
+                        Ok(json!({"language": l}))
+                    }
+                    None => Err(format!("unknown language {code:?} (use one of {})", i18n::Language::code_list(", "))),
+                }
+            }
+            "app.language.english" => {
+                self.ui.language = i18n::Language::En;
+                Ok(json!({"language": i18n::Language::En}))
+            }
+            "app.language.japanese" => {
+                self.ui.language = i18n::Language::Ja;
+                Ok(json!({"language": i18n::Language::Ja}))
+            }
+            "ui.backstage" => {
+                // `{"page": "info"}` opens File › Info; `{"page": "close"}` returns to the sheet.
+                match p.get("page").and_then(Json::as_str).map(str::trim) {
+                    Some("close" | "none" | "") => self.backstage = None,
+                    Some(id) => match backstage::Page::parse(id) {
+                        Some(page) => self.open_backstage(page),
+                        None => {
+                            return Some(Err(format!(
+                                "unknown File page {id:?} (use home, new, open, info, saveAs, print, export, options or close)"
+                            )));
+                        }
+                    },
+                    None => self.open_backstage(backstage::Page::Home),
+                }
+                Ok(json!({"page": self.backstage.as_ref().map(|b| b.page.id())}))
+            }
+            "ui.dialog" => {
+                let name = p.get("name").and_then(Json::as_str).unwrap_or("");
+                self.open_dialog(name, p.clone());
+                Ok(json!({"dialog": self.dialog.as_ref().map(|d| d.name())}))
+            }
+            "ui.message.dismiss" => {
+                self.message = None;
+                Ok(Json::Null)
+            }
+            "ui.notice" => Ok(match &self.notice {
+                Some(n) => json!({
+                    "text": n.text,
+                    "kind": match n.kind { NoticeKind::Warning => "warning", NoticeKind::Info => "info" },
+                    "action": n.action,
+                }),
+                None => Json::Null,
+            }),
+            "ui.notice.dismiss" => {
+                self.notice = None;
+                Ok(Json::Null)
+            }
+            _ => return None,
+        };
+        Some(r)
+    }
+
+    /// Picks up requests commands made (dialogs, edit mode…).
+    pub fn after_engine(&mut self) {
+        // The requests belong to the window the command left active.
+        self.follow_active_window();
+        for req in self.session.take_ui_requests() {
+            match req {
+                UiRequest::Dialog(name, params) => self.open_dialog(&name, params),
+                UiRequest::Message(m) => self.message = Some(("GridCraft".into(), m)),
+                UiRequest::EditCell(text) => {
+                    let text = text.map(|text| {
+                        self.session
+                            .active()
+                            .map(|d| formula_locale::display_template(&text, self.ui.language.formula_locale(), &d.wb, d.wb.active_sheet()))
+                            .unwrap_or(text)
+                    });
+                    self.begin_edit(text, false);
+                }
+                UiRequest::InsertName(name) => dialogs::insert_name(self, &name),
+                UiRequest::OpenUrl(u) => {
+                    if let Some(f) = &self.services.open_url {
+                        f(&u);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Whether the active sheet of the active document is protected (drives the Protect/Unprotect
+    /// Sheet labels and actions).
+    pub fn active_sheet_protected(&self) -> bool {
+        self.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false)
+    }
+
+    pub fn open_dialog(&mut self, name: &str, params: Json) {
+        if let Err(e) = self.commit_text_box_edit() {
+            self.message = Some(("Text Box".into(), clean_error(&e)));
+            return;
+        }
+        // Every Protect Sheet entry point (ribbon menus, keytips, tab menu) becomes Unprotect Sheet
+        // on a protected sheet. A sheet without a password is unprotected straight away.
+        let name = if name == "protectSheet" && self.active_sheet_protected() { "unprotectSheet" } else { name };
+        if name == "unprotectSheet"
+            && self
+                .session
+                .active()
+                .and_then(|d| d.wb.active())
+                .and_then(|s| s.protection.as_ref())
+                .is_some_and(|p| p.password.is_none() && p.legacy_password_hash.is_none())
+        {
+            self.run_or_alert("review.unprotectSheet", json!({}));
+            return;
+        }
+        match name {
+            "open" => {
+                if let Some(start) = &self.services.open_async {
+                    start();
+                } else if let Some(pick) = &self.services.pick_open
+                    && let Some(path) = pick()
+                {
+                    self.open_path(&path);
+                }
+            }
+            "saveAs" => {
+                let suggested = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
+                if let Some(pick) = &self.services.pick_save {
+                    if let Some(path) = pick(&suggested) {
+                        let path = if std::path::Path::new(&path).extension().is_none() { format!("{path}.xlsx") } else { path };
+                        self.run_or_alert("file.save", json!({"path": path}));
+                    }
+                } else if self.services.download.is_some()
+                    && let Ok(r) = self.run("file.saveBytes", json!({"format": "xlsx"}))
+                    && let Some(dl) = &self.services.download
+                    && let Some(b) = r.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
+                {
+                    let name = r.get("name").and_then(Json::as_str).unwrap_or("Book.xlsx").to_string();
+                    dl(&name, &b);
+                }
+            }
+            // File › Options (`file.options`) and the File tab itself open the Backstage view.
+            "options" => self.open_backstage(backstage::Page::Options),
+            "backstage" => {
+                let page = params.get("page").and_then(Json::as_str).and_then(backstage::Page::parse).unwrap_or(backstage::Page::Home);
+                self.open_backstage(page);
+            }
+            other => self.dialog = dialogs::Dialog::open(self, other, params),
+        }
+    }
+
+    /// Opens the File tab's Backstage view on `page`, committing a cell still being edited first
+    /// (File actions work on the whole workbook). A draft that can't be committed keeps the sheet.
+    pub fn open_backstage(&mut self, page: backstage::Page) {
+        if !self.chrome.file_tab {
+            return;
+        }
+        if !self.commit_edit(0, 0, false, false) {
+            return;
+        }
+        match &mut self.backstage {
+            Some(b) => b.page = page,
+            None => self.backstage = Some(backstage::Backstage::new(page)),
+        }
+    }
+
+    pub fn open_path(&mut self, path: &str) {
+        match self.run("file.open", json!({"path": path})) {
+            Ok(r) => self.after_open(Some(path), &r),
+            // A password-protected workbook: ask for the password; the dialog opens it.
+            Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => self.open_dialog("openPassword", json!({"path": path})),
+            Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
+        }
+        self.after_engine();
+    }
+
+    /// What follows a successful `file.open`: the workbook shows (not the Backstage), the Recent
+    /// list (for a file on disk) and the open warnings notice. Shared by File › Open, the
+    /// password dialog and the control channel.
+    pub fn after_open(&mut self, path: Option<&str>, r: &Json) {
+        self.backstage = None;
+        if let Some(path) = path {
+            self.ui.recent.retain(|p| p != path);
+            self.ui.recent.insert(0, path.to_string());
+            self.ui.recent.truncate(20);
+        }
+        self.show_open_warnings(r);
+    }
+
+    /// Turns the `warnings` a `file.open` result carries into an info-bar notice, choosing the
+    /// most important one (a preserved VBA project outranks, say, a skipped optional part).
+    /// Kept deliberately generic: any open-time warning can reach the user this way.
+    pub fn show_open_warnings(&mut self, r: &Json) {
+        // The opened workbook's window shows them, however it was opened (a script may have run
+        // `file.open` on the session directly).
+        self.follow_active_window();
+        let Some(list) = r.get("warnings").and_then(Json::as_array) else {
+            self.notice = None;
+            return;
+        };
+        let msgs: Vec<&str> = list.iter().filter_map(Json::as_str).collect();
+        if msgs.is_empty() {
+            // A clean open clears any notice left over from the previous document.
+            self.notice = None;
+            return;
+        }
+        let vba: Vec<&str> = msgs.iter().copied().filter(|m| m.to_lowercase().contains("macro") || m.contains("VBA")).collect();
+        if !vba.is_empty() {
+            // The reader says "dropped" when the VBA project was missing or unreadable; never promise to keep it then.
+            let dropped = vba.iter().any(|m| m.contains("dropped"));
+            let text = if dropped {
+                "This workbook's VBA macros could not be loaded and were dropped, so they will not be in the saved file. Keep the original file."
+            } else {
+                "This workbook contains VBA macros. GridCraft keeps them when you save as .xlsm, but does not run them."
+            };
+            self.notice = Some(Notice { text: text.into(), kind: NoticeKind::Warning, action: Some(("What this means".into(), "macros".into())) });
+        } else {
+            let text = if msgs.len() == 1 {
+                msgs[0].to_string()
+            } else {
+                format!("{} items in this file were handled differently. First: {}", msgs.len(), msgs[0])
+            };
+            self.notice = Some(Notice { text, kind: NoticeKind::Info, action: None });
+        }
+    }
+
+    /// The open windows in order, for the Switch Windows lists.
+    pub fn open_windows(&self) -> Vec<OpenWindow> {
+        let active = self.session.active_window();
+        self.session
+            .windows()
+            .iter()
+            .filter_map(|w| {
+                let d = self.session.documents().iter().find(|d| d.uid == w.doc_uid)?;
+                let title = self.session.window_title(w.id)?;
+                Some(OpenWindow { window: w.id, doc: d.uid, title, dirty: d.is_dirty(), active: active == Some(w.id) })
+            })
+            .collect()
+    }
+
+    /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
+    pub fn view_key(&self) -> Option<(u64, usize)> {
+        self.session.active().map(|d| (d.uid, d.wb.active_sheet()))
+    }
+
+    /// The active window and sheet: each window scrolls on its own.
+    fn scroll_key(&self) -> Option<(u64, usize)> {
+        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet()))
+    }
+
+    pub fn view(&self) -> SheetView {
+        self.scroll_key().and_then(|k| self.views.get(&k).copied()).unwrap_or_else(|| self.saved_view())
+    }
+
+    pub fn view_mut(&mut self) -> Option<&mut SheetView> {
+        let k = self.scroll_key()?;
+        let saved = self.saved_view();
+        Some(self.views.entry(k).or_insert(saved))
+    }
+
+    /// The view a sheet opens with: scrolled to the file's saved first visible cell (`topLeftCell`).
+    fn saved_view(&self) -> SheetView {
+        let Some(sh) = self.session.active().and_then(|d| d.wb.active()) else { return SheetView::default() };
+        if sh.view != gridcraft_engine::model::SheetViewMode::Normal {
+            return SheetView::default();
+        }
+        let (fr, fc) = sh.freeze.unwrap_or((0, 0));
+        let top = sh.view_top_left;
+        let y = sh.row_top(top.row.max(fr)) - sh.row_top(fr);
+        let x = sh.col_left(top.col.max(fc)) - sh.col_left(fc);
+        SheetView { scroll: egui::vec2(x.max(0.0) as f32, y.max(0.0) as f32) }
+    }
+
+    /// Hands the active document's scroll positions (first visible cell per sheet) and active
+    /// cell to the engine so a save writes them (`sheetView topLeftCell`). Normal view only:
+    /// Page Layout view scrolls over pages, not cells.
+    pub fn store_view_state(&mut self) {
+        let window = self.session.active_window();
+        let Some(d) = self.session.active_mut() else { return };
+        let mut tops = Vec::new();
+        for (&(w, si), v) in &self.views {
+            let Some(sh) = d.wb.sheets.get(si).filter(|sh| Some(w) == window && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
+                continue;
+            };
+            let (fr, fc) = sh.freeze.unwrap_or((0, 0));
+            // A hair past the edge so a row that starts exactly at the scroll offset is the one found.
+            let row = sh.row_at(sh.row_top(fr) + v.scroll.y.max(0.0) as f64 + 0.01);
+            let col = sh.col_at(sh.col_left(fc) + v.scroll.x.max(0.0) as f64 + 0.01);
+            tops.push((si, CellRef::new(row, col)));
+        }
+        d.store_view(&tops);
+    }
+
+    /// Starts editing the active cell. `text` replaces the content (typing) or pre-fills it.
+    pub fn begin_edit(&mut self, text: Option<String>, from_formula_bar: bool) {
+        // The source formula is display-only on spill children. Grid replacement keeps its
+        // existing behavior, but no formula-bar entry path may edit that displayed formula.
+        if from_formula_bar && formula_bar::active_spill_anchor(self).is_some() {
+            return;
+        }
+        if let Err(e) = self.commit_text_box_edit() {
+            self.message = Some(("Text Box".into(), clean_error(&e)));
+            return;
+        }
+        let Some(d) = self.session.active() else { return };
+        let Some(sh) = d.wb.active() else { return };
+        let at = sh.merge_at(d.selection.active).map(|m| m.start).unwrap_or(d.selection.active);
+        // A picture has no editable scalar text. Selecting it, F2, or clicking
+        // the formula bar must not turn its fallback value into a text edit.
+        // Typing still starts an intentional replacement.
+        if text.is_none() && sh.cell_pictures.contains_key(&at) {
+            return;
+        }
+        let locale = self.ui.language.formula_locale();
+        let current = if sh.cell_pictures.contains_key(&at) {
+            String::new()
+        } else {
+            match sh.cell(at) {
+                Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet()),
+                _ => gridcraft_engine::display::edit_text(&d.wb, sh, at),
+            }
+        };
+        let (text, replace) = match text {
+            Some(t) => (t, true),
+            None => (current.clone(), false),
+        };
+        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet(), at, text, replace, from_formula_bar);
+        ed.window = self.session.active_window();
+        ed.locale = locale;
+        if replace && self.ui.autocomplete && !ed.is_formula() {
+            ed.completion = editor::column_completion(sh, at, &ed.text);
+        }
+        self.editor = Some(ed);
+        self.session.mode = if replace { gridcraft_engine::Mode::Enter } else { gridcraft_engine::Mode::Edit };
+    }
+
+    /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
+    ///
+    /// The draft goes into the window and workbook it was typed in. If another window is
+    /// showing, that window stays active afterwards; a draft its own workbook refuses
+    /// (validation, a bad formula) brings its window back to the front with the draft still open.
+    pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
+        let Some((doc, window)) = self.editor.as_ref().map(|ed| (ed.doc, ed.window)) else { return true };
+        if !self.draft_elsewhere() {
+            return self.commit_edit_here(dr, dc, array, fill_selection);
+        }
+        // Its window, or (when that window closed) its workbook's most recent one.
+        let Some(owner) = window.filter(|w| self.session.window(*w).is_some()).or_else(|| self.session.doc_window(doc)) else {
+            self.cancel_edit();
+            return true;
+        };
+        let back = self.session.active_window();
+        self.session.activate_window(owner);
+        if !self.commit_edit_here(dr, dc, array, fill_selection) {
+            // Refused: its window stays in front with the draft open and the reason shown.
+            return false;
+        }
+        if let Some(back) = back {
+            self.session.activate_window(back);
+        }
+        true
+    }
+
+    /// The cell draft belongs to a window or workbook other than the one showing.
+    fn draft_elsewhere(&self) -> bool {
+        self.editor.as_ref().is_some_and(|ed| {
+            self.session.active().map(|d| d.uid) != Some(ed.doc) || ed.window.is_some_and(|w| self.session.active_window() != Some(w))
+        })
+    }
+
+    /// Commits the cell and text-box drafts, as Enter would, before a command that can show
+    /// another workbook or write this one to a file, so a draft never lands in another workbook.
+    /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
+    pub(crate) fn settle_drafts(&mut self) -> Result<(), String> {
+        if !self.commit_edit(0, 0, false, false) {
+            return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
+        }
+        self.commit_text_box_edit()
+    }
+
+    fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
+        let Some(ed) = self.editor.take() else { return true };
+        self.session.mode = gridcraft_engine::Mode::Ready;
+        let text = match &ed.completion {
+            Some(full) if full.to_lowercase().starts_with(&ed.text.to_lowercase()) => full.clone(),
+            _ => ed.text.clone(),
+        };
+        // F2 then Enter (or a file command) on an untouched draft: nothing to write.
+        if !fill_selection && !array && ed.original.as_ref() == Some(&text) {
+            if dr != 0 || dc != 0 {
+                self.move_after_enter(dr, dc);
+            }
+            return true;
+        }
+        let text = match self.session.active().map(|d| formula_locale::canonical(&text, ed.locale, &d.wb, ed.sheet, ed.cell)) {
+            Some(Ok(text)) => text,
+            Some(Err(error)) => {
+                self.message = Some(("GridCraft".into(), error.to_string()));
+                self.editor = Some(ed);
+                self.session.mode = gridcraft_engine::Mode::Edit;
+                return false;
+            }
+            None => text,
+        };
+        // Data validation.
+        if let Some(d) = self.session.active()
+            && let Some((dv, msg)) = gridcraft_engine::cmd::data::check_validation(&d.wb, ed.sheet, ed.cell, &text)
+        {
+            if dv.error_style == gridcraft_engine::model::ErrorStyle::Stop {
+                let title = if dv.error_title.is_empty() { "GridCraft".to_string() } else { dv.error_title.clone() };
+                self.message = Some((title, msg));
+                self.editor = Some(ed);
+                self.session.mode = gridcraft_engine::Mode::Edit;
+                return false;
+            }
+            self.toast = Some((msg, now_ms()));
+        }
+        // Point mode can leave another sheet active; the edit belongs to the sheet it started on.
+        if self.session.active().is_some_and(|d| d.wb.active_sheet() != ed.sheet)
+            && let Err(e) = self.session.run("sheet.activate", json!({"sheet": ed.sheet}))
+        {
+            self.message = Some(("GridCraft".into(), clean_error(&e)));
+            self.editor = Some(ed);
+            self.session.mode = gridcraft_engine::Mode::Edit;
+            return false;
+        }
+        // Committing nothing into an empty cell changes nothing: no undo step (#1855, Backspace has
+        // already cleared the cell as its own step).
+        let unchanged = !fill_selection
+            && !array
+            && text.is_empty()
+            && self
+                .session
+                .active()
+                .and_then(|d| d.wb.sheet(ed.sheet))
+                .is_some_and(|sh| sh.cell(ed.cell).is_none_or(|c| c.formula.is_none() && c.value == gridcraft_engine::core::Value::Empty));
+        let r = if unchanged {
+            Ok(json!({}))
+        } else if fill_selection {
+            self.session.run("range.fill", json!({"input": text}))
+        } else {
+            self.session.run("cell.set", json!({"cell": ed.cell.a1(), "input": text, "array": array}))
+        };
+        match r {
+            Ok(_) => {
+                if dr != 0 || dc != 0 {
+                    self.move_after_enter(dr, dc);
+                }
+                self.after_engine();
+                true
+            }
+            Err(e) => {
+                self.message = Some(("GridCraft".into(), clean_error(&e)));
+                self.editor = Some(ed);
+                self.session.mode = gridcraft_engine::Mode::Edit;
+                false
+            }
+        }
+    }
+
+    /// Commits the edit with an arrow key. The arrow is an ordinary move, so it ends a run of Tabs
+    /// instead of continuing it (Right) or going back to its column like Enter (Down), as in Excel.
+    pub fn commit_edit_arrow(&mut self, dr: i64, dc: i64) -> bool {
+        let run = self.tab_run.take();
+        let ok = self.commit_edit(dr, dc, false, false);
+        self.tab_run = if ok { None } else { run };
+        ok
+    }
+
+    pub fn cancel_edit(&mut self) {
+        self.editor = None;
+        self.session.mode = gridcraft_engine::Mode::Ready;
+    }
+
+    /// Enter/Tab move inside a multi-cell selection, otherwise to the next cell.
+    pub fn move_after_enter(&mut self, dr: i64, dc: i64) {
+        let multi = self.session.active().is_some_and(|d| !d.selection.is_single_cell());
+        // Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
+        // last Tab landed on, which ends the run.
+        let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
+        let run = self.tab_run.take().filter(|&(uid, sheet, _, at)| here == Some((uid, sheet, at)));
+        if multi {
+            let fwd = dr > 0 || dc > 0;
+            let _ = self.session.run("selection.next", json!({"forward": fwd, "byRow": dc != 0}));
+        } else if let (Some((_, _, col, at)), 1, 0) = (run, dr, dc) {
+            let back = i64::from(col) - i64::from(at.col);
+            let _ = self.session.run("selection.move", json!({"dr": 1, "dc": back}));
+        } else {
+            let _ = self.session.run("selection.move", json!({"dr": dr, "dc": dc}));
+            if dr == 0 && dc != 0 {
+                let start = run.map(|r| r.2);
+                self.tab_run = self.session.active().and_then(|d| {
+                    let (uid, sheet) = (d.uid, d.wb.active_sheet());
+                    let col = start.or(here.map(|h| h.2.col))?;
+                    Some((uid, sheet, col, d.selection.active))
+                });
+            }
+        }
+        self.grid.ensure_visible = true;
+    }
+
+    /// Terminal feedback also reaches the normal window when printing starts through control.
+    /// Polls printing feedback. Called once per frame from [`Self::logic`]; the direct calls in
+    /// `tests/native_print.rs` deliberately bypass the lifecycle to test this helper alone.
+    pub fn poll_printing(&mut self, ctx: &egui::Context) {
+        self.printing.poll(ctx);
+        if self.printing.message == self.print_feedback_seen {
+            return;
+        }
+        self.print_feedback_seen = self.printing.message.clone();
+        let Some(message @ (printing::Feedback::Submitted(_) | printing::Feedback::Failed(_) | printing::Feedback::WorkerStopped)) =
+            self.printing.message.clone()
+        else {
+            return;
+        };
+        let text = printing::feedback(&message, self.ui.language, |label| self.ui.language.tr(label).to_owned());
+        if matches!(message, printing::Feedback::Submitted(_)) {
+            self.toast = Some((text, now_ms()));
+        } else {
+            self.alert(text);
+        }
+    }
+
+    /// Holds back a window close (the close button, Alt+F4, the OS quitting the app) while a
+    /// workbook has unsaved changes, and asks about them first.
+    fn guard_window_close(&mut self, ctx: &egui::Context) {
+        if self.native_windows || self.allow_close || !ctx.input(|i| i.viewport().close_requested()) {
+            return;
+        }
+        // A cell still being edited is part of the workbook, as for File › Close.
+        if !self.commit_edit(0, 0, false, false) {
+            ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
+            return;
+        }
+        if !self.session.documents().iter().any(|d| d.is_dirty()) {
+            return;
+        }
+        ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
+        match self.dialog.as_mut() {
+            // Already asking about a workbook (File › Close): answering it now goes on to quit.
+            Some(d) if d.name() == "saveChanges" => {
+                d.values.insert("quit".into(), json!(true));
+            }
+            _ => self.continue_quit(ctx),
+        }
+    }
+
+    /// Asks about the next unsaved workbook before quitting, in its window, or closes the app
+    /// once none is left.
+    pub(crate) fn continue_quit(&mut self, ctx: &egui::Context) {
+        let dirty = self.session.documents().iter().find(|d| d.is_dirty()).map(|d| d.uid);
+        match dirty.and_then(|uid| self.session.doc_window(uid)) {
+            Some(window) => {
+                // Its window comes forward (the native window too: see `doc_windows`).
+                self.enter_window(window);
+                let title = self.session.active().map(|d| d.display_title()).unwrap_or_default();
+                self.open_dialog("saveChanges", json!({"title": title, "quit": true}));
+            }
+            None => {
+                self.allow_close = true;
+                ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Close);
+            }
+        }
+    }
+
+    /// Answers the Save Changes question about the active workbook (its buttons). While quitting,
+    /// the next unsaved workbook is asked about once this one is answered; Cancel stops the quit.
+    /// Returns whether the question is settled: Save keeps it open when the cell being edited
+    /// can't be entered.
+    pub fn answer_save_changes(&mut self, answer: SaveAnswer, quitting: bool, ctx: &egui::Context) -> bool {
+        match answer {
+            SaveAnswer::Cancel => {}
+            SaveAnswer::DontSave => {
+                self.run_or_alert("file.close", json!({"force": true, "document": true}));
+                if quitting {
+                    self.continue_quit(ctx);
+                }
+            }
+            SaveAnswer::Save => {
+                // File operations include the cell still being edited, as File › Save does.
+                if !self.commit_edit(0, 0, false, false) {
+                    return false;
+                }
+                self.run_or_alert("file.save", json!({}));
+                if self.session.active().is_some_and(|x| !x.is_dirty()) {
+                    self.run_or_alert("file.close", json!({"force": true, "document": true}));
+                    if quitting {
+                        self.continue_quit(ctx);
+                    }
+                }
+            }
+        }
+        true
+    }
+
+    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, then asks
+    /// about each unsaved workbook in its window; Cancel on any of them stops the quit. A draft its
+    /// workbook refuses stops the quit too, with its window in front and the reason shown.
+    pub fn request_quit(&mut self, ctx: &egui::Context) {
+        while let Some(window) = self.parked_window_with_draft() {
+            self.enter_window(window);
+            if self.settle_drafts().is_err() {
+                return;
+            }
+        }
+        if self.settle_drafts().is_err() {
+            return;
+        }
+        if let Some(d) = self.dialog.as_mut().filter(|d| d.name() == "saveChanges") {
+            // Already asking about a workbook (File › Close): answering it goes on to quit.
+            d.values.insert("quit".into(), json!(true));
+            return;
+        }
+        self.continue_quit(ctx);
+    }
+
+    /// Per-frame logic (control channel, screenshots). Call before `ui`.
+    pub fn logic(&mut self, ctx: &egui::Context) {
+        self.ensure_text_width(ctx);
+        // A keytip control request lives one frame: the ribbon consumes it during `ui`, and
+        // anything that never reached a control (collapsed ribbon, tab switch) is dropped.
+        self.ui.keytip_invoke = None;
+        // Floating pictures' textures go with their workbook, even when no sheet is painted.
+        let open: Vec<u64> = self.session.documents().iter().map(|d| d.uid).collect();
+        floating_pictures::forget_closed(ctx, &open);
+        self.apply_font_state(ctx);
+        if let Some(answer) = self.desktop_theme.take_change() {
+            self.desktop_dark = Some(answer);
+        }
+        self.sync_theme_preference(ctx);
+        self.sync_input_options(ctx);
+        // The geometry captures are bound to. Native frames recorded it from their fresh
+        // `RawInput` in `raw_input_hook` (including hidden logic-only ticks); the epoch is
+        // monotonic, so a resize back to the original values is still a new epoch and old pixels
+        // are never saved with new geometry.
+        let capture_geometry = control::current_capture_geometry(self, ctx);
+        control::note_capture_geometry(self, capture_geometry);
+        // Drain before admission: completed or timed-out captures release their slots and
+        // reservation first, so a new request is never refused for budget that is about to free.
+        // Screenshot results, deadlines and geometry validation belong to `logic`; `ui` only
+        // issues the capture command (after every widget, so a command cannot be missed).
+        control::drain_screenshots(self, ctx);
+        control::poll(self, ctx);
+        // Printing feedback is polled once per frame, here, so hidden windows and logic-only
+        // frames still see worker completion. `ui` and the desktop app no longer poll it.
+        self.poll_printing(ctx);
+        self.guard_window_close(ctx);
+        #[cfg(not(target_arch = "wasm32"))]
+        updates_ui::tick(self, ctx);
+        // Files read asynchronously (web file picker, dropped files).
+        self.poll_async_opens();
+        self.autosave(ctx);
+        self.update_title(ctx);
+        self.request_hidden_paint(ctx);
+        // One window always shows a workbook, unless each workbook has a native window of its own
+        // (`doc_windows` decides what having none left means).
+        if self.session.active().is_none() && !self.native_windows {
+            self.session.new_workbook();
+        }
+        self.follow_active_window();
+    }
+
+    /// Installs the text-width closure once, on the first frame.
+    fn ensure_text_width(&mut self, ctx: &egui::Context) {
+        if self.session.text_width.is_some() {
+            return;
+        }
+        let ctx = ctx.clone();
+        self.session.text_width = Some(std::sync::Arc::new(move |text, font, exact| theme::cell_text_width(&ctx, text, font, exact)));
+    }
+
+    /// Applies the font gates: a language Han-order change, startup/prepared fonts and workbook
+    /// font binding. Every branch keeps its one-frame paint gate.
+    fn apply_font_state(&mut self, ctx: &egui::Context) {
+        // A pending synthetic step owns the next real `ui` pass: `ui` returns at the font gate
+        // before it handles input, so a font change requested now would consume the step without
+        // applying it. Delay the change one frame; the hidden-paint request keeps it coming.
+        let defer_font_change = self.synthetic_pending || !self.synthetic.is_empty();
+        if !defer_font_change && self.fonts_han.is_some_and(|han| han != theme::HanOrder::of(self.ui.language)) {
+            self.fonts_ready = false;
+            self.fonts_set = false;
+        }
+        if !self.fonts_ready {
+            self.start_font_setup(ctx);
+        } else if self.fonts_rebind {
+            // A font-set change made last frame is active now.
+            self.fonts_rebind = false;
+        } else if !defer_font_change && !self.prepared_fonts && fonts::scan_done() {
+            self.rebind_workbook_fonts(ctx);
+        }
+    }
+
+    /// Applies the pending font set. New fonts apply from the next frame on: paint nothing until
+    /// then. Startup always proceeds: without it a queued step would be re-offered forever.
+    fn start_font_setup(&mut self, ctx: &egui::Context) {
+        if self.fonts_set {
+            self.fonts_ready = true;
+            return;
+        }
+        if self.prepared_fonts {
+            ctx.set_fonts(theme::pinned_font_definitions());
+            theme::apply(ctx, self.ui.dark);
+        } else {
+            SheetApp::setup_context_for_language(ctx, self.ui.dark, self.ui.language);
+        }
+        self.fonts_set = true;
+        // The rebuilt set has no workbook fonts yet: bind them again once it is active.
+        self.fonts_bound.clear();
+        self.fonts_seen = (0, 0);
+        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
+        ctx.request_repaint();
+    }
+
+    /// Binds the workbook's installed fonts once the background scan has finished. Adding fonts
+    /// re-applies the font set, which egui activates at the next pass, so skip this frame's paint
+    /// (same one-frame cost as startup). Only when an open workbook changed.
+    fn rebind_workbook_fonts(&mut self, ctx: &egui::Context) {
+        let seen = self.fonts_key();
+        if seen == self.fonts_seen {
+            return;
+        }
+        let used = self.used_fonts();
+        self.fonts_seen = seen;
+        if used == self.fonts_bound {
+            return;
+        }
+        ctx.set_fonts(theme::font_definitions_with(self.ui.language, &used));
+        self.fonts_bound = used;
+        self.fonts_rebind = true;
+        ctx.request_repaint();
+    }
+
+    /// Follows the desktop/system theme preference and records the effective theme.
+    fn sync_theme_preference(&mut self, ctx: &egui::Context) {
+        let preference = match (
+            self.ui.system_theme,
+            ctx.system_theme().or_else(|| self.desktop_dark.map(|d| if d { egui::Theme::Dark } else { egui::Theme::Light })),
+        ) {
+            (true, Some(egui::Theme::Dark)) => egui::ThemePreference::Dark,
+            (true, Some(egui::Theme::Light)) => egui::ThemePreference::Light,
+            _ => self.ui.theme_preference(),
+        };
+        if ctx.options(|o| o.theme_preference) != preference {
+            ctx.set_theme(preference);
+            ctx.request_repaint();
+        }
+        self.effective_dark = ctx.theme() == egui::Theme::Dark;
+    }
+
+    /// Keeps egui's own keyboard zoom and quit shortcuts off and applies GridCraft's zoom factor.
+    fn sync_input_options(&mut self, ctx: &egui::Context) {
+        // Interface size: the preference owns the zoom factor, so egui's own Ctrl/Cmd +/-/0 zoom
+        // keys stay off (they would also swallow GridCraft's shortcuts).
+        if ctx.options(|o| o.zoom_with_keyboard) {
+            ctx.options_mut(|o| o.zoom_with_keyboard = false);
+        }
+        // egui closes the window on Ctrl+Q (and with Shift or Alt held too) without asking to save
+        // (#1443). Excel for Windows has no such key (Ctrl+Q is Quick Analysis). With a native
+        // window per workbook egui's Cmd+Q would close only the window it was typed in: the menu
+        // bar's Quit item has the key instead (it asks about unsaved workbooks first).
+        if (ctx.os() != egui::os::OperatingSystem::Mac || self.native_windows) && ctx.options(|o| !o.quit_shortcuts.is_empty()) {
+            ctx.options_mut(|o| o.quit_shortcuts.clear());
+        }
+        let zoom = self.ui.zoom_factor();
+        if (ctx.zoom_factor() - zoom).abs() > 0.001 {
+            ctx.set_zoom_factor(zoom);
+            ctx.request_repaint();
+        }
+    }
+
+    /// Opens files that arrived asynchronously (web file picker, dropped files).
+    fn poll_async_opens(&mut self) {
+        let arrived: Vec<(String, Vec<u8>)> = self
+            .services
+            .inbox
+            .as_ref()
+            .map(|i| std::mem::take(&mut *i.lock().unwrap_or_else(std::sync::PoisonError::into_inner)))
+            .unwrap_or_default();
+        for (name, bytes) in arrived {
+            let b64 = gridcraft_engine::io::base64_encode(&bytes);
+            match self.run("file.open", json!({"name": &name, "base64": &b64})) {
+                // A file picked from File › Open (web) arrives here: show it, not the Backstage.
+                Ok(r) => {
+                    self.backstage = None;
+                    self.show_open_warnings(&r);
+                }
+                Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => {
+                    self.backstage = None;
+                    self.open_dialog("openPassword", json!({"name": name, "base64": b64}));
+                }
+                Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
+            }
+            self.after_engine();
+        }
+    }
+
+    /// AutoSave: save workbooks that have a file shortly after they change. This decision lives in
+    /// `logic` so a hidden or logic-only frame still saves; the monotonic timestamp check keeps a
+    /// forced hidden UI pass from saving the same change twice.
+    fn autosave(&mut self, ctx: &egui::Context) {
+        let dirty_xlsx = self.session.active().is_some_and(|d| d.is_dirty() && d.path.as_deref().is_some_and(|p| p.ends_with(".xlsx")));
+        let now = crate::monotonic_ms();
+        let autosave_due =
+            self.ui.autosave && self.editor.is_none() && self.text_box_editor.is_none() && now - self.grid.last_autosave > 2000.0 && dirty_xlsx;
+        if autosave_due {
+            self.grid.last_autosave = now;
+            self.store_view_state();
+            let _ = self.session.run("file.save", json!({}));
+        } else if self.ui.autosave && dirty_xlsx {
+            // Keep checking even when no input arrives while the window is hidden.
+            ctx.request_repaint_after(std::time::Duration::from_secs(2));
+        }
+    }
+
+    /// Look for a newer release once, in the background, as the desktop app starts (a no-op on the
+    /// web). A found release opens the update prompt; nothing is shown when GridCraft is current.
+    pub fn start_update_check(&mut self) {
+        #[cfg(not(target_arch = "wasm32"))]
+        updates_ui::start(self, false);
+    }
+
+    /// Help ▸ Check for Updates…: look now, and say so when GridCraft is up to date or the check fails.
+    pub fn check_for_updates(&mut self) {
+        #[cfg(not(target_arch = "wasm32"))]
+        updates_ui::start(self, true);
+        #[cfg(target_arch = "wasm32")]
+        {
+            self.message = Some(("GridCraft".into(), "The web version is always the latest release.".into()));
+        }
+    }
+
+    /// Window title, next to the close/autosave state: `ViewportCommand::Title` is valid outside a
+    /// pass and a control-channel rename while hidden updates it on return.
+    fn update_title(&mut self, ctx: &egui::Context) {
+        // Native windows get theirs from `doc_windows`.
+        if self.native_windows {
+            return;
+        }
+        let Some(d) = self.session.active() else { return };
+        let title = format!("{}{}", d.display_title(), if d.is_dirty() { " — Edited" } else { "" });
+        if self.grid.last_title.as_deref() != Some(title.as_str()) {
+            ctx.send_viewport_cmd(egui::ViewportCommand::Title(title.clone()));
+            self.grid.last_title = Some(title);
+        }
+    }
+
+    /// A queued/settling capture with a capturable size and an unapplied synthetic step both need
+    /// a real `ui` pass. Once a capture is issued, its `Screenshot` command's own `wants_paint`
+    /// paints the hidden window; after that a full hidden pass every frame only wastes CPU. A
+    /// minimized request has no size, so no hidden pass can reach issuance: the restore pass issues
+    /// it instead. Native eframe honours `RequestPaintWhileHidden`; the web runner does not (hidden
+    /// tabs only run `run_logic`), so a hidden web tab queues the work until it is shown again.
+    /// This is a shared eframe web follow-up, not a GridCraft-local workaround, and the control
+    /// protocol documents the limitation.
+    fn request_hidden_paint(&self, ctx: &egui::Context) {
+        if !(self.shots.needs_hidden_paint() || self.synthetic_pending || !self.synthetic.is_empty()) {
+            return;
+        }
+        // The web runner has no `RequestPaintWhileHidden`; sending it there only logs an
+        // unhandled command. A visible tab still gets the repaint below; a hidden tab keeps the
+        // work queued (see the shared eframe follow-up in docs/egui-037-local-followups.md).
+        #[cfg(not(target_arch = "wasm32"))]
+        ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
+        ctx.request_repaint();
+    }
+
+    /// Records capture geometry from the fresh raw frame, then offers exactly one pending synthetic batch and tracks whether it was applied.
+    pub fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
+        // Capture geometry from this frame's real input before any synthetic event is added. This
+        // runs on every native frame, including hidden/minimized logic-only ticks, so a resize,
+        // DPI/zoom change, Wayland frame without `inner_rect`, or minimize/restore is recorded
+        // even though egui's last UI pass still describes the old layout.
+        let geometry = control::CaptureGeometry::from_raw_input(raw, ctx);
+        control::note_capture_geometry(self, geometry);
+        self.capture_geometry_from_raw = true;
+        // One unapplied gesture step at a time. eframe retains an unconsumed `RawInput` for the
+        // next pass and for a hidden logic-only tick, so the batch is offered once and survives
+        // until a `ui` pass applies it (which pops it). Press and release stay distinct batches.
+        //
+        // A completed egui pass may have consumed the injected events without applying them: the
+        // font gate returns before input handling, but `begin_pass` has already taken the events.
+        // `cumulative_pass_nr` only advances when a pass ends, so a newer value with the batch
+        // still pending means exactly that, and the step is offered again for the next real pass.
+        if self.synthetic_pending {
+            let consumed_by_an_unapplied_pass = self.synthetic_injected_at_pass.is_some_and(|pass| ctx.cumulative_pass_nr() > pass);
+            if !consumed_by_an_unapplied_pass {
+                return;
+            }
+        }
+        if let Some(batch) = self.synthetic.front() {
+            raw.events.extend(batch.iter().cloned());
+            self.synthetic_pending = true;
+            self.synthetic_injected_at_pass = Some(ctx.cumulative_pass_nr());
+        }
+    }
+
+    /// Flip AutoSave (title-bar switch / Options ▸ Save). Persisted with the other UI
+    /// preferences, so it stays as the user left it across restarts (#1901).
+    pub fn toggle_autosave(&mut self) {
+        self.ui.autosave = !self.ui.autosave;
+    }
+
+    /// Lays out the whole window.
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        let ctx = ui.ctx().clone();
+        if !self.fonts_ready || self.fonts_rebind {
+            ctx.request_repaint();
+            return;
+        }
+        let t0 = now_ms();
+        // A script may have switched windows since the last frame.
+        self.follow_active_window();
+        text_box::before_ui(self, &ctx);
+        // Another window came forward without going through a command (which settles drafts
+        // first): the draft goes into its own window instead of floating over this one. If its
+        // workbook refuses it, its window comes back to the front with the draft open.
+        if self.draft_elsewhere() {
+            self.commit_edit(0, 0, false, false);
+        }
+        // The language the widgets translate with this frame (see `i18n::current`).
+        i18n::set_current(&ctx, self.ui.language);
+        #[cfg(not(target_arch = "wasm32"))]
+        updates_ui::show(self, &ctx);
+        let t = theme::Tokens::get(&ctx);
+        // A host can turn the File tab off while Backstage is already open: close it.
+        if !self.chrome.file_tab {
+            self.backstage = None;
+        }
+        // Keytips opened the File view (Alt, F): its letters keep working there.
+        if self.backstage.is_none() || self.keytips.prefix().is_some() {
+            self.ribbon_keys(&ctx);
+        }
+        if self.chrome.title_bar {
+            ribbon::title_bar(self, ui);
+        }
+        if self.backstage.is_some() {
+            // File tab: the Backstage view replaces everything below the title bar.
+            backstage::show(self, ui);
+        } else {
+            ribbon::show(self, ui);
+            widgets::notice_bar(self, ui);
+            if self.session.prefs.formula_bar {
+                formula_bar::show(self, ui);
+            }
+            if self.ui.status_bar {
+                tabs::status_bar(self, ui);
+            }
+            tabs::sheet_tabs(self, ui);
+            pivot_pane::show(self, ui);
+            panes::show(self, ui);
+            egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.grid_bg)).show(ui, |ui| {
+                let g0 = now_ms();
+                grid::show(self, ui);
+                self.perf.grid_ms = now_ms() - g0;
+            });
+        }
+        dialogs::show(self, &ctx);
+        widgets::message_box(self, &ctx);
+        widgets::toast(self, &ctx);
+        // Requests are admitted in `logic`, for the root viewport, so only its pass issues them.
+        if ctx.viewport_id() == egui::ViewportId::ROOT {
+            control::issue_screenshots(self, &ctx);
+        }
+        if !ctx.input(|i| i.focused) {
+            // Nothing else to do.
+        }
+        let now = now_ms();
+        self.perf.frame_ms = now - t0;
+        if self.perf.last > 0.0 {
+            let dt = now - self.perf.last;
+            if dt > 0.0 {
+                self.perf.fps = self.perf.fps * 0.9 + 100.0 / dt;
+            }
+        }
+        self.perf.last = now;
+        // The step is applied only after a completed UI pass. A discarded or repeated pass of the
+        // same frame must not offer it again (grid sizing calls `ui` more than once per frame);
+        // provenance is the injected pass number, so only a pass that missed input handling is
+        // re-offered by `raw_input_hook`.
+        // Synthetic input reaches the root viewport only (`raw_input_hook`), so its pass consumes it.
+        if self.synthetic_pending && ctx.viewport_id() == egui::ViewportId::ROOT {
+            self.synthetic.pop_front();
+            self.synthetic_pending = false;
+            self.synthetic_injected_at_pass = None;
+        }
+    }
+
+    fn ribbon_keys(&mut self, ctx: &egui::Context) {
+        let before = self.keytips.prefix().map(str::to_string);
+        let enabled = self.editor.is_none()
+            && self.dialog.is_none()
+            && self.message.is_none()
+            && self.name_box.is_none()
+            && !ctx.text_edit_focused()
+            && self.grid.context_menu.is_none()
+            && self.grid.object_menu.is_none()
+            && self.grid.header_menu.is_none()
+            && self.grid.fill_menu.is_none()
+            && self.grid.filter_menu.is_none()
+            && self.grid.list_picker.is_none()
+            && self.grid.renaming_tab.is_none()
+            && (before.is_some() || !egui::Popup::is_any_open(ctx));
+        let actions = self.keytips.process(ctx, enabled);
+        // Backing out of F to the tab letters, or finishing an F sequence, closes the File view
+        // that Alt, F opened: the command runs on the sheet, as it did without the view.
+        if self.backstage.is_some() && before.is_some() && (self.keytips.prefix() == Some("") || !actions.is_empty()) {
+            self.backstage = None;
+        }
+        if before.is_some() && before.as_deref() != self.keytips.prefix() && !ctx.input(|i| i.pointer.any_pressed()) {
+            // Leave pointer cancellation to the popup so clicking a menu item still works.
+            egui::Popup::close_all(ctx);
+        }
+        for action in actions {
+            match action {
+                keytips::Action::Tab("File") => self.open_backstage(backstage::Page::Home),
+                keytips::Action::Tab(tab) => {
+                    self.run_or_alert("ui.ribbonTab", json!({"tab": tab}));
+                    self.ui.ribbon_collapsed = false;
+                }
+                keytips::Action::Command(id @ ("edit.copy" | "edit.cut")) => self.copy_to_clipboard(ctx, id),
+                keytips::Action::Command("edit.paste") => self.paste_from_clipboard(),
+                keytips::Action::Command(id) => self.run_or_alert(id, json!({})),
+                keytips::Action::CommandWith(id, params) => {
+                    let params: Json = serde_json::from_str(params).unwrap_or_else(|_| json!({}));
+                    // A Borders preset picked by key tip becomes the split button's face, as a
+                    // click on the same menu item does.
+                    if id == "home.borders"
+                        && let Some(preset) = params.get("preset").and_then(Json::as_str)
+                    {
+                        self.grid.last_border = preset.to_string();
+                    }
+                    self.run_or_alert(id, params);
+                }
+                keytips::Action::Dialog(name) => self.open_dialog(name, json!({})),
+                keytips::Action::DialogWith(name, params) => self.open_dialog(name, serde_json::from_str(params).unwrap_or_else(|_| json!({}))),
+                // Reserved sequence: fires silently while its command is missing. When the
+                // command lands in the catalog it goes live with no table edit.
+                keytips::Action::Pending(id) => {
+                    if gridcraft_engine::find_command(id).is_some() {
+                        self.run_or_alert(id, json!({}));
+                    }
+                }
+                // Route to the ribbon control that owns this keytip: it opens its dropdown or
+                // runs its click handler with the right params (the engine command alone would
+                // be missing them).
+                keytips::Action::Control(id) => self.ui.keytip_invoke = Some(id),
+            }
+        }
+    }
+
+    /// Current selection's top-left cell text as A1 (for the Name Box).
+    pub fn name_box_text(&self) -> String {
+        let Some(d) = self.session.active() else { return String::new() };
+        let sel = &d.selection;
+        let cur = sel.current();
+        // A named range that exactly matches shows its name.
+        let sh = d.wb.active();
+        if let Some(sh) = sh {
+            for n in &d.wb.names {
+                let target = n.formula.replace('$', "");
+                let (sheet, body) = match target.rsplit_once('!') {
+                    Some((s, b)) => (Some(gridcraft_engine::core::unquote_sheet(s)), b.to_string()),
+                    None => (None, target.clone()),
+                };
+                if sheet.as_deref().is_none_or(|s| s.eq_ignore_ascii_case(&sh.name)) && RangeRef::parse(&body) == Some(cur) {
+                    return n.name.clone();
+                }
+            }
+        }
+        if self.grid.drag_select && !cur.is_single() {
+            return format!("{}R x {}C", cur.height(), cur.width());
+        }
+        sel.active.a1()
+    }
+}
+
+#[cfg(test)]
+mod lifecycle_tests {
+    use super::*;
+
+    /// Builds a key-A press or release event without modifiers.
+    fn key_event(pressed: bool) -> egui::Event {
+        egui::Event::Key { key: egui::Key::A, physical_key: None, pressed, repeat: false, modifiers: egui::Modifiers::NONE }
+    }
+
+    /// Returns a test app with a new workbook and default services.
+    fn app() -> SheetApp {
+        let mut session = Session::new();
+        session.new_workbook();
+        SheetApp::new(session, Services::default())
+    }
+
+    /// One headless pass; a test has no renderer for the texture atlas delta (0.37 panics when it
+    /// is dropped unapplied).
+    fn ui_pass(ctx: &egui::Context, raw: egui::RawInput, f: impl FnMut(&mut egui::Ui)) -> egui::FullOutput {
+        let mut out = ctx.run_ui(raw, f);
+        out.textures_delta.clear();
+        out
+    }
+
+    #[test]
+    /// Only one synthetic step is offered, is not duplicated by a hidden logic-only tick, and press/release remain distinct batches.
+    fn a_hidden_logic_tick_keeps_one_unapplied_synthetic_step() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.synthetic.push_back(vec![key_event(true)]);
+        app.synthetic.push_back(vec![key_event(false)]);
+
+        let mut first = egui::RawInput::default();
+        app.raw_input_hook(&ctx, &mut first);
+        assert_eq!(first.events.len(), 1, "only one step is offered");
+        assert!(app.synthetic_pending);
+        assert_eq!(app.synthetic.len(), 2, "a logic-only frame does not consume the step");
+
+        // eframe carries the unconsumed `RawInput` into the next pass, so the hook offers the step
+        // only once; a hidden logic-only tick does not duplicate it or offer the release.
+        let mut second = egui::RawInput::default();
+        app.raw_input_hook(&ctx, &mut second);
+        assert!(second.events.is_empty(), "an unapplied step is not injected a second time");
+        assert_eq!(app.synthetic.len(), 2, "press and release stay distinct batches");
+    }
+
+    /// Returns raw input with a screen rect at the given size.
+    fn raw_with_size(size: egui::Vec2) -> egui::RawInput {
+        egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() }
+    }
+
+    #[test]
+    /// A font-gated early-returning pass does not lose the queued step; the hook offers it again and a later real pass applies it.
+    fn a_font_gated_pass_offers_the_synthetic_step_again() {
+        let ctx = egui::Context::default();
+        ctx.set_fonts(theme::font_definitions());
+        let mut app = app();
+        app.fonts_ready = true;
+        app.fonts_set = true;
+        // Binds `session.text_width`, as eframe's first frame does.
+        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        app.synthetic.push_back(vec![key_event(true)]);
+
+        // The font gate returns before input handling; `begin_pass` has still consumed the events.
+        app.fonts_rebind = true;
+        let mut raw = raw_with_size(egui::vec2(900.0, 700.0));
+        app.raw_input_hook(&ctx, &mut raw);
+        assert_eq!(raw.events.len(), 1);
+        let _ = ui_pass(&ctx, raw, |ui| app.ui(ui));
+        assert!(app.synthetic_pending, "the early-returning pass did not apply the step");
+        assert_eq!(app.synthetic.len(), 1, "the step is still queued");
+
+        // A completed pass that did not apply it made the hook offer it again for a real pass.
+        app.fonts_rebind = false;
+        let mut raw = raw_with_size(egui::vec2(900.0, 700.0));
+        app.raw_input_hook(&ctx, &mut raw);
+        assert_eq!(raw.events.len(), 1, "the step is not lost across the font gate");
+        let _ = ui_pass(&ctx, raw, |ui| app.ui(ui));
+        assert!(!app.synthetic_pending);
+        assert!(app.synthetic.is_empty(), "the real UI pass applied the step");
+    }
+
+    #[test]
+    /// A language-driven font rebuild waits while a synthetic step is pending and proceeds once it is clear.
+    fn a_pending_step_delays_a_font_change() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.fonts_ready = true;
+        app.fonts_han = Some(theme::HanOrder::Chinese);
+        app.ui.language = i18n::Language::Ja;
+        app.synthetic.push_back(vec![key_event(true)]);
+        app.synthetic_pending = true;
+        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        assert!(app.fonts_ready, "the font rebuild waits for the pass that applies the step");
+        app.synthetic.clear();
+        app.synthetic_pending = false;
+        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        assert!(!app.fonts_ready, "without pending input the language rebuild proceeds");
+    }
+
+    #[test]
+    /// Logic ticks see fresh viewport and DPI information; resizing back to the original size still advances the capture epoch.
+    fn a_hidden_logic_tick_sees_fresh_viewport_info_and_keeps_the_epoch_monotonic() {
+        /// Runs one logic tick with the requested width and native scale.
+        fn tick(ctx: &egui::Context, app: &mut SheetApp, width: f32, native_ppp: f32) {
+            let mut raw =
+                egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0))), ..Default::default() };
+            if let Some(viewport) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
+                viewport.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0)));
+                viewport.native_pixels_per_point = Some(native_ppp);
+            }
+            let _ = ctx.run_logic(&raw, |ctx| app.logic(ctx));
+        }
+        let ctx = egui::Context::default();
+        let mut app = app();
+        tick(&ctx, &mut app, 800.0, 2.0);
+        let first = app.capture_geometry.expect("the first logic tick records the geometry");
+        assert_eq!(first.viewport, Some(egui::vec2(800.0, 400.0)));
+        assert_eq!(first.pixels_per_point, 2.0, "native scale times the interface zoom");
+        tick(&ctx, &mut app, 900.0, 2.0);
+        let resized = app.capture_geometry.expect("geometry");
+        assert_eq!(resized.viewport, Some(egui::vec2(900.0, 400.0)), "run_logic's ViewportInfo is the fresh size");
+        let epoch = app.capture_epoch;
+        tick(&ctx, &mut app, 800.0, 2.0);
+        assert_eq!(app.capture_geometry.map(|g| g.viewport), Some(Some(egui::vec2(800.0, 400.0))));
+        assert!(app.capture_epoch > epoch, "resizing back is still a new epoch: old pixels must not be saved");
+    }
+
+    #[test]
+    /// A resize and a resize back both advance the capture epoch.
+    fn the_capture_epoch_changes_even_when_the_geometry_returns() {
+        /// Runs one UI pass at the requested width.
+        fn tick(ctx: &egui::Context, app: &mut SheetApp, width: f32) {
+            let raw =
+                egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0))), ..Default::default() };
+            let _ = ui_pass(ctx, raw, |ui| app.logic(ui.ctx()));
+        }
+        let ctx = egui::Context::default();
+        let mut app = app();
+        tick(&ctx, &mut app, 800.0);
+        let base = app.capture_epoch;
+        tick(&ctx, &mut app, 900.0);
+        let changed = app.capture_epoch;
+        assert!(changed > base, "a resize increments the capture epoch");
+        tick(&ctx, &mut app, 800.0);
+        assert!(app.capture_epoch > changed, "resizing back is still a new epoch: old pixels must not be saved");
+    }
+
+    /// Extracts title viewport commands from a logic output.
+    fn titles(out: &egui::LogicOutput) -> Vec<String> {
+        out.viewport_commands
+            .values()
+            .flatten()
+            .filter_map(|c| match c {
+                egui::ViewportCommand::Title(title) => Some(title.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    #[test]
+    /// A hidden logic tick saves a dirty file-backed workbook once and clears its dirty state.
+    fn a_logic_only_tick_autosaves_a_dirty_workbook_once() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        let dir = std::env::temp_dir().join(format!("gridcraft-logic-autosave-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("autosave.xlsx");
+        app.run("cell.set", serde_json::json!({"cell": "A1", "input": "42"})).unwrap();
+        app.ui.autosave = true;
+        app.session.active_mut().unwrap().path = Some(path.to_string_lossy().into_owned());
+        app.grid.last_autosave = monotonic_ms() - 3000.0;
+
+        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        assert!(path.exists(), "a hidden logic-only tick saves a dirty workbook with a file");
+        assert!(!app.session.active().unwrap().is_dirty(), "the save clears the dirty state");
+        let saved_at = app.grid.last_autosave;
+        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        assert_eq!(app.grid.last_autosave, saved_at, "the same change is not saved a second time");
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    /// The title is sent on the first tick and after a rename, but not on every unchanged frame.
+    fn a_logic_only_tick_updates_the_title_once_per_change() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        let first = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        let title = app.session.active().unwrap().display_title().to_string();
+        let expected = format!("{title}{}", if app.session.active().unwrap().is_dirty() { " — Edited" } else { "" });
+        assert_eq!(titles(&first), [expected], "the first logic tick titles the window");
+        let second = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        assert!(titles(&second).is_empty(), "an unchanged title is not sent every frame");
+
+        app.session.active_mut().unwrap().title = "Renamed".into();
+        let third = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        let expected = format!("Renamed{}", if app.session.active().unwrap().is_dirty() { " — Edited" } else { "" });
+        assert_eq!(titles(&third), [expected], "a rename while hidden updates the title");
+    }
+
+    #[test]
+    /// A hidden tick surfaces a failed print job in the app message.
+    fn a_logic_only_tick_polls_printing_feedback() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.printing.printers.push(crate::printing::Printer { name: "Queue".into(), label: String::new(), default: true });
+        app.run("ui.printSettings", serde_json::json!({"printer": "Queue"})).unwrap();
+        app.services.print_native = Some(Box::new(|_, _| {
+            let (sender, receiver) = std::sync::mpsc::channel();
+            sender.send(Err("printer is offline".into())).unwrap();
+            receiver
+        }));
+        app.run("ui.printSubmit", serde_json::json!({})).unwrap();
+        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
+        assert_eq!(app.printing.message, Some(crate::printing::Feedback::Failed("printer is offline".into())));
+        assert!(app.message.as_ref().is_some_and(|(_, text)| text.contains("printer is offline")), "logic surfaces the failure");
+    }
+
+    #[test]
+    /// Pending synthetic input makes logic request a real hidden paint.
+    fn a_pending_synthetic_step_requests_a_hidden_paint() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.synthetic.push_back(vec![key_event(true)]);
+        app.synthetic_pending = true;
+        let out = ui_pass(&ctx, egui::RawInput::default(), |ui| app.logic(ui.ctx()));
+        let painted = out
+            .viewport_output
+            .get(&ctx.viewport_id())
+            .is_some_and(|output| output.commands.iter().any(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)));
+        assert!(painted, "logic must ask for a real UI pass while a synthetic step is unapplied");
+    }
+}
diff --git a/crates/ui-egui/src/clock.rs b/crates/ui-egui/src/clock.rs
new file mode 100644
index 000000000..ca1b57783
--- /dev/null
+++ b/crates/ui-egui/src/clock.rs
@@ -0,0 +1,25 @@
+/// Wall-clock milliseconds since the Unix epoch, for user-visible timestamps (Backstage's "last
+/// changed", toasts). It can jump when the system clock is adjusted, so it must not drive
+/// deadlines or pacing; use [`monotonic_ms`] for those.
+pub fn now_ms() -> f64 {
+    gridcraft_engine::core::date::unix_now_ms().unwrap_or(0.0)
+}
+
+/// Monotonic milliseconds since the first call, for screenshot deadlines and AutoSave pacing.
+///
+/// Deliberately separate from [`now_ms`]: a wall-clock adjustment must not extend (or expire) a
+/// screenshot deadline or save a workbook twice. Native uses [`std::time::Instant`]; wasm uses the
+/// browser's `performance.now()`, which is monotonic too.
+#[cfg(not(target_arch = "wasm32"))]
+#[allow(clippy::disallowed_methods)] // the std clock is read only off wasm
+pub fn monotonic_ms() -> f64 {
+    use std::sync::OnceLock;
+    static START: OnceLock<std::time::Instant> = OnceLock::new();
+    START.get_or_init(std::time::Instant::now).elapsed().as_secs_f64() * 1000.0
+}
+
+#[cfg(target_arch = "wasm32")]
+/// Web monotonic clock: the browser's `performance.now()`, or 0 when it is unavailable.
+pub fn monotonic_ms() -> f64 {
+    web_sys::window().and_then(|window| window.performance()).map_or(0.0, |performance| performance.now())
+}
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 55b3bd740..421f71459 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -52,6 +52,15 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Value as Json, json};
 
 pub use control::{ControlRequest, ControlResponse};
+
+mod app;
+mod clock;
+mod services;
+mod state;
+
+pub use clock::{monotonic_ms, now_ms};
+pub use services::{Chrome, Inbox, Services};
+pub use state::{NoticeKind, OpenWindow, SaveAnswer, SheetView};
 pub mod desktop_theme;
 
 /// Persisted UI preferences.
@@ -160,19 +169,6 @@ impl UiState {
     }
 }
 
-/// Per-sheet view state (scroll position in sheet points).
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct SheetView {
-    pub scroll: egui::Vec2,
-}
-
-/// Severity of a notice shown in the info bar under the ribbon.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum NoticeKind {
-    Info,
-    Warning,
-}
-
 /// A dismissible bar under the ribbon, in the spirit of Excel's message bar. Used to tell the
 /// user what an opened file carried that GridCraft handled differently (e.g. preserved macros).
 #[derive(Clone, Debug, PartialEq)]
@@ -183,74 +179,6 @@ pub struct Notice {
     pub action: Option<(String, String)>,
 }
 
-/// An answer to the Save Changes question.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum SaveAnswer {
-    Save,
-    DontSave,
-    Cancel,
-}
-
-/// One open window, as View › Switch Windows and the macOS Window menu list it.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct OpenWindow {
-    /// The window's id, the `window` param of `view.switchWindows`.
-    pub window: u64,
-    /// Its workbook's `DocState::uid`.
-    pub doc: u64,
-    pub title: String,
-    pub dirty: bool,
-    pub active: bool,
-}
-
-impl OpenWindow {
-    /// The title ("Book1", or "Book1:2" for a workbook's second window), with a bullet after it
-    /// while the workbook has unsaved changes.
-    pub fn label(&self) -> String {
-        if self.dirty { format!("{} •", self.title) } else { self.title.clone() }
-    }
-}
-
-/// Host services the platform shell provides (file pickers, opening URLs).
-#[derive(Default)]
-pub struct Services {
-    /// Desktop: discover configured printers on a worker.
-    pub printers: Option<printing::Discover>,
-    /// Desktop: submit the PDF with the chosen settings on a worker.
-    pub print_native: Option<printing::Submit>,
-    pub pick_open: Option<Box<dyn Fn() -> Option<String>>>,
-    pub pick_save: Option<Box<dyn Fn(&str) -> Option<String>>>,
-    /// Native picture picker (PNG/JPEG), separate from workbook opening.
-    pub pick_picture: Option<Box<dyn Fn() -> Option<String>>>,
-    /// Browser picture picker. Each dialog owns its inbox, so canceled picks cannot
-    /// insert into a subsequent dialog or open the image as a workbook.
-    pub pick_picture_async: Option<Box<dyn Fn(Inbox)>>,
-    pub open_url: Option<Box<dyn Fn(&str)>>,
-    /// Publish HTML and its plain-text alternative together. `Ok` means the host owns the
-    /// write (including any asynchronous fallback); an immediate error uses egui's text path.
-    pub copy_html: Option<Box<dyn FnMut(&str, &str) -> Result<(), String>>>,
-    /// Read the HTML flavour of the system clipboard when the user pastes text, so cells the
-    /// source spreadsheet recorded as numbers stay numbers ("Rp10,000.00" → 10000). `None` from
-    /// the host pastes the plain text alone.
-    pub paste_html: Option<Box<dyn FnMut() -> Option<String>>>,
-    /// Read the system clipboard's plain text for the ribbon and menu Paste commands (Cmd/Ctrl+V
-    /// gets it from egui's `Event::Paste`). `None` from the host, or no service (web), pastes
-    /// GridCraft's own clipboard.
-    pub paste_text: Option<Box<dyn FnMut() -> Option<String>>>,
-    /// Web: deliver a file to the user (name, bytes).
-    pub download: Option<Box<dyn Fn(&str, &[u8])>>,
-    /// Web: start an asynchronous file pick; the bytes arrive later in `inbox`.
-    pub open_async: Option<Box<dyn Fn()>>,
-    /// Files delivered asynchronously (name, bytes), opened on the next frame.
-    pub inbox: Option<Inbox>,
-    /// Web: hand PDF bytes to the browser's print flow directly (no download,
-    /// no intermediate file) — opens the system print dialog on that PDF.
-    pub print: Option<Box<dyn Fn(&[u8])>>,
-}
-
-/// Shared queue of files read asynchronously (browser file picker, drag and drop).
-pub type Inbox = std::sync::Arc<std::sync::Mutex<Vec<(String, Vec<u8>)>>>;
-
 #[derive(Clone, Debug, Default)]
 pub struct Perf {
     pub frame_ms: f64,
@@ -259,26 +187,6 @@ pub struct Perf {
     last: f64,
 }
 
-/// Which parts of the app's own window chrome are drawn. Everything is on by default; a host
-/// that embeds the sheet in its own window (and owns files itself) can turn off the title bar
-/// and the File tab, whose Backstage view then never opens. Not persisted: it describes the
-/// host, not a user preference.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Chrome {
-    /// The title bar: AutoSave, Home, Save, Undo/Redo, the file name, Comments, Share, Search and
-    /// the theme switch.
-    pub title_bar: bool,
-    /// The ribbon's File tab and the Backstage view it opens (also reached by keyboard and
-    /// commands such as `ui.backstage`).
-    pub file_tab: bool,
-}
-
-impl Default for Chrome {
-    fn default() -> Self {
-        Chrome { title_bar: true, file_tab: true }
-    }
-}
-
 pub struct SheetApp {
     pub session: Session,
     pub ui: UiState,
@@ -381,1520 +289,6 @@ pub struct SheetApp {
     updates_rt: updates_ui::Runtime,
 }
 
-impl SheetApp {
-    /// Constructs a `SheetApp` with default UI, grid, printing, control and screenshot state and the caller's session and services.
-    pub fn new(session: Session, services: Services) -> SheetApp {
-        SheetApp {
-            session,
-            ui: UiState::default(),
-            chrome: Chrome::default(),
-            views: HashMap::new(),
-            editor: None,
-            text_box_editor: None,
-            dialog: None,
-            backstage: None,
-            message: None,
-            toast: None,
-            notice: None,
-            services,
-            printing: Default::default(),
-            print_feedback_seen: None,
-            synthetic: Default::default(),
-            synthetic_pending: false,
-            synthetic_injected_at_pass: None,
-            control_rx: None,
-            grid: grid::GridState {
-                last_border: "bottom".into(),
-                last_fill: "#FFFF00".into(),
-                last_font_color: "#C00000".into(),
-                ..Default::default()
-            },
-            perf: Perf::default(),
-            fonts_ready: false,
-            fonts_set: false,
-            prepared_fonts: false,
-            fonts_bound: Vec::new(),
-            fonts_seen: (0, 0),
-            fonts_rebind: false,
-            fonts_han: None,
-            effective_dark: false,
-            desktop_theme: desktop_theme::DesktopTheme::default(),
-            desktop_dark: None,
-            name_box: None,
-            keytips: keytips::KeyTips::default(),
-            shots: control::Shots::default(),
-            capture_epoch: 0,
-            capture_geometry: None,
-            capture_geometry_from_raw: false,
-            selected_chart: None,
-            clipboard_text_at_copy: None,
-            cut_text: None,
-            tab_run: None,
-            started: now_ms(),
-            allow_close: false,
-            open_switch_windows: false,
-            ui_window: None,
-            parked: HashMap::new(),
-            native_windows: false,
-            arrange_windows: None,
-            #[cfg(not(target_arch = "wasm32"))]
-            updates_rt: Default::default(),
-        }
-    }
-
-    /// One-time context setup: start cataloging the machine's fonts, then install the fonts and
-    /// visuals. Workbook-specific fonts are bound later, once the scan is done (see [`logic`]).
-    ///
-    /// [`logic`]: SheetApp::logic
-    pub fn setup_context(ctx: &egui::Context, dark: bool) {
-        fonts::start_scan();
-        Self::setup_context_for_language(ctx, dark, i18n::Language::En);
-    }
-
-    /// Sets up fonts and visuals for a specific persisted interface language.
-    pub fn setup_context_for_language(ctx: &egui::Context, dark: bool, language: i18n::Language) {
-        ctx.set_fonts(theme::font_definitions_for_language(language));
-        theme::apply(ctx, dark);
-    }
-
-    /// Test-harness setup: mark a deterministic font set (see
-    /// [`theme::pinned_font_definitions`]) as already installed, so the first `logic` pass neither
-    /// starts the host font scan nor replaces the harness's pinned set. Production uses
-    /// [`Self::setup_context`] instead.
-    #[doc(hidden)]
-    pub fn use_prepared_fonts(&mut self) {
-        self.prepared_fonts = true;
-        self.fonts_ready = true;
-        self.fonts_set = true;
-        self.fonts_rebind = false;
-        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
-        self.fonts_bound = self.used_fonts();
-        self.fonts_seen = self.fonts_key();
-    }
-
-    /// The font names the open workbooks use: every style's font plus the theme's heading/body
-    /// fonts. These are the families [`fonts`] binds an installed file for. Every workbook's, as
-    /// each may be showing in a window of its own.
-    pub fn used_fonts(&self) -> Vec<String> {
-        let mut names: Vec<String> = Vec::new();
-        for d in self.session.documents() {
-            names.extend(d.wb.styles.iter().map(|(_, s)| s.font.name.clone()));
-            names.push(d.wb.theme.major_font.clone());
-            names.push(d.wb.theme.minor_font.clone());
-            // Text boxes and shapes name their own typefaces.
-            names.extend(d.wb.sheets.iter().flat_map(|sh| sh.shapes.iter().filter_map(|s| s.format.font.clone())));
-        }
-        names
-    }
-
-    /// The open workbooks' (uid, revision), folded: [`Self::used_fonts`] changes only with it.
-    fn fonts_key(&self) -> (u64, u64) {
-        self.session
-            .documents()
-            .iter()
-            .fold((0u64, 0u64), |(uid, rev), d| (uid.wrapping_mul(31).wrapping_add(d.uid), rev.wrapping_mul(31).wrapping_add(d.revision)))
-    }
-
-    /// Runs an engine command (or a UI command) and handles UI requests it makes.
-    pub fn run(&mut self, id: &str, params: Json) -> Result<Json, String> {
-        let r = self.run_command(id, params);
-        // This copy leaves the system clipboard alone: note what it holds, so Paste can tell
-        // that GridCraft's copy is newer while that text is still there.
-        if matches!(id, "edit.copy" | "edit.cut") && r.is_ok() {
-            self.clipboard_text_at_copy = self.system_clipboard_text();
-            self.cut_text = if id == "edit.cut" { self.clipboard_text_at_copy.clone() } else { None };
-        }
-        r
-    }
-
-    fn run_command(&mut self, id: &str, params: Json) -> Result<Json, String> {
-        let switches_window = id.starts_with("window.")
-            || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
-            || (id == "view.switchWindows" && ["window", "doc"].iter().any(|k| params.get(*k).is_some_and(|d| !d.is_null())));
-        if id.starts_with("file.") || switches_window {
-            self.settle_drafts()?;
-        }
-        if matches!(id, "file.save" | "file.saveAs" | "file.saveBytes") {
-            self.store_view_state();
-        }
-        if matches!(
-            id,
-            "sheet.activate"
-                | "sheet.next"
-                | "sheet.previous"
-                | "sheet.move"
-                | "sheet.hide"
-                | "sheet.unhide"
-                | "home.insertSheet"
-                | "home.deleteSheet"
-                | "edit.undo"
-                | "edit.redo"
-                | "object.delete"
-                | "object.move"
-        ) {
-            self.commit_text_box_edit()?;
-        }
-        if let Some(r) = self.run_ui_command(id, &params) {
-            return r;
-        }
-        let before = self.session.active_window();
-        let r = self.session.run(id, params);
-        if id.starts_with("file.") && self.session.active_window() != before {
-            // File › New or Open from the Backstage view: the window it was in goes back to its sheet.
-            self.backstage = None;
-        }
-        // Requests the command made (a dialog, a draft) belong to the window it left active.
-        self.follow_active_window();
-        self.after_engine();
-        if id == "view.arrangeAll"
-            && self.native_windows
-            && let Ok(r) = &r
-        {
-            let arrange = r.get("arrange").and_then(Json::as_str).unwrap_or("tiled").to_string();
-            let windows = r.get("windows").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
-            self.arrange_windows = Some((arrange, windows));
-        }
-        // The new chart is selected, as after inserting any object, so Delete removes it, not its data.
-        if id == "insert.chart"
-            && let Ok(r) = &r
-            && let Some(chart) = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok())
-        {
-            self.selected_chart = Some(chart);
-        }
-        if id == "file.exportPdf"
-            && let Ok(r) = &r
-        {
-            self.deliver_pdf(r);
-        }
-        r
-    }
-
-    /// Copy or cut the selected cells to the system clipboard. Engine-only commands keep
-    /// their existing internal clipboard behavior and do not write to the host clipboard.
-    pub fn copy_to_clipboard(&mut self, ctx: &egui::Context, command: &str) {
-        // Only ask the engine for HTML when the host can publish it.
-        let result = match self.run_command(command, json!({"html": self.services.copy_html.is_some()})) {
-            Ok(result) => result,
-            Err(e) => return self.alert(e),
-        };
-        let Some(text) = result.get("text").and_then(Json::as_str) else { return };
-        // The system clipboard gets this copy, so its text decides what Paste pastes.
-        self.clipboard_text_at_copy = None;
-        self.cut_text = (command == "edit.cut").then(|| text.replace("\r\n", "\n"));
-        if let Some(html) = result.get("html").and_then(Json::as_str)
-            && let Some(copy_html) = &mut self.services.copy_html
-        {
-            match copy_html(html, text) {
-                Ok(()) => return,
-                Err(error) => log::warn!("HTML clipboard unavailable; copying plain text: {error}"),
-            }
-        }
-        ctx.copy_text(text.to_string());
-    }
-
-    /// Paste text that came from the system clipboard (Cmd/Ctrl+V, or the ribbon and menu Paste),
-    /// with the clipboard's HTML flavour when the host can read it.
-    ///
-    /// Excel pastes a cut once: after GridCraft's cut has been pasted, the system clipboard text
-    /// that came with it is not pasted again over the moved block; GridCraft's own (empty)
-    /// clipboard is pasted instead, which reports "Nothing to paste.". Other text means the
-    /// clipboard has moved on, so the cut's text is forgotten and pastes normally later.
-    pub fn paste_external(&mut self, text: String) {
-        if Self::same_clipboard_text(Some(&text), self.cut_text.as_deref()) {
-            if self.session.clipboard.is_none() {
-                return self.run_or_alert("edit.paste", json!({}));
-            }
-        } else {
-            self.cut_text = None;
-        }
-        let html = self.services.paste_html.as_mut().and_then(|read| read());
-        let params = match html {
-            Some(html) => json!({"text": text, "html": html}),
-            None => json!({"text": text}),
-        };
-        self.run_or_alert("edit.paste", params);
-    }
-
-    /// Ribbon and menu Paste: paste the text on the system clipboard, as Cmd/Ctrl+V does. With no
-    /// text there, no host clipboard (web), or the text that was there when GridCraft last copied
-    /// without publishing, GridCraft's own clipboard is pasted.
-    pub fn paste_from_clipboard(&mut self) {
-        match self.system_clipboard_text() {
-            Some(text) if self.session.clipboard.is_none() || self.clipboard_text_at_copy.as_ref() != Some(&text) => self.paste_external(text),
-            _ => self.run_or_alert("edit.paste", json!({})),
-        }
-    }
-
-    /// The system clipboard's plain text, with the line endings of egui's `Event::Paste` text.
-    /// `None` when it holds no text or the host can't read it.
-    fn system_clipboard_text(&mut self) -> Option<String> {
-        self.services.paste_text.as_mut().and_then(|read| read()).filter(|t| !t.is_empty()).map(|t| t.replace("\r\n", "\n"))
-    }
-
-    /// Whether two clipboard texts are the same copy: trailing line breaks don't count, as in the
-    /// engine's `edit.paste`, and CRLF matches LF (egui's `Event::Paste` text may keep the host's).
-    fn same_clipboard_text(a: Option<&str>, b: Option<&str>) -> bool {
-        fn chars(t: &str) -> impl Iterator<Item = char> + '_ {
-            t.trim_end_matches(['\r', '\n']).chars().filter(|c| *c != '\r')
-        }
-        match (a, b) {
-            (Some(a), Some(b)) => chars(a).eq(chars(b)),
-            _ => false,
-        }
-    }
-
-    /// Web: `file.exportPdf` without a path returns the PDF as base64; hand it to the browser as a download.
-    fn deliver_pdf(&self, result: &Json) {
-        if result.get("path").is_some() {
-            return;
-        }
-        if let Some(dl) = &self.services.download
-            && let Some(b) = result.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
-        {
-            let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
-            dl(&std::path::Path::new(&title).with_extension("pdf").to_string_lossy(), &b);
-        }
-    }
-
-    /// Runs a command and shows its error in a message box (for menu/ribbon clicks).
-    /// Follow the desktop's light/dark choice while the app runs (Linux; the desktop app calls
-    /// this once — tests and embedders don't start the watcher thread).
-    pub fn watch_desktop_theme(&mut self) {
-        self.desktop_theme = desktop_theme::DesktopTheme::start();
-    }
-
-    pub fn run_or_alert(&mut self, id: &str, params: Json) {
-        // A menu/shortcut opens the settings first; the Print page's button submits explicitly.
-        if id == "file.print" {
-            if self.services.print_native.is_some() {
-                self.open_backstage(backstage::Page::Print);
-                return;
-            }
-            return self.print_now(params);
-        }
-        // Menu-style Export as PDF with no file named: ask where to save, like Save As does.
-        // Programmatic callers use `run` and keep getting the PDF bytes back.
-        if id == "file.exportPdf" && self.services.pick_save.is_some() && params.get("path").and_then(Json::as_str).is_none_or(str::is_empty) {
-            return self.export_pdf_with_picker(params);
-        }
-        // Recommended Charts with no chart type named (ribbon button, keytip, command search) asks
-        // which chart to insert; programmatic callers of `run` still get the first recommendation.
-        if id == "insert.recommendedCharts" && params.get("type").is_none() {
-            return self.open_dialog("recommendedCharts", json!({}));
-        }
-        // Switch Windows with no window named (key tip, command search) opens the View tab's
-        // list to choose from; programmatic callers of `run` get the list back.
-        if id == "view.switchWindows" && ["window", "doc"].iter().all(|k| params.get(*k).is_none_or(Json::is_null)) {
-            self.ui.ribbon_tab = "View".into();
-            self.ui.ribbon_collapsed = false;
-            self.open_switch_windows = true;
-            return;
-        }
-        match self.run(id, params) {
-            // A refused cell draft already shows its own message (with the rule's title).
-            Err(e) if self.message.as_ref().is_some_and(|(_, m)| *m == e) => {}
-            Err(e) => self.alert(e),
-            Ok(_) => {}
-        }
-    }
-
-    /// Asks for a `.pdf` path with the save picker, then re-runs `file.exportPdf` with it. Other
-    /// params (range, sheets, fitToPage) are kept. A cancelled picker does nothing.
-    fn export_pdf_with_picker(&mut self, mut params: Json) {
-        if !self.commit_edit(0, 0, false, false) {
-            return;
-        }
-        let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
-        let stem = std::path::Path::new(&title).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Book1").to_string();
-        let Some(pick) = &self.services.pick_save else { return };
-        let Some(path) = pick(&format!("{stem}.pdf")) else { return };
-        // The picker may suggest a workbook extension; the export writes a PDF.
-        let path = std::path::Path::new(&path).with_extension("pdf").to_string_lossy().into_owned();
-        match &mut params {
-            Json::Object(map) => {
-                map.insert("path".into(), Json::String(path));
-            }
-            other => *other = json!({"path": path}),
-        }
-        if let Err(e) = self.run("file.exportPdf", params) {
-            self.alert(e);
-        }
-    }
-
-    /// Shows a command error: a toast for an unavailable command, else a message box.
-    fn alert(&mut self, e: String) {
-        // Shown in the window the user ends up in, also after a command that switched windows.
-        self.follow_active_window();
-        if e.contains("is not available right now") {
-            self.toast = Some((e, now_ms()));
-        } else {
-            self.message = Some(("GridCraft".into(), clean_error(&e)));
-        }
-    }
-
-    /// Builds the selected sheets' print-ready PDF and hands it to the desktop worker or the
-    /// browser. Rendering errors use the usual alert; asynchronous spooler errors stay visible
-    /// on the Print page. The engine command still returns PDF bytes without submitting.
-    pub fn print_now(&mut self, params: Json) {
-        if let Err(error) = self.submit_print(params) {
-            self.alert(error);
-        }
-    }
-
-    fn submit_print(&mut self, params: Json) -> Result<Json, String> {
-        if self.services.print_native.is_some() && !self.printing.ready() {
-            return Err("Select an available printer in File > Print before submitting.".into());
-        }
-        let pdf = self.run("file.print", params)?;
-        let encoded = pdf.get("base64").and_then(Json::as_str).ok_or("The print command did not produce a PDF.")?;
-        let bytes = gridcraft_engine::io::base64_decode(encoded).ok_or("Couldn't decode the generated PDF.")?;
-        let len = bytes.len();
-        if let Some(submit) = &self.services.print_native {
-            self.printing.begin(submit(bytes, self.printing.settings.clone())).map_err(|_| "A print job is already being submitted.".to_owned())?;
-            self.print_feedback_seen = None;
-        } else if let Some(print) = &self.services.print {
-            print(&bytes);
-        } else {
-            return Err("Printing is unavailable here; export a PDF instead.".into());
-        }
-        Ok(json!({"printing": true, "bytes": len, "pending": self.services.print_native.is_some()}))
-    }
-
-    /// UI-only commands (dialogs, view toggles that aren't saved in the file).
-    fn run_ui_command(&mut self, id: &str, p: &Json) -> Option<Result<Json, String>> {
-        let r = match id {
-            "app.checkForUpdates" | "help.checkForUpdates" => {
-                self.check_for_updates();
-                Ok(Json::Null)
-            }
-            "ui.printSettings" => printing::settings(&mut self.printing, p, self.services.printers.as_ref()),
-            "ui.printSubmit" => self.submit_print(p.clone()),
-            "ui.ribbonTab" => {
-                self.ui.ribbon_tab = p.get("tab").and_then(Json::as_str).unwrap_or("Home").to_string();
-                Ok(Json::Null)
-            }
-            "view.collapseRibbon" => {
-                self.ui.ribbon_collapsed = !self.ui.ribbon_collapsed;
-                Ok(Json::Null)
-            }
-            "view.expandFormulaBar" => {
-                self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded);
-                Ok(json!({"on": self.ui.formula_bar_expanded}))
-            }
-            "view.darkMode" => {
-                let current = if self.ui.system_theme { self.effective_dark } else { self.ui.dark };
-                self.ui.dark = p.get("on").and_then(Json::as_bool).unwrap_or(!current);
-                self.ui.system_theme = false;
-                Ok(json!({"on": self.ui.dark}))
-            }
-            "view.theme" => {
-                match p.get("mode").and_then(Json::as_str) {
-                    Some("system") => self.ui.system_theme = true,
-                    Some(mode @ ("light" | "dark")) => {
-                        self.ui.dark = mode == "dark";
-                        self.ui.system_theme = false;
-                    }
-                    _ => return Some(Err("theme mode must be system, light, or dark".into())),
-                }
-                Ok(json!({"mode": self.ui.theme_mode()}))
-            }
-            "view.animations" => {
-                self.ui.animations = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.animations);
-                Ok(json!({"on": self.ui.animations}))
-            }
-            "options.autoComplete" => {
-                self.ui.autocomplete = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.autocomplete);
-                Ok(json!({"on": self.ui.autocomplete}))
-            }
-            "view.interfaceScale" => {
-                // `{"percent": 125}` or `{"percent": "auto"}`; out-of-range values are clamped.
-                let percent = match p.get("percent") {
-                    Some(Json::String(s)) if s.eq_ignore_ascii_case("auto") => Some(100),
-                    Some(v) => v.as_f64().and_then(clamp_interface_scale),
-                    None => None,
-                };
-                match percent {
-                    Some(v) => {
-                        self.ui.interface_scale = v;
-                        Ok(json!({"percent": v}))
-                    }
-                    None => Err(format!("missing `percent` ({INTERFACE_SCALE_MIN}–{INTERFACE_SCALE_MAX}, or \"auto\")")),
-                }
-            }
-            "app.language.set" => {
-                // `{"language": "ja"}`; `code` is accepted as an alias.
-                let code = p.get("language").or_else(|| p.get("code")).and_then(Json::as_str).unwrap_or("");
-                match i18n::Language::parse(code) {
-                    Some(l) => {
-                        self.ui.language = l;
-                        Ok(json!({"language": l}))
-                    }
-                    None => Err(format!("unknown language {code:?} (use one of {})", i18n::Language::code_list(", "))),
-                }
-            }
-            "app.language.english" => {
-                self.ui.language = i18n::Language::En;
-                Ok(json!({"language": i18n::Language::En}))
-            }
-            "app.language.japanese" => {
-                self.ui.language = i18n::Language::Ja;
-                Ok(json!({"language": i18n::Language::Ja}))
-            }
-            "ui.backstage" => {
-                // `{"page": "info"}` opens File › Info; `{"page": "close"}` returns to the sheet.
-                match p.get("page").and_then(Json::as_str).map(str::trim) {
-                    Some("close" | "none" | "") => self.backstage = None,
-                    Some(id) => match backstage::Page::parse(id) {
-                        Some(page) => self.open_backstage(page),
-                        None => {
-                            return Some(Err(format!(
-                                "unknown File page {id:?} (use home, new, open, info, saveAs, print, export, options or close)"
-                            )));
-                        }
-                    },
-                    None => self.open_backstage(backstage::Page::Home),
-                }
-                Ok(json!({"page": self.backstage.as_ref().map(|b| b.page.id())}))
-            }
-            "ui.dialog" => {
-                let name = p.get("name").and_then(Json::as_str).unwrap_or("");
-                self.open_dialog(name, p.clone());
-                Ok(json!({"dialog": self.dialog.as_ref().map(|d| d.name())}))
-            }
-            "ui.message.dismiss" => {
-                self.message = None;
-                Ok(Json::Null)
-            }
-            "ui.notice" => Ok(match &self.notice {
-                Some(n) => json!({
-                    "text": n.text,
-                    "kind": match n.kind { NoticeKind::Warning => "warning", NoticeKind::Info => "info" },
-                    "action": n.action,
-                }),
-                None => Json::Null,
-            }),
-            "ui.notice.dismiss" => {
-                self.notice = None;
-                Ok(Json::Null)
-            }
-            _ => return None,
-        };
-        Some(r)
-    }
-
-    /// Picks up requests commands made (dialogs, edit mode…).
-    pub fn after_engine(&mut self) {
-        // The requests belong to the window the command left active.
-        self.follow_active_window();
-        for req in self.session.take_ui_requests() {
-            match req {
-                UiRequest::Dialog(name, params) => self.open_dialog(&name, params),
-                UiRequest::Message(m) => self.message = Some(("GridCraft".into(), m)),
-                UiRequest::EditCell(text) => {
-                    let text = text.map(|text| {
-                        self.session
-                            .active()
-                            .map(|d| formula_locale::display_template(&text, self.ui.language.formula_locale(), &d.wb, d.wb.active_sheet()))
-                            .unwrap_or(text)
-                    });
-                    self.begin_edit(text, false);
-                }
-                UiRequest::InsertName(name) => dialogs::insert_name(self, &name),
-                UiRequest::OpenUrl(u) => {
-                    if let Some(f) = &self.services.open_url {
-                        f(&u);
-                    }
-                }
-            }
-        }
-    }
-
-    /// Whether the active sheet of the active document is protected (drives the Protect/Unprotect
-    /// Sheet labels and actions).
-    pub fn active_sheet_protected(&self) -> bool {
-        self.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false)
-    }
-
-    pub fn open_dialog(&mut self, name: &str, params: Json) {
-        if let Err(e) = self.commit_text_box_edit() {
-            self.message = Some(("Text Box".into(), clean_error(&e)));
-            return;
-        }
-        // Every Protect Sheet entry point (ribbon menus, keytips, tab menu) becomes Unprotect Sheet
-        // on a protected sheet. A sheet without a password is unprotected straight away.
-        let name = if name == "protectSheet" && self.active_sheet_protected() { "unprotectSheet" } else { name };
-        if name == "unprotectSheet"
-            && self
-                .session
-                .active()
-                .and_then(|d| d.wb.active())
-                .and_then(|s| s.protection.as_ref())
-                .is_some_and(|p| p.password.is_none() && p.legacy_password_hash.is_none())
-        {
-            self.run_or_alert("review.unprotectSheet", json!({}));
-            return;
-        }
-        match name {
-            "open" => {
-                if let Some(start) = &self.services.open_async {
-                    start();
-                } else if let Some(pick) = &self.services.pick_open
-                    && let Some(path) = pick()
-                {
-                    self.open_path(&path);
-                }
-            }
-            "saveAs" => {
-                let suggested = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
-                if let Some(pick) = &self.services.pick_save {
-                    if let Some(path) = pick(&suggested) {
-                        let path = if std::path::Path::new(&path).extension().is_none() { format!("{path}.xlsx") } else { path };
-                        self.run_or_alert("file.save", json!({"path": path}));
-                    }
-                } else if self.services.download.is_some()
-                    && let Ok(r) = self.run("file.saveBytes", json!({"format": "xlsx"}))
-                    && let Some(dl) = &self.services.download
-                    && let Some(b) = r.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
-                {
-                    let name = r.get("name").and_then(Json::as_str).unwrap_or("Book.xlsx").to_string();
-                    dl(&name, &b);
-                }
-            }
-            // File › Options (`file.options`) and the File tab itself open the Backstage view.
-            "options" => self.open_backstage(backstage::Page::Options),
-            "backstage" => {
-                let page = params.get("page").and_then(Json::as_str).and_then(backstage::Page::parse).unwrap_or(backstage::Page::Home);
-                self.open_backstage(page);
-            }
-            other => self.dialog = dialogs::Dialog::open(self, other, params),
-        }
-    }
-
-    /// Opens the File tab's Backstage view on `page`, committing a cell still being edited first
-    /// (File actions work on the whole workbook). A draft that can't be committed keeps the sheet.
-    pub fn open_backstage(&mut self, page: backstage::Page) {
-        if !self.chrome.file_tab {
-            return;
-        }
-        if !self.commit_edit(0, 0, false, false) {
-            return;
-        }
-        match &mut self.backstage {
-            Some(b) => b.page = page,
-            None => self.backstage = Some(backstage::Backstage::new(page)),
-        }
-    }
-
-    pub fn open_path(&mut self, path: &str) {
-        match self.run("file.open", json!({"path": path})) {
-            Ok(r) => self.after_open(Some(path), &r),
-            // A password-protected workbook: ask for the password; the dialog opens it.
-            Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => self.open_dialog("openPassword", json!({"path": path})),
-            Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
-        }
-        self.after_engine();
-    }
-
-    /// What follows a successful `file.open`: the workbook shows (not the Backstage), the Recent
-    /// list (for a file on disk) and the open warnings notice. Shared by File › Open, the
-    /// password dialog and the control channel.
-    pub fn after_open(&mut self, path: Option<&str>, r: &Json) {
-        self.backstage = None;
-        if let Some(path) = path {
-            self.ui.recent.retain(|p| p != path);
-            self.ui.recent.insert(0, path.to_string());
-            self.ui.recent.truncate(20);
-        }
-        self.show_open_warnings(r);
-    }
-
-    /// Turns the `warnings` a `file.open` result carries into an info-bar notice, choosing the
-    /// most important one (a preserved VBA project outranks, say, a skipped optional part).
-    /// Kept deliberately generic: any open-time warning can reach the user this way.
-    pub fn show_open_warnings(&mut self, r: &Json) {
-        // The opened workbook's window shows them, however it was opened (a script may have run
-        // `file.open` on the session directly).
-        self.follow_active_window();
-        let Some(list) = r.get("warnings").and_then(Json::as_array) else {
-            self.notice = None;
-            return;
-        };
-        let msgs: Vec<&str> = list.iter().filter_map(Json::as_str).collect();
-        if msgs.is_empty() {
-            // A clean open clears any notice left over from the previous document.
-            self.notice = None;
-            return;
-        }
-        let vba: Vec<&str> = msgs.iter().copied().filter(|m| m.to_lowercase().contains("macro") || m.contains("VBA")).collect();
-        if !vba.is_empty() {
-            // The reader says "dropped" when the VBA project was missing or unreadable; never promise to keep it then.
-            let dropped = vba.iter().any(|m| m.contains("dropped"));
-            let text = if dropped {
-                "This workbook's VBA macros could not be loaded and were dropped, so they will not be in the saved file. Keep the original file."
-            } else {
-                "This workbook contains VBA macros. GridCraft keeps them when you save as .xlsm, but does not run them."
-            };
-            self.notice = Some(Notice { text: text.into(), kind: NoticeKind::Warning, action: Some(("What this means".into(), "macros".into())) });
-        } else {
-            let text = if msgs.len() == 1 {
-                msgs[0].to_string()
-            } else {
-                format!("{} items in this file were handled differently. First: {}", msgs.len(), msgs[0])
-            };
-            self.notice = Some(Notice { text, kind: NoticeKind::Info, action: None });
-        }
-    }
-
-    /// The open windows in order, for the Switch Windows lists.
-    pub fn open_windows(&self) -> Vec<OpenWindow> {
-        let active = self.session.active_window();
-        self.session
-            .windows()
-            .iter()
-            .filter_map(|w| {
-                let d = self.session.documents().iter().find(|d| d.uid == w.doc_uid)?;
-                let title = self.session.window_title(w.id)?;
-                Some(OpenWindow { window: w.id, doc: d.uid, title, dirty: d.is_dirty(), active: active == Some(w.id) })
-            })
-            .collect()
-    }
-
-    /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
-    pub fn view_key(&self) -> Option<(u64, usize)> {
-        self.session.active().map(|d| (d.uid, d.wb.active_sheet()))
-    }
-
-    /// The active window and sheet: each window scrolls on its own.
-    fn scroll_key(&self) -> Option<(u64, usize)> {
-        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet()))
-    }
-
-    pub fn view(&self) -> SheetView {
-        self.scroll_key().and_then(|k| self.views.get(&k).copied()).unwrap_or_else(|| self.saved_view())
-    }
-
-    pub fn view_mut(&mut self) -> Option<&mut SheetView> {
-        let k = self.scroll_key()?;
-        let saved = self.saved_view();
-        Some(self.views.entry(k).or_insert(saved))
-    }
-
-    /// The view a sheet opens with: scrolled to the file's saved first visible cell (`topLeftCell`).
-    fn saved_view(&self) -> SheetView {
-        let Some(sh) = self.session.active().and_then(|d| d.wb.active()) else { return SheetView::default() };
-        if sh.view != gridcraft_engine::model::SheetViewMode::Normal {
-            return SheetView::default();
-        }
-        let (fr, fc) = sh.freeze.unwrap_or((0, 0));
-        let top = sh.view_top_left;
-        let y = sh.row_top(top.row.max(fr)) - sh.row_top(fr);
-        let x = sh.col_left(top.col.max(fc)) - sh.col_left(fc);
-        SheetView { scroll: egui::vec2(x.max(0.0) as f32, y.max(0.0) as f32) }
-    }
-
-    /// Hands the active document's scroll positions (first visible cell per sheet) and active
-    /// cell to the engine so a save writes them (`sheetView topLeftCell`). Normal view only:
-    /// Page Layout view scrolls over pages, not cells.
-    pub fn store_view_state(&mut self) {
-        let window = self.session.active_window();
-        let Some(d) = self.session.active_mut() else { return };
-        let mut tops = Vec::new();
-        for (&(w, si), v) in &self.views {
-            let Some(sh) = d.wb.sheets.get(si).filter(|sh| Some(w) == window && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
-                continue;
-            };
-            let (fr, fc) = sh.freeze.unwrap_or((0, 0));
-            // A hair past the edge so a row that starts exactly at the scroll offset is the one found.
-            let row = sh.row_at(sh.row_top(fr) + v.scroll.y.max(0.0) as f64 + 0.01);
-            let col = sh.col_at(sh.col_left(fc) + v.scroll.x.max(0.0) as f64 + 0.01);
-            tops.push((si, CellRef::new(row, col)));
-        }
-        d.store_view(&tops);
-    }
-
-    /// Starts editing the active cell. `text` replaces the content (typing) or pre-fills it.
-    pub fn begin_edit(&mut self, text: Option<String>, from_formula_bar: bool) {
-        // The source formula is display-only on spill children. Grid replacement keeps its
-        // existing behavior, but no formula-bar entry path may edit that displayed formula.
-        if from_formula_bar && formula_bar::active_spill_anchor(self).is_some() {
-            return;
-        }
-        if let Err(e) = self.commit_text_box_edit() {
-            self.message = Some(("Text Box".into(), clean_error(&e)));
-            return;
-        }
-        let Some(d) = self.session.active() else { return };
-        let Some(sh) = d.wb.active() else { return };
-        let at = sh.merge_at(d.selection.active).map(|m| m.start).unwrap_or(d.selection.active);
-        // A picture has no editable scalar text. Selecting it, F2, or clicking
-        // the formula bar must not turn its fallback value into a text edit.
-        // Typing still starts an intentional replacement.
-        if text.is_none() && sh.cell_pictures.contains_key(&at) {
-            return;
-        }
-        let locale = self.ui.language.formula_locale();
-        let current = if sh.cell_pictures.contains_key(&at) {
-            String::new()
-        } else {
-            match sh.cell(at) {
-                Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet()),
-                _ => gridcraft_engine::display::edit_text(&d.wb, sh, at),
-            }
-        };
-        let (text, replace) = match text {
-            Some(t) => (t, true),
-            None => (current.clone(), false),
-        };
-        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet(), at, text, replace, from_formula_bar);
-        ed.window = self.session.active_window();
-        ed.locale = locale;
-        if replace && self.ui.autocomplete && !ed.is_formula() {
-            ed.completion = editor::column_completion(sh, at, &ed.text);
-        }
-        self.editor = Some(ed);
-        self.session.mode = if replace { gridcraft_engine::Mode::Enter } else { gridcraft_engine::Mode::Edit };
-    }
-
-    /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
-    ///
-    /// The draft goes into the window and workbook it was typed in. If another window is
-    /// showing, that window stays active afterwards; a draft its own workbook refuses
-    /// (validation, a bad formula) brings its window back to the front with the draft still open.
-    pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
-        let Some((doc, window)) = self.editor.as_ref().map(|ed| (ed.doc, ed.window)) else { return true };
-        if !self.draft_elsewhere() {
-            return self.commit_edit_here(dr, dc, array, fill_selection);
-        }
-        // Its window, or (when that window closed) its workbook's most recent one.
-        let Some(owner) = window.filter(|w| self.session.window(*w).is_some()).or_else(|| self.session.doc_window(doc)) else {
-            self.cancel_edit();
-            return true;
-        };
-        let back = self.session.active_window();
-        self.session.activate_window(owner);
-        if !self.commit_edit_here(dr, dc, array, fill_selection) {
-            // Refused: its window stays in front with the draft open and the reason shown.
-            return false;
-        }
-        if let Some(back) = back {
-            self.session.activate_window(back);
-        }
-        true
-    }
-
-    /// The cell draft belongs to a window or workbook other than the one showing.
-    fn draft_elsewhere(&self) -> bool {
-        self.editor.as_ref().is_some_and(|ed| {
-            self.session.active().map(|d| d.uid) != Some(ed.doc) || ed.window.is_some_and(|w| self.session.active_window() != Some(w))
-        })
-    }
-
-    /// Commits the cell and text-box drafts, as Enter would, before a command that can show
-    /// another workbook or write this one to a file, so a draft never lands in another workbook.
-    /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
-    pub(crate) fn settle_drafts(&mut self) -> Result<(), String> {
-        if !self.commit_edit(0, 0, false, false) {
-            return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
-        }
-        self.commit_text_box_edit()
-    }
-
-    fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
-        let Some(ed) = self.editor.take() else { return true };
-        self.session.mode = gridcraft_engine::Mode::Ready;
-        let text = match &ed.completion {
-            Some(full) if full.to_lowercase().starts_with(&ed.text.to_lowercase()) => full.clone(),
-            _ => ed.text.clone(),
-        };
-        // F2 then Enter (or a file command) on an untouched draft: nothing to write.
-        if !fill_selection && !array && ed.original.as_ref() == Some(&text) {
-            if dr != 0 || dc != 0 {
-                self.move_after_enter(dr, dc);
-            }
-            return true;
-        }
-        let text = match self.session.active().map(|d| formula_locale::canonical(&text, ed.locale, &d.wb, ed.sheet, ed.cell)) {
-            Some(Ok(text)) => text,
-            Some(Err(error)) => {
-                self.message = Some(("GridCraft".into(), error.to_string()));
-                self.editor = Some(ed);
-                self.session.mode = gridcraft_engine::Mode::Edit;
-                return false;
-            }
-            None => text,
-        };
-        // Data validation.
-        if let Some(d) = self.session.active()
-            && let Some((dv, msg)) = gridcraft_engine::cmd::data::check_validation(&d.wb, ed.sheet, ed.cell, &text)
-        {
-            if dv.error_style == gridcraft_engine::model::ErrorStyle::Stop {
-                let title = if dv.error_title.is_empty() { "GridCraft".to_string() } else { dv.error_title.clone() };
-                self.message = Some((title, msg));
-                self.editor = Some(ed);
-                self.session.mode = gridcraft_engine::Mode::Edit;
-                return false;
-            }
-            self.toast = Some((msg, now_ms()));
-        }
-        // Point mode can leave another sheet active; the edit belongs to the sheet it started on.
-        if self.session.active().is_some_and(|d| d.wb.active_sheet() != ed.sheet)
-            && let Err(e) = self.session.run("sheet.activate", json!({"sheet": ed.sheet}))
-        {
-            self.message = Some(("GridCraft".into(), clean_error(&e)));
-            self.editor = Some(ed);
-            self.session.mode = gridcraft_engine::Mode::Edit;
-            return false;
-        }
-        // Committing nothing into an empty cell changes nothing: no undo step (#1855, Backspace has
-        // already cleared the cell as its own step).
-        let unchanged = !fill_selection
-            && !array
-            && text.is_empty()
-            && self
-                .session
-                .active()
-                .and_then(|d| d.wb.sheet(ed.sheet))
-                .is_some_and(|sh| sh.cell(ed.cell).is_none_or(|c| c.formula.is_none() && c.value == gridcraft_engine::core::Value::Empty));
-        let r = if unchanged {
-            Ok(json!({}))
-        } else if fill_selection {
-            self.session.run("range.fill", json!({"input": text}))
-        } else {
-            self.session.run("cell.set", json!({"cell": ed.cell.a1(), "input": text, "array": array}))
-        };
-        match r {
-            Ok(_) => {
-                if dr != 0 || dc != 0 {
-                    self.move_after_enter(dr, dc);
-                }
-                self.after_engine();
-                true
-            }
-            Err(e) => {
-                self.message = Some(("GridCraft".into(), clean_error(&e)));
-                self.editor = Some(ed);
-                self.session.mode = gridcraft_engine::Mode::Edit;
-                false
-            }
-        }
-    }
-
-    /// Commits the edit with an arrow key. The arrow is an ordinary move, so it ends a run of Tabs
-    /// instead of continuing it (Right) or going back to its column like Enter (Down), as in Excel.
-    pub fn commit_edit_arrow(&mut self, dr: i64, dc: i64) -> bool {
-        let run = self.tab_run.take();
-        let ok = self.commit_edit(dr, dc, false, false);
-        self.tab_run = if ok { None } else { run };
-        ok
-    }
-
-    pub fn cancel_edit(&mut self) {
-        self.editor = None;
-        self.session.mode = gridcraft_engine::Mode::Ready;
-    }
-
-    /// Enter/Tab move inside a multi-cell selection, otherwise to the next cell.
-    pub fn move_after_enter(&mut self, dr: i64, dc: i64) {
-        let multi = self.session.active().is_some_and(|d| !d.selection.is_single_cell());
-        // Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
-        // last Tab landed on, which ends the run.
-        let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
-        let run = self.tab_run.take().filter(|&(uid, sheet, _, at)| here == Some((uid, sheet, at)));
-        if multi {
-            let fwd = dr > 0 || dc > 0;
-            let _ = self.session.run("selection.next", json!({"forward": fwd, "byRow": dc != 0}));
-        } else if let (Some((_, _, col, at)), 1, 0) = (run, dr, dc) {
-            let back = i64::from(col) - i64::from(at.col);
-            let _ = self.session.run("selection.move", json!({"dr": 1, "dc": back}));
-        } else {
-            let _ = self.session.run("selection.move", json!({"dr": dr, "dc": dc}));
-            if dr == 0 && dc != 0 {
-                let start = run.map(|r| r.2);
-                self.tab_run = self.session.active().and_then(|d| {
-                    let (uid, sheet) = (d.uid, d.wb.active_sheet());
-                    let col = start.or(here.map(|h| h.2.col))?;
-                    Some((uid, sheet, col, d.selection.active))
-                });
-            }
-        }
-        self.grid.ensure_visible = true;
-    }
-
-    /// Terminal feedback also reaches the normal window when printing starts through control.
-    /// Polls printing feedback. Called once per frame from [`Self::logic`]; the direct calls in
-    /// `tests/native_print.rs` deliberately bypass the lifecycle to test this helper alone.
-    pub fn poll_printing(&mut self, ctx: &egui::Context) {
-        self.printing.poll(ctx);
-        if self.printing.message == self.print_feedback_seen {
-            return;
-        }
-        self.print_feedback_seen = self.printing.message.clone();
-        let Some(message @ (printing::Feedback::Submitted(_) | printing::Feedback::Failed(_) | printing::Feedback::WorkerStopped)) =
-            self.printing.message.clone()
-        else {
-            return;
-        };
-        let text = printing::feedback(&message, self.ui.language, |label| self.ui.language.tr(label).to_owned());
-        if matches!(message, printing::Feedback::Submitted(_)) {
-            self.toast = Some((text, now_ms()));
-        } else {
-            self.alert(text);
-        }
-    }
-
-    /// Holds back a window close (the close button, Alt+F4, the OS quitting the app) while a
-    /// workbook has unsaved changes, and asks about them first.
-    fn guard_window_close(&mut self, ctx: &egui::Context) {
-        if self.native_windows || self.allow_close || !ctx.input(|i| i.viewport().close_requested()) {
-            return;
-        }
-        // A cell still being edited is part of the workbook, as for File › Close.
-        if !self.commit_edit(0, 0, false, false) {
-            ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-            return;
-        }
-        if !self.session.documents().iter().any(|d| d.is_dirty()) {
-            return;
-        }
-        ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-        match self.dialog.as_mut() {
-            // Already asking about a workbook (File › Close): answering it now goes on to quit.
-            Some(d) if d.name() == "saveChanges" => {
-                d.values.insert("quit".into(), json!(true));
-            }
-            _ => self.continue_quit(ctx),
-        }
-    }
-
-    /// Asks about the next unsaved workbook before quitting, in its window, or closes the app
-    /// once none is left.
-    pub(crate) fn continue_quit(&mut self, ctx: &egui::Context) {
-        let dirty = self.session.documents().iter().find(|d| d.is_dirty()).map(|d| d.uid);
-        match dirty.and_then(|uid| self.session.doc_window(uid)) {
-            Some(window) => {
-                // Its window comes forward (the native window too: see `doc_windows`).
-                self.enter_window(window);
-                let title = self.session.active().map(|d| d.display_title()).unwrap_or_default();
-                self.open_dialog("saveChanges", json!({"title": title, "quit": true}));
-            }
-            None => {
-                self.allow_close = true;
-                ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Close);
-            }
-        }
-    }
-
-    /// Answers the Save Changes question about the active workbook (its buttons). While quitting,
-    /// the next unsaved workbook is asked about once this one is answered; Cancel stops the quit.
-    /// Returns whether the question is settled: Save keeps it open when the cell being edited
-    /// can't be entered.
-    pub fn answer_save_changes(&mut self, answer: SaveAnswer, quitting: bool, ctx: &egui::Context) -> bool {
-        match answer {
-            SaveAnswer::Cancel => {}
-            SaveAnswer::DontSave => {
-                self.run_or_alert("file.close", json!({"force": true, "document": true}));
-                if quitting {
-                    self.continue_quit(ctx);
-                }
-            }
-            SaveAnswer::Save => {
-                // File operations include the cell still being edited, as File › Save does.
-                if !self.commit_edit(0, 0, false, false) {
-                    return false;
-                }
-                self.run_or_alert("file.save", json!({}));
-                if self.session.active().is_some_and(|x| !x.is_dirty()) {
-                    self.run_or_alert("file.close", json!({"force": true, "document": true}));
-                    if quitting {
-                        self.continue_quit(ctx);
-                    }
-                }
-            }
-        }
-        true
-    }
-
-    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, then asks
-    /// about each unsaved workbook in its window; Cancel on any of them stops the quit. A draft its
-    /// workbook refuses stops the quit too, with its window in front and the reason shown.
-    pub fn request_quit(&mut self, ctx: &egui::Context) {
-        while let Some(window) = self.parked_window_with_draft() {
-            self.enter_window(window);
-            if self.settle_drafts().is_err() {
-                return;
-            }
-        }
-        if self.settle_drafts().is_err() {
-            return;
-        }
-        if let Some(d) = self.dialog.as_mut().filter(|d| d.name() == "saveChanges") {
-            // Already asking about a workbook (File › Close): answering it goes on to quit.
-            d.values.insert("quit".into(), json!(true));
-            return;
-        }
-        self.continue_quit(ctx);
-    }
-
-    /// Per-frame logic (control channel, screenshots). Call before `ui`.
-    pub fn logic(&mut self, ctx: &egui::Context) {
-        self.ensure_text_width(ctx);
-        // A keytip control request lives one frame: the ribbon consumes it during `ui`, and
-        // anything that never reached a control (collapsed ribbon, tab switch) is dropped.
-        self.ui.keytip_invoke = None;
-        // Floating pictures' textures go with their workbook, even when no sheet is painted.
-        let open: Vec<u64> = self.session.documents().iter().map(|d| d.uid).collect();
-        floating_pictures::forget_closed(ctx, &open);
-        self.apply_font_state(ctx);
-        if let Some(answer) = self.desktop_theme.take_change() {
-            self.desktop_dark = Some(answer);
-        }
-        self.sync_theme_preference(ctx);
-        self.sync_input_options(ctx);
-        // The geometry captures are bound to. Native frames recorded it from their fresh
-        // `RawInput` in `raw_input_hook` (including hidden logic-only ticks); the epoch is
-        // monotonic, so a resize back to the original values is still a new epoch and old pixels
-        // are never saved with new geometry.
-        let capture_geometry = control::current_capture_geometry(self, ctx);
-        control::note_capture_geometry(self, capture_geometry);
-        // Drain before admission: completed or timed-out captures release their slots and
-        // reservation first, so a new request is never refused for budget that is about to free.
-        // Screenshot results, deadlines and geometry validation belong to `logic`; `ui` only
-        // issues the capture command (after every widget, so a command cannot be missed).
-        control::drain_screenshots(self, ctx);
-        control::poll(self, ctx);
-        // Printing feedback is polled once per frame, here, so hidden windows and logic-only
-        // frames still see worker completion. `ui` and the desktop app no longer poll it.
-        self.poll_printing(ctx);
-        self.guard_window_close(ctx);
-        #[cfg(not(target_arch = "wasm32"))]
-        updates_ui::tick(self, ctx);
-        // Files read asynchronously (web file picker, dropped files).
-        self.poll_async_opens();
-        self.autosave(ctx);
-        self.update_title(ctx);
-        self.request_hidden_paint(ctx);
-        // One window always shows a workbook, unless each workbook has a native window of its own
-        // (`doc_windows` decides what having none left means).
-        if self.session.active().is_none() && !self.native_windows {
-            self.session.new_workbook();
-        }
-        self.follow_active_window();
-    }
-
-    /// Installs the text-width closure once, on the first frame.
-    fn ensure_text_width(&mut self, ctx: &egui::Context) {
-        if self.session.text_width.is_some() {
-            return;
-        }
-        let ctx = ctx.clone();
-        self.session.text_width = Some(std::sync::Arc::new(move |text, font, exact| theme::cell_text_width(&ctx, text, font, exact)));
-    }
-
-    /// Applies the font gates: a language Han-order change, startup/prepared fonts and workbook
-    /// font binding. Every branch keeps its one-frame paint gate.
-    fn apply_font_state(&mut self, ctx: &egui::Context) {
-        // A pending synthetic step owns the next real `ui` pass: `ui` returns at the font gate
-        // before it handles input, so a font change requested now would consume the step without
-        // applying it. Delay the change one frame; the hidden-paint request keeps it coming.
-        let defer_font_change = self.synthetic_pending || !self.synthetic.is_empty();
-        if !defer_font_change && self.fonts_han.is_some_and(|han| han != theme::HanOrder::of(self.ui.language)) {
-            self.fonts_ready = false;
-            self.fonts_set = false;
-        }
-        if !self.fonts_ready {
-            self.start_font_setup(ctx);
-        } else if self.fonts_rebind {
-            // A font-set change made last frame is active now.
-            self.fonts_rebind = false;
-        } else if !defer_font_change && !self.prepared_fonts && fonts::scan_done() {
-            self.rebind_workbook_fonts(ctx);
-        }
-    }
-
-    /// Applies the pending font set. New fonts apply from the next frame on: paint nothing until
-    /// then. Startup always proceeds: without it a queued step would be re-offered forever.
-    fn start_font_setup(&mut self, ctx: &egui::Context) {
-        if self.fonts_set {
-            self.fonts_ready = true;
-            return;
-        }
-        if self.prepared_fonts {
-            ctx.set_fonts(theme::pinned_font_definitions());
-            theme::apply(ctx, self.ui.dark);
-        } else {
-            SheetApp::setup_context_for_language(ctx, self.ui.dark, self.ui.language);
-        }
-        self.fonts_set = true;
-        // The rebuilt set has no workbook fonts yet: bind them again once it is active.
-        self.fonts_bound.clear();
-        self.fonts_seen = (0, 0);
-        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
-        ctx.request_repaint();
-    }
-
-    /// Binds the workbook's installed fonts once the background scan has finished. Adding fonts
-    /// re-applies the font set, which egui activates at the next pass, so skip this frame's paint
-    /// (same one-frame cost as startup). Only when an open workbook changed.
-    fn rebind_workbook_fonts(&mut self, ctx: &egui::Context) {
-        let seen = self.fonts_key();
-        if seen == self.fonts_seen {
-            return;
-        }
-        let used = self.used_fonts();
-        self.fonts_seen = seen;
-        if used == self.fonts_bound {
-            return;
-        }
-        ctx.set_fonts(theme::font_definitions_with(self.ui.language, &used));
-        self.fonts_bound = used;
-        self.fonts_rebind = true;
-        ctx.request_repaint();
-    }
-
-    /// Follows the desktop/system theme preference and records the effective theme.
-    fn sync_theme_preference(&mut self, ctx: &egui::Context) {
-        let preference = match (
-            self.ui.system_theme,
-            ctx.system_theme().or_else(|| self.desktop_dark.map(|d| if d { egui::Theme::Dark } else { egui::Theme::Light })),
-        ) {
-            (true, Some(egui::Theme::Dark)) => egui::ThemePreference::Dark,
-            (true, Some(egui::Theme::Light)) => egui::ThemePreference::Light,
-            _ => self.ui.theme_preference(),
-        };
-        if ctx.options(|o| o.theme_preference) != preference {
-            ctx.set_theme(preference);
-            ctx.request_repaint();
-        }
-        self.effective_dark = ctx.theme() == egui::Theme::Dark;
-    }
-
-    /// Keeps egui's own keyboard zoom and quit shortcuts off and applies GridCraft's zoom factor.
-    fn sync_input_options(&mut self, ctx: &egui::Context) {
-        // Interface size: the preference owns the zoom factor, so egui's own Ctrl/Cmd +/-/0 zoom
-        // keys stay off (they would also swallow GridCraft's shortcuts).
-        if ctx.options(|o| o.zoom_with_keyboard) {
-            ctx.options_mut(|o| o.zoom_with_keyboard = false);
-        }
-        // egui closes the window on Ctrl+Q (and with Shift or Alt held too) without asking to save
-        // (#1443). Excel for Windows has no such key (Ctrl+Q is Quick Analysis). With a native
-        // window per workbook egui's Cmd+Q would close only the window it was typed in: the menu
-        // bar's Quit item has the key instead (it asks about unsaved workbooks first).
-        if (ctx.os() != egui::os::OperatingSystem::Mac || self.native_windows) && ctx.options(|o| !o.quit_shortcuts.is_empty()) {
-            ctx.options_mut(|o| o.quit_shortcuts.clear());
-        }
-        let zoom = self.ui.zoom_factor();
-        if (ctx.zoom_factor() - zoom).abs() > 0.001 {
-            ctx.set_zoom_factor(zoom);
-            ctx.request_repaint();
-        }
-    }
-
-    /// Opens files that arrived asynchronously (web file picker, dropped files).
-    fn poll_async_opens(&mut self) {
-        let arrived: Vec<(String, Vec<u8>)> = self
-            .services
-            .inbox
-            .as_ref()
-            .map(|i| std::mem::take(&mut *i.lock().unwrap_or_else(std::sync::PoisonError::into_inner)))
-            .unwrap_or_default();
-        for (name, bytes) in arrived {
-            let b64 = gridcraft_engine::io::base64_encode(&bytes);
-            match self.run("file.open", json!({"name": &name, "base64": &b64})) {
-                // A file picked from File › Open (web) arrives here: show it, not the Backstage.
-                Ok(r) => {
-                    self.backstage = None;
-                    self.show_open_warnings(&r);
-                }
-                Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => {
-                    self.backstage = None;
-                    self.open_dialog("openPassword", json!({"name": name, "base64": b64}));
-                }
-                Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
-            }
-            self.after_engine();
-        }
-    }
-
-    /// AutoSave: save workbooks that have a file shortly after they change. This decision lives in
-    /// `logic` so a hidden or logic-only frame still saves; the monotonic timestamp check keeps a
-    /// forced hidden UI pass from saving the same change twice.
-    fn autosave(&mut self, ctx: &egui::Context) {
-        let dirty_xlsx = self.session.active().is_some_and(|d| d.is_dirty() && d.path.as_deref().is_some_and(|p| p.ends_with(".xlsx")));
-        let now = crate::monotonic_ms();
-        let autosave_due =
-            self.ui.autosave && self.editor.is_none() && self.text_box_editor.is_none() && now - self.grid.last_autosave > 2000.0 && dirty_xlsx;
-        if autosave_due {
-            self.grid.last_autosave = now;
-            self.store_view_state();
-            let _ = self.session.run("file.save", json!({}));
-        } else if self.ui.autosave && dirty_xlsx {
-            // Keep checking even when no input arrives while the window is hidden.
-            ctx.request_repaint_after(std::time::Duration::from_secs(2));
-        }
-    }
-
-    /// Look for a newer release once, in the background, as the desktop app starts (a no-op on the
-    /// web). A found release opens the update prompt; nothing is shown when GridCraft is current.
-    pub fn start_update_check(&mut self) {
-        #[cfg(not(target_arch = "wasm32"))]
-        updates_ui::start(self, false);
-    }
-
-    /// Help ▸ Check for Updates…: look now, and say so when GridCraft is up to date or the check fails.
-    pub fn check_for_updates(&mut self) {
-        #[cfg(not(target_arch = "wasm32"))]
-        updates_ui::start(self, true);
-        #[cfg(target_arch = "wasm32")]
-        {
-            self.message = Some(("GridCraft".into(), "The web version is always the latest release.".into()));
-        }
-    }
-
-    /// Window title, next to the close/autosave state: `ViewportCommand::Title` is valid outside a
-    /// pass and a control-channel rename while hidden updates it on return.
-    fn update_title(&mut self, ctx: &egui::Context) {
-        // Native windows get theirs from `doc_windows`.
-        if self.native_windows {
-            return;
-        }
-        let Some(d) = self.session.active() else { return };
-        let title = format!("{}{}", d.display_title(), if d.is_dirty() { " — Edited" } else { "" });
-        if self.grid.last_title.as_deref() != Some(title.as_str()) {
-            ctx.send_viewport_cmd(egui::ViewportCommand::Title(title.clone()));
-            self.grid.last_title = Some(title);
-        }
-    }
-
-    /// A queued/settling capture with a capturable size and an unapplied synthetic step both need
-    /// a real `ui` pass. Once a capture is issued, its `Screenshot` command's own `wants_paint`
-    /// paints the hidden window; after that a full hidden pass every frame only wastes CPU. A
-    /// minimized request has no size, so no hidden pass can reach issuance: the restore pass issues
-    /// it instead. Native eframe honours `RequestPaintWhileHidden`; the web runner does not (hidden
-    /// tabs only run `run_logic`), so a hidden web tab queues the work until it is shown again.
-    /// This is a shared eframe web follow-up, not a GridCraft-local workaround, and the control
-    /// protocol documents the limitation.
-    fn request_hidden_paint(&self, ctx: &egui::Context) {
-        if !(self.shots.needs_hidden_paint() || self.synthetic_pending || !self.synthetic.is_empty()) {
-            return;
-        }
-        // The web runner has no `RequestPaintWhileHidden`; sending it there only logs an
-        // unhandled command. A visible tab still gets the repaint below; a hidden tab keeps the
-        // work queued (see the shared eframe follow-up in docs/egui-037-local-followups.md).
-        #[cfg(not(target_arch = "wasm32"))]
-        ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
-        ctx.request_repaint();
-    }
-
-    /// Records capture geometry from the fresh raw frame, then offers exactly one pending synthetic batch and tracks whether it was applied.
-    pub fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
-        // Capture geometry from this frame's real input before any synthetic event is added. This
-        // runs on every native frame, including hidden/minimized logic-only ticks, so a resize,
-        // DPI/zoom change, Wayland frame without `inner_rect`, or minimize/restore is recorded
-        // even though egui's last UI pass still describes the old layout.
-        let geometry = control::CaptureGeometry::from_raw_input(raw, ctx);
-        control::note_capture_geometry(self, geometry);
-        self.capture_geometry_from_raw = true;
-        // One unapplied gesture step at a time. eframe retains an unconsumed `RawInput` for the
-        // next pass and for a hidden logic-only tick, so the batch is offered once and survives
-        // until a `ui` pass applies it (which pops it). Press and release stay distinct batches.
-        //
-        // A completed egui pass may have consumed the injected events without applying them: the
-        // font gate returns before input handling, but `begin_pass` has already taken the events.
-        // `cumulative_pass_nr` only advances when a pass ends, so a newer value with the batch
-        // still pending means exactly that, and the step is offered again for the next real pass.
-        if self.synthetic_pending {
-            let consumed_by_an_unapplied_pass = self.synthetic_injected_at_pass.is_some_and(|pass| ctx.cumulative_pass_nr() > pass);
-            if !consumed_by_an_unapplied_pass {
-                return;
-            }
-        }
-        if let Some(batch) = self.synthetic.front() {
-            raw.events.extend(batch.iter().cloned());
-            self.synthetic_pending = true;
-            self.synthetic_injected_at_pass = Some(ctx.cumulative_pass_nr());
-        }
-    }
-
-    /// Flip AutoSave (title-bar switch / Options ▸ Save). Persisted with the other UI
-    /// preferences, so it stays as the user left it across restarts (#1901).
-    pub fn toggle_autosave(&mut self) {
-        self.ui.autosave = !self.ui.autosave;
-    }
-
-    /// Lays out the whole window.
-    pub fn ui(&mut self, ui: &mut egui::Ui) {
-        let ctx = ui.ctx().clone();
-        if !self.fonts_ready || self.fonts_rebind {
-            ctx.request_repaint();
-            return;
-        }
-        let t0 = now_ms();
-        // A script may have switched windows since the last frame.
-        self.follow_active_window();
-        text_box::before_ui(self, &ctx);
-        // Another window came forward without going through a command (which settles drafts
-        // first): the draft goes into its own window instead of floating over this one. If its
-        // workbook refuses it, its window comes back to the front with the draft open.
-        if self.draft_elsewhere() {
-            self.commit_edit(0, 0, false, false);
-        }
-        // The language the widgets translate with this frame (see `i18n::current`).
-        i18n::set_current(&ctx, self.ui.language);
-        #[cfg(not(target_arch = "wasm32"))]
-        updates_ui::show(self, &ctx);
-        let t = theme::Tokens::get(&ctx);
-        // A host can turn the File tab off while Backstage is already open: close it.
-        if !self.chrome.file_tab {
-            self.backstage = None;
-        }
-        // Keytips opened the File view (Alt, F): its letters keep working there.
-        if self.backstage.is_none() || self.keytips.prefix().is_some() {
-            self.ribbon_keys(&ctx);
-        }
-        if self.chrome.title_bar {
-            ribbon::title_bar(self, ui);
-        }
-        if self.backstage.is_some() {
-            // File tab: the Backstage view replaces everything below the title bar.
-            backstage::show(self, ui);
-        } else {
-            ribbon::show(self, ui);
-            widgets::notice_bar(self, ui);
-            if self.session.prefs.formula_bar {
-                formula_bar::show(self, ui);
-            }
-            if self.ui.status_bar {
-                tabs::status_bar(self, ui);
-            }
-            tabs::sheet_tabs(self, ui);
-            pivot_pane::show(self, ui);
-            panes::show(self, ui);
-            egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.grid_bg)).show(ui, |ui| {
-                let g0 = now_ms();
-                grid::show(self, ui);
-                self.perf.grid_ms = now_ms() - g0;
-            });
-        }
-        dialogs::show(self, &ctx);
-        widgets::message_box(self, &ctx);
-        widgets::toast(self, &ctx);
-        // Requests are admitted in `logic`, for the root viewport, so only its pass issues them.
-        if ctx.viewport_id() == egui::ViewportId::ROOT {
-            control::issue_screenshots(self, &ctx);
-        }
-        if !ctx.input(|i| i.focused) {
-            // Nothing else to do.
-        }
-        let now = now_ms();
-        self.perf.frame_ms = now - t0;
-        if self.perf.last > 0.0 {
-            let dt = now - self.perf.last;
-            if dt > 0.0 {
-                self.perf.fps = self.perf.fps * 0.9 + 100.0 / dt;
-            }
-        }
-        self.perf.last = now;
-        // The step is applied only after a completed UI pass. A discarded or repeated pass of the
-        // same frame must not offer it again (grid sizing calls `ui` more than once per frame);
-        // provenance is the injected pass number, so only a pass that missed input handling is
-        // re-offered by `raw_input_hook`.
-        // Synthetic input reaches the root viewport only (`raw_input_hook`), so its pass consumes it.
-        if self.synthetic_pending && ctx.viewport_id() == egui::ViewportId::ROOT {
-            self.synthetic.pop_front();
-            self.synthetic_pending = false;
-            self.synthetic_injected_at_pass = None;
-        }
-    }
-
-    fn ribbon_keys(&mut self, ctx: &egui::Context) {
-        let before = self.keytips.prefix().map(str::to_string);
-        let enabled = self.editor.is_none()
-            && self.dialog.is_none()
-            && self.message.is_none()
-            && self.name_box.is_none()
-            && !ctx.text_edit_focused()
-            && self.grid.context_menu.is_none()
-            && self.grid.object_menu.is_none()
-            && self.grid.header_menu.is_none()
-            && self.grid.fill_menu.is_none()
-            && self.grid.filter_menu.is_none()
-            && self.grid.list_picker.is_none()
-            && self.grid.renaming_tab.is_none()
-            && (before.is_some() || !egui::Popup::is_any_open(ctx));
-        let actions = self.keytips.process(ctx, enabled);
-        // Backing out of F to the tab letters, or finishing an F sequence, closes the File view
-        // that Alt, F opened: the command runs on the sheet, as it did without the view.
-        if self.backstage.is_some() && before.is_some() && (self.keytips.prefix() == Some("") || !actions.is_empty()) {
-            self.backstage = None;
-        }
-        if before.is_some() && before.as_deref() != self.keytips.prefix() && !ctx.input(|i| i.pointer.any_pressed()) {
-            // Leave pointer cancellation to the popup so clicking a menu item still works.
-            egui::Popup::close_all(ctx);
-        }
-        for action in actions {
-            match action {
-                keytips::Action::Tab("File") => self.open_backstage(backstage::Page::Home),
-                keytips::Action::Tab(tab) => {
-                    self.run_or_alert("ui.ribbonTab", json!({"tab": tab}));
-                    self.ui.ribbon_collapsed = false;
-                }
-                keytips::Action::Command(id @ ("edit.copy" | "edit.cut")) => self.copy_to_clipboard(ctx, id),
-                keytips::Action::Command("edit.paste") => self.paste_from_clipboard(),
-                keytips::Action::Command(id) => self.run_or_alert(id, json!({})),
-                keytips::Action::CommandWith(id, params) => {
-                    let params: Json = serde_json::from_str(params).unwrap_or_else(|_| json!({}));
-                    // A Borders preset picked by key tip becomes the split button's face, as a
-                    // click on the same menu item does.
-                    if id == "home.borders"
-                        && let Some(preset) = params.get("preset").and_then(Json::as_str)
-                    {
-                        self.grid.last_border = preset.to_string();
-                    }
-                    self.run_or_alert(id, params);
-                }
-                keytips::Action::Dialog(name) => self.open_dialog(name, json!({})),
-                keytips::Action::DialogWith(name, params) => self.open_dialog(name, serde_json::from_str(params).unwrap_or_else(|_| json!({}))),
-                // Reserved sequence: fires silently while its command is missing. When the
-                // command lands in the catalog it goes live with no table edit.
-                keytips::Action::Pending(id) => {
-                    if gridcraft_engine::find_command(id).is_some() {
-                        self.run_or_alert(id, json!({}));
-                    }
-                }
-                // Route to the ribbon control that owns this keytip: it opens its dropdown or
-                // runs its click handler with the right params (the engine command alone would
-                // be missing them).
-                keytips::Action::Control(id) => self.ui.keytip_invoke = Some(id),
-            }
-        }
-    }
-
-    /// Current selection's top-left cell text as A1 (for the Name Box).
-    pub fn name_box_text(&self) -> String {
-        let Some(d) = self.session.active() else { return String::new() };
-        let sel = &d.selection;
-        let cur = sel.current();
-        // A named range that exactly matches shows its name.
-        let sh = d.wb.active();
-        if let Some(sh) = sh {
-            for n in &d.wb.names {
-                let target = n.formula.replace('$', "");
-                let (sheet, body) = match target.rsplit_once('!') {
-                    Some((s, b)) => (Some(gridcraft_engine::core::unquote_sheet(s)), b.to_string()),
-                    None => (None, target.clone()),
-                };
-                if sheet.as_deref().is_none_or(|s| s.eq_ignore_ascii_case(&sh.name)) && RangeRef::parse(&body) == Some(cur) {
-                    return n.name.clone();
-                }
-            }
-        }
-        if self.grid.drag_select && !cur.is_single() {
-            return format!("{}R x {}C", cur.height(), cur.width());
-        }
-        sel.active.a1()
-    }
-}
-
 /// Strips the engine's error prefixes for message boxes.
 pub fn clean_error(e: &str) -> String {
     if let Some(rest) = e.split_once("`: ").map(|(_, r)| r) {
@@ -1903,268 +297,6 @@ pub fn clean_error(e: &str) -> String {
     e.to_string()
 }
 
-/// Wall-clock milliseconds since the Unix epoch, for user-visible timestamps (Backstage's "last
-/// changed", toasts). It can jump when the system clock is adjusted, so it must not drive
-/// deadlines or pacing; use [`monotonic_ms`] for those.
-pub fn now_ms() -> f64 {
-    gridcraft_engine::core::date::unix_now_ms().unwrap_or(0.0)
-}
-
-/// Monotonic milliseconds since the first call, for screenshot deadlines and AutoSave pacing.
-///
-/// Deliberately separate from [`now_ms`]: a wall-clock adjustment must not extend (or expire) a
-/// screenshot deadline or save a workbook twice. Native uses [`std::time::Instant`]; wasm uses the
-/// browser's `performance.now()`, which is monotonic too.
-#[cfg(not(target_arch = "wasm32"))]
-#[allow(clippy::disallowed_methods)] // the std clock is read only off wasm
-pub fn monotonic_ms() -> f64 {
-    use std::sync::OnceLock;
-    static START: OnceLock<std::time::Instant> = OnceLock::new();
-    START.get_or_init(std::time::Instant::now).elapsed().as_secs_f64() * 1000.0
-}
-
-#[cfg(target_arch = "wasm32")]
-/// Web monotonic clock: the browser's `performance.now()`, or 0 when it is unavailable.
-pub fn monotonic_ms() -> f64 {
-    web_sys::window().and_then(|window| window.performance()).map_or(0.0, |performance| performance.now())
-}
-
 pub fn cell(r: u32, c: u32) -> CellRef {
     CellRef::new(r, c)
 }
-
-#[cfg(test)]
-mod lifecycle_tests {
-    use super::*;
-
-    /// Builds a key-A press or release event without modifiers.
-    fn key_event(pressed: bool) -> egui::Event {
-        egui::Event::Key { key: egui::Key::A, physical_key: None, pressed, repeat: false, modifiers: egui::Modifiers::NONE }
-    }
-
-    /// Returns a test app with a new workbook and default services.
-    fn app() -> SheetApp {
-        let mut session = Session::new();
-        session.new_workbook();
-        SheetApp::new(session, Services::default())
-    }
-
-    /// One headless pass; a test has no renderer for the texture atlas delta (0.37 panics when it
-    /// is dropped unapplied).
-    fn ui_pass(ctx: &egui::Context, raw: egui::RawInput, f: impl FnMut(&mut egui::Ui)) -> egui::FullOutput {
-        let mut out = ctx.run_ui(raw, f);
-        out.textures_delta.clear();
-        out
-    }
-
-    #[test]
-    /// Only one synthetic step is offered, is not duplicated by a hidden logic-only tick, and press/release remain distinct batches.
-    fn a_hidden_logic_tick_keeps_one_unapplied_synthetic_step() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.synthetic.push_back(vec![key_event(true)]);
-        app.synthetic.push_back(vec![key_event(false)]);
-
-        let mut first = egui::RawInput::default();
-        app.raw_input_hook(&ctx, &mut first);
-        assert_eq!(first.events.len(), 1, "only one step is offered");
-        assert!(app.synthetic_pending);
-        assert_eq!(app.synthetic.len(), 2, "a logic-only frame does not consume the step");
-
-        // eframe carries the unconsumed `RawInput` into the next pass, so the hook offers the step
-        // only once; a hidden logic-only tick does not duplicate it or offer the release.
-        let mut second = egui::RawInput::default();
-        app.raw_input_hook(&ctx, &mut second);
-        assert!(second.events.is_empty(), "an unapplied step is not injected a second time");
-        assert_eq!(app.synthetic.len(), 2, "press and release stay distinct batches");
-    }
-
-    /// Returns raw input with a screen rect at the given size.
-    fn raw_with_size(size: egui::Vec2) -> egui::RawInput {
-        egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() }
-    }
-
-    #[test]
-    /// A font-gated early-returning pass does not lose the queued step; the hook offers it again and a later real pass applies it.
-    fn a_font_gated_pass_offers_the_synthetic_step_again() {
-        let ctx = egui::Context::default();
-        ctx.set_fonts(theme::font_definitions());
-        let mut app = app();
-        app.fonts_ready = true;
-        app.fonts_set = true;
-        // Binds `session.text_width`, as eframe's first frame does.
-        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        app.synthetic.push_back(vec![key_event(true)]);
-
-        // The font gate returns before input handling; `begin_pass` has still consumed the events.
-        app.fonts_rebind = true;
-        let mut raw = raw_with_size(egui::vec2(900.0, 700.0));
-        app.raw_input_hook(&ctx, &mut raw);
-        assert_eq!(raw.events.len(), 1);
-        let _ = ui_pass(&ctx, raw, |ui| app.ui(ui));
-        assert!(app.synthetic_pending, "the early-returning pass did not apply the step");
-        assert_eq!(app.synthetic.len(), 1, "the step is still queued");
-
-        // A completed pass that did not apply it made the hook offer it again for a real pass.
-        app.fonts_rebind = false;
-        let mut raw = raw_with_size(egui::vec2(900.0, 700.0));
-        app.raw_input_hook(&ctx, &mut raw);
-        assert_eq!(raw.events.len(), 1, "the step is not lost across the font gate");
-        let _ = ui_pass(&ctx, raw, |ui| app.ui(ui));
-        assert!(!app.synthetic_pending);
-        assert!(app.synthetic.is_empty(), "the real UI pass applied the step");
-    }
-
-    #[test]
-    /// A language-driven font rebuild waits while a synthetic step is pending and proceeds once it is clear.
-    fn a_pending_step_delays_a_font_change() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.fonts_ready = true;
-        app.fonts_han = Some(theme::HanOrder::Chinese);
-        app.ui.language = i18n::Language::Ja;
-        app.synthetic.push_back(vec![key_event(true)]);
-        app.synthetic_pending = true;
-        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        assert!(app.fonts_ready, "the font rebuild waits for the pass that applies the step");
-        app.synthetic.clear();
-        app.synthetic_pending = false;
-        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        assert!(!app.fonts_ready, "without pending input the language rebuild proceeds");
-    }
-
-    #[test]
-    /// Logic ticks see fresh viewport and DPI information; resizing back to the original size still advances the capture epoch.
-    fn a_hidden_logic_tick_sees_fresh_viewport_info_and_keeps_the_epoch_monotonic() {
-        /// Runs one logic tick with the requested width and native scale.
-        fn tick(ctx: &egui::Context, app: &mut SheetApp, width: f32, native_ppp: f32) {
-            let mut raw =
-                egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0))), ..Default::default() };
-            if let Some(viewport) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
-                viewport.inner_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0)));
-                viewport.native_pixels_per_point = Some(native_ppp);
-            }
-            let _ = ctx.run_logic(&raw, |ctx| app.logic(ctx));
-        }
-        let ctx = egui::Context::default();
-        let mut app = app();
-        tick(&ctx, &mut app, 800.0, 2.0);
-        let first = app.capture_geometry.expect("the first logic tick records the geometry");
-        assert_eq!(first.viewport, Some(egui::vec2(800.0, 400.0)));
-        assert_eq!(first.pixels_per_point, 2.0, "native scale times the interface zoom");
-        tick(&ctx, &mut app, 900.0, 2.0);
-        let resized = app.capture_geometry.expect("geometry");
-        assert_eq!(resized.viewport, Some(egui::vec2(900.0, 400.0)), "run_logic's ViewportInfo is the fresh size");
-        let epoch = app.capture_epoch;
-        tick(&ctx, &mut app, 800.0, 2.0);
-        assert_eq!(app.capture_geometry.map(|g| g.viewport), Some(Some(egui::vec2(800.0, 400.0))));
-        assert!(app.capture_epoch > epoch, "resizing back is still a new epoch: old pixels must not be saved");
-    }
-
-    #[test]
-    /// A resize and a resize back both advance the capture epoch.
-    fn the_capture_epoch_changes_even_when_the_geometry_returns() {
-        /// Runs one UI pass at the requested width.
-        fn tick(ctx: &egui::Context, app: &mut SheetApp, width: f32) {
-            let raw =
-                egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0))), ..Default::default() };
-            let _ = ui_pass(ctx, raw, |ui| app.logic(ui.ctx()));
-        }
-        let ctx = egui::Context::default();
-        let mut app = app();
-        tick(&ctx, &mut app, 800.0);
-        let base = app.capture_epoch;
-        tick(&ctx, &mut app, 900.0);
-        let changed = app.capture_epoch;
-        assert!(changed > base, "a resize increments the capture epoch");
-        tick(&ctx, &mut app, 800.0);
-        assert!(app.capture_epoch > changed, "resizing back is still a new epoch: old pixels must not be saved");
-    }
-
-    /// Extracts title viewport commands from a logic output.
-    fn titles(out: &egui::LogicOutput) -> Vec<String> {
-        out.viewport_commands
-            .values()
-            .flatten()
-            .filter_map(|c| match c {
-                egui::ViewportCommand::Title(title) => Some(title.clone()),
-                _ => None,
-            })
-            .collect()
-    }
-
-    #[test]
-    /// A hidden logic tick saves a dirty file-backed workbook once and clears its dirty state.
-    fn a_logic_only_tick_autosaves_a_dirty_workbook_once() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        let dir = std::env::temp_dir().join(format!("gridcraft-logic-autosave-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let path = dir.join("autosave.xlsx");
-        app.run("cell.set", serde_json::json!({"cell": "A1", "input": "42"})).unwrap();
-        app.ui.autosave = true;
-        app.session.active_mut().unwrap().path = Some(path.to_string_lossy().into_owned());
-        app.grid.last_autosave = monotonic_ms() - 3000.0;
-
-        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        assert!(path.exists(), "a hidden logic-only tick saves a dirty workbook with a file");
-        assert!(!app.session.active().unwrap().is_dirty(), "the save clears the dirty state");
-        let saved_at = app.grid.last_autosave;
-        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        assert_eq!(app.grid.last_autosave, saved_at, "the same change is not saved a second time");
-
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    /// The title is sent on the first tick and after a rename, but not on every unchanged frame.
-    fn a_logic_only_tick_updates_the_title_once_per_change() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        let first = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        let title = app.session.active().unwrap().display_title().to_string();
-        let expected = format!("{title}{}", if app.session.active().unwrap().is_dirty() { " — Edited" } else { "" });
-        assert_eq!(titles(&first), [expected], "the first logic tick titles the window");
-        let second = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        assert!(titles(&second).is_empty(), "an unchanged title is not sent every frame");
-
-        app.session.active_mut().unwrap().title = "Renamed".into();
-        let third = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        let expected = format!("Renamed{}", if app.session.active().unwrap().is_dirty() { " — Edited" } else { "" });
-        assert_eq!(titles(&third), [expected], "a rename while hidden updates the title");
-    }
-
-    #[test]
-    /// A hidden tick surfaces a failed print job in the app message.
-    fn a_logic_only_tick_polls_printing_feedback() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.printing.printers.push(crate::printing::Printer { name: "Queue".into(), label: String::new(), default: true });
-        app.run("ui.printSettings", serde_json::json!({"printer": "Queue"})).unwrap();
-        app.services.print_native = Some(Box::new(|_, _| {
-            let (sender, receiver) = std::sync::mpsc::channel();
-            sender.send(Err("printer is offline".into())).unwrap();
-            receiver
-        }));
-        app.run("ui.printSubmit", serde_json::json!({})).unwrap();
-        let _ = ctx.run_logic(&egui::RawInput::default(), |ctx| app.logic(ctx));
-        assert_eq!(app.printing.message, Some(crate::printing::Feedback::Failed("printer is offline".into())));
-        assert!(app.message.as_ref().is_some_and(|(_, text)| text.contains("printer is offline")), "logic surfaces the failure");
-    }
-
-    #[test]
-    /// Pending synthetic input makes logic request a real hidden paint.
-    fn a_pending_synthetic_step_requests_a_hidden_paint() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.synthetic.push_back(vec![key_event(true)]);
-        app.synthetic_pending = true;
-        let out = ui_pass(&ctx, egui::RawInput::default(), |ui| app.logic(ui.ctx()));
-        let painted = out
-            .viewport_output
-            .get(&ctx.viewport_id())
-            .is_some_and(|output| output.commands.iter().any(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)));
-        assert!(painted, "logic must ask for a real UI pass while a synthetic step is unapplied");
-    }
-}
diff --git a/crates/ui-egui/src/services.rs b/crates/ui-egui/src/services.rs
new file mode 100644
index 000000000..1e6455860
--- /dev/null
+++ b/crates/ui-egui/src/services.rs
@@ -0,0 +1,61 @@
+use super::*;
+
+/// Host services the platform shell provides (file pickers, opening URLs).
+#[derive(Default)]
+pub struct Services {
+    /// Desktop: discover configured printers on a worker.
+    pub printers: Option<printing::Discover>,
+    /// Desktop: submit the PDF with the chosen settings on a worker.
+    pub print_native: Option<printing::Submit>,
+    pub pick_open: Option<Box<dyn Fn() -> Option<String>>>,
+    pub pick_save: Option<Box<dyn Fn(&str) -> Option<String>>>,
+    /// Native picture picker (PNG/JPEG), separate from workbook opening.
+    pub pick_picture: Option<Box<dyn Fn() -> Option<String>>>,
+    /// Browser picture picker. Each dialog owns its inbox, so canceled picks cannot
+    /// insert into a subsequent dialog or open the image as a workbook.
+    pub pick_picture_async: Option<Box<dyn Fn(Inbox)>>,
+    pub open_url: Option<Box<dyn Fn(&str)>>,
+    /// Publish HTML and its plain-text alternative together. `Ok` means the host owns the
+    /// write (including any asynchronous fallback); an immediate error uses egui's text path.
+    pub copy_html: Option<Box<dyn FnMut(&str, &str) -> Result<(), String>>>,
+    /// Read the HTML flavour of the system clipboard when the user pastes text, so cells the
+    /// source spreadsheet recorded as numbers stay numbers ("Rp10,000.00" → 10000). `None` from
+    /// the host pastes the plain text alone.
+    pub paste_html: Option<Box<dyn FnMut() -> Option<String>>>,
+    /// Read the system clipboard's plain text for the ribbon and menu Paste commands (Cmd/Ctrl+V
+    /// gets it from egui's `Event::Paste`). `None` from the host, or no service (web), pastes
+    /// GridCraft's own clipboard.
+    pub paste_text: Option<Box<dyn FnMut() -> Option<String>>>,
+    /// Web: deliver a file to the user (name, bytes).
+    pub download: Option<Box<dyn Fn(&str, &[u8])>>,
+    /// Web: start an asynchronous file pick; the bytes arrive later in `inbox`.
+    pub open_async: Option<Box<dyn Fn()>>,
+    /// Files delivered asynchronously (name, bytes), opened on the next frame.
+    pub inbox: Option<Inbox>,
+    /// Web: hand PDF bytes to the browser's print flow directly (no download,
+    /// no intermediate file) — opens the system print dialog on that PDF.
+    pub print: Option<Box<dyn Fn(&[u8])>>,
+}
+
+/// Shared queue of files read asynchronously (browser file picker, drag and drop).
+pub type Inbox = std::sync::Arc<std::sync::Mutex<Vec<(String, Vec<u8>)>>>;
+
+/// Which parts of the app's own window chrome are drawn. Everything is on by default; a host
+/// that embeds the sheet in its own window (and owns files itself) can turn off the title bar
+/// and the File tab, whose Backstage view then never opens. Not persisted: it describes the
+/// host, not a user preference.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Chrome {
+    /// The title bar: AutoSave, Home, Save, Undo/Redo, the file name, Comments, Share, Search and
+    /// the theme switch.
+    pub title_bar: bool,
+    /// The ribbon's File tab and the Backstage view it opens (also reached by keyboard and
+    /// commands such as `ui.backstage`).
+    pub file_tab: bool,
+}
+
+impl Default for Chrome {
+    fn default() -> Self {
+        Chrome { title_bar: true, file_tab: true }
+    }
+}
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
new file mode 100644
index 000000000..d9e6ceaaa
--- /dev/null
+++ b/crates/ui-egui/src/state.rs
@@ -0,0 +1,40 @@
+/// Per-sheet view state (scroll position in sheet points).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct SheetView {
+    pub scroll: egui::Vec2,
+}
+
+/// Severity of a notice shown in the info bar under the ribbon.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum NoticeKind {
+    Info,
+    Warning,
+}
+
+/// An answer to the Save Changes question.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SaveAnswer {
+    Save,
+    DontSave,
+    Cancel,
+}
+
+/// One open window, as View › Switch Windows and the macOS Window menu list it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct OpenWindow {
+    /// The window's id, the `window` param of `view.switchWindows`.
+    pub window: u64,
+    /// Its workbook's `DocState::uid`.
+    pub doc: u64,
+    pub title: String,
+    pub dirty: bool,
+    pub active: bool,
+}
+
+impl OpenWindow {
+    /// The title ("Book1", or "Book1:2" for a workbook's second window), with a bullet after it
+    /// while the workbook has unsaved changes.
+    pub fn label(&self) -> String {
+        if self.dirty { format!("{} •", self.title) } else { self.title.clone() }
+    }
+}

From 5f041665b523425b75e6b0fcad88940a7f912559 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Mon, 26 Oct 2026 20:22:58 +0000
Subject: [PATCH 73/76] refactor(ui-egui): move SheetApp methods to app/

---
 crates/ui-egui/src/app.rs           | 1260 +--------------------------
 crates/ui-egui/src/app/clipboard.rs |   77 ++
 crates/ui-egui/src/app/commands.rs  |  348 ++++++++
 crates/ui-egui/src/app/editing.rs   |  211 +++++
 crates/ui-egui/src/app/files.rs     |  127 +++
 crates/ui-egui/src/app/fonts.rs     |  112 +++
 crates/ui-egui/src/app/input.rs     |   33 +
 crates/ui-egui/src/app/keys.rs      |   66 ++
 crates/ui-egui/src/app/prefs.rs     |   65 ++
 crates/ui-egui/src/app/print.rs     |   89 ++
 crates/ui-egui/src/app/quit.rs      |   96 ++
 crates/ui-egui/src/app/view.rs      |   56 ++
 12 files changed, 1293 insertions(+), 1247 deletions(-)
 create mode 100644 crates/ui-egui/src/app/clipboard.rs
 create mode 100644 crates/ui-egui/src/app/commands.rs
 create mode 100644 crates/ui-egui/src/app/editing.rs
 create mode 100644 crates/ui-egui/src/app/files.rs
 create mode 100644 crates/ui-egui/src/app/fonts.rs
 create mode 100644 crates/ui-egui/src/app/input.rs
 create mode 100644 crates/ui-egui/src/app/keys.rs
 create mode 100644 crates/ui-egui/src/app/prefs.rs
 create mode 100644 crates/ui-egui/src/app/print.rs
 create mode 100644 crates/ui-egui/src/app/quit.rs
 create mode 100644 crates/ui-egui/src/app/view.rs

diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index a524925ce..f2671692a 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -3,6 +3,18 @@ use super::services::{Chrome, Services};
 use super::state::{NoticeKind, OpenWindow, SaveAnswer, SheetView};
 use super::*;
 
+mod clipboard;
+mod commands;
+mod editing;
+mod files;
+mod fonts;
+mod input;
+mod keys;
+mod prefs;
+mod print;
+mod quit;
+mod view;
+
 impl SheetApp {
     /// Constructs a `SheetApp` with default UI, grid, printing, control and screenshot state and the caller's session and services.
     pub fn new(session: Session, services: Services) -> SheetApp {
@@ -69,7 +81,7 @@ impl SheetApp {
     ///
     /// [`logic`]: SheetApp::logic
     pub fn setup_context(ctx: &egui::Context, dark: bool) {
-        fonts::start_scan();
+        crate::fonts::start_scan();
         Self::setup_context_for_language(ctx, dark, i18n::Language::En);
     }
 
@@ -79,984 +91,6 @@ impl SheetApp {
         theme::apply(ctx, dark);
     }
 
-    /// Test-harness setup: mark a deterministic font set (see
-    /// [`theme::pinned_font_definitions`]) as already installed, so the first `logic` pass neither
-    /// starts the host font scan nor replaces the harness's pinned set. Production uses
-    /// [`Self::setup_context`] instead.
-    #[doc(hidden)]
-    pub fn use_prepared_fonts(&mut self) {
-        self.prepared_fonts = true;
-        self.fonts_ready = true;
-        self.fonts_set = true;
-        self.fonts_rebind = false;
-        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
-        self.fonts_bound = self.used_fonts();
-        self.fonts_seen = self.fonts_key();
-    }
-
-    /// The font names the open workbooks use: every style's font plus the theme's heading/body
-    /// fonts. These are the families [`fonts`] binds an installed file for. Every workbook's, as
-    /// each may be showing in a window of its own.
-    pub fn used_fonts(&self) -> Vec<String> {
-        let mut names: Vec<String> = Vec::new();
-        for d in self.session.documents() {
-            names.extend(d.wb.styles.iter().map(|(_, s)| s.font.name.clone()));
-            names.push(d.wb.theme.major_font.clone());
-            names.push(d.wb.theme.minor_font.clone());
-            // Text boxes and shapes name their own typefaces.
-            names.extend(d.wb.sheets.iter().flat_map(|sh| sh.shapes.iter().filter_map(|s| s.format.font.clone())));
-        }
-        names
-    }
-
-    /// The open workbooks' (uid, revision), folded: [`Self::used_fonts`] changes only with it.
-    fn fonts_key(&self) -> (u64, u64) {
-        self.session
-            .documents()
-            .iter()
-            .fold((0u64, 0u64), |(uid, rev), d| (uid.wrapping_mul(31).wrapping_add(d.uid), rev.wrapping_mul(31).wrapping_add(d.revision)))
-    }
-
-    /// Runs an engine command (or a UI command) and handles UI requests it makes.
-    pub fn run(&mut self, id: &str, params: Json) -> Result<Json, String> {
-        let r = self.run_command(id, params);
-        // This copy leaves the system clipboard alone: note what it holds, so Paste can tell
-        // that GridCraft's copy is newer while that text is still there.
-        if matches!(id, "edit.copy" | "edit.cut") && r.is_ok() {
-            self.clipboard_text_at_copy = self.system_clipboard_text();
-            self.cut_text = if id == "edit.cut" { self.clipboard_text_at_copy.clone() } else { None };
-        }
-        r
-    }
-
-    fn run_command(&mut self, id: &str, params: Json) -> Result<Json, String> {
-        let switches_window = id.starts_with("window.")
-            || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
-            || (id == "view.switchWindows" && ["window", "doc"].iter().any(|k| params.get(*k).is_some_and(|d| !d.is_null())));
-        if id.starts_with("file.") || switches_window {
-            self.settle_drafts()?;
-        }
-        if matches!(id, "file.save" | "file.saveAs" | "file.saveBytes") {
-            self.store_view_state();
-        }
-        if matches!(
-            id,
-            "sheet.activate"
-                | "sheet.next"
-                | "sheet.previous"
-                | "sheet.move"
-                | "sheet.hide"
-                | "sheet.unhide"
-                | "home.insertSheet"
-                | "home.deleteSheet"
-                | "edit.undo"
-                | "edit.redo"
-                | "object.delete"
-                | "object.move"
-        ) {
-            self.commit_text_box_edit()?;
-        }
-        if let Some(r) = self.run_ui_command(id, &params) {
-            return r;
-        }
-        let before = self.session.active_window();
-        let r = self.session.run(id, params);
-        if id.starts_with("file.") && self.session.active_window() != before {
-            // File › New or Open from the Backstage view: the window it was in goes back to its sheet.
-            self.backstage = None;
-        }
-        // Requests the command made (a dialog, a draft) belong to the window it left active.
-        self.follow_active_window();
-        self.after_engine();
-        if id == "view.arrangeAll"
-            && self.native_windows
-            && let Ok(r) = &r
-        {
-            let arrange = r.get("arrange").and_then(Json::as_str).unwrap_or("tiled").to_string();
-            let windows = r.get("windows").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
-            self.arrange_windows = Some((arrange, windows));
-        }
-        // The new chart is selected, as after inserting any object, so Delete removes it, not its data.
-        if id == "insert.chart"
-            && let Ok(r) = &r
-            && let Some(chart) = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok())
-        {
-            self.selected_chart = Some(chart);
-        }
-        if id == "file.exportPdf"
-            && let Ok(r) = &r
-        {
-            self.deliver_pdf(r);
-        }
-        r
-    }
-
-    /// Copy or cut the selected cells to the system clipboard. Engine-only commands keep
-    /// their existing internal clipboard behavior and do not write to the host clipboard.
-    pub fn copy_to_clipboard(&mut self, ctx: &egui::Context, command: &str) {
-        // Only ask the engine for HTML when the host can publish it.
-        let result = match self.run_command(command, json!({"html": self.services.copy_html.is_some()})) {
-            Ok(result) => result,
-            Err(e) => return self.alert(e),
-        };
-        let Some(text) = result.get("text").and_then(Json::as_str) else { return };
-        // The system clipboard gets this copy, so its text decides what Paste pastes.
-        self.clipboard_text_at_copy = None;
-        self.cut_text = (command == "edit.cut").then(|| text.replace("\r\n", "\n"));
-        if let Some(html) = result.get("html").and_then(Json::as_str)
-            && let Some(copy_html) = &mut self.services.copy_html
-        {
-            match copy_html(html, text) {
-                Ok(()) => return,
-                Err(error) => log::warn!("HTML clipboard unavailable; copying plain text: {error}"),
-            }
-        }
-        ctx.copy_text(text.to_string());
-    }
-
-    /// Paste text that came from the system clipboard (Cmd/Ctrl+V, or the ribbon and menu Paste),
-    /// with the clipboard's HTML flavour when the host can read it.
-    ///
-    /// Excel pastes a cut once: after GridCraft's cut has been pasted, the system clipboard text
-    /// that came with it is not pasted again over the moved block; GridCraft's own (empty)
-    /// clipboard is pasted instead, which reports "Nothing to paste.". Other text means the
-    /// clipboard has moved on, so the cut's text is forgotten and pastes normally later.
-    pub fn paste_external(&mut self, text: String) {
-        if Self::same_clipboard_text(Some(&text), self.cut_text.as_deref()) {
-            if self.session.clipboard.is_none() {
-                return self.run_or_alert("edit.paste", json!({}));
-            }
-        } else {
-            self.cut_text = None;
-        }
-        let html = self.services.paste_html.as_mut().and_then(|read| read());
-        let params = match html {
-            Some(html) => json!({"text": text, "html": html}),
-            None => json!({"text": text}),
-        };
-        self.run_or_alert("edit.paste", params);
-    }
-
-    /// Ribbon and menu Paste: paste the text on the system clipboard, as Cmd/Ctrl+V does. With no
-    /// text there, no host clipboard (web), or the text that was there when GridCraft last copied
-    /// without publishing, GridCraft's own clipboard is pasted.
-    pub fn paste_from_clipboard(&mut self) {
-        match self.system_clipboard_text() {
-            Some(text) if self.session.clipboard.is_none() || self.clipboard_text_at_copy.as_ref() != Some(&text) => self.paste_external(text),
-            _ => self.run_or_alert("edit.paste", json!({})),
-        }
-    }
-
-    /// The system clipboard's plain text, with the line endings of egui's `Event::Paste` text.
-    /// `None` when it holds no text or the host can't read it.
-    fn system_clipboard_text(&mut self) -> Option<String> {
-        self.services.paste_text.as_mut().and_then(|read| read()).filter(|t| !t.is_empty()).map(|t| t.replace("\r\n", "\n"))
-    }
-
-    /// Whether two clipboard texts are the same copy: trailing line breaks don't count, as in the
-    /// engine's `edit.paste`, and CRLF matches LF (egui's `Event::Paste` text may keep the host's).
-    fn same_clipboard_text(a: Option<&str>, b: Option<&str>) -> bool {
-        fn chars(t: &str) -> impl Iterator<Item = char> + '_ {
-            t.trim_end_matches(['\r', '\n']).chars().filter(|c| *c != '\r')
-        }
-        match (a, b) {
-            (Some(a), Some(b)) => chars(a).eq(chars(b)),
-            _ => false,
-        }
-    }
-
-    /// Web: `file.exportPdf` without a path returns the PDF as base64; hand it to the browser as a download.
-    fn deliver_pdf(&self, result: &Json) {
-        if result.get("path").is_some() {
-            return;
-        }
-        if let Some(dl) = &self.services.download
-            && let Some(b) = result.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
-        {
-            let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
-            dl(&std::path::Path::new(&title).with_extension("pdf").to_string_lossy(), &b);
-        }
-    }
-
-    /// Runs a command and shows its error in a message box (for menu/ribbon clicks).
-    /// Follow the desktop's light/dark choice while the app runs (Linux; the desktop app calls
-    /// this once — tests and embedders don't start the watcher thread).
-    pub fn watch_desktop_theme(&mut self) {
-        self.desktop_theme = desktop_theme::DesktopTheme::start();
-    }
-
-    pub fn run_or_alert(&mut self, id: &str, params: Json) {
-        // A menu/shortcut opens the settings first; the Print page's button submits explicitly.
-        if id == "file.print" {
-            if self.services.print_native.is_some() {
-                self.open_backstage(backstage::Page::Print);
-                return;
-            }
-            return self.print_now(params);
-        }
-        // Menu-style Export as PDF with no file named: ask where to save, like Save As does.
-        // Programmatic callers use `run` and keep getting the PDF bytes back.
-        if id == "file.exportPdf" && self.services.pick_save.is_some() && params.get("path").and_then(Json::as_str).is_none_or(str::is_empty) {
-            return self.export_pdf_with_picker(params);
-        }
-        // Recommended Charts with no chart type named (ribbon button, keytip, command search) asks
-        // which chart to insert; programmatic callers of `run` still get the first recommendation.
-        if id == "insert.recommendedCharts" && params.get("type").is_none() {
-            return self.open_dialog("recommendedCharts", json!({}));
-        }
-        // Switch Windows with no window named (key tip, command search) opens the View tab's
-        // list to choose from; programmatic callers of `run` get the list back.
-        if id == "view.switchWindows" && ["window", "doc"].iter().all(|k| params.get(*k).is_none_or(Json::is_null)) {
-            self.ui.ribbon_tab = "View".into();
-            self.ui.ribbon_collapsed = false;
-            self.open_switch_windows = true;
-            return;
-        }
-        match self.run(id, params) {
-            // A refused cell draft already shows its own message (with the rule's title).
-            Err(e) if self.message.as_ref().is_some_and(|(_, m)| *m == e) => {}
-            Err(e) => self.alert(e),
-            Ok(_) => {}
-        }
-    }
-
-    /// Asks for a `.pdf` path with the save picker, then re-runs `file.exportPdf` with it. Other
-    /// params (range, sheets, fitToPage) are kept. A cancelled picker does nothing.
-    fn export_pdf_with_picker(&mut self, mut params: Json) {
-        if !self.commit_edit(0, 0, false, false) {
-            return;
-        }
-        let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
-        let stem = std::path::Path::new(&title).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Book1").to_string();
-        let Some(pick) = &self.services.pick_save else { return };
-        let Some(path) = pick(&format!("{stem}.pdf")) else { return };
-        // The picker may suggest a workbook extension; the export writes a PDF.
-        let path = std::path::Path::new(&path).with_extension("pdf").to_string_lossy().into_owned();
-        match &mut params {
-            Json::Object(map) => {
-                map.insert("path".into(), Json::String(path));
-            }
-            other => *other = json!({"path": path}),
-        }
-        if let Err(e) = self.run("file.exportPdf", params) {
-            self.alert(e);
-        }
-    }
-
-    /// Shows a command error: a toast for an unavailable command, else a message box.
-    fn alert(&mut self, e: String) {
-        // Shown in the window the user ends up in, also after a command that switched windows.
-        self.follow_active_window();
-        if e.contains("is not available right now") {
-            self.toast = Some((e, now_ms()));
-        } else {
-            self.message = Some(("GridCraft".into(), clean_error(&e)));
-        }
-    }
-
-    /// Builds the selected sheets' print-ready PDF and hands it to the desktop worker or the
-    /// browser. Rendering errors use the usual alert; asynchronous spooler errors stay visible
-    /// on the Print page. The engine command still returns PDF bytes without submitting.
-    pub fn print_now(&mut self, params: Json) {
-        if let Err(error) = self.submit_print(params) {
-            self.alert(error);
-        }
-    }
-
-    fn submit_print(&mut self, params: Json) -> Result<Json, String> {
-        if self.services.print_native.is_some() && !self.printing.ready() {
-            return Err("Select an available printer in File > Print before submitting.".into());
-        }
-        let pdf = self.run("file.print", params)?;
-        let encoded = pdf.get("base64").and_then(Json::as_str).ok_or("The print command did not produce a PDF.")?;
-        let bytes = gridcraft_engine::io::base64_decode(encoded).ok_or("Couldn't decode the generated PDF.")?;
-        let len = bytes.len();
-        if let Some(submit) = &self.services.print_native {
-            self.printing.begin(submit(bytes, self.printing.settings.clone())).map_err(|_| "A print job is already being submitted.".to_owned())?;
-            self.print_feedback_seen = None;
-        } else if let Some(print) = &self.services.print {
-            print(&bytes);
-        } else {
-            return Err("Printing is unavailable here; export a PDF instead.".into());
-        }
-        Ok(json!({"printing": true, "bytes": len, "pending": self.services.print_native.is_some()}))
-    }
-
-    /// UI-only commands (dialogs, view toggles that aren't saved in the file).
-    fn run_ui_command(&mut self, id: &str, p: &Json) -> Option<Result<Json, String>> {
-        let r = match id {
-            "app.checkForUpdates" | "help.checkForUpdates" => {
-                self.check_for_updates();
-                Ok(Json::Null)
-            }
-            "ui.printSettings" => printing::settings(&mut self.printing, p, self.services.printers.as_ref()),
-            "ui.printSubmit" => self.submit_print(p.clone()),
-            "ui.ribbonTab" => {
-                self.ui.ribbon_tab = p.get("tab").and_then(Json::as_str).unwrap_or("Home").to_string();
-                Ok(Json::Null)
-            }
-            "view.collapseRibbon" => {
-                self.ui.ribbon_collapsed = !self.ui.ribbon_collapsed;
-                Ok(Json::Null)
-            }
-            "view.expandFormulaBar" => {
-                self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded);
-                Ok(json!({"on": self.ui.formula_bar_expanded}))
-            }
-            "view.darkMode" => {
-                let current = if self.ui.system_theme { self.effective_dark } else { self.ui.dark };
-                self.ui.dark = p.get("on").and_then(Json::as_bool).unwrap_or(!current);
-                self.ui.system_theme = false;
-                Ok(json!({"on": self.ui.dark}))
-            }
-            "view.theme" => {
-                match p.get("mode").and_then(Json::as_str) {
-                    Some("system") => self.ui.system_theme = true,
-                    Some(mode @ ("light" | "dark")) => {
-                        self.ui.dark = mode == "dark";
-                        self.ui.system_theme = false;
-                    }
-                    _ => return Some(Err("theme mode must be system, light, or dark".into())),
-                }
-                Ok(json!({"mode": self.ui.theme_mode()}))
-            }
-            "view.animations" => {
-                self.ui.animations = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.animations);
-                Ok(json!({"on": self.ui.animations}))
-            }
-            "options.autoComplete" => {
-                self.ui.autocomplete = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.autocomplete);
-                Ok(json!({"on": self.ui.autocomplete}))
-            }
-            "view.interfaceScale" => {
-                // `{"percent": 125}` or `{"percent": "auto"}`; out-of-range values are clamped.
-                let percent = match p.get("percent") {
-                    Some(Json::String(s)) if s.eq_ignore_ascii_case("auto") => Some(100),
-                    Some(v) => v.as_f64().and_then(clamp_interface_scale),
-                    None => None,
-                };
-                match percent {
-                    Some(v) => {
-                        self.ui.interface_scale = v;
-                        Ok(json!({"percent": v}))
-                    }
-                    None => Err(format!("missing `percent` ({INTERFACE_SCALE_MIN}–{INTERFACE_SCALE_MAX}, or \"auto\")")),
-                }
-            }
-            "app.language.set" => {
-                // `{"language": "ja"}`; `code` is accepted as an alias.
-                let code = p.get("language").or_else(|| p.get("code")).and_then(Json::as_str).unwrap_or("");
-                match i18n::Language::parse(code) {
-                    Some(l) => {
-                        self.ui.language = l;
-                        Ok(json!({"language": l}))
-                    }
-                    None => Err(format!("unknown language {code:?} (use one of {})", i18n::Language::code_list(", "))),
-                }
-            }
-            "app.language.english" => {
-                self.ui.language = i18n::Language::En;
-                Ok(json!({"language": i18n::Language::En}))
-            }
-            "app.language.japanese" => {
-                self.ui.language = i18n::Language::Ja;
-                Ok(json!({"language": i18n::Language::Ja}))
-            }
-            "ui.backstage" => {
-                // `{"page": "info"}` opens File › Info; `{"page": "close"}` returns to the sheet.
-                match p.get("page").and_then(Json::as_str).map(str::trim) {
-                    Some("close" | "none" | "") => self.backstage = None,
-                    Some(id) => match backstage::Page::parse(id) {
-                        Some(page) => self.open_backstage(page),
-                        None => {
-                            return Some(Err(format!(
-                                "unknown File page {id:?} (use home, new, open, info, saveAs, print, export, options or close)"
-                            )));
-                        }
-                    },
-                    None => self.open_backstage(backstage::Page::Home),
-                }
-                Ok(json!({"page": self.backstage.as_ref().map(|b| b.page.id())}))
-            }
-            "ui.dialog" => {
-                let name = p.get("name").and_then(Json::as_str).unwrap_or("");
-                self.open_dialog(name, p.clone());
-                Ok(json!({"dialog": self.dialog.as_ref().map(|d| d.name())}))
-            }
-            "ui.message.dismiss" => {
-                self.message = None;
-                Ok(Json::Null)
-            }
-            "ui.notice" => Ok(match &self.notice {
-                Some(n) => json!({
-                    "text": n.text,
-                    "kind": match n.kind { NoticeKind::Warning => "warning", NoticeKind::Info => "info" },
-                    "action": n.action,
-                }),
-                None => Json::Null,
-            }),
-            "ui.notice.dismiss" => {
-                self.notice = None;
-                Ok(Json::Null)
-            }
-            _ => return None,
-        };
-        Some(r)
-    }
-
-    /// Picks up requests commands made (dialogs, edit mode…).
-    pub fn after_engine(&mut self) {
-        // The requests belong to the window the command left active.
-        self.follow_active_window();
-        for req in self.session.take_ui_requests() {
-            match req {
-                UiRequest::Dialog(name, params) => self.open_dialog(&name, params),
-                UiRequest::Message(m) => self.message = Some(("GridCraft".into(), m)),
-                UiRequest::EditCell(text) => {
-                    let text = text.map(|text| {
-                        self.session
-                            .active()
-                            .map(|d| formula_locale::display_template(&text, self.ui.language.formula_locale(), &d.wb, d.wb.active_sheet()))
-                            .unwrap_or(text)
-                    });
-                    self.begin_edit(text, false);
-                }
-                UiRequest::InsertName(name) => dialogs::insert_name(self, &name),
-                UiRequest::OpenUrl(u) => {
-                    if let Some(f) = &self.services.open_url {
-                        f(&u);
-                    }
-                }
-            }
-        }
-    }
-
-    /// Whether the active sheet of the active document is protected (drives the Protect/Unprotect
-    /// Sheet labels and actions).
-    pub fn active_sheet_protected(&self) -> bool {
-        self.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false)
-    }
-
-    pub fn open_dialog(&mut self, name: &str, params: Json) {
-        if let Err(e) = self.commit_text_box_edit() {
-            self.message = Some(("Text Box".into(), clean_error(&e)));
-            return;
-        }
-        // Every Protect Sheet entry point (ribbon menus, keytips, tab menu) becomes Unprotect Sheet
-        // on a protected sheet. A sheet without a password is unprotected straight away.
-        let name = if name == "protectSheet" && self.active_sheet_protected() { "unprotectSheet" } else { name };
-        if name == "unprotectSheet"
-            && self
-                .session
-                .active()
-                .and_then(|d| d.wb.active())
-                .and_then(|s| s.protection.as_ref())
-                .is_some_and(|p| p.password.is_none() && p.legacy_password_hash.is_none())
-        {
-            self.run_or_alert("review.unprotectSheet", json!({}));
-            return;
-        }
-        match name {
-            "open" => {
-                if let Some(start) = &self.services.open_async {
-                    start();
-                } else if let Some(pick) = &self.services.pick_open
-                    && let Some(path) = pick()
-                {
-                    self.open_path(&path);
-                }
-            }
-            "saveAs" => {
-                let suggested = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
-                if let Some(pick) = &self.services.pick_save {
-                    if let Some(path) = pick(&suggested) {
-                        let path = if std::path::Path::new(&path).extension().is_none() { format!("{path}.xlsx") } else { path };
-                        self.run_or_alert("file.save", json!({"path": path}));
-                    }
-                } else if self.services.download.is_some()
-                    && let Ok(r) = self.run("file.saveBytes", json!({"format": "xlsx"}))
-                    && let Some(dl) = &self.services.download
-                    && let Some(b) = r.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
-                {
-                    let name = r.get("name").and_then(Json::as_str).unwrap_or("Book.xlsx").to_string();
-                    dl(&name, &b);
-                }
-            }
-            // File › Options (`file.options`) and the File tab itself open the Backstage view.
-            "options" => self.open_backstage(backstage::Page::Options),
-            "backstage" => {
-                let page = params.get("page").and_then(Json::as_str).and_then(backstage::Page::parse).unwrap_or(backstage::Page::Home);
-                self.open_backstage(page);
-            }
-            other => self.dialog = dialogs::Dialog::open(self, other, params),
-        }
-    }
-
-    /// Opens the File tab's Backstage view on `page`, committing a cell still being edited first
-    /// (File actions work on the whole workbook). A draft that can't be committed keeps the sheet.
-    pub fn open_backstage(&mut self, page: backstage::Page) {
-        if !self.chrome.file_tab {
-            return;
-        }
-        if !self.commit_edit(0, 0, false, false) {
-            return;
-        }
-        match &mut self.backstage {
-            Some(b) => b.page = page,
-            None => self.backstage = Some(backstage::Backstage::new(page)),
-        }
-    }
-
-    pub fn open_path(&mut self, path: &str) {
-        match self.run("file.open", json!({"path": path})) {
-            Ok(r) => self.after_open(Some(path), &r),
-            // A password-protected workbook: ask for the password; the dialog opens it.
-            Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => self.open_dialog("openPassword", json!({"path": path})),
-            Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
-        }
-        self.after_engine();
-    }
-
-    /// What follows a successful `file.open`: the workbook shows (not the Backstage), the Recent
-    /// list (for a file on disk) and the open warnings notice. Shared by File › Open, the
-    /// password dialog and the control channel.
-    pub fn after_open(&mut self, path: Option<&str>, r: &Json) {
-        self.backstage = None;
-        if let Some(path) = path {
-            self.ui.recent.retain(|p| p != path);
-            self.ui.recent.insert(0, path.to_string());
-            self.ui.recent.truncate(20);
-        }
-        self.show_open_warnings(r);
-    }
-
-    /// Turns the `warnings` a `file.open` result carries into an info-bar notice, choosing the
-    /// most important one (a preserved VBA project outranks, say, a skipped optional part).
-    /// Kept deliberately generic: any open-time warning can reach the user this way.
-    pub fn show_open_warnings(&mut self, r: &Json) {
-        // The opened workbook's window shows them, however it was opened (a script may have run
-        // `file.open` on the session directly).
-        self.follow_active_window();
-        let Some(list) = r.get("warnings").and_then(Json::as_array) else {
-            self.notice = None;
-            return;
-        };
-        let msgs: Vec<&str> = list.iter().filter_map(Json::as_str).collect();
-        if msgs.is_empty() {
-            // A clean open clears any notice left over from the previous document.
-            self.notice = None;
-            return;
-        }
-        let vba: Vec<&str> = msgs.iter().copied().filter(|m| m.to_lowercase().contains("macro") || m.contains("VBA")).collect();
-        if !vba.is_empty() {
-            // The reader says "dropped" when the VBA project was missing or unreadable; never promise to keep it then.
-            let dropped = vba.iter().any(|m| m.contains("dropped"));
-            let text = if dropped {
-                "This workbook's VBA macros could not be loaded and were dropped, so they will not be in the saved file. Keep the original file."
-            } else {
-                "This workbook contains VBA macros. GridCraft keeps them when you save as .xlsm, but does not run them."
-            };
-            self.notice = Some(Notice { text: text.into(), kind: NoticeKind::Warning, action: Some(("What this means".into(), "macros".into())) });
-        } else {
-            let text = if msgs.len() == 1 {
-                msgs[0].to_string()
-            } else {
-                format!("{} items in this file were handled differently. First: {}", msgs.len(), msgs[0])
-            };
-            self.notice = Some(Notice { text, kind: NoticeKind::Info, action: None });
-        }
-    }
-
-    /// The open windows in order, for the Switch Windows lists.
-    pub fn open_windows(&self) -> Vec<OpenWindow> {
-        let active = self.session.active_window();
-        self.session
-            .windows()
-            .iter()
-            .filter_map(|w| {
-                let d = self.session.documents().iter().find(|d| d.uid == w.doc_uid)?;
-                let title = self.session.window_title(w.id)?;
-                Some(OpenWindow { window: w.id, doc: d.uid, title, dirty: d.is_dirty(), active: active == Some(w.id) })
-            })
-            .collect()
-    }
-
-    /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
-    pub fn view_key(&self) -> Option<(u64, usize)> {
-        self.session.active().map(|d| (d.uid, d.wb.active_sheet()))
-    }
-
-    /// The active window and sheet: each window scrolls on its own.
-    fn scroll_key(&self) -> Option<(u64, usize)> {
-        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet()))
-    }
-
-    pub fn view(&self) -> SheetView {
-        self.scroll_key().and_then(|k| self.views.get(&k).copied()).unwrap_or_else(|| self.saved_view())
-    }
-
-    pub fn view_mut(&mut self) -> Option<&mut SheetView> {
-        let k = self.scroll_key()?;
-        let saved = self.saved_view();
-        Some(self.views.entry(k).or_insert(saved))
-    }
-
-    /// The view a sheet opens with: scrolled to the file's saved first visible cell (`topLeftCell`).
-    fn saved_view(&self) -> SheetView {
-        let Some(sh) = self.session.active().and_then(|d| d.wb.active()) else { return SheetView::default() };
-        if sh.view != gridcraft_engine::model::SheetViewMode::Normal {
-            return SheetView::default();
-        }
-        let (fr, fc) = sh.freeze.unwrap_or((0, 0));
-        let top = sh.view_top_left;
-        let y = sh.row_top(top.row.max(fr)) - sh.row_top(fr);
-        let x = sh.col_left(top.col.max(fc)) - sh.col_left(fc);
-        SheetView { scroll: egui::vec2(x.max(0.0) as f32, y.max(0.0) as f32) }
-    }
-
-    /// Hands the active document's scroll positions (first visible cell per sheet) and active
-    /// cell to the engine so a save writes them (`sheetView topLeftCell`). Normal view only:
-    /// Page Layout view scrolls over pages, not cells.
-    pub fn store_view_state(&mut self) {
-        let window = self.session.active_window();
-        let Some(d) = self.session.active_mut() else { return };
-        let mut tops = Vec::new();
-        for (&(w, si), v) in &self.views {
-            let Some(sh) = d.wb.sheets.get(si).filter(|sh| Some(w) == window && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
-                continue;
-            };
-            let (fr, fc) = sh.freeze.unwrap_or((0, 0));
-            // A hair past the edge so a row that starts exactly at the scroll offset is the one found.
-            let row = sh.row_at(sh.row_top(fr) + v.scroll.y.max(0.0) as f64 + 0.01);
-            let col = sh.col_at(sh.col_left(fc) + v.scroll.x.max(0.0) as f64 + 0.01);
-            tops.push((si, CellRef::new(row, col)));
-        }
-        d.store_view(&tops);
-    }
-
-    /// Starts editing the active cell. `text` replaces the content (typing) or pre-fills it.
-    pub fn begin_edit(&mut self, text: Option<String>, from_formula_bar: bool) {
-        // The source formula is display-only on spill children. Grid replacement keeps its
-        // existing behavior, but no formula-bar entry path may edit that displayed formula.
-        if from_formula_bar && formula_bar::active_spill_anchor(self).is_some() {
-            return;
-        }
-        if let Err(e) = self.commit_text_box_edit() {
-            self.message = Some(("Text Box".into(), clean_error(&e)));
-            return;
-        }
-        let Some(d) = self.session.active() else { return };
-        let Some(sh) = d.wb.active() else { return };
-        let at = sh.merge_at(d.selection.active).map(|m| m.start).unwrap_or(d.selection.active);
-        // A picture has no editable scalar text. Selecting it, F2, or clicking
-        // the formula bar must not turn its fallback value into a text edit.
-        // Typing still starts an intentional replacement.
-        if text.is_none() && sh.cell_pictures.contains_key(&at) {
-            return;
-        }
-        let locale = self.ui.language.formula_locale();
-        let current = if sh.cell_pictures.contains_key(&at) {
-            String::new()
-        } else {
-            match sh.cell(at) {
-                Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet()),
-                _ => gridcraft_engine::display::edit_text(&d.wb, sh, at),
-            }
-        };
-        let (text, replace) = match text {
-            Some(t) => (t, true),
-            None => (current.clone(), false),
-        };
-        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet(), at, text, replace, from_formula_bar);
-        ed.window = self.session.active_window();
-        ed.locale = locale;
-        if replace && self.ui.autocomplete && !ed.is_formula() {
-            ed.completion = editor::column_completion(sh, at, &ed.text);
-        }
-        self.editor = Some(ed);
-        self.session.mode = if replace { gridcraft_engine::Mode::Enter } else { gridcraft_engine::Mode::Edit };
-    }
-
-    /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
-    ///
-    /// The draft goes into the window and workbook it was typed in. If another window is
-    /// showing, that window stays active afterwards; a draft its own workbook refuses
-    /// (validation, a bad formula) brings its window back to the front with the draft still open.
-    pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
-        let Some((doc, window)) = self.editor.as_ref().map(|ed| (ed.doc, ed.window)) else { return true };
-        if !self.draft_elsewhere() {
-            return self.commit_edit_here(dr, dc, array, fill_selection);
-        }
-        // Its window, or (when that window closed) its workbook's most recent one.
-        let Some(owner) = window.filter(|w| self.session.window(*w).is_some()).or_else(|| self.session.doc_window(doc)) else {
-            self.cancel_edit();
-            return true;
-        };
-        let back = self.session.active_window();
-        self.session.activate_window(owner);
-        if !self.commit_edit_here(dr, dc, array, fill_selection) {
-            // Refused: its window stays in front with the draft open and the reason shown.
-            return false;
-        }
-        if let Some(back) = back {
-            self.session.activate_window(back);
-        }
-        true
-    }
-
-    /// The cell draft belongs to a window or workbook other than the one showing.
-    fn draft_elsewhere(&self) -> bool {
-        self.editor.as_ref().is_some_and(|ed| {
-            self.session.active().map(|d| d.uid) != Some(ed.doc) || ed.window.is_some_and(|w| self.session.active_window() != Some(w))
-        })
-    }
-
-    /// Commits the cell and text-box drafts, as Enter would, before a command that can show
-    /// another workbook or write this one to a file, so a draft never lands in another workbook.
-    /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
-    pub(crate) fn settle_drafts(&mut self) -> Result<(), String> {
-        if !self.commit_edit(0, 0, false, false) {
-            return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
-        }
-        self.commit_text_box_edit()
-    }
-
-    fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
-        let Some(ed) = self.editor.take() else { return true };
-        self.session.mode = gridcraft_engine::Mode::Ready;
-        let text = match &ed.completion {
-            Some(full) if full.to_lowercase().starts_with(&ed.text.to_lowercase()) => full.clone(),
-            _ => ed.text.clone(),
-        };
-        // F2 then Enter (or a file command) on an untouched draft: nothing to write.
-        if !fill_selection && !array && ed.original.as_ref() == Some(&text) {
-            if dr != 0 || dc != 0 {
-                self.move_after_enter(dr, dc);
-            }
-            return true;
-        }
-        let text = match self.session.active().map(|d| formula_locale::canonical(&text, ed.locale, &d.wb, ed.sheet, ed.cell)) {
-            Some(Ok(text)) => text,
-            Some(Err(error)) => {
-                self.message = Some(("GridCraft".into(), error.to_string()));
-                self.editor = Some(ed);
-                self.session.mode = gridcraft_engine::Mode::Edit;
-                return false;
-            }
-            None => text,
-        };
-        // Data validation.
-        if let Some(d) = self.session.active()
-            && let Some((dv, msg)) = gridcraft_engine::cmd::data::check_validation(&d.wb, ed.sheet, ed.cell, &text)
-        {
-            if dv.error_style == gridcraft_engine::model::ErrorStyle::Stop {
-                let title = if dv.error_title.is_empty() { "GridCraft".to_string() } else { dv.error_title.clone() };
-                self.message = Some((title, msg));
-                self.editor = Some(ed);
-                self.session.mode = gridcraft_engine::Mode::Edit;
-                return false;
-            }
-            self.toast = Some((msg, now_ms()));
-        }
-        // Point mode can leave another sheet active; the edit belongs to the sheet it started on.
-        if self.session.active().is_some_and(|d| d.wb.active_sheet() != ed.sheet)
-            && let Err(e) = self.session.run("sheet.activate", json!({"sheet": ed.sheet}))
-        {
-            self.message = Some(("GridCraft".into(), clean_error(&e)));
-            self.editor = Some(ed);
-            self.session.mode = gridcraft_engine::Mode::Edit;
-            return false;
-        }
-        // Committing nothing into an empty cell changes nothing: no undo step (#1855, Backspace has
-        // already cleared the cell as its own step).
-        let unchanged = !fill_selection
-            && !array
-            && text.is_empty()
-            && self
-                .session
-                .active()
-                .and_then(|d| d.wb.sheet(ed.sheet))
-                .is_some_and(|sh| sh.cell(ed.cell).is_none_or(|c| c.formula.is_none() && c.value == gridcraft_engine::core::Value::Empty));
-        let r = if unchanged {
-            Ok(json!({}))
-        } else if fill_selection {
-            self.session.run("range.fill", json!({"input": text}))
-        } else {
-            self.session.run("cell.set", json!({"cell": ed.cell.a1(), "input": text, "array": array}))
-        };
-        match r {
-            Ok(_) => {
-                if dr != 0 || dc != 0 {
-                    self.move_after_enter(dr, dc);
-                }
-                self.after_engine();
-                true
-            }
-            Err(e) => {
-                self.message = Some(("GridCraft".into(), clean_error(&e)));
-                self.editor = Some(ed);
-                self.session.mode = gridcraft_engine::Mode::Edit;
-                false
-            }
-        }
-    }
-
-    /// Commits the edit with an arrow key. The arrow is an ordinary move, so it ends a run of Tabs
-    /// instead of continuing it (Right) or going back to its column like Enter (Down), as in Excel.
-    pub fn commit_edit_arrow(&mut self, dr: i64, dc: i64) -> bool {
-        let run = self.tab_run.take();
-        let ok = self.commit_edit(dr, dc, false, false);
-        self.tab_run = if ok { None } else { run };
-        ok
-    }
-
-    pub fn cancel_edit(&mut self) {
-        self.editor = None;
-        self.session.mode = gridcraft_engine::Mode::Ready;
-    }
-
-    /// Enter/Tab move inside a multi-cell selection, otherwise to the next cell.
-    pub fn move_after_enter(&mut self, dr: i64, dc: i64) {
-        let multi = self.session.active().is_some_and(|d| !d.selection.is_single_cell());
-        // Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
-        // last Tab landed on, which ends the run.
-        let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
-        let run = self.tab_run.take().filter(|&(uid, sheet, _, at)| here == Some((uid, sheet, at)));
-        if multi {
-            let fwd = dr > 0 || dc > 0;
-            let _ = self.session.run("selection.next", json!({"forward": fwd, "byRow": dc != 0}));
-        } else if let (Some((_, _, col, at)), 1, 0) = (run, dr, dc) {
-            let back = i64::from(col) - i64::from(at.col);
-            let _ = self.session.run("selection.move", json!({"dr": 1, "dc": back}));
-        } else {
-            let _ = self.session.run("selection.move", json!({"dr": dr, "dc": dc}));
-            if dr == 0 && dc != 0 {
-                let start = run.map(|r| r.2);
-                self.tab_run = self.session.active().and_then(|d| {
-                    let (uid, sheet) = (d.uid, d.wb.active_sheet());
-                    let col = start.or(here.map(|h| h.2.col))?;
-                    Some((uid, sheet, col, d.selection.active))
-                });
-            }
-        }
-        self.grid.ensure_visible = true;
-    }
-
-    /// Terminal feedback also reaches the normal window when printing starts through control.
-    /// Polls printing feedback. Called once per frame from [`Self::logic`]; the direct calls in
-    /// `tests/native_print.rs` deliberately bypass the lifecycle to test this helper alone.
-    pub fn poll_printing(&mut self, ctx: &egui::Context) {
-        self.printing.poll(ctx);
-        if self.printing.message == self.print_feedback_seen {
-            return;
-        }
-        self.print_feedback_seen = self.printing.message.clone();
-        let Some(message @ (printing::Feedback::Submitted(_) | printing::Feedback::Failed(_) | printing::Feedback::WorkerStopped)) =
-            self.printing.message.clone()
-        else {
-            return;
-        };
-        let text = printing::feedback(&message, self.ui.language, |label| self.ui.language.tr(label).to_owned());
-        if matches!(message, printing::Feedback::Submitted(_)) {
-            self.toast = Some((text, now_ms()));
-        } else {
-            self.alert(text);
-        }
-    }
-
-    /// Holds back a window close (the close button, Alt+F4, the OS quitting the app) while a
-    /// workbook has unsaved changes, and asks about them first.
-    fn guard_window_close(&mut self, ctx: &egui::Context) {
-        if self.native_windows || self.allow_close || !ctx.input(|i| i.viewport().close_requested()) {
-            return;
-        }
-        // A cell still being edited is part of the workbook, as for File › Close.
-        if !self.commit_edit(0, 0, false, false) {
-            ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-            return;
-        }
-        if !self.session.documents().iter().any(|d| d.is_dirty()) {
-            return;
-        }
-        ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-        match self.dialog.as_mut() {
-            // Already asking about a workbook (File › Close): answering it now goes on to quit.
-            Some(d) if d.name() == "saveChanges" => {
-                d.values.insert("quit".into(), json!(true));
-            }
-            _ => self.continue_quit(ctx),
-        }
-    }
-
-    /// Asks about the next unsaved workbook before quitting, in its window, or closes the app
-    /// once none is left.
-    pub(crate) fn continue_quit(&mut self, ctx: &egui::Context) {
-        let dirty = self.session.documents().iter().find(|d| d.is_dirty()).map(|d| d.uid);
-        match dirty.and_then(|uid| self.session.doc_window(uid)) {
-            Some(window) => {
-                // Its window comes forward (the native window too: see `doc_windows`).
-                self.enter_window(window);
-                let title = self.session.active().map(|d| d.display_title()).unwrap_or_default();
-                self.open_dialog("saveChanges", json!({"title": title, "quit": true}));
-            }
-            None => {
-                self.allow_close = true;
-                ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Close);
-            }
-        }
-    }
-
-    /// Answers the Save Changes question about the active workbook (its buttons). While quitting,
-    /// the next unsaved workbook is asked about once this one is answered; Cancel stops the quit.
-    /// Returns whether the question is settled: Save keeps it open when the cell being edited
-    /// can't be entered.
-    pub fn answer_save_changes(&mut self, answer: SaveAnswer, quitting: bool, ctx: &egui::Context) -> bool {
-        match answer {
-            SaveAnswer::Cancel => {}
-            SaveAnswer::DontSave => {
-                self.run_or_alert("file.close", json!({"force": true, "document": true}));
-                if quitting {
-                    self.continue_quit(ctx);
-                }
-            }
-            SaveAnswer::Save => {
-                // File operations include the cell still being edited, as File › Save does.
-                if !self.commit_edit(0, 0, false, false) {
-                    return false;
-                }
-                self.run_or_alert("file.save", json!({}));
-                if self.session.active().is_some_and(|x| !x.is_dirty()) {
-                    self.run_or_alert("file.close", json!({"force": true, "document": true}));
-                    if quitting {
-                        self.continue_quit(ctx);
-                    }
-                }
-            }
-        }
-        true
-    }
-
-    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, then asks
-    /// about each unsaved workbook in its window; Cancel on any of them stops the quit. A draft its
-    /// workbook refuses stops the quit too, with its window in front and the reason shown.
-    pub fn request_quit(&mut self, ctx: &egui::Context) {
-        while let Some(window) = self.parked_window_with_draft() {
-            self.enter_window(window);
-            if self.settle_drafts().is_err() {
-                return;
-            }
-        }
-        if self.settle_drafts().is_err() {
-            return;
-        }
-        if let Some(d) = self.dialog.as_mut().filter(|d| d.name() == "saveChanges") {
-            // Already asking about a workbook (File › Close): answering it goes on to quit.
-            d.values.insert("quit".into(), json!(true));
-            return;
-        }
-        self.continue_quit(ctx);
-    }
-
     /// Per-frame logic (control channel, screenshots). Call before `ui`.
     pub fn logic(&mut self, ctx: &egui::Context) {
         self.ensure_text_width(ctx);
@@ -1103,175 +137,6 @@ impl SheetApp {
         self.follow_active_window();
     }
 
-    /// Installs the text-width closure once, on the first frame.
-    fn ensure_text_width(&mut self, ctx: &egui::Context) {
-        if self.session.text_width.is_some() {
-            return;
-        }
-        let ctx = ctx.clone();
-        self.session.text_width = Some(std::sync::Arc::new(move |text, font, exact| theme::cell_text_width(&ctx, text, font, exact)));
-    }
-
-    /// Applies the font gates: a language Han-order change, startup/prepared fonts and workbook
-    /// font binding. Every branch keeps its one-frame paint gate.
-    fn apply_font_state(&mut self, ctx: &egui::Context) {
-        // A pending synthetic step owns the next real `ui` pass: `ui` returns at the font gate
-        // before it handles input, so a font change requested now would consume the step without
-        // applying it. Delay the change one frame; the hidden-paint request keeps it coming.
-        let defer_font_change = self.synthetic_pending || !self.synthetic.is_empty();
-        if !defer_font_change && self.fonts_han.is_some_and(|han| han != theme::HanOrder::of(self.ui.language)) {
-            self.fonts_ready = false;
-            self.fonts_set = false;
-        }
-        if !self.fonts_ready {
-            self.start_font_setup(ctx);
-        } else if self.fonts_rebind {
-            // A font-set change made last frame is active now.
-            self.fonts_rebind = false;
-        } else if !defer_font_change && !self.prepared_fonts && fonts::scan_done() {
-            self.rebind_workbook_fonts(ctx);
-        }
-    }
-
-    /// Applies the pending font set. New fonts apply from the next frame on: paint nothing until
-    /// then. Startup always proceeds: without it a queued step would be re-offered forever.
-    fn start_font_setup(&mut self, ctx: &egui::Context) {
-        if self.fonts_set {
-            self.fonts_ready = true;
-            return;
-        }
-        if self.prepared_fonts {
-            ctx.set_fonts(theme::pinned_font_definitions());
-            theme::apply(ctx, self.ui.dark);
-        } else {
-            SheetApp::setup_context_for_language(ctx, self.ui.dark, self.ui.language);
-        }
-        self.fonts_set = true;
-        // The rebuilt set has no workbook fonts yet: bind them again once it is active.
-        self.fonts_bound.clear();
-        self.fonts_seen = (0, 0);
-        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
-        ctx.request_repaint();
-    }
-
-    /// Binds the workbook's installed fonts once the background scan has finished. Adding fonts
-    /// re-applies the font set, which egui activates at the next pass, so skip this frame's paint
-    /// (same one-frame cost as startup). Only when an open workbook changed.
-    fn rebind_workbook_fonts(&mut self, ctx: &egui::Context) {
-        let seen = self.fonts_key();
-        if seen == self.fonts_seen {
-            return;
-        }
-        let used = self.used_fonts();
-        self.fonts_seen = seen;
-        if used == self.fonts_bound {
-            return;
-        }
-        ctx.set_fonts(theme::font_definitions_with(self.ui.language, &used));
-        self.fonts_bound = used;
-        self.fonts_rebind = true;
-        ctx.request_repaint();
-    }
-
-    /// Follows the desktop/system theme preference and records the effective theme.
-    fn sync_theme_preference(&mut self, ctx: &egui::Context) {
-        let preference = match (
-            self.ui.system_theme,
-            ctx.system_theme().or_else(|| self.desktop_dark.map(|d| if d { egui::Theme::Dark } else { egui::Theme::Light })),
-        ) {
-            (true, Some(egui::Theme::Dark)) => egui::ThemePreference::Dark,
-            (true, Some(egui::Theme::Light)) => egui::ThemePreference::Light,
-            _ => self.ui.theme_preference(),
-        };
-        if ctx.options(|o| o.theme_preference) != preference {
-            ctx.set_theme(preference);
-            ctx.request_repaint();
-        }
-        self.effective_dark = ctx.theme() == egui::Theme::Dark;
-    }
-
-    /// Keeps egui's own keyboard zoom and quit shortcuts off and applies GridCraft's zoom factor.
-    fn sync_input_options(&mut self, ctx: &egui::Context) {
-        // Interface size: the preference owns the zoom factor, so egui's own Ctrl/Cmd +/-/0 zoom
-        // keys stay off (they would also swallow GridCraft's shortcuts).
-        if ctx.options(|o| o.zoom_with_keyboard) {
-            ctx.options_mut(|o| o.zoom_with_keyboard = false);
-        }
-        // egui closes the window on Ctrl+Q (and with Shift or Alt held too) without asking to save
-        // (#1443). Excel for Windows has no such key (Ctrl+Q is Quick Analysis). With a native
-        // window per workbook egui's Cmd+Q would close only the window it was typed in: the menu
-        // bar's Quit item has the key instead (it asks about unsaved workbooks first).
-        if (ctx.os() != egui::os::OperatingSystem::Mac || self.native_windows) && ctx.options(|o| !o.quit_shortcuts.is_empty()) {
-            ctx.options_mut(|o| o.quit_shortcuts.clear());
-        }
-        let zoom = self.ui.zoom_factor();
-        if (ctx.zoom_factor() - zoom).abs() > 0.001 {
-            ctx.set_zoom_factor(zoom);
-            ctx.request_repaint();
-        }
-    }
-
-    /// Opens files that arrived asynchronously (web file picker, dropped files).
-    fn poll_async_opens(&mut self) {
-        let arrived: Vec<(String, Vec<u8>)> = self
-            .services
-            .inbox
-            .as_ref()
-            .map(|i| std::mem::take(&mut *i.lock().unwrap_or_else(std::sync::PoisonError::into_inner)))
-            .unwrap_or_default();
-        for (name, bytes) in arrived {
-            let b64 = gridcraft_engine::io::base64_encode(&bytes);
-            match self.run("file.open", json!({"name": &name, "base64": &b64})) {
-                // A file picked from File › Open (web) arrives here: show it, not the Backstage.
-                Ok(r) => {
-                    self.backstage = None;
-                    self.show_open_warnings(&r);
-                }
-                Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => {
-                    self.backstage = None;
-                    self.open_dialog("openPassword", json!({"name": name, "base64": b64}));
-                }
-                Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
-            }
-            self.after_engine();
-        }
-    }
-
-    /// AutoSave: save workbooks that have a file shortly after they change. This decision lives in
-    /// `logic` so a hidden or logic-only frame still saves; the monotonic timestamp check keeps a
-    /// forced hidden UI pass from saving the same change twice.
-    fn autosave(&mut self, ctx: &egui::Context) {
-        let dirty_xlsx = self.session.active().is_some_and(|d| d.is_dirty() && d.path.as_deref().is_some_and(|p| p.ends_with(".xlsx")));
-        let now = crate::monotonic_ms();
-        let autosave_due =
-            self.ui.autosave && self.editor.is_none() && self.text_box_editor.is_none() && now - self.grid.last_autosave > 2000.0 && dirty_xlsx;
-        if autosave_due {
-            self.grid.last_autosave = now;
-            self.store_view_state();
-            let _ = self.session.run("file.save", json!({}));
-        } else if self.ui.autosave && dirty_xlsx {
-            // Keep checking even when no input arrives while the window is hidden.
-            ctx.request_repaint_after(std::time::Duration::from_secs(2));
-        }
-    }
-
-    /// Look for a newer release once, in the background, as the desktop app starts (a no-op on the
-    /// web). A found release opens the update prompt; nothing is shown when GridCraft is current.
-    pub fn start_update_check(&mut self) {
-        #[cfg(not(target_arch = "wasm32"))]
-        updates_ui::start(self, false);
-    }
-
-    /// Help ▸ Check for Updates…: look now, and say so when GridCraft is up to date or the check fails.
-    pub fn check_for_updates(&mut self) {
-        #[cfg(not(target_arch = "wasm32"))]
-        updates_ui::start(self, true);
-        #[cfg(target_arch = "wasm32")]
-        {
-            self.message = Some(("GridCraft".into(), "The web version is always the latest release.".into()));
-        }
-    }
-
     /// Window title, next to the close/autosave state: `ViewportCommand::Title` is valid outside a
     /// pass and a control-channel rename while hidden updates it on return.
     fn update_title(&mut self, ctx: &egui::Context) {
@@ -1307,42 +172,6 @@ impl SheetApp {
         ctx.request_repaint();
     }
 
-    /// Records capture geometry from the fresh raw frame, then offers exactly one pending synthetic batch and tracks whether it was applied.
-    pub fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
-        // Capture geometry from this frame's real input before any synthetic event is added. This
-        // runs on every native frame, including hidden/minimized logic-only ticks, so a resize,
-        // DPI/zoom change, Wayland frame without `inner_rect`, or minimize/restore is recorded
-        // even though egui's last UI pass still describes the old layout.
-        let geometry = control::CaptureGeometry::from_raw_input(raw, ctx);
-        control::note_capture_geometry(self, geometry);
-        self.capture_geometry_from_raw = true;
-        // One unapplied gesture step at a time. eframe retains an unconsumed `RawInput` for the
-        // next pass and for a hidden logic-only tick, so the batch is offered once and survives
-        // until a `ui` pass applies it (which pops it). Press and release stay distinct batches.
-        //
-        // A completed egui pass may have consumed the injected events without applying them: the
-        // font gate returns before input handling, but `begin_pass` has already taken the events.
-        // `cumulative_pass_nr` only advances when a pass ends, so a newer value with the batch
-        // still pending means exactly that, and the step is offered again for the next real pass.
-        if self.synthetic_pending {
-            let consumed_by_an_unapplied_pass = self.synthetic_injected_at_pass.is_some_and(|pass| ctx.cumulative_pass_nr() > pass);
-            if !consumed_by_an_unapplied_pass {
-                return;
-            }
-        }
-        if let Some(batch) = self.synthetic.front() {
-            raw.events.extend(batch.iter().cloned());
-            self.synthetic_pending = true;
-            self.synthetic_injected_at_pass = Some(ctx.cumulative_pass_nr());
-        }
-    }
-
-    /// Flip AutoSave (title-bar switch / Options ▸ Save). Persisted with the other UI
-    /// preferences, so it stays as the user left it across restarts (#1901).
-    pub fn toggle_autosave(&mut self) {
-        self.ui.autosave = !self.ui.autosave;
-    }
-
     /// Lays out the whole window.
     pub fn ui(&mut self, ui: &mut egui::Ui) {
         let ctx = ui.ctx().clone();
@@ -1428,69 +257,6 @@ impl SheetApp {
         }
     }
 
-    fn ribbon_keys(&mut self, ctx: &egui::Context) {
-        let before = self.keytips.prefix().map(str::to_string);
-        let enabled = self.editor.is_none()
-            && self.dialog.is_none()
-            && self.message.is_none()
-            && self.name_box.is_none()
-            && !ctx.text_edit_focused()
-            && self.grid.context_menu.is_none()
-            && self.grid.object_menu.is_none()
-            && self.grid.header_menu.is_none()
-            && self.grid.fill_menu.is_none()
-            && self.grid.filter_menu.is_none()
-            && self.grid.list_picker.is_none()
-            && self.grid.renaming_tab.is_none()
-            && (before.is_some() || !egui::Popup::is_any_open(ctx));
-        let actions = self.keytips.process(ctx, enabled);
-        // Backing out of F to the tab letters, or finishing an F sequence, closes the File view
-        // that Alt, F opened: the command runs on the sheet, as it did without the view.
-        if self.backstage.is_some() && before.is_some() && (self.keytips.prefix() == Some("") || !actions.is_empty()) {
-            self.backstage = None;
-        }
-        if before.is_some() && before.as_deref() != self.keytips.prefix() && !ctx.input(|i| i.pointer.any_pressed()) {
-            // Leave pointer cancellation to the popup so clicking a menu item still works.
-            egui::Popup::close_all(ctx);
-        }
-        for action in actions {
-            match action {
-                keytips::Action::Tab("File") => self.open_backstage(backstage::Page::Home),
-                keytips::Action::Tab(tab) => {
-                    self.run_or_alert("ui.ribbonTab", json!({"tab": tab}));
-                    self.ui.ribbon_collapsed = false;
-                }
-                keytips::Action::Command(id @ ("edit.copy" | "edit.cut")) => self.copy_to_clipboard(ctx, id),
-                keytips::Action::Command("edit.paste") => self.paste_from_clipboard(),
-                keytips::Action::Command(id) => self.run_or_alert(id, json!({})),
-                keytips::Action::CommandWith(id, params) => {
-                    let params: Json = serde_json::from_str(params).unwrap_or_else(|_| json!({}));
-                    // A Borders preset picked by key tip becomes the split button's face, as a
-                    // click on the same menu item does.
-                    if id == "home.borders"
-                        && let Some(preset) = params.get("preset").and_then(Json::as_str)
-                    {
-                        self.grid.last_border = preset.to_string();
-                    }
-                    self.run_or_alert(id, params);
-                }
-                keytips::Action::Dialog(name) => self.open_dialog(name, json!({})),
-                keytips::Action::DialogWith(name, params) => self.open_dialog(name, serde_json::from_str(params).unwrap_or_else(|_| json!({}))),
-                // Reserved sequence: fires silently while its command is missing. When the
-                // command lands in the catalog it goes live with no table edit.
-                keytips::Action::Pending(id) => {
-                    if gridcraft_engine::find_command(id).is_some() {
-                        self.run_or_alert(id, json!({}));
-                    }
-                }
-                // Route to the ribbon control that owns this keytip: it opens its dropdown or
-                // runs its click handler with the right params (the engine command alone would
-                // be missing them).
-                keytips::Action::Control(id) => self.ui.keytip_invoke = Some(id),
-            }
-        }
-    }
-
     /// Current selection's top-left cell text as A1 (for the Name Box).
     pub fn name_box_text(&self) -> String {
         let Some(d) = self.session.active() else { return String::new() };
diff --git a/crates/ui-egui/src/app/clipboard.rs b/crates/ui-egui/src/app/clipboard.rs
new file mode 100644
index 000000000..4d6e466d4
--- /dev/null
+++ b/crates/ui-egui/src/app/clipboard.rs
@@ -0,0 +1,77 @@
+use super::*;
+
+impl SheetApp {
+    /// Copy or cut the selected cells to the system clipboard. Engine-only commands keep
+    /// their existing internal clipboard behavior and do not write to the host clipboard.
+    pub fn copy_to_clipboard(&mut self, ctx: &egui::Context, command: &str) {
+        // Only ask the engine for HTML when the host can publish it.
+        let result = match self.run_command(command, json!({"html": self.services.copy_html.is_some()})) {
+            Ok(result) => result,
+            Err(e) => return self.alert(e),
+        };
+        let Some(text) = result.get("text").and_then(Json::as_str) else { return };
+        // The system clipboard gets this copy, so its text decides what Paste pastes.
+        self.clipboard_text_at_copy = None;
+        self.cut_text = (command == "edit.cut").then(|| text.replace("\r\n", "\n"));
+        if let Some(html) = result.get("html").and_then(Json::as_str)
+            && let Some(copy_html) = &mut self.services.copy_html
+        {
+            match copy_html(html, text) {
+                Ok(()) => return,
+                Err(error) => log::warn!("HTML clipboard unavailable; copying plain text: {error}"),
+            }
+        }
+        ctx.copy_text(text.to_string());
+    }
+
+    /// Paste text that came from the system clipboard (Cmd/Ctrl+V, or the ribbon and menu Paste),
+    /// with the clipboard's HTML flavour when the host can read it.
+    ///
+    /// Excel pastes a cut once: after GridCraft's cut has been pasted, the system clipboard text
+    /// that came with it is not pasted again over the moved block; GridCraft's own (empty)
+    /// clipboard is pasted instead, which reports "Nothing to paste.". Other text means the
+    /// clipboard has moved on, so the cut's text is forgotten and pastes normally later.
+    pub fn paste_external(&mut self, text: String) {
+        if Self::same_clipboard_text(Some(&text), self.cut_text.as_deref()) {
+            if self.session.clipboard.is_none() {
+                return self.run_or_alert("edit.paste", json!({}));
+            }
+        } else {
+            self.cut_text = None;
+        }
+        let html = self.services.paste_html.as_mut().and_then(|read| read());
+        let params = match html {
+            Some(html) => json!({"text": text, "html": html}),
+            None => json!({"text": text}),
+        };
+        self.run_or_alert("edit.paste", params);
+    }
+
+    /// Ribbon and menu Paste: paste the text on the system clipboard, as Cmd/Ctrl+V does. With no
+    /// text there, no host clipboard (web), or the text that was there when GridCraft last copied
+    /// without publishing, GridCraft's own clipboard is pasted.
+    pub fn paste_from_clipboard(&mut self) {
+        match self.system_clipboard_text() {
+            Some(text) if self.session.clipboard.is_none() || self.clipboard_text_at_copy.as_ref() != Some(&text) => self.paste_external(text),
+            _ => self.run_or_alert("edit.paste", json!({})),
+        }
+    }
+
+    /// The system clipboard's plain text, with the line endings of egui's `Event::Paste` text.
+    /// `None` when it holds no text or the host can't read it.
+    pub(super) fn system_clipboard_text(&mut self) -> Option<String> {
+        self.services.paste_text.as_mut().and_then(|read| read()).filter(|t| !t.is_empty()).map(|t| t.replace("\r\n", "\n"))
+    }
+
+    /// Whether two clipboard texts are the same copy: trailing line breaks don't count, as in the
+    /// engine's `edit.paste`, and CRLF matches LF (egui's `Event::Paste` text may keep the host's).
+    fn same_clipboard_text(a: Option<&str>, b: Option<&str>) -> bool {
+        fn chars(t: &str) -> impl Iterator<Item = char> + '_ {
+            t.trim_end_matches(['\r', '\n']).chars().filter(|c| *c != '\r')
+        }
+        match (a, b) {
+            (Some(a), Some(b)) => chars(a).eq(chars(b)),
+            _ => false,
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs
new file mode 100644
index 000000000..a3dd9ac37
--- /dev/null
+++ b/crates/ui-egui/src/app/commands.rs
@@ -0,0 +1,348 @@
+use super::*;
+
+impl SheetApp {
+    /// Runs an engine command (or a UI command) and handles UI requests it makes.
+    pub fn run(&mut self, id: &str, params: Json) -> Result<Json, String> {
+        let r = self.run_command(id, params);
+        // This copy leaves the system clipboard alone: note what it holds, so Paste can tell
+        // that GridCraft's copy is newer while that text is still there.
+        if matches!(id, "edit.copy" | "edit.cut") && r.is_ok() {
+            self.clipboard_text_at_copy = self.system_clipboard_text();
+            self.cut_text = if id == "edit.cut" { self.clipboard_text_at_copy.clone() } else { None };
+        }
+        r
+    }
+
+    pub(super) fn run_command(&mut self, id: &str, params: Json) -> Result<Json, String> {
+        let switches_window = id.starts_with("window.")
+            || matches!(id, "view.newWindow" | "view.hideWindow" | "view.unhideWindow")
+            || (id == "view.switchWindows" && ["window", "doc"].iter().any(|k| params.get(*k).is_some_and(|d| !d.is_null())));
+        if id.starts_with("file.") || switches_window {
+            self.settle_drafts()?;
+        }
+        if matches!(id, "file.save" | "file.saveAs" | "file.saveBytes") {
+            self.store_view_state();
+        }
+        if matches!(
+            id,
+            "sheet.activate"
+                | "sheet.next"
+                | "sheet.previous"
+                | "sheet.move"
+                | "sheet.hide"
+                | "sheet.unhide"
+                | "home.insertSheet"
+                | "home.deleteSheet"
+                | "edit.undo"
+                | "edit.redo"
+                | "object.delete"
+                | "object.move"
+        ) {
+            self.commit_text_box_edit()?;
+        }
+        if let Some(r) = self.run_ui_command(id, &params) {
+            return r;
+        }
+        let before = self.session.active_window();
+        let r = self.session.run(id, params);
+        if id.starts_with("file.") && self.session.active_window() != before {
+            // File › New or Open from the Backstage view: the window it was in goes back to its sheet.
+            self.backstage = None;
+        }
+        // Requests the command made (a dialog, a draft) belong to the window it left active.
+        self.follow_active_window();
+        self.after_engine();
+        if id == "view.arrangeAll"
+            && self.native_windows
+            && let Ok(r) = &r
+        {
+            let arrange = r.get("arrange").and_then(Json::as_str).unwrap_or("tiled").to_string();
+            let windows = r.get("windows").and_then(Json::as_array).map(|a| a.iter().filter_map(Json::as_u64).collect()).unwrap_or_default();
+            self.arrange_windows = Some((arrange, windows));
+        }
+        // The new chart is selected, as after inserting any object, so Delete removes it, not its data.
+        if id == "insert.chart"
+            && let Ok(r) = &r
+            && let Some(chart) = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok())
+        {
+            self.selected_chart = Some(chart);
+        }
+        if id == "file.exportPdf"
+            && let Ok(r) = &r
+        {
+            self.deliver_pdf(r);
+        }
+        r
+    }
+
+    pub fn run_or_alert(&mut self, id: &str, params: Json) {
+        // A menu/shortcut opens the settings first; the Print page's button submits explicitly.
+        if id == "file.print" {
+            if self.services.print_native.is_some() {
+                self.open_backstage(backstage::Page::Print);
+                return;
+            }
+            return self.print_now(params);
+        }
+        // Menu-style Export as PDF with no file named: ask where to save, like Save As does.
+        // Programmatic callers use `run` and keep getting the PDF bytes back.
+        if id == "file.exportPdf" && self.services.pick_save.is_some() && params.get("path").and_then(Json::as_str).is_none_or(str::is_empty) {
+            return self.export_pdf_with_picker(params);
+        }
+        // Recommended Charts with no chart type named (ribbon button, keytip, command search) asks
+        // which chart to insert; programmatic callers of `run` still get the first recommendation.
+        if id == "insert.recommendedCharts" && params.get("type").is_none() {
+            return self.open_dialog("recommendedCharts", json!({}));
+        }
+        // Switch Windows with no window named (key tip, command search) opens the View tab's
+        // list to choose from; programmatic callers of `run` get the list back.
+        if id == "view.switchWindows" && ["window", "doc"].iter().all(|k| params.get(*k).is_none_or(Json::is_null)) {
+            self.ui.ribbon_tab = "View".into();
+            self.ui.ribbon_collapsed = false;
+            self.open_switch_windows = true;
+            return;
+        }
+        match self.run(id, params) {
+            // A refused cell draft already shows its own message (with the rule's title).
+            Err(e) if self.message.as_ref().is_some_and(|(_, m)| *m == e) => {}
+            Err(e) => self.alert(e),
+            Ok(_) => {}
+        }
+    }
+
+    /// Shows a command error: a toast for an unavailable command, else a message box.
+    pub(super) fn alert(&mut self, e: String) {
+        // Shown in the window the user ends up in, also after a command that switched windows.
+        self.follow_active_window();
+        if e.contains("is not available right now") {
+            self.toast = Some((e, now_ms()));
+        } else {
+            self.message = Some(("GridCraft".into(), clean_error(&e)));
+        }
+    }
+
+    /// UI-only commands (dialogs, view toggles that aren't saved in the file).
+    fn run_ui_command(&mut self, id: &str, p: &Json) -> Option<Result<Json, String>> {
+        let r = match id {
+            "app.checkForUpdates" | "help.checkForUpdates" => {
+                self.check_for_updates();
+                Ok(Json::Null)
+            }
+            "ui.printSettings" => printing::settings(&mut self.printing, p, self.services.printers.as_ref()),
+            "ui.printSubmit" => self.submit_print(p.clone()),
+            "ui.ribbonTab" => {
+                self.ui.ribbon_tab = p.get("tab").and_then(Json::as_str).unwrap_or("Home").to_string();
+                Ok(Json::Null)
+            }
+            "view.collapseRibbon" => {
+                self.ui.ribbon_collapsed = !self.ui.ribbon_collapsed;
+                Ok(Json::Null)
+            }
+            "view.expandFormulaBar" => {
+                self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded);
+                Ok(json!({"on": self.ui.formula_bar_expanded}))
+            }
+            "view.darkMode" => {
+                let current = if self.ui.system_theme { self.effective_dark } else { self.ui.dark };
+                self.ui.dark = p.get("on").and_then(Json::as_bool).unwrap_or(!current);
+                self.ui.system_theme = false;
+                Ok(json!({"on": self.ui.dark}))
+            }
+            "view.theme" => {
+                match p.get("mode").and_then(Json::as_str) {
+                    Some("system") => self.ui.system_theme = true,
+                    Some(mode @ ("light" | "dark")) => {
+                        self.ui.dark = mode == "dark";
+                        self.ui.system_theme = false;
+                    }
+                    _ => return Some(Err("theme mode must be system, light, or dark".into())),
+                }
+                Ok(json!({"mode": self.ui.theme_mode()}))
+            }
+            "view.animations" => {
+                self.ui.animations = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.animations);
+                Ok(json!({"on": self.ui.animations}))
+            }
+            "options.autoComplete" => {
+                self.ui.autocomplete = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.autocomplete);
+                Ok(json!({"on": self.ui.autocomplete}))
+            }
+            "view.interfaceScale" => {
+                // `{"percent": 125}` or `{"percent": "auto"}`; out-of-range values are clamped.
+                let percent = match p.get("percent") {
+                    Some(Json::String(s)) if s.eq_ignore_ascii_case("auto") => Some(100),
+                    Some(v) => v.as_f64().and_then(clamp_interface_scale),
+                    None => None,
+                };
+                match percent {
+                    Some(v) => {
+                        self.ui.interface_scale = v;
+                        Ok(json!({"percent": v}))
+                    }
+                    None => Err(format!("missing `percent` ({INTERFACE_SCALE_MIN}–{INTERFACE_SCALE_MAX}, or \"auto\")")),
+                }
+            }
+            "app.language.set" => {
+                // `{"language": "ja"}`; `code` is accepted as an alias.
+                let code = p.get("language").or_else(|| p.get("code")).and_then(Json::as_str).unwrap_or("");
+                match i18n::Language::parse(code) {
+                    Some(l) => {
+                        self.ui.language = l;
+                        Ok(json!({"language": l}))
+                    }
+                    None => Err(format!("unknown language {code:?} (use one of {})", i18n::Language::code_list(", "))),
+                }
+            }
+            "app.language.english" => {
+                self.ui.language = i18n::Language::En;
+                Ok(json!({"language": i18n::Language::En}))
+            }
+            "app.language.japanese" => {
+                self.ui.language = i18n::Language::Ja;
+                Ok(json!({"language": i18n::Language::Ja}))
+            }
+            "ui.backstage" => {
+                // `{"page": "info"}` opens File › Info; `{"page": "close"}` returns to the sheet.
+                match p.get("page").and_then(Json::as_str).map(str::trim) {
+                    Some("close" | "none" | "") => self.backstage = None,
+                    Some(id) => match backstage::Page::parse(id) {
+                        Some(page) => self.open_backstage(page),
+                        None => {
+                            return Some(Err(format!(
+                                "unknown File page {id:?} (use home, new, open, info, saveAs, print, export, options or close)"
+                            )));
+                        }
+                    },
+                    None => self.open_backstage(backstage::Page::Home),
+                }
+                Ok(json!({"page": self.backstage.as_ref().map(|b| b.page.id())}))
+            }
+            "ui.dialog" => {
+                let name = p.get("name").and_then(Json::as_str).unwrap_or("");
+                self.open_dialog(name, p.clone());
+                Ok(json!({"dialog": self.dialog.as_ref().map(|d| d.name())}))
+            }
+            "ui.message.dismiss" => {
+                self.message = None;
+                Ok(Json::Null)
+            }
+            "ui.notice" => Ok(match &self.notice {
+                Some(n) => json!({
+                    "text": n.text,
+                    "kind": match n.kind { NoticeKind::Warning => "warning", NoticeKind::Info => "info" },
+                    "action": n.action,
+                }),
+                None => Json::Null,
+            }),
+            "ui.notice.dismiss" => {
+                self.notice = None;
+                Ok(Json::Null)
+            }
+            _ => return None,
+        };
+        Some(r)
+    }
+
+    /// Picks up requests commands made (dialogs, edit mode…).
+    pub fn after_engine(&mut self) {
+        // The requests belong to the window the command left active.
+        self.follow_active_window();
+        for req in self.session.take_ui_requests() {
+            match req {
+                UiRequest::Dialog(name, params) => self.open_dialog(&name, params),
+                UiRequest::Message(m) => self.message = Some(("GridCraft".into(), m)),
+                UiRequest::EditCell(text) => {
+                    let text = text.map(|text| {
+                        self.session
+                            .active()
+                            .map(|d| formula_locale::display_template(&text, self.ui.language.formula_locale(), &d.wb, d.wb.active_sheet()))
+                            .unwrap_or(text)
+                    });
+                    self.begin_edit(text, false);
+                }
+                UiRequest::InsertName(name) => dialogs::insert_name(self, &name),
+                UiRequest::OpenUrl(u) => {
+                    if let Some(f) = &self.services.open_url {
+                        f(&u);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Whether the active sheet of the active document is protected (drives the Protect/Unprotect
+    /// Sheet labels and actions).
+    pub fn active_sheet_protected(&self) -> bool {
+        self.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false)
+    }
+
+    pub fn open_dialog(&mut self, name: &str, params: Json) {
+        if let Err(e) = self.commit_text_box_edit() {
+            self.message = Some(("Text Box".into(), clean_error(&e)));
+            return;
+        }
+        // Every Protect Sheet entry point (ribbon menus, keytips, tab menu) becomes Unprotect Sheet
+        // on a protected sheet. A sheet without a password is unprotected straight away.
+        let name = if name == "protectSheet" && self.active_sheet_protected() { "unprotectSheet" } else { name };
+        if name == "unprotectSheet"
+            && self
+                .session
+                .active()
+                .and_then(|d| d.wb.active())
+                .and_then(|s| s.protection.as_ref())
+                .is_some_and(|p| p.password.is_none() && p.legacy_password_hash.is_none())
+        {
+            self.run_or_alert("review.unprotectSheet", json!({}));
+            return;
+        }
+        match name {
+            "open" => {
+                if let Some(start) = &self.services.open_async {
+                    start();
+                } else if let Some(pick) = &self.services.pick_open
+                    && let Some(path) = pick()
+                {
+                    self.open_path(&path);
+                }
+            }
+            "saveAs" => {
+                let suggested = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
+                if let Some(pick) = &self.services.pick_save {
+                    if let Some(path) = pick(&suggested) {
+                        let path = if std::path::Path::new(&path).extension().is_none() { format!("{path}.xlsx") } else { path };
+                        self.run_or_alert("file.save", json!({"path": path}));
+                    }
+                } else if self.services.download.is_some()
+                    && let Ok(r) = self.run("file.saveBytes", json!({"format": "xlsx"}))
+                    && let Some(dl) = &self.services.download
+                    && let Some(b) = r.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
+                {
+                    let name = r.get("name").and_then(Json::as_str).unwrap_or("Book.xlsx").to_string();
+                    dl(&name, &b);
+                }
+            }
+            // File › Options (`file.options`) and the File tab itself open the Backstage view.
+            "options" => self.open_backstage(backstage::Page::Options),
+            "backstage" => {
+                let page = params.get("page").and_then(Json::as_str).and_then(backstage::Page::parse).unwrap_or(backstage::Page::Home);
+                self.open_backstage(page);
+            }
+            other => self.dialog = dialogs::Dialog::open(self, other, params),
+        }
+    }
+
+    /// Opens the File tab's Backstage view on `page`, committing a cell still being edited first
+    /// (File actions work on the whole workbook). A draft that can't be committed keeps the sheet.
+    pub fn open_backstage(&mut self, page: backstage::Page) {
+        if !self.chrome.file_tab {
+            return;
+        }
+        if !self.commit_edit(0, 0, false, false) {
+            return;
+        }
+        match &mut self.backstage {
+            Some(b) => b.page = page,
+            None => self.backstage = Some(backstage::Backstage::new(page)),
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/editing.rs b/crates/ui-egui/src/app/editing.rs
new file mode 100644
index 000000000..c9c494fb1
--- /dev/null
+++ b/crates/ui-egui/src/app/editing.rs
@@ -0,0 +1,211 @@
+use super::*;
+
+impl SheetApp {
+    /// Starts editing the active cell. `text` replaces the content (typing) or pre-fills it.
+    pub fn begin_edit(&mut self, text: Option<String>, from_formula_bar: bool) {
+        // The source formula is display-only on spill children. Grid replacement keeps its
+        // existing behavior, but no formula-bar entry path may edit that displayed formula.
+        if from_formula_bar && formula_bar::active_spill_anchor(self).is_some() {
+            return;
+        }
+        if let Err(e) = self.commit_text_box_edit() {
+            self.message = Some(("Text Box".into(), clean_error(&e)));
+            return;
+        }
+        let Some(d) = self.session.active() else { return };
+        let Some(sh) = d.wb.active() else { return };
+        let at = sh.merge_at(d.selection.active).map(|m| m.start).unwrap_or(d.selection.active);
+        // A picture has no editable scalar text. Selecting it, F2, or clicking
+        // the formula bar must not turn its fallback value into a text edit.
+        // Typing still starts an intentional replacement.
+        if text.is_none() && sh.cell_pictures.contains_key(&at) {
+            return;
+        }
+        let locale = self.ui.language.formula_locale();
+        let current = if sh.cell_pictures.contains_key(&at) {
+            String::new()
+        } else {
+            match sh.cell(at) {
+                Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet()),
+                _ => gridcraft_engine::display::edit_text(&d.wb, sh, at),
+            }
+        };
+        let (text, replace) = match text {
+            Some(t) => (t, true),
+            None => (current.clone(), false),
+        };
+        let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet(), at, text, replace, from_formula_bar);
+        ed.window = self.session.active_window();
+        ed.locale = locale;
+        if replace && self.ui.autocomplete && !ed.is_formula() {
+            ed.completion = editor::column_completion(sh, at, &ed.text);
+        }
+        self.editor = Some(ed);
+        self.session.mode = if replace { gridcraft_engine::Mode::Enter } else { gridcraft_engine::Mode::Edit };
+    }
+
+    /// Commits the edit; `then` moves the selection (dr, dc) afterwards.
+    ///
+    /// The draft goes into the window and workbook it was typed in. If another window is
+    /// showing, that window stays active afterwards; a draft its own workbook refuses
+    /// (validation, a bad formula) brings its window back to the front with the draft still open.
+    pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
+        let Some((doc, window)) = self.editor.as_ref().map(|ed| (ed.doc, ed.window)) else { return true };
+        if !self.draft_elsewhere() {
+            return self.commit_edit_here(dr, dc, array, fill_selection);
+        }
+        // Its window, or (when that window closed) its workbook's most recent one.
+        let Some(owner) = window.filter(|w| self.session.window(*w).is_some()).or_else(|| self.session.doc_window(doc)) else {
+            self.cancel_edit();
+            return true;
+        };
+        let back = self.session.active_window();
+        self.session.activate_window(owner);
+        if !self.commit_edit_here(dr, dc, array, fill_selection) {
+            // Refused: its window stays in front with the draft open and the reason shown.
+            return false;
+        }
+        if let Some(back) = back {
+            self.session.activate_window(back);
+        }
+        true
+    }
+
+    /// The cell draft belongs to a window or workbook other than the one showing.
+    pub(super) fn draft_elsewhere(&self) -> bool {
+        self.editor.as_ref().is_some_and(|ed| {
+            self.session.active().map(|d| d.uid) != Some(ed.doc) || ed.window.is_some_and(|w| self.session.active_window() != Some(w))
+        })
+    }
+
+    /// Commits the cell and text-box drafts, as Enter would, before a command that can show
+    /// another workbook or write this one to a file, so a draft never lands in another workbook.
+    /// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
+    pub(crate) fn settle_drafts(&mut self) -> Result<(), String> {
+        if !self.commit_edit(0, 0, false, false) {
+            return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
+        }
+        self.commit_text_box_edit()
+    }
+
+    fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
+        let Some(ed) = self.editor.take() else { return true };
+        self.session.mode = gridcraft_engine::Mode::Ready;
+        let text = match &ed.completion {
+            Some(full) if full.to_lowercase().starts_with(&ed.text.to_lowercase()) => full.clone(),
+            _ => ed.text.clone(),
+        };
+        // F2 then Enter (or a file command) on an untouched draft: nothing to write.
+        if !fill_selection && !array && ed.original.as_ref() == Some(&text) {
+            if dr != 0 || dc != 0 {
+                self.move_after_enter(dr, dc);
+            }
+            return true;
+        }
+        let text = match self.session.active().map(|d| formula_locale::canonical(&text, ed.locale, &d.wb, ed.sheet, ed.cell)) {
+            Some(Ok(text)) => text,
+            Some(Err(error)) => {
+                self.message = Some(("GridCraft".into(), error.to_string()));
+                self.editor = Some(ed);
+                self.session.mode = gridcraft_engine::Mode::Edit;
+                return false;
+            }
+            None => text,
+        };
+        // Data validation.
+        if let Some(d) = self.session.active()
+            && let Some((dv, msg)) = gridcraft_engine::cmd::data::check_validation(&d.wb, ed.sheet, ed.cell, &text)
+        {
+            if dv.error_style == gridcraft_engine::model::ErrorStyle::Stop {
+                let title = if dv.error_title.is_empty() { "GridCraft".to_string() } else { dv.error_title.clone() };
+                self.message = Some((title, msg));
+                self.editor = Some(ed);
+                self.session.mode = gridcraft_engine::Mode::Edit;
+                return false;
+            }
+            self.toast = Some((msg, now_ms()));
+        }
+        // Point mode can leave another sheet active; the edit belongs to the sheet it started on.
+        if self.session.active().is_some_and(|d| d.wb.active_sheet() != ed.sheet)
+            && let Err(e) = self.session.run("sheet.activate", json!({"sheet": ed.sheet}))
+        {
+            self.message = Some(("GridCraft".into(), clean_error(&e)));
+            self.editor = Some(ed);
+            self.session.mode = gridcraft_engine::Mode::Edit;
+            return false;
+        }
+        // Committing nothing into an empty cell changes nothing: no undo step (#1855, Backspace has
+        // already cleared the cell as its own step).
+        let unchanged = !fill_selection
+            && !array
+            && text.is_empty()
+            && self
+                .session
+                .active()
+                .and_then(|d| d.wb.sheet(ed.sheet))
+                .is_some_and(|sh| sh.cell(ed.cell).is_none_or(|c| c.formula.is_none() && c.value == gridcraft_engine::core::Value::Empty));
+        let r = if unchanged {
+            Ok(json!({}))
+        } else if fill_selection {
+            self.session.run("range.fill", json!({"input": text}))
+        } else {
+            self.session.run("cell.set", json!({"cell": ed.cell.a1(), "input": text, "array": array}))
+        };
+        match r {
+            Ok(_) => {
+                if dr != 0 || dc != 0 {
+                    self.move_after_enter(dr, dc);
+                }
+                self.after_engine();
+                true
+            }
+            Err(e) => {
+                self.message = Some(("GridCraft".into(), clean_error(&e)));
+                self.editor = Some(ed);
+                self.session.mode = gridcraft_engine::Mode::Edit;
+                false
+            }
+        }
+    }
+
+    /// Commits the edit with an arrow key. The arrow is an ordinary move, so it ends a run of Tabs
+    /// instead of continuing it (Right) or going back to its column like Enter (Down), as in Excel.
+    pub fn commit_edit_arrow(&mut self, dr: i64, dc: i64) -> bool {
+        let run = self.tab_run.take();
+        let ok = self.commit_edit(dr, dc, false, false);
+        self.tab_run = if ok { None } else { run };
+        ok
+    }
+
+    pub fn cancel_edit(&mut self) {
+        self.editor = None;
+        self.session.mode = gridcraft_engine::Mode::Ready;
+    }
+
+    /// Enter/Tab move inside a multi-cell selection, otherwise to the next cell.
+    pub fn move_after_enter(&mut self, dr: i64, dc: i64) {
+        let multi = self.session.active().is_some_and(|d| !d.selection.is_single_cell());
+        // Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
+        // last Tab landed on, which ends the run.
+        let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
+        let run = self.tab_run.take().filter(|&(uid, sheet, _, at)| here == Some((uid, sheet, at)));
+        if multi {
+            let fwd = dr > 0 || dc > 0;
+            let _ = self.session.run("selection.next", json!({"forward": fwd, "byRow": dc != 0}));
+        } else if let (Some((_, _, col, at)), 1, 0) = (run, dr, dc) {
+            let back = i64::from(col) - i64::from(at.col);
+            let _ = self.session.run("selection.move", json!({"dr": 1, "dc": back}));
+        } else {
+            let _ = self.session.run("selection.move", json!({"dr": dr, "dc": dc}));
+            if dr == 0 && dc != 0 {
+                let start = run.map(|r| r.2);
+                self.tab_run = self.session.active().and_then(|d| {
+                    let (uid, sheet) = (d.uid, d.wb.active_sheet());
+                    let col = start.or(here.map(|h| h.2.col))?;
+                    Some((uid, sheet, col, d.selection.active))
+                });
+            }
+        }
+        self.grid.ensure_visible = true;
+    }
+}
diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs
new file mode 100644
index 000000000..4c7e20913
--- /dev/null
+++ b/crates/ui-egui/src/app/files.rs
@@ -0,0 +1,127 @@
+use super::*;
+
+impl SheetApp {
+    pub fn open_path(&mut self, path: &str) {
+        match self.run("file.open", json!({"path": path})) {
+            Ok(r) => self.after_open(Some(path), &r),
+            // A password-protected workbook: ask for the password; the dialog opens it.
+            Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => self.open_dialog("openPassword", json!({"path": path})),
+            Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
+        }
+        self.after_engine();
+    }
+
+    /// What follows a successful `file.open`: the workbook shows (not the Backstage), the Recent
+    /// list (for a file on disk) and the open warnings notice. Shared by File › Open, the
+    /// password dialog and the control channel.
+    pub fn after_open(&mut self, path: Option<&str>, r: &Json) {
+        self.backstage = None;
+        if let Some(path) = path {
+            self.ui.recent.retain(|p| p != path);
+            self.ui.recent.insert(0, path.to_string());
+            self.ui.recent.truncate(20);
+        }
+        self.show_open_warnings(r);
+    }
+
+    /// Turns the `warnings` a `file.open` result carries into an info-bar notice, choosing the
+    /// most important one (a preserved VBA project outranks, say, a skipped optional part).
+    /// Kept deliberately generic: any open-time warning can reach the user this way.
+    pub fn show_open_warnings(&mut self, r: &Json) {
+        // The opened workbook's window shows them, however it was opened (a script may have run
+        // `file.open` on the session directly).
+        self.follow_active_window();
+        let Some(list) = r.get("warnings").and_then(Json::as_array) else {
+            self.notice = None;
+            return;
+        };
+        let msgs: Vec<&str> = list.iter().filter_map(Json::as_str).collect();
+        if msgs.is_empty() {
+            // A clean open clears any notice left over from the previous document.
+            self.notice = None;
+            return;
+        }
+        let vba: Vec<&str> = msgs.iter().copied().filter(|m| m.to_lowercase().contains("macro") || m.contains("VBA")).collect();
+        if !vba.is_empty() {
+            // The reader says "dropped" when the VBA project was missing or unreadable; never promise to keep it then.
+            let dropped = vba.iter().any(|m| m.contains("dropped"));
+            let text = if dropped {
+                "This workbook's VBA macros could not be loaded and were dropped, so they will not be in the saved file. Keep the original file."
+            } else {
+                "This workbook contains VBA macros. GridCraft keeps them when you save as .xlsm, but does not run them."
+            };
+            self.notice = Some(Notice { text: text.into(), kind: NoticeKind::Warning, action: Some(("What this means".into(), "macros".into())) });
+        } else {
+            let text = if msgs.len() == 1 {
+                msgs[0].to_string()
+            } else {
+                format!("{} items in this file were handled differently. First: {}", msgs.len(), msgs[0])
+            };
+            self.notice = Some(Notice { text, kind: NoticeKind::Info, action: None });
+        }
+    }
+
+    /// The open windows in order, for the Switch Windows lists.
+    pub fn open_windows(&self) -> Vec<OpenWindow> {
+        let active = self.session.active_window();
+        self.session
+            .windows()
+            .iter()
+            .filter_map(|w| {
+                let d = self.session.documents().iter().find(|d| d.uid == w.doc_uid)?;
+                let title = self.session.window_title(w.id)?;
+                Some(OpenWindow { window: w.id, doc: d.uid, title, dirty: d.is_dirty(), active: active == Some(w.id) })
+            })
+            .collect()
+    }
+
+    /// Opens files that arrived asynchronously (web file picker, dropped files).
+    pub(super) fn poll_async_opens(&mut self) {
+        let arrived: Vec<(String, Vec<u8>)> = self
+            .services
+            .inbox
+            .as_ref()
+            .map(|i| std::mem::take(&mut *i.lock().unwrap_or_else(std::sync::PoisonError::into_inner)))
+            .unwrap_or_default();
+        for (name, bytes) in arrived {
+            let b64 = gridcraft_engine::io::base64_encode(&bytes);
+            match self.run("file.open", json!({"name": &name, "base64": &b64})) {
+                // A file picked from File › Open (web) arrives here: show it, not the Backstage.
+                Ok(r) => {
+                    self.backstage = None;
+                    self.show_open_warnings(&r);
+                }
+                Err(e) if e.contains(gridcraft_engine::io::PASSWORD_REQUIRED) => {
+                    self.backstage = None;
+                    self.open_dialog("openPassword", json!({"name": name, "base64": b64}));
+                }
+                Err(e) => self.message = Some(("GridCraft".into(), clean_error(&e))),
+            }
+            self.after_engine();
+        }
+    }
+
+    /// AutoSave: save workbooks that have a file shortly after they change. This decision lives in
+    /// `logic` so a hidden or logic-only frame still saves; the monotonic timestamp check keeps a
+    /// forced hidden UI pass from saving the same change twice.
+    pub(super) fn autosave(&mut self, ctx: &egui::Context) {
+        let dirty_xlsx = self.session.active().is_some_and(|d| d.is_dirty() && d.path.as_deref().is_some_and(|p| p.ends_with(".xlsx")));
+        let now = crate::monotonic_ms();
+        let autosave_due =
+            self.ui.autosave && self.editor.is_none() && self.text_box_editor.is_none() && now - self.grid.last_autosave > 2000.0 && dirty_xlsx;
+        if autosave_due {
+            self.grid.last_autosave = now;
+            self.store_view_state();
+            let _ = self.session.run("file.save", json!({}));
+        } else if self.ui.autosave && dirty_xlsx {
+            // Keep checking even when no input arrives while the window is hidden.
+            ctx.request_repaint_after(std::time::Duration::from_secs(2));
+        }
+    }
+
+    /// Flip AutoSave (title-bar switch / Options ▸ Save). Persisted with the other UI
+    /// preferences, so it stays as the user left it across restarts (#1901).
+    pub fn toggle_autosave(&mut self) {
+        self.ui.autosave = !self.ui.autosave;
+    }
+}
diff --git a/crates/ui-egui/src/app/fonts.rs b/crates/ui-egui/src/app/fonts.rs
new file mode 100644
index 000000000..32e072d93
--- /dev/null
+++ b/crates/ui-egui/src/app/fonts.rs
@@ -0,0 +1,112 @@
+use super::*;
+use crate::fonts;
+
+impl SheetApp {
+    /// Test-harness setup: mark a deterministic font set (see
+    /// [`theme::pinned_font_definitions`]) as already installed, so the first `logic` pass neither
+    /// starts the host font scan nor replaces the harness's pinned set. Production uses
+    /// [`Self::setup_context`] instead.
+    #[doc(hidden)]
+    pub fn use_prepared_fonts(&mut self) {
+        self.prepared_fonts = true;
+        self.fonts_ready = true;
+        self.fonts_set = true;
+        self.fonts_rebind = false;
+        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
+        self.fonts_bound = self.used_fonts();
+        self.fonts_seen = self.fonts_key();
+    }
+
+    /// The font names the open workbooks use: every style's font plus the theme's heading/body
+    /// fonts. These are the families [`fonts`] binds an installed file for. Every workbook's, as
+    /// each may be showing in a window of its own.
+    pub fn used_fonts(&self) -> Vec<String> {
+        let mut names: Vec<String> = Vec::new();
+        for d in self.session.documents() {
+            names.extend(d.wb.styles.iter().map(|(_, s)| s.font.name.clone()));
+            names.push(d.wb.theme.major_font.clone());
+            names.push(d.wb.theme.minor_font.clone());
+            // Text boxes and shapes name their own typefaces.
+            names.extend(d.wb.sheets.iter().flat_map(|sh| sh.shapes.iter().filter_map(|s| s.format.font.clone())));
+        }
+        names
+    }
+
+    /// The open workbooks' (uid, revision), folded: [`Self::used_fonts`] changes only with it.
+    fn fonts_key(&self) -> (u64, u64) {
+        self.session
+            .documents()
+            .iter()
+            .fold((0u64, 0u64), |(uid, rev), d| (uid.wrapping_mul(31).wrapping_add(d.uid), rev.wrapping_mul(31).wrapping_add(d.revision)))
+    }
+
+    /// Installs the text-width closure once, on the first frame.
+    pub(super) fn ensure_text_width(&mut self, ctx: &egui::Context) {
+        if self.session.text_width.is_some() {
+            return;
+        }
+        let ctx = ctx.clone();
+        self.session.text_width = Some(std::sync::Arc::new(move |text, font, exact| theme::cell_text_width(&ctx, text, font, exact)));
+    }
+
+    /// Applies the font gates: a language Han-order change, startup/prepared fonts and workbook
+    /// font binding. Every branch keeps its one-frame paint gate.
+    pub(super) fn apply_font_state(&mut self, ctx: &egui::Context) {
+        // A pending synthetic step owns the next real `ui` pass: `ui` returns at the font gate
+        // before it handles input, so a font change requested now would consume the step without
+        // applying it. Delay the change one frame; the hidden-paint request keeps it coming.
+        let defer_font_change = self.synthetic_pending || !self.synthetic.is_empty();
+        if !defer_font_change && self.fonts_han.is_some_and(|han| han != theme::HanOrder::of(self.ui.language)) {
+            self.fonts_ready = false;
+            self.fonts_set = false;
+        }
+        if !self.fonts_ready {
+            self.start_font_setup(ctx);
+        } else if self.fonts_rebind {
+            // A font-set change made last frame is active now.
+            self.fonts_rebind = false;
+        } else if !defer_font_change && !self.prepared_fonts && fonts::scan_done() {
+            self.rebind_workbook_fonts(ctx);
+        }
+    }
+
+    /// Applies the pending font set. New fonts apply from the next frame on: paint nothing until
+    /// then. Startup always proceeds: without it a queued step would be re-offered forever.
+    fn start_font_setup(&mut self, ctx: &egui::Context) {
+        if self.fonts_set {
+            self.fonts_ready = true;
+            return;
+        }
+        if self.prepared_fonts {
+            ctx.set_fonts(theme::pinned_font_definitions());
+            theme::apply(ctx, self.ui.dark);
+        } else {
+            SheetApp::setup_context_for_language(ctx, self.ui.dark, self.ui.language);
+        }
+        self.fonts_set = true;
+        // The rebuilt set has no workbook fonts yet: bind them again once it is active.
+        self.fonts_bound.clear();
+        self.fonts_seen = (0, 0);
+        self.fonts_han = Some(theme::HanOrder::of(self.ui.language));
+        ctx.request_repaint();
+    }
+
+    /// Binds the workbook's installed fonts once the background scan has finished. Adding fonts
+    /// re-applies the font set, which egui activates at the next pass, so skip this frame's paint
+    /// (same one-frame cost as startup). Only when an open workbook changed.
+    fn rebind_workbook_fonts(&mut self, ctx: &egui::Context) {
+        let seen = self.fonts_key();
+        if seen == self.fonts_seen {
+            return;
+        }
+        let used = self.used_fonts();
+        self.fonts_seen = seen;
+        if used == self.fonts_bound {
+            return;
+        }
+        ctx.set_fonts(theme::font_definitions_with(self.ui.language, &used));
+        self.fonts_bound = used;
+        self.fonts_rebind = true;
+        ctx.request_repaint();
+    }
+}
diff --git a/crates/ui-egui/src/app/input.rs b/crates/ui-egui/src/app/input.rs
new file mode 100644
index 000000000..fb8f31bfa
--- /dev/null
+++ b/crates/ui-egui/src/app/input.rs
@@ -0,0 +1,33 @@
+use super::*;
+
+impl SheetApp {
+    /// Records capture geometry from the fresh raw frame, then offers exactly one pending synthetic batch and tracks whether it was applied.
+    pub fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
+        // Capture geometry from this frame's real input before any synthetic event is added. This
+        // runs on every native frame, including hidden/minimized logic-only ticks, so a resize,
+        // DPI/zoom change, Wayland frame without `inner_rect`, or minimize/restore is recorded
+        // even though egui's last UI pass still describes the old layout.
+        let geometry = control::CaptureGeometry::from_raw_input(raw, ctx);
+        control::note_capture_geometry(self, geometry);
+        self.capture_geometry_from_raw = true;
+        // One unapplied gesture step at a time. eframe retains an unconsumed `RawInput` for the
+        // next pass and for a hidden logic-only tick, so the batch is offered once and survives
+        // until a `ui` pass applies it (which pops it). Press and release stay distinct batches.
+        //
+        // A completed egui pass may have consumed the injected events without applying them: the
+        // font gate returns before input handling, but `begin_pass` has already taken the events.
+        // `cumulative_pass_nr` only advances when a pass ends, so a newer value with the batch
+        // still pending means exactly that, and the step is offered again for the next real pass.
+        if self.synthetic_pending {
+            let consumed_by_an_unapplied_pass = self.synthetic_injected_at_pass.is_some_and(|pass| ctx.cumulative_pass_nr() > pass);
+            if !consumed_by_an_unapplied_pass {
+                return;
+            }
+        }
+        if let Some(batch) = self.synthetic.front() {
+            raw.events.extend(batch.iter().cloned());
+            self.synthetic_pending = true;
+            self.synthetic_injected_at_pass = Some(ctx.cumulative_pass_nr());
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/keys.rs b/crates/ui-egui/src/app/keys.rs
new file mode 100644
index 000000000..913cdbeb6
--- /dev/null
+++ b/crates/ui-egui/src/app/keys.rs
@@ -0,0 +1,66 @@
+use super::*;
+
+impl SheetApp {
+    pub(super) fn ribbon_keys(&mut self, ctx: &egui::Context) {
+        let before = self.keytips.prefix().map(str::to_string);
+        let enabled = self.editor.is_none()
+            && self.dialog.is_none()
+            && self.message.is_none()
+            && self.name_box.is_none()
+            && !ctx.text_edit_focused()
+            && self.grid.context_menu.is_none()
+            && self.grid.object_menu.is_none()
+            && self.grid.header_menu.is_none()
+            && self.grid.fill_menu.is_none()
+            && self.grid.filter_menu.is_none()
+            && self.grid.list_picker.is_none()
+            && self.grid.renaming_tab.is_none()
+            && (before.is_some() || !egui::Popup::is_any_open(ctx));
+        let actions = self.keytips.process(ctx, enabled);
+        // Backing out of F to the tab letters, or finishing an F sequence, closes the File view
+        // that Alt, F opened: the command runs on the sheet, as it did without the view.
+        if self.backstage.is_some() && before.is_some() && (self.keytips.prefix() == Some("") || !actions.is_empty()) {
+            self.backstage = None;
+        }
+        if before.is_some() && before.as_deref() != self.keytips.prefix() && !ctx.input(|i| i.pointer.any_pressed()) {
+            // Leave pointer cancellation to the popup so clicking a menu item still works.
+            egui::Popup::close_all(ctx);
+        }
+        for action in actions {
+            match action {
+                keytips::Action::Tab("File") => self.open_backstage(backstage::Page::Home),
+                keytips::Action::Tab(tab) => {
+                    self.run_or_alert("ui.ribbonTab", json!({"tab": tab}));
+                    self.ui.ribbon_collapsed = false;
+                }
+                keytips::Action::Command(id @ ("edit.copy" | "edit.cut")) => self.copy_to_clipboard(ctx, id),
+                keytips::Action::Command("edit.paste") => self.paste_from_clipboard(),
+                keytips::Action::Command(id) => self.run_or_alert(id, json!({})),
+                keytips::Action::CommandWith(id, params) => {
+                    let params: Json = serde_json::from_str(params).unwrap_or_else(|_| json!({}));
+                    // A Borders preset picked by key tip becomes the split button's face, as a
+                    // click on the same menu item does.
+                    if id == "home.borders"
+                        && let Some(preset) = params.get("preset").and_then(Json::as_str)
+                    {
+                        self.grid.last_border = preset.to_string();
+                    }
+                    self.run_or_alert(id, params);
+                }
+                keytips::Action::Dialog(name) => self.open_dialog(name, json!({})),
+                keytips::Action::DialogWith(name, params) => self.open_dialog(name, serde_json::from_str(params).unwrap_or_else(|_| json!({}))),
+                // Reserved sequence: fires silently while its command is missing. When the
+                // command lands in the catalog it goes live with no table edit.
+                keytips::Action::Pending(id) => {
+                    if gridcraft_engine::find_command(id).is_some() {
+                        self.run_or_alert(id, json!({}));
+                    }
+                }
+                // Route to the ribbon control that owns this keytip: it opens its dropdown or
+                // runs its click handler with the right params (the engine command alone would
+                // be missing them).
+                keytips::Action::Control(id) => self.ui.keytip_invoke = Some(id),
+            }
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/prefs.rs b/crates/ui-egui/src/app/prefs.rs
new file mode 100644
index 000000000..bd80b36e3
--- /dev/null
+++ b/crates/ui-egui/src/app/prefs.rs
@@ -0,0 +1,65 @@
+use super::*;
+
+impl SheetApp {
+    /// Runs a command and shows its error in a message box (for menu/ribbon clicks).
+    /// Follow the desktop's light/dark choice while the app runs (Linux; the desktop app calls
+    /// this once — tests and embedders don't start the watcher thread).
+    pub fn watch_desktop_theme(&mut self) {
+        self.desktop_theme = desktop_theme::DesktopTheme::start();
+    }
+
+    /// Follows the desktop/system theme preference and records the effective theme.
+    pub(super) fn sync_theme_preference(&mut self, ctx: &egui::Context) {
+        let preference = match (
+            self.ui.system_theme,
+            ctx.system_theme().or_else(|| self.desktop_dark.map(|d| if d { egui::Theme::Dark } else { egui::Theme::Light })),
+        ) {
+            (true, Some(egui::Theme::Dark)) => egui::ThemePreference::Dark,
+            (true, Some(egui::Theme::Light)) => egui::ThemePreference::Light,
+            _ => self.ui.theme_preference(),
+        };
+        if ctx.options(|o| o.theme_preference) != preference {
+            ctx.set_theme(preference);
+            ctx.request_repaint();
+        }
+        self.effective_dark = ctx.theme() == egui::Theme::Dark;
+    }
+
+    /// Keeps egui's own keyboard zoom and quit shortcuts off and applies GridCraft's zoom factor.
+    pub(super) fn sync_input_options(&mut self, ctx: &egui::Context) {
+        // Interface size: the preference owns the zoom factor, so egui's own Ctrl/Cmd +/-/0 zoom
+        // keys stay off (they would also swallow GridCraft's shortcuts).
+        if ctx.options(|o| o.zoom_with_keyboard) {
+            ctx.options_mut(|o| o.zoom_with_keyboard = false);
+        }
+        // egui closes the window on Ctrl+Q (and with Shift or Alt held too) without asking to save
+        // (#1443). Excel for Windows has no such key (Ctrl+Q is Quick Analysis). With a native
+        // window per workbook egui's Cmd+Q would close only the window it was typed in: the menu
+        // bar's Quit item has the key instead (it asks about unsaved workbooks first).
+        if (ctx.os() != egui::os::OperatingSystem::Mac || self.native_windows) && ctx.options(|o| !o.quit_shortcuts.is_empty()) {
+            ctx.options_mut(|o| o.quit_shortcuts.clear());
+        }
+        let zoom = self.ui.zoom_factor();
+        if (ctx.zoom_factor() - zoom).abs() > 0.001 {
+            ctx.set_zoom_factor(zoom);
+            ctx.request_repaint();
+        }
+    }
+
+    /// Look for a newer release once, in the background, as the desktop app starts (a no-op on the
+    /// web). A found release opens the update prompt; nothing is shown when GridCraft is current.
+    pub fn start_update_check(&mut self) {
+        #[cfg(not(target_arch = "wasm32"))]
+        updates_ui::start(self, false);
+    }
+
+    /// Help ▸ Check for Updates…: look now, and say so when GridCraft is up to date or the check fails.
+    pub fn check_for_updates(&mut self) {
+        #[cfg(not(target_arch = "wasm32"))]
+        updates_ui::start(self, true);
+        #[cfg(target_arch = "wasm32")]
+        {
+            self.message = Some(("GridCraft".into(), "The web version is always the latest release.".into()));
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/print.rs b/crates/ui-egui/src/app/print.rs
new file mode 100644
index 000000000..7c683f4ba
--- /dev/null
+++ b/crates/ui-egui/src/app/print.rs
@@ -0,0 +1,89 @@
+use super::*;
+
+impl SheetApp {
+    /// Web: `file.exportPdf` without a path returns the PDF as base64; hand it to the browser as a download.
+    pub(super) fn deliver_pdf(&self, result: &Json) {
+        if result.get("path").is_some() {
+            return;
+        }
+        if let Some(dl) = &self.services.download
+            && let Some(b) = result.get("base64").and_then(Json::as_str).and_then(gridcraft_engine::io::base64_decode)
+        {
+            let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
+            dl(&std::path::Path::new(&title).with_extension("pdf").to_string_lossy(), &b);
+        }
+    }
+
+    /// Asks for a `.pdf` path with the save picker, then re-runs `file.exportPdf` with it. Other
+    /// params (range, sheets, fitToPage) are kept. A cancelled picker does nothing.
+    pub(super) fn export_pdf_with_picker(&mut self, mut params: Json) {
+        if !self.commit_edit(0, 0, false, false) {
+            return;
+        }
+        let title = self.session.active().map(|d| d.display_title()).unwrap_or_else(|| "Book1".into());
+        let stem = std::path::Path::new(&title).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Book1").to_string();
+        let Some(pick) = &self.services.pick_save else { return };
+        let Some(path) = pick(&format!("{stem}.pdf")) else { return };
+        // The picker may suggest a workbook extension; the export writes a PDF.
+        let path = std::path::Path::new(&path).with_extension("pdf").to_string_lossy().into_owned();
+        match &mut params {
+            Json::Object(map) => {
+                map.insert("path".into(), Json::String(path));
+            }
+            other => *other = json!({"path": path}),
+        }
+        if let Err(e) = self.run("file.exportPdf", params) {
+            self.alert(e);
+        }
+    }
+
+    /// Builds the selected sheets' print-ready PDF and hands it to the desktop worker or the
+    /// browser. Rendering errors use the usual alert; asynchronous spooler errors stay visible
+    /// on the Print page. The engine command still returns PDF bytes without submitting.
+    pub fn print_now(&mut self, params: Json) {
+        if let Err(error) = self.submit_print(params) {
+            self.alert(error);
+        }
+    }
+
+    pub(super) fn submit_print(&mut self, params: Json) -> Result<Json, String> {
+        if self.services.print_native.is_some() && !self.printing.ready() {
+            return Err("Select an available printer in File > Print before submitting.".into());
+        }
+        let pdf = self.run("file.print", params)?;
+        let encoded = pdf.get("base64").and_then(Json::as_str).ok_or("The print command did not produce a PDF.")?;
+        let bytes = gridcraft_engine::io::base64_decode(encoded).ok_or("Couldn't decode the generated PDF.")?;
+        let len = bytes.len();
+        if let Some(submit) = &self.services.print_native {
+            self.printing.begin(submit(bytes, self.printing.settings.clone())).map_err(|_| "A print job is already being submitted.".to_owned())?;
+            self.print_feedback_seen = None;
+        } else if let Some(print) = &self.services.print {
+            print(&bytes);
+        } else {
+            return Err("Printing is unavailable here; export a PDF instead.".into());
+        }
+        Ok(json!({"printing": true, "bytes": len, "pending": self.services.print_native.is_some()}))
+    }
+
+    /// Terminal feedback also reaches the normal window when printing starts through control.
+    /// Polls printing feedback. Called once per frame from [`Self::logic`]; the direct calls in
+    /// `tests/native_print.rs` deliberately bypass the lifecycle to test this helper alone.
+    pub fn poll_printing(&mut self, ctx: &egui::Context) {
+        self.printing.poll(ctx);
+        if self.printing.message == self.print_feedback_seen {
+            return;
+        }
+        self.print_feedback_seen = self.printing.message.clone();
+        let Some(message @ (printing::Feedback::Submitted(_) | printing::Feedback::Failed(_) | printing::Feedback::WorkerStopped)) =
+            self.printing.message.clone()
+        else {
+            return;
+        };
+        let text = printing::feedback(&message, self.ui.language, |label| self.ui.language.tr(label).to_owned());
+        if matches!(message, printing::Feedback::Submitted(_)) {
+            self.toast = Some((text, now_ms()));
+        } else {
+            self.alert(text);
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/quit.rs b/crates/ui-egui/src/app/quit.rs
new file mode 100644
index 000000000..e70928eee
--- /dev/null
+++ b/crates/ui-egui/src/app/quit.rs
@@ -0,0 +1,96 @@
+use super::*;
+
+impl SheetApp {
+    /// Holds back a window close (the close button, Alt+F4, the OS quitting the app) while a
+    /// workbook has unsaved changes, and asks about them first.
+    pub(super) fn guard_window_close(&mut self, ctx: &egui::Context) {
+        if self.native_windows || self.allow_close || !ctx.input(|i| i.viewport().close_requested()) {
+            return;
+        }
+        // A cell still being edited is part of the workbook, as for File › Close.
+        if !self.commit_edit(0, 0, false, false) {
+            ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
+            return;
+        }
+        if !self.session.documents().iter().any(|d| d.is_dirty()) {
+            return;
+        }
+        ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
+        match self.dialog.as_mut() {
+            // Already asking about a workbook (File › Close): answering it now goes on to quit.
+            Some(d) if d.name() == "saveChanges" => {
+                d.values.insert("quit".into(), json!(true));
+            }
+            _ => self.continue_quit(ctx),
+        }
+    }
+
+    /// Asks about the next unsaved workbook before quitting, in its window, or closes the app
+    /// once none is left.
+    pub(crate) fn continue_quit(&mut self, ctx: &egui::Context) {
+        let dirty = self.session.documents().iter().find(|d| d.is_dirty()).map(|d| d.uid);
+        match dirty.and_then(|uid| self.session.doc_window(uid)) {
+            Some(window) => {
+                // Its window comes forward (the native window too: see `doc_windows`).
+                self.enter_window(window);
+                let title = self.session.active().map(|d| d.display_title()).unwrap_or_default();
+                self.open_dialog("saveChanges", json!({"title": title, "quit": true}));
+            }
+            None => {
+                self.allow_close = true;
+                ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Close);
+            }
+        }
+    }
+
+    /// Answers the Save Changes question about the active workbook (its buttons). While quitting,
+    /// the next unsaved workbook is asked about once this one is answered; Cancel stops the quit.
+    /// Returns whether the question is settled: Save keeps it open when the cell being edited
+    /// can't be entered.
+    pub fn answer_save_changes(&mut self, answer: SaveAnswer, quitting: bool, ctx: &egui::Context) -> bool {
+        match answer {
+            SaveAnswer::Cancel => {}
+            SaveAnswer::DontSave => {
+                self.run_or_alert("file.close", json!({"force": true, "document": true}));
+                if quitting {
+                    self.continue_quit(ctx);
+                }
+            }
+            SaveAnswer::Save => {
+                // File operations include the cell still being edited, as File › Save does.
+                if !self.commit_edit(0, 0, false, false) {
+                    return false;
+                }
+                self.run_or_alert("file.save", json!({}));
+                if self.session.active().is_some_and(|x| !x.is_dirty()) {
+                    self.run_or_alert("file.close", json!({"force": true, "document": true}));
+                    if quitting {
+                        self.continue_quit(ctx);
+                    }
+                }
+            }
+        }
+        true
+    }
+
+    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, then asks
+    /// about each unsaved workbook in its window; Cancel on any of them stops the quit. A draft its
+    /// workbook refuses stops the quit too, with its window in front and the reason shown.
+    pub fn request_quit(&mut self, ctx: &egui::Context) {
+        while let Some(window) = self.parked_window_with_draft() {
+            self.enter_window(window);
+            if self.settle_drafts().is_err() {
+                return;
+            }
+        }
+        if self.settle_drafts().is_err() {
+            return;
+        }
+        if let Some(d) = self.dialog.as_mut().filter(|d| d.name() == "saveChanges") {
+            // Already asking about a workbook (File › Close): answering it goes on to quit.
+            d.values.insert("quit".into(), json!(true));
+            return;
+        }
+        self.continue_quit(ctx);
+    }
+}
diff --git a/crates/ui-egui/src/app/view.rs b/crates/ui-egui/src/app/view.rs
new file mode 100644
index 000000000..c74cf15f0
--- /dev/null
+++ b/crates/ui-egui/src/app/view.rs
@@ -0,0 +1,56 @@
+use super::*;
+
+impl SheetApp {
+    /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
+    pub fn view_key(&self) -> Option<(u64, usize)> {
+        self.session.active().map(|d| (d.uid, d.wb.active_sheet()))
+    }
+
+    /// The active window and sheet: each window scrolls on its own.
+    fn scroll_key(&self) -> Option<(u64, usize)> {
+        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet()))
+    }
+
+    pub fn view(&self) -> SheetView {
+        self.scroll_key().and_then(|k| self.views.get(&k).copied()).unwrap_or_else(|| self.saved_view())
+    }
+
+    pub fn view_mut(&mut self) -> Option<&mut SheetView> {
+        let k = self.scroll_key()?;
+        let saved = self.saved_view();
+        Some(self.views.entry(k).or_insert(saved))
+    }
+
+    /// The view a sheet opens with: scrolled to the file's saved first visible cell (`topLeftCell`).
+    fn saved_view(&self) -> SheetView {
+        let Some(sh) = self.session.active().and_then(|d| d.wb.active()) else { return SheetView::default() };
+        if sh.view != gridcraft_engine::model::SheetViewMode::Normal {
+            return SheetView::default();
+        }
+        let (fr, fc) = sh.freeze.unwrap_or((0, 0));
+        let top = sh.view_top_left;
+        let y = sh.row_top(top.row.max(fr)) - sh.row_top(fr);
+        let x = sh.col_left(top.col.max(fc)) - sh.col_left(fc);
+        SheetView { scroll: egui::vec2(x.max(0.0) as f32, y.max(0.0) as f32) }
+    }
+
+    /// Hands the active document's scroll positions (first visible cell per sheet) and active
+    /// cell to the engine so a save writes them (`sheetView topLeftCell`). Normal view only:
+    /// Page Layout view scrolls over pages, not cells.
+    pub fn store_view_state(&mut self) {
+        let window = self.session.active_window();
+        let Some(d) = self.session.active_mut() else { return };
+        let mut tops = Vec::new();
+        for (&(w, si), v) in &self.views {
+            let Some(sh) = d.wb.sheets.get(si).filter(|sh| Some(w) == window && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
+                continue;
+            };
+            let (fr, fc) = sh.freeze.unwrap_or((0, 0));
+            // A hair past the edge so a row that starts exactly at the scroll offset is the one found.
+            let row = sh.row_at(sh.row_top(fr) + v.scroll.y.max(0.0) as f64 + 0.01);
+            let col = sh.col_at(sh.col_left(fc) + v.scroll.x.max(0.0) as f64 + 0.01);
+            tops.push((si, CellRef::new(row, col)));
+        }
+        d.store_view(&tops);
+    }
+}

From 4425fed53f1e54dde045365878cb79e57f856b92 Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Tue, 27 Oct 2026 15:12:20 +0100
Subject: [PATCH 74/76] Add an XLSX write benchmark example

`cargo run --release -p gridcraft-xlsx --example write_perf -- [rows] [runs] [out.xlsx]`
builds a sales-style workbook (order ids, dates, categories, numbers, two
formula columns with cached values, booleans, sparse notes, a summary sheet)
and times write_xlsx, printing each run and the median / minimum. An optional
output path keeps the last package for byte comparisons between builds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/xlsx/examples/write_perf.rs | 89 ++++++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 crates/xlsx/examples/write_perf.rs

diff --git a/crates/xlsx/examples/write_perf.rs b/crates/xlsx/examples/write_perf.rs
new file mode 100644
index 000000000..37f80cf6c
--- /dev/null
+++ b/crates/xlsx/examples/write_perf.rs
@@ -0,0 +1,89 @@
+//! XLSX save timing on a generated workbook of realistic shape (release build):
+//! `cargo run --release -p gridcraft-xlsx --example write_perf -- [rows] [runs] [out.xlsx]`
+//!
+//! The workbook mixes what a large business sheet holds: repeated and unique text, integers,
+//! decimals, dates, booleans, formulas with cached values, a few styles, a header row and a
+//! second summary sheet. Prints each run and the median / minimum of `write_xlsx`.
+#![allow(clippy::disallowed_methods)] // a native-only benchmark: wasm never runs it
+
+use std::time::Instant;
+
+use gridcraft_core::{CellRef, Value};
+use gridcraft_model::{Cell, Formula, NumFmt, Sheet, StyleId, Workbook};
+
+fn build(rows: u32) -> Workbook {
+    let mut wb = Workbook::new();
+    let bold = wb.styles.derive(StyleId::DEFAULT, |s| s.font.bold = true);
+    let money = wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("#,##0.00"));
+    let date = wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("yyyy-mm-dd"));
+    let pct = wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("0.0%"));
+    let regions = ["North", "South", "East", "West", "Central"];
+    let products = ["Widget", "Gadget", "Gizmo", "Doohickey", "Sprocket", "Thingamajig", "Whatsit"];
+    let mut s = Sheet::new("Sales");
+    let set = |s: &mut Sheet, row: u32, col: u32, value: Value, style: StyleId| {
+        s.cells.set(CellRef::new(row, col), Cell { value, formula: None, style });
+    };
+    for (col, title) in ["Order", "Date", "Region", "Product", "Units", "Price", "Revenue", "Share", "Paid", "Note"].iter().enumerate() {
+        set(&mut s, 0, col as u32, Value::text(*title), bold);
+    }
+    for r in 1..=rows {
+        let i = r as usize;
+        set(&mut s, r, 0, Value::text(format!("ORD-{:07}", r)), StyleId::DEFAULT);
+        set(&mut s, r, 1, Value::Number(45000.0 + (i % 730) as f64), date);
+        set(&mut s, r, 2, Value::text(regions[i % regions.len()]), StyleId::DEFAULT);
+        set(&mut s, r, 3, Value::text(products[i % products.len()]), StyleId::DEFAULT);
+        let units = (i * 7 % 250 + 1) as f64;
+        let price = ((i * 37 % 10_000) as f64) / 100.0 + 0.99;
+        set(&mut s, r, 4, Value::Number(units), StyleId::DEFAULT);
+        set(&mut s, r, 5, Value::Number(price), money);
+        let mut rev = Cell::formula(Formula::new(&format!("=E{0}*F{0}", r + 1)));
+        rev.value = Value::Number(units * price);
+        rev.style = money;
+        s.cells.set(CellRef::new(r, 6), rev);
+        let mut share = Cell::formula(Formula::new(&format!("=G{}/Summary!$B$1", r + 1)));
+        share.value = Value::Number(units * price / 1.0e7);
+        share.style = pct;
+        s.cells.set(CellRef::new(r, 7), share);
+        set(&mut s, r, 8, Value::Bool(!i.is_multiple_of(3)), StyleId::DEFAULT);
+        if i.is_multiple_of(10) {
+            set(&mut s, r, 9, Value::text(format!("Follow up with customer #{} & check <terms>", i % 977)), StyleId::DEFAULT);
+        }
+    }
+    let mut summary = Sheet::new("Summary");
+    let mut total = Cell::formula(Formula::new(&format!("=SUM(Sales!G2:G{})", rows + 1)));
+    total.value = Value::Number(1.0e7);
+    summary.cells.set(CellRef::new(0, 1), total);
+    summary.cells.set(CellRef::new(0, 0), Cell { value: Value::text("Total"), formula: None, style: bold });
+    for (k, region) in regions.iter().enumerate() {
+        let row = k as u32 + 2;
+        summary.cells.set(CellRef::new(row, 0), Cell { value: Value::text(*region), formula: None, style: StyleId::DEFAULT });
+        let mut f = Cell::formula(Formula::new(&format!("=SUMIFS(Sales!G:G,Sales!C:C,A{})", row + 1)));
+        f.value = Value::Number(2.0e6);
+        f.style = money;
+        summary.cells.set(CellRef::new(row, 1), f);
+    }
+    wb.sheets = vec![std::sync::Arc::new(s), std::sync::Arc::new(summary)];
+    wb
+}
+
+fn main() {
+    let mut args = std::env::args().skip(1);
+    let rows: u32 = args.next().and_then(|s| s.parse().ok()).unwrap_or(200_000);
+    let runs: usize = args.next().and_then(|s| s.parse().ok()).unwrap_or(7).max(1);
+    let out = args.next();
+    let wb = build(rows);
+    let mut times = vec![];
+    let mut bytes = vec![];
+    for i in 0..runs {
+        let t = Instant::now();
+        bytes = gridcraft_xlsx::write_xlsx(&wb).expect("write");
+        let dt = t.elapsed().as_secs_f64() * 1000.0;
+        println!("run {i}: {dt:.1} ms ({} bytes)", bytes.len());
+        times.push(dt);
+    }
+    times.sort_by(f64::total_cmp);
+    println!("write_xlsx {rows} rows: median {:.1} ms, min {:.1} ms", times[times.len() / 2], times[0]);
+    if let Some(path) = out {
+        std::fs::write(&path, &bytes).expect("write output");
+    }
+}

From 63038650549064d7238c64a7f1101a1de87a12db Mon Sep 17 00:00:00 2001
From: aiongg <67543387+aiongg@users.noreply.github.com>
Date: Tue, 27 Oct 2026 10:26:30 -0400
Subject: [PATCH 75/76] fix(ui): dropdown menus grow back after a search with
 no matches (#2743)

* fix(ui-egui): dropdown menus regrow while open

Use craft_ui's ComboBox and combo::Menu so a menu that shrank (a filter with
no matches) grows back when the filter is cleared (egui#5225). Repin
craft-libs to one revision.

* chore(deps): craft-libs 60d60d48 (dropdown fixes)

* chore(deps): craft-libs 6af63481 (dropdown fixes)

* chore(deps): craft-libs 4d7b82f7 (dropdown fixes)

* chore(deps): craft-libs 92d392cf (#387 merged)
---
 Cargo.lock                                 |  12 +-
 Cargo.toml                                 |   4 +-
 apps/gridcraft/Cargo.toml                  |   2 +-
 clippy.toml                                |   4 +
 crates/ui-egui/Cargo.toml                  |   2 +-
 crates/ui-egui/src/backstage.rs            |   2 +-
 crates/ui-egui/src/backstage/options.rs    |   4 +-
 crates/ui-egui/src/backstage/print.rs      |   2 +-
 crates/ui-egui/src/credits.rs              |   2 +-
 crates/ui-egui/src/dialogs/analysis.rs     |   4 +-
 crates/ui-egui/src/dialogs/data.rs         |   4 +-
 crates/ui-egui/src/dialogs/format_cells.rs |   2 +-
 crates/ui-egui/src/dialogs/show.rs         |   2 +-
 crates/ui-egui/src/pivot_pane.rs           |   2 +-
 crates/ui-egui/src/ribbon/controls.rs      | 203 ++++++++++++---------
 crates/ui-egui/src/ribbon/view.rs          |   6 +-
 crates/ui-egui/tests/it/font_box_filter.rs |  71 +++++++
 crates/ui-egui/tests/it/main.rs            |   1 +
 18 files changed, 217 insertions(+), 112 deletions(-)
 create mode 100644 crates/ui-egui/tests/it/font_box_filter.rs

diff --git a/Cargo.lock b/Cargo.lock
index 53b2326da..247d8afe2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -889,12 +889,12 @@ dependencies = [
 [[package]]
 name = "craft-fonts-build"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 
 [[package]]
 name = "craft-i18n"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "fixed_decimal",
  "icu_decimal",
@@ -917,7 +917,7 @@ dependencies = [
 [[package]]
 name = "craft-print"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "craft-winprint-gdi",
  "miniz_oxide 0.9.1",
@@ -930,7 +930,7 @@ dependencies = [
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "craft-fonts-build",
  "craft-i18n",
@@ -950,7 +950,7 @@ dependencies = [
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "chrono",
  "dunce",
@@ -975,7 +975,7 @@ dependencies = [
 [[package]]
 name = "craft-window"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=b926b5c03e256c86ca10934f58d03f628810b5b7#b926b5c03e256c86ca10934f58d03f628810b5b7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "egui",
  "objc2 0.6.5",
diff --git a/Cargo.toml b/Cargo.toml
index e23c106e6..32823c84a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ gridcraft-mcp = { path = "crates/mcp" }
 gridcraft-pdf = { path = "crates/pdf" }
 # Every craft-libs crate (craft-update and craft-window here, craft-ui in ui-egui, craft-print in
 # the app) comes from one storytold/craft-libs revision.
-craft-update = { git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7", version = "=0.1.0", features = ["egui"] }
+craft-update = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.1.0", features = ["egui"] }
 
 # foundation
 thiserror = "2"
@@ -61,7 +61,7 @@ skrifa = { version = "0.44", default-features = false, features = ["std"] }
 epaint_default_fonts = "0.37"
 # One native window per workbook: the window list, Window menu titles and the immediate-viewport
 # driver. Same craft-libs revision as craft-update above.
-craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7", default-features = false, features = ["egui"] }
+craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", default-features = false, features = ["egui"] }
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
diff --git a/apps/gridcraft/Cargo.toml b/apps/gridcraft/Cargo.toml
index 8429070b7..2ec400cd6 100644
--- a/apps/gridcraft/Cargo.toml
+++ b/apps/gridcraft/Cargo.toml
@@ -30,7 +30,7 @@ winit = { version = "0.30", default-features = false, features = ["x11"] }
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Same craft-libs revision as the workspace's craft-update and craft-window (see the root
 # Cargo.toml).
-craft-print = { git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7" }
+craft-print = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
 craft-update = { workspace = true }
 rfd = { workspace = true }
 arboard = { workspace = true }
diff --git a/clippy.toml b/clippy.toml
index 8b8bc5a3a..de0f11db4 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -10,3 +10,7 @@ disallowed-methods = [
     { path = "std::time::Instant::now", reason = "traps on wasm; read the clock only off wasm" },
     { path = "std::time::SystemTime::now", reason = "traps on wasm; read the clock only off wasm" },
 ]
+
+disallowed-types = [
+    { path = "egui::ComboBox", reason = "use craft_ui::ComboBox: egui's combo box menu can't grow back while open (egui#5225)" },
+]
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index ac1a67c33..762663c5c 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -11,7 +11,7 @@ workspace = true
 [dependencies]
 # The shared capture slot (`craft_ui::capture`) comes from the one craft-libs revision every
 # craft-libs dependency uses (see the root Cargo.toml).
-craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "b926b5c03e256c86ca10934f58d03f628810b5b7" }
+craft-ui = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
 gridcraft-engine = { workspace = true }
 gridcraft-chart = { workspace = true }
 # `monochrome_emoji_fonts` restores the Noto Emoji and emoji-icon faces that 0.37 moved behind
diff --git a/crates/ui-egui/src/backstage.rs b/crates/ui-egui/src/backstage.rs
index 3f8706dec..6310dd6a0 100644
--- a/crates/ui-egui/src/backstage.rs
+++ b/crates/ui-egui/src/backstage.rs
@@ -677,7 +677,7 @@ fn save_as(app: &mut SheetApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcom
     let current = SAVE_TYPES.iter().find(|(ext, _)| *ext == fmt).map_or("Excel Workbook (*.xlsx)", |(_, label)| *label);
     ui.horizontal(|ui| {
         let label = ui.label(lang.tr("Save as type"));
-        egui::ComboBox::from_id_salt("backstage_save_type")
+        craft_ui::ComboBox::from_id_salt("backstage_save_type")
             .width(280.0)
             .selected_text(lang.tr(current))
             .show_ui(ui, |ui| {
diff --git a/crates/ui-egui/src/backstage/options.rs b/crates/ui-egui/src/backstage/options.rs
index 5a772e093..f40bc9cc5 100644
--- a/crates/ui-egui/src/backstage/options.rs
+++ b/crates/ui-egui/src/backstage/options.rs
@@ -45,7 +45,7 @@ fn general_options(app: &mut SheetApp, ui: &mut Ui, lang: Language) {
             "dark" => "Dark",
             _ => "Light",
         };
-        egui::ComboBox::from_id_salt("backstage_theme")
+        craft_ui::ComboBox::from_id_salt("backstage_theme")
             .width(160.0)
             .selected_text(lang.tr(current))
             .show_ui(ui, |ui| {
@@ -59,7 +59,7 @@ fn general_options(app: &mut SheetApp, ui: &mut Ui, lang: Language) {
             .labelled_by(label.id);
         ui.end_row();
         let label = ui.label(lang.tr("Interface language"));
-        egui::ComboBox::from_id_salt("backstage_language")
+        craft_ui::ComboBox::from_id_salt("backstage_language")
             .width(160.0)
             .selected_text(lang.name())
             .show_ui(ui, |ui| {
diff --git a/crates/ui-egui/src/backstage/print.rs b/crates/ui-egui/src/backstage/print.rs
index ac0b183d6..493951593 100644
--- a/crates/ui-egui/src/backstage/print.rs
+++ b/crates/ui-egui/src/backstage/print.rs
@@ -33,7 +33,7 @@ pub(super) fn print(app: &mut SheetApp, ui: &mut Ui, bs: &mut Backstage, out: &m
             }
             ui.add_space(16.0);
             let scope = if bs.print_all { "Print Entire Workbook" } else { "Print Active Sheets" };
-            egui::ComboBox::from_id_salt("backstage_print_scope")
+            craft_ui::ComboBox::from_id_salt("backstage_print_scope")
                 .width(230.0)
                 .selected_text(lang.tr(scope))
                 .show_ui(ui, |ui| {
diff --git a/crates/ui-egui/src/credits.rs b/crates/ui-egui/src/credits.rs
index adf13bfea..a20039d03 100644
--- a/crates/ui-egui/src/credits.rs
+++ b/crates/ui-egui/src/credits.rs
@@ -223,7 +223,7 @@ pub fn contributors_ui(ui: &mut egui::Ui) {
         }
         ui.separator();
         ui.label("Sort");
-        egui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).show_ui(ui, |ui| {
+        craft_ui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).show_ui(ui, |ui| {
             for k in SortKey::ALL {
                 if ui.selectable_label(v.key == k, k.label().0).clicked() {
                     v.key = k;
diff --git a/crates/ui-egui/src/dialogs/analysis.rs b/crates/ui-egui/src/dialogs/analysis.rs
index 595be229c..a24ddd67b 100644
--- a/crates/ui-egui/src/dialogs/analysis.rs
+++ b/crates/ui-egui/src/dialogs/analysis.rs
@@ -216,7 +216,7 @@ pub(super) fn solver(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open
     ui.horizontal(|ui| {
         edit(ui, d, "newLhs", 110.0, "Constraint Cell Reference");
         let op = text(d, "newOp");
-        egui::ComboBox::from_id_salt("solverOp")
+        craft_ui::ComboBox::from_id_salt("solverOp")
             .selected_text(op.clone())
             .width(60.0)
             .show_ui(ui, |ui| {
@@ -262,7 +262,7 @@ pub(super) fn solver(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open
             "evolutionary" => "Evolutionary",
             _ => "GRG Nonlinear",
         };
-        egui::ComboBox::from_id_salt("solverMethod")
+        craft_ui::ComboBox::from_id_salt("solverMethod")
             .selected_text(label(&method))
             .show_ui(ui, |ui| {
                 for m in ["grg", "simplex", "evolutionary"] {
diff --git a/crates/ui-egui/src/dialogs/data.rs b/crates/ui-egui/src/dialogs/data.rs
index 615c64ab9..bda8bcf90 100644
--- a/crates/ui-egui/src/dialogs/data.rs
+++ b/crates/ui-egui/src/dialogs/data.rs
@@ -218,7 +218,7 @@ pub(super) fn sort(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confir
             if columns.is_empty() {
                 ui.add(egui::TextEdit::singleline(&mut col).desired_width(50.0)).labelled_by(label.id);
             } else {
-                egui::ComboBox::from_id_salt(("sort_col", i))
+                craft_ui::ComboBox::from_id_salt(("sort_col", i))
                     .selected_text(col.clone())
                     .show_ui(ui, |ui| {
                         for (letter, label) in &columns {
@@ -230,7 +230,7 @@ pub(super) fn sort(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confir
             }
             lv["column"] = json!(col.to_ascii_uppercase());
             let mut by = lv["by"].as_str().unwrap_or("values").to_string();
-            egui::ComboBox::from_id_salt(("by", i))
+            craft_ui::ComboBox::from_id_salt(("by", i))
                 .selected_text(match by.as_str() {
                     "cellColor" => "Cell Color",
                     "fontColor" => "Font Color",
diff --git a/crates/ui-egui/src/dialogs/format_cells.rs b/crates/ui-egui/src/dialogs/format_cells.rs
index f28c1de1b..9755ac7a0 100644
--- a/crates/ui-egui/src/dialogs/format_cells.rs
+++ b/crates/ui-egui/src/dialogs/format_cells.rs
@@ -107,7 +107,7 @@ pub(super) fn format_cells(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog
             ui.checkbox(&mut st.align.shrink, lang.tr("Shrink to fit"));
         }
         "Font" => {
-            egui::ComboBox::from_label(lang.tr("Font")).selected_text(st.font.name.clone()).show_ui(ui, |ui| {
+            craft_ui::ComboBox::from_label(lang.tr("Font")).selected_text(st.font.name.clone()).show_ui(ui, |ui| {
                 for f in crate::fonts::families() {
                     ui.selectable_value(&mut st.font.name, f.clone(), f.clone());
                 }
diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs
index d6bc92daa..ff25ba2c7 100644
--- a/crates/ui-egui/src/dialogs/show.rs
+++ b/crates/ui-egui/src/dialogs/show.rs
@@ -537,7 +537,7 @@ pub(super) fn form_fields(ui: &mut egui::Ui, d: &mut Dialog) {
                         let cur = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
                         if d.name == "dataValidation" {
                             let selected = options.iter().find(|(val, _)| *val == cur).map(|(_, text)| lang.tr(text)).unwrap_or("");
-                            egui::ComboBox::from_id_salt(("dataValidation", key))
+                            craft_ui::ComboBox::from_id_salt(("dataValidation", key))
                                 .selected_text(selected)
                                 .width(300.0)
                                 .show_ui(ui, |ui| {
diff --git a/crates/ui-egui/src/pivot_pane.rs b/crates/ui-egui/src/pivot_pane.rs
index a6bffce4e..ef753fa99 100644
--- a/crates/ui-egui/src/pivot_pane.rs
+++ b/crates/ui-egui/src/pivot_pane.rs
@@ -169,7 +169,7 @@ pub fn show(app: &mut SheetApp, ui: &mut Ui) {
             if ui.button(lang.tr("Calculated Field…")).clicked() {
                 app.run_or_alert("pivot.calculatedField", json!({"pivot": name}));
             }
-            egui::ComboBox::from_id_salt("pv_layout")
+            craft_ui::ComboBox::from_id_salt("pv_layout")
                 .selected_text(lang.tr("Report Layout"))
                 .show_ui(ui, |ui| {
                     for (l, v) in [("Compact", "compact"), ("Outline", "outline"), ("Tabular", "tabular")] {
diff --git a/crates/ui-egui/src/ribbon/controls.rs b/crates/ui-egui/src/ribbon/controls.rs
index e77e583a6..88091de3e 100644
--- a/crates/ui-egui/src/ribbon/controls.rs
+++ b/crates/ui-egui/src/ribbon/controls.rs
@@ -115,6 +115,87 @@ pub(super) fn list_combo(
     combo_popup(ui, anchor, salt, current_value, items, false, false, Some(under))
 }
 
+/// What the header of a combo popup hands to its list: the rows to show and the highlighted one.
+struct ComboHead {
+    filtered: Vec<usize>,
+    sel: i32,
+    down: bool,
+    up: bool,
+    enter: bool,
+}
+
+/// Arrow and Enter keys (taken out of the input so a filter field never sees them), the filter
+/// field when `text` is given, and the rows its text matches.
+fn combo_head(ui: &mut Ui, text: Option<(&mut String, egui::Id)>, open_now: bool, sel: i32, items: &[(&str, String)]) -> ComboHead {
+    let (mut down, mut up, mut enter) = (false, false, false);
+    ui.input(|i| {
+        down = i.key_pressed(egui::Key::ArrowDown);
+        up = i.key_pressed(egui::Key::ArrowUp);
+        enter = i.key_pressed(egui::Key::Enter);
+    });
+    if down || up || enter {
+        ui.ctx().input_mut(|i| {
+            i.events
+                .retain(|e| !matches!(e, egui::Event::Key { key: egui::Key::ArrowDown | egui::Key::ArrowUp | egui::Key::Enter, pressed: true, .. }));
+        });
+    }
+    let mut lower = String::new();
+    if let Some((text, text_id)) = text {
+        let te = ui.add(egui::TextEdit::singleline(text).id(text_id).desired_width(220.0).hint_text("Type to filter…"));
+        if open_now && !te.has_focus() {
+            ui.ctx().memory_mut(|m| m.request_focus(text_id));
+            // Select all once focus lands so typing replaces the filter.
+            if let Some(mut s) = egui::text_edit::TextEditState::load(ui.ctx(), text_id) {
+                let len = text.chars().count();
+                s.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(len))));
+                s.store(ui.ctx(), text_id);
+            }
+        }
+        ui.separator();
+        lower = text.to_lowercase();
+    }
+    let filtered: Vec<usize> = items.iter().enumerate().filter(|(_, (_, d))| d.to_lowercase().contains(&lower)).map(|(i, _)| i).collect();
+    let mut sel = sel;
+    if !filtered.is_empty() {
+        let n = filtered.len() as i32;
+        sel = sel.clamp(0, n - 1);
+        if down {
+            sel = (sel + 1).rem_euclid(n);
+        }
+        if up {
+            sel = (sel - 1).rem_euclid(n);
+        }
+    }
+    ComboHead { filtered, sel, down, up, enter }
+}
+
+/// The rows of a combo popup. Returns the picked value and the highlighted row.
+fn combo_rows(ui: &mut Ui, head: ComboHead, items: &[(&str, String)], row_w: f32) -> (Option<String>, i32) {
+    let ComboHead { filtered, mut sel, down, up, enter } = head;
+    let mut picked = None;
+    if enter && !filtered.is_empty() {
+        let idx = filtered[sel.clamp(0, filtered.len() as i32 - 1) as usize];
+        picked = Some(items[idx].0.to_string());
+    }
+    for (pos, i) in filtered.iter().enumerate() {
+        let (value, disp) = &items[*i];
+        let row = ui.add(egui::Button::selectable(pos as i32 == sel, egui::RichText::new(disp)).min_size(vec2(row_w, 20.0)));
+        if (down || up) && pos as i32 == sel && !ui.clip_rect().contains_rect(row.rect) {
+            row.scroll_to_me(Some(if down { egui::Align::Max } else { egui::Align::Min }));
+        }
+        if row.clicked() {
+            picked = Some(value.to_string());
+        }
+        if row.hovered() {
+            sel = pos as i32;
+        }
+    }
+    if picked.is_some() {
+        ui.close();
+    }
+    (picked, sel)
+}
+
 fn combo_popup(
     ui: &mut Ui,
     anchor: &egui::Response,
@@ -125,9 +206,12 @@ fn combo_popup(
     filter: bool,
     under: Option<Rect>,
 ) -> ComboResult {
-    let popup_id = anchor.id.with("popup");
+    let popup_id = egui::Popup::default_response_id(anchor);
     let state_id = anchor.id.with(salt).with("__combo_state");
     let mut st = ui.data_mut(|d| d.get_temp::<ComboState>(state_id)).unwrap_or_default();
+    if forced {
+        egui::Popup::open_id(ui.ctx(), popup_id);
+    }
     let open_now = egui::Popup::is_id_open(ui.ctx(), popup_id);
     if open_now && !st.was_open {
         st.text = String::new();
@@ -137,96 +221,41 @@ fn combo_popup(
         ui.ctx().request_repaint();
     }
     st.was_open = open_now;
-    let mut result = ComboResult::None;
-    let mut popup = egui::Popup::menu(anchor).open_memory(popup_command(forced, anchor.clicked()));
+    // Below `under` and as wide as it, or below the anchor itself.
+    let mut field = anchor.clone();
     if let Some(r) = under {
-        popup = popup.anchor(r).align(egui::RectAlign::BOTTOM_START).width(r.width());
+        field.rect = r;
     }
     let row_w = under.map_or(220.0, |r| r.width() - 12.0);
-    popup.show(|ui| {
-        // Arrows and Enter navigate the list, not the filter field's cursor. Capture them and
-        // strip them from the input so the TextEdit never sees them.
-        let (mut down, mut up, mut enter) = (false, false, false);
-        ui.input(|i| {
-            down = i.key_pressed(egui::Key::ArrowDown);
-            up = i.key_pressed(egui::Key::ArrowUp);
-            enter = i.key_pressed(egui::Key::Enter);
-        });
-        if down || up || enter {
-            ui.ctx().input_mut(|i| {
-                i.events.retain(|e| {
-                    !matches!(e, egui::Event::Key { key: egui::Key::ArrowDown | egui::Key::ArrowUp | egui::Key::Enter, pressed: true, .. })
-                });
-            });
+    // Nine rows as today, plus the filter field and its separator, plus the popup frame.
+    let button_h = ui.spacing().interact_size.y.max(20.0);
+    let spacing = ui.spacing().item_spacing.y;
+    let max_rows = 9.0_f32;
+    let mut height = max_rows * button_h + (max_rows - 1.0) * spacing + egui::Frame::popup(ui.style()).total_margin().sum().y;
+    if filter {
+        height += ui.spacing().interact_size.y + 4.0 * spacing + 1.0;
+    }
+    let menu = craft_ui::combo::Menu::new(ui, &field).height(height);
+    let text_id = anchor.id.with(salt).with("__combo_text");
+    let sel0 = st.sel;
+    let shown = if filter {
+        menu.show_ui_with_header(
+            |ui| combo_head(ui, Some((&mut st.text, text_id)), open_now, sel0, items),
+            |ui, head| combo_rows(ui, head, items, row_w),
+        )
+    } else {
+        menu.show_ui(|ui| {
+            let head = combo_head(ui, None, open_now, sel0, items);
+            combo_rows(ui, head, items, row_w)
+        })
+    };
+    let mut result = ComboResult::None;
+    if let Some((picked, sel)) = shown {
+        st.sel = sel;
+        if let Some(value) = picked {
+            result = ComboResult::Picked(value);
         }
-        if filter {
-            let text_id = anchor.id.with(salt).with("__combo_text");
-            let te = ui.add(egui::TextEdit::singleline(&mut st.text).id(text_id).desired_width(220.0).hint_text("Type to filter…"));
-            if open_now && !te.has_focus() {
-                ui.ctx().memory_mut(|m| m.request_focus(text_id));
-                // Select all once focus lands so typing replaces the filter.
-                if let Some(mut s) = egui::text_edit::TextEditState::load(ui.ctx(), text_id) {
-                    let len = st.text.chars().count();
-                    s.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(len))));
-                    s.store(ui.ctx(), text_id);
-                }
-            }
-        }
-        let lower = st.text.to_lowercase();
-        let filtered: Vec<usize> = items.iter().enumerate().filter(|(_, (_, d))| d.to_lowercase().contains(&lower)).map(|(i, _)| i).collect();
-        if !filtered.is_empty() {
-            let n = filtered.len() as i32;
-            st.sel = st.sel.clamp(0, n - 1);
-            if down {
-                st.sel = (st.sel + 1).rem_euclid(n);
-            }
-            if up {
-                st.sel = (st.sel - 1).rem_euclid(n);
-            }
-        }
-        if enter && !filtered.is_empty() {
-            let idx = filtered[st.sel.clamp(0, filtered.len() as i32 - 1) as usize];
-            result = ComboResult::Picked(items[idx].0.to_string());
-        }
-        if filter {
-            ui.separator();
-        }
-        let button_h = ui.spacing().interact_size.y.max(20.0);
-        let spacing = ui.spacing().item_spacing.y;
-        let n = filtered.len() as f32;
-
-        let content_h = n * button_h + (n - 1.0).max(0.0) * spacing;
-
-        let max_rows = 9.0_f32;
-        let max_h = max_rows * button_h + (max_rows - 1.0) * spacing;
-
-        let desired_h = content_h.min(max_h);
-
-        ui.set_min_height(desired_h);
-
-        egui::ScrollArea::vertical().max_height(desired_h).show(ui, |ui| {
-            for (pos, i) in filtered.iter().enumerate() {
-                let (value, disp) = &items[*i];
-
-                let row = ui.add(egui::Button::selectable(pos as i32 == st.sel, egui::RichText::new(disp)).min_size(vec2(row_w, 20.0)));
-
-                if (down || up) && pos as i32 == st.sel && !ui.clip_rect().contains_rect(row.rect) {
-                    row.scroll_to_me(Some(if down { egui::Align::Max } else { egui::Align::Min }));
-                }
-
-                if row.clicked() {
-                    result = ComboResult::Picked(value.to_string());
-                }
-
-                if row.hovered() {
-                    st.sel = pos as i32;
-                }
-            }
-        });
-        if !matches!(result, ComboResult::None) {
-            ui.close();
-        }
-    });
+    }
     ui.data_mut(|d| d.insert_temp(state_id, st));
     result
 }
diff --git a/crates/ui-egui/src/ribbon/view.rs b/crates/ui-egui/src/ribbon/view.rs
index da278ad31..c21134791 100644
--- a/crates/ui-egui/src/ribbon/view.rs
+++ b/crates/ui-egui/src/ribbon/view.rs
@@ -107,7 +107,7 @@ pub(super) fn view(app: &mut SheetApp, ui: &mut Ui) {
             "dark" => "Dark",
             _ => "Light",
         };
-        egui::ComboBox::from_id_salt("display_theme")
+        craft_ui::ComboBox::from_id_salt("display_theme")
             .selected_text(lang.tr(label))
             .width(88.0)
             .show_ui(ui, |ui| {
@@ -131,7 +131,7 @@ pub(super) fn view(app: &mut SheetApp, ui: &mut Ui) {
         let label = ui.label(egui::RichText::new(lang.tr("Interface size")).font(theme::ui_font(11.5)).color(t.text_dim));
         let current = app.ui.interface_scale;
         let text = |v: u16| if v == 100 { lang.tr("Auto").to_string() } else { format!("{v}%") };
-        egui::ComboBox::from_id_salt("ui_interface_size")
+        craft_ui::ComboBox::from_id_salt("ui_interface_size")
             .width(120.0)
             .selected_text(egui::RichText::new(text(current)).font(theme::ui_font(12.5)))
             .show_ui(ui, |ui| {
@@ -148,7 +148,7 @@ pub(super) fn view(app: &mut SheetApp, ui: &mut Ui) {
     // the current language so it stays readable; the choices are always shown in their own script.
     ui.vertical(|ui| {
         let label = ui.label(egui::RichText::new(lang.tr("Interface language")).font(theme::ui_font(11.5)).color(t.text_dim));
-        egui::ComboBox::from_id_salt("ui_language")
+        craft_ui::ComboBox::from_id_salt("ui_language")
             .width(120.0)
             .selected_text(egui::RichText::new(lang.name()).font(theme::ui_font(12.5)))
             .show_ui(ui, |ui| {
diff --git a/crates/ui-egui/tests/it/font_box_filter.rs b/crates/ui-egui/tests/it/font_box_filter.rs
new file mode 100644
index 000000000..40d270d69
--- /dev/null
+++ b/crates/ui-egui/tests/it/font_box_filter.rs
@@ -0,0 +1,71 @@
+//! The Home ▸ Font list grows back when a filter that matched nothing is cleared, and its filter
+//! field stays where it is (egui#5225).
+
+use egui::{Event, Key, Modifiers, accesskit::Role};
+use egui_kittest::kittest::Queryable as _;
+use gridcraft_engine::Session;
+use gridcraft_ui_egui::SheetApp;
+use serde_json::json;
+
+type Harness = egui_kittest::Harness<'static, SheetApp>;
+
+fn harness() -> Harness {
+    let mut s = Session::new();
+    s.new_workbook();
+    s.execute("selection.set", json!({"range": "A1"})).unwrap();
+    let mut h = crate::common::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
+        |ui, app: &mut SheetApp| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        },
+        crate::common::app(s),
+    );
+    h.run_steps(4);
+    h
+}
+
+fn key(h: &mut Harness, key: Key) {
+    h.input_mut().events.extend([
+        Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE },
+        Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE },
+    ]);
+    h.run_steps(3);
+}
+
+fn type_text(h: &mut Harness, text: &str) {
+    h.input_mut().events.push(Event::Text(text.to_string()));
+    h.run_steps(3);
+}
+
+fn text_inputs(h: &Harness) -> Vec<egui::Rect> {
+    h.get_all_by_role(Role::TextInput).map(|n| n.rect()).collect()
+}
+
+/// The bottom of the Font list's ninth row, if that row is on screen.
+fn ninth_row_bottom(h: &Harness) -> Option<f32> {
+    h.query_by_label("Garamond").map(|n| n.rect().bottom())
+}
+
+#[test]
+fn font_list_grows_back_after_a_filter_is_cleared() {
+    let mut h = harness();
+    let before = text_inputs(&h);
+    let font = h.state().session.active().unwrap().wb.active().unwrap().style_id(gridcraft_engine::core::CellRef::parse("A1").unwrap());
+    let name = h.state().session.active().unwrap().wb.styles.get(font).font.name.clone();
+    h.get_by_label(&name).click();
+    h.run_steps(4);
+    let open: Vec<_> = text_inputs(&h).into_iter().filter(|r| !before.contains(r)).collect();
+    assert_eq!(open.len(), 1, "the open list has one filter field");
+    let field = open[0];
+    let full = ninth_row_bottom(&h).expect("the full list shows its ninth row");
+
+    type_text(&mut h, "zzz");
+    assert!(ninth_row_bottom(&h).is_none(), "a filter that matches nothing leaves no rows");
+    assert!(text_inputs(&h).contains(&field), "the filter field stays put while the list is empty");
+
+    for _ in 0..3 {
+        key(&mut h, Key::Backspace);
+    }
+    assert_eq!(ninth_row_bottom(&h), Some(full), "the cleared filter shows the full list again");
+    assert!(text_inputs(&h).contains(&field), "the filter field stays put after the list regrows");
+}
diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs
index 53625015e..75ab9e86e 100644
--- a/crates/ui-egui/tests/it/main.rs
+++ b/crates/ui-egui/tests/it/main.rs
@@ -36,6 +36,7 @@ mod filter_list_scroll;
 mod filter_menu_enter;
 mod find_dialog_focus;
 mod floating_pictures;
+mod font_box_filter;
 mod font_size_box;
 mod format_painter;
 mod formula_bar;

From 393a524aa3ad3475eef408cd23da5e63048faf4e Mon Sep 17 00:00:00 2001
From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com>
Date: Tue, 27 Oct 2026 15:12:20 +0100
Subject: [PATCH 76/76] Speed up XLSX worksheet writing

Saving a large workbook spent about half its time building worksheet XML,
mostly in small per-cell allocations. The writer now appends to the part
directly:

- Cell references, row numbers, style ids, shared string indexes and
  numbers are appended without temporary strings (push_a1, push_u64,
  push_num), and text is escaped in place (push_esc, with a fast path for
  plain ASCII).
- sheetData walks the cell store in its own row-major order instead of
  copying every address into a BTreeSet and a per-row BTreeMap and looking
  each cell up again. Cells outside the store (pictures, spill values,
  table headers) still go through the sorted set.
- Formulas with nothing the file spells differently (no LET/LAMBDA, no
  _xlfn function, no spill, @, trim operator or structured reference) are
  printed from the shared expression instead of being cloned and rebuilt
  twice by the file rewrite.
- The A1 printer in gridcraft-formula appends references to the output
  instead of formatting each anchor into its own string.

The output is byte-for-byte unchanged.

write_perf, 200,000 rows (2.0M cells, 14.2 MB package), release, Ryzen
16 threads / Linux, 36 interleaved runs each:
  before: median 2083.9 ms, min 1615.7 ms
  after:  median 1501.3 ms, min 1192.3 ms  (-28.0 % median, -26.2 % min)

What remains is mostly deflate (zlib-rs, level 6), about 70 % of the save.

Tests pin the exact sheetData of a workbook covering row settings between
cell rows, spill values, every value kind, number spellings, escaping and
formulas with and without a file spelling (generated with the previous
writer), and check each appending helper and the formula fast path against
the code they replace.

The formula fast path is guarded by a test that runs both paths over every
function in the gridcraft-functions registry (a new dev-dependency, allowed
by the layer rules), in 15 surrounding shapes covering every operator and
rewrite, so a function or rewrite added later without updating the trigger
list fails it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock                              |   1 +
 crates/formula/src/printer.rs           |  75 +++++++++++---
 crates/formula/src/tests.rs             |  25 +++++
 crates/xlsx/Cargo.toml                  |   4 +
 crates/xlsx/src/fmla.rs                 |  83 ++++++++++++++-
 crates/xlsx/src/sheet_write.rs          |  99 +++++++++++-------
 crates/xlsx/src/tests.rs                |   1 +
 crates/xlsx/src/tests/sheet_data_pin.rs |  68 +++++++++++++
 crates/xlsx/src/xml.rs                  | 128 +++++++++++++++++++++++-
 9 files changed, 429 insertions(+), 55 deletions(-)
 create mode 100644 crates/xlsx/src/tests/sheet_data_pin.rs

diff --git a/Cargo.lock b/Cargo.lock
index 53b2326da..a092cd3e3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2124,6 +2124,7 @@ dependencies = [
  "aes",
  "gridcraft-core",
  "gridcraft-formula",
+ "gridcraft-functions",
  "gridcraft-model",
  "quick-xml 0.41.0",
  "sha1 0.11.0",
diff --git a/crates/formula/src/printer.rs b/crates/formula/src/printer.rs
index 8a1c0c45b..3b5989372 100644
--- a/crates/formula/src/printer.rs
+++ b/crates/formula/src/printer.rs
@@ -2,7 +2,7 @@
 
 use std::fmt::Write;
 
-use gridcraft_core::{CellRef, col_to_letters, number_to_text};
+use gridcraft_core::{CellRef, number_to_text};
 
 use crate::ast::{Anchor, BinOp, Expr, RefKind, Reference, SheetSel, StructItem, StructRef, UnOp};
 
@@ -19,8 +19,32 @@ fn sheet_prefix(s: &SheetSel) -> String {
     }
 }
 
-fn anchor_a1(a: &Anchor) -> String {
-    format!("{}{}{}{}", if a.col_abs { "$" } else { "" }, col_to_letters(a.col), if a.row_abs { "$" } else { "" }, a.row as u64 + 1)
+fn push_anchor_a1(s: &mut String, a: &Anchor) {
+    if a.col_abs {
+        s.push('$');
+    }
+    push_col(s, a.col);
+    if a.row_abs {
+        s.push('$');
+    }
+    let _ = write!(s, "{}", a.row as u64 + 1);
+}
+
+/// Appends [`gridcraft_core::col_to_letters`]`(col)` without allocating.
+fn push_col(s: &mut String, col: u32) {
+    let mut letters = [0u8; 8];
+    let mut i = letters.len();
+    let mut n = col as u64 + 1;
+    while n > 0 && i > 0 {
+        i -= 1;
+        if let Some(l) = letters.get_mut(i) {
+            *l = b'A' + ((n - 1) % 26) as u8;
+        }
+        n = (n - 1) / 26;
+    }
+    for &l in letters.get(i..).unwrap_or_default() {
+        s.push(char::from(l));
+    }
 }
 
 pub fn reference_a1(r: &Reference) -> String {
@@ -29,15 +53,40 @@ pub fn reference_a1(r: &Reference) -> String {
 
 /// A1 text with `sep` between the two ends of a range (`:` or a trim operator).
 fn range_a1(r: &Reference, sep: &str) -> String {
-    let body = match &r.kind {
-        RefKind::Cell(a) => anchor_a1(a),
-        RefKind::Range(a, b) => format!("{}{sep}{}", anchor_a1(a), anchor_a1(b)),
-        RefKind::Rows(r0, a0, r1, a1) => format!("{}{}{sep}{}{}", if *a0 { "$" } else { "" }, r0 + 1, if *a1 { "$" } else { "" }, r1 + 1),
-        RefKind::Cols(c0, a0, c1, a1) => {
-            format!("{}{}{sep}{}{}", if *a0 { "$" } else { "" }, col_to_letters(*c0), if *a1 { "$" } else { "" }, col_to_letters(*c1))
+    let mut s = String::new();
+    push_range_a1(&mut s, r, sep);
+    s
+}
+
+/// Appends [`range_a1`]`(r, sep)` to `s`.
+fn push_range_a1(s: &mut String, r: &Reference, sep: &str) {
+    match &r.sheet {
+        SheetSel::Current => {}
+        SheetSel::Named(n) => {
+            s.push_str(&quote_sheet(n));
+            s.push('!');
         }
-    };
-    format!("{}{}", sheet_prefix(&r.sheet), body)
+        sheet @ SheetSel::Span(_, _) => s.push_str(&sheet_prefix(sheet)),
+    }
+    let dollar = |abs: bool| if abs { "$" } else { "" };
+    match &r.kind {
+        RefKind::Cell(a) => push_anchor_a1(s, a),
+        RefKind::Range(a, b) => {
+            push_anchor_a1(s, a);
+            s.push_str(sep);
+            push_anchor_a1(s, b);
+        }
+        RefKind::Rows(r0, a0, r1, a1) => {
+            let _ = write!(s, "{}{}{sep}{}{}", dollar(*a0), r0 + 1, dollar(*a1), r1 + 1);
+        }
+        RefKind::Cols(c0, a0, c1, a1) => {
+            s.push_str(dollar(*a0));
+            push_col(s, *c0);
+            s.push_str(sep);
+            s.push_str(dollar(*a1));
+            push_col(s, *c1);
+        }
+    }
 }
 
 fn r1c1_part(letter: char, v: u32, abs: bool, base: u32) -> String {
@@ -207,7 +256,7 @@ fn write_expr(s: &mut String, e: &Expr, r1c1: Option<CellRef>) {
         }
         Expr::Ref(r) => match r1c1 {
             Some(at) => s.push_str(&reference_r1c1(r, at)),
-            None => s.push_str(&reference_a1(r)),
+            None => push_range_a1(s, r, ":"),
         },
         Expr::Name(n) => match sheet_split(n) {
             // A sheet-qualified name is stored with the bare sheet name (`My Sheet!Total`): quote it so it parses back.
@@ -246,7 +295,7 @@ fn write_expr(s: &mut String, e: &Expr, r1c1: Option<CellRef>) {
             UnOp::Trim(mode) => match &**x {
                 Expr::Ref(r) if !matches!(r.kind, RefKind::Cell(_)) => match r1c1 {
                     Some(at) => s.push_str(&range_r1c1(r, at, mode.symbol())),
-                    None => s.push_str(&range_a1(r, mode.symbol())),
+                    None => push_range_a1(s, r, mode.symbol()),
                 },
                 Expr::Binary(BinOp::Range, a, b) => {
                     write_expr(s, a, r1c1);
diff --git a/crates/formula/src/tests.rs b/crates/formula/src/tests.rs
index a7506aa4b..0f16116af 100644
--- a/crates/formula/src/tests.rs
+++ b/crates/formula/src/tests.rs
@@ -518,3 +518,28 @@ fn three_d_span_and_cell_start_still_lex_as_span() {
     assert_eq!(rt("SUM(Sheet1:Sheet3!A1)"), "SUM(Sheet1:Sheet3!A1)");
     assert_eq!(rt("SUM(Q1:Sheet3!A1)"), "SUM('Q1:Sheet3'!A1)");
 }
+
+/// References print the same through the appending printer for every reference shape.
+#[test]
+fn reference_shapes_print_unchanged() {
+    for text in [
+        "A1",
+        "XFD1048576",
+        "$AA$10:AB$11",
+        "$A:XFD",
+        "B:$C",
+        "1:$1048576",
+        "$3:4",
+        "'My Sheet'!A1",
+        "'It''s'!$B$2:C3",
+        "Sheet1:Sheet3!B2",
+        "'Sheet 1:Sheet3'!B2",
+        "SUM(A1:.B3)+SUM(A.:.B)",
+    ] {
+        let e = parse(text).unwrap();
+        assert_eq!(print(&e), text);
+        if let Expr::Ref(r) = &e {
+            assert_eq!(printer::reference_a1(r), text);
+        }
+    }
+}
diff --git a/crates/xlsx/Cargo.toml b/crates/xlsx/Cargo.toml
index b53a44828..562afff11 100644
--- a/crates/xlsx/Cargo.toml
+++ b/crates/xlsx/Cargo.toml
@@ -23,3 +23,7 @@ zip = { workspace = true }
 aes = { workspace = true }
 sha1 = { workspace = true }
 sha2 = { workspace = true }
+
+[dev-dependencies]
+# Every registered function name, for the formula file-spelling test.
+gridcraft-functions = { workspace = true }
diff --git a/crates/xlsx/src/fmla.rs b/crates/xlsx/src/fmla.rs
index c5e1f686c..966088d5b 100644
--- a/crates/xlsx/src/fmla.rs
+++ b/crates/xlsx/src/fmla.rs
@@ -6,12 +6,29 @@ use gridcraft_model::Formula;
 
 /// Formula text for a file.
 pub fn to_file(f: &Formula) -> String {
-    match f.expr() {
-        Some(e) => expr_to_file(e),
+    match f.expr_arc() {
+        // Most formulas have nothing the file spells differently: print them without copying.
+        Some(e) if !needs_file_spelling(&e) => gridcraft_formula::print(&e),
+        Some(e) => expr_to_file(Expr::clone(&e)),
         None => f.text.clone(),
     }
 }
 
+/// Whether [`expr_to_file`] would change anything in `e`: a LET or LAMBDA (parameter prefixes),
+/// a function with a file prefix, a spill, `@` or trim operator, or a structured reference.
+fn needs_file_spelling(e: &Expr) -> bool {
+    let mut found = false;
+    e.walk(&mut |x| {
+        found |= match x {
+            Expr::Call(name, _) => name == "LET" || name == "LAMBDA" || crate::tables::file_function_name(name).is_some(),
+            Expr::Unary(gridcraft_formula::UnOp::Spill | gridcraft_formula::UnOp::At | gridcraft_formula::UnOp::Trim(_), _) => true,
+            Expr::Struct(_) => true,
+            _ => false,
+        }
+    });
+    found
+}
+
 /// Arbitrary formula text (names, CF, validation) for a file. Unparseable text is kept.
 pub fn text_to_file(text: &str) -> String {
     let body = text.strip_prefix('=').unwrap_or(text);
@@ -136,6 +153,68 @@ pub fn from_file(text: &str) -> String {
 mod tests {
     use super::*;
 
+    /// Formulas without a file spelling skip the rewrite; the text must be what it would give.
+    #[test]
+    fn plain_formulas_print_as_the_rewrite_would() {
+        for text in [
+            "SUM(A1:B2)*2",
+            "A1&\"x\"\"y\"",
+            "Sheet2!$A$1+'My Sheet'!C:C-$3:4",
+            "IF(A1>0,{1,2;3,4},-B$2%)",
+            "Sheet1:Sheet3!A1",
+            "INDEX(A:A,1):B5",
+            "Total*2",
+            "XLOOKUP(1,A:A,B:B)",
+            "LET(x,1,x)",
+            "LAMBDA(a,a)(1)",
+            "A1#",
+            "@A1:A2",
+            "SUM(A1:.B3)",
+            "T[@C]",
+        ] {
+            let f = Formula::new(text);
+            assert_eq!(to_file(&f), expr_to_file(f.expr().unwrap()), "{text}");
+        }
+    }
+
+    /// The fast path in [`to_file`] skips the rewrite on a list of what triggers it. Run both paths
+    /// over every registered function, alone, nested and next to every operator, so a function or
+    /// rewrite added later without updating [`needs_file_spelling`] fails here.
+    #[test]
+    fn every_registered_function_prints_as_the_rewrite_would() {
+        let shapes = [
+            "{}",
+            "1+{}",
+            "-{}%",
+            "SUM({},A1:B2)",
+            "IF(A1,{},Sheet2!$C$3)",
+            "LET(x,{},x)",
+            "LAMBDA(a,{})(1)",
+            "@{}",
+            "{}&A1#",
+            "{}+SUM(A1:.B3)",
+            "{}+T[@C]",
+            "{}+T[[#All],[C]]",
+            "({})*{{1,2;3,4}}",
+            "{}:B5 C1:D2",
+            "{}+My Sheet!A:A+Total",
+        ];
+        let mut checked = 0;
+        for spec in gridcraft_functions::all() {
+            let n = spec.min_args.max(1).min(spec.max_args).min(4);
+            let args = ["A1", "B2:C3", "1", "\"x\""].get(..n).unwrap_or_default().join(",");
+            let call = format!("{}({args})", spec.name);
+            for shape in shapes {
+                let text = shape.replace("{}", &call).replace("{{", "{").replace("}}", "}");
+                let f = Formula::new(&text);
+                let Some(e) = f.expr() else { continue };
+                assert_eq!(to_file(&f), expr_to_file(e), "{text}");
+                checked += 1;
+            }
+        }
+        assert!(checked > gridcraft_functions::all().len() * 10, "only {checked} formulas parsed");
+    }
+
     #[test]
     fn spill_references() {
         assert_eq!(to_file(&Formula::new("SUM(Sheet1!$D$1#)+B2#")), "SUM(_xlfn.ANCHORARRAY(Sheet1!$D$1))+_xlfn.ANCHORARRAY(B2)");
diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs
index aeca78123..b03bfbd5e 100644
--- a/crates/xlsx/src/sheet_write.rs
+++ b/crates/xlsx/src/sheet_write.rs
@@ -16,7 +16,7 @@ use crate::tables::{paper_id, px_to_col_width, px_to_pt};
 use crate::write::{
     CT_CHART, CT_COMMENTS, CT_DRAWING, CT_TABLE, CT_THREADED_COMMENTS, NS_MAIN, NS_REL, NS_THREADED, Out, REL_THREADED_COMMENT, Rels, XML_DECL,
 };
-use crate::xml::{encode_xstring, esc, esc_attr, num};
+use crate::xml::{encode_xstring, esc, esc_attr, num, push_a1, push_esc, push_num, push_u64};
 
 mod parts;
 mod rules;
@@ -253,24 +253,46 @@ pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (
     }
 
     // sheetData
-    let mut keys: BTreeSet<CellRef> = sheet.cells.iter().map(|(c, _)| c).collect();
-    keys.extend(sheet.cell_pictures.keys().copied());
-    keys.extend(extra.keys().copied());
-    keys.extend(overrides.keys().copied());
-    let mut rows: BTreeMap<u32, Vec<CellRef>> = BTreeMap::new();
-    for k in keys {
-        rows.entry(k.row).or_default().push(k);
-    }
-    for r in sheet.rows.keys() {
-        rows.entry(*r).or_default();
+    // Every written cell in row-major order: the store already iterates that way, so only cells
+    // that exist outside it (pictures, cached spill values, table headers) need sorting in.
+    let mut keys: Vec<(CellRef, Option<&Cell>)> = Vec::with_capacity(sheet.cells.len());
+    keys.extend(sheet.cells.iter().map(|(c, cell)| (c, Some(cell))));
+    if !sheet.cell_pictures.is_empty() || !extra.is_empty() || !overrides.is_empty() || !keys.is_sorted_by_key(|(c, _)| *c) {
+        let mut all: BTreeSet<CellRef> = keys.iter().map(|(c, _)| *c).collect();
+        all.extend(sheet.cell_pictures.keys().copied());
+        all.extend(extra.keys().copied());
+        all.extend(overrides.keys().copied());
+        keys = all.into_iter().map(|c| (c, sheet.cells.get(c))).collect();
     }
+    s.reserve(keys.len().saturating_mul(32));
     s.push_str("<sheetData>");
-    for (r, cells) in &rows {
-        let info = sheet.rows.get(r).copied().unwrap_or_default();
+    let mut row_infos = sheet.rows.iter().peekable();
+    let mut next = 0;
+    loop {
+        // The next row with cells or row settings, and its cells.
+        let cell_row = keys.get(next).map(|(c, _)| c.row);
+        let info_row = row_infos.peek().map(|(r, _)| **r);
+        let r = match (cell_row, info_row) {
+            (Some(a), Some(b)) => a.min(b),
+            (Some(a), None) => a,
+            (None, Some(b)) => b,
+            (None, None) => break,
+        };
+        let info = match row_infos.next_if(|(row, _)| **row == r) {
+            Some((_, info)) => *info,
+            None => LineInfo::default(),
+        };
+        let first = next;
+        while keys.get(next).is_some_and(|(c, _)| c.row == r) {
+            next += 1;
+        }
+        let cells = keys.get(first..next).unwrap_or_default();
         if cells.is_empty() && info == LineInfo::default() {
             continue;
         }
-        let _ = write!(s, "<row r=\"{}\"", r + 1);
+        s.push_str("<row r=\"");
+        push_u64(&mut s, u64::from(r) + 1);
+        s.push('"');
         if let Some(st) = info.style {
             let _ = write!(s, " s=\"{}\" customFormat=\"1\"", sid(st));
         }
@@ -291,15 +313,14 @@ pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (
             continue;
         }
         s.push('>');
-        for c in cells {
-            let cell = sheet.cells.get(*c);
-            let ov = overrides.get(c);
-            let ex = extra.get(c);
-            let array = dynamic.get(c).copied().or_else(|| {
+        for &(c, cell) in cells {
+            let ov = overrides.get(&c);
+            let ex = extra.get(&c);
+            let array = dynamic.get(&c).copied().or_else(|| {
                 let f = cell?.formula.as_ref()?;
-                (f.array.is_none() && crate::array_formula::needs_array(wb, si, *c, f)).then_some(RangeRef::cell(*c))
+                (f.array.is_none() && crate::array_formula::needs_array(wb, si, c, f)).then_some(RangeRef::cell(c))
             });
-            write_cell(&mut s, *c, cell, sheet.cell_pictures.get(c), ov, ex, array.as_ref(), &sid, out);
+            write_cell(&mut s, c, cell, sheet.cell_pictures.get(&c), ov, ex, array.as_ref(), &sid, out);
         }
         s.push_str("</row>");
     }
@@ -635,9 +656,13 @@ fn write_cell(
     out: &mut Out,
 ) {
     let style = cell.map(|x| sid(x.style)).unwrap_or(0);
-    let _ = write!(s, "<c r=\"{}\"", c.a1());
+    s.push_str("<c r=\"");
+    push_a1(s, c);
+    s.push('"');
     if style != 0 {
-        let _ = write!(s, " s=\"{style}\"");
+        s.push_str(" s=\"");
+        push_u64(s, u64::from(style));
+        s.push('"');
     }
     if let Some(picture) = picture {
         let vm = out.cell_pictures.index(picture);
@@ -679,21 +704,19 @@ fn write_cell(
         };
         s.push_str(t);
         s.push('>');
-        let text = esc(&crate::fmla::to_file(f));
-        match (f.array, dynamic) {
-            (Some(r), _) => {
-                let _ = write!(s, "<f t=\"array\" ref=\"{}\">{text}</f>", r.a1());
-            }
-            (None, Some(r)) => {
-                let _ = write!(s, "<f t=\"array\" ref=\"{}\">{text}</f>", r.a1());
-            }
-            _ => {
-                let _ = write!(s, "<f>{text}</f>");
+        match f.array.or(dynamic.copied()) {
+            Some(r) => {
+                let _ = write!(s, "<f t=\"array\" ref=\"{}\">", r.a1());
             }
+            None => s.push_str("<f>"),
         }
+        push_esc(s, &crate::fmla::to_file(f));
+        s.push_str("</f>");
         match &value {
             Value::Number(n) => {
-                let _ = write!(s, "<v>{}</v>", num(*n));
+                s.push_str("<v>");
+                push_num(s, *n);
+                s.push_str("</v>");
             }
             Value::Text(t) => {
                 let _ = write!(s, "<v>{}</v>", esc(&encode_xstring(t)));
@@ -712,11 +735,15 @@ fn write_cell(
     match &value {
         Value::Empty | Value::Array(_) => s.push_str("/>"),
         Value::Number(n) => {
-            let _ = write!(s, "><v>{}</v></c>", num(*n));
+            s.push_str("><v>");
+            push_num(s, *n);
+            s.push_str("</v></c>");
         }
         Value::Text(t) => {
             let i = out.sst.index(t);
-            let _ = write!(s, " t=\"s\"><v>{i}</v></c>");
+            s.push_str(" t=\"s\"><v>");
+            push_u64(s, u64::from(i));
+            s.push_str("</v></c>");
         }
         Value::Bool(b) => {
             let _ = write!(s, " t=\"b\"><v>{}</v></c>", *b as u8);
diff --git a/crates/xlsx/src/tests.rs b/crates/xlsx/src/tests.rs
index a7f6f1eb7..73be1a064 100644
--- a/crates/xlsx/src/tests.rs
+++ b/crates/xlsx/src/tests.rs
@@ -23,6 +23,7 @@ mod richdata_tests;
 mod roundtrip;
 mod shape_text_rtl;
 mod shared_media;
+mod sheet_data_pin;
 mod sheet_names;
 mod smooth_roundtrip;
 mod trendline_roundtrip;
diff --git a/crates/xlsx/src/tests/sheet_data_pin.rs b/crates/xlsx/src/tests/sheet_data_pin.rs
new file mode 100644
index 000000000..5f9b72a01
--- /dev/null
+++ b/crates/xlsx/src/tests/sheet_data_pin.rs
@@ -0,0 +1,68 @@
+//! Pins the exact `<sheetData>` the writer produces: row order with row settings between and
+//! around cell rows, cells added outside the store (cached spill values), every value kind, number
+//! spellings, escaping, cell references far out in the grid and formulas with and without a file
+//! spelling. The expected text was produced by the writer before its per-cell path was made
+//! allocation-free, so any change in the bytes shows up here.
+
+use std::sync::Arc;
+
+use gridcraft_core::{CellError, CellRef, RangeRef, Value};
+use gridcraft_model::{Cell, Formula, LineInfo, NumFmt, StyleId, Workbook};
+
+use crate::package::Package;
+use crate::write_xlsx;
+
+fn at(a: &str) -> CellRef {
+    CellRef::parse(a).unwrap()
+}
+
+fn formula(text: &str, value: Value, style: StyleId) -> Cell {
+    Cell { value, formula: Some(Arc::new(Formula::new(text))), style }
+}
+
+fn sheet_data(wb: &Workbook) -> String {
+    let bytes = write_xlsx(wb).unwrap();
+    let mut pkg = Package::open(&bytes).unwrap();
+    let xml = String::from_utf8(pkg.read("xl/worksheets/sheet1.xml").unwrap().unwrap()).unwrap();
+    let start = xml.find("<sheetData>").unwrap();
+    let end = xml.find("</sheetData>").unwrap() + "</sheetData>".len();
+    xml[start..end].to_string()
+}
+
+#[test]
+fn sheet_data_is_written_byte_for_byte_as_pinned() {
+    let mut wb = Workbook::new();
+    let money = wb.styles.derive(StyleId::DEFAULT, |s| s.num_fmt = NumFmt::new("0.00"));
+    let sh = wb.sheet_mut(0).unwrap();
+    sh.rows.insert(1, LineInfo { hidden: true, ..LineInfo::default() });
+    sh.rows.insert(4, LineInfo { size: Some(30.0), custom: true, ..LineInfo::default() });
+    sh.rows.insert(7, LineInfo { outline: 2, style: Some(money), ..LineInfo::default() });
+    let set = |sh: &mut gridcraft_model::Sheet, a: &str, value: Value, style: StyleId| sh.cells.set(at(a), Cell { value, formula: None, style });
+    set(sh, "A3", Value::text("a & <b> \"q\""), StyleId::DEFAULT);
+    set(sh, "B3", Value::Number(-5.0), StyleId::DEFAULT);
+    set(sh, "C3", Value::Number(0.1), money);
+    set(sh, "D3", Value::Bool(true), StyleId::DEFAULT);
+    set(sh, "E3", Value::Error(CellError::NA), StyleId::DEFAULT);
+    set(sh, "Z3", Value::Number(-0.0), StyleId::DEFAULT);
+    set(sh, "AA3", Value::Number(-2.5), StyleId::DEFAULT);
+    set(sh, "A5", Value::Number(1e20), money);
+    set(sh, "B5", Value::Number(1.5e-7), StyleId::DEFAULT);
+    set(sh, "C5", Value::Number(123_456_789_012_345.0), StyleId::DEFAULT);
+    set(sh, "D5", Value::Number(-1e15), StyleId::DEFAULT);
+    set(sh, "E5", Value::Number(f64::NAN), StyleId::DEFAULT);
+    set(sh, "F5", Value::text("Grüße\r\n\u{1}_x0041_ 日本"), StyleId::DEFAULT);
+    set(sh, "G5", Value::text("a & <b> \"q\""), StyleId::DEFAULT);
+    set(sh, "H5", Value::Empty, money);
+    sh.cells.set(at("B1"), formula("SEQUENCE(2)", Value::Number(1.0), StyleId::DEFAULT));
+    sh.spill_ranges.insert(at("B1"), RangeRef::parse("B1:B2").unwrap());
+    sh.spill.insert(at("B2"), Value::Number(2.0));
+    sh.cells.set(at("AB10000"), formula("SUM($A$1:B2,Sheet2!C:C,3:$5,'My Sheet'!$XFD$1)*2", Value::Number(0.25), money));
+    sh.cells.set(at("AC10000"), formula("A1&\"<x>\"", Value::text("t & <u>"), StyleId::DEFAULT));
+    sh.cells.set(at("AD10000"), formula("LET(x,1,x+XLOOKUP(1,A:A,B:B))", Value::Bool(false), StyleId::DEFAULT));
+    sh.cells.set(at("AE10000"), formula("1/0", Value::Error(CellError::Div0), StyleId::DEFAULT));
+    sh.cells.set(at("AF10000"), formula("A1", Value::Empty, StyleId::DEFAULT));
+    sh.cells.set(at("XFD1048576"), Cell::value(Value::Number(7.0)));
+    assert_eq!(sheet_data(&wb), EXPECTED);
+}
+
+const EXPECTED: &str = r#"<sheetData><row r="1"><c r="B1" cm="1"><f t="array" ref="B1:B2">_xlfn.SEQUENCE(2)</f><v>1</v></c></row><row r="2" hidden="1"><c r="B2"><v>2</v></c></row><row r="3"><c r="A3" t="s"><v>0</v></c><c r="B3"><v>-5</v></c><c r="C3" s="1"><v>0.1</v></c><c r="D3" t="b"><v>1</v></c><c r="E3" t="e"><v>#N/A</v></c><c r="Z3"><v>0</v></c><c r="AA3"><v>-2.5</v></c></row><row r="5" ht="22.5" customHeight="1"><c r="A5" s="1"><v>1E20</v></c><c r="B5"><v>1.5E-7</v></c><c r="C5"><v>123456789012345</v></c><c r="D5"><v>-1000000000000000.0</v></c><c r="E5"><v>0</v></c><c r="F5" t="s"><v>1</v></c><c r="G5" t="s"><v>0</v></c><c r="H5" s="1"/></row><row r="8" s="1" customFormat="1" outlineLevel="2"/><row r="10000"><c r="AB10000" s="1"><f>SUM($A$1:B2,Sheet2!C:C,3:$5,'My Sheet'!$XFD$1)*2</f><v>0.25</v></c><c r="AC10000" t="str"><f>A1&amp;"&lt;x&gt;"</f><v>t &amp; &lt;u&gt;</v></c><c r="AD10000" t="b"><f>_xlfn.LET(_xlpm.x,1,_xlpm.x+_xlfn.XLOOKUP(1,A:A,B:B))</f><v>0</v></c><c r="AE10000" t="e"><f>1/0</f><v>#DIV/0!</v></c><c r="AF10000"><f>A1</f></c></row><row r="1048576"><c r="XFD1048576"><v>7</v></c></row></sheetData>"#;
diff --git a/crates/xlsx/src/xml.rs b/crates/xlsx/src/xml.rs
index 166994180..940a66261 100644
--- a/crates/xlsx/src/xml.rs
+++ b/crates/xlsx/src/xml.rs
@@ -325,6 +325,17 @@ pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Res
 /// Escapes text content.
 pub fn esc(s: &str) -> String {
     let mut o = String::with_capacity(s.len());
+    push_esc(&mut o, s);
+    o
+}
+
+/// Appends [`esc`]`(s)` to `o`.
+pub fn push_esc(o: &mut String, s: &str) {
+    if s.bytes().all(|b| matches!(b, b'\t' | b'\n' | 0x20..=0x7E) && !matches!(b, b'&' | b'<' | b'>')) {
+        o.push_str(s);
+        return;
+    }
+    o.reserve(s.len());
     for c in s.chars() {
         match c {
             '&' => o.push_str("&amp;"),
@@ -335,7 +346,43 @@ pub fn esc(s: &str) -> String {
             _ => {}
         }
     }
-    o
+}
+
+/// Appends `n` in decimal.
+pub fn push_u64(o: &mut String, mut n: u64) {
+    let mut buf = [0u8; 20];
+    let mut i = buf.len();
+    loop {
+        i -= 1;
+        if let Some(d) = buf.get_mut(i) {
+            *d = b'0' + (n % 10) as u8;
+        }
+        n /= 10;
+        if n == 0 || i == 0 {
+            break;
+        }
+    }
+    for &d in buf.get(i..).unwrap_or_default() {
+        o.push(char::from(d));
+    }
+}
+
+/// Appends the `A1`-style text of `c` ([`gridcraft_core::CellRef::a1`]).
+pub fn push_a1(o: &mut String, c: gridcraft_core::CellRef) {
+    let mut letters = [0u8; 8];
+    let mut i = letters.len();
+    let mut n = u64::from(c.col) + 1;
+    while n > 0 && i > 0 {
+        i -= 1;
+        if let Some(l) = letters.get_mut(i) {
+            *l = b'A' + ((n - 1) % 26) as u8;
+        }
+        n = (n - 1) / 26;
+    }
+    for &l in letters.get(i..).unwrap_or_default() {
+        o.push(char::from(l));
+    }
+    push_u64(o, u64::from(c.row) + 1);
 }
 
 /// Escapes an attribute value (double-quoted).
@@ -475,13 +522,30 @@ pub fn si_body(text: &str, phonetic: Option<&PhoneticString>) -> String {
 
 /// Formats a number for an XML attribute/value (shortest round-trip form).
 pub fn num(n: f64) -> String {
+    let mut s = String::new();
+    push_num(&mut s, n);
+    s
+}
+
+/// Appends [`num`]`(n)` to `o`.
+pub fn push_num(o: &mut String, n: f64) {
     if !n.is_finite() {
-        return "0".into();
+        o.push('0');
+        return;
     }
     if n == n.trunc() && n.abs() < 1e15 {
-        return format!("{}", n as i64);
+        let i = n as i64;
+        if i < 0 {
+            o.push('-');
+        }
+        push_u64(o, i.unsigned_abs());
+        return;
+    }
+    let start = o.len();
+    let _ = write!(o, "{n:?}");
+    if let Some(e) = o.get(start..).and_then(|t| t.find('e')) {
+        o.replace_range(start + e..start + e + 1, "E");
     }
-    format!("{n:?}").replace('e', "E")
 }
 
 #[cfg(test)]
@@ -618,6 +682,62 @@ mod tests {
         assert_eq!(esc_attr("a\rb"), "a&#13;b");
     }
 
+    /// The appending helpers the sheet writer uses write exactly what the allocating spellings
+    /// (`CellRef::a1`, `to_string`, the `num` formula and the `esc` character loop) write.
+    #[test]
+    fn appending_helpers_match_the_allocating_spellings() {
+        use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS};
+        for c in [
+            CellRef::new(0, 0),
+            CellRef::new(9, 25),
+            CellRef::new(99, 26),
+            CellRef::new(0, 701),
+            CellRef::new(0, 702),
+            CellRef::new(MAX_ROWS - 1, MAX_COLS - 1),
+            CellRef::new(u32::MAX, u32::MAX),
+        ] {
+            let mut s = String::from("x");
+            push_a1(&mut s, c);
+            assert_eq!(s, format!("x{}", c.a1()));
+        }
+        for n in [0, 9, 10, 99, 1_048_576, u64::MAX] {
+            let mut s = String::from("x");
+            push_u64(&mut s, n);
+            assert_eq!(s, format!("x{n}"));
+        }
+        for n in
+            [0.0, -0.0, 1.0, -3.0, 0.1, -2.5, 1e-7, 1.5e20, 1e15, -1e15, 999_999_999_999_999.0, f64::NAN, f64::INFINITY, f64::MIN_POSITIVE, f64::MAX]
+        {
+            let reference = if !n.is_finite() {
+                "0".to_string()
+            } else if n == n.trunc() && n.abs() < 1e15 {
+                format!("{}", n as i64)
+            } else {
+                format!("{n:?}").replace('e', "E")
+            };
+            let mut s = String::from("x");
+            push_num(&mut s, n);
+            assert_eq!(s, format!("x{reference}"), "{n}");
+            assert_eq!(num(n), reference);
+        }
+        for t in ["plain", "", "a & <b> > c \"q\"", "tab\tnew\nline\rcr", "\u{1}\u{8}ctl", "日本語 ü", "\u{FFFE}\u{FFFF}x", "~\u{7F}"] {
+            let mut reference = String::new();
+            for c in t.chars() {
+                match c {
+                    '&' => reference.push_str("&amp;"),
+                    '<' => reference.push_str("&lt;"),
+                    '>' => reference.push_str("&gt;"),
+                    '\r' => reference.push_str("&#13;"),
+                    c if is_xml_char(c) => reference.push(c),
+                    _ => {}
+                }
+            }
+            let mut s = String::from("x");
+            push_esc(&mut s, t);
+            assert_eq!(s, format!("x{reference}"), "{t:?}");
+        }
+    }
+
     #[test]
     fn numbers() {
         assert_eq!(num(1.0), "1");