diff --git a/AGENTS.md b/AGENTS.md
index 289cb12d0..01a8da9b3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -23,7 +23,7 @@ Standards and learnings shared across the crafting apps live in `../../craftrule
 People trust GridCraft with their numbers; a crash loses their work. **This outranks feature work.** Standard: [`craftrules/standards/never-crash.md`](https://github.com/storytold/craftrules/blob/main/standards/never-crash.md).
 - **No panics in non-test code:** no `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!`; no `unsafe` (`unsafe_code = "forbid"`).
 - **Errors are `Result<T, E>`** through the crate's error type and `?`.
-- **Input-derived numbers are hostile** (files, formulas, commands, MCP/control params): `get()` instead of indexing, checked/saturating arithmetic, cap input-sized allocations (huge ranges, `REPT`, `SEQUENCE`, whole-column references).
+- **Input-derived numbers are hostile** (files, formulas, commands, MCP/control params): validate indexes and ranges before access, use checked access when validity is not established, use checked/saturating arithmetic, and cap input-sized allocations (huge ranges, `REPT`, `SEQUENCE`, whole-column references).
 - **Bound recursion** (formula nesting, dependency chains, names referring to names).
 - **Last-resort guard:** `Session::execute` catches escaped panics and restores the workbook. It's a safety net, not a licence.
 - **Prove it:** every crash fix lands with a regression test (`tests::every_command_survives_empty_params` fuzzes every command; `crates/engine/tests/it/command_sequence_fuzz.rs` fuzzes random command sequences against undo/redo, XLSX round-trip and full-recalc invariants; soak it with `GRIDCRAFT_FUZZ_SEEDS`/`GRIDCRAFT_FUZZ_STEPS`, replay with `GRIDCRAFT_FUZZ_SEED`).
diff --git a/CLAUDE.md b/CLAUDE.md
index 8bf527c54..266016a1a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -27,7 +27,7 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr
 - **Bound recursion** (formula nesting, dependency chains, names referring to names).
 - **Last-resort guard:** `Session::execute` catches escaped panics and restores the workbook. It's a safety net, not a licence.
 - **Prove it:** every crash fix lands with a regression test (`tests::every_command_survives_empty_params` fuzzes every command; `crates/engine/tests/it/command_sequence_fuzz.rs` fuzzes random command sequences against undo/redo, XLSX round-trip and full-recalc invariants; soak it with `GRIDCRAFT_FUZZ_SEEDS`/`GRIDCRAFT_FUZZ_STEPS`, replay with `GRIDCRAFT_FUZZ_SEED`).
-- Crates carry `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`.
+- Production crate roots carry `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`; every new workspace crate must also include `[lints] workspace = true` in `Cargo.toml` to inherit `[workspace.lints]`.
 
 ## Non-negotiables
 - **Clean-room.** Microsoft Excel is installed on the dev machine and may be *observed* black-box: run it, use its UI with synthetic workbooks, take screenshots (by window id) stored only under `plan/excel/screenshots/`. Never read, disassemble or copy anything inside the Office bundle, never commit files produced by Excel, never copy GPL/AGPL/LGPL code (LibreOffice, Gnumeric…). Function behaviour comes from public documentation and observation.
diff --git a/Cargo.lock b/Cargo.lock
index 87ff12215..f5a6a6328 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2024,6 +2024,7 @@ dependencies = [
  "serde",
  "serde_json",
  "thiserror 2.0.21",
+ "web-time",
  "zip 3.0.0",
 ]
 
@@ -2097,6 +2098,7 @@ dependencies = [
  "sys-locale",
  "toml",
  "web-sys",
+ "web-time",
  "zbus",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 32823c84a..4bafc9b27 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,8 @@ serde = { version = "1", features = ["derive", "rc"] }
 serde_json = { version = "1", features = ["float_roundtrip"] }
 log = "0.4"
 # All date/time conversion goes through chrono (no hand-rolled calendar code beyond the 400-year range extension; AGENTS.md).
-chrono = { version = "0.4.45", default-features = false, features = ["std"] }
+chrono = { version = "0.4.45", default-features = false, features = ["std", "clock"] }
+web-time = "1.1.0"
 rayon = "1"
 regex = { version = "1", default-features = false, features = ["std", "unicode", "perf"] }
 quick-xml = "0.41"
@@ -67,10 +68,11 @@ craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-li
 unsafe_code = "forbid"
 
 [workspace.lints.clippy]
+cognitive_complexity = "deny"
+too_many_arguments = "deny"
+wildcard_imports = "deny"
 dbg_macro = "warn"
 todo = "warn"
-too_many_arguments = "allow"
-type_complexity = "allow"
 
 [profile.dev.package."*"]
 opt-level = 2
diff --git a/apps/gridcraft-cli/src/check/fidelity.rs b/apps/gridcraft-cli/src/check/fidelity.rs
index 446a8949a..d8def2747 100644
--- a/apps/gridcraft-cli/src/check/fidelity.rs
+++ b/apps/gridcraft-cli/src/check/fidelity.rs
@@ -1,6 +1,6 @@
 use super::calc::formula_text;
 use super::package::{REBUILT_KINDS, relationship_kinds, validate_package};
-use super::*;
+use super::{BTreeSet, Category, Cell, CellError, CellRef, Diffs, Options, RoundTrip, Sheet, Value, Workbook, number_text, quote_sheet};
 
 // ---------------------------------------------------------------- round trip
 
diff --git a/apps/gridcraft-cli/src/check/package.rs b/apps/gridcraft-cli/src/check/package.rs
index bcbbef10f..6b97fa495 100644
--- a/apps/gridcraft-cli/src/check/package.rs
+++ b/apps/gridcraft-cli/src/check/package.rs
@@ -20,7 +20,9 @@ fn local_name(name: &[u8]) -> &[u8] {
 }
 
 /// `(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> {
+type XmlElement = (String, Vec<(String, String)>);
+
+fn xml_elements(xml: &[u8]) -> Result<Vec<XmlElement>, String> {
     use quick_xml::events::Event;
     let mut reader = quick_xml::Reader::from_reader(xml);
     let mut buf = Vec::new();
diff --git a/apps/gridcraft-cli/src/check/report.rs b/apps/gridcraft-cli/src/check/report.rs
index 54227e797..6c0d6b36d 100644
--- a/apps/gridcraft-cli/src/check/report.rs
+++ b/apps/gridcraft-cli/src/check/report.rs
@@ -131,7 +131,7 @@ fn fit(s: &str, w: usize) -> String {
     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) {
+fn print_file_reports(reports: &[FileReport]) {
     for r in reports {
         outln!("== {}", r.path);
         if let Some(e) = &r.error {
@@ -186,7 +186,9 @@ pub(super) fn print_human(reports: &[FileReport], opts: &Options) {
             }
         }
     }
-    outln!("");
+}
+
+fn print_file_table(reports: &[FileReport]) {
     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",
@@ -220,7 +222,9 @@ pub(super) fn print_human(reports: &[FileReport], opts: &Options) {
             c.volatile
         );
     }
-    let t = totals(reports);
+}
+
+fn print_rankings(t: &Totals, opts: &Options) {
     let top = ranked(&t.functions);
     if !top.is_empty() {
         outln!("");
@@ -239,6 +243,9 @@ pub(super) fn print_human(reports: &[FileReport], opts: &Options) {
             outln!("  {n:>8}  {sig}");
         }
     }
+}
+
+fn print_totals(t: &Totals) {
     outln!("");
     outln!("files: {} ({} opened, {} failed to open)", t.files, t.opened, t.failed);
     outln!(
@@ -262,3 +269,12 @@ pub(super) fn print_human(reports: &[FileReport], opts: &Options) {
         if cats.is_empty() { String::new() } else { format!("; categories (files): {}", cats.join(", ")) }
     );
 }
+
+pub(super) fn print_human(reports: &[FileReport], opts: &Options) {
+    print_file_reports(reports);
+    outln!("");
+    print_file_table(reports);
+    let t = totals(reports);
+    print_rankings(&t, opts);
+    print_totals(&t);
+}
diff --git a/apps/gridcraft-cli/tests/it/main.rs b/apps/gridcraft-cli/tests/it/main.rs
index 17f8db87f..5906b3967 100644
--- a/apps/gridcraft-cli/tests/it/main.rs
+++ b/apps/gridcraft-cli/tests/it/main.rs
@@ -1,5 +1,3 @@
 //! The crate's integration tests, one module per file, built as one test binary.
-
-#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 mod cli;
 mod text_to_columns_quotes;
diff --git a/apps/gridcraft/src/logging.rs b/apps/gridcraft/src/logging.rs
index 413797378..ca7d05717 100644
--- a/apps/gridcraft/src/logging.rs
+++ b/apps/gridcraft/src/logging.rs
@@ -268,9 +268,10 @@ impl log::Log for AppLogger {
         }
         // Formatted before the sink is locked, so a message that logs while it is formatted can't deadlock.
         let thread = std::thread::current();
-        #[allow(clippy::disallowed_methods)] // the desktop app (native only): wasm never runs it
-        let line =
-            format_line(&timestamp(SystemTime::now()), record.level(), thread.name().unwrap_or("?"), record.target(), &record.args().to_string());
+        let logged_at = gridcraft_engine::core::date::unix_now_ms()
+            .and_then(|milliseconds| SystemTime::UNIX_EPOCH.checked_add(std::time::Duration::from_millis(milliseconds.max(0.0) as u64)))
+            .unwrap_or(SystemTime::UNIX_EPOCH);
+        let line = format_line(&timestamp(logged_at), record.level(), thread.name().unwrap_or("?"), record.target(), &record.args().to_string());
         if self.stderr {
             // No terminal (a Windows GUI build, a closed pipe) is not an error worth reporting.
             let _ = std::io::stderr().write_all(line.as_bytes());
diff --git a/apps/gridcraft/tests/mac_menu_appkit.rs b/apps/gridcraft/tests/mac_menu_appkit.rs
index e713f6699..8b132fd05 100644
--- a/apps/gridcraft/tests/mac_menu_appkit.rs
+++ b/apps/gridcraft/tests/mac_menu_appkit.rs
@@ -7,7 +7,6 @@
 // unit tests compile here too without a harness to run them).
 #[cfg(target_os = "macos")]
 #[path = "../src/native_menu.rs"]
-#[allow(unused_imports, dead_code)]
 mod native_menu;
 
 #[cfg(target_os = "macos")]
diff --git a/clippy.toml b/clippy.toml
index de0f11db4..c6fbddafd 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -14,3 +14,4 @@ disallowed-methods = [
 disallowed-types = [
     { path = "egui::ComboBox", reason = "use craft_ui::ComboBox: egui's combo box menu can't grow back while open (egui#5225)" },
 ]
+cognitive-complexity-threshold = 30
diff --git a/crates/calc/src/eval.rs b/crates/calc/src/eval.rs
index 45d81ccca..4972623fc 100644
--- a/crates/calc/src/eval.rs
+++ b/crates/calc/src/eval.rs
@@ -7,7 +7,7 @@
 use std::sync::Arc;
 
 use gridcraft_core::{Array, CellError, CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value, compare};
-use gridcraft_formula::{BinOp, Expr, RefKind, Reference, SheetSel, StructItem, StructRef, UnOp};
+use gridcraft_formula::{BinOp, Expr, Reference, SheetSel, StructItem, StructRef, UnOp};
 use gridcraft_functions::{Arg, Ctx};
 use gridcraft_model::Workbook;
 
diff --git a/crates/calc/src/eval/array.rs b/crates/calc/src/eval/array.rs
index b17a8c70f..ab6ac1b06 100644
--- a/crates/calc/src/eval/array.rs
+++ b/crates/calc/src/eval/array.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Array, BinOp, CellError, MAX_CELLS, Value, compare};
 
 /// The aggregates that can fold a reference without building an array.
 #[derive(Clone, Copy, PartialEq, Eq)]
diff --git a/crates/calc/src/eval/call.rs b/crates/calc/src/eval/call.rs
index 9013ca882..08d563d43 100644
--- a/crates/calc/src/eval/call.rs
+++ b/crates/calc/src/eval/call.rs
@@ -1,40 +1,13 @@
 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::*;
+use super::{Area, Arg, Array, CellError, Ev, Evaluator, Expr, FnCtx, Lambda, Pipe, Value, compare, err};
+use std::sync::Arc;
 
 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),
-                }
-            }
+            "IF" => self.if_call(args),
             "IFS" => {
                 if args.len() < 2 || !args.len().is_multiple_of(2) {
                     return err(CellError::Value);
@@ -50,101 +23,10 @@ impl<'h> Evaluator<'h> {
                 }
                 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),
-                }
-            }
+            "IFERROR" | "IFNA" => self.if_error_call(name, args),
+            "CHOOSE" => self.choose_call(args),
+            "SWITCH" => self.switch_call(args),
+            "ROW" | "COLUMN" => self.row_column_call(name, args),
             "ROWS" | "COLUMNS" => {
                 if args.len() != 1 {
                     return err(CellError::Value);
@@ -180,28 +62,7 @@ impl<'h> Evaluator<'h> {
                     }
                 }
             }
-            "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),
-                }
-            }
+            "SHEET" | "SHEETS" => self.sheet_call(name, args),
             "OFFSET" => self.offset(args),
             "INDIRECT" => self.indirect(args),
             "INDEX" => self.index(args),
@@ -273,6 +134,156 @@ impl<'h> Evaluator<'h> {
         }
     }
 
+    fn if_call(&mut self, args: &[Expr]) -> Ev {
+        if args.is_empty() || args.len() > 3 {
+            return err(CellError::Value);
+        }
+        let condition = self.arg_val(args, 0).unwrap_or_default();
+        if let Value::Array(array) = &condition {
+            let when_true = self.arg_val(args, 1).unwrap_or(Value::Bool(true));
+            let when_false = if args.len() > 2 { self.arg_val(args, 2).unwrap_or(Value::Bool(false)) } else { Value::Bool(false) };
+            return Ev::V(zip3(array, &when_true, &when_false, |condition, when_true, when_false| match condition.to_bool() {
+                Ok(true) => when_true.clone(),
+                Ok(false) => when_false.clone(),
+                Err(error) => Value::Error(error),
+            }));
+        }
+        match condition.to_bool() {
+            Ok(true) => match args.get(1) {
+                Some(Expr::Missing) => Ev::V(Value::Number(0.0)),
+                Some(expression) => self.eval(expression),
+                None => Ev::V(Value::Bool(true)),
+            },
+            Ok(false) => match args.get(2) {
+                Some(Expr::Missing) => Ev::V(Value::Number(0.0)),
+                Some(expression) => self.eval(expression),
+                None => Ev::V(Value::Bool(false)),
+            },
+            Err(error) => err(error),
+        }
+    }
+
+    fn if_error_call(&mut self, name: &str, args: &[Expr]) -> Ev {
+        if args.len() != 2 {
+            return err(CellError::Value);
+        }
+        let value = self.arg_ev(args, 0).unwrap_or(Ev::V(Value::Empty));
+        let na_only = name == "IFNA";
+        let catches = |error: CellError| !na_only || error == CellError::NA;
+        match &value {
+            Ev::V(Value::Error(error)) if catches(*error) => self.eval(&args[1]),
+            Ev::V(Value::Array(array)) if array.data.iter().any(|item| item.as_error().is_some_and(catches)) => {
+                let alternate = self.arg_val(args, 1).unwrap_or_default();
+                let data =
+                    array.data.iter().map(|item| if item.as_error().is_some_and(catches) { alternate.scalar() } else { item.clone() }).collect();
+                Ev::V(Array::new(array.rows, array.cols, data).map(Value::from).unwrap_or(Value::Error(CellError::Value)))
+            }
+            Ev::R(_) => self.if_error_reference(value.clone(), args, catches),
+            _ => value,
+        }
+    }
+
+    fn if_error_reference(&mut self, value: Ev, args: &[Expr], catches: impl Fn(CellError) -> bool + Copy) -> Ev {
+        match self.deref(value.clone()) {
+            Value::Error(error) if catches(error) => self.eval(&args[1]),
+            Value::Array(ref array) if array.data.iter().any(|item| item.as_error().is_some_and(catches)) => {
+                let alternate = self.arg_val(args, 1).unwrap_or_default();
+                let data =
+                    array.data.iter().map(|item| if item.as_error().is_some_and(catches) { alternate.scalar() } else { item.clone() }).collect();
+                Ev::V(Array::new(array.rows, array.cols, data).map(Value::from).unwrap_or(Value::Error(CellError::Value)))
+            }
+            _ => value,
+        }
+    }
+
+    fn choose_call(&mut self, args: &[Expr]) -> Ev {
+        if args.len() < 2 {
+            return err(CellError::Value);
+        }
+        let index = self.value(&args[0]);
+        if let Value::Array(_) = index {
+            let Some(spec) = gridcraft_functions::lookup("CHOOSE") else { return err(CellError::Name) };
+            let mut evaluated = vec![Arg { value: index, from_ref: false }];
+            for argument in &args[1..] {
+                evaluated.push(Arg { value: self.value(argument), from_ref: false });
+            }
+            let mut context = FnCtx { ev: self, criteria: None, lambda: None };
+            return gridcraft_functions::call(spec, &evaluated, &mut context).pipe(Ev::V);
+        }
+        let index = match index.to_number() {
+            Ok(number) => number.trunc() as i64,
+            Err(error) => return err(error),
+        };
+        if index < 1 || index as usize >= args.len() {
+            return err(CellError::Value);
+        }
+        self.eval(&args[index as usize])
+    }
+
+    fn switch_call(&mut self, args: &[Expr]) -> Ev {
+        if args.len() < 3 {
+            return err(CellError::Value);
+        }
+        let value = self.arg_val(args, 0).unwrap_or_default().scalar();
+        if let Value::Error(error) = value {
+            return err(error);
+        }
+        let choices = &args[1..];
+        for pair in choices.as_chunks::<2>().0 {
+            let (candidate, result) = (&pair[0], &pair[1]);
+            let candidate = self.value(candidate).scalar();
+            if !candidate.is_error() && compare(&value, &candidate) == std::cmp::Ordering::Equal && same_kind(&value, &candidate) {
+                return self.eval(result);
+            }
+        }
+        if let Some(default) = choices.get(choices.len().saturating_sub(1)).filter(|_| choices.len() % 2 == 1) {
+            self.eval(default)
+        } else {
+            err(CellError::NA)
+        }
+    }
+
+    fn row_column_call(&mut self, name: &str, args: &[Expr]) -> Ev {
+        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));
+        }
+        let areas = match self.eval(&args[0]) {
+            Ev::R(areas) => areas,
+            Ev::V(Value::Error(error)) => return err(error),
+            _ => return err(CellError::Value),
+        };
+        let Some(area) = areas.first() else { return err(CellError::Ref) };
+        let range = self.trim_lines(area);
+        if is_row {
+            let values: Vec<Value> = (range.start.row..=range.end.row).map(|row| Value::number(row as f64 + 1.0)).collect();
+            if values.len() == 1 { Ev::V(values.into_iter().next().unwrap_or_default()) } else { Ev::V(Array::column(values).into()) }
+        } else {
+            let values: Vec<Value> = (range.start.col..=range.end.col).map(|col| Value::number(col as f64 + 1.0)).collect();
+            if values.len() == 1 { Ev::V(values.into_iter().next().unwrap_or_default()) } else { Ev::V(Array::row(values).into()) }
+        }
+    }
+
+    fn sheet_call(&mut self, name: &str, args: &[Expr]) -> Ev {
+        let is_sheet = name == "SHEET";
+        if args.is_empty() {
+            let count = if is_sheet { self.sheet + 1 } else { self.host.workbook().sheets.len() };
+            return Ev::V(Value::number(count as f64));
+        }
+        match self.eval(&args[0]) {
+            Ev::R(areas) if is_sheet => areas.first().map_or(err(CellError::Ref), |area| Ev::V(Value::number(area.sheet as f64 + 1.0))),
+            Ev::R(areas) => {
+                let mut sheets: Vec<usize> = areas.iter().map(|area| area.sheet).collect();
+                sheets.dedup();
+                Ev::V(Value::number(sheets.len() as f64))
+            }
+            Ev::V(Value::Text(name)) if is_sheet => {
+                self.host.workbook().sheet_index(&name).map_or(err(CellError::NA), |index| Ev::V(Value::number(index as f64 + 1.0)))
+            }
+            _ => err(CellError::NA),
+        }
+    }
+
     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.
diff --git a/crates/calc/src/eval/format.rs b/crates/calc/src/eval/format.rs
index a4c52b492..a288b410e 100644
--- a/crates/calc/src/eval/format.rs
+++ b/crates/calc/src/eval/format.rs
@@ -1,4 +1,5 @@
-use super::*;
+use super::{CellError, Value};
+use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS};
 
 /// CELL("format") code for a number format.
 pub(super) fn cell_format_code(code: &str) -> String {
diff --git a/crates/calc/src/eval/lambda.rs b/crates/calc/src/eval/lambda.rs
index 45f99b488..dfb30029a 100644
--- a/crates/calc/src/eval/lambda.rs
+++ b/crates/calc/src/eval/lambda.rs
@@ -1,5 +1,7 @@
+use super::MAX_LAMBDA_CALLS;
 use super::array::{broadcast_len, single};
-use super::*;
+use super::{Array, CellError, Ev, Evaluator, Expr, Lambda, MAX_CELLS, Value, err};
+use std::sync::Arc;
 
 impl<'h> Evaluator<'h> {
     pub fn apply_lambda(&mut self, l: &Lambda, args: &[Expr]) -> Ev {
diff --git a/crates/calc/src/eval/reference_fns.rs b/crates/calc/src/eval/reference_fns.rs
index a21797c23..4f5154c2d 100644
--- a/crates/calc/src/eval/reference_fns.rs
+++ b/crates/calc/src/eval/reference_fns.rs
@@ -1,5 +1,7 @@
 use super::format::{cell_format_code, r1c1_to_a1};
-use super::*;
+use super::{Area, Arg, Array, CellError, Ev, Evaluator, Expr, FnCtx, MAX_CELLS, Value, err};
+use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef};
+use std::sync::Arc;
 
 impl<'h> Evaluator<'h> {
     /// Whole rows/columns trimmed for ROW()/COLUMN() arrays.
diff --git a/crates/calc/src/eval/special.rs b/crates/calc/src/eval/special.rs
index f68badbfc..0151ea2f9 100644
--- a/crates/calc/src/eval/special.rs
+++ b/crates/calc/src/eval/special.rs
@@ -1,4 +1,5 @@
-use super::*;
+use super::{Area, BinOp, Ev, Expr, Reference, SheetSel, Value, Workbook};
+use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef};
 
 /// 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 {
@@ -162,6 +163,3 @@ pub const SPECIAL_FUNCTIONS: &[&str] = &[
 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) {}
diff --git a/crates/calc/src/recalc.rs b/crates/calc/src/recalc.rs
index b7f403131..eb11045db 100644
--- a/crates/calc/src/recalc.rs
+++ b/crates/calc/src/recalc.rs
@@ -10,14 +10,13 @@
 //! and the formulas that read one are evaluated again until the loop settles
 //! (`PassHost::iterate_loops`).
 
-use std::collections::{BTreeSet, VecDeque};
-use std::hash::{BuildHasherDefault, Hasher};
+use std::collections::VecDeque;
 
 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};
+use crate::eval::{Evaluator, Host, precedents, stack_position};
 
 mod graph;
 mod pass_host;
@@ -368,105 +367,13 @@ impl Calc {
                 self.circular.retain(|k| !evaluated.contains(k));
             }
             self.circular.extend(cycles);
-            // Write back.
-            let mut spill_changes: Vec<Key> = Vec::new();
-            let mut freed: Vec<(usize, RangeRef)> = Vec::new();
-            for (k, v) in results {
-                let Some(sheet) = wb.sheet_mut(k.0) else { continue };
-                if let Some(cell) = sheet.cells.get_mut(k.1)
-                    && cell.value != v
-                {
-                    cell.value = v;
-                }
-            }
-            for k in &dirty {
-                let new = spills.get(k);
-                let Some(sheet) = wb.sheet_mut(k.0) else { continue };
-                let old = sheet.spill_ranges.get(&k.1).copied();
-                if old.is_none() && new.is_none() {
-                    continue;
-                }
-                // An array that spills exactly as before changes nothing its dependents read, so
-                // they aren't queued again. Otherwise two arrays that read each other's spill areas
-                // queue each other in every round, up to the round limit.
-                if let (Some(r), Some(arr)) = (old, new)
-                    && spills_as_before(sheet, k.1, r, arr)
-                {
-                    continue;
-                }
-                if let Some(r) = old {
-                    for c in r.iter() {
-                        sheet.spill.remove(&c);
-                    }
-                    sheet.spill_ranges.remove(&k.1);
-                }
-                let mut changed_range = old;
-                if let Some(arr) = new {
-                    let end = CellRef::new(k.1.row.saturating_add(arr.rows as u32 - 1), k.1.col.saturating_add(arr.cols as u32 - 1));
-                    let range = RangeRef::new(k.1, end);
-                    let blocked = end.row >= gridcraft_core::MAX_ROWS
-                        || end.col >= gridcraft_core::MAX_COLS
-                        || range.iter().any(|c| c != k.1 && (sheet.cells.has(c) || sheet.spill.contains_key(&c)))
-                        || sheet.merges.iter().any(|m| m.intersects(&range))
-                        || sheet.tables.iter().any(|t| t.range.contains(k.1));
-                    if blocked {
-                        if let Some(cell) = sheet.cells.get_mut(k.1) {
-                            cell.value = Value::Error(CellError::Spill);
-                        }
-                        // Not blocked while the pass ran (it would have been #SPILL! there), so
-                        // blocked by another array of this pass: the formulas that read this one,
-                        // at its anchor or over the area it would have spilled into, read #SPILL!
-                        // or empty cells now.
-                        let mut deps = Vec::new();
-                        self.graph.dependents_of_range(k.0, range, &mut deps);
-                        spill_changes.extend(deps.into_iter().filter(|d| d != k));
-                    } else {
-                        for (i, c) in range.iter().enumerate() {
-                            if c != k.1 {
-                                sheet.spill.insert(c, arr.data.get(i).cloned().unwrap_or_default());
-                            }
-                        }
-                        sheet.spill_ranges.insert(k.1, range);
-                        changed_range = Some(changed_range.map_or(range, |o| o.union(&range)));
-                    }
-                }
-                if let Some(r) = changed_range {
-                    let mut deps = Vec::new();
-                    self.graph.dependents_of_range(k.0, r, &mut deps);
-                    // Not the anchor itself (that would read its own array), unless its old array
-                    // is gone or partly freed: its new formula may have read the old values, still
-                    // laid out while it was evaluated.
-                    let freed = match (old, sheet.spill_ranges.get(&k.1)) {
-                        (Some(o), Some(n)) => !(n.contains(o.start) && n.contains(o.end)),
-                        (_, None) => true,
-                        (None, Some(_)) => false,
-                    };
-                    spill_changes.extend(deps.into_iter().filter(|d| d != k || freed));
-                }
-                if let Some(o) = old
-                    && !sheet.spill_ranges.get(&k.1).is_some_and(|n| n.contains(o.start) && n.contains(o.end))
-                {
-                    freed.push((k.0, o));
-                }
-            }
+            let mut spill_changes = self.write_back(wb, &dirty, results, &spills);
             // Formulas with references only known while evaluating (INDIRECT, OFFSET) may have read
             // a spill area before it was laid out: they are evaluated once more.
             if dynamic_again && !spills.is_empty() {
                 dynamic_again = false;
                 spill_changes.extend(self.graph.dynamic.iter().copied());
             }
-            // An area a formula no longer spills over may unblock another formula's array.
-            for (si, o) in freed {
-                for &(s, c) in self.graph.nodes.keys() {
-                    if s == si
-                        && c.row <= o.end.row
-                        && c.col <= o.end.col
-                        && wb.sheet(s).is_some_and(|sh| sh.value(c) == Value::Error(CellError::Spill))
-                    {
-                        spill_changes.push((s, c));
-                    }
-                }
-            }
             if full {
                 // Everything was already evaluated once; spill dependents need another pass.
             }
@@ -488,6 +395,105 @@ impl Calc {
             self.circular.retain(|k| self.graph.nodes.contains_key(k));
         }
     }
+
+    fn write_back(
+        &mut self,
+        wb: &mut Workbook,
+        dirty: &[Key],
+        results: HashMap<Key, Value>,
+        spills: &HashMap<Key, std::sync::Arc<Array>>,
+    ) -> Vec<Key> {
+        let mut spill_changes = Vec::new();
+        let mut freed = Vec::new();
+        for (key, value) in results {
+            let Some(sheet) = wb.sheet_mut(key.0) else { continue };
+            if let Some(cell) = sheet.cells.get_mut(key.1)
+                && cell.value != value
+            {
+                cell.value = value;
+            }
+        }
+        for key in dirty {
+            let new = spills.get(key);
+            let Some(sheet) = wb.sheet_mut(key.0) else { continue };
+            let old = sheet.spill_ranges.get(&key.1).copied();
+            if old.is_none() && new.is_none() {
+                continue;
+            }
+            // An unchanged spill does not alter any values its dependents read.
+            if let (Some(range), Some(array)) = (old, new)
+                && spills_as_before(sheet, key.1, range, array)
+            {
+                continue;
+            }
+            if let Some(range) = old {
+                for cell in range.iter() {
+                    sheet.spill.remove(&cell);
+                }
+                sheet.spill_ranges.remove(&key.1);
+            }
+            let mut changed_range = old;
+            if let Some(array) = new {
+                let end = CellRef::new(key.1.row.saturating_add(array.rows as u32 - 1), key.1.col.saturating_add(array.cols as u32 - 1));
+                let range = RangeRef::new(key.1, end);
+                let blocked = spill_is_blocked(sheet, key.1, range, end);
+                if blocked {
+                    if let Some(cell) = sheet.cells.get_mut(key.1) {
+                        cell.value = Value::Error(CellError::Spill);
+                    }
+                    let mut blocked_dependents = Vec::new();
+                    self.graph.dependents_of_range(key.0, range, &mut blocked_dependents);
+                    spill_changes.extend(blocked_dependents.into_iter().filter(|dependent| dependent != key));
+                } else {
+                    fill_spill(sheet, key.1, range, array);
+                    changed_range = Some(changed_range.map_or(range, |previous| previous.union(&range)));
+                }
+            }
+            if let Some(range) = changed_range {
+                let mut dependents = Vec::new();
+                self.graph.dependents_of_range(key.0, range, &mut dependents);
+                let freed_old_range = match (old, sheet.spill_ranges.get(&key.1)) {
+                    (Some(previous), Some(current)) => !(current.contains(previous.start) && current.contains(previous.end)),
+                    (_, None) => true,
+                    (None, Some(_)) => false,
+                };
+                spill_changes.extend(dependents.into_iter().filter(|dependent| dependent != key || freed_old_range));
+            }
+            if let Some(previous) = old
+                && !sheet.spill_ranges.get(&key.1).is_some_and(|current| current.contains(previous.start) && current.contains(previous.end))
+            {
+                freed.push((key.0, previous));
+            }
+        }
+        for (sheet_index, range) in freed {
+            for &(sheet, cell) in self.graph.nodes.keys() {
+                let was_blocked_cell = cell.row <= range.end.row
+                    && cell.col <= range.end.col
+                    && wb.sheet(sheet).is_some_and(|sheet| sheet.value(cell) == Value::Error(CellError::Spill));
+                if sheet == sheet_index && was_blocked_cell {
+                    spill_changes.push((sheet, cell));
+                }
+            }
+        }
+        spill_changes
+    }
+}
+
+fn spill_is_blocked(sheet: &gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, end: CellRef) -> bool {
+    end.row >= gridcraft_core::MAX_ROWS
+        || end.col >= gridcraft_core::MAX_COLS
+        || range.iter().any(|cell| cell != anchor && (sheet.cells.has(cell) || sheet.spill.contains_key(&cell)))
+        || sheet.merges.iter().any(|merge| merge.intersects(&range))
+        || sheet.tables.iter().any(|table| table.range.contains(anchor))
+}
+
+fn fill_spill(sheet: &mut gridcraft_model::Sheet, anchor: CellRef, range: RangeRef, array: &Array) {
+    for (index, cell) in range.iter().enumerate() {
+        if cell != anchor {
+            sheet.spill.insert(cell, array.data.get(index).cloned().unwrap_or_default());
+        }
+    }
+    sheet.spill_ranges.insert(anchor, range);
 }
 
 /// Current date-time as a serial (1900 system), from the system clock (browser clock on wasm).
@@ -513,21 +519,13 @@ pub fn evaluate_expr(wb: &Workbook, sheet: usize, at: CellRef, expr: &Expr) -> V
     ev.value(expr)
 }
 
-#[allow(clippy::disallowed_methods)] // the clock is read only off wasm
 fn prof_now() -> f64 {
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs_f64() * 1000.0).unwrap_or(0.0)
-    }
-    #[cfg(target_arch = "wasm32")]
-    {
-        0.0
-    }
+    gridcraft_core::date::unix_now_ms().unwrap_or(0.0)
 }
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use std::time::{Duration, Instant};
+    use std::time::Duration;
 
     use gridcraft_core::{CellRef, RangeRef, Value};
     use gridcraft_model::{Cell, Formula, Workbook};
@@ -640,11 +638,10 @@ pub(crate) mod tests {
     }
 
     /// Opening (full recalc), changing every value of a column, and re-entering every formula.
-    #[allow(clippy::disallowed_methods)] // a native-only timing test: the clock is read off wasm
     fn open_and_bulk_edit(rows: u32) -> Duration {
         let mut wb = sum_rows(rows);
         let mut calc = Calc::new();
-        let t = Instant::now();
+        let started = gridcraft_core::date::unix_now_ms().unwrap_or(0.0);
         calc.recalc_all(&mut wb);
         let values: Vec<Key> = (0..rows).map(|r| (0, CellRef::new(r, 4))).collect();
         if let Some(sh) = wb.sheet_mut(0) {
@@ -655,7 +652,8 @@ pub(crate) mod tests {
         calc.cells_changed(&mut wb, &values);
         let formulas: Vec<Key> = (0..rows).map(|r| (0, CellRef::new(r, 10))).collect();
         calc.cells_changed(&mut wb, &formulas);
-        let elapsed = t.elapsed();
+        let ended = gridcraft_core::date::unix_now_ms().unwrap_or(started);
+        let elapsed = Duration::from_secs_f64((ended - started).max(0.0) / 1000.0);
         let last = wb.sheet(0).map(|s| s.value(CellRef::new(rows - 1, 10)));
         let r = rows - 1;
         assert_eq!(last, Some(Value::Number(f64::from(1 + (5..10).map(|c| r % 97 + c).sum::<u32>()))));
@@ -670,7 +668,6 @@ pub(crate) mod tests {
 
     #[test]
     #[ignore = "timing-sensitive; run with --ignored in release"]
-    #[allow(clippy::disallowed_methods)]
     fn recalc_with_range_formulas_scales_linearly() {
         // Each row's SUM reads a range in the same columns. Recalculating on open used to walk
         // every row per range read (the used range), and finding a cell's dependents scanned
diff --git a/crates/calc/src/recalc/graph.rs b/crates/calc/src/recalc/graph.rs
index aee4b46d5..ab034f8cc 100644
--- a/crates/calc/src/recalc/graph.rs
+++ b/crates/calc/src/recalc/graph.rs
@@ -1,4 +1,8 @@
-use super::*;
+use super::RangeRef;
+use crate::eval::Area;
+use gridcraft_core::CellRef;
+use std::collections::BTreeSet;
+use std::hash::{BuildHasherDefault, Hasher};
 
 /// A fast, non-cryptographic hasher for cell keys (FxHash-style multiply-rotate).
 #[derive(Default, Clone, Copy)]
@@ -179,6 +183,9 @@ pub struct Graph {
     unsettled_wide: HashSet<usize>,
 }
 
+/// A formula's precedents split by shape: single cells, column intervals and wide ranges.
+type Entries = (Vec<Key>, Vec<(usize, u32, u32, u32)>, Vec<(usize, RangeRef)>);
+
 impl Graph {
     pub fn len(&self) -> usize {
         self.nodes.len()
@@ -189,7 +196,7 @@ impl Graph {
 
     /// 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)>) {
+    fn entries(areas: &[Area]) -> Entries {
         let (mut cells, mut cols, mut wide) = (Vec::new(), Vec::new(), Vec::new());
         for a in areas {
             if a.range.is_single() {
diff --git a/crates/calc/src/recalc/pass_host.rs b/crates/calc/src/recalc/pass_host.rs
index 00e92e82b..6aa8a1204 100644
--- a/crates/calc/src/recalc/pass_host.rs
+++ b/crates/calc/src/recalc/pass_host.rs
@@ -1,5 +1,7 @@
 use super::graph::{HashMap, HashSet, Key};
-use super::*;
+use super::{Evaluator, Host, Workbook, stack_position};
+use gridcraft_core::{Array, CellError, CellRef, RangeRef, Value};
+use gridcraft_formula::Expr;
 
 /// 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
diff --git a/crates/chart/src/render.rs b/crates/chart/src/render.rs
index 76a1619e3..6a64558a1 100644
--- a/crates/chart/src/render.rs
+++ b/crates/chart/src/render.rs
@@ -1,9 +1,8 @@
 //! Chart layout: title, legend, axes and every chart kind, drawn into [`Prim`]s.
 
-use std::collections::HashSet;
 use std::f32::consts::{PI, TAU};
 
-use gridcraft_model::{Chart, ChartKind, LegendPos, LineDash, QuartileMethod, Theme, TrendlineKind};
+use gridcraft_model::{Chart, ChartKind, LineDash, QuartileMethod, Theme, TrendlineKind};
 
 use crate::axis::{Fmt, Scale, clean, fixed_scale, nice_scale};
 use crate::resolve::{MAX_POINTS, MAX_SERIES, MAX_TRENDLINES, series_color};
@@ -70,8 +69,7 @@ impl Ctx<'_> {
         }
         String::new()
     }
-    #[allow(clippy::too_many_arguments)]
-    fn text(&mut self, x: f32, y: f32, s: &str, size: f32, color: Rgba, align: HAlign, valign: VAlign) {
+    fn text(&mut self, x: f32, y: f32, s: &str, size: f32, color: Rgba, (align, valign): (HAlign, VAlign)) {
         if s.is_empty() {
             return;
         }
@@ -135,7 +133,7 @@ pub fn render(chart: &Chart, data: &ChartData, w: f32, h: f32, m: &dyn Measure)
     if let Some(t) = chart_title(chart, &data) {
         let size = TITLE_SIZE.min(h * 0.12).max(4.0);
         let t = ctx.fit(&t, size, area.w);
-        ctx.text(w / 2.0, area.y, &t, size, TEXT, HAlign::Center, VAlign::Top);
+        ctx.text(w / 2.0, area.y, &t, size, TEXT, (HAlign::Center, VAlign::Top));
         let used = size * 1.3 + 4.0;
         area.y += used;
         area.h -= used;
diff --git a/crates/chart/src/render/cartesian.rs b/crates/chart/src/render/cartesian.rs
index 85a577b08..d449498e7 100644
--- a/crates/chart/src/render/cartesian.rs
+++ b/crates/chart/src/render/cartesian.rs
@@ -2,7 +2,10 @@ 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::*;
+use super::{
+    Chart, ChartData, ChartKind, Ctx, Fmt, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_LINE_PTS, MAX_MARKERS, Prim, Scale, SeriesData, TEXT,
+    VAlign, WHITE, clean, fixed_scale, nice_scale,
+};
 
 // ---------------------------------------------------------------- cartesian (column/bar/line/area/combo)
 
@@ -18,6 +21,9 @@ enum Fam {
     Area100,
 }
 
+/// Stack accumulator: (axis, family) key with positive and negative running sums.
+type Stack = ((bool, Fam), Vec<f64>, Vec<f64>);
+
 fn family(k: ChartKind) -> Fam {
     use ChartKind::*;
     match k {
@@ -45,16 +51,7 @@ 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();
-
+fn series_spans(data: &ChartData, fams: &[Fam], sec: &[bool], ncat: usize) -> Vec<Vec<Option<(f64, f64)>>> {
     // 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() {
@@ -81,7 +78,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
         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 stacks: Vec<Stack> = 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);
@@ -126,6 +123,10 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
         spans.push(row);
     }
 
+    spans
+}
+
+fn axis_scales(data: &ChartData, fams: &[Fam], sec: &[bool], spans: &[Vec<Option<(f64, f64)>>]) -> Vec<(Scale, Fmt)> {
     // Axis scales.
     let mut axes: Vec<(Scale, Fmt)> = Vec::new();
     for axis in [false, true] {
@@ -151,6 +152,46 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
             break;
         }
     }
+    axes
+}
+
+fn column_slots(fams: &[Fam], sec: &[bool]) -> (Vec<usize>, f32) {
+    // 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; fams.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;
+        }
+    }
+    (slot_of, slot_keys.len().max(1) as f32)
+}
+
+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();
+
+    let spans = series_spans(data, &fams, &sec, ncat);
+
+    let axes = axis_scales(data, &fams, &sec, &spans);
     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 });
@@ -177,27 +218,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
     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 (slot_of, nslots) = column_slots(&fams, &sec);
     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.
@@ -275,20 +296,20 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
                             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);
+                                    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);
+                                    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);
+                                    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);
+                                    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);
+                                    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);
+                                    ctx.text(x, lo + len + 2.0, &t, LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Top));
                                 }
                             }
                         }
@@ -304,7 +325,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
                     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);
+                                ctx.text(p[0], p[1] - 5.0, &fmt.format(v, None), LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Bottom));
                             }
                         }
                     }
@@ -312,7 +333,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
             }
         }
         for (x, y, t) in area_labels.drain(..) {
-            ctx.text(x, y, &t, LABEL_SIZE, TEXT, HAlign::Center, VAlign::Bottom);
+            ctx.text(x, y, &t, LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Bottom));
         }
     }
     // Trendlines on top: x is the category number 1..n.
@@ -412,7 +433,7 @@ pub(super) fn scatter(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
         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);
+                    ctx.text(p[0], p[1] - 6.0, &fy.format(*y, None), LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Bottom));
                 }
             }
         }
diff --git a/crates/chart/src/render/frame.rs b/crates/chart/src/render/frame.rs
index 7fa2a54a1..0117423b3 100644
--- a/crates/chart/src/render/frame.rs
+++ b/crates/chart/src/render/frame.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{AXIS, AXIS_TITLE_SIZE, Chart, ChartData, Ctx, DARK_TEXT, Fmt, GRID, HAlign, LABEL_SIZE, PI, Prim, Rgba, Scale, TEXT, VAlign, WHITE};
 
 #[derive(Clone, Copy, Debug)]
 pub(super) struct Bx {
@@ -44,7 +44,7 @@ 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);
+        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()) {
@@ -123,12 +123,12 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
             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);
+            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);
+                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 };
@@ -142,7 +142,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
                 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);
+                    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.
@@ -152,7 +152,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
                         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);
+                            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);
@@ -169,7 +169,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
                 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);
+                    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;
@@ -202,7 +202,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
                 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);
+                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 };
@@ -213,7 +213,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
         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);
+            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.
@@ -224,7 +224,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
                 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);
+                    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);
diff --git a/crates/chart/src/render/kinds.rs b/crates/chart/src/render/kinds.rs
index 2ffbfa3dd..54ce6bec8 100644
--- a/crates/chart/src/render/kinds.rs
+++ b/crates/chart/src/render/kinds.rs
@@ -1,6 +1,9 @@
 use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range};
 use super::legend::{cat_label, point_color};
-use super::*;
+use super::{
+    AXIS, Chart, ChartData, Ctx, DOWN, Fmt, GRID, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_MARKERS, Prim, QuartileMethod, STOCK, SeriesData,
+    TAU, TEXT, UP, VAlign, WHITE, clean, nice_scale,
+};
 
 // ---------------------------------------------------------------- histogram
 
@@ -47,7 +50,7 @@ pub(super) fn histogram(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
         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);
+            ctx.text(x + cw / 2.0, top - 2.0, &c.to_string(), LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Bottom));
         }
     }
 }
@@ -110,7 +113,7 @@ pub(super) fn waterfall(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
         }
         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);
+            ctx.text(x + bw / 2.0, yb.min(yt) - 2.0, &f.format(v, None), LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Bottom));
         }
     }
 }
@@ -150,10 +153,10 @@ pub(super) fn funnel(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
             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);
+                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);
+            ctx.text(plot.x - 6.0, yc, &l, LABEL_SIZE, TEXT, (HAlign::Right, VAlign::Middle));
         }
     }
 }
@@ -194,7 +197,7 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne
         a += sweep;
     }
     for (x, y, t, c) in labels {
-        ctx.text(x, y, &t, LABEL_SIZE, c, HAlign::Center, VAlign::Middle);
+        ctx.text(x, y, &t, LABEL_SIZE, c, (HAlign::Center, VAlign::Middle));
     }
 }
 
@@ -281,11 +284,11 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
         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);
+            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);
+                ctx.text(b.x + 4.0, b.y + 4.0 + LABEL_SIZE * 1.4, &t, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top));
             }
         }
     }
@@ -325,7 +328,7 @@ pub(super) fn radar(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
             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);
+            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);
@@ -349,7 +352,7 @@ pub(super) fn radar(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
             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);
+        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();
diff --git a/crates/chart/src/render/legend.rs b/crates/chart/src/render/legend.rs
index 95cb39d48..fec1e4549 100644
--- a/crates/chart/src/render/legend.rs
+++ b/crates/chart/src/render/legend.rs
@@ -1,6 +1,10 @@
 use super::frame::Bx;
 use super::trend::supports_trendline;
-use super::*;
+use super::{
+    Chart, ChartData, ChartKind, Ctx, DOWN, HAlign, LABEL_SIZE, MAX_CATS, MAX_SERIES, MAX_TRENDLINES, Prim, Rgba, SeriesData, TEXT, Theme, UP,
+    VAlign, auto_name, series_color,
+};
+use gridcraft_model::LegendPos;
 
 /// How a legend entry's swatch is drawn.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -132,7 +136,7 @@ pub(super) fn draw_legend(ctx: &mut Ctx, entries: &[(String, Rgba, Swatch)], pos
                         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);
+                        ctx.text(x + sx, yc, &t, size, TEXT, (HAlign::Left, VAlign::Middle));
                     }
                     x += iw + spacing;
                 }
@@ -152,7 +156,7 @@ pub(super) fn draw_legend(ctx: &mut Ctx, entries: &[(String, Rgba, Swatch)], pos
                 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);
+                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
index 9cef4608c..ae0229cfb 100644
--- a/crates/chart/src/render/lines.rs
+++ b/crates/chart/src/render/lines.rs
@@ -1,5 +1,6 @@
 use super::frame::Bx;
-use super::*;
+use super::{Ctx, MAX_LINE_PTS, MAX_MARKERS, Prim, Rgba, WHITE};
+use std::collections::HashSet;
 
 // ---------------------------------------------------------------- helpers
 
diff --git a/crates/chart/src/render/trend.rs b/crates/chart/src/render/trend.rs
index 38e435a47..b642df262 100644
--- a/crates/chart/src/render/trend.rs
+++ b/crates/chart/src/render/trend.rs
@@ -1,6 +1,9 @@
 use super::frame::{Bx, value_range};
 use super::lines::decimate;
-use super::*;
+use super::{
+    ChartKind, Ctx, HAlign, LABEL_SIZE, LineDash, MAX_CATS, MAX_LINE_PTS, MAX_TRENDLINES, Prim, SeriesData, TEXT, TrendlineKind, VAlign,
+    fit_trendline, moving_average,
+};
 
 // ---------------------------------------------------------------- trendlines
 
@@ -36,10 +39,11 @@ 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)
 }
 
+type ClippedSegment = ((f64, f64), (f64, f64), bool, bool);
+
 /// 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)> {
+fn clip_segment(a: (f64, f64), b: (f64, f64)) -> Option<ClippedSegment> {
     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)] {
@@ -161,6 +165,6 @@ pub(super) fn draw_trend_labels(ctx: &mut Ctx, plot: Bx, labels: &[String]) {
             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);
+        ctx.text(plot.right() - 4.0, y, &t, LABEL_SIZE, TEXT, (HAlign::Right, VAlign::Top));
     }
 }
diff --git a/crates/core/src/addr.rs b/crates/core/src/addr.rs
index fd8ffec11..9d10ea87c 100644
--- a/crates/core/src/addr.rs
+++ b/crates/core/src/addr.rs
@@ -295,15 +295,16 @@ mod tests {
     use super::*;
 
     #[test]
-    fn range_parse_rejects_signed_rows() {
+    fn range_parse_rejects_signed_rows() -> Result<(), std::io::Error> {
         assert!(RangeRef::parse("+1:+3").is_none());
         assert!(RangeRef::parse("-1:3").is_none());
         assert!(RangeRef::parse("$$1:3").is_none());
         assert!(RangeRef::parse(":3").is_none());
         assert!(RangeRef::parse("$$A:$$C").is_none());
         assert!(RangeRef::parse("$A:$C").is_some());
-        let r = RangeRef::parse("$1:$3").unwrap();
+        let r = RangeRef::parse("$1:$3").ok_or_else(|| std::io::Error::other("valid row range"))?;
         assert_eq!((r.start.row, r.end.row), (0, 2));
+        Ok(())
     }
 
     #[test]
@@ -389,18 +390,20 @@ mod tests {
     }
 
     #[test]
-    fn ranges() {
-        let r = RangeRef::parse("C3:A1").unwrap();
+    fn ranges() -> Result<(), std::io::Error> {
+        let parse = |s| RangeRef::parse(s).ok_or_else(|| std::io::Error::other("valid range"));
+        let r = parse("C3:A1")?;
         assert_eq!(r.a1(), "A1:C3");
         assert_eq!(r.count(), 9);
-        assert_eq!(RangeRef::parse("A:C").unwrap().a1(), "A:C");
-        assert_eq!(RangeRef::parse("3:5").unwrap().a1(), "3:5");
+        assert_eq!(parse("A:C")?.a1(), "A:C");
+        assert_eq!(parse("3:5")?.a1(), "3:5");
         assert!(RangeRef::parse("0:5").is_none());
-        let a = RangeRef::parse("A1:C3").unwrap();
-        let b = RangeRef::parse("B2:D4").unwrap();
-        assert_eq!(a.intersection(&b).unwrap().a1(), "B2:C3");
+        let a = parse("A1:C3")?;
+        let b = parse("B2:D4")?;
+        assert_eq!(a.intersection(&b).ok_or_else(|| std::io::Error::other("overlap expected"))?.a1(), "B2:C3");
         assert_eq!(a.union(&b).a1(), "A1:D4");
         assert_eq!(a.iter().count(), 9);
+        Ok(())
     }
 
     #[test]
@@ -458,18 +461,19 @@ mod category_level_tests {
     use super::*;
 
     #[test]
-    fn a_wide_range_beside_a_column_of_values_is_a_multi_level_axis() {
-        let r = |s: &str| RangeRef::parse(s).unwrap();
-        assert_eq!(category_levels(&r("A4:B39"), Some(&r("C4:C39"))), Some(CategoryLevels { by_columns: true, outer: 1 }));
-        assert_eq!(category_levels(&r("A4:D39"), Some(&r("C4:C39"))), Some(CategoryLevels { by_columns: true, outer: 3 }));
-        assert_eq!(category_levels(&r("A4:F39"), Some(&r("C4:C39"))).map(|l| l.outer), Some(3), "capped");
-        assert_eq!(category_levels(&r("A4:A39"), Some(&r("C4:C39"))), None, "one column: a plain list");
+    fn a_wide_range_beside_a_column_of_values_is_a_multi_level_axis() -> Result<(), std::io::Error> {
+        let r = |s| RangeRef::parse(s).ok_or_else(|| std::io::Error::other("valid test range"));
+        assert_eq!(category_levels(&r("A4:B39")?, Some(&r("C4:C39")?)), Some(CategoryLevels { by_columns: true, outer: 1 }));
+        assert_eq!(category_levels(&r("A4:D39")?, Some(&r("C4:C39")?)), Some(CategoryLevels { by_columns: true, outer: 3 }));
+        assert_eq!(category_levels(&r("A4:F39")?, Some(&r("C4:C39")?)).map(|l| l.outer), Some(3), "capped");
+        assert_eq!(category_levels(&r("A4:A39")?, Some(&r("C4:C39")?)), None, "one column: a plain list");
         // A row of values: levels are rows.
-        assert_eq!(category_levels(&r("B2:M3"), Some(&r("B4:M4"))), Some(CategoryLevels { by_columns: false, outer: 1 }));
-        assert_eq!(category_levels(&r("B3:M3"), Some(&r("B4:M4"))), None);
+        assert_eq!(category_levels(&r("B2:M3")?, Some(&r("B4:M4")?)), Some(CategoryLevels { by_columns: false, outer: 1 }));
+        assert_eq!(category_levels(&r("B3:M3")?, Some(&r("B4:M4")?)), None);
         // Literal values: the categories' own shape decides.
-        assert_eq!(category_levels(&r("A1:B6"), None), Some(CategoryLevels { by_columns: true, outer: 1 }));
-        assert_eq!(category_levels(&r("A1:F2"), None), Some(CategoryLevels { by_columns: false, outer: 1 }));
-        assert_eq!(category_levels(&r("A:B"), Some(&r("C:C"))), None, "whole columns");
+        assert_eq!(category_levels(&r("A1:B6")?, None), Some(CategoryLevels { by_columns: true, outer: 1 }));
+        assert_eq!(category_levels(&r("A1:F2")?, None), Some(CategoryLevels { by_columns: false, outer: 1 }));
+        assert_eq!(category_levels(&r("A:B")?, Some(&r("C:C")?)), None, "whole columns");
+        Ok(())
     }
 }
diff --git a/crates/core/src/date.rs b/crates/core/src/date.rs
index 8e68695f1..606d3dacf 100644
--- a/crates/core/src/date.rs
+++ b/crates/core/src/date.rs
@@ -47,13 +47,11 @@ pub fn days_from_civil(y: i32, m: u32, d: u32) -> i64 {
 }
 
 /// Milliseconds since the Unix epoch (UTC) from the system clock; `None` when the clock is unavailable.
-/// On wasm32 `std::time::SystemTime::now` traps, so the browser clock is read through `Date.now()`.
-#[allow(clippy::disallowed_methods)] // the std clock is read only off wasm
+/// Chrono uses the browser clock on wasm32, where the standard library clock methods trap.
 pub fn unix_now_ms() -> Option<f64> {
     #[cfg(not(target_arch = "wasm32"))]
     {
-        let d = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).ok()?;
-        Some(d.as_secs_f64() * 1000.0)
+        Some(chrono::Utc::now().timestamp_millis() as f64)
     }
     #[cfg(target_arch = "wasm32")]
     {
@@ -323,7 +321,7 @@ mod tests {
     }
 
     #[test]
-    fn fictitious_1900_02_29() {
+    fn fictitious_1900_02_29() -> Result<(), std::io::Error> {
         // Excel's 1900 calendar has a 29 February 1900 (serial 60); day and month overflow count
         // through it.
         let s = DateSystem::D1900;
@@ -345,7 +343,7 @@ mod tests {
         assert_eq!(serial_from_ymd(s, 1904, 2, 29), Some(1521.0));
         // Every serial up to 1900-12-31 comes back from its own year, month and day.
         for serial in 0..=366 {
-            let d = datetime_from_serial(s, serial as f64).unwrap();
+            let d = datetime_from_serial(s, serial as f64).ok_or_else(|| std::io::Error::other("serial should convert"))?;
             assert_eq!(serial_from_ymd(s, d.year as i64, d.month as i64, d.day as i64), Some(serial as f64), "{d:?}");
         }
         assert_eq!(days_in_month_in(s, 1900, 2), 29);
@@ -358,6 +356,7 @@ mod tests {
         assert_eq!(serial_from_ymd(s, 1904, 3, 1), Some(60.0));
         assert_eq!(serial_from_ymd(s, 1904, 1, 0), None);
         assert_eq!(serial_from_ymd(s, 1900, 2, 29), None);
+        Ok(())
     }
 
     #[test]
@@ -371,17 +370,18 @@ mod tests {
     }
 
     #[test]
-    fn roundtrip() {
+    fn roundtrip() -> Result<(), std::io::Error> {
         let s = DateSystem::D1900;
         for serial in [1.0, 59.0, 60.0, 61.0, 36526.0, 46302.0, 2958465.0] {
-            let d = datetime_from_serial(s, serial).unwrap();
+            let d = datetime_from_serial(s, serial).ok_or_else(|| std::io::Error::other("serial should convert"))?;
             assert_eq!(serial_from_ymd(s, d.year as i64, d.month as i64, d.day as i64), Some(serial));
         }
-        let d = datetime_from_serial(s, 60.0).unwrap();
+        let d = datetime_from_serial(s, 60.0).ok_or_else(|| std::io::Error::other("leap-day serial should convert"))?;
         assert_eq!((d.year, d.month, d.day), (1900, 2, 29));
-        let d = datetime_from_serial(s, 46302.75).unwrap();
+        let d = datetime_from_serial(s, 46302.75).ok_or_else(|| std::io::Error::other("time serial should convert"))?;
         assert_eq!((d.hour, d.minute, d.weekday), (18, 0, 3)); // 2026-10-07 is a Wednesday
-        let d = datetime_from_serial(s, 1.0).unwrap();
+        let d = datetime_from_serial(s, 1.0).ok_or_else(|| std::io::Error::other("first serial should convert"))?;
         assert_eq!(d.weekday, 0); // 1900-01-01 was a Sunday in Excel's calendar
+        Ok(())
     }
 }
diff --git a/crates/core/src/value.rs b/crates/core/src/value.rs
index c531de4dc..46721beda 100644
--- a/crates/core/src/value.rs
+++ b/crates/core/src/value.rs
@@ -454,11 +454,12 @@ mod tests {
     }
 
     #[test]
-    fn arrays() {
-        let a = Array::new(2, 2, vec![1.0.into(), 2.0.into(), 3.0.into(), 4.0.into()]).unwrap();
+    fn arrays() -> Result<(), std::io::Error> {
+        let a = Array::new(2, 2, vec![1.0.into(), 2.0.into(), 3.0.into(), 4.0.into()]).ok_or_else(|| std::io::Error::other("valid array"))?;
         assert_eq!(a.transpose().get(0, 1), Some(&Value::Number(3.0)));
         assert!(Array::new(2, 2, vec![]).is_none());
         let row = Array::row(vec![1.0.into(), 2.0.into()]);
         assert_eq!(row.get_broadcast(5, 1), Value::Number(2.0));
+        Ok(())
     }
 }
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index e8ea91c26..1de94c60c 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -17,6 +17,7 @@ gridcraft-model = { workspace = true }
 gridcraft-calc = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+web-time = { workspace = true }
 thiserror = { workspace = true }
 log = { workspace = true }
 gridcraft-xlsx = { workspace = true }
diff --git a/crates/engine/src/cf.rs b/crates/engine/src/cf.rs
index 0c0f9683e..4c9325e36 100644
--- a/crates/engine/src/cf.rs
+++ b/crates/engine/src/cf.rs
@@ -136,6 +136,95 @@ fn lerp(a: [u8; 3], b: [u8; 3], t: f64) -> [u8; 3] {
 
 pub use gridcraft_model::icon_count;
 
+struct RuleEval<'a> {
+    wb: &'a Workbook,
+    sheet: usize,
+    cell: CellRef,
+    first: CellRef,
+    value: &'a Value,
+    text: &'a str,
+    stats: &'a RuleStats,
+}
+
+fn simple_rule_style<'a>(ctx: &RuleEval<'_>, rule: &'a CfRule) -> Option<&'a Style> {
+    let RuleEval { wb, sheet, cell, first, value, text, stats } = ctx;
+    match rule {
+        CfRule::CellIs { op, a, b, style } => {
+            let eval = |f: &str| gridcraft_calc::evaluate(wb, *sheet, *cell, &relative(f, *first, *cell));
+            let av = eval(a);
+            let matches = match op {
+                CfOperator::Between | CfOperator::NotBetween => {
+                    let bv = b.as_deref().map(eval).unwrap_or_default();
+                    let (lo, hi) = if compare(&av, &bv) == std::cmp::Ordering::Greater { (bv, av) } else { (av, bv) };
+                    let within = compare(value, &lo) != std::cmp::Ordering::Less && compare(value, &hi) != std::cmp::Ordering::Greater;
+                    if *op == CfOperator::Between { within } else { !within }
+                }
+                CfOperator::Equal => compare(value, &av) == std::cmp::Ordering::Equal,
+                CfOperator::NotEqual => compare(value, &av) != std::cmp::Ordering::Equal,
+                CfOperator::Greater => compare(value, &av) == std::cmp::Ordering::Greater,
+                CfOperator::Less => compare(value, &av) == std::cmp::Ordering::Less,
+                CfOperator::GreaterOrEqual => compare(value, &av) != std::cmp::Ordering::Less,
+                CfOperator::LessOrEqual => compare(value, &av) != std::cmp::Ordering::Greater,
+            };
+            (matches && !value.is_error()).then_some(style.as_ref())
+        }
+        CfRule::Expression { formula, style } => {
+            gridcraft_calc::evaluate(wb, *sheet, *cell, &relative(formula, *first, *cell)).to_bool().unwrap_or(false).then_some(style.as_ref())
+        }
+        CfRule::ContainsText { text: needle, style } => {
+            (!value.is_error() && text.to_lowercase().contains(&needle.to_lowercase())).then_some(style.as_ref())
+        }
+        CfRule::NotContainsText { text: needle, style } => {
+            (value.is_error() || !text.to_lowercase().contains(&needle.to_lowercase())).then_some(style.as_ref())
+        }
+        CfRule::BeginsWith { text: needle, style } => {
+            (!value.is_error() && text.to_lowercase().starts_with(&needle.to_lowercase())).then_some(style.as_ref())
+        }
+        CfRule::EndsWith { text: needle, style } => {
+            (!value.is_error() && text.to_lowercase().ends_with(&needle.to_lowercase())).then_some(style.as_ref())
+        }
+        CfRule::Blanks { style } => (value.is_empty() || text.trim().is_empty()).then_some(style.as_ref()),
+        CfRule::NoBlanks { style } => (!value.is_empty() && !text.trim().is_empty()).then_some(style.as_ref()),
+        CfRule::Errors { style } => value.is_error().then_some(style.as_ref()),
+        CfRule::NoErrors { style } => (!value.is_error()).then_some(style.as_ref()),
+        CfRule::Duplicate { style } => {
+            (!value.is_empty() && stats.counts.get(&text.to_lowercase()).copied().unwrap_or(0) > 1).then_some(style.as_ref())
+        }
+        CfRule::Unique { style } => {
+            (!value.is_empty() && stats.counts.get(&text.to_lowercase()).copied().unwrap_or(0) == 1).then_some(style.as_ref())
+        }
+        _ => None,
+    }
+}
+
+fn time_period_matches(wb: &Workbook, period: &str, serial: f64) -> bool {
+    let today = gridcraft_core::date::serial_in_system(wb.date_system, gridcraft_calc::now_serial()).floor();
+    let day = serial.floor();
+    let date = |serial| gridcraft_core::date::datetime_from_serial(wb.date_system, serial);
+    let week_start = today - date(today).map(|value| value.weekday as f64).unwrap_or(0.0);
+    let (year, month) = date(today).map(|value| (value.year, value.month)).unwrap_or((2026, 1));
+    let year_month = date(day).map(|value| (value.year, value.month));
+    let month_matches = |offset: i32| {
+        let shifted_month = month as i32 + offset;
+        let shifted_year = year + (shifted_month - 1).div_euclid(12);
+        let shifted_month = (shifted_month - 1).rem_euclid(12) + 1;
+        year_month == Some((shifted_year, shifted_month as u32))
+    };
+    match period {
+        "yesterday" => day == today - 1.0,
+        "today" => day == today,
+        "tomorrow" => day == today + 1.0,
+        "last7Days" => day > today - 7.0 && day <= today,
+        "lastWeek" => day >= week_start - 7.0 && day < week_start,
+        "thisWeek" => day >= week_start && day < week_start + 7.0,
+        "nextWeek" => day >= week_start + 7.0 && day < week_start + 14.0,
+        "lastMonth" => month_matches(-1),
+        "thisMonth" => month_matches(0),
+        "nextMonth" => month_matches(1),
+        _ => false,
+    }
+}
+
 impl CfCache {
     pub fn new() -> Self {
         Self::default()
@@ -161,52 +250,8 @@ impl CfCache {
                 None => &no_stats,
             };
             let text = v.display();
-            let matched_style: Option<&Style> = match &cf.rule {
-                CfRule::CellIs { op, a, b, style } => {
-                    let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, c, &relative(f, first, c));
-                    let av = eval(a);
-                    let ok = match op {
-                        CfOperator::Between | CfOperator::NotBetween => {
-                            let bv = b.as_deref().map(eval).unwrap_or_default();
-                            let (lo, hi) = if compare(&av, &bv) == std::cmp::Ordering::Greater { (bv, av) } else { (av, bv) };
-                            let inside = compare(&v, &lo) != std::cmp::Ordering::Less && compare(&v, &hi) != std::cmp::Ordering::Greater;
-                            if *op == CfOperator::Between { inside } else { !inside }
-                        }
-                        CfOperator::Equal => compare(&v, &av) == std::cmp::Ordering::Equal,
-                        CfOperator::NotEqual => compare(&v, &av) != std::cmp::Ordering::Equal,
-                        CfOperator::Greater => compare(&v, &av) == std::cmp::Ordering::Greater,
-                        CfOperator::Less => compare(&v, &av) == std::cmp::Ordering::Less,
-                        CfOperator::GreaterOrEqual => compare(&v, &av) != std::cmp::Ordering::Less,
-                        CfOperator::LessOrEqual => compare(&v, &av) != std::cmp::Ordering::Greater,
-                    };
-                    // As in Excel, a blank cell compares as 0 (or ""), and an error never matches.
-                    (ok && !v.is_error()).then_some(style.as_ref())
-                }
-                CfRule::Expression { formula, style } => {
-                    gridcraft_calc::evaluate(wb, sheet, c, &relative(formula, first, c)).to_bool().unwrap_or(false).then_some(style.as_ref())
-                }
-                // As in Excel, an error value never contains, begins or ends with anything (its rule
-                // formulas SEARCH/LEFT/RIGHT fail on it), so it always "does not contain" (#1162).
-                CfRule::ContainsText { text: t, style } => {
-                    (!v.is_error() && text.to_lowercase().contains(&t.to_lowercase())).then_some(style.as_ref())
-                }
-                CfRule::NotContainsText { text: t, style } => {
-                    (v.is_error() || !text.to_lowercase().contains(&t.to_lowercase())).then_some(style.as_ref())
-                }
-                CfRule::BeginsWith { text: t, style } => {
-                    (!v.is_error() && text.to_lowercase().starts_with(&t.to_lowercase())).then_some(style.as_ref())
-                }
-                CfRule::EndsWith { text: t, style } => (!v.is_error() && text.to_lowercase().ends_with(&t.to_lowercase())).then_some(style.as_ref()),
-                CfRule::Blanks { style } => (v.is_empty() || text.trim().is_empty()).then_some(style.as_ref()),
-                CfRule::NoBlanks { style } => (!v.is_empty() && !text.trim().is_empty()).then_some(style.as_ref()),
-                CfRule::Errors { style } => v.is_error().then_some(style.as_ref()),
-                CfRule::NoErrors { style } => (!v.is_error()).then_some(style.as_ref()),
-                CfRule::Duplicate { style } => {
-                    (!v.is_empty() && st.counts.get(&text.to_lowercase()).copied().unwrap_or(0) > 1).then_some(style.as_ref())
-                }
-                CfRule::Unique { style } => {
-                    (!v.is_empty() && st.counts.get(&text.to_lowercase()).copied().unwrap_or(0) == 1).then_some(style.as_ref())
-                }
+            let context = RuleEval { wb, sheet, cell: c, first, value: &v, text: &text, stats: st };
+            let matched_style = simple_rule_style(&context, &cf.rule).or_else(|| match &cf.rule {
                 CfRule::Top10 { bottom, percent, rank, style } => match v.as_f64() {
                     Some(n) if !st.sorted.is_empty() => {
                         let k = if *percent { ((st.sorted.len() as f64) * (*rank as f64) / 100.0).floor().max(1.0) as usize } else { *rank as usize };
@@ -229,36 +274,8 @@ impl CfCache {
                     None => None,
                 },
                 CfRule::TimePeriod { period, style } => match v.as_f64() {
-                    Some(n) => {
-                        let today = gridcraft_core::date::serial_in_system(wb.date_system, gridcraft_calc::now_serial()).floor();
-                        let d = n.floor();
-                        let wd = gridcraft_core::date::datetime_from_serial(wb.date_system, today).map(|x| x.weekday as f64).unwrap_or(0.0);
-                        let week_start = today - wd;
-                        let (ty, tm) =
-                            gridcraft_core::date::datetime_from_serial(wb.date_system, today).map(|x| (x.year, x.month)).unwrap_or((2026, 1));
-                        let ym = gridcraft_core::date::datetime_from_serial(wb.date_system, d).map(|x| (x.year, x.month));
-                        let month_off = |k: i32| {
-                            let m = tm as i32 + k;
-                            let y = ty + (m - 1).div_euclid(12);
-                            let m = (m - 1).rem_euclid(12) + 1;
-                            ym == Some((y, m as u32))
-                        };
-                        let ok = match period.as_str() {
-                            "yesterday" => d == today - 1.0,
-                            "today" => d == today,
-                            "tomorrow" => d == today + 1.0,
-                            "last7Days" => d > today - 7.0 && d <= today,
-                            "lastWeek" => d >= week_start - 7.0 && d < week_start,
-                            "thisWeek" => d >= week_start && d < week_start + 7.0,
-                            "nextWeek" => d >= week_start + 7.0 && d < week_start + 14.0,
-                            "lastMonth" => month_off(-1),
-                            "thisMonth" => month_off(0),
-                            "nextMonth" => month_off(1),
-                            _ => false,
-                        };
-                        ok.then_some(style.as_ref())
-                    }
-                    None => None,
+                    Some(n) if time_period_matches(wb, period, n) => Some(style.as_ref()),
+                    _ => None,
                 },
                 CfRule::ColorScale { stops } => {
                     if let Some(n) = v.as_f64() {
@@ -329,7 +346,8 @@ impl CfCache {
                     }
                     None
                 }
-            };
+                _ => None,
+            });
             if let Some(st) = matched_style {
                 any = true;
                 // Every matching rule applies; where two set the same part, the rule with the
diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs
index ef6714eea..90c8a5227 100644
--- a/crates/engine/src/cmd.rs
+++ b/crates/engine/src/cmd.rs
@@ -205,7 +205,6 @@ pub(crate) fn register_undoable_test_command(id: &'static str, run: Run) {
 }
 
 fn test_commands() -> std::sync::MutexGuard<'static, Vec<&'static CommandSpec>> {
-    #[allow(clippy::unwrap_used)] // a poisoned test registry has no meaningful recovery
     match TEST_COMMANDS.lock() {
         Ok(guard) => guard,
         Err(poisoned) => poisoned.into_inner(),
@@ -349,11 +348,15 @@ pub(crate) fn edit<R>(s: &mut Session, f: impl FnOnce(&mut Ctx) -> Result<R>) ->
     })
 }
 
+fn wall_clock() -> std::time::Duration {
+    std::time::SystemTime::UNIX_EPOCH.elapsed().unwrap_or_default()
+}
+
 pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>) -> Result<R> {
-    // `GRIDCRAFT_PROFILE` timing. Read the clock only when profiling, and never on wasm: there
-    // `Instant::now` traps (`RuntimeError: unreachable`), which broke every edit in the web app.
-    #[allow(clippy::disallowed_methods)]
-    let t0 = if cfg!(target_arch = "wasm32") { None } else { std::env::var_os("GRIDCRAFT_PROFILE").map(|_| std::time::Instant::now()) };
+    // `GRIDCRAFT_PROFILE` timing, never on wasm where the clock traps. `elapsed` on the epoch
+    // reads the wall clock without the (disallowed) `now`.
+    let t0 = if cfg!(target_arch = "wasm32") { None } else { std::env::var_os("GRIDCRAFT_PROFILE").map(|_| wall_clock()) };
+    let since = |t0: std::time::Duration| wall_clock().saturating_sub(t0);
     let mut sel = d.selection.clone();
     let mut ctx = Ctx { wb: (*d.wb).clone(), changed: Vec::new(), structural: false, sel: &mut sel, fit_rows: Vec::new(), protection_checked: false };
     let r = f(&mut ctx)?;
@@ -368,7 +371,7 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
         fit_rows.extend(changed.iter().map(|(s, c)| (*s, c.row)));
     }
     if let Some(t0) = t0 {
-        eprintln!("commit: edit {:?}, {} changed", t0.elapsed(), changed.len());
+        eprintln!("commit: edit {:?}, {} changed", since(t0), changed.len());
     }
     if structural {
         d.calc.recalc_all(&mut wb);
@@ -376,7 +379,7 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
         d.calc.cells_changed(&mut wb, &changed);
     }
     if let Some(t0) = t0 {
-        eprintln!("commit: + recalc {:?}", t0.elapsed());
+        eprintln!("commit: + recalc {:?}", since(t0));
     }
     fit_rows.sort_unstable();
     fit_rows.dedup();
@@ -384,7 +387,7 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
         auto_row_height(&mut wb, si, row);
     }
     if let Some(t0) = t0 {
-        eprintln!("commit: + rows {:?}", t0.elapsed());
+        eprintln!("commit: + rows {:?}", since(t0));
     }
     d.wb = std::sync::Arc::new(wb);
     d.selection = sel;
diff --git a/crates/engine/src/cmd/analysis.rs b/crates/engine/src/cmd/analysis.rs
index 6225b4934..9552e95f7 100644
--- a/crates/engine/src/cmd/analysis.rs
+++ b/crates/engine/src/cmd/analysis.rs
@@ -14,7 +14,7 @@ use gridcraft_model::{Cell, NumFmt, Sheet};
 use serde_json::{Value as Json, json};
 
 use super::whatif::parse_range;
-use super::*;
+use super::{CommandSpec, EngineError, Result, Session, bad, cmd, edit, has_doc, str_param};
 
 const CMD: &str = "data.analysisToolPak";
 /// Most input cells a tool reads.
diff --git a/crates/engine/src/cmd/data.rs b/crates/engine/src/cmd/data.rs
index 5fa076e64..143763a5e 100644
--- a/crates/engine/src/cmd/data.rs
+++ b/crates/engine/src/cmd/data.rs
@@ -4,10 +4,16 @@ use std::cmp::Ordering;
 use std::sync::Arc;
 
 use gridcraft_core::{CellRef, RangeRef, Value, sort_compare};
-use gridcraft_model::*;
+use gridcraft_model::{
+    Anchor, AnchorMode, AutoFilter, Cell, CfOperator, Comment, ErrorStyle, FilterCriterion, Formula, Hyperlink, LineInfo, Sheet, Validation,
+    ValidationKind, Workbook,
+};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, Session, bad, bool_param, cell_param, cell_param_on, cmd, edit, has_doc, ok, parse_lines, split_sheet,
+    str_param, target_range, target_ranges, target_sheet,
+};
 use crate::outline;
 use crate::selection::current_region;
 
diff --git a/crates/engine/src/cmd/data/filter.rs b/crates/engine/src/cmd/data/filter.rs
index 71aa698f4..1b52e4537 100644
--- a/crates/engine/src/cmd/data/filter.rs
+++ b/crates/engine/src/cmd/data/filter.rs
@@ -1,5 +1,8 @@
 use super::sort::sort_key;
-use super::*;
+use super::{
+    AutoFilter, CellRef, EngineError, FilterCriterion, Json, Ordering, RangeRef, Result, Session, Sheet, Value, Workbook, bad, bool_param, col_param,
+    current_region, data_target, edit, json,
+};
 
 // ---------------------------------------------------------------- filter
 
diff --git a/crates/engine/src/cmd/data/grouping.rs b/crates/engine/src/cmd/data/grouping.rs
index 7b5a2254c..d2e183ae1 100644
--- a/crates/engine/src/cmd/data/grouping.rs
+++ b/crates/engine/src/cmd/data/grouping.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CellRef, EngineError, Json, LineInfo, RangeRef, Result, Session, bad, bool_param, col_param, data_target, edit, json, outline, parse_lines,
+    str_param, target_sheet,
+};
 
 // ---------------------------------------------------------------- outline
 
diff --git a/crates/engine/src/cmd/data/sort.rs b/crates/engine/src/cmd/data/sort.rs
index 919de1734..a36527650 100644
--- a/crates/engine/src/cmd/data/sort.rs
+++ b/crates/engine/src/cmd/data/sort.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Anchor, AnchorMode, Arc, Cell, CellRef, Comment, EngineError, Formula, Hyperlink, Json, LineInfo, Ordering, RangeRef, Result, Session, Sheet,
+    Value, bad, bool_param, col_param, data_range, edit, guess_header, json, ok, sort_compare, split_sheet, str_param, target_sheet,
+};
 
 #[derive(Clone)]
 struct SortKey {
diff --git a/crates/engine/src/cmd/data/tools.rs b/crates/engine/src/cmd/data/tools.rs
index 1603b2cb4..2cbca17bd 100644
--- a/crates/engine/src/cmd/data/tools.rs
+++ b/crates/engine/src/cmd/data/tools.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Cell, CellRef, EngineError, Json, RangeRef, Result, Session, bad, bool_param, cell_param_on, col_param, data_target, edit, guess_header, json,
+    ok, str_param, target_range, target_sheet,
+};
 
 // ---------------------------------------------------------------- tools
 
diff --git a/crates/engine/src/cmd/data/validation.rs b/crates/engine/src/cmd/data/validation.rs
index 6d4ae73cf..ce0d7e3b8 100644
--- a/crates/engine/src/cmd/data/validation.rs
+++ b/crates/engine/src/cmd/data/validation.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Cell, CellRef, CfOperator, EngineError, ErrorStyle, Json, RangeRef, Result, Session, Validation, ValidationKind, Value, Workbook, bad,
+    bool_param, cell_param, edit, json, ok, str_param, target_ranges, target_sheet,
+};
 
 // ---------------------------------------------------------------- validation
 
diff --git a/crates/engine/src/cmd/draw.rs b/crates/engine/src/cmd/draw.rs
index a86be3099..f6184509c 100644
--- a/crates/engine/src/cmd/draw.rs
+++ b/crates/engine/src/cmd/draw.rs
@@ -1,10 +1,10 @@
 //! Draw tab: pen and eraser tools, ink strokes, Ink to Shape.
 
 use gridcraft_core::CellRef;
-use gridcraft_model::*;
+use gridcraft_model::{Anchor, Color, Shape, ShapeKind};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, EngineError, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, ok, str_param, u32_param};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index e48fe8838..f977a95ce 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -4,7 +4,10 @@ use gridcraft_core::{CellRef, MAX_ROWS, RangeRef, Value};
 use gridcraft_model::{Cell, Formula, StyleId};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, bad, bool_param, can_redo, can_undo, cell_param, cell_param_on, cmd, edit, f64_param, has_clipboard, has_doc,
+    locked_cell_error, ok, split_sheet, str_param, target_range, target_ranges, target_sheet, u32_param,
+};
 use crate::selection::{current_region, jump};
 use crate::{Clipboard, Session};
 
diff --git a/crates/engine/src/cmd/edit/cell.rs b/crates/engine/src/cmd/edit/cell.rs
index 62a6b38bd..c57afae97 100644
--- a/crates/engine/src/cmd/edit/cell.rs
+++ b/crates/engine/src/cmd/edit/cell.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Cell, CellRef, EngineError, Formula, Json, MAX_ROWS, RangeRef, Result, Session, StyleId, Value, bad, bool_param, cell_param_on, edit, json,
+    locked_cell_error, str_param, target_range, target_ranges, target_sheet,
+};
 
 // ---------------------------------------------------------------- entry
 
diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs
index 60c05c687..de921226e 100644
--- a/crates/engine/src/cmd/edit/clipboard.rs
+++ b/crates/engine/src/cmd/edit/clipboard.rs
@@ -1,6 +1,8 @@
 use super::cell::input_to_cell;
 use super::paste_special::paste_special;
-use super::*;
+use super::{
+    Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, cell_param_on, edit, json, ok, str_param, target_ranges, target_sheet,
+};
 
 // ---------------------------------------------------------------- clipboard
 
diff --git a/crates/engine/src/cmd/edit/fill.rs b/crates/engine/src/cmd/edit/fill.rs
index 84f4cd6d3..8cd1e3d88 100644
--- a/crates/engine/src/cmd/edit/fill.rs
+++ b/crates/engine/src/cmd/edit/fill.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{CellRef, EngineError, Json, RangeRef, Result, Session, bad, edit, f64_param, json, str_param, target_range, target_sheet};
 
 // ---------------------------------------------------------------- fill
 
@@ -78,7 +78,7 @@ pub(super) fn fill_series(s: &mut Session, p: &Json) -> Result<Json> {
     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)?;
+        crate::fill::series(cx, sheet, crate::fill::SeriesOptions { range: r, rows, kind: &kind, step, stop, unit: &unit })?;
         Ok(Json::Null)
     })
 }
diff --git a/crates/engine/src/cmd/edit/find.rs b/crates/engine/src/cmd/edit/find.rs
index 2dcbfa886..bce0ba728 100644
--- a/crates/engine/src/cmd/edit/find.rs
+++ b/crates/engine/src/cmd/edit/find.rs
@@ -1,5 +1,5 @@
 use super::cell::input_to_cell;
-use super::*;
+use super::{Cell, CellRef, EngineError, Json, Result, Session, Value, bad, bool_param, edit, json, str_param};
 
 // ---------------------------------------------------------------- find & replace
 
diff --git a/crates/engine/src/cmd/edit/go_to.rs b/crates/engine/src/cmd/edit/go_to.rs
index b94bcd221..bc4f414db 100644
--- a/crates/engine/src/cmd/edit/go_to.rs
+++ b/crates/engine/src/cmd/edit/go_to.rs
@@ -1,5 +1,5 @@
 use super::selection::{select_region, selection_set};
-use super::*;
+use super::{CellRef, EngineError, Json, RangeRef, Result, Session, bad, bool_param, coalesce, json, split_sheet, str_param};
 
 /// How many references the Go To dialog keeps for going back to.
 pub(super) const GO_TO_RECENT: usize = 10;
diff --git a/crates/engine/src/cmd/edit/paste_special.rs b/crates/engine/src/cmd/edit/paste_special.rs
index eba1b429e..0a6d14247 100644
--- a/crates/engine/src/cmd/edit/paste_special.rs
+++ b/crates/engine/src/cmd/edit/paste_special.rs
@@ -1,5 +1,76 @@
 use super::clipboard::What;
-use super::*;
+use super::{
+    Cell, CellRef, EngineError, Formula, Json, RangeRef, Result, Session, StyleId, Value, bad, bool_param, cell_param_on, edit, json, str_param,
+    target_sheet,
+};
+
+fn tiled_cells(rows: u32, cols: u32, tiles_r: u32, tiles_c: u32) -> impl Iterator<Item = (u32, u32, u32, u32)> + Clone {
+    (0..tiles_r).flat_map(move |tr| (0..tiles_c).flat_map(move |tc| (0..rows).flat_map(move |r| (0..cols).map(move |c| (tr, tc, r, c)))))
+}
+
+fn apply_operation(op: &str, old: &Cell, new: &mut Cell) {
+    let operand = new.value.clone();
+    if let (Ok(x), Ok(y)) = (old.value.to_number(), operand.to_number())
+        && (old.value.is_number() || old.value.is_empty() || old.value.is_text())
+        && (operand.is_number() || operand.is_empty())
+    {
+        new.value = match op {
+            "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),
+            "divide" => Value::number(x / y),
+            _ => operand.clone(),
+        };
+    } else if (old.value.is_text() || old.value.is_error()) && (operand.is_number() || operand.is_empty()) {
+        new.value = old.value.clone();
+    }
+    if let Some(formula) = &old.formula
+        && let Ok(y) = operand.to_number()
+        && (operand.is_number() || operand.is_empty())
+        && let Some(symbol) = operation_symbol(op)
+    {
+        let text = format!("=({}){symbol}{}", formula.text, gridcraft_core::number_to_text(y));
+        new.formula = Some(std::sync::Arc::new(Formula::new(&text)));
+        new.value = Value::Empty;
+    }
+}
+
+fn operation_symbol(op: &str) -> Option<char> {
+    match op {
+        "add" => Some('+'),
+        "subtract" => Some('-'),
+        "multiply" => Some('*'),
+        "divide" => Some('/'),
+        _ => None,
+    }
+}
+
+fn copy_merges(
+    cx: &mut crate::cmd::Ctx,
+    dest_sheet: usize,
+    src_sheet: &gridcraft_model::Sheet,
+    src: RangeRef,
+    at: CellRef,
+    what: What,
+    transpose: bool,
+) -> Result<()> {
+    if !matches!(what, What::All | What::Formats) || transpose {
+        return Ok(());
+    }
+    let merges: Vec<RangeRef> = src_sheet.merges.iter().filter(|merge| src.contains_range(merge)).copied().collect();
+    for merge in merges {
+        let row_offset = at.row as i64 - src.start.row as i64;
+        let col_offset = at.col as i64 - src.start.col as i64;
+        if let (Some(start), Some(end)) = (merge.start.offset(row_offset, col_offset), merge.end.offset(row_offset, col_offset)) {
+            let moved = RangeRef::new(start, end);
+            let sheet = cx.sheet_mut(dest_sheet)?;
+            sheet.merges.retain(|existing| !existing.intersects(&moved));
+            sheet.merges.push(moved);
+        }
+    }
+    Ok(())
+}
 
 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())) };
@@ -74,209 +145,145 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
             }
             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())
+        for (tr, tc, r, c) in tiled_cells(src.height(), src.width(), tiles_r, tiles_c) {
+            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 {
-                            src_sheet.cell(sc).cloned()
+                            st
                         };
-                        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;
+                    }
+                    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);
                         }
-                        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;
-                                }
-                            }
+                    }
+                    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);
                         }
-                        // 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);
+                    }
+                    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);
+                    }
+                    // Numbers stored as text participate; other text and errors stay as they are.
+                    apply_operation(&op, &old, &mut new);
+                }
+            }
+            // 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);
-                }
-            }
-        }
+        copy_merges(cx, dest_sheet, src_sheet, src, at, what, transpose)?;
         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();
diff --git a/crates/engine/src/cmd/edit/selection.rs b/crates/engine/src/cmd/edit/selection.rs
index 95793f338..ede66a34d 100644
--- a/crates/engine/src/cmd/edit/selection.rs
+++ b/crates/engine/src/cmd/edit/selection.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CellRef, EngineError, Json, RangeRef, Result, Session, bool_param, cell_param, current_region, json, jump, split_sheet, str_param, target_ranges,
+    target_sheet,
+};
 
 // ---------------------------------------------------------------- selection
 
diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs
index bf21433ab..c9a1582a2 100644
--- a/crates/engine/src/cmd/extra.rs
+++ b/crates/engine/src/cmd/extra.rs
@@ -2,10 +2,16 @@
 //! tools, Get Data, scripts (Automate), cell checkboxes, theme colours and fonts.
 
 use gridcraft_core::{CellRef, RangeRef, Value};
-use gridcraft_model::*;
+use gridcraft_model::{
+    Anchor, Chart, Color, DefinedName, HAlign, LegendPos, NumFmt, Shape, Sheet, SheetViewMode, TableColumn, TotalsFn, Trendline, TrendlineKind,
+    Workbook,
+};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, Session, always, anchor_mode_name, bad, bool_param, cell_param, cell_param_on, cmd, edit, f64_param, has_doc,
+    ok, split_sheet, str_param, target_range, target_ranges, target_sheet, u32_param,
+};
 
 mod cells;
 mod chart;
diff --git a/crates/engine/src/cmd/extra/cells.rs b/crates/engine/src/cmd/extra/cells.rs
index 5cddf0982..ff0d5b65b 100644
--- a/crates/engine/src/cmd/extra/cells.rs
+++ b/crates/engine/src/cmd/extra/cells.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CellRef, EngineError, HAlign, Json, NumFmt, Result, Session, Value, bad, bool_param, cell_param, cell_param_on, edit, json, object_params, ok,
+    str_param, target_ranges, target_sheet,
+};
 
 /// Whether `c` has checkbox formatting.
 pub(crate) fn is_checkbox_cell(wb: &gridcraft_model::Workbook, sh: &gridcraft_model::Sheet, c: CellRef) -> bool {
diff --git a/crates/engine/src/cmd/extra/chart.rs b/crates/engine/src/cmd/extra/chart.rs
index 2e16befa6..b6761f1a9 100644
--- a/crates/engine/src/cmd/extra/chart.rs
+++ b/crates/engine/src/cmd/extra/chart.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CellRef, Chart, Color, EngineError, Json, LegendPos, RangeRef, Result, Session, Trendline, TrendlineKind, bad, bool_param, cell_param_on, edit,
+    f64_param, json, split_sheet, str_param, u32_param,
+};
 
 fn find_chart(s: &Session, p: &Json) -> Result<(usize, usize)> {
     let d = s.doc()?;
diff --git a/crates/engine/src/cmd/extra/data.rs b/crates/engine/src/cmd/extra/data.rs
index cef840f21..9a1ae7417 100644
--- a/crates/engine/src/cmd/extra/data.rs
+++ b/crates/engine/src/cmd/extra/data.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{CellRef, EngineError, Json, RangeRef, Result, Session, TableColumn, TotalsFn, Value, bad, edit, json, ok, str_param, target_range};
 
 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`"))?;
diff --git a/crates/engine/src/cmd/extra/objects.rs b/crates/engine/src/cmd/extra/objects.rs
index 59ab8447a..30725f81e 100644
--- a/crates/engine/src/cmd/extra/objects.rs
+++ b/crates/engine/src/cmd/extra/objects.rs
@@ -1,5 +1,7 @@
 use super::chart::format_series;
-use super::*;
+use super::{
+    Anchor, CellRef, Color, EngineError, Json, Result, Session, Shape, Sheet, anchor_mode_name, bad, bool_param, edit, json, str_param, u32_param,
+};
 
 pub(super) fn shape_fill(s: &mut Session, p: &Json) -> Result<Json> {
     if str_param(p, "kind") == Some("shape") {
diff --git a/crates/engine/src/cmd/extra/scripts.rs b/crates/engine/src/cmd/extra/scripts.rs
index 9f86837ab..f1118410f 100644
--- a/crates/engine/src/cmd/extra/scripts.rs
+++ b/crates/engine/src/cmd/extra/scripts.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, Result, SCRIPTS_NAME, Session, Workbook, bad, bool_param, edit, json, stash_get, stash_map, stash_set, str_param};
 
 pub(super) fn record(s: &mut Session, p: &Json) -> Result<Json> {
     if bool_param(p, "stop").unwrap_or(false) || s.recording.is_some() {
diff --git a/crates/engine/src/cmd/extra/window.rs b/crates/engine/src/cmd/extra/window.rs
index 19e92743f..b20a00a61 100644
--- a/crates/engine/src/cmd/extra/window.rs
+++ b/crates/engine/src/cmd/extra/window.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CellRef, EngineError, Json, Result, Session, SheetViewMode, VIEWS_NAME, WATCH_NAME, Workbook, bad, bool_param, edit, json, ok, split_sheet,
+    stash_get, stash_map, stash_set, str_param, target_sheet, u32_param,
+};
 
 /// 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.
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 9af85b9dd..8d28c25a5 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -2,7 +2,7 @@
 
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, Result, Session, always, bad, bool_param, cmd, edit, has_doc, ok, str_param, target_sheet, u32_param};
 use crate::DocState;
 
 pub fn specs() -> Vec<CommandSpec> {
diff --git a/crates/engine/src/cmd/forecast.rs b/crates/engine/src/cmd/forecast.rs
index b7472fd22..9bb15936b 100644
--- a/crates/engine/src/cmd/forecast.rs
+++ b/crates/engine/src/cmd/forecast.rs
@@ -11,7 +11,7 @@ use gridcraft_functions::Timeline;
 use gridcraft_model::{Anchor, Cell, Chart, ChartKind, Formula, LegendPos, Series, Sheet, StyleId, Table, TableColumn, TotalsFn};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, EngineError, Result, Session, bad, bool_param, cmd, edit, has_doc, split_sheet, str_param};
 use crate::selection::current_region;
 
 const CMD: &str = "data.forecastSheet";
diff --git a/crates/engine/src/cmd/format.rs b/crates/engine/src/cmd/format.rs
index 744b6d136..69123dcfa 100644
--- a/crates/engine/src/cmd/format.rs
+++ b/crates/engine/src/cmd/format.rs
@@ -1,10 +1,13 @@
 //! Formatting: Home › Font, Alignment, Number, Styles, Cells › Format.
 
 use gridcraft_core::{CellRef, RangeRef};
-use gridcraft_model::*;
+use gridcraft_model::{BorderLine, BorderStyle, Borders, Color, Fill, HAlign, NumFmt, Style, StyleId, Theme, Underline, VAlign, VertAlign};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, ok, parse_lines, split_sheet, str_param,
+    target_ranges, target_sheet,
+};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/format/cell_styles.rs b/crates/engine/src/cmd/format/cell_styles.rs
index 53d378202..5ad0ccc15 100644
--- a/crates/engine/src/cmd/format/cell_styles.rs
+++ b/crates/engine/src/cmd/format/cell_styles.rs
@@ -1,4 +1,6 @@
-use super::*;
+use super::{
+    ACCOUNTING, BorderLine, BorderStyle, Borders, COMMA, Color, Fill, Json, NumFmt, Result, Session, Style, Theme, apply_style, bad, str_param,
+};
 
 /// Built-in cell styles (our own palette).
 pub fn builtin_cell_style(name: &str, theme: &Theme) -> Option<Style> {
diff --git a/crates/engine/src/cmd/format/sizes.rs b/crates/engine/src/cmd/format/sizes.rs
index 9d82f40c0..3335d6100 100644
--- a/crates/engine/src/cmd/format/sizes.rs
+++ b/crates/engine/src/cmd/format/sizes.rs
@@ -1,4 +1,6 @@
-use super::*;
+use super::{
+    CellRef, EngineError, Json, RangeRef, Result, Session, StyleId, bad, edit, f64_param, parse_lines, split_sheet, str_param, target_sheet,
+};
 
 // ---------------------------------------------------------------- sizes
 
diff --git a/crates/engine/src/cmd/formulas.rs b/crates/engine/src/cmd/formulas.rs
index 88c4cc76c..c9d8acec9 100644
--- a/crates/engine/src/cmd/formulas.rs
+++ b/crates/engine/src/cmd/formulas.rs
@@ -4,7 +4,10 @@ use gridcraft_core::{CellError, CellRef, RangeRef, Value};
 use gridcraft_model::{CalcMode, Cell, DefinedName, Formula, Workbook};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, Session, always, bad, bool_param, cell_param, cmd, edit, f64_param, has_doc, ok, stash, str_param,
+    target_range, target_ranges, target_sheet, u32_param,
+};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs
index 6dc2de5fe..7bba4086d 100644
--- a/crates/engine/src/cmd/insert.rs
+++ b/crates/engine/src/cmd/insert.rs
@@ -3,11 +3,18 @@
 
 use gridcraft_core::{CellRef, MAX_ROWS, RangeRef};
 use gridcraft_formula::adjust::{Axis, Edit};
-use gridcraft_model::*;
+use gridcraft_model::{
+    Anchor, BorderLine, BorderStyle, Borders, Cell, CellPicture, CfOperator, CfRule, CfValueKind, Chart, ChartKind, Color, Comment, CondFormat, Fill,
+    Formula, Hyperlink, Image, LegendPos, Series, Shape, ShapeKind, Sheet, Sparkline, SparklineKind, Style, Table, TableColumn, TotalsFn, Underline,
+    Workbook,
+};
 use serde_json::{Value as Json, json};
 
 use super::sheet::{rewrite, shift_cell_features};
-use super::*;
+use super::{
+    CommandSpec, EngineError, PROTECTED, Result, Session, anchor_mode_name, anchor_mode_param, bad, bool_param, cell_param, cell_param_on, cmd, edit,
+    f64_param, has_doc, locked_cell_error, ok, split_sheet, str_param, target_range, target_ranges, target_sheet, u32_param,
+};
 use crate::selection::current_region;
 
 mod chart;
diff --git a/crates/engine/src/cmd/insert/chart.rs b/crates/engine/src/cmd/insert/chart.rs
index 4817e41ec..bdd5e77d1 100644
--- a/crates/engine/src/cmd/insert/chart.rs
+++ b/crates/engine/src/cmd/insert/chart.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Anchor, CellRef, Chart, ChartKind, EngineError, Json, LegendPos, RangeRef, Result, Series, Session, Sheet, anchor_mode_param, bad, block,
+    bool_param, cell_param_on, edit, f64_param, json, split_sheet, str_param, target_ranges, target_sheet, u32_param,
+};
 
 fn chart_areas(s: &Session, p: &Json) -> Result<Vec<RangeRef>> {
     if p.get("range").is_some() {
diff --git a/crates/engine/src/cmd/insert/cond_format.rs b/crates/engine/src/cmd/insert/cond_format.rs
index aeeb9db55..faafcfcf2 100644
--- a/crates/engine/src/cmd/insert/cond_format.rs
+++ b/crates/engine/src/cmd/insert/cond_format.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Anchor, BorderLine, BorderStyle, Borders, CfOperator, CfRule, CfValueKind, Color, CondFormat, EngineError, Fill, Json, Result, Session, Shape,
+    ShapeKind, Style, anchor_mode_param, bad, bool_param, cell_param, edit, f64_param, json, ok, str_param, target_ranges, target_sheet, u32_param,
+};
 
 // ---------------------------------------------------------------- conditional formatting
 
diff --git a/crates/engine/src/cmd/insert/links.rs b/crates/engine/src/cmd/insert/links.rs
index a024350fd..59a69e6f9 100644
--- a/crates/engine/src/cmd/insert/links.rs
+++ b/crates/engine/src/cmd/insert/links.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Cell, Color, Comment, EngineError, Hyperlink, Json, RangeRef, Result, Session, Underline, Workbook, bool_param, cell_param_on, edit, json, ok,
+    split_sheet, str_param, target_ranges, target_sheet,
+};
 
 // ---------------------------------------------------------------- links & comments
 
diff --git a/crates/engine/src/cmd/insert/objects.rs b/crates/engine/src/cmd/insert/objects.rs
index e4486b7e4..9f51daf0f 100644
--- a/crates/engine/src/cmd/insert/objects.rs
+++ b/crates/engine/src/cmd/insert/objects.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Anchor, CellPicture, CellRef, Color, EngineError, Image, Json, PROTECTED, Result, Session, Shape, ShapeKind, Sparkline, SparklineKind,
+    anchor_mode_name, anchor_mode_param, bad, bool_param, cell_param, edit, f64_param, json, locked_cell_error, ok, str_param, u32_param,
+};
 
 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();
diff --git a/crates/engine/src/cmd/insert/table.rs b/crates/engine/src/cmd/insert/table.rs
index 461af7861..45f5a2162 100644
--- a/crates/engine/src/cmd/insert/table.rs
+++ b/crates/engine/src/cmd/insert/table.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Axis, Cell, CellRef, Edit, EngineError, Formula, Json, MAX_ROWS, RangeRef, Result, Session, Sheet, Style, Table, TableColumn, TotalsFn, bad,
+    block, bool_param, edit, json, rewrite, shift_cell_features, str_param, target_range, target_sheet, with,
+};
 
 // ---------------------------------------------------------------- tables
 
diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index f9d5f9dc3..ee4e05917 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -3,7 +3,7 @@
 use gridcraft_core::{CellRef, RangeRef, Value};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, EngineError, Result, Session, always, bad, bool_param, cell_param_on, cmd, has_doc, str_param, target_range, target_sheet};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/pivot.rs b/crates/engine/src/cmd/pivot.rs
index bbc66fa0c..1451e2dab 100644
--- a/crates/engine/src/cmd/pivot.rs
+++ b/crates/engine/src/cmd/pivot.rs
@@ -7,10 +7,16 @@
 use std::sync::Arc;
 
 use gridcraft_core::{CellRef, RangeRef};
-use gridcraft_model::*;
+use gridcraft_model::{
+    Anchor, Cell, Chart, ChartKind, LegendPos, NumFmt, PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout, PivotShowAs,
+    PivotSort, PivotTable, PivotValue, Sheet, StyleId, Workbook,
+};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, Ctx, EngineError, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, has_doc, ok, str_param,
+    u32_param,
+};
 use crate::pivot as pv;
 use crate::selection::current_region;
 
diff --git a/crates/engine/src/cmd/pivot/charts.rs b/crates/engine/src/cmd/pivot/charts.rs
index 0a0d72ed4..8ae00b161 100644
--- a/crates/engine/src/cmd/pivot/charts.rs
+++ b/crates/engine/src/cmd/pivot/charts.rs
@@ -1,5 +1,8 @@
 use super::create::{insert_pivot, source_param};
-use super::*;
+use super::{
+    Anchor, CellRef, Chart, ChartKind, EngineError, Json, LegendPos, PivotDateGroup, Result, Session, Workbook, anchor_mode_param, bad, cell_param,
+    edit, f64_param, find_pivot, json, other, pv, str_param,
+};
 
 // ---------------------------------------------------------------- PivotChart
 
diff --git a/crates/engine/src/cmd/pivot/create.rs b/crates/engine/src/cmd/pivot/create.rs
index 48770f3a0..5a65609c3 100644
--- a/crates/engine/src/cmd/pivot/create.rs
+++ b/crates/engine/src/cmd/pivot/create.rs
@@ -1,6 +1,9 @@
-use super::fields::{add_to_area, in_axes};
+use super::fields::{AreaPlacement, 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::*;
+use super::{
+    Arc, Cell, CellRef, Ctx, EngineError, Json, NumFmt, PivotDateGroup, PivotTable, RangeRef, Result, Session, Sheet, StyleId, Workbook, bad,
+    bool_param, cell_param, current_region, edit, find_pivot, json, other, pv, str_param, with,
+};
 
 // ---------------------------------------------------------------- insert
 
@@ -115,7 +118,9 @@ pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
         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::String(n) => {
+                        add_to_area(pt, &src, AreaPlacement { cmd: "insert.pivotTable", field: n, area, func: None, name: None, position: 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") {
@@ -124,7 +129,11 @@ pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
                             }
                             None => None,
                         };
-                        add_to_area("insert.pivotTable", pt, &src, n, area, func, str_param(f, "name"), None)?;
+                        add_to_area(
+                            pt,
+                            &src,
+                            AreaPlacement { cmd: "insert.pivotTable", field: n, area, func, name: str_param(f, "name"), position: None },
+                        )?;
                         let by = group_param(str_param(f, "group"));
                         if let Some(by) = by.filter(|b| *b != PivotDateGroup::None)
                             && matches!(area, "rows" | "columns")
diff --git a/crates/engine/src/cmd/pivot/fields.rs b/crates/engine/src/cmd/pivot/fields.rs
index 344a60af3..48c25657c 100644
--- a/crates/engine/src/cmd/pivot/fields.rs
+++ b/crates/engine/src/cmd/pivot/fields.rs
@@ -1,6 +1,9 @@
 use super::create::pivot_json;
 use super::params::{area_param, func_param, position_param, show_as_param};
-use super::*;
+use super::{
+    Json, PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotShowAs, PivotTable, PivotValue, Result, Session, Workbook, bad,
+    bool_param, edit, find_pivot, json, ok, other, pv, str_param, u32_param,
+};
 
 // ---------------------------------------------------------------- layout editing (pure)
 
@@ -104,16 +107,17 @@ fn auto_name(f: PivotFunc, field: &str) -> String {
 }
 
 /// 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<()> {
+pub(super) struct AreaPlacement<'a> {
+    pub cmd: &'a str,
+    pub field: &'a str,
+    pub area: &'a str,
+    pub func: Option<PivotFunc>,
+    pub name: Option<&'a str>,
+    pub position: Option<usize>,
+}
+
+pub(super) fn add_to_area(pt: &mut PivotTable, src: &pv::Source, placement: AreaPlacement<'_>) -> Result<()> {
+    let AreaPlacement { cmd, field, area, func, name, position } = placement;
     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."));
@@ -300,7 +304,7 @@ pub(super) fn add_field(s: &mut Session, p: &Json) -> Result<Json> {
     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)?;
+        add_to_area(pt, src, AreaPlacement { cmd: C, field: &field, area, func, name: name.as_deref(), position: pos })?;
         Ok(json!({"field": canonical_any(C, pt, src, &field)?, "area": area}))
     })
 }
@@ -364,7 +368,7 @@ pub(super) fn calculated_field(s: &mut Session, p: &Json) -> Result<Json> {
             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)?;
+            add_to_area(pt, src, AreaPlacement { cmd: C, field: &canon, area: "values", func: Some(PivotFunc::Sum), name: None, position: None })?;
         }
         Ok(json!({
             "name": canon,
@@ -452,7 +456,7 @@ pub(super) fn move_field(s: &mut Session, p: &Json) -> Result<Json> {
         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)?;
+        add_to_area(pt, src, AreaPlacement { cmd: C, field: &src_field, area: to, func: None, name: None, position: 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))) {
diff --git a/crates/engine/src/cmd/pivot/layout.rs b/crates/engine/src/cmd/pivot/layout.rs
index b3582ea46..9b6a9527e 100644
--- a/crates/engine/src/cmd/pivot/layout.rs
+++ b/crates/engine/src/cmd/pivot/layout.rs
@@ -1,7 +1,10 @@
 use super::create::source_param;
 use super::fields::{canonical, in_axes, shift_values, update};
 use super::params::{group_param, layout_name};
-use super::*;
+use super::{
+    Chart, Json, PivotDateGroup, PivotField, PivotFilter, PivotLayout, PivotSort, PivotTable, Result, Session, bad, bool_param, edit, find_pivot,
+    json, other, pv, str_param,
+};
 
 pub(super) fn filter(s: &mut Session, p: &Json) -> Result<Json> {
     const C: &str = "pivot.filter";
diff --git a/crates/engine/src/cmd/pivot/params.rs b/crates/engine/src/cmd/pivot/params.rs
index 8aa098479..b257621d8 100644
--- a/crates/engine/src/cmd/pivot/params.rs
+++ b/crates/engine/src/cmd/pivot/params.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, PivotDateGroup, PivotFunc, PivotLayout, PivotShowAs, PivotSort, Result, bad, u32_param};
 
 pub(super) fn area_param(cmd: &str, v: Option<&str>) -> Result<&'static str> {
     match v.map(str::to_ascii_lowercase) {
diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs
index 639f9b63d..4e4f6870c 100644
--- a/crates/engine/src/cmd/pivot/tests.rs
+++ b/crates/engine/src/cmd/pivot/tests.rs
@@ -243,6 +243,70 @@ fn compact_vs_tabular_shapes() {
     assert_eq!(text(&s, "A5"), "Apples");
 }
 
+fn assert_values_on_rows_default(s: &Session) {
+    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));
+}
+
+fn assert_values_on_rows_tabular(s: &mut Session) {
+    // 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");
+}
+
+fn assert_values_on_rows_position(s: &mut Session) {
+    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 values_on_rows_layouts() {
     let mut s = sales();
@@ -250,61 +314,9 @@ fn values_on_rows_layouts() {
     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());
+    assert_values_on_rows_default(&s);
+    assert_values_on_rows_tabular(&mut s);
+    assert_values_on_rows_position(&mut s);
 }
 
 #[test]
@@ -355,53 +367,65 @@ fn change_source_keeps_values_ahead_of_its_field() {
     assert_eq!(text(&s, "A5"), "Apples");
 }
 
+fn assert_values_between_compact_rows(s: &Session) {
+    // 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);
+}
+
+fn assert_values_between_outline(s: &mut Session) {
+    // 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));
+}
+
+fn assert_values_between_tabular(s: &mut Session) {
+    // 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 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));
+    assert_values_between_compact_rows(&s);
+    assert_values_between_outline(&mut s);
+    assert_values_between_tabular(&mut s);
 }
 
 #[test]
diff --git a/crates/engine/src/cmd/print.rs b/crates/engine/src/cmd/print.rs
index 3b6dcb0ec..cda52f31d 100644
--- a/crates/engine/src/cmd/print.rs
+++ b/crates/engine/src/cmd/print.rs
@@ -10,11 +10,16 @@
 //! codes.
 
 use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value};
-use gridcraft_model::*;
-use gridcraft_pdf::{Font, Page, PdfDoc, Rgb};
+#[cfg(test)]
+use gridcraft_model::{Alignment, Image, SheetViewMode};
+use gridcraft_model::{
+    Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PatternType, PrintSettings, ShapeKind, Sheet, Style, StyleId, StyleTable,
+    Underline, VAlign, Visibility, Workbook,
+};
+use gridcraft_pdf::{Font, Page, PdfDoc, Point, Rect, Rgb};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, split_sheet, str_param, target_sheet, u32_param};
 
 mod draw;
 mod header_footer;
@@ -27,6 +32,9 @@ 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,
 };
+/// Decoded pictures (bytes, width, height) keyed by (sheet, picture); `None` = undecodable.
+type PicCache = std::collections::HashMap<(usize, usize), Option<(Vec<u8>, u32, u32)>>;
+
 #[cfg(test)]
 use layout::bands;
 pub(crate) use layout::split_bands;
@@ -94,7 +102,7 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
     let mut printed_blocks = Vec::new();
     // Decoded pictures are reused across the pages their anchor covers: a floating picture
     // spanning 40 pages was decoded (and pushed into the PDF) 40 times (#2389).
-    let mut pics: std::collections::HashMap<(usize, usize), Option<(Vec<u8>, u32, u32)>> = std::collections::HashMap::new();
+    let mut pics = PicCache::new();
     for lay in layouts {
         let Some(sh) = wb.sheet(lay.sheet) else { continue };
         let mut cf = if sh.cond_formats.is_empty() { None } else { Some(crate::cf::CfCache::new()) };
@@ -116,7 +124,7 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
             for (rsi, rs) in rsegs.iter().enumerate() {
                 let mut x = ox + lay.heading_w * k;
                 for (csi, cs) in csegs.iter().enumerate() {
-                    let b = make_block(wb, lay.sheet, sh, *rs, *cs, x, y, lay);
+                    let b = make_block(wb, lay.sheet, sh, *rs, *cs, (x, y), lay);
                     draw_block(pg, &b, lay.settings.gridlines, &mut cf);
                     draw_block_links(pg, &b, page_index, &mut pending_links);
                     printed_blocks.push(PrintedBlock { page: page_index, sheet: lay.sheet, rows: *rs, cols: *cs, x, y, k });
@@ -155,7 +163,7 @@ pub fn render_pdf(wb: &Workbook, layouts: &[SheetLayout], file: &str, path: &str
             && let Some(page) = doc.page_mut(link.page)
         {
             let (lx, ly, w, h) = link.rect;
-            page.link_page(lx, ly, w, h, target_page, x, y);
+            page.link_page(Rect::new(lx, ly, w, h), target_page, Point::new(x, y));
         }
     }
     let n = doc.page_count();
diff --git a/crates/engine/src/cmd/print/draw.rs b/crates/engine/src/cmd/print/draw.rs
index 4f67f1449..d90335390 100644
--- a/crates/engine/src/cmd/print/draw.rs
+++ b/crates/engine/src/cmd/print/draw.rs
@@ -1,7 +1,10 @@
 use super::layout::{DENSE_BLOCK, SheetLayout};
 use super::objects::draw_cell_picture;
-use super::text::draw_text;
-use super::*;
+use super::text::{TextPlacement, draw_text};
+use super::{
+    BorderLine, BorderStyle, Borders, CellRef, Color, Font, Page, PatternType, Point, RangeRef, Rgb, Sheet, Style, StyleId, Underline, Workbook,
+    split_sheet,
+};
 
 // ---------------------------------------------------------------- drawing
 
@@ -151,7 +154,7 @@ pub(super) fn draw_prims(pg: &mut Page, prims: &[gridcraft_chart::Prim], xf: Xf)
                 };
                 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);
+                pg.text_rotated(Point::new(ax + dx * cs - dy * sn, ay + dx * sn + dy * cs), size, font, blend(*color), text, *rotation);
             }
         }
     }
@@ -207,10 +210,11 @@ fn border_dash(style: BorderStyle, k: f32) -> Vec<f32> {
     }
 }
 
-fn draw_border(pg: &mut Page, b: &BorderLine, wb: &Workbook, x0: f32, y0: f32, x1: f32, y1: f32, k: f32) {
+fn draw_border(pg: &mut Page, b: &BorderLine, wb: &Workbook, start: Point, end: Point, k: f32) {
     if b.is_none() {
         return;
     }
+    let (x0, y0, x1, y1) = (start.x, start.y, end.x, end.y);
     let color = rgb_of(b.color, wb).unwrap_or([0, 0, 0]);
     if b.style == BorderStyle::Double {
         let off = 1.0 * k;
@@ -221,7 +225,7 @@ fn draw_border(pg: &mut Page, b: &BorderLine, wb: &Workbook, x0: f32, y0: f32, x
         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));
+    pg.stroke_line_dashed(Point::new(x0, y0), Point::new(x1, y1), lw, color, &border_dash(b.style, k));
 }
 
 /// Draws the cells of a block: fills, gridlines, data bars, borders and text.
@@ -324,12 +328,12 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
             ),
             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);
+        draw_border(pg, &bd.top, b.wb, Point::new(x, y), Point::new(x + w, y), b.k);
+        draw_border(pg, &bottom, b.wb, Point::new(x, y + h), Point::new(x + w, y + h), b.k);
+        draw_border(pg, &bd.left, b.wb, Point::new(x, y), Point::new(x, y + h), b.k);
+        draw_border(pg, &right, b.wb, Point::new(x + w, y), Point::new(x + w, y + h), b.k);
+        draw_border(pg, &bd.diag_down, b.wb, Point::new(x, y), Point::new(x + w, y + h), b.k);
+        draw_border(pg, &bd.diag_up, b.wb, Point::new(x, y + h), Point::new(x + w, y), b.k);
     }
     // Text.
     for (c, l) in &looks {
@@ -340,7 +344,7 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
         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));
+            draw_text(pg, b, TextPlacement { cell: *c, look: l, rect: (x, y, w, h), merged, merges: &merges, limits: (bx, bx + bw) });
         }
     }
     pg.restore();
@@ -444,10 +448,10 @@ pub(super) fn make_block<'a>(
     sh: &'a Sheet,
     rows: (u32, u32),
     cols: (u32, u32),
-    x: f32,
-    y: f32,
+    origin: (f32, f32),
     lay: &SheetLayout,
 ) -> Block<'a> {
+    let (x, y) = origin;
     let k = lay.k();
     let mut xs = Vec::with_capacity((cols.1 - cols.0 + 2) as usize);
     let mut acc = x;
diff --git a/crates/engine/src/cmd/print/header_footer.rs b/crates/engine/src/cmd/print/header_footer.rs
index 769e3b3ad..0f973d7fb 100644
--- a/crates/engine/src/cmd/print/header_footer.rs
+++ b/crates/engine/src/cmd/print/header_footer.rs
@@ -1,5 +1,5 @@
 use super::layout::SheetLayout;
-use super::*;
+use super::{Font, Page, Value, Workbook};
 
 /// 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;
diff --git a/crates/engine/src/cmd/print/layout.rs b/crates/engine/src/cmd/print/layout.rs
index 55e874de7..83ff45183 100644
--- a/crates/engine/src/cmd/print/layout.rs
+++ b/crates/engine/src/cmd/print/layout.rs
@@ -1,5 +1,8 @@
 use super::header_footer::HF_FIXED_SIDE_MARGIN;
-use super::*;
+use super::{
+    Anchor, CellRef, Json, MAX_COLS, MAX_PAGES, MAX_ROWS, Orientation, PX_TO_PT, PrintSettings, RangeRef, Result, Sheet, Visibility, Workbook, bad,
+    bool_param, split_sheet, str_param,
+};
 
 /// Cells in a page block above which only stored cells are visited (not every grid position).
 pub(super) const DENSE_BLOCK: u64 = 60_000;
@@ -287,10 +290,13 @@ pub fn layout_sheet(wb: &Workbook, si: usize, opts: &PrintOptions, range_overrid
     Some(lay)
 }
 
+/// Inclusive-start/end index spans of the pages along one axis.
+pub(crate) type Bands = Vec<(u32, u32)>;
+
 /// 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)>) {
+pub(crate) fn split_bands(sh: &Sheet, lay: &SheetLayout, cap: usize) -> (Bands, Bands) {
     let k = lay.k();
     let (aw, ah) = lay.avail();
     let (aw, ah) = (aw / k, ah / k);
diff --git a/crates/engine/src/cmd/print/objects.rs b/crates/engine/src/cmd/print/objects.rs
index 83044836e..d2128f961 100644
--- a/crates/engine/src/cmd/print/objects.rs
+++ b/crates/engine/src/cmd/print/objects.rs
@@ -1,6 +1,6 @@
 use super::draw::{Block, PdfMeasure, Xf, draw_prims, rgb_of};
 use super::text::wrap_lines;
-use super::*;
+use super::{Anchor, Font, Page, RangeRef, Rect, ShapeKind, Sheet, Value, Workbook};
 
 /// 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) {
@@ -25,7 +25,7 @@ pub(super) fn draw_cell_picture(pg: &mut Page, data: &[u8], rect: (f32, f32, f32
         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());
+    pg.image_rgba(Rect::new(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.
@@ -49,14 +49,7 @@ fn decode_image(data: &[u8], max_w: u32, max_h: u32) -> Option<(Vec<u8>, u32, u3
 /// 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)>>,
-) {
+pub(super) fn draw_objects(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet, b: &Block, pics: &mut super::PicCache) {
     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)));
@@ -77,7 +70,7 @@ pub(super) fn draw_objects(
         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);
+            pg.image_rgba(Rect::new(x, y, w, h), px, [*pw, *ph]);
         }
     }
     for shp in &sh.shapes {
diff --git a/crates/engine/src/cmd/print/text.rs b/crates/engine/src/cmd/print/text.rs
index 2e1029b48..6f71699ce 100644
--- a/crates/engine/src/cmd/print/text.rs
+++ b/crates/engine/src/cmd/print/text.rs
@@ -1,5 +1,5 @@
 use super::draw::{Block, Look, rgb_of};
-use super::*;
+use super::{CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, Sheet, Style, StyleTable, Underline, VAlign, Value};
 
 const PAD_PX: f32 = 2.0;
 
@@ -51,11 +51,55 @@ fn font_for(style: &Style) -> Font {
     Font::styled(Font::family_for(&style.font.name), style.font.bold, style.font.italic)
 }
 
+fn text_align(align: HAlign, value: &Value) -> HAlign {
+    match align {
+        HAlign::General => match value {
+            Value::Number(_) => HAlign::Right,
+            Value::Bool(_) | Value::Error(_) => HAlign::Center,
+            _ => HAlign::Left,
+        },
+        HAlign::CenterAcross | HAlign::Distributed => HAlign::Center,
+        HAlign::Justify | HAlign::Fill => HAlign::Left,
+        other => other,
+    }
+}
+
 /// 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))
 }
 
+fn extend_text_bounds(sh: &Sheet, c: CellRef, merges: &[RangeRef], k: f32, need: f32, align: HAlign, bounds: (f32, f32)) -> (f32, f32) {
+    let (mut clip_l, mut clip_r) = bounds;
+    let grow = |dir: i64, mut remaining: f32| -> f32 {
+        let mut ext = 0.0;
+        let mut col = c.col as i64 + dir;
+        while remaining > 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 width = sh.col_width(nc.col) * k;
+            ext += width;
+            remaining -= width;
+            col += dir;
+            if ext > 20_000.0 {
+                break;
+            }
+        }
+        ext
+    };
+    match 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),
+    }
+    (clip_l, clip_r)
+}
+
 /// 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;
@@ -71,16 +115,17 @@ pub(super) fn center_across_width(styles: &StyleTable, sh: &Sheet, c: CellRef, m
     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),
-) {
+pub(super) struct TextPlacement<'a> {
+    pub cell: CellRef,
+    pub look: &'a Look,
+    pub rect: (f32, f32, f32, f32),
+    pub merged: bool,
+    pub merges: &'a [RangeRef],
+    pub limits: (f32, f32),
+}
+
+pub(super) fn draw_text(pg: &mut Page, b: &Block, placement: TextPlacement<'_>) {
+    let TextPlacement { cell: c, look: l, rect, merged, merges, limits } = placement;
     let (x, y, w, h) = rect;
     let sh = b.sh;
     let wb = b.wb;
@@ -133,20 +178,7 @@ pub(super) fn draw_text(
         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 h_align = text_align(st.align.h, &v);
     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.
@@ -170,32 +202,7 @@ pub(super) fn draw_text(
     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),
-        }
+        (clip_l, clip_r) = extend_text_bounds(sh, c, merges, b.k, need, h_align, (clip_l, clip_r));
     }
     let clip_l = clip_l.max(limits.0);
     let clip_r = clip_r.min(limits.1);
@@ -215,7 +222,7 @@ pub(super) fn draw_text(
             } else {
                 (x + pad + (last - i) * line_h, y + pad + size * 0.8)
             };
-            pg.text_rotated(ox, oy, size, font, color, t, angle);
+            pg.text_rotated(Point::new(ox, oy), size, font, color, t, angle);
         }
         pg.restore();
         return;
diff --git a/crates/engine/src/cmd/review.rs b/crates/engine/src/cmd/review.rs
index 9811fde9e..d1aea3cc7 100644
--- a/crates/engine/src/cmd/review.rs
+++ b/crates/engine/src/cmd/review.rs
@@ -5,7 +5,7 @@ use gridcraft_core::CellRef;
 use gridcraft_model::{EditRange, PasswordHash, SheetProtection, Visibility, password_hash};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, DocState, EngineError, Result, Session, bad, bool_param, cmd, edit, has_doc, str_param, target_ranges, target_sheet};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/sheet/tabs.rs b/crates/engine/src/cmd/sheet/tabs.rs
index 245404723..13956e35c 100644
--- a/crates/engine/src/cmd/sheet/tabs.rs
+++ b/crates/engine/src/cmd/sheet/tabs.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arc, CellRef, Ctx, EngineError, Json, Result, Session, Sheet, Visibility, bad, bool_param, edit, json, ok, str_param, target_sheet};
 
 pub(super) fn insert_sheet(s: &mut Session, p: &Json) -> Result<Json> {
     if s.doc()?.wb.protected_structure {
diff --git a/crates/engine/src/cmd/slicer.rs b/crates/engine/src/cmd/slicer.rs
index 10e3cf13c..bd961c9d5 100644
--- a/crates/engine/src/cmd/slicer.rs
+++ b/crates/engine/src/cmd/slicer.rs
@@ -6,10 +6,12 @@
 //! `table.insertSlicer`) selects everything, i.e. applies no filter.
 
 use gridcraft_core::CellRef;
-use gridcraft_model::*;
+use gridcraft_model::{Anchor, AnchorMode, AutoFilter, FilterCriterion, Slicer, Workbook};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, Session, bad, bool_param, cell_param_on, cmd, edit, f64_param, has_doc, str_param, target_sheet, u32_param,
+};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/solver.rs b/crates/engine/src/cmd/solver.rs
index d42b75961..2cb3da434 100644
--- a/crates/engine/src/cmd/solver.rs
+++ b/crates/engine/src/cmd/solver.rs
@@ -97,9 +97,17 @@ struct Solve {
     evo_end: Option<EvoEnd>,
 }
 
+/// Variable bounds and integrality flags.
+#[derive(Clone, Copy)]
+struct Bounds<'a> {
+    lo: &'a [f64],
+    hi: &'a [f64],
+    integer: &'a [bool],
+}
+
 /// Runs the model's method for `goal` within `lo..hi` from `x0`.
-#[allow(clippy::too_many_arguments)]
-fn optimise(ev: &mut Evaluator, m: &Model, goal: Goal, x0: &[f64], lo: &[f64], hi: &[f64], integer: &[bool], gap: f64) -> Solve {
+fn optimise(ev: &mut Evaluator, m: &Model, goal: Goal, x0: &[f64], bounds: Bounds, gap: f64) -> Solve {
+    let Bounds { lo, hi, integer } = bounds;
     let any_int = integer.iter().any(|b| *b);
     let mut not_linear = false;
     let mut evo_end = None;
@@ -203,7 +211,8 @@ fn run(s: &mut Session, p: &Json) -> Result<Json> {
                 .into(),
         ));
     }
-    let Solve { outcome, not_linear, evo_end } = optimise(&mut ev, &model, model.goal, &x0, &prob.lo, &prob.hi, &prob.integer, gap);
+    let Solve { outcome, not_linear, evo_end } =
+        optimise(&mut ev, &model, model.goal, &x0, Bounds { lo: &prob.lo, hi: &prob.hi, integer: &prob.integer }, gap);
     let (status, message, solution) = match outcome {
         _ if not_linear => ("notLinear", "The model isn't linear in the variable cells, so Simplex LP can't solve it. Try GRG Nonlinear.", None),
         Outcome::Solved(x, _, true) if model.method == Method::Evolutionary => match evo_end {
diff --git a/crates/engine/src/cmd/solver/evolutionary.rs b/crates/engine/src/cmd/solver/evolutionary.rs
index 391d4e8ed..def1ef7d8 100644
--- a/crates/engine/src/cmd/solver/evolutionary.rs
+++ b/crates/engine/src/cmd/solver/evolutionary.rs
@@ -2,7 +2,7 @@ use super::lp::{Outcome, Row, Sense};
 use super::model::{EvoOptions, Goal};
 use super::nlp::{project, shape, violation};
 use super::problem::Evaluator;
-use super::*;
+use super::{MAX_POPULATION, MIN_POPULATION, PRECISION};
 
 // ---------------------------------------------------------------- evolutionary
 
diff --git a/crates/engine/src/cmd/solver/lp.rs b/crates/engine/src/cmd/solver/lp.rs
index 29dad10db..3c1462d71 100644
--- a/crates/engine/src/cmd/solver/lp.rs
+++ b/crates/engine/src/cmd/solver/lp.rs
@@ -1,8 +1,13 @@
 use super::problem::Evaluator;
-use super::*;
+use super::{CellRef, EPS};
 
 // ---------------------------------------------------------------- evaluation
 
+type BoundRow = (Vec<(usize, f64)>, Sense, f64);
+
+/// Objective (gradient, constant) and per-row (gradient, constant).
+pub(super) type Linearized = ((Vec<f64>, f64), Vec<(Vec<f64>, f64)>);
+
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub(super) enum Sense {
     Le,
@@ -29,6 +34,188 @@ pub(super) enum Outcome {
     Limit,
 }
 
+struct Map {
+    var: usize,
+    sign: f64,
+}
+
+struct VariableMap {
+    columns: Vec<Map>,
+    offset: Vec<f64>,
+    bound_rows: Vec<BoundRow>,
+}
+
+struct Tableau {
+    rows: Vec<Vec<f64>>,
+    basis: Vec<usize>,
+    width: usize,
+    decision_cols: usize,
+    slack_cols: usize,
+    artificial_cols: usize,
+}
+
+fn map_variables(n: usize, lo: &[f64], hi: &[f64]) -> VariableMap {
+    let mut columns = Vec::new();
+    let mut offset = vec![0.0; n];
+    let mut bound_rows = Vec::new();
+    for j in 0..n {
+        let lower = lo.get(j).copied().unwrap_or(f64::NEG_INFINITY);
+        let upper = hi.get(j).copied().unwrap_or(f64::INFINITY);
+        if lower.is_finite() {
+            if let Some(value) = offset.get_mut(j) {
+                *value = lower;
+            }
+            columns.push(Map { var: j, sign: 1.0 });
+            if upper.is_finite() {
+                bound_rows.push((vec![(columns.len() - 1, 1.0)], Sense::Le, upper - lower));
+            }
+        } else if upper.is_finite() {
+            if let Some(value) = offset.get_mut(j) {
+                *value = upper;
+            }
+            columns.push(Map { var: j, sign: -1.0 });
+        } else {
+            columns.push(Map { var: j, sign: 1.0 });
+            columns.push(Map { var: j, sign: -1.0 });
+        }
+    }
+    VariableMap { columns, offset, bound_rows }
+}
+
+fn normalize_rows(rows: &[(Vec<f64>, Sense, f64)], bound_rows: Vec<BoundRow>, columns: &[Map], offset: &[f64]) -> Vec<(Vec<f64>, Sense, f64)> {
+    let width = columns.len();
+    let mut transformed = Vec::with_capacity(rows.len() + bound_rows.len());
+    for (coefficients, sense, rhs) in rows {
+        let mut row = vec![0.0; width];
+        for (index, mapping) in columns.iter().enumerate() {
+            if let Some(value) = row.get_mut(index) {
+                *value = coefficients.get(mapping.var).copied().unwrap_or(0.0) * mapping.sign;
+            }
+        }
+        let shift: f64 = coefficients.iter().zip(offset).map(|(coefficient, base)| coefficient * base).sum();
+        transformed.push((row, *sense, rhs - shift));
+    }
+    for (entries, sense, rhs) in bound_rows {
+        let mut row = vec![0.0; width];
+        for (index, value) in entries {
+            if let Some(slot) = row.get_mut(index) {
+                *slot = value;
+            }
+        }
+        transformed.push((row, sense, rhs));
+    }
+    // Rows with a negative right side are negated so every right side is >= 0.
+    transformed
+        .into_iter()
+        .map(|(row, sense, rhs)| {
+            if rhs < 0.0 {
+                let sense = match sense {
+                    Sense::Le => Sense::Ge,
+                    Sense::Ge => Sense::Le,
+                    Sense::Eq => Sense::Eq,
+                };
+                (row.iter().map(|v| -v).collect(), sense, -rhs)
+            } else {
+                (row, sense, rhs)
+            }
+        })
+        .collect()
+}
+
+fn build_tableau(normalized: &[(Vec<f64>, Sense, f64)], decision_cols: usize, slack_cols: usize, artificial_cols: usize) -> Tableau {
+    let width = decision_cols + slack_cols + artificial_cols;
+    let mut rows = Vec::with_capacity(normalized.len());
+    let mut basis = vec![0usize; normalized.len()];
+    let (mut slack, mut artificial) = (decision_cols, decision_cols + slack_cols);
+    for (i, (coefficients, sense, rhs)) in normalized.iter().enumerate() {
+        let mut row = vec![0.0; width + 1];
+        for (value, coefficient) in row.iter_mut().zip(coefficients) {
+            *value = *coefficient;
+        }
+        let basic = match sense {
+            Sense::Le => {
+                if let Some(value) = row.get_mut(slack) {
+                    *value = 1.0;
+                }
+                let basic = slack;
+                slack += 1;
+                basic
+            }
+            Sense::Ge => {
+                if let Some(value) = row.get_mut(slack) {
+                    *value = -1.0;
+                }
+                slack += 1;
+                if let Some(value) = row.get_mut(artificial) {
+                    *value = 1.0;
+                }
+                let basic = artificial;
+                artificial += 1;
+                basic
+            }
+            Sense::Eq => {
+                if let Some(value) = row.get_mut(artificial) {
+                    *value = 1.0;
+                }
+                let basic = artificial;
+                artificial += 1;
+                basic
+            }
+        };
+        if let Some(value) = row.get_mut(width) {
+            *value = *rhs;
+        }
+        if let Some(slot) = basis.get_mut(i) {
+            *slot = basic;
+        }
+        rows.push(row);
+    }
+    Tableau { rows, basis, width, decision_cols, slack_cols, artificial_cols }
+}
+
+fn phase_one(tableau: &mut Tableau, normalized: &[(Vec<f64>, Sense, f64)], budget: &mut u64) -> Result<(), Outcome> {
+    if tableau.artificial_cols == 0 {
+        return Ok(());
+    }
+    let mut objective = vec![0.0; tableau.width + 1];
+    for column in tableau.decision_cols + tableau.slack_cols..tableau.width {
+        if let Some(value) = objective.get_mut(column) {
+            *value = 1.0;
+        }
+    }
+    for (i, row) in tableau.rows.iter().enumerate() {
+        if tableau.basis.get(i).is_some_and(|basic| *basic >= tableau.decision_cols + tableau.slack_cols) {
+            for (value, coefficient) in objective.iter_mut().zip(row) {
+                *value -= coefficient;
+            }
+        }
+    }
+    let all = vec![true; tableau.width];
+    if matches!(simplex(&mut tableau.rows, &mut tableau.basis, &mut objective, &all, budget), Step::Limit) {
+        return Err(Outcome::Limit);
+    }
+    let scale = normalized.iter().map(|row| row.2.abs()).fold(1.0f64, f64::max);
+    if -objective.get(tableau.width).copied().unwrap_or(0.0) > 1e-7 * scale {
+        return Err(Outcome::Infeasible);
+    }
+    for i in 0..tableau.rows.len() {
+        if !tableau.basis.get(i).is_some_and(|basic| *basic >= tableau.decision_cols + tableau.slack_cols) {
+            continue;
+        }
+        let pivot_col = tableau
+            .rows
+            .get(i)
+            .and_then(|row| (0..tableau.decision_cols + tableau.slack_cols).find(|&column| row.get(column).is_some_and(|value| value.abs() > EPS)));
+        if let Some(column) = pivot_col {
+            pivot(&mut tableau.rows, &mut objective, i, column);
+            if let Some(basic) = tableau.basis.get_mut(i) {
+                *basic = column;
+            }
+        }
+    }
+    Ok(())
+}
+
 /// Depth-first branch and bound over a relaxation solver; returns the best integer point.
 pub(super) fn branch_and_bound(
     lo: &[f64],
@@ -201,165 +388,23 @@ fn simplex(t: &mut [Vec<f64>], basis: &mut [usize], obj: &mut [f64], allowed: &[
 
 /// 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 mapping = map_variables(c.len(), lo, hi);
+    let VariableMap { columns: cols, offset, bound_rows: extra } = mapping;
     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;
-                }
-            }
-        }
+    let normalized = normalize_rows(rows, extra, &cols, &offset);
+    let n_slack = normalized.iter().filter(|row| row.1 != Sense::Eq).count();
+    let n_art = normalized.iter().filter(|row| row.1 != Sense::Le).count();
+    let mut tableau = build_tableau(&normalized, ny, n_slack, n_art);
+    if let Err(outcome) = phase_one(&mut tableau, &normalized, budget) {
+        return outcome;
     }
+    let Tableau { rows: mut t, mut basis, width, decision_cols: ny, slack_cols: n_slack, .. } = tableau;
+    let is_art = |column: usize| column >= ny + n_slack && column < width;
     // 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() {
@@ -402,8 +447,7 @@ pub(super) fn solve_lp(c: &[f64], rows: &[(Vec<f64>, Sense, f64)], lo: &[f64], h
 
 /// 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> {
+pub(super) fn linearize(ev: &mut Evaluator, x0: &[f64]) -> std::result::Result<Linearized, &'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()) {
diff --git a/crates/engine/src/cmd/solver/model.rs b/crates/engine/src/cmd/solver/model.rs
index b97eccd78..d959b5907 100644
--- a/crates/engine/src/cmd/solver/model.rs
+++ b/crates/engine/src/cmd/solver/model.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CMD, CellRef, DefinedName, EngineError, Json, MAX_CONSTRAINTS, MAX_POPULATION, MAX_VARS, MIN_POPULATION, RangeRef, Result, Session, Workbook,
+    bad, bool_param, f64_param, json, split_sheet, str_param,
+};
 
 // ---------------------------------------------------------------- model
 
diff --git a/crates/engine/src/cmd/solver/nlp.rs b/crates/engine/src/cmd/solver/nlp.rs
index 6219e9b23..a85baea7a 100644
--- a/crates/engine/src/cmd/solver/nlp.rs
+++ b/crates/engine/src/cmd/solver/nlp.rs
@@ -1,7 +1,7 @@
+use super::PRECISION;
 use super::lp::{Outcome, Row, Sense};
 use super::model::Goal;
 use super::problem::{Evaluator, Point};
-use super::*;
 
 // ---------------------------------------------------------------- nonlinear
 
diff --git a/crates/engine/src/cmd/solver/problem.rs b/crates/engine/src/cmd/solver/problem.rs
index be74a81af..6d6cce847 100644
--- a/crates/engine/src/cmd/solver/problem.rs
+++ b/crates/engine/src/cmd/solver/problem.rs
@@ -1,6 +1,6 @@
 use super::lp::{Row, Sense};
 use super::model::{Model, Rel, Rhs};
-use super::*;
+use super::{CellRef, Trial, Value};
 
 /// The values the solvers see at a point: the objective and `lhs − rhs` per row.
 #[derive(Clone, Debug)]
diff --git a/crates/engine/src/cmd/solver/reports.rs b/crates/engine/src/cmd/solver/reports.rs
index 9f3b82866..eade2789b 100644
--- a/crates/engine/src/cmd/solver/reports.rs
+++ b/crates/engine/src/cmd/solver/reports.rs
@@ -1,7 +1,10 @@
 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::*;
+use super::{
+    Cell, CellRef, Ctx, DEFAULT_EVALS, DocState, EngineError, Json, MAX_EVALS, PRECISION, REPORT_CMD, Result, Session, Sheet, Trial, Value, bad,
+    edit, json, optimise, str_param,
+};
 
 // ---------------------------------------------------------------- reports
 
@@ -226,7 +229,7 @@ fn limits_report(d: &DocState, sh: &Sheet, inp: &ReportInput) -> Result<Lines> {
             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);
+            let solve = optimise(&mut ev, m, goal, x, super::Bounds { lo: &lo, hi: &hi, integer: &inp.prob.integer }, 0.0);
             ends.push(match solve.outcome {
                 Outcome::Solved(p, _, _) => {
                     let v = p.get(j).copied().unwrap_or(f64::NAN);
diff --git a/crates/engine/src/cmd/spelling.rs b/crates/engine/src/cmd/spelling.rs
index 1dd3df7a5..470cf6ccb 100644
--- a/crates/engine/src/cmd/spelling.rs
+++ b/crates/engine/src/cmd/spelling.rs
@@ -7,7 +7,7 @@ use std::sync::OnceLock;
 use gridcraft_core::{RangeRef, Value};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, EngineError, Result, Session, bad, bool_param, cell_param, cmd, has_doc, ok, str_param, target_range, target_sheet};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
diff --git a/crates/engine/src/cmd/view.rs b/crates/engine/src/cmd/view.rs
index 876f92cea..c508890c3 100644
--- a/crates/engine/src/cmd/view.rs
+++ b/crates/engine/src/cmd/view.rs
@@ -1,10 +1,13 @@
 //! View tab (sheet view state that's saved with the file) and Page Layout settings.
 
-use gridcraft_core::{CellRef, RangeRef};
+use gridcraft_core::RangeRef;
 use gridcraft_model::Orientation;
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{
+    CommandSpec, EngineError, Result, Session, always, bad, bool_param, cell_param, cell_param_on, cmd, edit, f64_param, has_doc, str_param,
+    target_range, target_sheet, u32_param,
+};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
@@ -493,9 +496,6 @@ fn theme(s: &mut Session, p: &Json) -> Result<Json> {
     })
 }
 
-#[allow(dead_code)]
-fn unused(_: CellRef) {}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/engine/src/cmd/whatif.rs b/crates/engine/src/cmd/whatif.rs
index 7b6f20c8d..c801c7359 100644
--- a/crates/engine/src/cmd/whatif.rs
+++ b/crates/engine/src/cmd/whatif.rs
@@ -14,7 +14,7 @@ use gridcraft_model::{CalcMode, Cell, DefinedName, Sheet, StyleId, Workbook};
 use serde::{Deserialize, Serialize};
 use serde_json::{Value as Json, json};
 
-use super::*;
+use super::{CommandSpec, DocState, EngineError, Result, Session, bad, bool_param, cmd, edit, f64_param, has_doc, split_sheet, str_param};
 
 mod advanced_filter;
 mod consolidate;
diff --git a/crates/engine/src/cmd/whatif/advanced_filter.rs b/crates/engine/src/cmd/whatif/advanced_filter.rs
index 53e55820c..e21004342 100644
--- a/crates/engine/src/cmd/whatif/advanced_filter.rs
+++ b/crates/engine/src/cmd/whatif/advanced_filter.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Cell, CellRef, EngineError, HashSet, Json, RangeRef, Result, Session, Value, bad, bool_param, edit, json, parse_range, str_param};
 
 // ---------------------------------------------------------------- advanced filter
 
diff --git a/crates/engine/src/cmd/whatif/consolidate.rs b/crates/engine/src/cmd/whatif/consolidate.rs
index 1962f64e5..ec5fbb54a 100644
--- a/crates/engine/src/cmd/whatif/consolidate.rs
+++ b/crates/engine/src/cmd/whatif/consolidate.rs
@@ -1,4 +1,6 @@
-use super::*;
+use super::{
+    Cell, CellRef, EngineError, HashMap, Json, RangeRef, Result, Session, StyleId, Value, bad, bool_param, edit, json, parse_range, str_param,
+};
 
 // ---------------------------------------------------------------- consolidate
 
diff --git a/crates/engine/src/cmd/whatif/scenarios.rs b/crates/engine/src/cmd/whatif/scenarios.rs
index 15aa053eb..fc442f8f9 100644
--- a/crates/engine/src/cmd/whatif/scenarios.rs
+++ b/crates/engine/src/cmd/whatif/scenarios.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    Cell, CellRef, DefinedName, Deserialize, EngineError, HashMap, Json, Result, Serialize, Session, Sheet, StyleId, Trial, Value, Workbook, bad,
+    bool_param, cell_list, edit, json, json_value, str_param, value_json,
+};
 
 // ---------------------------------------------------------------- scenarios
 
diff --git a/crates/engine/src/fill.rs b/crates/engine/src/fill.rs
index b12700e4f..c4354ec7c 100644
--- a/crates/engine/src/fill.rs
+++ b/crates/engine/src/fill.rs
@@ -540,8 +540,19 @@ fn split_num(t: &str) -> Option<(String, i64, String, usize)> {
     Some((prefix, n, suffix, width))
 }
 
+/// Options for filling a numeric or date series.
+pub struct SeriesOptions<'a> {
+    pub range: RangeRef,
+    pub rows: bool,
+    pub kind: &'a str,
+    pub step: f64,
+    pub stop: Option<f64>,
+    pub unit: &'a str,
+}
+
 /// Home › Fill › Series.
-pub fn series(cx: &mut Ctx, sheet: usize, r: RangeRef, rows: bool, kind: &str, step: f64, stop: Option<f64>, unit: &str) -> Result<()> {
+pub fn series(cx: &mut Ctx, sheet: usize, options: SeriesOptions<'_>) -> Result<()> {
+    let SeriesOptions { range: r, rows, kind, step, stop, unit } = options;
     let sys = cx.wb.date_system;
     let Some(sh) = cx.wb.sheet(sheet) else { return Ok(()) };
     let lanes: Vec<u32> = if rows { (r.start.row..=r.end.row).collect() } else { (r.start.col..=r.end.col).collect() };
diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs
index f51fcbe61..99548d4d3 100644
--- a/crates/engine/src/io.rs
+++ b/crates/engine/src/io.rs
@@ -606,6 +606,7 @@ fn script_sandbox_check(path: &str) -> Result<()> {
 
 /// The largest native file the reader still touches: its own cap plus one, used to stop
 /// reads whose bytes arrive faster than metadata can claim (device files, growing files).
+#[cfg(not(target_arch = "wasm32"))]
 const MAX_READ_BYTES: u64 = 2 * 1024 * 1024 * 1024;
 
 #[cfg(not(target_arch = "wasm32"))]
diff --git a/crates/engine/src/pivot/charts.rs b/crates/engine/src/pivot/charts.rs
index 0126d6c7b..bc5d8e597 100644
--- a/crates/engine/src/pivot/charts.rs
+++ b/crates/engine/src/pivot/charts.rs
@@ -1,5 +1,5 @@
 use super::output::Output;
-use super::*;
+use super::{CellRef, Chart, Series, Workbook, quote_sheet};
 
 // ---------------------------------------------------------------- PivotCharts
 
diff --git a/crates/engine/src/pivot/compute.rs b/crates/engine/src/pivot/compute.rs
index 19864ab9a..9ebf44737 100644
--- a/crates/engine/src/pivot/compute.rs
+++ b/crates/engine/src/pivot/compute.rs
@@ -1,6 +1,9 @@
 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::*;
+use super::{
+    CalcSet, CellError, CellRef, HashMap, HashSet, MAX_AXIS_FIELDS, MAX_COLS, MAX_VALUE_FIELDS, PivotDateGroup, PivotField, PivotFilter, PivotFunc,
+    PivotLayout, PivotShowAs, PivotTable, PivotValue, Source, Value, Workbook, read_source,
+};
 
 /// Why Show Details turns a cell down when it isn't a value cell of a PivotTable (the front end
 /// edits that cell instead).
@@ -52,16 +55,388 @@ fn check_current(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize, out: &Outpu
     Ok(())
 }
 
+type ProbePath = (usize, Vec<u32>, Vec<u32>);
+
 /// 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>)>>,
+    paths: Option<Vec<ProbePath>>,
     cells: Option<HashSet<(usize, usize)>>,
 }
 
+struct AggregateInput<'a> {
+    wb: &'a Workbook,
+    pt: &'a PivotTable,
+    src: &'a Source,
+    rows: &'a [(usize, &'a PivotField)],
+    cols: &'a [(usize, &'a PivotField)],
+    vals: &'a [(ValSrc, &'a PivotValue)],
+    extra: &'a [usize],
+    filters: &'a [(usize, &'a PivotFilter, PivotDateGroup, bool)],
+    filter_fmts: &'a [String],
+    row_fmts: &'a [String],
+    col_fmts: &'a [String],
+    empty: bool,
+}
+
+#[derive(Default)]
+struct AggregateData {
+    row_items: Vec<FieldItems>,
+    col_items: Vec<FieldItems>,
+    aggs: AggMap,
+    row_set: HashSet<Vec<u32>>,
+    col_set: HashSet<Vec<u32>>,
+    col_leaves: HashSet<Vec<u32>>,
+}
+
+fn aggregate_record(
+    input: &AggregateInput<'_>,
+    data: &mut AggregateData,
+    probe: &mut Option<&mut Probe>,
+    ri: usize,
+    rec: &[Value],
+) -> Result<(), String> {
+    for ((c, field, group, _), fmt) in input.filters.iter().zip(input.filter_fmts) {
+        if let Some(selected) = &field.selected {
+            let label = item_label(input.wb, rec.get(*c).unwrap_or(&Value::Empty), *group, fmt);
+            if !selected.iter().any(|value| value.eq_ignore_ascii_case(&label)) {
+                return Ok(());
+            }
+        }
+    }
+    if input.empty {
+        return Ok(());
+    }
+    let mut row_path = Vec::with_capacity(input.rows.len());
+    for (((column, field), items), fmt) in input.rows.iter().zip(data.row_items.iter_mut()).zip(input.row_fmts) {
+        row_path.push(items.intern(input.wb, rec.get(*column).unwrap_or(&Value::Empty), field.date_group, fmt, ri));
+    }
+    let mut col_path = Vec::with_capacity(input.cols.len());
+    for (((column, field), items), fmt) in input.cols.iter().zip(data.col_items.iter_mut()).zip(input.col_fmts) {
+        col_path.push(items.intern(input.wb, rec.get(*column).unwrap_or(&Value::Empty), field.date_group, fmt, ri));
+    }
+    for row_depth in 0..=row_path.len() {
+        for col_depth in 0..=col_path.len() {
+            let accs = data
+                .aggs
+                .entry((row_path[..row_depth].to_vec(), col_path[..col_depth].to_vec()))
+                .or_insert_with(|| vec![Acc::default(); input.vals.len() + input.extra.len()]);
+            for (acc, (source, _)) in accs.iter_mut().zip(input.vals) {
+                if let ValSrc::Col(column) = source {
+                    acc.add(rec.get(*column).unwrap_or(&Value::Empty));
+                }
+            }
+            for (acc, column) in accs.iter_mut().skip(input.vals.len()).zip(input.extra) {
+                acc.add(rec.get(*column).unwrap_or(&Value::Empty));
+            }
+        }
+    }
+    let shown_depth = input
+        .cols
+        .iter()
+        .zip(data.col_items.iter())
+        .zip(col_path.iter())
+        .position(|(((_, field), items), &item)| !field.collapsed_items.is_empty() && is_collapsed(field, &items.label(item)))
+        .map_or(col_path.len(), |depth| depth + 1);
+    data.col_leaves.insert(col_path[..shown_depth].to_vec());
+    if let Some(paths) = probe.as_deref_mut().and_then(|value| value.paths.as_mut()) {
+        paths.push((ri, row_path.clone(), col_path.clone()));
+    }
+    data.row_set.insert(row_path);
+    data.col_set.insert(col_path);
+    if !input.cols.is_empty() && data_cols_exceed_sheet(data.col_leaves.len(), input.pt.grand_totals_rows, input.vals.len()) {
+        return Err("The PivotTable report will not fit on the sheet.".into());
+    }
+    if data.aggs.len() > 5_000_000 {
+        return Err("The PivotTable report is too large.".into());
+    }
+    Ok(())
+}
+
+fn aggregate_source(input: AggregateInput<'_>, probe: &mut Option<&mut Probe>) -> Result<AggregateData, String> {
+    let mut data = AggregateData {
+        row_items: input.rows.iter().map(|_| FieldItems::default()).collect(),
+        col_items: input.cols.iter().map(|_| FieldItems::default()).collect(),
+        ..AggregateData::default()
+    };
+    for (ri, record) in input.src.rows.iter().enumerate() {
+        aggregate_record(&input, &mut data, probe, ri, record)?;
+    }
+    Ok(data)
+}
+
+struct HeaderInput<'a> {
+    vals: &'a [(ValSrc, &'a PivotValue)],
+    row_fields: &'a [&'a PivotField],
+    col_fields: &'a [&'a PivotField],
+    col_items: &'a [FieldItems],
+    col_fmts: &'a [String],
+    vpos: Option<usize>,
+    data_cols: &'a [(usize, Option<usize>)],
+    specs: &'a [ColSpec],
+    row_levels: usize,
+    compact: bool,
+    on_rows: bool,
+    k: usize,
+    l: usize,
+    headers_on: bool,
+}
+
+fn write_headers(g: &mut Grid, input: HeaderInput<'_>) -> Result<(), String> {
+    let HeaderInput { vals, row_fields, col_fields, col_items, col_fmts, vpos, data_cols, specs, row_levels, compact, on_rows, k, l, headers_on } =
+        input;
+    let val_name = |vi: usize| vals.get(vi).map(|(_, v)| v.name.clone()).unwrap_or_default();
+    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 col_fields.is_empty() {
+        let r = g.push_row(RowKind::Header)?;
+        row_header(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 = col_fields.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 { col_fmts.get(lv).cloned() } 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 + col_fields.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(g, last);
+    }
+
+    Ok(())
+}
+
+struct ValueLookup<'a> {
+    wb: &'a Workbook,
+    source: &'a Source,
+    calc: &'a CalcSet,
+    vals: &'a [(ValSrc, &'a PivotValue)],
+    extra: &'a [usize],
+    aggs: &'a AggMap,
+    value_count: usize,
+}
+
+impl ValueLookup<'_> {
+    fn get(&self, row_path: &[u32], col_path: &[u32], value_index: usize) -> Option<Value> {
+        let (source, definition) = self.vals.get(value_index)?;
+        let accumulators = self.aggs.get(&(row_path.to_vec(), col_path.to_vec()))?;
+        match source {
+            ValSrc::Col(_) => accumulators.get(value_index).map(|acc| acc.result(definition.func)),
+            ValSrc::Calc(index) => {
+                let sum = |name: &str| -> Value {
+                    self.source
+                        .col(name)
+                        .and_then(|column| self.extra.iter().position(|extra_column| *extra_column == column))
+                        .and_then(|index| accumulators.get(self.value_count + index))
+                        .map(|acc| acc.result(PivotFunc::Sum))
+                        .unwrap_or(Value::Number(0.0))
+                };
+                Some(self.calc.value(self.wb, *index, &sum))
+            }
+        }
+    }
+}
+
+struct ShowContext<'a> {
+    row_path: &'a [u32],
+    col_path: &'a [u32],
+    value_index: usize,
+    level0: &'a [u32],
+    siblings: &'a HashMap<Vec<u32>, Vec<u32>>,
+}
+
+fn number(value: &Option<Value>) -> Option<f64> {
+    value.as_ref().and_then(Value::as_f64)
+}
+
+fn ratio(a: Value, b: Option<Value>) -> Value {
+    match (a, b) {
+        (Value::Error(error), _) => Value::Error(error),
+        (_, Some(Value::Error(error))) => Value::Error(error),
+        (Value::Number(_), Some(Value::Number(0.0))) => Value::Error(CellError::Div0),
+        (Value::Number(x), Some(Value::Number(y))) => Value::number(x / y),
+        (value, _) => value,
+    }
+}
+
+fn running_total(raw: Value, lookup: &ValueLookup<'_>, context: &ShowContext<'_>) -> Value {
+    let Some((first, _)) = context.row_path.split_first() else { return raw };
+    if !matches!(raw, Value::Number(_)) {
+        return raw;
+    }
+    let mut total = 0.0;
+    for item in context.level0 {
+        let mut path = context.row_path.to_vec();
+        if let Some(first_item) = path.first_mut() {
+            *first_item = *item;
+        }
+        total += number(&lookup.get(&path, context.col_path, context.value_index)).unwrap_or(0.0);
+        if item == first {
+            break;
+        }
+    }
+    Value::number(total)
+}
+
+fn ranked_value(raw: Value, lookup: &ValueLookup<'_>, context: &ShowContext<'_>) -> Value {
+    let Some((_, parent)) = context.row_path.split_last() else { return Value::Empty };
+    let Some(me) = raw.as_f64() else { return raw };
+    let siblings = context.siblings.get(parent).cloned().unwrap_or_default();
+    let mut rank = 1u64;
+    for sibling in siblings {
+        let mut path = parent.to_vec();
+        path.push(sibling);
+        if number(&lookup.get(&path, context.col_path, context.value_index)).is_some_and(|value| value > me) {
+            rank += 1;
+        }
+    }
+    Value::number(rank as f64)
+}
+
+fn show_value(definition: &PivotValue, raw: Value, lookup: &ValueLookup<'_>, context: &ShowContext<'_>) -> Value {
+    match definition.show_as {
+        PivotShowAs::Normal => raw,
+        PivotShowAs::PercentOfGrandTotal => ratio(raw, lookup.get(&[], &[], context.value_index)),
+        PivotShowAs::PercentOfColumnTotal => ratio(raw, lookup.get(&[], context.col_path, context.value_index)),
+        PivotShowAs::PercentOfRowTotal => ratio(raw, lookup.get(context.row_path, &[], context.value_index)),
+        PivotShowAs::RunningTotal => running_total(raw, lookup, context),
+        PivotShowAs::Rank => ranked_value(raw, lookup, context),
+    }
+}
+
+type ReportFilter<'a> = (usize, &'a PivotFilter, PivotDateGroup, bool);
+
+fn report_filters<'a>(pt: &'a PivotTable, src: &Source) -> (Vec<ReportFilter<'a>>, Vec<ReportFilter<'a>>) {
+    let axis_group =
+        |name: &str| pt.rows.iter().chain(pt.columns.iter()).find(|field| field.source_col.eq_ignore_ascii_case(name)).map(|field| field.date_group);
+    let filters: Vec<_> = pt
+        .filters
+        .iter()
+        .filter_map(|filter| {
+            let column = src.col(&filter.source_col)?;
+            let group = axis_group(&filter.source_col);
+            Some((column, filter, group.unwrap_or_default(), group.is_none()))
+        })
+        .collect();
+    let shown = filters.iter().copied().filter(|filter| filter.3).collect();
+    (filters, shown)
+}
+
+fn values_position(pt: &PivotTable, src: &Source, value_count: usize) -> Option<usize> {
+    if !pt.values_on_rows || value_count <= 1 {
+        return None;
+    }
+    let position = pt.values_position.unwrap_or(pt.rows.len());
+    Some(pt.rows.iter().take(position).filter(|field| src.col(&field.source_col).is_some()).count())
+}
+
+fn calculated_source_columns(vals: &[(ValSrc, &PivotValue)], calc: &CalcSet, src: &Source) -> Vec<usize> {
+    let mut columns = Vec::new();
+    for (source, _) in vals {
+        let ValSrc::Calc(index) = source else { continue };
+        for name in calc.source_refs(*index) {
+            if let Some(column) = src.col(&name)
+                && !columns.contains(&column)
+            {
+                columns.push(column);
+            }
+        }
+    }
+    columns
+}
+
+fn data_columns(specs: &[ColSpec], has_column_fields: bool, on_rows: bool, value_count: usize) -> Result<Vec<(usize, Option<usize>)>, String> {
+    let mut columns = Vec::new();
+    for (spec_index, _) in specs.iter().enumerate() {
+        if on_rows {
+            columns.push((spec_index, None));
+        } else if value_count == 0 {
+            if has_column_fields {
+                columns.push((spec_index, None));
+            }
+        } else {
+            columns.extend((0..value_count).map(|value_index| (spec_index, Some(value_index))));
+        }
+        if columns.len() > MAX_COLS as usize {
+            return Err("The PivotTable report will not fit on the sheet.".into());
+        }
+    }
+    Ok(columns)
+}
+
 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();
@@ -77,116 +452,45 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
         })
         .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);
-                }
-            }
-        }
-    }
+    let extra = calculated_source_columns(&vals, &calc, src);
     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 (filters, shown_filters) = report_filters(pt, src);
 
     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 vpos = values_position(pt, src, k);
     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());
-        }
-    }
+    let aggregate = aggregate_source(
+        AggregateInput {
+            wb,
+            pt,
+            src,
+            rows: &rows,
+            cols: &cols,
+            vals: &vals,
+            extra: &extra,
+            filters: &filters,
+            filter_fmts: &filter_fmts,
+            row_fmts: &row_fmts,
+            col_fmts: &col_fmts,
+            empty,
+        },
+        &mut probe,
+    )?;
+    let AggregateData { row_items, col_items, aggs, row_set, col_set, col_leaves: _ } = aggregate;
 
     // ---- axes
     let row_fields: Vec<&PivotField> = rows.iter().map(|(_, f)| *f).collect();
@@ -236,24 +540,7 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
             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 data_cols = data_columns(&specs, !cols.is_empty(), on_rows, k)?;
 
     let compact = pt.layout == PivotLayout::Compact;
     let l = if row_levels == 0 && cols.is_empty() {
@@ -304,128 +591,28 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
         });
     }
 
-    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);
-    }
+    write_headers(
+        &mut g,
+        HeaderInput {
+            vals: &vals,
+            row_fields: &row_fields,
+            col_fields: &col_fields,
+            col_items: &col_items,
+            col_fmts: &col_fmts,
+            vpos,
+            data_cols: &data_cols,
+            specs: &specs,
+            row_levels,
+            compact,
+            on_rows,
+            k,
+            l,
+            headers_on: pt.show_headers,
+        },
+    )?;
+    let val_name = |vi: usize| vals.get(vi).map(|(_, value)| value.name.clone()).unwrap_or_default();
 
     // ---- 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 {
@@ -445,6 +632,7 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
             }),
         })
         .collect();
+    let lookup = ValueLookup { wb, source: src, calc: &calc, vals: &vals, extra: &extra, aggs: &aggs, value_count: k };
     let mut chart_rows: Vec<u32> = Vec::new();
     let chart_cols: Vec<(u32, String)> = data_cols
         .iter()
@@ -501,46 +689,9 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
             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,
-                },
-            };
+            let Some(raw) = lookup.get(rp, cp, *vi) else { continue };
+            let context = ShowContext { row_path: rp, col_path: cp, value_index: *vi, level0: &level0, siblings: &siblings };
+            let shown = show_value(vdef, raw, &lookup, &context);
             if let Some(pr) = probe.as_deref_mut() {
                 if pr.at == Some((r, l + j)) {
                     pr.hit = Some((rp.to_vec(), cp.to_vec()));
diff --git a/crates/engine/src/pivot/items.rs b/crates/engine/src/pivot/items.rs
index 2877d0ef0..1a39c59d9 100644
--- a/crates/engine/src/pivot/items.rs
+++ b/crates/engine/src/pivot/items.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{CellError, HashMap, MONTHS, Ordering, PivotDateGroup, PivotField, PivotFunc, PivotSort, Source, Value, Workbook, datetime_from_serial};
 
 // ---------------------------------------------------------------- items
 
diff --git a/crates/engine/src/pivot/output.rs b/crates/engine/src/pivot/output.rs
index 9dbf8836c..c3d6ee88d 100644
--- a/crates/engine/src/pivot/output.rs
+++ b/crates/engine/src/pivot/output.rs
@@ -1,5 +1,8 @@
 use super::items::{Acc, FieldItems, Node, is_collapsed};
-use super::*;
+use super::{
+    BorderLine, BorderStyle, Color, Fill, HAlign, HashMap, MAX_COLS, MAX_OUTPUT_CELLS, MAX_ROWS, NumFmt, PivotField, PivotLayout, PivotTable, Style,
+    Value,
+};
 
 // ---------------------------------------------------------------- output
 
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 13fbb9b3a..250e1f7b8 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -2406,8 +2406,7 @@ fn ods_import_keeps_cached_values_and_reports_limits() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn ods_import_never_reuses_source_as_save_target() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-ods-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let bytes = ods_fixture();
@@ -2437,8 +2436,7 @@ fn ods_import_never_reuses_source_as_save_target() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn saving_an_opened_semicolon_csv_keeps_semicolons() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-csv-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let path = dir.join("cut list.csv");
@@ -2512,8 +2510,7 @@ fn link_target(path: &std::path::Path) -> String {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn save_as_into_another_folder_keeps_linked_workbooks_on_the_same_file() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let a = std::env::temp_dir().join(format!("gridcraft-links-{}-{nonce}", std::process::id()));
     let b = a.join("b");
     std::fs::create_dir_all(&b).unwrap();
@@ -2541,8 +2538,7 @@ fn save_as_into_another_folder_keeps_linked_workbooks_on_the_same_file() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn saving_to_an_unknown_extension_is_refused() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-unknown-ext-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let mut s = s();
@@ -2566,8 +2562,7 @@ fn saving_to_an_unknown_extension_is_refused() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn an_xlsx_opened_under_an_unknown_extension_saves_back_as_xlsx() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-dat-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let path = dir.join("budget.dat");
@@ -3240,8 +3235,7 @@ fn xlsb_import_keeps_cached_values_and_reports_limits() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn xlsb_import_never_reuses_source_as_save_target() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-xlsb-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let bytes = xlsb_fixture();
@@ -4410,8 +4404,7 @@ fn encrypted_workbooks_open_with_their_password() {
 #[cfg(not(target_arch = "wasm32"))]
 fn a_decrypted_workbook_never_overwrites_its_encrypted_original() {
     const PW: &str = "synthetic-pw-5522";
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-encrypted-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let path = dir.join("Secret.xlsx");
@@ -4544,8 +4537,7 @@ fn csv_as_text_keeps_identifier_columns_as_written() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn cell_filename_follows_the_file_the_workbook_lives_in() {
-    #[allow(clippy::disallowed_methods)] // native-only test: a unique temp dir name
-    let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
+    let nonce = unique_nonce();
     let dir = std::env::temp_dir().join(format!("gridcraft-cellname-{}-{nonce}", std::process::id()));
     std::fs::create_dir(&dir).unwrap();
     let name = "=CELL(\"filename\",A1)";
@@ -5117,3 +5109,10 @@ fn a_saved_workbook_keeps_its_values_until_an_edit_reaches_them() {
     assert_eq!(v(&saved, "B1"), Value::Number(6.0));
     assert_eq!(v(&saved, "C1"), Value::Number(7.0));
 }
+
+/// A per-test unique suffix for temp dir names.
+#[cfg(not(target_arch = "wasm32"))]
+fn unique_nonce() -> u64 {
+    static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+    N.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+}
diff --git a/crates/formula/src/lexer.rs b/crates/formula/src/lexer.rs
index 332cb6eeb..2799b5b6f 100644
--- a/crates/formula/src/lexer.rs
+++ b/crates/formula/src/lexer.rs
@@ -67,6 +67,198 @@ fn starts_range_end(c: Option<char>) -> bool {
     c.is_some_and(|c| c.is_ascii_alphanumeric() || c == '$')
 }
 
+fn byte_pos(src: &str, chars: &[(usize, char)], index: usize) -> usize {
+    chars.get(index).map(|c| c.0).unwrap_or(src.len())
+}
+
+fn char_at(chars: &[(usize, char)], index: usize) -> Option<char> {
+    chars.get(index).map(|c| c.1)
+}
+
+fn emit(src: &str, chars: &[(usize, char)], out: &mut Vec<Token>, tok: Tok, start: usize, end_index: usize) {
+    out.push(Token { tok, start, end: byte_pos(src, chars, end_index) });
+}
+
+fn quoted(src: &str, chars: &[(usize, char)], i: usize, start: usize, out: &mut Vec<Token>) -> Result<usize, LexError> {
+    let quote = char_at(chars, i).unwrap_or_default();
+    let mut value = String::new();
+    let mut j = i + 1;
+    loop {
+        match char_at(chars, j) {
+            None => {
+                let msg = if quote == '"' { "unterminated text" } else { "unterminated sheet name" };
+                return Err(LexError { msg: msg.into(), pos: start });
+            }
+            Some(c) if c == quote && char_at(chars, j + 1) == Some(quote) => {
+                value.push(quote);
+                j += 2;
+            }
+            Some(c) if c == quote => {
+                j += 1;
+                break;
+            }
+            Some(c) => {
+                value.push(c);
+                j += 1;
+            }
+        }
+    }
+    if quote == '"' {
+        emit(src, chars, out, Tok::Text(value), start, j);
+        return Ok(j);
+    }
+    if char_at(chars, j) != Some('!') {
+        return Err(LexError { msg: "expected ! after sheet name".into(), pos: byte_pos(src, chars, j) });
+    }
+    let (first, last) = match value.split_once(':') {
+        Some((first, last)) => (first.to_string(), Some(last.to_string())),
+        None => (value, None),
+    };
+    emit(src, chars, out, Tok::Sheet(first, last), start, j + 1);
+    Ok(j + 1)
+}
+
+fn error_literal(src: &str, chars: &[(usize, char)], i: usize, start: usize, out: &mut Vec<Token>) -> Result<usize, LexError> {
+    let rest = src.get(start..).unwrap_or("");
+    let error = CellError::ALL
+        .iter()
+        .copied()
+        .find(|error| rest.get(..error.as_str().len()).is_some_and(|text| text.eq_ignore_ascii_case(error.as_str())))
+        .ok_or_else(|| LexError { msg: "unknown error literal".into(), pos: start })?;
+    let end = i + error.as_str().chars().count();
+    emit(src, chars, out, Tok::Error(error), start, end);
+    Ok(end)
+}
+
+fn structured_ref(src: &str, chars: &[(usize, char)], i: usize, start: usize, out: &mut Vec<Token>) -> Result<usize, LexError> {
+    let mut depth = 0;
+    let mut j = i;
+    loop {
+        match char_at(chars, j) {
+            None => return Err(LexError { msg: "unbalanced [".into(), pos: start }),
+            Some('\'') => j += 2,
+            Some('[') => {
+                depth += 1;
+                j += 1;
+            }
+            Some(']') => {
+                depth -= 1;
+                j += 1;
+                if depth == 0 {
+                    break;
+                }
+            }
+            Some(_) => j += 1,
+        }
+    }
+    let inner = src.get(byte_pos(src, chars, i + 1)..byte_pos(src, chars, j.saturating_sub(1))).unwrap_or("").to_string();
+    emit(src, chars, out, Tok::Struct(inner), start, j);
+    Ok(j)
+}
+
+fn number(src: &str, chars: &[(usize, char)], locale: crate::FormulaLocale, i: usize, start: usize, out: &mut Vec<Token>) -> Result<usize, LexError> {
+    let ch = |index| char_at(chars, index);
+    let mut j = i;
+    while ch(j).is_some_and(|c| c.is_ascii_digit()) {
+        j += 1;
+    }
+    let is_row_ref = {
+        let mut k = j;
+        if ch(k) == Some('.') && ch(k + 1) == Some(':') {
+            k += 1;
+        }
+        ch(k) == Some(':') && {
+            k += 1;
+            if ch(k) == Some('.') {
+                k += 1;
+            }
+            if ch(k) == Some('$') {
+                k += 1;
+            }
+            ch(k).is_some_and(|c| c.is_ascii_digit())
+        }
+    };
+    if is_row_ref {
+        let word = chars.get(i..j).map(|s| s.iter().map(|c| c.1).collect()).unwrap_or_default();
+        emit(src, chars, out, Tok::Word(word), start, j);
+        return Ok(j);
+    }
+    if ch(j) == Some(locale.decimal_separator()) {
+        j += 1;
+        while ch(j).is_some_and(|c| c.is_ascii_digit()) {
+            j += 1;
+        }
+    }
+    if matches!(ch(j), Some('e' | 'E')) {
+        let mut exponent = j + 1;
+        if matches!(ch(exponent), Some('+' | '-')) {
+            exponent += 1;
+        }
+        if ch(exponent).is_some_and(|c| c.is_ascii_digit()) {
+            while ch(exponent).is_some_and(|c| c.is_ascii_digit()) {
+                exponent += 1;
+            }
+            j = exponent;
+        }
+    }
+    let text = src.get(start..byte_pos(src, chars, j)).unwrap_or("");
+    let value: f64 =
+        text.replace(locale.decimal_separator(), ".").parse().map_err(|_| LexError { msg: format!("bad number `{text}`"), pos: start })?;
+    if !value.is_finite() {
+        return Err(LexError { msg: format!("number too large `{text}`"), pos: start });
+    }
+    emit(src, chars, out, Tok::Number(value), start, j);
+    Ok(j)
+}
+
+fn word(src: &str, chars: &[(usize, char)], locale: crate::FormulaLocale, array_depth: usize, i: usize, start: usize, out: &mut Vec<Token>) -> usize {
+    let ch = |index| char_at(chars, index);
+    let mut j = i;
+    while ch(j).is_some_and(|c| is_word_char(c) && !(array_depth > 0 && c == locale.array_column_separator())) {
+        j += 1;
+    }
+    let value: String = chars.get(i..j).map(|s| s.iter().map(|c| c.1).collect()).unwrap_or_default();
+    if ch(j) == Some('!') {
+        emit(src, chars, out, Tok::Sheet(value, None), start, j + 1);
+        j + 1
+    } else if ch(j) == Some(':') && sheet_range_end(chars, locale, array_depth, &value, j, out) {
+        let mut end = j + 1;
+        while ch(end).is_some_and(|c| is_word_char(c) && !(array_depth > 0 && c == locale.array_column_separator())) {
+            end += 1;
+        }
+        let last: String = chars.get(j + 1..end).map(|s| s.iter().map(|c| c.1).collect()).unwrap_or_default();
+        emit(src, chars, out, Tok::Sheet(value, Some(last)), start, end + 1);
+        end + 1
+    } else if ch(j) == Some('(') {
+        emit(src, chars, out, Tok::Func(value), start, j + 1);
+        j + 1
+    } else if value.eq_ignore_ascii_case("TRUE") && ch(j) != Some('[') {
+        emit(src, chars, out, Tok::Bool(true), start, j);
+        j
+    } else if value.eq_ignore_ascii_case("FALSE") && ch(j) != Some('[') {
+        emit(src, chars, out, Tok::Bool(false), start, j);
+        j
+    } else if value.len() > 1 && value.ends_with('.') && ch(j) == Some(':') && is_range_end(value.get(..value.len() - 1).unwrap_or("")) {
+        emit(src, chars, out, Tok::Word(value[..value.len() - 1].to_string()), start, j - 1);
+        j - 1
+    } else {
+        emit(src, chars, out, Tok::Word(value), start, j);
+        j
+    }
+}
+
+fn sheet_range_end(chars: &[(usize, char)], locale: crate::FormulaLocale, array_depth: usize, value: &str, colon: usize, out: &[Token]) -> bool {
+    let ch = |index| char_at(chars, index);
+    let mut end = colon + 1;
+    while ch(end).is_some_and(|c| is_word_char(c) && !(array_depth > 0 && c == locale.array_column_separator())) {
+        end += 1;
+    }
+    let repeats_sheet = is_range_end(value)
+        && matches!(out.last(), Some(Token { tok: Tok::Sheet(previous, None), .. })
+            if chars.get(colon + 1..end).is_some_and(|s| crate::same_name(&s.iter().map(|c| c.1).collect::<String>(), previous)));
+    end > colon + 1 && ch(end) == Some('!') && !repeats_sheet
+}
+
 /// Tokenizes formula text (without the leading `=`).
 pub fn tokenize(src: &str) -> Result<Vec<Token>, LexError> {
     tokenize_locale(src, crate::FormulaLocale::En)
@@ -94,107 +286,17 @@ pub fn tokenize_locale(src: &str, locale: crate::FormulaLocale) -> Result<Vec<To
                 push(&mut out, Tok::Space, j);
                 i = j;
             }
-            '"' => {
-                let mut s = String::new();
-                let mut j = i + 1;
-                loop {
-                    match ch(j) {
-                        None => return Err(LexError { msg: "unterminated text".into(), pos: start }),
-                        Some('"') if ch(j + 1) == Some('"') => {
-                            s.push('"');
-                            j += 2;
-                        }
-                        Some('"') => {
-                            j += 1;
-                            break;
-                        }
-                        Some(x) => {
-                            s.push(x);
-                            j += 1;
-                        }
-                    }
-                }
-                push(&mut out, Tok::Text(s), j);
-                i = j;
-            }
-            '\'' => {
-                // Quoted sheet name: 'My Sheet'!  or 'A:B'!
-                let mut s = String::new();
-                let mut j = i + 1;
-                loop {
-                    match ch(j) {
-                        None => return Err(LexError { msg: "unterminated sheet name".into(), pos: start }),
-                        Some('\'') if ch(j + 1) == Some('\'') => {
-                            s.push('\'');
-                            j += 2;
-                        }
-                        Some('\'') => {
-                            j += 1;
-                            break;
-                        }
-                        Some(x) => {
-                            s.push(x);
-                            j += 1;
-                        }
-                    }
-                }
-                if ch(j) != Some('!') {
-                    return Err(LexError { msg: "expected ! after sheet name".into(), pos: pos_of(j) });
-                }
-                let (a, b) = match s.split_once(':') {
-                    Some((a, b)) => (a.to_string(), Some(b.to_string())),
-                    None => (s, None),
-                };
-                push(&mut out, Tok::Sheet(a, b), j + 1);
-                i = j + 1;
-            }
+            '"' | '\'' => i = quoted(src, &chars, i, start, &mut out)?,
             '#' if out.last().is_some_and(|t: &Token| t.end == start && matches!(t.tok, Tok::Word(_))) => {
                 // Spill range operator right after a reference: `A1#`.
                 push(&mut out, Tok::Op("#"), i + 1);
                 i += 1;
             }
             '#' => {
-                // Error literal, or #-prefixed struct specifier (only inside [] which we lex as Struct).
-                let rest = src.get(start..).unwrap_or("");
-                let mut found = None;
-                for e in CellError::ALL {
-                    let t = e.as_str();
-                    if rest.len() >= t.len() && rest.get(..t.len()).is_some_and(|p| p.eq_ignore_ascii_case(t)) {
-                        found = Some(e);
-                        break;
-                    }
-                }
-                let Some(e) = found else { return Err(LexError { msg: "unknown error literal".into(), pos: start }) };
-                let len = e.as_str().chars().count();
-                // `#REF!A1` style is not valid; `#REF!` is an error literal.
-                push(&mut out, Tok::Error(e), i + len);
-                i += len;
+                i = error_literal(src, &chars, i, start, &mut out)?;
             }
             '[' => {
-                // Structured reference body: balanced brackets.
-                let mut depth = 0;
-                let mut j = i;
-                loop {
-                    match ch(j) {
-                        None => return Err(LexError { msg: "unbalanced [".into(), pos: start }),
-                        Some('\'') => j += 2, // escape char inside struct refs
-                        Some('[') => {
-                            depth += 1;
-                            j += 1;
-                        }
-                        Some(']') => {
-                            depth -= 1;
-                            j += 1;
-                            if depth == 0 {
-                                break;
-                            }
-                        }
-                        Some(_) => j += 1,
-                    }
-                }
-                let inner = src.get(pos_of(i + 1)..pos_of(j.saturating_sub(1))).unwrap_or("").to_string();
-                push(&mut out, Tok::Struct(inner), j);
-                i = j;
+                i = structured_ref(src, &chars, i, start, &mut out)?;
             }
             '.' if ch(i + 1) == Some(':') => {
                 // Trim reference `A1.:E10` / `A1.:.E10` (the word before stopped at the dot).
@@ -207,64 +309,7 @@ pub fn tokenize_locale(src: &str, locale: crate::FormulaLocale) -> Result<Vec<To
                 }
             }
             c if c.is_ascii_digit() || (c == locale.decimal_separator() && ch(i + 1).is_some_and(|d| d.is_ascii_digit())) => {
-                // Number, unless it is a row range like 1:3 (handled by parser via Word) — numbers
-                // followed by ':' and digits are row refs: lex as Word.
-                let mut j = i;
-                while ch(j).is_some_and(|d| d.is_ascii_digit()) {
-                    j += 1;
-                }
-                // Row ranges `1:3`, and the trim forms `1.:3`, `1:.3`, `1.:.3`.
-                let is_row_ref = {
-                    let mut k = j;
-                    if ch(k) == Some('.') && ch(k + 1) == Some(':') {
-                        k += 1;
-                    }
-                    ch(k) == Some(':') && {
-                        k += 1;
-                        if ch(k) == Some('.') {
-                            k += 1;
-                        }
-                        if ch(k) == Some('$') {
-                            k += 1;
-                        }
-                        ch(k).is_some_and(|d| d.is_ascii_digit())
-                    }
-                };
-                // A word like "1A" can't happen in valid formulas; numbers then.
-                if is_row_ref {
-                    let w: String = chars.get(i..j).map(|s| s.iter().map(|c| c.1).collect()).unwrap_or_default();
-                    push(&mut out, Tok::Word(w), j);
-                    i = j;
-                    continue;
-                }
-                if ch(j) == Some(locale.decimal_separator()) {
-                    j += 1;
-                    while ch(j).is_some_and(|d| d.is_ascii_digit()) {
-                        j += 1;
-                    }
-                }
-                if matches!(ch(j), Some('e' | 'E')) {
-                    let mut k = j + 1;
-                    if matches!(ch(k), Some('+' | '-')) {
-                        k += 1;
-                    }
-                    if ch(k).is_some_and(|d| d.is_ascii_digit()) {
-                        while ch(k).is_some_and(|d| d.is_ascii_digit()) {
-                            k += 1;
-                        }
-                        j = k;
-                    }
-                }
-                let text = src.get(start..pos_of(j)).unwrap_or("");
-                let v: f64 = text
-                    .replace(locale.decimal_separator(), ".")
-                    .parse()
-                    .map_err(|_| LexError { msg: format!("bad number `{text}`"), pos: start })?;
-                if !v.is_finite() {
-                    return Err(LexError { msg: format!("number too large `{text}`"), pos: start });
-                }
-                push(&mut out, Tok::Number(v), j);
-                i = j;
+                i = number(src, &chars, locale, i, start, &mut out)?;
             }
             '(' => {
                 push(&mut out, Tok::LParen, i + 1);
@@ -328,53 +373,7 @@ pub fn tokenize_locale(src: &str, locale: crate::FormulaLocale) -> Result<Vec<To
                 push(&mut out, Tok::Op(op), i + len);
                 i += len;
             }
-            c if is_word_char(c) => {
-                let mut j = i;
-                while ch(j).is_some_and(|c| is_word_char(c) && !(array_depth > 0 && c == locale.array_column_separator())) {
-                    j += 1;
-                }
-                let w: String = chars.get(i..j).map(|s| s.iter().map(|c| c.1).collect()).unwrap_or_default();
-                if ch(j) == Some('!') {
-                    push(&mut out, Tok::Sheet(w, None), j + 1);
-                    i = j + 1;
-                } else if ch(j) == Some(':') && {
-                    // Sheet1:Sheet3!A1 — look ahead for word then '!'.
-                    let mut k = j + 1;
-                    while ch(k).is_some_and(|c| is_word_char(c) && !(array_depth > 0 && c == locale.array_column_separator())) {
-                        k += 1;
-                    }
-                    // `Sheet1!A1:Sheet1!B2` is a range whose second end repeats the sheet, not a span.
-                    let repeats_sheet = is_range_end(&w)
-                        && matches!(out.last(), Some(Token { tok: Tok::Sheet(p, None), .. })
-                            if chars.get(j + 1..k).is_some_and(|s| crate::same_name(&s.iter().map(|c| c.1).collect::<String>(), p)));
-                    k > j + 1 && ch(k) == Some('!') && !repeats_sheet
-                } {
-                    let mut k = j + 1;
-                    while ch(k).is_some_and(|c| is_word_char(c) && !(array_depth > 0 && c == locale.array_column_separator())) {
-                        k += 1;
-                    }
-                    let w2: String = chars.get(j + 1..k).map(|s| s.iter().map(|c| c.1).collect()).unwrap_or_default();
-                    push(&mut out, Tok::Sheet(w, Some(w2)), k + 1);
-                    i = k + 1;
-                } else if ch(j) == Some('(') {
-                    push(&mut out, Tok::Func(w), j + 1);
-                    i = j + 1;
-                } else if w.eq_ignore_ascii_case("TRUE") && ch(j) != Some('[') {
-                    push(&mut out, Tok::Bool(true), j);
-                    i = j;
-                } else if w.eq_ignore_ascii_case("FALSE") && ch(j) != Some('[') {
-                    push(&mut out, Tok::Bool(false), j);
-                    i = j;
-                } else if w.len() > 1 && w.ends_with('.') && ch(j) == Some(':') && is_range_end(w.get(..w.len() - 1).unwrap_or("")) {
-                    // `A1.:E10`: the dot belongs to the trim operator, lexed next.
-                    let w = w.get(..w.len() - 1).unwrap_or("").to_string();
-                    push(&mut out, Tok::Word(w), j - 1);
-                    i = j - 1;
-                } else {
-                    push(&mut out, Tok::Word(w), j);
-                    i = j;
-                }
-            }
+            c if is_word_char(c) => i = word(src, &chars, locale, array_depth, i, start, &mut out),
             other => return Err(LexError { msg: format!("unexpected character `{other}`"), pos: start }),
         }
     }
diff --git a/crates/formula/src/tests.rs b/crates/formula/src/tests.rs
index 0f16116af..0fdc9ca38 100644
--- a/crates/formula/src/tests.rs
+++ b/crates/formula/src/tests.rs
@@ -2,7 +2,10 @@ use super::*;
 use crate::adjust::{Axis, Edit, adjust, rename_sheet, shift_relative};
 
 fn rt(src: &str) -> String {
-    print(&parse(src).unwrap_or_else(|e| panic!("{src}: {e}")))
+    match parse(src) {
+        Ok(e) => print(&e),
+        Err(e) => format!("{src}: {e}"),
+    }
 }
 
 #[test]
@@ -87,11 +90,11 @@ fn normalises() {
 }
 
 #[test]
-fn spill_operator() {
+fn spill_operator() -> Result<(), Box<dyn std::error::Error>> {
     for f in ["A1#", "Sheet1!$D$1#", "SUM(B2#)", "'My Sheet'!A1#*2", "ROWS(A1#)+1", "IF(A1,#N/A,#REF!)"] {
         assert_eq!(rt(f), f);
     }
-    assert!(matches!(parse("A1#").unwrap(), Expr::Unary(UnOp::Spill, _)));
+    assert!(matches!(parse("A1#")?, Expr::Unary(UnOp::Spill, _)));
     // Files spell it ANCHORARRAY.
     assert_eq!(rt("_xlfn.ANCHORARRAY(Sheet1!$D$1)"), "Sheet1!$D$1#");
     assert_eq!(rt("SUM(ANCHORARRAY(B2))"), "SUM(B2#)");
@@ -99,35 +102,35 @@ fn spill_operator() {
     assert!(parse("A1:B2#").is_err());
     assert!(parse("Name#").is_err());
     // Deleting the anchor's sheet leaves #REF!.
-    assert_eq!(print(&crate::adjust::delete_sheet(parse("SUM(Data!A1#)").unwrap(), "Data", &[])), "SUM(#REF!)");
+    assert_eq!(print(&crate::adjust::delete_sheet(parse("SUM(Data!A1#)")?, "Data", &[])), "SUM(#REF!)");
+    Ok(())
 }
 
 #[test]
-fn delete_sheet_shrinks_3d_span() {
+fn delete_sheet_shrinks_3d_span() -> Result<(), Box<dyn std::error::Error>> {
     let order: Vec<String> = ["Sheet1", "Sheet2", "Sheet3", "Results"].iter().map(|s| s.to_string()).collect();
-    let del = |f: &str, n: &str| print(&crate::adjust::delete_sheet(parse(f).unwrap(), n, &order));
-    assert_eq!(del("SUM(Sheet1:Sheet3!A1)", "Sheet1"), "SUM(Sheet2:Sheet3!A1)");
-    assert_eq!(del("SUM(Sheet1:Sheet3!A1)", "Sheet3"), "SUM(Sheet1:Sheet2!A1)");
-    assert_eq!(del("SUM(Sheet3:Sheet1!A1)", "Sheet1"), "SUM(Sheet3:Sheet2!A1)");
-    assert_eq!(del("SUM(Sheet1:Sheet3!A1)", "Sheet2"), "SUM(Sheet1:Sheet3!A1)");
-    assert_eq!(del("SUM(Sheet1:Sheet2!A1)", "Sheet1"), "SUM(Sheet2!A1)");
-    assert_eq!(del("Sheet1!A1+Sheet3!A1", "Sheet1"), "#REF!+Sheet3!A1");
+    let del = |f: &str, n: &str| parse(f).map(|e| print(&crate::adjust::delete_sheet(e, n, &order)));
+    assert_eq!(del("SUM(Sheet1:Sheet3!A1)", "Sheet1")?, "SUM(Sheet2:Sheet3!A1)");
+    assert_eq!(del("SUM(Sheet1:Sheet3!A1)", "Sheet3")?, "SUM(Sheet1:Sheet2!A1)");
+    assert_eq!(del("SUM(Sheet3:Sheet1!A1)", "Sheet1")?, "SUM(Sheet3:Sheet2!A1)");
+    assert_eq!(del("SUM(Sheet1:Sheet3!A1)", "Sheet2")?, "SUM(Sheet1:Sheet3!A1)");
+    assert_eq!(del("SUM(Sheet1:Sheet2!A1)", "Sheet1")?, "SUM(Sheet2!A1)");
+    assert_eq!(del("Sheet1!A1+Sheet3!A1", "Sheet1")?, "#REF!+Sheet3!A1");
+    Ok(())
 }
 
 #[test]
-fn precedence() {
-    let e = parse("1+2*3").unwrap();
+fn precedence() -> Result<(), Box<dyn std::error::Error>> {
+    let e = parse("1+2*3")?;
     assert!(matches!(e, Expr::Binary(BinOp::Add, _, _)));
-    let e = parse("-2^2").unwrap();
+    let e = parse("-2^2")?;
     assert!(matches!(e, Expr::Binary(BinOp::Pow, _, _)));
-    let e = parse("1&2=\"12\"").unwrap();
+    let e = parse("1&2=\"12\"")?;
     assert!(matches!(e, Expr::Binary(BinOp::Eq, _, _)));
-    let e = parse("2^3^2").unwrap(); // left associative: (2^3)^2
-    if let Expr::Binary(BinOp::Pow, l, _) = e {
-        assert!(matches!(*l, Expr::Binary(BinOp::Pow, _, _)));
-    } else {
-        panic!()
-    }
+    let e = parse("2^3^2")?; // left associative: (2^3)^2
+    let Expr::Binary(BinOp::Pow, l, _) = e else { return Err("not a power".into()) };
+    assert!(matches!(*l, Expr::Binary(BinOp::Pow, _, _)));
+    Ok(())
 }
 
 #[test]
@@ -149,122 +152,130 @@ fn no_panic_on_garbage() {
 }
 
 #[test]
-fn references() {
-    let e = parse("SUM(A1:B2)+Sheet2!C3*D4").unwrap();
+fn references() -> Result<(), Box<dyn std::error::Error>> {
+    let e = parse("SUM(A1:B2)+Sheet2!C3*D4")?;
     let refs: Vec<String> = e.references().iter().map(|r| printer::reference_a1(r)).collect();
     assert_eq!(refs, ["A1:B2", "Sheet2!C3", "D4"]);
+    Ok(())
 }
 
 #[test]
-fn copy_shift() {
-    let e = parse("A1+$A1+A$1+$A$1+SUM(B2:C3)").unwrap();
+fn copy_shift() -> Result<(), Box<dyn std::error::Error>> {
+    let e = parse("A1+$A1+A$1+$A$1+SUM(B2:C3)")?;
     assert_eq!(print(&shift_relative(e, 2, 1)), "B3+$A3+B$1+$A$1+SUM(C4:D5)");
-    let e = parse("A1").unwrap();
+    let e = parse("A1")?;
     assert_eq!(print(&shift_relative(e, -1, 0)), "#REF!");
-    let e = parse("SUM(A:A)").unwrap();
+    let e = parse("SUM(A:A)")?;
     assert_eq!(print(&shift_relative(e, 5, 1)), "SUM(B:B)");
+    Ok(())
 }
 
 #[test]
-fn insert_delete() {
+fn insert_delete() -> Result<(), Box<dyn std::error::Error>> {
     let ins = Edit::Insert { axis: Axis::Rows, at: 2, count: 2 };
-    let e = parse("A1+A3+SUM(A2:A5)+Other!A3").unwrap();
+    let e = parse("A1+A3+SUM(A2:A5)+Other!A3")?;
     assert_eq!(print(&adjust(e, "Sheet1", "Sheet1", &ins)), "A1+A5+SUM(A2:A7)+Other!A3");
     let del = Edit::Delete { axis: Axis::Rows, at: 2, count: 2 }; // rows 3-4
-    let e = parse("A1+A3+SUM(A2:A5)+A6").unwrap();
+    let e = parse("A1+A3+SUM(A2:A5)+A6")?;
     assert_eq!(print(&adjust(e, "Sheet1", "Sheet1", &del)), "A1+#REF!+SUM(A2:A3)+A4");
     let del = Edit::Delete { axis: Axis::Cols, at: 0, count: 1 };
-    let e = parse("SUM(A1:C1)+B2").unwrap();
+    let e = parse("SUM(A1:C1)+B2")?;
     assert_eq!(print(&adjust(e, "S", "S", &del)), "SUM(A1:B1)+A2");
-    let e = parse("Sheet1!B2").unwrap();
+    let e = parse("Sheet1!B2")?;
     assert_eq!(print(&adjust(e, "Other", "Sheet1", &del)), "Sheet1!A2");
-    let e = parse("SUM(A:A)").unwrap();
+    let e = parse("SUM(A:A)")?;
     assert_eq!(print(&adjust(e, "S", "S", &del)), "SUM(#REF!)");
+    Ok(())
 }
 
 #[test]
-fn insert_delete_cells() {
-    let range = |a: &str| gridcraft_core::RangeRef::parse(a).unwrap();
-    let adj = |f: &str, e: &Edit| print(&adjust(parse(f).unwrap(), "S", "S", e));
+fn insert_delete_cells() -> Result<(), Box<dyn std::error::Error>> {
+    let range = |a: &str| gridcraft_core::RangeRef::parse(a);
+    let adj = |f: &str, e: &Edit| parse(f).map(|x| print(&adjust(x, "S", "S", e)));
     // Insert A3:A4, shifting down: column A moves, other columns and wider ranges don't.
-    let ins = Edit::InsertCells { axis: Axis::Rows, range: range("A3:A4") };
-    assert_eq!(adj("SUM(A1:A5)+A2+A3+$A$9+B3+SUM(A1:B5)+SUM(A:A)", &ins), "SUM(A1:A7)+A2+A5+$A$11+B3+SUM(A1:B5)+SUM(A:A)");
+    let ins = Edit::InsertCells { axis: Axis::Rows, range: range("A3:A4").ok_or("none")? };
+    assert_eq!(adj("SUM(A1:A5)+A2+A3+$A$9+B3+SUM(A1:B5)+SUM(A:A)", &ins)?, "SUM(A1:A7)+A2+A5+$A$11+B3+SUM(A1:B5)+SUM(A:A)");
     // Insert B2 shifting right.
-    let ins = Edit::InsertCells { axis: Axis::Cols, range: range("B2") };
-    assert_eq!(adj("A2+B2+C2+B3+SUM(A2:C2)", &ins), "A2+C2+D2+B3+SUM(A2:D2)");
+    let ins = Edit::InsertCells { axis: Axis::Cols, range: range("B2").ok_or("none")? };
+    assert_eq!(adj("A2+B2+C2+B3+SUM(A2:C2)", &ins)?, "A2+C2+D2+B3+SUM(A2:D2)");
     // Delete A3:A4 shifting up: references into it become #REF!, those below move up.
-    let del = Edit::DeleteCells { axis: Axis::Rows, range: range("A3:A4") };
-    assert_eq!(adj("A2+A3+A4+A5+B5+SUM(A1:A10)+SUM(A3:A4)+SUM(A1:B10)", &del), "A2+#REF!+#REF!+A3+B5+SUM(A1:A8)+SUM(#REF!)+SUM(A1:B10)");
+    let del = Edit::DeleteCells { axis: Axis::Rows, range: range("A3:A4").ok_or("none")? };
+    assert_eq!(adj("A2+A3+A4+A5+B5+SUM(A1:A10)+SUM(A3:A4)+SUM(A1:B10)", &del)?, "A2+#REF!+#REF!+A3+B5+SUM(A1:A8)+SUM(#REF!)+SUM(A1:B10)");
     // Delete B1:C2 shifting left.
-    let del = Edit::DeleteCells { axis: Axis::Cols, range: range("B1:C2") };
-    assert_eq!(adj("A1+B1+D1+D2+D3+SUM(A1:E1)", &del), "A1+#REF!+B1+B2+D3+SUM(A1:C1)");
+    let del = Edit::DeleteCells { axis: Axis::Cols, range: range("B1:C2").ok_or("none")? };
+    assert_eq!(adj("A1+B1+D1+D2+D3+SUM(A1:E1)", &del)?, "A1+#REF!+B1+B2+D3+SUM(A1:C1)");
+    Ok(())
 }
 
 #[test]
-fn moves_and_renames() {
-    let mv = Edit::Move { from: gridcraft_core::RangeRef::parse("A1:B2").unwrap(), to_row: 9, to_col: 3 };
-    let e = parse("A1+B2+C3+SUM(A1:B2)").unwrap();
+fn moves_and_renames() -> Result<(), Box<dyn std::error::Error>> {
+    let mv = Edit::Move { from: gridcraft_core::RangeRef::parse("A1:B2").ok_or("none")?, to_row: 9, to_col: 3 };
+    let e = parse("A1+B2+C3+SUM(A1:B2)")?;
     assert_eq!(print(&adjust(e, "S", "S", &mv)), "D10+E11+C3+SUM(D10:E11)");
-    let mv = Edit::Move { from: gridcraft_core::RangeRef::parse("B:C").unwrap(), to_row: 0, to_col: 4 };
-    assert_eq!(print(&adjust(parse("SUM(B:B)+SUM($C:$C)+D1").unwrap(), "S", "S", &mv)), "SUM(E:E)+SUM($F:$F)+D1");
-    let e = parse("Old!A1+'Old'!B2").unwrap();
+    let mv = Edit::Move { from: gridcraft_core::RangeRef::parse("B:C").ok_or("none")?, to_row: 0, to_col: 4 };
+    assert_eq!(print(&adjust(parse("SUM(B:B)+SUM($C:$C)+D1")?, "S", "S", &mv)), "SUM(E:E)+SUM($F:$F)+D1");
+    let e = parse("Old!A1+'Old'!B2")?;
     assert_eq!(print(&rename_sheet(e, "Old", "New Name")), "'New Name'!A1+'New Name'!B2");
+    Ok(())
 }
 
 #[test]
-fn rename_sheet_updates_qualified_names() {
-    let e = parse("Data!MyName+MyName+Other!MyName").unwrap();
+fn rename_sheet_updates_qualified_names() -> Result<(), Box<dyn std::error::Error>> {
+    let e = parse("Data!MyName+MyName+Other!MyName")?;
     assert_eq!(print(&rename_sheet(e, "data", "Numbers")), "Numbers!MyName+MyName+Other!MyName");
-    let e = parse("Data!MyName").unwrap();
+    let e = parse("Data!MyName")?;
     assert_eq!(print(&rename_sheet(e, "Data", "New Name")), "'New Name'!MyName");
     // Stored bare, like a parsed name, so the evaluator finds the sheet and a second rename still matches.
-    let e = rename_sheet(parse("Data!MyName").unwrap(), "Data", "It's");
+    let e = rename_sheet(parse("Data!MyName")?, "Data", "It's");
     assert_eq!(e, Expr::Name("It's!MyName".into()));
     assert_eq!(print(&rename_sheet(e, "It's", "Totals")), "Totals!MyName");
+    Ok(())
 }
 
 #[test]
-fn moves_between_sheets() {
-    let mv = Edit::MoveToSheet { from: gridcraft_core::RangeRef::parse("A1:B2").unwrap(), to_sheet: "New Name".into(), to_row: 9, to_col: 3 };
+fn moves_between_sheets() -> Result<(), Box<dyn std::error::Error>> {
+    let mv = Edit::MoveToSheet { from: gridcraft_core::RangeRef::parse("A1:B2").ok_or("none")?, to_sheet: "New Name".into(), to_row: 9, to_col: 3 };
     for (host, input, expected) in [
         ("Source", "A1+$B$2+C3+SUM(A1:B2)", "'New Name'!D10+'New Name'!$E$11+C3+SUM('New Name'!D10:E11)"),
         ("Other", "A1+sOuRcE!$B2+Other!B2", "A1+'New Name'!$E11+Other!B2"),
         ("Source", "SUM(A1:C3)+SUM(Source:Other!A1)", "SUM(A1:C3)+SUM(Source:Other!A1)"),
     ] {
-        assert_eq!(print(&adjust(parse(input).unwrap(), host, "Source", &mv)), expected);
+        assert_eq!(print(&adjust(parse(input)?, host, "Source", &mv)), expected);
     }
     let edge = Edit::MoveToSheet {
-        from: gridcraft_core::RangeRef::parse("A1:B2").unwrap(),
+        from: gridcraft_core::RangeRef::parse("A1:B2").ok_or("none")?,
         to_sheet: "New Name".into(),
         to_row: gridcraft_core::MAX_ROWS - 1,
         to_col: 3,
     };
-    assert_eq!(print(&adjust(parse("B2").unwrap(), "Source", "Source", &edge)), "#REF!");
+    assert_eq!(print(&adjust(parse("B2")?, "Source", "Source", &edge)), "#REF!");
     for (from, input, row, col, expected) in [("A:A", "$A:$A", 0, 2, "Dest!$C:$C"), ("1:1", "$1:$1", 2, 0, "Dest!$3:$3")] {
-        let mv = Edit::MoveToSheet { from: gridcraft_core::RangeRef::parse(from).unwrap(), to_sheet: "Dest".into(), to_row: row, to_col: col };
-        assert_eq!(print(&adjust(parse(input).unwrap(), "Source", "Source", &mv)), expected);
+        let mv = Edit::MoveToSheet { from: gridcraft_core::RangeRef::parse(from).ok_or("none")?, to_sheet: "Dest".into(), to_row: row, to_col: col };
+        assert_eq!(print(&adjust(parse(input)?, "Source", "Source", &mv)), expected);
     }
+    Ok(())
 }
 
 #[test]
-fn r1c1() {
-    let e = parse("A1+$B$2+SUM(C:C)").unwrap();
+fn r1c1() -> Result<(), Box<dyn std::error::Error>> {
+    let e = parse("A1+$B$2+SUM(C:C)")?;
     assert_eq!(print_r1c1(&e, gridcraft_core::CellRef::new(1, 1)), "R[-1]C[-1]+R2C2+SUM(C[1])");
+    Ok(())
 }
 
 #[test]
-fn spans() {
-    let toks = lexer::tokenize("SUM(A1, B2)").unwrap();
-    let a1 = toks.iter().find(|t| t.tok == lexer::Tok::Word("A1".into())).unwrap();
+fn spans() -> Result<(), Box<dyn std::error::Error>> {
+    let toks = lexer::tokenize("SUM(A1, B2)")?;
+    let a1 = toks.iter().find(|t| t.tok == lexer::Tok::Word("A1".into())).ok_or("none")?;
     assert_eq!((a1.start, a1.end), (4, 6));
+    Ok(())
 }
 
 #[test]
-fn unbracketed_this_row_column() {
+fn unbracketed_this_row_column() -> Result<(), Box<dyn std::error::Error>> {
     // Writers such as xlsxwriter spell `[@Units]` as `[[#This Row],Units]`.
-    let p = |f: &str| parse(f).unwrap_or_else(|e| panic!("{f}: {e}"));
-    let Expr::Binary(BinOp::Mul, a, _) = p("[[#This Row],Units]*[[#This Row],Price]") else { panic!() };
-    let Expr::Struct(s) = *a else { panic!() };
+    let Expr::Binary(BinOp::Mul, a, _) = parse("[[#This Row],Units]*[[#This Row],Price]")? else { return Err("not a product".into()) };
+    let Expr::Struct(s) = *a else { return Err("not a struct".into()) };
     assert_eq!((s.specifiers.as_slice(), s.col_start.as_deref()), ([StructItem::ThisRow].as_slice(), Some("Units")));
     assert_eq!(rt("[[#This Row],Units]*[[#This Row],Price]"), "[@Units]*[@Price]");
     assert_eq!(rt("Sales[[#This Row],Units]"), "Sales[@Units]");
@@ -284,24 +295,26 @@ fn unbracketed_this_row_column() {
     ] {
         assert!(parse(bad).is_err(), "{bad} should fail");
     }
+    Ok(())
 }
 
 #[test]
-fn struct_column_keeps_edge_spaces() {
+fn struct_column_keeps_edge_spaces() -> Result<(), Box<dyn std::error::Error>> {
     // The spaces are part of the column name: `Table1[Qty ]` names `Qty `, never `Qty`.
-    let Expr::Struct(s) = parse("Table1[Qty ]").unwrap() else { panic!() };
+    let Expr::Struct(s) = parse("Table1[Qty ]")? else { return Err("unexpected expression".into()) };
     assert_eq!(s.col_start.as_deref(), Some("Qty "));
-    let Expr::Struct(s) = parse("Table1[ Qty]").unwrap() else { panic!() };
+    let Expr::Struct(s) = parse("Table1[ Qty]")? else { return Err("unexpected expression".into()) };
     assert_eq!(s.col_start.as_deref(), Some(" Qty"));
     // Excel writes such a column in the double-bracket form.
     assert_eq!(rt("Table1[Qty ]"), "Table1[[Qty ]]");
     for f in ["Table1[[Qty ]]", "Table1[[ Sum for Q2 ]]", "Table1[[#Totals],[Qty ]]", "Table1[@[Qty ]]", "Table1[Unit Price]"] {
         assert_eq!(rt(f), f);
     }
+    Ok(())
 }
 
 #[test]
-fn trim_references() {
+fn trim_references() -> Result<(), Box<dyn std::error::Error>> {
     for f in [
         "SUM(A1:.E10)",
         "SUM(A1.:E10)",
@@ -319,15 +332,15 @@ fn trim_references() {
     ] {
         assert_eq!(rt(f), f, "round trip of {f}");
     }
-    let Expr::Call(_, args) = parse("SUM(A1:.E10)").unwrap() else { panic!() };
+    let Expr::Call(_, args) = parse("SUM(A1:.E10)")? else { return Err("unexpected expression".into()) };
     assert!(matches!(args.as_slice(), [Expr::Unary(UnOp::Trim(TrimMode::Trailing), r)] if matches!(**r, Expr::Ref(_))));
     // Decimals, row ranges and dotted names keep their meaning.
-    assert_eq!(parse("1.5+.5").unwrap(), Expr::Binary(BinOp::Add, Box::new(Expr::Number(1.5)), Box::new(Expr::Number(0.5))));
+    assert_eq!(parse("1.5+.5")?, Expr::Binary(BinOp::Add, Box::new(Expr::Number(1.5)), Box::new(Expr::Number(0.5))));
     for f in ["SUM(1:5)", "Q1.2026!A1:B2", "my.name+1", "SUM(A1:B2)*1.5", "1.:5"] {
         assert_eq!(rt(f), f);
     }
     assert_eq!(rt("'Q1.2026'!A1:B2"), "Q1.2026!A1:B2");
-    assert!(matches!(parse("Q1.2026!A1:B2").unwrap(), Expr::Ref(_)));
+    assert!(matches!(parse("Q1.2026!A1:B2")?, Expr::Ref(_)));
     // File call forms.
     assert_eq!(rt("SUM(_xlfn._TRO_TRAILING(A1:E10))"), "SUM(A1:.E10)");
     assert_eq!(rt("_xlfn._TRO_LEADING(A:A)"), "A.:A");
@@ -338,77 +351,76 @@ fn trim_references() {
         assert!(parse(bad).is_err(), "{bad} should fail");
     }
     // R1C1 keeps the operator.
-    assert_eq!(print_r1c1(&parse("SUM(A1:.B2)+ROWS(2.:2)").unwrap(), gridcraft_core::CellRef::new(0, 0)), "SUM(RC:.R[1]C[1])+ROWS(R[1].:R[1])");
+    assert_eq!(print_r1c1(&parse("SUM(A1:.B2)+ROWS(2.:2)")?, gridcraft_core::CellRef::new(0, 0)), "SUM(RC:.R[1]C[1])+ROWS(R[1].:R[1])");
+    Ok(())
 }
 
 #[test]
-fn trim_references_adjust() {
+fn trim_references_adjust() -> Result<(), Box<dyn std::error::Error>> {
     let ins = Edit::Insert { axis: Axis::Rows, at: 2, count: 2 };
-    let e = parse("SUM(A1:.A5)+SUM(B:.B)+ROWS(2.:.4)").unwrap();
+    let e = parse("SUM(A1:.A5)+SUM(B:.B)+ROWS(2.:.4)")?;
     assert_eq!(print(&adjust(e, "S", "S", &ins)), "SUM(A1:.A7)+SUM(B:.B)+ROWS(2.:.6)");
     let del = Edit::Delete { axis: Axis::Cols, at: 0, count: 1 };
-    let e = parse("SUM(A1.:C1)+SUM(A:.A)").unwrap();
+    let e = parse("SUM(A1.:C1)+SUM(A:.A)")?;
     assert_eq!(print(&adjust(e, "S", "S", &del)), "SUM(A1.:B1)+SUM(#REF!)");
-    assert_eq!(print(&shift_relative(parse("SUM(A1.:.B2)").unwrap(), 1, 1)), "SUM(B2.:.C3)");
-    let refs: Vec<String> = parse("SUM(Sheet2!A1:.B5)").unwrap().references().iter().map(|r| printer::reference_a1(r)).collect();
+    assert_eq!(print(&shift_relative(parse("SUM(A1.:.B2)")?, 1, 1)), "SUM(B2.:.C3)");
+    let refs: Vec<String> = parse("SUM(Sheet2!A1:.B5)")?.references().iter().map(|r| printer::reference_a1(r)).collect();
     assert_eq!(refs, ["Sheet2!A1:B5"]);
+    Ok(())
 }
 
 #[test]
-fn prints_long_flat_chain_without_deep_recursion() {
+fn prints_long_flat_chain_without_deep_recursion() -> Result<(), Box<dyn std::error::Error>> {
     // Small stack: a recursive printer overflows long before 20000 levels.
-    let handle = std::thread::Builder::new()
-        .stack_size(256 * 1024)
-        .spawn(|| {
-            let mut e = Expr::Number(1.0);
-            for _ in 0..20000 {
-                e = Expr::Binary(BinOp::Add, Box::new(e), Box::new(Expr::Number(1.0)));
-            }
-            let text = print(&e);
-            let r1c1 = print_r1c1(&e, gridcraft_core::CellRef { row: 0, col: 0 });
-            // Dropping the deep tree recurses; leak it so only the printer is under test.
-            std::mem::forget(e);
-            (text, r1c1)
-        })
-        .expect("spawn");
-    let (text, r1c1) = handle.join().expect("printer must not overflow the stack");
+    let handle = std::thread::Builder::new().stack_size(256 * 1024).spawn(|| {
+        let mut e = Expr::Number(1.0);
+        for _ in 0..20000 {
+            e = Expr::Binary(BinOp::Add, Box::new(e), Box::new(Expr::Number(1.0)));
+        }
+        let text = print(&e);
+        let r1c1 = print_r1c1(&e, gridcraft_core::CellRef { row: 0, col: 0 });
+        // Dropping the deep tree recurses; leak it so only the printer is under test.
+        std::mem::forget(e);
+        (text, r1c1)
+    })?;
+    let (text, r1c1) = handle.join().map_err(|_| "thread panicked")?;
     assert_eq!(text, vec!["1"; 20001].join("+"));
     assert_eq!(r1c1, text);
+    Ok(())
 }
 
 #[test]
-fn hostile_formulas_are_errors_not_stack_overflows() {
+fn hostile_formulas_are_errors_not_stack_overflows() -> Result<(), Box<dyn std::error::Error>> {
     // A small stack: parsing must fail cleanly instead of building trees deeper than the nesting
     // limit, which dropping, printing and evaluating walk recursively.
-    let handle = std::thread::Builder::new()
-        .stack_size(512 * 1024)
-        .spawn(|| {
-            let percents = format!("1{}", "%".repeat(1_000));
-            let invokes = format!("LAMBDA(x,x)(1){}", "(1)".repeat(1_000));
-            let long_chain = format!("1{}", "+1".repeat(100_000));
-            let huge_percents = format!("1{}", "%".repeat(1_000_000));
-            (parse(&percents).is_err(), parse(&invokes).is_err(), parse(&long_chain).is_err(), parse(&huge_percents).is_err())
-        })
-        .expect("spawn");
-    assert_eq!(handle.join().expect("parsing must not overflow the stack"), (true, true, true, true));
+    let handle = std::thread::Builder::new().stack_size(512 * 1024).spawn(|| {
+        let percents = format!("1{}", "%".repeat(1_000));
+        let invokes = format!("LAMBDA(x,x)(1){}", "(1)".repeat(1_000));
+        let long_chain = format!("1{}", "+1".repeat(100_000));
+        let huge_percents = format!("1{}", "%".repeat(1_000_000));
+        (parse(&percents).is_err(), parse(&invokes).is_err(), parse(&long_chain).is_err(), parse(&huge_percents).is_err())
+    })?;
+    assert_eq!(handle.join().map_err(|_| "thread panicked")?, (true, true, true, true));
     // Within the limits these still parse.
     assert!(parse(&format!("1{}", "%".repeat(100))).is_ok());
     assert!(parse("LAMBDA(x,x)(1)(2)").is_ok());
+    Ok(())
 }
 
 #[test]
-fn formulas_longer_than_excel_allows_are_refused() {
+fn formulas_longer_than_excel_allows_are_refused() -> Result<(), Box<dyn std::error::Error>> {
     let at_limit = format!("1{}", "+1".repeat((crate::MAX_FORMULA_LEN - 1) / 2));
     assert_eq!(at_limit.chars().count(), crate::MAX_FORMULA_LEN - 1);
     assert!(parse(&at_limit).is_ok());
     assert!(parse(&format!("={at_limit}")).is_ok(), "the leading = does not count");
     let over = format!("{at_limit}+1");
-    let err = parse(&over).unwrap_err();
+    let err = parse(&over).err().ok_or("none")?;
     assert!(err.msg.contains("8192"), "{}", err.msg);
     // Characters, not bytes: 8,000 two-byte characters in a text literal are within the limit.
     let text = format!("\"{}\"", "é".repeat(8_000));
     assert!(text.len() > crate::MAX_FORMULA_LEN);
     assert!(parse(&text).is_ok());
+    Ok(())
 }
 
 #[test]
@@ -424,41 +436,40 @@ fn sheet_names_excel_quotes_stay_quoted() {
 }
 
 #[test]
-fn longest_flat_chains_clone_compare_walk_and_adjust_without_deep_recursion() {
+fn longest_flat_chains_clone_compare_walk_and_adjust_without_deep_recursion() -> Result<(), Box<dyn std::error::Error>> {
     // `=1+1+…` with 4,096 operands is 8,192 characters, Excel's formula limit, and nests 4,095
     // levels on its left. On a 1 MiB stack (the Windows main thread) the derived, recursive
     // Clone overflowed when the engine stored such a formula (#916).
-    let handle = std::thread::Builder::new()
-        .stack_size(1 << 20)
-        .spawn(|| {
-            let plus = vec!["1"; 4096].join("+");
-            let e = parse(&plus).expect("parse");
-            let copy = e.clone();
-            assert!(copy == e);
-            let other = parse(&format!("{}-1", vec!["1"; 4095].join("+"))).expect("parse");
-            assert!(other != e);
-            let mut nodes = 0;
-            e.walk(&mut |_| nodes += 1);
-            assert_eq!(nodes, 2 * 4096 - 1);
-            assert_eq!(print(&copy.map(&mut |x| x)), plus);
-            // A chain of references: walk finds them in order, adjust rewrites every one.
-            let refs = (1..=1000).map(|r| format!("A{r}")).collect::<Vec<_>>().join("+");
-            let e = parse(&refs).expect("parse");
-            let found: Vec<String> = e.references().iter().map(|r| printer::reference_a1(r)).collect();
-            assert_eq!(found.first().map(String::as_str), Some("A1"));
-            assert_eq!(found.last().map(String::as_str), Some("A1000"));
-            assert_eq!(found.len(), 1000);
-            let ins = Edit::Insert { axis: Axis::Rows, at: 0, count: 1 };
-            let moved = print(&adjust(e.clone(), "S", "S", &ins));
-            assert_eq!(moved, (2..=1001).map(|r| format!("A{r}")).collect::<Vec<_>>().join("+"));
-            assert_eq!(print(&shift_relative(e, 0, 1)), (1..=1000).map(|r| format!("B{r}")).collect::<Vec<_>>().join("+"));
-        })
-        .expect("spawn");
-    handle.join().expect("long chains must not overflow the stack");
+    let handle = std::thread::Builder::new().stack_size(1 << 20).spawn(|| {
+        let plus = vec!["1"; 4096].join("+");
+        let e = parse(&plus)?;
+        let copy = e.clone();
+        assert!(copy == e);
+        let other = parse(&format!("{}-1", vec!["1"; 4095].join("+")))?;
+        assert!(other != e);
+        let mut nodes = 0;
+        e.walk(&mut |_| nodes += 1);
+        assert_eq!(nodes, 2 * 4096 - 1);
+        assert_eq!(print(&copy.map(&mut |x| x)), plus);
+        // A chain of references: walk finds them in order, adjust rewrites every one.
+        let refs = (1..=1000).map(|r| format!("A{r}")).collect::<Vec<_>>().join("+");
+        let e = parse(&refs)?;
+        let found: Vec<String> = e.references().iter().map(|r| printer::reference_a1(r)).collect();
+        assert_eq!(found.first().map(String::as_str), Some("A1"));
+        assert_eq!(found.last().map(String::as_str), Some("A1000"));
+        assert_eq!(found.len(), 1000);
+        let ins = Edit::Insert { axis: Axis::Rows, at: 0, count: 1 };
+        let moved = print(&adjust(e.clone(), "S", "S", &ins));
+        assert_eq!(moved, (2..=1001).map(|r| format!("A{r}")).collect::<Vec<_>>().join("+"));
+        assert_eq!(print(&shift_relative(e, 0, 1)), (1..=1000).map(|r| format!("B{r}")).collect::<Vec<_>>().join("+"));
+        Ok::<(), crate::ParseError>(())
+    })?;
+    handle.join().map_err(|_| "thread panicked")??;
+    Ok(())
 }
 
 #[test]
-fn spanish_input_counts_left_operand_of_a_chain_at_the_same_depth() {
+fn spanish_input_counts_left_operand_of_a_chain_at_the_same_depth() -> Result<(), Box<dyn std::error::Error>> {
     // The leftmost operand of a flat chain is not nested, so `(((…1)))+1` is accepted whenever
     // `(((…1)))` is, in both the pre-check and `normalize`.
     let wrap = |n: usize| {
@@ -469,17 +480,18 @@ fn spanish_input_counts_left_operand_of_a_chain_at_the_same_depth() {
         e
     };
     let es = |e: &Expr| crate::print_input(e, FormulaLocale::Es, |_| false);
-    let deepest = (0..400).take_while(|&n| es(&wrap(n)).is_ok()).last().expect("depth 0 is accepted");
+    let deepest = (0..400).take_while(|&n| es(&wrap(n)).is_ok()).last().ok_or("none")?;
     assert!(deepest > 1 && deepest < 400);
     let chain = Expr::Binary(BinOp::Add, Box::new(wrap(deepest)), Box::new(Expr::Number(1.0)));
     assert!(es(&chain).is_ok());
+    Ok(())
 }
 
 #[test]
-fn walk_is_preorder_and_map_is_postorder_left_to_right() {
+fn walk_is_preorder_and_map_is_postorder_left_to_right() -> Result<(), Box<dyn std::error::Error>> {
     // `(A1+B1)+SUM(C1,D1)-E1`: a chain with a call on its right. walk visits parents before
     // children, map rewrites children (left to right) before their parent.
-    let e = parse("(A1+B1)+SUM(C1,D1)-E1").unwrap();
+    let e = parse("(A1+B1)+SUM(C1,D1)-E1")?;
     let mut walked = Vec::new();
     e.walk(&mut |n| walked.push(print(n)));
     assert_eq!(walked, ["(A1+B1)+SUM(C1,D1)-E1", "(A1+B1)+SUM(C1,D1)", "(A1+B1)", "A1+B1", "A1", "B1", "SUM(C1,D1)", "C1", "D1", "E1"]);
@@ -490,19 +502,21 @@ fn walk_is_preorder_and_map_is_postorder_left_to_right() {
     });
     assert_eq!(mapped, ["A1", "B1", "A1+B1", "(A1+B1)", "C1", "D1", "SUM(C1,D1)", "(A1+B1)+SUM(C1,D1)", "E1", "(A1+B1)+SUM(C1,D1)-E1"]);
     assert_eq!(print(&out), "(A1+B1)+SUM(C1,D1)-E1");
+    Ok(())
 }
 
 #[test]
-fn missing_closing_parentheses_are_closed_and_errors_describe_the_typed_text() {
+fn missing_closing_parentheses_are_closed_and_errors_describe_the_typed_text() -> Result<(), Box<dyn std::error::Error>> {
     // #2030: `1+` reported "unexpected `)`", the error of the last retry with `)` appended.
     let entry = |src: &str| parse_closing_parens(src, parse);
     assert_eq!(entry("SUM(1,2").map(|e| print(&e)), Ok("SUM(1,2)".to_string()));
     assert_eq!(entry("((1+2").map(|e| print(&e)), Ok("((1+2))".to_string()));
     assert_eq!(entry("1+2").map(|e| print(&e)), Ok("1+2".to_string()));
     for src in ["1+", "--", "SUM(1,+", "1+*2", &format!("{}1", "(".repeat(9))] {
-        assert_eq!(entry(src).unwrap_err(), parse(src).unwrap_err(), "{src}");
+        assert_eq!(entry(src).err().ok_or("none")?, parse(src).err().ok_or("none")?, "{src}");
     }
-    assert_eq!(entry("1+").unwrap_err().msg, "unexpected end of formula");
+    assert_eq!(entry("1+").err().ok_or("none")?.msg, "unexpected end of formula");
+    Ok(())
 }
 
 #[test]
@@ -521,7 +535,7 @@ fn three_d_span_and_cell_start_still_lex_as_span() {
 
 /// References print the same through the appending printer for every reference shape.
 #[test]
-fn reference_shapes_print_unchanged() {
+fn reference_shapes_print_unchanged() -> Result<(), Box<dyn std::error::Error>> {
     for text in [
         "A1",
         "XFD1048576",
@@ -536,10 +550,11 @@ fn reference_shapes_print_unchanged() {
         "'Sheet 1:Sheet3'!B2",
         "SUM(A1:.B3)+SUM(A.:.B)",
     ] {
-        let e = parse(text).unwrap();
+        let e = parse(text)?;
         assert_eq!(print(&e), text);
         if let Expr::Ref(r) = &e {
             assert_eq!(printer::reference_a1(r), text);
         }
     }
+    Ok(())
 }
diff --git a/crates/functions/src/criteria.rs b/crates/functions/src/criteria.rs
index 2d8218f3e..fd5342352 100644
--- a/crates/functions/src/criteria.rs
+++ b/crates/functions/src/criteria.rs
@@ -389,7 +389,7 @@ mod tests {
     }
 
     #[test]
-    fn criteria() {
+    fn text_criteria() {
         assert!(m(">5", Value::Number(6.0)));
         assert!(!m(">5", Value::Number(5.0)));
         assert!(m(">=5", Value::Number(5.0)));
@@ -402,6 +402,10 @@ mod tests {
         assert!(m("?pple", Value::from("apple")));
         assert!(m("~*", Value::from("*")));
         assert!(!m("~*", Value::from("x")));
+    }
+
+    #[test]
+    fn blank_criteria() {
         assert!(m("", Value::Empty));
         assert!(m("", Value::from("")));
         assert!(!m("", Value::Number(0.0)));
@@ -409,10 +413,14 @@ mod tests {
         assert!(!m("=", Value::from("a")));
         assert!(m("<>", Value::from("a")));
         assert!(!m("<>", Value::Empty));
-        assert!(m("TRUE", Value::Bool(true)));
-        // A bare "<=" or ">=" never matches an empty string (Excel 365: COUNTIF(="", "<=") is 0).
         assert!(!m("<=", Value::from("")));
         assert!(!m(">=", Value::from("")));
+        // A bare "<=" or ">=" never matches an empty string (Excel 365: COUNTIF(="", "<=") is 0).
+    }
+
+    #[test]
+    fn typed_criteria() {
+        assert!(m("TRUE", Value::Bool(true)));
         assert!(m("<b", Value::from("apple")));
         assert!(!m("<b", Value::Number(1.0)));
         assert!(m("#N/A", Value::Error(CellError::NA)));
diff --git a/crates/functions/src/database.rs b/crates/functions/src/database.rs
index 455b8a1d6..37289d9fb 100644
--- a/crates/functions/src/database.rs
+++ b/crates/functions/src/database.rs
@@ -66,11 +66,15 @@ fn cell_criterion(v: &Value) -> Option<Criterion> {
     }
 }
 
+/// A criteria row: its index and its conditions (criteria column, database column or `None`
+/// when the label is unknown, criterion).
+type CriteriaRow = (usize, Vec<(usize, Option<usize>, Criterion)>);
+
 /// Rows (1-based within the database, excluding the header) of matching records.
 fn matching_records(db: &Array, crit: &Array, ctx: &mut dyn Ctx) -> Vec<usize> {
     // Per criteria row: its index and a list of (criteria column, database column or None when
     // the label is unknown, criterion).
-    let mut rows: Vec<(usize, Vec<(usize, Option<usize>, Criterion)>)> = Vec::new();
+    let mut rows: Vec<CriteriaRow> = Vec::new();
     for r in 1..crit.rows {
         let mut conds = Vec::new();
         for c in 0..crit.cols {
diff --git a/crates/functions/src/engineering/bessel.rs b/crates/functions/src/engineering/bessel.rs
index 34be81783..c91157318 100644
--- a/crates/functions/src/engineering/bessel.rs
+++ b/crates/functions/src/engineering/bessel.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, CellError, Ctx, PI, R, Value, num, num_val};
 
 // ---------------------------------------------------------------------------------------------
 // Bessel functions
diff --git a/crates/functions/src/engineering/complex.rs b/crates/functions/src/engineering/complex.rs
index 86ab6b535..a04c19e8f 100644
--- a/crates/functions/src/engineering/complex.rs
+++ b/crates/functions/src/engineering/complex.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, CellError, Ctx, R, Value, flatten, has, num, num_val, number_to_text, scalar, text, text_val};
 
 // ---------------------------------------------------------------------------------------------
 // Complex numbers
diff --git a/crates/functions/src/engineering/units.rs b/crates/functions/src/engineering/units.rs
index e54abd87a..b6c4faf2b 100644
--- a/crates/functions/src/engineering/units.rs
+++ b/crates/functions/src/engineering/units.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, CellError, Ctx, R, Value, num, num_val, text};
 
 // ---------------------------------------------------------------------------------------------
 // CONVERT
diff --git a/crates/functions/src/financial/day_count.rs b/crates/functions/src/financial/day_count.rs
index f91e7968f..a42156e17 100644
--- a/crates/functions/src/financial/day_count.rs
+++ b/crates/functions/src/financial/day_count.rs
@@ -1,4 +1,6 @@
-use super::*;
+use super::{
+    Arg, CellError, Ctx, DateSystem, R, Value, datetime_from_serial, days_in_month, is_leap, max_serial, num, num_val, opt_num, serial_from_ymd,
+};
 
 // ---------------------------------------------------------------------------------------------
 // Dates and day counts
diff --git a/crates/functions/src/financial/depreciation.rs b/crates/functions/src/financial/depreciation.rs
index d656aa76f..e7b456c69 100644
--- a/crates/functions/src/financial/depreciation.rs
+++ b/crates/functions/src/financial/depreciation.rs
@@ -1,5 +1,5 @@
 use super::day_count::{basis_arg, date, year_frac};
-use super::*;
+use super::{Arg, CellError, Ctx, R, Value, num, num_val, opt_bool, opt_num};
 
 // ---------------------------------------------------------------------------------------------
 // Depreciation
diff --git a/crates/functions/src/financial/securities.rs b/crates/functions/src/financial/securities.rs
index cfecd763a..ea696c8a6 100644
--- a/crates/functions/src/financial/securities.rs
+++ b/crates/functions/src/financial/securities.rs
@@ -1,5 +1,5 @@
 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::*;
+use super::{Arg, CellError, Ctx, DateSystem, R, Value, days_in_month, has, num, num_val, opt_bool};
 
 // ---------------------------------------------------------------------------------------------
 // Securities
@@ -479,7 +479,10 @@ fn odd_last(sys: DateSystem, settle: f64, mat: f64, last: f64, freq: f64, basis:
 }
 
 /// 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)> {
+/// `((dc, acc, dsc), rate, yield-or-price, redemption, frequency)` of an odd-last-period call.
+type OddLastArgs = ((f64, f64, f64), f64, f64, f64, f64);
+
+fn odd_last_args(a: &[Arg], sys: DateSystem) -> R<OddLastArgs> {
     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)?);
diff --git a/crates/functions/src/financial/tvm.rs b/crates/functions/src/financial/tvm.rs
index a62d29bb5..61710f0bd 100644
--- a/crates/functions/src/financial/tvm.rs
+++ b/crates/functions/src/financial/tvm.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, CellError, Ctx, R, Value, array_numbers, as_array, flatten, num, num_val, numbers, opt_num, type_arg};
 
 // ---------------------------------------------------------------------------------------------
 // Time value of money
diff --git a/crates/functions/src/math/criteria.rs b/crates/functions/src/math/criteria.rs
index fd77aed34..ac968b991 100644
--- a/crates/functions/src/math/criteria.rs
+++ b/crates/functions/src/math/criteria.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, Array, CellError, Criterion, Ctx, R, Value, as_array, has, num_val};
 
 // ---------------------------------------------------------------------------------------------
 // Criteria aggregates
diff --git a/crates/functions/src/math/matrix.rs b/crates/functions/src/math/matrix.rs
index 9bfb75c53..69917eae0 100644
--- a/crates/functions/src/math/matrix.rs
+++ b/crates/functions/src/math/matrix.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, CellError, Ctx, MAX_CELLS, R, Value, array_val, as_array, check_size, num, num_val, to_sig_digits};
 
 // ---------------------------------------------------------------------------------------------
 // Matrices
diff --git a/crates/functions/src/math/roman_base.rs b/crates/functions/src/math/roman_base.rs
index 931552e93..16376c4ec 100644
--- a/crates/functions/src/math/roman_base.rs
+++ b/crates/functions/src/math/roman_base.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, CellError, Ctx, R, Value, num, num_val, opt_num, text, text_val};
 
 // ---------------------------------------------------------------------------------------------
 // Number systems
diff --git a/crates/functions/src/stat/descriptive.rs b/crates/functions/src/stat/descriptive.rs
index af4c53607..299873398 100644
--- a/crates/functions/src/stat/descriptive.rs
+++ b/crates/functions/src/stat/descriptive.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arg, C, CellError, R, Value, arg, array_numbers, array_val, as_array, has, num, num_val, opt_num};
 
 // ---------------------------------------------------------------------------------------------
 // Basic helpers over number lists
diff --git a/crates/functions/src/stat/distributions.rs b/crates/functions/src/stat/distributions.rs
index cb2f0398a..18027e654 100644
--- a/crates/functions/src/stat/distributions.rs
+++ b/crates/functions/src/stat/distributions.rs
@@ -1,5 +1,8 @@
 use super::descriptive::{arg_nums, arg_pairs, mean, var_s};
-use super::*;
+use super::{
+    Arg, C, CellError, R, Value, arg, as_array, boolean, erf, gamma, has, invert, ln_beta, ln_gamma, norm_cdf, norm_inv, norm_pdf, num, num_val,
+    reg_gamma_p, reg_gamma_q, reg_inc_beta,
+};
 
 // ---------------------------------------------------------------------------------------------
 // Distributions
diff --git a/crates/functions/src/stat/regression.rs b/crates/functions/src/stat/regression.rs
index 410b086d4..55bf0aec7 100644
--- a/crates/functions/src/stat/regression.rs
+++ b/crates/functions/src/stat/regression.rs
@@ -1,5 +1,5 @@
 use super::descriptive::{arg_pairs, intercept, moments, slope};
-use super::*;
+use super::{Arg, C, CellError, R, Value, arg, array_val, as_array, boolean, has, num, num_val};
 
 pub(super) fn forecast(a: &[Arg], _: C) -> R<Value> {
     let x = num(a, 0)?;
diff --git a/crates/model/src/b64.rs b/crates/model/src/b64.rs
index b377fe451..f36ede104 100644
--- a/crates/model/src/b64.rs
+++ b/crates/model/src/b64.rs
@@ -90,10 +90,11 @@ pub mod opt {
 #[cfg(test)]
 mod tests {
     #[test]
-    fn roundtrip() {
+    fn roundtrip() -> Result<(), Box<dyn std::error::Error>> {
         for data in [&b""[..], b"a", b"ab", b"abc", b"hello world", &[0, 255, 128, 7]] {
-            assert_eq!(super::decode(&super::encode(data)).unwrap(), data);
+            assert_eq!(super::decode(&super::encode(data)).ok_or("none")?, data);
         }
         assert_eq!(super::encode(b"Man"), "TWFu");
+        Ok(())
     }
 }
diff --git a/crates/model/src/cellmap.rs b/crates/model/src/cellmap.rs
index f72b7b5af..bc120acce 100644
--- a/crates/model/src/cellmap.rs
+++ b/crates/model/src/cellmap.rs
@@ -27,7 +27,7 @@ mod tests {
     use gridcraft_core::CellRef;
 
     #[test]
-    fn comments_and_hyperlinks_survive_json() {
+    fn comments_and_hyperlinks_survive_json() -> Result<(), Box<dyn std::error::Error>> {
         let mut s = Sheet::new("S");
         let a1 = CellRef::new(0, 0);
         let c3 = CellRef::new(2, 2);
@@ -45,9 +45,10 @@ mod tests {
             },
         );
         s.hyperlinks.insert(c3, Hyperlink { target: "Sheet1!A1".into(), tooltip: Some("jump".into()), external: false });
-        let json = serde_json::to_string(&s).expect("serialize");
-        let back: Sheet = serde_json::from_str(&json).expect("deserialize");
+        let json = serde_json::to_string(&s)?;
+        let back: Sheet = serde_json::from_str(&json)?;
         assert_eq!(back.comments, s.comments);
         assert_eq!(back.hyperlinks, s.hyperlinks);
+        Ok(())
     }
 }
diff --git a/crates/model/src/features/pivot.rs b/crates/model/src/features/pivot.rs
index 368aa1f53..b34015f4c 100644
--- a/crates/model/src/features/pivot.rs
+++ b/crates/model/src/features/pivot.rs
@@ -1,4 +1,5 @@
-use super::*;
+use super::{CellRef, RangeRef};
+use serde::{Deserialize, Serialize};
 
 // ---------------------------------------------------------------- pivot tables
 
diff --git a/crates/model/src/features/print.rs b/crates/model/src/features/print.rs
index 6a4ab0be0..cbcaf3e55 100644
--- a/crates/model/src/features/print.rs
+++ b/crates/model/src/features/print.rs
@@ -1,4 +1,5 @@
-use super::*;
+use super::{CellRef, RangeRef};
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Orientation {
diff --git a/crates/model/src/password.rs b/crates/model/src/password.rs
index 59b9aafba..f46de4b44 100644
--- a/crates/model/src/password.rs
+++ b/crates/model/src/password.rs
@@ -106,28 +106,30 @@ mod tests {
     use super::*;
 
     #[test]
-    fn legacy_hash_matches_the_published_example() {
+    fn legacy_hash_matches_the_published_example() -> Result<(), Box<dyn std::error::Error>> {
         // The hash Excel writes for the password "password" (`password="83AF"`).
         assert_eq!(legacy_hash("password"), 0x83AF);
-        assert!(PasswordHash::Legacy(0x83AF).verify("password").unwrap());
-        assert!(!PasswordHash::Legacy(0x83AF).verify("Password").unwrap());
+        assert!(PasswordHash::Legacy(0x83AF).verify("password")?);
+        assert!(!PasswordHash::Legacy(0x83AF).verify("Password")?);
         assert_eq!(legacy_hash(""), 0xCE4B);
+        Ok(())
     }
 
     #[test]
-    fn iterated_hash_verifies_and_refuses_what_it_cannot_check() {
+    fn iterated_hash_verifies_and_refuses_what_it_cannot_check() -> Result<(), Box<dyn std::error::Error>> {
         let h = PasswordHash::new_sha512("s3cret", b"0123456789abcdef");
-        assert!(h.verify("s3cret").unwrap());
-        assert!(!h.verify("s3cret ").unwrap());
+        assert!(h.verify("s3cret")?);
+        assert!(!h.verify("s3cret ")?);
         assert!(matches!(&h, PasswordHash::Iterated { algorithm, spin_count: DEFAULT_SPIN_COUNT, .. } if algorithm == "SHA-512"));
-        let PasswordHash::Iterated { hash, salt, .. } = h else { return };
+        let PasswordHash::Iterated { hash, salt, .. } = h else { return Err("not an iterated hash".into()) };
         let other =
             |algorithm: &str, spin_count| PasswordHash::Iterated { algorithm: algorithm.into(), hash: hash.clone(), salt: salt.clone(), spin_count };
         assert!(other("SHA-1", 10).verify("s3cret").is_err());
         assert!(other("MD5", 10).verify("s3cret").is_err());
         assert!(other("SHA-512", MAX_SPIN_COUNT + 1).verify("s3cret").is_err());
-        assert!(!other("SHA-256", 2).verify("s3cret").unwrap());
+        assert!(!other("SHA-256", 2).verify("s3cret")?);
         let broken = PasswordHash::Iterated { algorithm: "SHA-512".into(), hash: "!!".into(), salt: salt.clone(), spin_count: 1 };
         assert!(broken.verify("s3cret").is_err());
+        Ok(())
     }
 }
diff --git a/crates/model/src/store.rs b/crates/model/src/store.rs
index 531273ce9..d6beb4994 100644
--- a/crates/model/src/store.rs
+++ b/crates/model/src/store.rs
@@ -330,30 +330,32 @@ mod tests {
     }
 
     #[test]
-    fn set_get_remove() {
+    fn set_get_remove() -> Result<(), Box<dyn std::error::Error>> {
         let mut s = CellStore::new();
         s.set(c(0, 0), Cell::value(1.0.into()));
         s.set(c(100, 5), Cell::value("x".into()));
         assert_eq!(s.len(), 2);
         assert_eq!(s.get(c(100, 5)).map(|x| x.value.clone()), Some(Value::from("x")));
-        assert_eq!(s.used_range().unwrap().a1(), "A1:F101");
+        assert_eq!(s.used_range().ok_or("none")?.a1(), "A1:F101");
         s.set(c(0, 0), Cell::default());
         assert_eq!(s.len(), 1);
         assert!(s.remove(c(100, 5)).is_some());
         assert!(s.is_empty());
         assert!(s.used_range().is_none());
+        Ok(())
     }
 
     #[test]
-    fn cow_snapshots() {
+    fn cow_snapshots() -> Result<(), Box<dyn std::error::Error>> {
         let mut s = CellStore::new();
         for r in 0..1000 {
             s.set(c(r, 0), Cell::value((r as f64).into()));
         }
         let snap = s.clone();
         s.set(c(5, 0), Cell::value(99.0.into()));
-        assert_eq!(snap.get(c(5, 0)).unwrap().value, Value::Number(5.0));
-        assert_eq!(s.get(c(5, 0)).unwrap().value, Value::Number(99.0));
+        assert_eq!(snap.get(c(5, 0)).ok_or("none")?.value, Value::Number(5.0));
+        assert_eq!(s.get(c(5, 0)).ok_or("none")?.value, Value::Number(99.0));
+        Ok(())
     }
 
     #[test]
@@ -371,14 +373,16 @@ mod tests {
     }
 
     #[test]
-    fn range_iteration_order() {
+    fn range_iteration_order() -> Result<(), Box<dyn std::error::Error>> {
         let mut s = CellStore::new();
         s.set(c(70, 2), Cell::value(3.0.into()));
         s.set(c(1, 1), Cell::value(1.0.into()));
         s.set(c(1, 3), Cell::value(2.0.into()));
         s.set(c(500, 0), Cell::value(4.0.into()));
-        let v: Vec<f64> = s.iter_range(RangeRef::parse("A1:D100").unwrap()).map(|(_, x)| x.value.as_f64().unwrap()).collect();
+        let v: Vec<f64> =
+            s.iter_range(RangeRef::parse("A1:D100").ok_or("none")?).map(|(_, x)| x.value.as_f64()).collect::<Option<_>>().ok_or("none")?;
         assert_eq!(v, [1.0, 2.0, 3.0]);
+        Ok(())
     }
 
     #[test]
diff --git a/crates/model/src/style.rs b/crates/model/src/style.rs
index 1ded99288..d2f10780e 100644
--- a/crates/model/src/style.rs
+++ b/crates/model/src/style.rs
@@ -500,32 +500,34 @@ mod tests {
     }
 
     #[test]
-    fn a_theme_saved_before_per_script_fonts_still_opens() {
-        let mut json = serde_json::to_value(Theme::default()).unwrap();
-        let fields = json.as_object_mut().unwrap();
+    fn a_theme_saved_before_per_script_fonts_still_opens() -> Result<(), Box<dyn std::error::Error>> {
+        let mut json = serde_json::to_value(Theme::default())?;
+        let fields = json.as_object_mut().ok_or("none")?;
         assert!(fields.remove("major_font_scripts").is_some() && fields.remove("minor_font_scripts").is_some());
-        assert_eq!(serde_json::from_value::<Theme>(json).unwrap(), Theme::default());
+        assert_eq!(serde_json::from_value::<Theme>(json)?, Theme::default());
+        Ok(())
     }
 
     #[test]
-    fn colors() {
+    fn colors() -> Result<(), Box<dyn std::error::Error>> {
         let th = Theme::default();
-        assert_eq!(Color::from_hex("#FF0000").unwrap().resolve(&th), Some([255, 0, 0]));
-        assert_eq!(Color::from_hex("FF00FF00").unwrap().resolve(&th), Some([0, 255, 0]));
+        assert_eq!(Color::from_hex("#FF0000").ok_or("none")?.resolve(&th), Some([255, 0, 0]));
+        assert_eq!(Color::from_hex("FF00FF00").ok_or("none")?.resolve(&th), Some([0, 255, 0]));
         assert_eq!(Color::Theme(0, -500).resolve(&th), Some([128, 128, 128]));
         assert_eq!(Color::Theme(1, 500).resolve(&th), Some([128, 128, 128]));
         assert_eq!(Color::Auto.resolve(&th), None);
+        Ok(())
     }
 
     #[test]
-    fn theme_json_keeps_ea_and_cs_and_reads_old_json() {
+    fn theme_json_keeps_ea_and_cs_and_reads_old_json() -> Result<(), Box<dyn std::error::Error>> {
         // JSON written before the ea/cs fields existed still deserializes (`serde(default)`).
-        let mut old = serde_json::to_value(Theme::default()).unwrap();
-        let obj = old.as_object_mut().unwrap();
+        let mut old = serde_json::to_value(Theme::default())?;
+        let obj = old.as_object_mut().ok_or("none")?;
         for key in ["major_font_ea", "minor_font_ea", "major_font_cs", "minor_font_cs"] {
             assert!(obj.remove(key).is_some(), "the default theme serializes {key}");
         }
-        assert_eq!(serde_json::from_value::<Theme>(old).unwrap(), Theme::default());
+        assert_eq!(serde_json::from_value::<Theme>(old)?, Theme::default());
 
         // Set fields serialize and come back.
         let t = Theme {
@@ -535,8 +537,9 @@ mod tests {
             minor_font_cs: "Times New Roman".into(),
             ..Theme::default()
         };
-        let json = serde_json::to_string(&t).unwrap();
+        let json = serde_json::to_string(&t)?;
         assert!(json.contains("major_font_ea") && json.contains("游ゴシック"), "{json}");
-        assert_eq!(serde_json::from_str::<Theme>(&json).unwrap(), t);
+        assert_eq!(serde_json::from_str::<Theme>(&json)?, t);
+        Ok(())
     }
 }
diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs
index ac6b3131b..ab02c4536 100644
--- a/crates/model/src/workbook.rs
+++ b/crates/model/src/workbook.rs
@@ -439,7 +439,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn phonetics_are_additive_in_json() {
+    fn phonetics_are_additive_in_json() -> Result<(), Box<dyn std::error::Error>> {
         let mut wb = Workbook::new();
         assert!(wb.phonetics.is_empty(), "new workbooks have no phonetic data");
         wb.phonetics.push(PhoneticString {
@@ -447,12 +447,13 @@ mod tests {
             runs: vec![PhoneticRun { start: 0, end: 1, text: "ヒガシ".into() }],
             props: Some(PhoneticProps { font_id: 3, kind: Some("Hiragana".into()), alignment: None }),
         });
-        let json = serde_json::to_string(&wb).expect("serialize");
-        assert_eq!(serde_json::from_str::<Workbook>(&json).expect("deserialize").phonetics, wb.phonetics);
+        let json = serde_json::to_string(&wb)?;
+        assert_eq!(serde_json::from_str::<Workbook>(&json)?.phonetics, wb.phonetics);
         // JSON written before the field existed still loads.
-        let mut value: serde_json::Value = serde_json::from_str(&json).expect("value");
-        value.as_object_mut().expect("an object").remove("phonetics");
-        assert!(serde_json::from_value::<Workbook>(value).expect("older JSON").phonetics.is_empty());
+        let mut value: serde_json::Value = serde_json::from_str(&json)?;
+        value.as_object_mut().ok_or("none")?.remove("phonetics");
+        assert!(serde_json::from_value::<Workbook>(value)?.phonetics.is_empty());
+        Ok(())
     }
 
     #[test]
diff --git a/crates/numfmt/src/parse.rs b/crates/numfmt/src/parse.rs
index 63e2d3008..ac905d36b 100644
--- a/crates/numfmt/src/parse.rs
+++ b/crates/numfmt/src/parse.rs
@@ -438,7 +438,7 @@ fn date_part(t: &Tok) -> Option<DatePart> {
 }
 
 fn analyze(raw: Raw) -> Section {
-    let Raw { mut toks, color, cond, currency } = raw;
+    let Raw { toks, color, cond, currency } = raw;
     let is_date = toks.iter().any(|t| matches!(t, Tok::Date(_)));
     let has_general = toks.iter().any(|t| matches!(t, Tok::General));
     let mut sec = Section {
@@ -458,69 +458,85 @@ fn analyze(raw: Raw) -> Section {
     };
     if is_date {
         sec.kind = SecKind::Date;
-        // m/mm after hours or before seconds means minutes.
-        for i in 0..toks.len() {
-            let Some(Tok::Date(DatePart::Month(n))) = toks.get(i) else { continue };
-            let n = *n;
-            if n > 2 {
-                continue;
-            }
-            let prev = toks.get(..i).and_then(|s| s.iter().rev().find_map(date_part));
-            let next = toks.get(i + 1..).and_then(|s| s.iter().find_map(date_part));
-            let after_h = matches!(prev, Some(DatePart::Hour(_) | DatePart::ElapsedH(_)));
-            let before_s = matches!(next, Some(DatePart::Second(_) | DatePart::ElapsedS(_)));
-            if (after_h || before_s)
-                && let Some(t) = toks.get_mut(i)
-            {
-                *t = Tok::Date(DatePart::Minute(n));
-            }
-        }
-        let mut out = Vec::with_capacity(toks.len());
-        let mut i = 0;
-        while let Some(t) = toks.get(i) {
-            if matches!(t, Tok::Point) && toks.get(i + 1) == Some(&Tok::Digit('0')) {
-                let mut n = 0usize;
-                while toks.get(i + 1 + n) == Some(&Tok::Digit('0')) {
-                    n += 1;
-                }
-                out.push(Tok::Date(DatePart::SubSec(n.min(255) as u8)));
-                i += 1 + n;
-                continue;
-            }
-            match t {
-                Tok::Date(_) | Tok::Fill(_) => out.push(t.clone()),
-                other => push_lit(&mut out, &other.literal_text()),
-            }
-            i += 1;
-        }
-        sec.toks = out;
-        return sec;
+        return analyze_date(toks, sec);
     }
     if has_general {
         sec.kind = SecKind::General;
-        let mut out = Vec::with_capacity(toks.len());
-        for t in &toks {
-            match t {
-                Tok::General | Tok::Fill(_) => out.push(t.clone()),
-                other => push_lit(&mut out, &other.literal_text()),
-            }
-        }
-        sec.toks = out;
-        return sec;
+        return analyze_general(toks, sec);
     }
     sec.has_digits = toks.iter().any(|t| matches!(t, Tok::Digit(_)));
     if sec.has_at && !sec.has_digits {
         sec.kind = SecKind::Text;
-        let mut out = Vec::with_capacity(toks.len());
-        for t in &toks {
-            match t {
-                Tok::At | Tok::Fill(_) => out.push(t.clone()),
-                other => push_lit(&mut out, &other.literal_text()),
-            }
-        }
-        sec.toks = out;
-        return sec;
+        return analyze_text(toks, sec);
     }
+    analyze_number(toks, sec)
+}
+
+fn analyze_date(mut toks: Vec<Tok>, mut sec: Section) -> Section {
+    // m/mm after hours or before seconds means minutes.
+    for i in 0..toks.len() {
+        let Some(Tok::Date(DatePart::Month(n))) = toks.get(i) else { continue };
+        let n = *n;
+        if n > 2 {
+            continue;
+        }
+        let prev = toks.get(..i).and_then(|s| s.iter().rev().find_map(date_part));
+        let next = toks.get(i + 1..).and_then(|s| s.iter().find_map(date_part));
+        let after_h = matches!(prev, Some(DatePart::Hour(_) | DatePart::ElapsedH(_)));
+        let before_s = matches!(next, Some(DatePart::Second(_) | DatePart::ElapsedS(_)));
+        if (after_h || before_s)
+            && let Some(t) = toks.get_mut(i)
+        {
+            *t = Tok::Date(DatePart::Minute(n));
+        }
+    }
+    let mut out = Vec::with_capacity(toks.len());
+    let mut i = 0;
+    while let Some(t) = toks.get(i) {
+        if matches!(t, Tok::Point) && toks.get(i + 1) == Some(&Tok::Digit('0')) {
+            let mut n = 0usize;
+            while toks.get(i + 1 + n) == Some(&Tok::Digit('0')) {
+                n += 1;
+            }
+            out.push(Tok::Date(DatePart::SubSec(n.min(255) as u8)));
+            i += 1 + n;
+            continue;
+        }
+        match t {
+            Tok::Date(_) | Tok::Fill(_) => out.push(t.clone()),
+            other => push_lit(&mut out, &other.literal_text()),
+        }
+        i += 1;
+    }
+    sec.toks = out;
+    sec
+}
+
+fn analyze_general(toks: Vec<Tok>, mut sec: Section) -> Section {
+    let mut out = Vec::with_capacity(toks.len());
+    for t in &toks {
+        match t {
+            Tok::General | Tok::Fill(_) => out.push(t.clone()),
+            other => push_lit(&mut out, &other.literal_text()),
+        }
+    }
+    sec.toks = out;
+    sec
+}
+
+fn analyze_text(toks: Vec<Tok>, mut sec: Section) -> Section {
+    let mut out = Vec::with_capacity(toks.len());
+    for t in &toks {
+        match t {
+            Tok::At | Tok::Fill(_) => out.push(t.clone()),
+            other => push_lit(&mut out, &other.literal_text()),
+        }
+    }
+    sec.toks = out;
+    sec
+}
+
+fn analyze_number(mut toks: Vec<Tok>, mut sec: Section) -> Section {
     // Number section.
     let mut seen_point = false;
     let mut seen_exp = false;
diff --git a/crates/numfmt/src/tests.rs b/crates/numfmt/src/tests.rs
index 2c33d16b4..4b2ee089d 100644
--- a/crates/numfmt/src/tests.rs
+++ b/crates/numfmt/src/tests.rs
@@ -247,7 +247,7 @@ fn question_mark_pads_thousands_separator() {
 }
 
 #[test]
-fn literals_and_fill() {
+fn literals_and_fill() -> Result<(), Box<dyn std::error::Error>> {
     assert_eq!(f("\"$\"#,##0.00", 3.0), "$3.00");
     assert_eq!(f("$#,##0.00", -3.0), "-$3.00");
     assert_eq!(f("[$€-407]#,##0.00", 1234.5), "€1,234.50");
@@ -256,7 +256,7 @@ fn literals_and_fill() {
     assert_eq!(f("(0)", 5.0), "(5)");
     let r = full("*-0", Value::Number(5.0));
     assert_eq!((r.text.as_str(), r.fill), ("5", Some(('-', 0))));
-    let acct = builtin_format(44).unwrap();
+    let acct = builtin_format(44).ok_or("none")?;
     let r = full(acct, Value::Number(0.0));
     assert_eq!((r.text.as_str(), r.fill), (" $-   ", Some((' ', 2))));
     let r = full(acct, Value::Number(1234.5));
@@ -267,6 +267,7 @@ fn literals_and_fill() {
     assert_eq!((r.text.as_str(), r.numeric), (" abc ", false));
     let r = full("-* 0", Value::Number(-5.0));
     assert_eq!((r.text.as_str(), r.fill), ("--5", Some((' ', 2))));
+    Ok(())
 }
 
 #[test]
@@ -279,6 +280,10 @@ fn dates_and_times() {
     assert_eq!(f("d-mmm-yy", 46302.0), "7-Oct-26");
     assert_eq!(f("e", 46302.0), "2026");
     assert_eq!(f("YYYY-MM-DD", 46302.0), "2026-10-07");
+}
+
+#[test]
+fn time_formats() {
     assert_eq!(f("yyyy-mm-dd hh:mm:ss", 46302.5), "2026-10-07 12:00:00");
     assert_eq!(f("h:mm AM/PM", 0.75), "6:00 PM");
     assert_eq!(f("h AM/PM", 0.0), "12 AM");
@@ -290,6 +295,10 @@ fn dates_and_times() {
     assert_eq!(f("[s]", 1.0 / 1440.0), "60");
     assert_eq!(f("mm:ss.0", 61.2 / 86400.0), "01:01.2");
     assert_eq!(f("mm:ss.00", 61.25 / 86400.0), "01:01.25");
+}
+
+#[test]
+fn date_serial_boundaries() {
     assert_eq!(f("h:mm:ss", 0.5 + 59.6 / 86400.0), "12:01:00");
     assert_eq!(f("h:mm", 0.5 + 40.0 / 86400.0), "12:00");
     assert_eq!(f("m/d/yyyy", 60.0), "2/29/1900");
@@ -342,12 +351,12 @@ fn general() {
 }
 
 #[test]
-fn kinds() {
+fn kinds() -> Result<(), Box<dyn std::error::Error>> {
     assert_eq!(NumberFormat::general().kind(), FormatKind::General);
     assert_eq!(NumberFormat::parse("0.00").kind(), FormatKind::Number);
     assert_eq!(NumberFormat::parse("#,##0.00;[Red](#,##0.00)").kind(), FormatKind::Number);
     assert_eq!(NumberFormat::parse("\"$\"#,##0.00").kind(), FormatKind::Currency);
-    assert_eq!(NumberFormat::parse(builtin_format(44).unwrap()).kind(), FormatKind::Accounting);
+    assert_eq!(NumberFormat::parse(builtin_format(44).ok_or("none")?).kind(), FormatKind::Accounting);
     assert_eq!(NumberFormat::parse("m/d/yyyy").kind(), FormatKind::Date);
     assert_eq!(NumberFormat::parse("h:mm AM/PM").kind(), FormatKind::Time);
     assert_eq!(NumberFormat::parse("0%").kind(), FormatKind::Percentage);
@@ -356,10 +365,11 @@ fn kinds() {
     assert_eq!(NumberFormat::parse("@").kind(), FormatKind::Text);
     assert_eq!(NumberFormat::parse("00000").kind(), FormatKind::Special);
     assert_eq!(NumberFormat::parse("\"hello\"").kind(), FormatKind::Custom);
+    Ok(())
 }
 
 #[test]
-fn builtins() {
+fn builtins() -> Result<(), Box<dyn std::error::Error>> {
     assert_eq!(builtin_format(0), Some("General"));
     assert_eq!(builtin_format(14), Some("m/d/yyyy"));
     assert_eq!(builtin_format(49), Some("@"));
@@ -375,9 +385,10 @@ fn builtins() {
             assert_eq!(builtin_id(code), Some(id));
         }
     }
-    assert_eq!(f(builtin_format(5).unwrap(), -1234.0), "($1,234)");
-    assert_eq!(f(builtin_format(12).unwrap(), 0.5), " 1/2");
-    assert_eq!(f(builtin_format(47).unwrap(), 61.2 / 86400.0), "0101.2");
+    assert_eq!(f(builtin_format(5).ok_or("none")?, -1234.0), "($1,234)");
+    assert_eq!(f(builtin_format(12).ok_or("none")?, 0.5), " 1/2");
+    assert_eq!(f(builtin_format(47).ok_or("none")?, 61.2 / 86400.0), "0101.2");
+    Ok(())
 }
 
 #[test]
@@ -844,28 +855,29 @@ fn format_codes_are_capped_at_255_characters() {
     assert_eq!(f(&huge, 0.5), "0.5");
 }
 
-/// Parses and renders `code` on a worker thread; panics if that takes more than 20 s, so a quadratic
+/// Parses and renders `code` on a worker thread; errors if that takes more than 20 s, so a quadratic
 /// parser fails the test instead of hanging CI. Not a benchmark: at this size an O(n^2) pass takes
 /// minutes and an O(n) pass milliseconds, so the margin is decades wide.
-fn finishes_in_time(code: String) -> String {
+fn finishes_in_time(code: String) -> Result<String, std::sync::mpsc::RecvTimeoutError> {
     let (tx, rx) = std::sync::mpsc::channel();
     std::thread::spawn(move || {
         // Uncapped: `parse` turns a code past 255 characters into General before the parser sees it.
         let _ = tx.send(format_value(&Value::Number(1234.5), &NumberFormat::parse_uncapped(&code), S).text);
     });
-    rx.recv_timeout(std::time::Duration::from_secs(20)).expect("format code did not parse and render in time")
+    rx.recv_timeout(std::time::Duration::from_secs(20))
 }
 
 #[test]
-fn hostile_codes_parse_in_linear_time() {
+fn hostile_codes_parse_in_linear_time() -> Result<(), std::sync::mpsc::RecvTimeoutError> {
     let n = 1_000_000;
     // Unclosed brackets, a run of commas after a digit, a run of fraction bars.
-    assert!(finishes_in_time("[".repeat(n)).starts_with('['));
-    finishes_in_time(format!("0{}", ",".repeat(n)));
-    finishes_in_time(format!("0{}", "/".repeat(n)));
-    finishes_in_time(format!("0{}0", ",".repeat(n)));
+    assert!(finishes_in_time("[".repeat(n))?.starts_with('['));
+    finishes_in_time(format!("0{}", ",".repeat(n)))?;
+    finishes_in_time(format!("0{}", "/".repeat(n)))?;
+    finishes_in_time(format!("0{}0", ",".repeat(n)))?;
     // Unclosed brackets mixed with semicolons: each is a literal and a section separator stays one.
-    finishes_in_time("[;".repeat(n / 2));
+    finishes_in_time("[;".repeat(n / 2))?;
+    Ok(())
 }
 
 #[test]
diff --git a/crates/numfmt/tests/poi_number_format_approx.rs b/crates/numfmt/tests/poi_number_format_approx.rs
index 0f9932101..f98267705 100644
--- a/crates/numfmt/tests/poi_number_format_approx.rs
+++ b/crates/numfmt/tests/poi_number_format_approx.rs
@@ -7,7 +7,6 @@ use gridcraft_numfmt::text_function;
 
 /// (format, value, Excel's result).
 // The last row's 3.14159 is the workbook's value, not an approximation of pi.
-#[allow(clippy::approx_constant)]
 const CASES: &[(&str, f64, &str)] = &[
     (r"|#,e-#|", 123456.789, r"|1e5|"),
     (r"|#e-#,|", 123456.789, r"|1e5|"),
@@ -256,7 +255,7 @@ const CASES: &[(&str, f64, &str)] = &[
     (r"|#.#|e+|???|", 1.2345678e-142, r"|1.2|e|-142|"),
     (r"|#.#|e+|????|", 1.2345678e-142, r"|1.2|e|- 142|"),
     (r"|#.#|e+|?????|", 1.2345678e-142, r"|1.2|e|-  142|"),
-    (r"#,##0.00e+00", 3.14159, r"3.14e+00"),
+    (r"#,##0.00e+00", 314_159.0 / 100_000.0, r"3.14e+00"),
 ];
 
 #[test]
diff --git a/crates/pdf/Cargo.toml b/crates/pdf/Cargo.toml
index 6cb0d2e3a..cd63456c2 100644
--- a/crates/pdf/Cargo.toml
+++ b/crates/pdf/Cargo.toml
@@ -4,6 +4,7 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 description = "GridCraft's tiny self-contained PDF 1.7 writer (standard 14 fonts, vector drawing, RGBA images)"
+readme = "README.md"
 
 [lints]
 workspace = true
diff --git a/crates/pdf/README.md b/crates/pdf/README.md
new file mode 100644
index 000000000..cdb6308eb
--- /dev/null
+++ b/crates/pdf/README.md
@@ -0,0 +1,33 @@
+# gridcraft-pdf
+
+A small, dependency-free PDF 1.7 writer for vector drawing and RGBA images.
+
+## API migration
+
+The geometry-taking methods now use `Point` and `Rect` values to name their coordinates, and
+`image_rgba` groups its pixel dimensions into an array. Update calls to the four changed methods as
+follows:
+
+```rust
+use gridcraft_pdf::{Font, PdfDoc, Point, Rect};
+
+let mut doc = PdfDoc::new();
+let page = doc.add_page(612.0, 792.0);
+
+// Before: page.link_page(20.0, 30.0, 80.0, 16.0, 1, 40.0, 50.0);
+page.link_page(Rect::new(20.0, 30.0, 80.0, 16.0), 1, Point::new(40.0, 50.0));
+
+// Before: page.stroke_line_dashed(0.0, 0.0, 100.0, 40.0, 1.0, [0, 0, 0], &[4.0, 2.0]);
+page.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(100.0, 40.0), 1.0, [0, 0, 0], &[4.0, 2.0]);
+
+// Before: page.text_rotated(20.0, 40.0, 12.0, Font::Helvetica, [0, 0, 0], "Label", 0.2);
+page.text_rotated(Point::new(20.0, 40.0), 12.0, Font::Helvetica, [0, 0, 0], "Label", 0.2);
+
+let rgba = [255, 0, 0, 255];
+// Before: page.image_rgba(10.0, 10.0, 24.0, 24.0, &rgba, 1, 1);
+page.image_rgba(Rect::new(10.0, 10.0, 24.0, 24.0), &rgba, [1, 1]);
+```
+
+`Point::new(x, y)` uses the page's top-left origin, where y increases downward. `Rect::new(x, y,
+width, height)` describes the destination or link rectangle in the same coordinate system. The
+`image_rgba` pixel-size array is `[width, height]`.
diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs
index e00b4fcc3..5270d4311 100644
--- a/crates/pdf/src/lib.rs
+++ b/crates/pdf/src/lib.rs
@@ -20,6 +20,34 @@ use std::fmt::Write as _;
 /// RGB colour, 0–255 per channel.
 pub type Rgb = [u8; 3];
 
+/// A point in page coordinates, measured from the top-left corner.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Point {
+    pub x: f32,
+    pub y: f32,
+}
+
+impl Point {
+    pub const fn new(x: f32, y: f32) -> Self {
+        Self { x, y }
+    }
+}
+
+/// A page-space rectangle described by its top-left corner and extent.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Rect {
+    pub x: f32,
+    pub y: f32,
+    pub width: f32,
+    pub height: f32,
+}
+
+impl Rect {
+    pub const fn new(x: f32, y: f32, width: f32, height: f32) -> Self {
+        Self { x, y, width, height }
+    }
+}
+
 /// The standard 14 fonts minus Symbol and ZapfDingbats.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum Font {
@@ -353,11 +381,12 @@ impl Page {
         }
     }
 
-    fn link_rect(&self, x: f32, y: f32, w: f32, h: f32) -> Option<[f32; 4]> {
-        if !finite(&[x, y, w, h]) || !extent(w) || !extent(h) || self.links.len() >= MAX_PAGE_LINKS {
+    fn link_rect(&self, rect: Rect) -> Option<[f32; 4]> {
+        let Rect { x, y, width, height } = rect;
+        if !finite(&[x, y, width, height]) || !extent(width) || !extent(height) || self.links.len() >= MAX_PAGE_LINKS {
             return None;
         }
-        let (right, bottom) = (x + w, y + h);
+        let (right, bottom) = (x + width, y + height);
         if !finite(&[right, bottom]) {
             return None;
         }
@@ -374,18 +403,18 @@ impl Page {
         if !allowed || uri.len() > MAX_LINK_URI_BYTES || uri.chars().any(char::is_control) {
             return;
         }
-        if let Some(rect) = self.link_rect(x, y, w, h) {
+        if let Some(rect) = self.link_rect(Rect::new(x, y, w, h)) {
             self.links.push(LinkAnnotation { rect, target: LinkTarget::Uri(uri.to_string()) });
         }
     }
 
     /// Adds a link to a location on another page of this document (zero-based page index).
-    pub fn link_page(&mut self, x: f32, y: f32, w: f32, h: f32, page: usize, target_x: f32, target_y: f32) {
-        if !finite(&[target_x, target_y]) {
+    pub fn link_page(&mut self, rect: Rect, page: usize, target: Point) {
+        if !finite(&[target.x, target.y]) {
             return;
         }
-        if let Some(rect) = self.link_rect(x, y, w, h) {
-            self.links.push(LinkAnnotation { rect, target: LinkTarget::Page { index: page, x: target_x, y: target_y } });
+        if let Some(rect) = self.link_rect(rect) {
+            self.links.push(LinkAnnotation { rect, target: LinkTarget::Page { index: page, x: target.x, y: target.y } });
         }
     }
 
@@ -424,12 +453,12 @@ impl Page {
     }
 
     pub fn stroke_line(&mut self, x0: f32, y0: f32, x1: f32, y1: f32, width: f32, color: Rgb) {
-        self.stroke_line_dashed(x0, y0, x1, y1, width, color, &[]);
+        self.stroke_line_dashed(Point::new(x0, y0), Point::new(x1, y1), width, color, &[]);
     }
 
     /// A line with a dash pattern (`[on, off, …]` in points; empty = solid).
-    pub fn stroke_line_dashed(&mut self, x0: f32, y0: f32, x1: f32, y1: f32, width: f32, color: Rgb, dash: &[f32]) {
-        if !finite(&[x0, y0, x1, y1]) {
+    pub fn stroke_line_dashed(&mut self, start: Point, end: Point, width: f32, color: Rgb, dash: &[f32]) {
+        if !finite(&[start.x, start.y, end.x, end.y]) {
             return;
         }
         let s = format!(
@@ -437,10 +466,10 @@ impl Page {
             rgb_op(color, true),
             n(stroke_width(width)),
             dash_values(dash),
-            n(x0),
-            n(self.y(y0)),
-            n(x1),
-            n(self.y(y1))
+            n(start.x),
+            n(self.y(start.y)),
+            n(end.x),
+            n(self.y(end.y))
         );
         self.op(&s);
     }
@@ -543,20 +572,20 @@ impl Page {
 
     /// Text with its baseline starting at `(x, y)`.
     pub fn text(&mut self, x: f32, y: f32, size: f32, font: Font, color: Rgb, text: &str) {
-        self.text_rotated(x, y, size, font, color, text, 0.0);
+        self.text_rotated(Point::new(x, y), size, font, color, text, 0.0);
     }
 
     /// Text rotated by `angle` radians (clockwise on the page, like the y-down coordinate
     /// system) about its baseline origin.
-    pub fn text_rotated(&mut self, x: f32, y: f32, size: f32, font: Font, color: Rgb, text: &str, angle: f32) {
-        if text.is_empty() || !extent(size) || !finite(&[x, y]) {
+    pub fn text_rotated(&mut self, origin: Point, size: f32, font: Font, color: Rgb, text: &str, angle: f32) {
+        if text.is_empty() || !extent(size) || !finite(&[origin.x, origin.y]) {
             return;
         }
         let fi = font.index();
         let size = n(size.min(10_000.0));
         let (sn, cs) = if angle.is_finite() { angle.sin_cos() } else { (0.0, 1.0) };
         // Clockwise in y-down = counter-clockwise negated in PDF's y-up space.
-        let mut s = format!("BT\n{}\n{} {} {} {} {} {} Tm\n", rgb_op(color, false), n(cs), n(-sn), n(sn), n(cs), n(x), n(self.y(y)));
+        let mut s = format!("BT\n{}\n{} {} {} {} {} {} Tm\n", rgb_op(color, false), n(cs), n(-sn), n(sn), n(cs), n(origin.x), n(self.y(origin.y)));
         // Runs of WinAnsi text use `font`; runs it cannot encode use the CID font. Each `Tj`
         // advances the text position, so the runs follow each other on the baseline.
         let mut rest = text;
@@ -577,7 +606,9 @@ impl Page {
 
     /// Draws an RGBA image (`pw`×`ph` pixels, row-major, straight alpha) into the box
     /// `(x, y, w, h)`. Malformed or oversized buffers are ignored.
-    pub fn image_rgba(&mut self, x: f32, y: f32, w: f32, h: f32, rgba: &[u8], pw: u32, ph: u32) {
+    pub fn image_rgba(&mut self, destination: Rect, rgba: &[u8], pixel_size: [u32; 2]) {
+        let Rect { x, y, width: w, height: h } = destination;
+        let [pw, ph] = pixel_size;
         let px = pw as u64 * ph as u64;
         if pw == 0 || ph == 0 || px > MAX_IMAGE_PIXELS || (rgba.len() as u64) < px * 4 || !(extent(w) && extent(h) && finite(&[x, y])) {
             return;
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index e540685d0..bd1ad73a8 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -1,4 +1,6 @@
 use super::*;
+use std::error::Error;
+use std::io;
 
 fn find(hay: &[u8], needle: &[u8]) -> Option<usize> {
     hay.windows(needle.len()).position(|w| w == needle)
@@ -8,22 +10,23 @@ fn rfind(hay: &[u8], needle: &[u8]) -> Option<usize> {
 }
 
 /// Parses the xref table back and checks each in-use entry points at `N 0 obj`.
-fn check_xref(pdf: &[u8]) -> usize {
-    let sx = rfind(pdf, b"startxref\n").unwrap();
-    let rest = std::str::from_utf8(&pdf[sx + 10..]).unwrap();
-    let off: usize = rest.lines().next().unwrap().trim().parse().unwrap();
+fn check_xref(pdf: &[u8]) -> Result<usize, Box<dyn Error>> {
+    let sx = rfind(pdf, b"startxref\n").ok_or_else(|| io::Error::other("missing startxref"))?;
+    let rest = std::str::from_utf8(&pdf[sx + 10..])?;
+    let off: usize = rest.lines().next().ok_or_else(|| io::Error::other("missing xref offset"))?.trim().parse()?;
     assert!(pdf[off..].starts_with(b"xref\n"), "startxref points at xref");
-    let table = std::str::from_utf8(&pdf[off..sx]).unwrap();
+    let table = std::str::from_utf8(&pdf[off..sx])?;
     let mut lines = table.lines();
     assert_eq!(lines.next(), Some("xref"));
-    let hdr: Vec<usize> = lines.next().unwrap().split(' ').map(|x| x.parse().unwrap()).collect();
-    assert_eq!(hdr[0], 0);
-    let count = hdr[1];
+    let hdr: Vec<usize> =
+        lines.next().ok_or_else(|| io::Error::other("missing xref header"))?.split(' ').map(str::parse).collect::<Result<_, _>>()?;
+    assert_eq!(hdr.first(), Some(&0));
+    let count = *hdr.get(1).ok_or_else(|| io::Error::other("missing xref count"))?;
     let mut checked = 0;
     for i in 0..count {
-        let e = lines.next().unwrap();
+        let e = lines.next().ok_or_else(|| io::Error::other("missing xref entry"))?;
         assert_eq!(e.len(), 19, "entry `{e}` (20 bytes with newline)");
-        let o: usize = e[..10].parse().unwrap();
+        let o: usize = e.get(..10).ok_or_else(|| io::Error::other("short xref offset"))?.parse()?;
         if e.trim_end().ends_with('n') {
             let want = format!("{i} 0 obj");
             assert!(pdf[o..].starts_with(want.as_bytes()), "object {i} at {o}");
@@ -32,38 +35,39 @@ fn check_xref(pdf: &[u8]) -> usize {
     }
     assert!(table.contains("trailer"));
     assert!(table.contains(&format!("/Size {count}")));
-    checked
+    Ok(checked)
 }
 
 #[test]
-fn minimal_document() {
+fn minimal_document() -> Result<(), Box<dyn Error>> {
     let pdf = PdfDoc::new().finish();
     assert!(pdf.starts_with(b"%PDF-1.7"));
     assert!(pdf.ends_with(b"%%EOF\n"));
-    assert!(check_xref(&pdf) >= 5);
+    assert!(check_xref(&pdf)? >= 5);
+    Ok(())
 }
 
 #[test]
-fn drawing_and_text() {
+fn drawing_and_text() -> Result<(), Box<dyn Error>> {
     let mut d = PdfDoc::new();
     d.info.title = "Report (Q1)".into();
     let p = d.add_page(612.0, 792.0);
     p.fill_rect(10.0, 10.0, 100.0, 20.0, [255, 255, 0]);
     p.rect_stroke(10.0, 10.0, 100.0, 20.0, 0.5, [0, 0, 0]);
     p.stroke_line(0.0, 0.0, 612.0, 792.0, 1.0, [255, 0, 0]);
-    p.stroke_line_dashed(0.0, 5.0, 100.0, 5.0, 1.0, [0, 0, 0], &[3.0, 2.0]);
+    p.stroke_line_dashed(Point::new(0.0, 5.0), Point::new(100.0, 5.0), 1.0, [0, 0, 0], &[3.0, 2.0]);
     p.polygon(&[[0.0, 0.0], [10.0, 0.0], [5.0, 8.0]], Some([0, 0, 255]), Some(([0, 0, 0], 1.0)));
     p.circle(300.0, 300.0, 20.0, Some([0, 128, 0]), None);
     p.save();
     p.clip_rect(0.0, 0.0, 50.0, 50.0);
     p.text(72.0, 72.0, 12.0, Font::Helvetica, [0, 0, 0], "Hello (world) \\ café €5");
     p.restore();
-    p.text_rotated(100.0, 100.0, 9.0, Font::TimesBold, [0, 0, 0], "Up", -std::f32::consts::FRAC_PI_2);
+    p.text_rotated(Point::new(100.0, 100.0), 9.0, Font::TimesBold, [0, 0, 0], "Up", -std::f32::consts::FRAC_PI_2);
     let p2 = d.add_page(842.0, 595.0);
     p2.text(10.0, 20.0, 10.0, Font::CourierBold, [0, 0, 0], "Second");
     assert_eq!(d.page_count(), 2);
     let pdf = d.finish();
-    check_xref(&pdf);
+    check_xref(&pdf)?;
     assert!(find(&pdf, b"(Hello \\(world\\) \\\\ caf\\351 \\2005) Tj").is_some());
     assert!(find(&pdf, b"(Second) Tj").is_some());
     assert!(find(&pdf, b"/BaseFont /Helvetica /Encoding /WinAnsiEncoding").is_some());
@@ -74,21 +78,22 @@ fn drawing_and_text() {
     assert!(find(&pdf, b"/Title (Report \\(Q1\\))").is_some());
     // Top-left origin: a line from (0,0) starts at the top of the page.
     assert!(find(&pdf, b"0 792 m 612 0 l S").is_some());
+    Ok(())
 }
 
 #[test]
-fn uri_and_page_links_are_real_pdf_annotations() {
+fn uri_and_page_links_are_real_pdf_annotations() -> Result<(), Box<dyn Error>> {
     let mut d = PdfDoc::new();
     let first = d.add_page(200.0, 300.0);
     first.link_uri(10.0, 20.0, 80.0, 30.0, "https://example.org/a(b)?q=£");
-    first.link_page(100.0, 40.0, 50.0, 20.0, 1, 35.0, 60.0);
+    first.link_page(Rect::new(100.0, 40.0, 50.0, 20.0), 1, Point::new(35.0, 60.0));
     first.link_uri(-20.0, -20.0, 40.0, 40.0, "mailto:a@example.org");
     first.link_uri(0.0, 0.0, f32::NAN, 10.0, "https://bad.example");
     first.link_uri(0.0, 0.0, 10.0, 10.0, "javascript:alert(1)");
     let second = d.add_page(100.0, 200.0);
-    second.link_page(0.0, 0.0, 10.0, 10.0, 99, 0.0, 0.0);
+    second.link_page(Rect::new(0.0, 0.0, 10.0, 10.0), 99, Point::new(0.0, 0.0));
     let pdf = d.finish();
-    check_xref(&pdf);
+    check_xref(&pdf)?;
     let s = String::from_utf8_lossy(&pdf);
     assert_eq!(s.matches("/Subtype /Link").count(), 3);
     assert!(s.contains("/Annots ["));
@@ -97,25 +102,27 @@ fn uri_and_page_links_are_real_pdf_annotations() {
     assert!(s.contains("/URI (https://example.org/a\\(b\\)?q=%C2%A3)"));
     assert!(s.contains("/XYZ 35 140 null"));
     assert!(!s.contains("https://bad.example"));
+    Ok(())
 }
 
 #[test]
-fn images_with_alpha() {
+fn images_with_alpha() -> Result<(), Box<dyn Error>> {
     let mut d = PdfDoc::new();
     let p = d.add_page(200.0, 200.0);
     let mut px = Vec::new();
     for i in 0..16u8 {
         px.extend_from_slice(&[i * 10, 0, 0, if i < 8 { 255 } else { 128 }]);
     }
-    p.image_rgba(10.0, 10.0, 40.0, 40.0, &px, 4, 4);
-    p.image_rgba(10.0, 10.0, 40.0, 40.0, &[255; 16], 2, 2); // opaque: no mask
-    p.image_rgba(0.0, 0.0, 1.0, 1.0, &[1, 2, 3], 4, 4); // too short: ignored
+    p.image_rgba(Rect::new(10.0, 10.0, 40.0, 40.0), &px, [4, 4]);
+    p.image_rgba(Rect::new(10.0, 10.0, 40.0, 40.0), &[255; 16], [2, 2]); // opaque: no mask
+    p.image_rgba(Rect::new(0.0, 0.0, 1.0, 1.0), &[1, 2, 3], [4, 4]); // too short: ignored
     let pdf = d.finish();
-    check_xref(&pdf);
+    check_xref(&pdf)?;
     assert!(find(&pdf, b"/SMask").is_some());
     assert!(find(&pdf, b"/Im1 Do").is_some());
     assert!(find(&pdf, b"/Im2 Do").is_some());
     assert!(find(&pdf, b"/Im3").is_none());
+    Ok(())
 }
 
 #[test]
@@ -166,7 +173,7 @@ fn widths() {
 }
 
 #[test]
-fn hostile_inputs_never_panic() {
+fn hostile_inputs_never_panic() -> Result<(), Box<dyn Error>> {
     let mut d = PdfDoc::new();
     let p = d.add_page(f32::NAN, -5.0);
     p.text(f32::INFINITY, f32::NAN, 1e30, Font::Helvetica, [0, 0, 0], "x");
@@ -176,9 +183,10 @@ fn hostile_inputs_never_panic() {
     p.restore();
     p.restore();
     p.save();
-    p.image_rgba(0.0, 0.0, 10.0, 10.0, &[], u32::MAX, u32::MAX);
+    p.image_rgba(Rect::new(0.0, 0.0, 10.0, 10.0), &[], [u32::MAX, u32::MAX]);
     let pdf = d.finish();
-    check_xref(&pdf);
+    check_xref(&pdf)?;
+    Ok(())
 }
 
 fn page_content(d: &PdfDoc) -> &str {
@@ -198,9 +206,9 @@ fn text_width_does_not_overflow() {
 fn all_zero_dash_is_drawn_solid() {
     let mut d = PdfDoc::new();
     let p = d.add_page(100.0, 100.0);
-    p.stroke_line_dashed(0.0, 0.0, 50.0, 0.0, 1.0, [0, 0, 0], &[0.0, 0.0]);
+    p.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(50.0, 0.0), 1.0, [0, 0, 0], &[0.0, 0.0]);
     p.polyline(&[[0.0, 0.0], [5.0, 5.0]], 1.0, [0, 0, 0], &[0.0, 0.0001, f32::NAN]);
-    p.stroke_line_dashed(0.0, 0.0, 50.0, 0.0, 1.0, [0, 0, 0], &[3.0, 2.0]);
+    p.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(50.0, 0.0), 1.0, [0, 0, 0], &[3.0, 2.0]);
     let c = page_content(&d);
     assert_eq!(c.matches("[] 0 d").count(), 2);
     assert!(!c.contains("[0 0]"));
@@ -226,15 +234,15 @@ fn non_finite_image_size_stores_nothing() {
     let p = d.add_page(200.0, 200.0);
     let px = [255u8; 16];
     for (w, h) in [(f32::NAN, 10.0), (10.0, f32::NAN), (f32::INFINITY, 10.0), (-1.0, 10.0)] {
-        p.image_rgba(0.0, 0.0, w, h, &px, 2, 2);
+        p.image_rgba(Rect::new(0.0, 0.0, w, h), &px, [2, 2]);
     }
-    p.image_rgba(f32::NAN, 0.0, 10.0, 10.0, &px, 2, 2);
+    p.image_rgba(Rect::new(f32::NAN, 0.0, 10.0, 10.0), &px, [2, 2]);
     assert!(p.images.is_empty());
     assert!(p.content.is_empty());
 }
 
 #[test]
-fn every_draw_method_survives_hostile_numbers() {
+fn every_draw_method_survives_hostile_numbers() -> Result<(), Box<dyn Error>> {
     let bad = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -7.0, 0.0, 1.0e30, -1.0e30];
     let px = [200u8; 16];
     let mut d = PdfDoc::new();
@@ -245,41 +253,45 @@ fn every_draw_method_survives_hostile_numbers() {
             p.fill_rect(a, b, b, a, [1, 2, 3]);
             p.rect_stroke(a, b, a, b, a, [1, 2, 3]);
             p.stroke_line(a, b, b, a, a, [1, 2, 3]);
-            p.stroke_line_dashed(a, b, b, a, b, [1, 2, 3], &[a, b, 0.0]);
+            p.stroke_line_dashed(Point::new(a, b), Point::new(b, a), b, [1, 2, 3], &[a, b, 0.0]);
             p.polyline(&[[a, b], [b, a], [1.0, 1.0]], a, [1, 2, 3], &[b, a]);
             p.polygon(&[[a, b], [b, a], [1.0, 1.0]], Some([1, 2, 3]), Some(([4, 5, 6], a)));
             p.circle(a, b, b, Some([1, 2, 3]), Some(([4, 5, 6], a)));
             p.text(a, b, a, Font::Helvetica, [0, 0, 0], "x");
-            p.text_rotated(a, b, 10.0, Font::TimesRoman, [0, 0, 0], "y", b);
-            p.image_rgba(a, b, b, a, &px, 2, 2);
+            p.text_rotated(Point::new(a, b), 10.0, Font::TimesRoman, [0, 0, 0], "y", b);
+            p.image_rgba(Rect::new(a, b, b, a), &px, [2, 2]);
         }
     }
-    p.stroke_line_dashed(0.0, 0.0, 1.0, 1.0, 1.0, [0, 0, 0], &[0.0; 100]);
+    p.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(1.0, 1.0), 1.0, [0, 0, 0], &[0.0; 100]);
     let c = page_content(&d);
     assert!(!c.contains("NaN") && !c.contains("inf"));
     let pdf = d.finish();
-    check_xref(&pdf);
+    check_xref(&pdf)?;
+    Ok(())
 }
 
 /// Decodes the `<FEFF…>` hex string following `key` in the file bytes.
-fn utf16_entry(pdf: &[u8], key: &str) -> String {
-    let at = find(pdf, key.as_bytes()).unwrap() + key.len();
-    let rest = std::str::from_utf8(&pdf[at..at + 9000.min(pdf.len() - at)]).unwrap_or("");
-    let hex = rest.trim_start().strip_prefix("<FEFF").unwrap();
-    let hex = &hex[..hex.find('>').unwrap()];
-    let units: Vec<u16> = (0..hex.len()).step_by(4).map(|i| u16::from_str_radix(&hex[i..i + 4], 16).unwrap()).collect();
-    String::from_utf16(&units).unwrap()
+fn utf16_entry(pdf: &[u8], key: &str) -> Result<String, Box<dyn Error>> {
+    let at = find(pdf, key.as_bytes()).ok_or_else(|| io::Error::other("missing PDF info key"))? + key.len();
+    let end = at + 9000.min(pdf.len() - at);
+    let rest = std::str::from_utf8(pdf.get(at..end).ok_or_else(|| io::Error::other("short PDF info value"))?)?;
+    let hex = rest.trim_start().strip_prefix("<FEFF").ok_or_else(|| io::Error::other("missing UTF-16 marker"))?;
+    let end = hex.find('>').ok_or_else(|| io::Error::other("missing UTF-16 terminator"))?;
+    let hex = hex.get(..end).ok_or_else(|| io::Error::other("invalid UTF-16 range"))?;
+    let units: Vec<u16> = (0..hex.len()).step_by(4).map(|i| u16::from_str_radix(hex.get(i..i + 4).unwrap_or(""), 16)).collect::<Result<_, _>>()?;
+    Ok(String::from_utf16(&units)?)
 }
 
 #[test]
-fn info_strings_with_non_ascii_are_utf16be() {
+fn info_strings_with_non_ascii_are_utf16be() -> Result<(), Box<dyn Error>> {
     let mut doc = PdfDoc::new();
     doc.add_page(200.0, 200.0);
     doc.info.title = "Übersicht €5 – “Q1” 日本 😀".into();
     doc.info.author = "Müller & Søn".into();
     let pdf = doc.finish();
-    assert_eq!(utf16_entry(&pdf, "/Title"), "Übersicht €5 – “Q1” 日本 😀");
-    assert_eq!(utf16_entry(&pdf, "/Author"), "Müller & Søn");
+    assert_eq!(utf16_entry(&pdf, "/Title")?, "Übersicht €5 – “Q1” 日本 😀");
+    assert_eq!(utf16_entry(&pdf, "/Author")?, "Müller & Søn");
+    Ok(())
 }
 
 #[test]
@@ -293,22 +305,23 @@ fn ascii_info_strings_stay_literal_and_escaped() {
 }
 
 #[test]
-fn info_strings_are_capped() {
+fn info_strings_are_capped() -> Result<(), Box<dyn Error>> {
     let mut doc = PdfDoc::new();
     doc.add_page(200.0, 200.0);
     doc.info.title = "日".repeat(100_000);
     let pdf = doc.finish();
-    assert_eq!(utf16_entry(&pdf, "/Title").chars().count(), MAX_INFO_CHARS);
+    assert_eq!(utf16_entry(&pdf, "/Title")?.chars().count(), MAX_INFO_CHARS);
+    Ok(())
 }
 
 #[test]
-fn cjk_text_is_not_replaced_by_question_marks() {
+fn cjk_text_is_not_replaced_by_question_marks() -> Result<(), Box<dyn Error>> {
     let mut doc = PdfDoc::new();
     let p = doc.add_page(612.0, 792.0);
     p.text(10.0, 20.0, 10.0, Font::Helvetica, [0, 0, 0], "签字清单");
     p.text(10.0, 40.0, 10.0, Font::Helvetica, [0, 0, 0], "No. 编号 2");
     let pdf = doc.finish();
-    check_xref(&pdf);
+    check_xref(&pdf)?;
     assert!(find(&pdf, b"(????) Tj").is_none(), "CJK text written as question marks");
     assert!(find(&pdf, b"<7B7E5B576E055355> Tj").is_some());
     assert!(find(&pdf, b"(No. ) Tj").is_some());
@@ -317,4 +330,5 @@ fn cjk_text_is_not_replaced_by_question_marks() {
     assert!(find(&pdf, b"/Encoding /UniGB-UTF16-H").is_some());
     // Measured as full-width glyphs, matching the CID font's default width.
     assert_eq!(text_width(Font::Helvetica, 10.0, "签字"), 20.0);
+    Ok(())
 }
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index 762663c5c..b9cddcb90 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -23,6 +23,7 @@ serde_json = { workspace = true }
 log = { workspace = true }
 image = { workspace = true }
 skrifa = { workspace = true }
+web-time = { workspace = true }
 
 # Linux only, where winit reports no system theme: the desktop portal's light/dark answer (see
 # `desktop_theme.rs`). Already in the tree, with these features, through egui's own
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index f2671692a..d53218d51 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -1,7 +1,15 @@
+#[cfg(test)]
+use super::clock::monotonic_ms;
 use super::clock::now_ms;
 use super::services::{Chrome, Services};
 use super::state::{NoticeKind, OpenWindow, SaveAnswer, SheetView};
-use super::*;
+#[cfg(not(target_arch = "wasm32"))]
+use super::updates_ui;
+use super::{
+    CellRef, HashMap, INTERFACE_SCALE_MAX, INTERFACE_SCALE_MIN, Json, Notice, Perf, RangeRef, Session, SheetApp, UiRequest, UiState, backstage,
+    clamp_interface_scale, clean_error, control, desktop_theme, dialogs, editor, floating_pictures, formula_bar, formula_locale, grid, i18n, json,
+    keytips, panes, pivot_pane, printing, ribbon, tabs, text_box, theme, widgets,
+};
 
 mod clipboard;
 mod commands;
diff --git a/crates/ui-egui/src/app/clipboard.rs b/crates/ui-egui/src/app/clipboard.rs
index 4d6e466d4..da75d8b73 100644
--- a/crates/ui-egui/src/app/clipboard.rs
+++ b/crates/ui-egui/src/app/clipboard.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, SheetApp, json};
 
 impl SheetApp {
     /// Copy or cut the selected cells to the system clipboard. Engine-only commands keep
diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs
index a3dd9ac37..969b6faac 100644
--- a/crates/ui-egui/src/app/commands.rs
+++ b/crates/ui-egui/src/app/commands.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    INTERFACE_SCALE_MAX, INTERFACE_SCALE_MIN, Json, NoticeKind, SheetApp, UiRequest, backstage, clamp_interface_scale, clean_error, dialogs,
+    formula_locale, i18n, json, now_ms, printing,
+};
 
 impl SheetApp {
     /// Runs an engine command (or a UI command) and handles UI requests it makes.
diff --git a/crates/ui-egui/src/app/editing.rs b/crates/ui-egui/src/app/editing.rs
index c9c494fb1..6890fb944 100644
--- a/crates/ui-egui/src/app/editing.rs
+++ b/crates/ui-egui/src/app/editing.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{SheetApp, clean_error, editor, formula_bar, formula_locale, json, now_ms};
 
 impl SheetApp {
     /// Starts editing the active cell. `text` replaces the content (typing) or pre-fills it.
diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs
index 4c7e20913..0cbde92a8 100644
--- a/crates/ui-egui/src/app/files.rs
+++ b/crates/ui-egui/src/app/files.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, Notice, NoticeKind, OpenWindow, SheetApp, clean_error, json};
 
 impl SheetApp {
     pub fn open_path(&mut self, path: &str) {
diff --git a/crates/ui-egui/src/app/fonts.rs b/crates/ui-egui/src/app/fonts.rs
index 32e072d93..1f99a9902 100644
--- a/crates/ui-egui/src/app/fonts.rs
+++ b/crates/ui-egui/src/app/fonts.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{SheetApp, theme};
 use crate::fonts;
 
 impl SheetApp {
diff --git a/crates/ui-egui/src/app/input.rs b/crates/ui-egui/src/app/input.rs
index fb8f31bfa..b9fa30a18 100644
--- a/crates/ui-egui/src/app/input.rs
+++ b/crates/ui-egui/src/app/input.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{SheetApp, control};
 
 impl SheetApp {
     /// Records capture geometry from the fresh raw frame, then offers exactly one pending synthetic batch and tracks whether it was applied.
diff --git a/crates/ui-egui/src/app/keys.rs b/crates/ui-egui/src/app/keys.rs
index 913cdbeb6..3490bd01c 100644
--- a/crates/ui-egui/src/app/keys.rs
+++ b/crates/ui-egui/src/app/keys.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, SheetApp, backstage, json, keytips};
 
 impl SheetApp {
     pub(super) fn ribbon_keys(&mut self, ctx: &egui::Context) {
diff --git a/crates/ui-egui/src/app/prefs.rs b/crates/ui-egui/src/app/prefs.rs
index bd80b36e3..216e4a568 100644
--- a/crates/ui-egui/src/app/prefs.rs
+++ b/crates/ui-egui/src/app/prefs.rs
@@ -1,4 +1,6 @@
-use super::*;
+#[cfg(not(target_arch = "wasm32"))]
+use super::updates_ui;
+use super::{SheetApp, desktop_theme};
 
 impl SheetApp {
     /// Runs a command and shows its error in a message box (for menu/ribbon clicks).
diff --git a/crates/ui-egui/src/app/print.rs b/crates/ui-egui/src/app/print.rs
index 7c683f4ba..0cf678505 100644
--- a/crates/ui-egui/src/app/print.rs
+++ b/crates/ui-egui/src/app/print.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, SheetApp, json, now_ms, printing};
 
 impl SheetApp {
     /// Web: `file.exportPdf` without a path returns the PDF as base64; hand it to the browser as a download.
diff --git a/crates/ui-egui/src/app/quit.rs b/crates/ui-egui/src/app/quit.rs
index e70928eee..ea507e60f 100644
--- a/crates/ui-egui/src/app/quit.rs
+++ b/crates/ui-egui/src/app/quit.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{SaveAnswer, SheetApp, json};
 
 impl SheetApp {
     /// Holds back a window close (the close button, Alt+F4, the OS quitting the app) while a
diff --git a/crates/ui-egui/src/app/view.rs b/crates/ui-egui/src/app/view.rs
index c74cf15f0..aea36abc2 100644
--- a/crates/ui-egui/src/app/view.rs
+++ b/crates/ui-egui/src/app/view.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{CellRef, SheetApp, SheetView};
 
 impl SheetApp {
     /// The active workbook and sheet: what drafts, text boxes and picture targets belong to.
diff --git a/crates/ui-egui/src/backstage/options.rs b/crates/ui-egui/src/backstage/options.rs
index f40bc9cc5..6b9f70eb7 100644
--- a/crates/ui-egui/src/backstage/options.rs
+++ b/crates/ui-egui/src/backstage/options.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Key, Language, Modifiers, SheetApp, Ui, dim, i18n, json, section, vec2};
 
 /// 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
diff --git a/crates/ui-egui/src/backstage/print.rs b/crates/ui-egui/src/backstage/print.rs
index 493951593..bcfe0417d 100644
--- a/crates/ui-egui/src/backstage/print.rs
+++ b/crates/ui-egui/src/backstage/print.rs
@@ -1,4 +1,6 @@
-use super::*;
+use super::{
+    Align2, Backstage, Icon, Json, Outcome, Rect, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, dim, json, pos2, square_button, theme, vec2,
+};
 
 /// 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) {
diff --git a/crates/ui-egui/src/control/screenshots.rs b/crates/ui-egui/src/control/screenshots.rs
index 5cf9e999b..998a924b9 100644
--- a/crates/ui-egui/src/control/screenshots.rs
+++ b/crates/ui-egui/src/control/screenshots.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{CaptureSlot, ControlResponse, Json, Sender, SheetApp, json, timeout_reply, with_token};
 
 /// Most screenshots one client may have in flight or waiting for its reply at once.
 pub const SCREENSHOT_MAX_REQUESTS: usize = 4;
diff --git a/crates/ui-egui/src/control/synthetic.rs b/crates/ui-egui/src/control/synthetic.rs
index a169cba64..e5a1a7acd 100644
--- a/crates/ui-egui/src/control/synthetic.rs
+++ b/crates/ui-egui/src/control/synthetic.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{CellRef, Json, SheetApp};
 
 pub(super) fn key_from(name: &str) -> Option<egui::Key> {
     egui::Key::from_name(name).or(match name.to_ascii_lowercase().as_str() {
diff --git a/crates/ui-egui/src/dialogs/about.rs b/crates/ui-egui/src/dialogs/about.rs
index a337627d9..a95878e92 100644
--- a/crates/ui-egui/src/dialogs/about.rs
+++ b/crates/ui-egui/src/dialogs/about.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::Dialog;
 
 /// Help ▸ About GridCraft: the app, its contributors and the AI models that helped. The credits
 /// are compiled in (`crate::credits`, docs/contributors.md).
diff --git a/crates/ui-egui/src/dialogs/analysis.rs b/crates/ui-egui/src/dialogs/analysis.rs
index a24ddd67b..cc0dc2f9a 100644
--- a/crates/ui-egui/src/dialogs/analysis.rs
+++ b/crates/ui-egui/src/dialogs/analysis.rs
@@ -1,5 +1,5 @@
 use super::show::{form_fields, ok_cancel};
-use super::*;
+use super::{Dialog, Field, Json, Map, SheetApp, json, vec2};
 
 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();
diff --git a/crates/ui-egui/src/dialogs/charts.rs b/crates/ui-egui/src/dialogs/charts.rs
index bd7da3d66..612ba381f 100644
--- a/crates/ui-egui/src/dialogs/charts.rs
+++ b/crates/ui-egui/src/dialogs/charts.rs
@@ -1,5 +1,5 @@
 use super::show::ok_cancel;
-use super::*;
+use super::{Color32, Dialog, Icon, Json, Sense, SheetApp, Stroke, StrokeKind, icons, json, vec2};
 
 /// Every chart type the All Charts tab offers: `(type, subtype, label)` for `insert.chart`.
 const ALL_CHARTS: [(&str, &str, &str); 21] = [
diff --git a/crates/ui-egui/src/dialogs/command_search.rs b/crates/ui-egui/src/dialogs/command_search.rs
index 509ca4700..aed9843fc 100644
--- a/crates/ui-egui/src/dialogs/command_search.rs
+++ b/crates/ui-egui/src/dialogs/command_search.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Dialog, Key, SheetApp, json, vec2};
 
 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| {
diff --git a/crates/ui-egui/src/dialogs/cond_format_rules.rs b/crates/ui-egui/src/dialogs/cond_format_rules.rs
index 216f79e31..4d8a22375 100644
--- a/crates/ui-egui/src/dialogs/cond_format_rules.rs
+++ b/crates/ui-egui/src/dialogs/cond_format_rules.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Json, SheetApp, json};
 
 pub(super) fn manage_rules(app: &mut SheetApp, ui: &mut egui::Ui) {
     let list = app.session.run("home.manageRules", json!({})).unwrap_or(Json::Null);
diff --git a/crates/ui-egui/src/dialogs/data.rs b/crates/ui-egui/src/dialogs/data.rs
index bda8bcf90..ec5eabfc1 100644
--- a/crates/ui-egui/src/dialogs/data.rs
+++ b/crates/ui-egui/src/dialogs/data.rs
@@ -1,7 +1,7 @@
 #[cfg(test)]
 use super::show::build_params;
 use super::show::{form_fields, ok_cancel};
-use super::*;
+use super::{Dialog, Field, Icon, Json, SheetApp, json, vec2};
 
 /// 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.
diff --git a/crates/ui-egui/src/dialogs/find.rs b/crates/ui-egui/src/dialogs/find.rs
index 27bd3687e..c1401d554 100644
--- a/crates/ui-egui/src/dialogs/find.rs
+++ b/crates/ui-egui/src/dialogs/find.rs
@@ -1,5 +1,5 @@
 use super::show::ok_cancel;
-use super::*;
+use super::{Dialog, Json, Key, SheetApp, json};
 
 /// 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) {
diff --git a/crates/ui-egui/src/dialogs/format_cells.rs b/crates/ui-egui/src/dialogs/format_cells.rs
index 9755ac7a0..7eee57e9c 100644
--- a/crates/ui-egui/src/dialogs/format_cells.rs
+++ b/crates/ui-egui/src/dialogs/format_cells.rs
@@ -1,5 +1,5 @@
 use super::show::ok_cancel;
-use super::*;
+use super::{Dialog, SheetApp, json, theme};
 
 /// 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) {
diff --git a/crates/ui-egui/src/dialogs/insert_function.rs b/crates/ui-egui/src/dialogs/insert_function.rs
index 2a240b1af..b662d7197 100644
--- a/crates/ui-egui/src/dialogs/insert_function.rs
+++ b/crates/ui-egui/src/dialogs/insert_function.rs
@@ -1,5 +1,5 @@
 use super::show::ok_cancel;
-use super::*;
+use super::{Dialog, Json, SheetApp, vec2};
 
 /// 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).
diff --git a/crates/ui-egui/src/dialogs/macros.rs b/crates/ui-egui/src/dialogs/macros.rs
index 269643f8d..8be2cc047 100644
--- a/crates/ui-egui/src/dialogs/macros.rs
+++ b/crates/ui-egui/src/dialogs/macros.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Dialog, Json, SheetApp, json};
 
 /// 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
diff --git a/crates/ui-egui/src/dialogs/names.rs b/crates/ui-egui/src/dialogs/names.rs
index f12374dae..d892b2999 100644
--- a/crates/ui-egui/src/dialogs/names.rs
+++ b/crates/ui-egui/src/dialogs/names.rs
@@ -1,5 +1,5 @@
 use super::show::ok_cancel;
-use super::*;
+use super::{Dialog, Json, Key, SheetApp, json};
 
 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);
diff --git a/crates/ui-egui/src/dialogs/paste.rs b/crates/ui-egui/src/dialogs/paste.rs
index bc01a7da2..9ac0bc579 100644
--- a/crates/ui-egui/src/dialogs/paste.rs
+++ b/crates/ui-egui/src/dialogs/paste.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Dialog, Field, Json, Key, SheetApp, Stroke, json, theme, vec2};
 
 /// 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
@@ -6,7 +6,8 @@ use super::*;
 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
+    type Choice = (&'static str, &'static str, Vec<(&'static str, &'static str)>);
+    let choices: Vec<Choice> = d
         .fields
         .iter()
         .filter_map(|f| match f {
diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs
index ff25ba2c7..0dcc3d9bc 100644
--- a/crates/ui-egui/src/dialogs/show.rs
+++ b/crates/ui-egui/src/dialogs/show.rs
@@ -12,7 +12,7 @@ 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::*;
+use super::{Dialog, Field, Json, Key, Map, RefPick, SheetApp, json, vec2};
 
 /// 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.
diff --git a/crates/ui-egui/src/dialogs/spelling.rs b/crates/ui-egui/src/dialogs/spelling.rs
index 2a53b6d8a..d9ca98c9e 100644
--- a/crates/ui-egui/src/dialogs/spelling.rs
+++ b/crates/ui-egui/src/dialogs/spelling.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Dialog, Json, SheetApp, json};
 
 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);
diff --git a/crates/ui-egui/src/dialogs/zoom.rs b/crates/ui-egui/src/dialogs/zoom.rs
index a81b03b35..6ba57738e 100644
--- a/crates/ui-egui/src/dialogs/zoom.rs
+++ b/crates/ui-egui/src/dialogs/zoom.rs
@@ -1,5 +1,5 @@
 use super::show::ok_cancel;
-use super::*;
+use super::{Dialog, Json, json};
 
 /// 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%")];
diff --git a/crates/ui-egui/src/formula_bar.rs b/crates/ui-egui/src/formula_bar.rs
index 142084aec..574f766de 100644
--- a/crates/ui-egui/src/formula_bar.rs
+++ b/crates/ui-egui/src/formula_bar.rs
@@ -296,127 +296,7 @@ pub fn editor_widget(app: &mut SheetApp, ui: &mut egui::Ui, id: egui::Id, font:
     // Keys the editor handles itself (before the TextEdit sees them), only where it has focus.
     let focused = ui.ctx().memory(|m| m.focused());
     let has_focus = focused == Some(id) || (mine && (ed.request_focus || focused.is_none()));
-    let mut action: Option<(i64, i64, bool, bool)> = None;
-    let mut arrow = false;
-    let mut cancel = false;
-    // A message box over the editor (a data validation alert, a formula error) gets Enter and Esc;
-    // the editor used to take them, so the first Esc cancelled the edit behind the message.
-    // So does a dialog opened from the editor (Paste Name): its OK takes Enter.
-    if has_focus && mine && app.message.is_none() && app.dialog.is_none() {
-        let (enter, tab, esc, alt_enter, cmd_enter, ctrl_shift_enter, shift) = ui.input_mut(|i| {
-            let m = i.modifiers;
-            let alt_enter =
-                i.consume_key(egui::Modifiers::ALT, Key::Enter) || i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::ALT, Key::Enter);
-            let ctrl_shift_enter = i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::SHIFT, Key::Enter);
-            let cmd_enter = i.consume_key(egui::Modifiers::COMMAND, Key::Enter);
-            let enter = i.consume_key(egui::Modifiers::NONE, Key::Enter) || i.consume_key(egui::Modifiers::SHIFT, Key::Enter);
-            let tab = i.consume_key(egui::Modifiers::NONE, Key::Tab) || i.consume_key(egui::Modifiers::SHIFT, Key::Tab);
-            let esc = i.consume_key(egui::Modifiers::NONE, Key::Escape);
-            dismiss_completion(i, &mut ed.completion);
-            (enter, tab, esc, alt_enter, cmd_enter, ctrl_shift_enter, m.shift)
-        });
-        if alt_enter {
-            let b = ed.text.char_indices().nth(ed.caret).map(|(i, _)| i).unwrap_or(ed.text.len());
-            ed.text.insert(b, '\n');
-            ed.caret += 1;
-            ed.caret_to_end = false;
-            ed.sync_caret = true;
-        }
-        if !ed.autocomplete.is_empty() && tab {
-            ed.accept_autocomplete();
-        } else if enter {
-            action = Some((if shift { -1 } else { 1 }, 0, false, false));
-        } else if tab {
-            action = Some((0, if shift { -1 } else { 1 }, false, false));
-        }
-        if cmd_enter {
-            action = Some((0, 0, false, true));
-        }
-        if ctrl_shift_enter {
-            action = Some((0, 0, true, false));
-        }
-        if esc {
-            if !ed.autocomplete.is_empty() {
-                ed.autocomplete.clear();
-            } else if ed.completion.is_some() {
-                ed.completion = None;
-            } else {
-                cancel = true;
-            }
-        }
-        // Arrow keys: autocomplete navigation, point mode, or (Enter mode) commit and move.
-        let arrows = ui.input(|i| {
-            (
-                i.key_pressed(Key::ArrowUp),
-                i.key_pressed(Key::ArrowDown),
-                i.key_pressed(Key::ArrowLeft),
-                i.key_pressed(Key::ArrowRight),
-                i.modifiers.shift,
-            )
-        });
-        let (up, down, left, right, ashift) = arrows;
-        if (up || down) && !ed.autocomplete.is_empty() {
-            ui.input_mut(|i| {
-                i.consume_key(egui::Modifiers::NONE, Key::ArrowUp);
-                i.consume_key(egui::Modifiers::NONE, Key::ArrowDown);
-            });
-            let n = ed.autocomplete.len();
-            ed.ac_index = if down { (ed.ac_index + 1) % n } else { (ed.ac_index + n - 1) % n };
-        } else if ed.enter_mode && (up || down || left || right) && !ed.from_formula_bar {
-            let (dr, dc) = if up {
-                (-1, 0)
-            } else if down {
-                (1, 0)
-            } else if left {
-                (0, -1)
-            } else {
-                (0, 1)
-            };
-            // Left/Right follow the screen on a right-to-left sheet.
-            let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
-            let dc = if rtl { -dc } else { dc };
-            if ed.can_point() {
-                ui.input_mut(|i| {
-                    for k in [Key::ArrowUp, Key::ArrowDown, Key::ArrowLeft, Key::ArrowRight] {
-                        i.consume_key(egui::Modifiers::NONE, k);
-                        i.consume_key(egui::Modifiers::SHIFT, k);
-                    }
-                });
-                crate::grid::point_move(app, &mut ed, dr, dc, ashift);
-            } else {
-                action = Some((dr, dc, false, false));
-                arrow = true;
-            }
-        }
-        // F4 cycles $ anchors of the reference before the caret.
-        if ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::F4)) {
-            cycle_anchor(&mut ed);
-        }
-        // F3 opens Paste Name when the workbook has names; OK puts the name at the caret.
-        if ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::F3)) {
-            app.open_dialog("pasteName", json!({"shortcut": true}));
-        }
-        // Ctrl+Shift+A (Control+Shift+A on a Mac) inserts the argument names. Consumed anywhere,
-        // as in Excel, so it never falls through to the text's select-all.
-        if ui.input_mut(|i| i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::SHIFT, Key::A)) {
-            let (text, caret) = (ed.text.clone(), ed.caret);
-            if ed.insert_argument_names(app.ui.language)
-                && let Some(mut state) = egui::TextEdit::load_state(ui.ctx(), id)
-            {
-                // The text edit records an undo point only once typing pauses: mark the text
-                // before the shortcut so one Undo takes back just the inserted names.
-                let mut undoer = state.undoer();
-                let cursor = state.cursor.char_range().unwrap_or(egui::text::CCursorRange::one(egui::text::CCursor::new(caret)));
-                undoer.add_undo(&(cursor, text));
-                state.set_undoer(undoer);
-                state.store(ui.ctx(), id);
-            }
-        }
-        // Ctrl+Shift+U (Control+Shift+U on a Mac) expands or collapses the formula bar while editing too.
-        if ui.input_mut(|i| i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::SHIFT, Key::U)) {
-            app.run_or_alert("view.expandFormulaBar", json!({}));
-        }
-    }
+    let EditorKeyOutcome { action, arrow, cancel } = editor_shortcuts(app, ui, id, &mut ed, mine, has_focus);
     // The text widget.
     let refs = formula_refs(&ed.text);
     let t = Tokens::get(ui.ctx());
@@ -536,85 +416,7 @@ pub fn editor_widget(app: &mut SheetApp, ui: &mut egui::Ui, id: egui::Id, font:
             gridcraft_engine::Mode::Edit
         };
     }
-    // Column AutoComplete: the rest of the suggested entry, shown selected after the caret.
-    if let Some(full) = &ed.completion
-        && let Some(rest) = crate::editor::completion_rest(full, &ed.text)
-    {
-        let pos = resp.rect.left_top() + egui::vec2(output.galley.rect.width(), 0.0);
-        let g = ui.painter().layout_no_wrap(
-            rest.to_string(),
-            output.galley.job.sections.first().map(|s| s.format.font_id.clone()).unwrap_or_default(),
-            t.on_accent,
-        );
-        let r = egui::Rect::from_min_size(pos, g.size());
-        ui.painter().rect_filled(r, 0.0, t.accent);
-        ui.painter().galley(pos, g, t.on_accent);
-    }
-    // Autocomplete list and argument hint under the editor. Decide visibility from the area the
-    // editor was allotted, not from its response: egui 0.37 gives every text field a
-    // `spacing.interact_size.y` floor, so a one-line cell editor's response can reach below a short
-    // cell and touch the visible quadrant even while the cell itself is hidden under a frozen row.
-    if mine && ui.max_rect().intersect(ui.clip_rect()).is_positive() && (!ed.autocomplete.is_empty() || ed.current_function().is_some()) {
-        let below = resp.rect.left_bottom() + vec2(0.0, 4.0);
-        let language = app.ui.language;
-        // Areas have their own clip rect: keep cell helpers inside the worksheet.
-        let bounds = if ed.from_formula_bar { ui.ctx().content_rect() } else { ui.clip_rect() };
-        egui::Area::new(id.with("ac")).fixed_pos(below).constrain_to(bounds).order(egui::Order::Tooltip).show(ui.ctx(), |ui| {
-            egui::Frame::popup(ui.style()).inner_margin(4.0).show(ui, |ui| {
-                if !ed.autocomplete.is_empty() {
-                    let mut pick = None;
-                    for (i, n) in ed.autocomplete.iter().enumerate() {
-                        let sel = i == ed.ac_index;
-                        let r = ui.add(
-                            egui::Button::selectable(sel, egui::RichText::new(format!("ƒ  {n}")).font(theme::ui_font(12.5)))
-                                .min_size(vec2(220.0, 20.0)),
-                        );
-                        if r.clicked() {
-                            pick = Some(i);
-                        }
-                        if sel && let Some(desc) = crate::formula_locale::description(n, ed.locale, language) {
-                            r.on_hover_text(desc);
-                        }
-                    }
-                    if let Some(desc) = ed.autocomplete.get(ed.ac_index).and_then(|n| crate::formula_locale::description(n, ed.locale, language)) {
-                        ui.separator();
-                        ui.add(egui::Label::new(egui::RichText::new(desc).small()).wrap());
-                    }
-                    if let Some(i) = pick {
-                        ed.ac_index = i;
-                        ed.accept_autocomplete();
-                        ed.request_focus = true;
-                    }
-                } else if let Some((name, arg)) = ed.current_function()
-                    && let Some(sig) = crate::formula_locale::signature(&name, ed.locale, language)
-                {
-                    ui.horizontal_wrapped(|ui| {
-                        ui.spacing_mut().item_spacing.x = 0.0;
-                        let (head, rest) = sig.split_once('(').unwrap_or((&sig, ""));
-                        ui.label(egui::RichText::new(format!("{head}(")).font(theme::ui_font(12.0)));
-                        let inner = rest.trim_end_matches(')');
-                        let parts: Vec<&str> = inner.split(&format!("{} ", ed.locale.list_separator())).collect();
-                        for (i, part) in parts.iter().enumerate() {
-                            let is_cur = i == arg.min(parts.len().saturating_sub(1)) || (part.contains("...") && arg >= i);
-                            let txt = egui::RichText::new(*part).font(if is_cur { theme::ui_bold(12.0) } else { theme::ui_font(12.0) });
-                            ui.label(txt);
-                            if i + 1 < parts.len() {
-                                ui.label(egui::RichText::new(format!("{} ", ed.locale.list_separator())).font(theme::ui_font(12.0)));
-                            }
-                        }
-                        ui.label(egui::RichText::new(")").font(theme::ui_font(12.0)));
-                    });
-                    // The description too, so values an argument takes (DATEDIF's units, #363) show
-                    // while it's typed; wrapped to the hint's width.
-                    if let Some(desc) = crate::formula_locale::description(&name, ed.locale, language) {
-                        ui.set_max_width(ui.min_rect().width().max(220.0));
-                        ui.separator();
-                        ui.add(egui::Label::new(egui::RichText::new(desc).small()).wrap());
-                    }
-                }
-            });
-        });
-    }
+    show_editor_suggestions(ui, EditorSuggestion { app, id, resp: &resp, ed: &mut ed, galley: &output.galley, tokens: &t, mine });
     let lines = output.galley.rows.len().max(1);
     let caret = Some(output.galley.pos_from_cursor(egui::text::CCursor::new(ed.caret)).translate(output.galley_pos.to_vec2()));
     app.editor = Some(ed);
@@ -630,6 +432,158 @@ pub fn editor_widget(app: &mut SheetApp, ui: &mut egui::Ui, id: egui::Id, font:
     EditorInfo { lines, caret }
 }
 
+type EditorAction = (i64, i64, bool, bool);
+
+struct EditorKeyOutcome {
+    action: Option<EditorAction>,
+    arrow: bool,
+    cancel: bool,
+}
+
+fn editor_shortcuts(
+    app: &mut SheetApp,
+    ui: &mut egui::Ui,
+    id: egui::Id,
+    ed: &mut crate::editor::EditState,
+    mine: bool,
+    has_focus: bool,
+) -> EditorKeyOutcome {
+    let mut outcome = EditorKeyOutcome { action: None, arrow: false, cancel: false };
+    // A message or dialog owns Enter and Escape until it closes.
+    if !has_focus || !mine || app.message.is_some() || app.dialog.is_some() {
+        return outcome;
+    }
+    let (action, cancel) = editor_confirm_keys(ui, ed);
+    outcome.action = action;
+    outcome.cancel = cancel;
+    let (action, arrow) = editor_arrow_keys(app, ui, ed, outcome.action);
+    outcome.action = action;
+    outcome.arrow = arrow;
+    editor_other_shortcuts(app, ui, id, ed);
+    outcome
+}
+
+fn editor_confirm_keys(ui: &mut egui::Ui, ed: &mut crate::editor::EditState) -> (Option<EditorAction>, bool) {
+    let (enter, tab, esc, alt_enter, cmd_enter, ctrl_shift_enter, shift) = ui.input_mut(|i| {
+        let m = i.modifiers;
+        let alt_enter = i.consume_key(egui::Modifiers::ALT, Key::Enter) || i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::ALT, Key::Enter);
+        let ctrl_shift_enter = i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::SHIFT, Key::Enter);
+        let cmd_enter = i.consume_key(egui::Modifiers::COMMAND, Key::Enter);
+        let enter = i.consume_key(egui::Modifiers::NONE, Key::Enter) || i.consume_key(egui::Modifiers::SHIFT, Key::Enter);
+        let tab = i.consume_key(egui::Modifiers::NONE, Key::Tab) || i.consume_key(egui::Modifiers::SHIFT, Key::Tab);
+        let esc = i.consume_key(egui::Modifiers::NONE, Key::Escape);
+        dismiss_completion(i, &mut ed.completion);
+        (enter, tab, esc, alt_enter, cmd_enter, ctrl_shift_enter, m.shift)
+    });
+    if alt_enter {
+        let b = ed.text.char_indices().nth(ed.caret).map(|(i, _)| i).unwrap_or(ed.text.len());
+        ed.text.insert(b, '\n');
+        ed.caret += 1;
+        ed.caret_to_end = false;
+        ed.sync_caret = true;
+    }
+    let mut action = if !ed.autocomplete.is_empty() && tab {
+        ed.accept_autocomplete();
+        None
+    } else if enter {
+        Some((if shift { -1 } else { 1 }, 0, false, false))
+    } else if tab {
+        Some((0, if shift { -1 } else { 1 }, false, false))
+    } else {
+        None
+    };
+    if cmd_enter {
+        action = Some((0, 0, false, true));
+    }
+    if ctrl_shift_enter {
+        action = Some((0, 0, true, false));
+    }
+    let cancel = if !esc {
+        false
+    } else if !ed.autocomplete.is_empty() {
+        ed.autocomplete.clear();
+        false
+    } else if ed.completion.is_some() {
+        ed.completion = None;
+        false
+    } else {
+        true
+    };
+    (action, cancel)
+}
+
+fn editor_arrow_keys(
+    app: &mut SheetApp,
+    ui: &mut egui::Ui,
+    ed: &mut crate::editor::EditState,
+    mut action: Option<EditorAction>,
+) -> (Option<EditorAction>, bool) {
+    let (up, down, left, right, shift) = ui.input(|i| {
+        (i.key_pressed(Key::ArrowUp), i.key_pressed(Key::ArrowDown), i.key_pressed(Key::ArrowLeft), i.key_pressed(Key::ArrowRight), i.modifiers.shift)
+    });
+    if (up || down) && !ed.autocomplete.is_empty() {
+        ui.input_mut(|i| {
+            i.consume_key(egui::Modifiers::NONE, Key::ArrowUp);
+            i.consume_key(egui::Modifiers::NONE, Key::ArrowDown);
+        });
+        let n = ed.autocomplete.len();
+        ed.ac_index = if down { (ed.ac_index + 1) % n } else { (ed.ac_index + n - 1) % n };
+        return (action, false);
+    }
+    if !ed.enter_mode || (!up && !down && !left && !right) || ed.from_formula_bar {
+        return (action, false);
+    }
+    let (dr, dc) = if up {
+        (-1, 0)
+    } else if down {
+        (1, 0)
+    } else if left {
+        (0, -1)
+    } else {
+        (0, 1)
+    };
+    let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
+    let dc = if rtl { -dc } else { dc };
+    if ed.can_point() {
+        ui.input_mut(|i| {
+            for key in [Key::ArrowUp, Key::ArrowDown, Key::ArrowLeft, Key::ArrowRight] {
+                i.consume_key(egui::Modifiers::NONE, key);
+                i.consume_key(egui::Modifiers::SHIFT, key);
+            }
+        });
+        crate::grid::point_move(app, ed, dr, dc, shift);
+        (action, false)
+    } else {
+        action = Some((dr, dc, false, false));
+        (action, true)
+    }
+}
+
+fn editor_other_shortcuts(app: &mut SheetApp, ui: &mut egui::Ui, id: egui::Id, ed: &mut crate::editor::EditState) {
+    if ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::F4)) {
+        cycle_anchor(ed);
+    }
+    if ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::F3)) {
+        app.open_dialog("pasteName", json!({"shortcut": true}));
+    }
+    if ui.input_mut(|i| i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::SHIFT, Key::A)) {
+        let (text, caret) = (ed.text.clone(), ed.caret);
+        if ed.insert_argument_names(app.ui.language)
+            && let Some(mut state) = egui::TextEdit::load_state(ui.ctx(), id)
+        {
+            // Record the pre-shortcut text so one Undo removes the inserted argument names.
+            let mut undoer = state.undoer();
+            let cursor = state.cursor.char_range().unwrap_or(egui::text::CCursorRange::one(egui::text::CCursor::new(caret)));
+            undoer.add_undo(&(cursor, text));
+            state.set_undoer(undoer);
+            state.store(ui.ctx(), id);
+        }
+    }
+    if ui.input_mut(|i| i.consume_key(egui::Modifiers::CTRL | egui::Modifiers::SHIFT, Key::U)) {
+        app.run_or_alert("view.expandFormulaBar", json!({}));
+    }
+}
+
 fn cycle_anchor(ed: &mut crate::editor::EditState) {
     let caret_b = ed.text.char_indices().nth(ed.caret).map(|(i, _)| i).unwrap_or(ed.text.len());
     for (a, b, ..) in formula_refs(&ed.text) {
@@ -871,3 +825,96 @@ mod tests {
         }
     }
 }
+
+struct EditorSuggestion<'a> {
+    app: &'a SheetApp,
+    id: egui::Id,
+    resp: &'a egui::Response,
+    ed: &'a mut crate::editor::EditState,
+    galley: &'a egui::Galley,
+    tokens: &'a Tokens,
+    mine: bool,
+}
+
+fn show_editor_suggestions(ui: &mut egui::Ui, suggestion: EditorSuggestion<'_>) {
+    let EditorSuggestion { app, id, resp, ed, galley, tokens: t, mine } = suggestion;
+    // Column AutoComplete: the rest of the suggested entry, shown selected after the caret.
+    if let Some(full) = &ed.completion
+        && let Some(rest) = crate::editor::completion_rest(full, &ed.text)
+    {
+        let pos = resp.rect.left_top() + egui::vec2(galley.rect.width(), 0.0);
+        let g = ui.painter().layout_no_wrap(
+            rest.to_string(),
+            galley.job.sections.first().map(|s| s.format.font_id.clone()).unwrap_or_default(),
+            t.on_accent,
+        );
+        let r = egui::Rect::from_min_size(pos, g.size());
+        ui.painter().rect_filled(r, 0.0, t.accent);
+        ui.painter().galley(pos, g, t.on_accent);
+    }
+    // Autocomplete list and argument hint under the editor. Decide visibility from the area the
+    // editor was allotted, not from its response: egui 0.37 gives every text field a
+    // `spacing.interact_size.y` floor, so a one-line cell editor's response can reach below a short
+    // cell and touch the visible quadrant even while the cell itself is hidden under a frozen row.
+    if mine && ui.max_rect().intersect(ui.clip_rect()).is_positive() && (!ed.autocomplete.is_empty() || ed.current_function().is_some()) {
+        let below = resp.rect.left_bottom() + vec2(0.0, 4.0);
+        let language = app.ui.language;
+        // Areas have their own clip rect: keep cell helpers inside the worksheet.
+        let bounds = if ed.from_formula_bar { ui.ctx().content_rect() } else { ui.clip_rect() };
+        egui::Area::new(id.with("ac")).fixed_pos(below).constrain_to(bounds).order(egui::Order::Tooltip).show(ui.ctx(), |ui| {
+            egui::Frame::popup(ui.style()).inner_margin(4.0).show(ui, |ui| {
+                if !ed.autocomplete.is_empty() {
+                    let mut pick = None;
+                    for (i, n) in ed.autocomplete.iter().enumerate() {
+                        let sel = i == ed.ac_index;
+                        let r = ui.add(
+                            egui::Button::selectable(sel, egui::RichText::new(format!("ƒ  {n}")).font(theme::ui_font(12.5)))
+                                .min_size(vec2(220.0, 20.0)),
+                        );
+                        if r.clicked() {
+                            pick = Some(i);
+                        }
+                        if sel && let Some(desc) = crate::formula_locale::description(n, ed.locale, language) {
+                            r.on_hover_text(desc);
+                        }
+                    }
+                    if let Some(desc) = ed.autocomplete.get(ed.ac_index).and_then(|n| crate::formula_locale::description(n, ed.locale, language)) {
+                        ui.separator();
+                        ui.add(egui::Label::new(egui::RichText::new(desc).small()).wrap());
+                    }
+                    if let Some(i) = pick {
+                        ed.ac_index = i;
+                        ed.accept_autocomplete();
+                        ed.request_focus = true;
+                    }
+                } else if let Some((name, arg)) = ed.current_function()
+                    && let Some(sig) = crate::formula_locale::signature(&name, ed.locale, language)
+                {
+                    ui.horizontal_wrapped(|ui| {
+                        ui.spacing_mut().item_spacing.x = 0.0;
+                        let (head, rest) = sig.split_once('(').unwrap_or((&sig, ""));
+                        ui.label(egui::RichText::new(format!("{head}(")).font(theme::ui_font(12.0)));
+                        let inner = rest.trim_end_matches(')');
+                        let parts: Vec<&str> = inner.split(&format!("{} ", ed.locale.list_separator())).collect();
+                        for (i, part) in parts.iter().enumerate() {
+                            let is_cur = i == arg.min(parts.len().saturating_sub(1)) || (part.contains("...") && arg >= i);
+                            let txt = egui::RichText::new(*part).font(if is_cur { theme::ui_bold(12.0) } else { theme::ui_font(12.0) });
+                            ui.label(txt);
+                            if i + 1 < parts.len() {
+                                ui.label(egui::RichText::new(format!("{} ", ed.locale.list_separator())).font(theme::ui_font(12.0)));
+                            }
+                        }
+                        ui.label(egui::RichText::new(")").font(theme::ui_font(12.0)));
+                    });
+                    // The description too, so values an argument takes (DATEDIF's units, #363) show
+                    // while it's typed; wrapped to the hint's width.
+                    if let Some(desc) = crate::formula_locale::description(&name, ed.locale, language) {
+                        ui.set_max_width(ui.min_rect().width().max(220.0));
+                        ui.separator();
+                        ui.add(egui::Label::new(egui::RichText::new(desc).small()).wrap());
+                    }
+                }
+            });
+        });
+    }
+}
diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index e3715a6de..0d1b131e0 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -15,6 +15,13 @@ use crate::SheetApp;
 use crate::editor::EditState;
 use crate::theme::{self, Tokens};
 
+/// A painted pane: its row span, column span and screen rectangle.
+pub(crate) type PaneQuad = ((u32, u32), (u32, u32), Rect);
+/// Cached Page Break Preview ranges, keyed by (doc uid, revision, sheet).
+type PagesCache = ((u64, u64, usize), Vec<(RangeRef, u32)>);
+/// Cached Show Details cells, keyed by (doc uid, revision, sheet, pivot).
+type DetailsCache = ((u64, u64, usize, usize), Option<std::collections::HashSet<(u32, u32)>>);
+
 mod cell_paint;
 mod cursor;
 mod editor;
@@ -37,9 +44,9 @@ pub use editor::validation_arrow;
 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(crate) use quadrant::{QuadrantPaint, paint_quadrant};
 pub use selection::selection_fill;
+pub(crate) use selection::{SelectionPaintInput, paint_selection};
 pub(crate) use show::horizontal_scrollbar;
 pub use show::show;
 #[cfg(test)]
@@ -210,7 +217,7 @@ pub struct GridState {
     /// Ink stroke being drawn (sheet points).
     pub ink: Vec<[f32; 2]>,
     /// Page ranges for Page Break Preview, cached per (doc uid, revision, sheet).
-    pub pages: Option<((u64, u64, usize), Vec<(RangeRef, u32)>)>,
+    pub pages: Option<PagesCache>,
     /// The PivotTable Fields pane's `pivot.fields` answer, cached per (doc uid, revision, pivot):
     /// it scans the whole source list, far too slow to repeat every frame (#2113).
     pub pivot_fields: Option<((u64, u64, String), serde_json::Value)>,
@@ -218,7 +225,7 @@ pub struct GridState {
     /// report's top-left and cached per (doc uid, revision, sheet, pivot): finding them computes
     /// the whole report. `None` when the report can't be computed or is out of date: every cell
     /// of it offers Show Details, and running it says why.
-    pub show_details_cells: Option<((u64, u64, usize, usize), Option<std::collections::HashSet<(u32, u32)>>)>,
+    pub show_details_cells: Option<DetailsCache>,
     pub header_menu: Option<(Pos2, bool)>,
     /// Page Layout view pagination, cached per (doc uid, revision, sheet, rows, columns).
     pub paper: Option<crate::paper_view::PaperCache>,
diff --git a/crates/ui-egui/src/grid/cell_paint.rs b/crates/ui-egui/src/grid/cell_paint.rs
index 99ff2320e..9c6a0b10b 100644
--- a/crates/ui-egui/src/grid/cell_paint.rs
+++ b/crates/ui-egui/src/grid/cell_paint.rs
@@ -1,5 +1,8 @@
 use super::geo::Geo;
-use super::*;
+use super::{
+    BorderLine, BorderStyle, CellRef, CfCache, CfLook, Color, Color32, FontId, HAlign, MAX_COLS, Painter, PatternType, Pos2, RangeRef, Rect, Sheet,
+    Stroke, Style, Underline, VAlign, Value, Workbook, pos2, theme, vec2,
+};
 
 /// Resolved look of a cell for painting.
 pub(super) struct Look {
@@ -171,21 +174,20 @@ pub(crate) fn rotated_text_pos(rect: Rect, size: egui::Vec2, angle: f32, h: HAli
     pos2(x, y) - turned.min.to_vec2()
 }
 
+/// A merged range, where it is drawn, and the visible rows and columns.
+#[derive(Clone, Copy)]
+pub(super) struct MergedArea {
+    pub(super) m: RangeRef,
+    pub(super) rect: Rect,
+    pub(super) rows: (u32, u32),
+    pub(super) cols: (u32, u32),
+}
+
 /// 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])> {
+pub(super) fn merged_edges(wb: &Workbook, si: usize, sh: &Sheet, geo: &Geo, area: MergedArea, cf: &mut CfCache) -> Vec<(BorderLine, [Pos2; 2])> {
+    let MergedArea { m, rect, rows, cols } = area;
     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 {
diff --git a/crates/ui-egui/src/grid/cursor.rs b/crates/ui-egui/src/grid/cursor.rs
index b72f9e160..ae381c7ff 100644
--- a/crates/ui-egui/src/grid/cursor.rs
+++ b/crates/ui-egui/src/grid/cursor.rs
@@ -1,6 +1,6 @@
 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::*;
+use super::{CellRef, Color32, CursorIcon, Drag, Pos2, RangeRef, Rect, Sheet, SheetApp, Stroke, pos2, vec2};
 
 /// 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) {
diff --git a/crates/ui-egui/src/grid/editor.rs b/crates/ui-egui/src/grid/editor.rs
index d87ec385a..59f375e80 100644
--- a/crates/ui-egui/src/grid/editor.rs
+++ b/crates/ui-egui/src/grid/editor.rs
@@ -1,6 +1,6 @@
 use super::cell_paint::ink_on;
 use super::geo::Geo;
-use super::*;
+use super::{Align2, CellRef, Color32, FontId, PatternType, Rect, Sheet, SheetApp, Stroke, StrokeKind, Tokens, Workbook, json, pos2, theme, vec2};
 
 /// 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,
diff --git a/crates/ui-egui/src/grid/geo.rs b/crates/ui-egui/src/grid/geo.rs
index 0c17e173a..33b1b5461 100644
--- a/crates/ui-egui/src/grid/geo.rs
+++ b/crates/ui-egui/src/grid/geo.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Arc, COL_HEADER_H, CellRef, DISPLAY_SCALE, LineIndex, MAX_COLS, MAX_ROWS, Pos2, RangeRef, Rect, Sheet, pos2};
 
 /// Geometry of the grid for one frame (handles zoom and frozen panes).
 #[derive(Clone)]
diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs
index f59f367a7..fdbf632a5 100644
--- a/crates/ui-egui/src/grid/interact.rs
+++ b/crates/ui-egui/src/grid/interact.rs
@@ -4,13 +4,51 @@ 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::*;
+use super::{
+    CellRef, Color32, CursorIcon, Drag, EditState, MAX_COLS, MAX_ROWS, Painter, Pos2, RangeRef, Rect, Sheet, SheetApp, Stroke, Tokens, Workbook,
+    json, pos2, vec2,
+};
 
 // ------------------------------------------------------------------ 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;
 
+struct InteractionInput<'a> {
+    ui: &'a mut egui::Ui,
+    response: &'a egui::Response,
+    geo: &'a Geo,
+    sheet: &'a Sheet,
+    workbook: &'a Workbook,
+    context: egui::Context,
+    press_origin: Option<Pos2>,
+    any_pointer_down: bool,
+    modifiers: egui::Modifiers,
+    position: Option<Pos2>,
+    primary_clicked: bool,
+    in_cells: bool,
+    in_column_header: bool,
+    in_row_header: bool,
+    in_corner: bool,
+    selection: gridcraft_engine::Selection,
+    current_rect: Rect,
+    handle: Rect,
+    handle_panes: Vec<Rect>,
+    border_panes: Vec<Rect>,
+    freeze_columns: Rect,
+    freeze_rows: Rect,
+}
+
+impl InteractionInput<'_> {
+    fn on_handle(&self, p: Pos2) -> bool {
+        self.handle.contains(p) && self.handle_panes.iter().any(|r| r.contains(p))
+    }
+
+    fn on_current_border(&self, p: Pos2) -> bool {
+        on_border(self.current_rect, p) && self.border_panes.iter().any(|r| r.contains(p))
+    }
+}
+
 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() {
@@ -34,54 +72,33 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
     // 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;
-        }
+    let input = InteractionInput {
+        ui,
+        response: resp,
+        geo,
+        sheet: sh,
+        workbook: wb,
+        context: ctx.clone(),
+        press_origin: pointer.press_origin(),
+        any_pointer_down: pointer.any_down(),
+        modifiers: mods,
+        position: pos,
+        primary_clicked,
+        in_cells,
+        in_column_header: in_col_header,
+        in_row_header,
+        in_corner,
+        selection: sel.clone(),
+        current_rect: cur_rect,
+        handle,
+        handle_panes,
+        border_panes,
+        freeze_columns: freeze_cols,
+        freeze_rows,
+    };
+    if handle_draw_tool(app, &input) {
+        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.
@@ -144,45 +161,14 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         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;
-        }
+    if handle_header_autofit(app, &input) {
+        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)
+        && input.on_handle(p)
     {
         // Fill down as far as the neighbouring column goes.
         let src = sel.current();
@@ -199,215 +185,397 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         return;
     }
 
-    // Press: decide the drag mode.
+    // Press: choose the interaction mode before pointer movement is applied.
     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))
+        handle_press(app, &input);
+        return;
+    }
+
+    handle_dragging(app, &input);
+
+    handle_release(app, &input);
+
+    handle_context_menu_and_keyboard(app, &input);
+}
+
+fn handle_draw_tool(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool {
+    let (in_cells, pos, resp, geo, sh, primary_clicked) =
+        (input.in_cells, input.position, input.response, input.geo, input.sheet, input.primary_clicked);
+    let ctx = input.context.clone();
+    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()
             {
-                app.grid.drag = Drag::MoveCols { source: sel.current(), before: None };
-                return;
+                // 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]);
             }
-            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 });
+            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();
+                input
+                    .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 true;
+        }
+        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 true;
+        }
+    }
+    false
+}
+
+fn handle_header_autofit(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool {
+    let (geo, sh, sel, pos) = (input.geo, input.sheet, &input.selection, input.position);
+    let (in_col_header, in_row_header) = (input.in_column_header, input.in_row_header);
+    let resp = input.response;
+    if !resp.double_clicked() {
+        return false;
+    }
+    let Some(p) = pos else { return false };
+
+    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 true;
+    }
+    false
+}
+
+fn handle_column_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, p: Pos2) {
+    let (geo, sh, wb, sel) = (input.geo, input.sheet, input.workbook, &input.selection);
+    let mods = input.modifiers;
+    let resp = input.response;
+    let in_col_header = input.in_column_header;
+    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;
         }
-        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 });
+        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 !in_cells {
+        if point_header(app, wb, sh, RangeRef::cols(c, c), mods.shift, mods.command) {
             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)
+        // 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.list_picker = Some(sel.active);
+            app.grid.drag = Drag::MoveCols { source: sel.current(), before: None };
             return;
         }
-        // Filter dropdown buttons.
-        if is_filter_button(sh, geo, p) {
-            app.grid.filter_menu = Some((c.col, c.row, geo.mirror_pos(p)));
+        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 });
+    }
+}
+
+fn handle_row_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, p: Pos2) {
+    let (geo, sh, wb, sel) = (input.geo, input.sheet, input.workbook, &input.selection);
+    let mods = input.modifiers;
+    let in_row_header = input.in_row_header;
+    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;
         }
-        // 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);
-            }
+        let r = geo.row_at(sh, p.y);
+        if point_header(app, wb, sh, RangeRef::rows(r, r), mods.shift, mods.command) {
             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);
-                }
-            }
+        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 });
+    }
+}
+
+fn handle_press(app: &mut SheetApp, input: &InteractionInput<'_>) {
+    let (geo, sh, wb, resp) = (input.geo, input.sheet, input.workbook, input.response);
+    let (pos, mods, sel) = (input.position, input.modifiers, &input.selection);
+    let (primary_clicked, in_cells, in_col_header, in_row_header, in_corner) =
+        (input.primary_clicked, input.in_cells, input.in_column_header, input.in_row_header, input.in_corner);
+    let (freeze_cols, freeze_rows) = (input.freeze_columns, input.freeze_rows);
+    let on_handle = |p| input.on_handle(p);
+    let on_cur_border = |p| input.on_current_border(p);
+    let pointer = input.press_origin;
+
+    // Where the press began (a drag is only recognised after the pointer has moved).
+    let Some(p) = pointer.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 {
+        handle_column_header_press(app, input, p);
+        return;
+    }
+    if in_row_header {
+        handle_row_header_press(app, input, p);
+        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
         {
-            // The first recognised drag already includes movement away from the press.
             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;
+    }
+    let now = crate::now_ms();
+    if handle_cell_double_click(app, input, c, now) {
+        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);
+    }
+}
 
-    // Dragging.
+fn handle_cell_double_click(app: &mut SheetApp, input: &InteractionInput<'_>, c: CellRef, now: f64) -> bool {
+    let (sh, mods) = (input.sheet, input.modifiers);
+    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 true,
+                Err(e) if e == not_a_value_cell => {}
+                Err(e) => {
+                    app.message = Some(("GridCraft".into(), crate::clean_error(&e)));
+                    return true;
+                }
+            }
+        }
+        // Following a hyperlink requires a single click in Excel; double-click edits.
+        app.begin_edit(None, false);
+        return true;
+    }
+    false
+}
+
+fn handle_context_menu_and_keyboard(app: &mut SheetApp, input: &InteractionInput<'_>) {
+    let (geo, sh, sel, pos) = (input.geo, input.sheet, &input.selection, input.position);
+    let resp = input.response;
+    let primary_clicked = input.primary_clicked;
+    let (in_cells, in_col_header, in_row_header) = (input.in_cells, input.in_column_header, input.in_row_header);
+    let ctx = input.context.clone();
+    // 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 = input.ui.ctx().cumulative_frame_nr();
+        }
+    }
+
+    if primary_clicked || resp.drag_started() {
+        resp.request_focus();
+    }
+    keyboard(app, &ctx, resp, geo, sh);
+}
+
+fn handle_dragging(app: &mut SheetApp, input: &InteractionInput<'_>) {
+    let (geo, sh, wb, sel, pos) = (input.geo, input.sheet, input.workbook, &input.selection, input.position);
+    let resp = input.response;
     if resp.dragged()
         && let Some(p) = pos
     {
@@ -519,9 +687,13 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
             Drag::None => {}
         }
     }
+}
 
-    // Release.
-    if resp.drag_stopped() || (!pointer.any_down() && app.grid.drag != Drag::None && !resp.dragged()) {
+fn handle_release(app: &mut SheetApp, input: &InteractionInput<'_>) {
+    let (geo, sh, wb, sel, pos, mods, resp) =
+        (input.geo, input.sheet, input.workbook, &input.selection, input.position, input.modifiers, input.response);
+    let ctx = input.context.clone();
+    if resp.drag_stopped() || (!input.any_pointer_down && app.grid.drag != Drag::None && !resp.dragged()) {
         match std::mem::take(&mut app.grid.drag) {
             Drag::Select => {
                 if resp.drag_stopped()
@@ -578,38 +750,6 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         }
         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
diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs
index 6cb4a8c9c..8d2e698ed 100644
--- a/crates/ui-egui/src/grid/keyboard.rs
+++ b/crates/ui-egui/src/grid/keyboard.rs
@@ -1,7 +1,7 @@
 use super::geo::Geo;
 use super::interact::delete_selected_object;
 use super::menus::is_checkbox;
-use super::*;
+use super::{CellRef, Drag, Sheet, SheetApp, json};
 
 /// 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) {
diff --git a/crates/ui-egui/src/grid/menus.rs b/crates/ui-egui/src/grid/menus.rs
index b239c7eac..dbe34af8d 100644
--- a/crates/ui-egui/src/grid/menus.rs
+++ b/crates/ui-egui/src/grid/menus.rs
@@ -1,7 +1,7 @@
 use super::editor::popup_dismissed;
 use super::geo::Geo;
 use super::tables::filter_table_range;
-use super::*;
+use super::{Arc, Drag, FillTag, RangeRef, Rect, Sense, Sheet, SheetApp, Stroke, Tokens, col_to_letters, json, pos2, vec2};
 
 /// 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) {
diff --git a/crates/ui-egui/src/grid/quadrant.rs b/crates/ui-egui/src/grid/quadrant.rs
index aa9e6fc07..e5fdd9c92 100644
--- a/crates/ui-egui/src/grid/quadrant.rs
+++ b/crates/ui-egui/src/grid/quadrant.rs
@@ -1,10 +1,13 @@
 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,
+    Look, MergedArea, 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::*;
+use super::{
+    CellRef, CfCache, CfLook, Color32, FontId, HAlign, MAX_COLS, Painter, Pos2, RangeRef, Rect, Sheet, Stroke, StrokeKind, Tokens, Underline, Value,
+    Workbook, pos2, theme, 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
@@ -65,26 +68,47 @@ fn mirror_shape(shape: &mut egui::Shape, axis: f32) {
     }
 }
 
-#[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;
+pub(crate) struct QuadrantPaint<'a> {
+    pub(crate) painter: &'a Painter,
+    pub(crate) geo: &'a Geo,
+    pub(crate) workbook: &'a Workbook,
+    pub(crate) sheet_index: usize,
+    pub(crate) sheet: &'a Sheet,
+    pub(crate) rows: (u32, u32),
+    pub(crate) cols: (u32, u32),
+    pub(crate) cf: &'a mut CfCache,
+    pub(crate) tokens: &'a Tokens,
+}
+
+pub(crate) fn paint_quadrant(mut quadrant: QuadrantPaint<'_>) {
+    let (r0, r1) = quadrant.rows;
+    let (c0, c1) = quadrant.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 merges = visible_merges(&quadrant, range);
+    paint_gridlines(&quadrant);
+    let cells = visible_cells(&quadrant);
+    let looks = paint_backgrounds(&mut quadrant, &cells, &merges);
+    let outside = outside_text_cells(&mut quadrant, &merges);
+    paint_cells(&mut quadrant, &looks, &outside, &merges);
+    paint_borders(&mut quadrant, &looks, &merges);
+    paint_sparklines(&quadrant, range);
+    paint_filter_buttons(&quadrant, range);
+}
+
+fn visible_merges(q: &QuadrantPaint<'_>, range: RangeRef) -> Vec<RangeRef> {
+    let (r0, r1) = (range.start.row, range.end.row);
+    let (c0, c1) = (range.start.col, range.end.col);
     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();
+    q.sheet.merges.iter().filter(|m| m.intersects(&near)).copied().collect()
+}
+
+fn paint_gridlines(q: &QuadrantPaint<'_>) {
+    let p = q.painter;
+    let geo = q.geo;
+    let sh = q.sheet;
+    let t = q.tokens;
+    let (r0, r1) = q.rows;
+    let (c0, c1) = q.cols;
     // Gridlines.
     if sh.show_gridlines {
         let stroke = Stroke::new(1.0, t.gridline);
@@ -107,6 +131,12 @@ pub(crate) fn paint_quadrant(
             p.line_segment([pos2(left, y), pos2(right, y)], stroke);
         }
     }
+}
+
+fn visible_cells(q: &QuadrantPaint<'_>) -> Vec<CellRef> {
+    let sh = q.sheet;
+    let (r0, r1) = q.rows;
+    let (c0, c1) = q.cols;
     // Merged areas: blank them (no inner gridlines) and paint as one cell.
     let mut cells: Vec<CellRef> = Vec::new();
     for r in r0..=r1 {
@@ -120,10 +150,22 @@ pub(crate) fn paint_quadrant(
             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() };
+    cells
+}
+
+fn paint_backgrounds(q: &mut QuadrantPaint<'_>, cells: &[CellRef], merges: &[RangeRef]) -> Vec<(CellRef, Rect, Look, Option<CfLook>)> {
+    let p = q.painter;
+    let geo = q.geo;
+    let wb = q.workbook;
+    let si = q.sheet_index;
+    let sh = q.sheet;
+    let cf = &mut *q.cf;
+    let (r0, _) = q.rows;
+    let c0 = q.cols.0;
+    let in_merge = |c: CellRef| merges.iter().find(|m| m.contains(c)).copied();
     // Backgrounds.
     let mut looks: Vec<(CellRef, Rect, Look, Option<CfLook>)> = Vec::with_capacity(cells.len().min(20_000));
-    for &c in &cells {
+    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),
@@ -137,6 +179,19 @@ pub(crate) fn paint_quadrant(
         }
         looks.push((anchor, rect, lk, cfl));
     }
+    looks
+}
+
+fn outside_text_cells(q: &mut QuadrantPaint<'_>, merges: &[RangeRef]) -> Vec<(CellRef, Rect, Look, Option<CfLook>)> {
+    let geo = q.geo;
+    let wb = q.workbook;
+    let si = q.sheet_index;
+    let sh = q.sheet;
+    let cf = &mut *q.cf;
+    let (r0, r1) = q.rows;
+    let (c0, c1) = q.cols;
+    let in_merge = |c: CellRef| merges.iter().find(|m| m.contains(c)).copied();
+    let empty_ok = |c: CellRef| sh.value_ref(c).is_none_or(Value::is_empty) && in_merge(c).is_none();
     // 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();
@@ -154,248 +209,323 @@ pub(crate) fn paint_quadrant(
             }
         }
     }
-    // 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;
+    outside
+}
+
+fn paint_cells(
+    q: &mut QuadrantPaint<'_>,
+    looks: &[(CellRef, Rect, Look, Option<CfLook>)],
+    outside: &[(CellRef, Rect, Look, Option<CfLook>)],
+    merges: &[RangeRef],
+) {
+    for cell in looks.iter().chain(outside) {
+        paint_cell(q, cell, merges);
+    }
+}
+
+fn paint_cell_decorations(q: &QuadrantPaint<'_>, c: CellRef, rect: Rect, lk: &Look, cfl: Option<&CfLook>) -> bool {
+    let v = q.sheet.value(c);
+    let p = q.painter;
+    let z = q.geo.z;
+    if let Some(picture) = q.sheet.cell_pictures.get(&c) {
+        crate::cell_pictures::paint(p, rect, picture);
+        return true;
+    }
+    if let Some(l) = cfl
+        && let Some((frac, rgb, gradient)) = l.bar
+    {
+        paint_data_bar(p, rect, frac, rgb, gradient);
+    }
+    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);
+    }
+    if lk.style.num_fmt.as_str() == "checkbox" && matches!(v, Value::Bool(_) | Value::Empty) {
+        paint_checkbox(p, rect, z, v == Value::Bool(true));
+        return true;
+    }
+    false
+}
+
+fn paint_data_bar(p: &egui::Painter, rect: Rect, frac: f32, rgb: [u8; 3], gradient: bool) {
+    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);
         }
-        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),
+        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);
+    }
+}
+
+fn paint_checkbox(p: &egui::Painter, rect: Rect, z: f32, on: bool) {
+    let s = (11.0 * z * 1.2).clamp(8.0, 24.0);
+    let b = Rect::from_center_size(rect.center(), vec2(s, s));
+    let color = if on { Color32::from_rgb(0x10, 0x7C, 0x41) } else { Color32::WHITE };
+    p.rect_filled(b, 2.0, color);
+    p.rect_stroke(b, 2.0, Stroke::new(1.0, if on { color } 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);
+    }
+}
+
+fn text_overflows_cell(numeric: bool, value: &Value, rotation: i16, width: f32, rect_width: f32, pad: f32) -> bool {
+    !numeric && !matches!(value, Value::Number(_)) && rotation.abs() != 90 && width > rect_width - 2.0 * pad
+}
+
+fn should_expand_text(filter_space: f32, overflows: bool, across_end: u32, col: u32, in_merge: bool) -> bool {
+    filter_space == 0.0 && (overflows || across_end > col) && !in_merge
+}
+
+fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option<CfLook>), merges: &[RangeRef]) {
+    let (cell, rect, lk, cfl) = painted;
+    let c = *cell;
+    let p = q.painter;
+    let geo = q.geo;
+    let wb = q.workbook;
+    let si = q.sheet_index;
+    let sh = q.sheet;
+    let t = q.tokens;
+    let z = geo.z;
+    let (c0, c1) = q.cols;
+    let in_merge = |cell| merges.iter().find(|m| m.contains(cell)).copied();
+    let empty_ok = |cell| sh.value_ref(cell).is_none_or(Value::is_empty) && in_merge(cell).is_none();
+    if paint_cell_decorations(q, c, *rect, lk, cfl.as_ref()) {
+        return;
+    }
+    let v = sh.value(c);
+    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 cfl.as_ref().is_some_and(|l| l.hide_value) || v.is_empty() {
+        return;
+    }
+    // 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() {
+        return;
+    }
+    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 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 galley = p.layout_job(job);
         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,
+            HAlign::Center | HAlign::CenterAcross => rect.center().x,
+            HAlign::Right => rect.right() - pad,
             _ => 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 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);
+        return;
+    }
+    // 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));
         }
-        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));
+        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 = text_overflows_cell(numeric, &v, st.align.rotation, w, rect.width(), pad);
+    if should_expand_text(filter_space, overflows, across_end, c.col, in_merge(c).is_some()) {
+        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 st.font.strike {
-            cp.line_segment([pos2(x, y + gh * 0.55), pos2(x + w, y + gh * 0.55)], Stroke::new(1.0, color));
+        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);
+    }
+    paint_text_decorations(&cp, TextDecoration { x, y, width: w, height: gh, color, underline: st.font.underline, strike: st.font.strike });
+}
+
+struct TextDecoration {
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+    color: Color32,
+    underline: Underline,
+    strike: bool,
+}
+
+fn paint_text_decorations(p: &Painter, decoration: TextDecoration) {
+    let TextDecoration { x, y, width, height, color, underline, strike } = decoration;
+    let baseline = y + height * 0.82;
+    match underline {
+        Underline::None => {}
+        Underline::Double | Underline::DoubleAccounting => {
+            p.line_segment([pos2(x, baseline + 1.0), pos2(x + width, baseline + 1.0)], Stroke::new(1.0, color));
+            p.line_segment([pos2(x, baseline + 3.0), pos2(x + width, baseline + 3.0)], Stroke::new(1.0, color));
+        }
+        _ => {
+            p.line_segment([pos2(x, baseline + 1.0), pos2(x + width, baseline + 1.0)], Stroke::new(1.0, color));
+        }
+    }
+    if strike {
+        p.line_segment([pos2(x, y + height * 0.55), pos2(x + width, y + height * 0.55)], Stroke::new(1.0, color));
+    }
+}
+
+fn paint_borders(q: &mut QuadrantPaint<'_>, looks: &[(CellRef, Rect, Look, Option<CfLook>)], merges: &[RangeRef]) {
+    let p = q.painter;
+    let geo = q.geo;
+    let wb = q.workbook;
+    let si = q.sheet_index;
+    let sh = q.sheet;
+    let cf = &mut *q.cf;
+    let t = q.tokens;
+    let z = geo.z;
+    let (r0, r1) = q.rows;
+    let (c0, c1) = q.cols;
     // Borders (over fills and text).
-    for (c, rect, lk, _) in &looks {
+    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),
+            Some(m) => merged_edges(wb, si, sh, geo, MergedArea { m: *m, rect: *rect, rows: (r0, r1), cols: (c0, c1) }, cf),
             None => vec![
                 (b.top, [rect.left_top(), rect.right_top()]),
                 (b.bottom, [rect.left_bottom(), rect.right_bottom()]),
@@ -436,6 +566,14 @@ pub(crate) fn paint_quadrant(
             ));
         }
     }
+}
+
+fn paint_sparklines(q: &QuadrantPaint<'_>, range: RangeRef) {
+    let p = q.painter;
+    let geo = q.geo;
+    let wb = q.workbook;
+    let si = q.sheet_index;
+    let sh = q.sheet;
     // Sparklines.
     for sp in &sh.sparklines {
         if !range.contains(sp.cell) {
@@ -450,6 +588,12 @@ pub(crate) fn paint_quadrant(
         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);
     }
+}
+
+fn paint_filter_buttons(q: &QuadrantPaint<'_>, range: RangeRef) {
+    let p = q.painter;
+    let geo = q.geo;
+    let sh = q.sheet;
     // Filter buttons.
     let mut buttons: Vec<(CellRef, bool)> = Vec::new();
     if let Some(af) = &sh.autofilter {
diff --git a/crates/ui-egui/src/grid/selection.rs b/crates/ui-egui/src/grid/selection.rs
index 3b5339f61..3fbd081d6 100644
--- a/crates/ui-egui/src/grid/selection.rs
+++ b/crates/ui-egui/src/grid/selection.rs
@@ -3,7 +3,7 @@ use super::geo::Geo;
 use super::interact::{hidden_col_edge, hidden_row_edge};
 #[cfg(test)]
 use super::show::hidden_around;
-use super::*;
+use super::{CellRef, Color32, Painter, RangeRef, Rect, Sheet, SheetApp, Stroke, StrokeKind, Tokens, json, pos2, vec2};
 
 /// 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 {
@@ -78,18 +78,20 @@ pub(crate) fn outline_bands(rect: Rect, width: f32, clip: Rect) -> Vec<Rect> {
 }
 
 /// `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),
-) {
+pub(crate) struct SelectionPaintInput<'a> {
+    pub(crate) painter: &'a Painter,
+    pub(crate) geo: &'a Geo,
+    pub(crate) sheet: &'a Sheet,
+    pub(crate) selection: &'a gridcraft_engine::Selection,
+    pub(crate) outline: Rect,
+    pub(crate) tokens: &'a Tokens,
+    pub(crate) app: &'a SheetApp,
+    pub(crate) rows: (u32, u32),
+    pub(crate) cols: (u32, u32),
+}
+
+pub(crate) fn paint_selection(input: SelectionPaintInput<'_>) {
+    let SelectionPaintInput { painter: p, geo, sheet: sh, selection: sel, outline, tokens: t, app, rows, cols } = input;
     // 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);
diff --git a/crates/ui-egui/src/grid/show.rs b/crates/ui-egui/src/grid/show.rs
index 442a4722d..193d8dc73 100644
--- a/crates/ui-egui/src/grid/show.rs
+++ b/crates/ui-egui/src/grid/show.rs
@@ -1,12 +1,20 @@
+#[cfg(test)]
+use super::Trace;
 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::quadrant::{QuadrantPaint, mirror_painted, paint_quadrant};
+use super::selection::{SelectionPaintInput, paint_selection};
 use super::tables::{TableHeading, paint_filter_button, table_headings};
-use super::*;
+use super::{
+    Align2, Arc, CfCache, Color32, DISPLAY_SCALE, Drag, MAX_COLS, MAX_ROWS, Painter, PaneQuad, RangeRef, Rect, Sense, Sheet, SheetApp, Stroke,
+    StrokeKind, Tokens, WHEEL_ZOOM_IDLE, WheelZoom, Workbook, col_to_letters, heading_font_size, json, pos2, theme, vec2, wheel_zoom_step,
+    zoom_glide_step,
+};
+#[cfg(test)]
+use super::{CellRef, Pos2};
 
 pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
     let t = Tokens::get(ui.ctx());
@@ -106,22 +114,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
         }
         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);
-    }
+    update_zoom_glide(app, ui, place, sh.zoom, now);
     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 {
@@ -138,7 +131,148 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
     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 {
+    ActiveCellVisibility { app, wb: &wb, si, sh, selection: &sel, paper, make_geo: &make_geo }.update(&mut view, &mut geo);
+    // 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 outline = selection_outline(app, ui, &geo, sh, &sel, place, now);
+    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(
+            crate::paper_view::PagePaintInput {
+                app,
+                painter: &painter,
+                geo: &geo,
+                workbook: &wb,
+                sheet_index: si,
+                sheet: sh,
+                selection: &sel,
+                outline,
+                tokens: &t,
+            },
+            &mut cf,
+        )
+    } else {
+        paint_panes(
+            PanesInput { app, painter: &painter, geo: &geo, workbook: &wb, sheet_index: si, sheet: sh, selection: &sel, outline, tokens: &t },
+            &mut cf,
+        )
+    };
+    // 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(OverlayInput {
+        app,
+        ui,
+        painter: &painter.with_clip_rect(geo.cells),
+        geo: &geo,
+        workbook: &wb,
+        sheet_index: si,
+        sheet: sh,
+        selection: &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);
+    }
+    show_grid_interactions(app, ui, &resp, &geo, sh, &wb);
+    let track_x = vertical_scroll_track(available, rect, rtl);
+    // 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);
+    update_clipboard_repaint(app, ui, now);
+}
+
+fn vertical_scroll_track(available: Rect, grid: Rect, rtl: bool) -> (f32, f32) {
+    if rtl { (available.left(), grid.left()) } else { (grid.right(), available.right()) }
+}
+
+fn update_clipboard_repaint(app: &mut SheetApp, ui: &egui::Ui, now: f64) {
+    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));
+    }
+}
+
+struct ActiveCellVisibility<'a, F> {
+    app: &'a mut SheetApp,
+    wb: &'a Workbook,
+    si: usize,
+    sh: &'a Sheet,
+    selection: &'a gridcraft_engine::Selection,
+    paper: bool,
+    make_geo: &'a F,
+}
+
+fn selection_outline(
+    app: &mut SheetApp,
+    ui: &egui::Ui,
+    geo: &Geo,
+    sh: &Sheet,
+    sel: &gridcraft_engine::Selection,
+    place: (u64, usize),
+    now: f64,
+) -> Rect {
+    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();
+    }
+    outline
+}
+
+impl<F: Fn(&mut SheetApp, egui::Vec2) -> Geo> ActiveCellVisibility<'_, F> {
+    fn update(&mut self, view: &mut crate::SheetView, geo: &mut Geo) {
+        if !self.app.grid.ensure_visible {
+            return;
+        }
+        let app = &mut *self.app;
+        let wb = self.wb;
+        let si = self.si;
+        let sh = self.sh;
+        let sel = self.selection;
+        let paper = self.paper;
+
         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 };
@@ -151,8 +285,8 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
         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);
+            crate::paper_view::ensure_covers(app, wb, si, target);
+            *geo = (self.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);
@@ -184,69 +318,11 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
             view.scroll.x = before.x;
         }
         view.scroll = view.scroll.max(egui::Vec2::ZERO);
-        geo = make_geo(app, view.scroll);
+        *geo = (self.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.
+}
+
+fn show_grid_interactions(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet, wb: &Workbook) {
     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() {
@@ -258,48 +334,54 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
             app.grid.touch_pan = false;
         }
     } else {
-        crate::paper_view::interact(app, ui, &resp, &geo, sh, &wb);
-        interact(app, ui, &resp, &geo, sh, &wb);
+        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);
+    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);
+        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);
+    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);
+    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));
+    error_check_tag(app, ui, geo, sh);
+}
+
+fn update_zoom_glide(app: &mut SheetApp, ui: &egui::Ui, place: (u64, usize), zoom: u16, now: f64) {
+    let mut zooming = WheelZoom::at(app, place, 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();
+    }
+    if app.grid.wheel_zoom.is_some_and(|w| w.glide.is_some()) {
+        app.grid.wheel_zoom = Some(zooming);
     }
 }
 
 /// 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,
+struct PanesInput<'a> {
+    app: &'a SheetApp,
+    painter: &'a Painter,
+    geo: &'a Geo,
+    workbook: &'a Workbook,
+    sheet_index: usize,
+    sheet: &'a Sheet,
+    selection: &'a gridcraft_engine::Selection,
     outline: Rect,
-    cf: &mut CfCache,
-    t: &Tokens,
-) -> Vec<((u32, u32), (u32, u32), Rect)> {
+    tokens: &'a Tokens,
+}
+
+fn paint_panes(input: PanesInput<'_>, cf: &mut CfCache) -> Vec<PaneQuad> {
+    let PanesInput { app, painter, geo, workbook: wb, sheet_index: si, sheet: sh, selection: sel, outline, tokens: t } = input;
     // Quadrants: (rows, cols, clip).
     let (sr0, sr1) = geo.scroll_rows(sh);
     let (sc0, sc1) = geo.scroll_cols(sh);
@@ -321,8 +403,8 @@ fn paint_panes(
             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);
+        paint_quadrant(QuadrantPaint { painter: &p, geo, workbook: wb, sheet_index: si, sheet: sh, rows: *rows, cols: *cols, cf, tokens: t });
+        paint_selection(SelectionPaintInput { painter: &p, geo, sheet: sh, selection: sel, outline, tokens: t, app, rows: *rows, cols: *cols });
     }
     // Freeze lines.
     if geo.fr > 0 {
@@ -446,7 +528,7 @@ pub(crate) fn paint_headers(
     sh: &Sheet,
     sel: &gridcraft_engine::Selection,
     t: &Tokens,
-    quads: &[((u32, u32), (u32, u32), Rect)],
+    quads: &[PaneQuad],
     headings: &[TableHeading],
 ) {
     let font = theme::ui_font(heading_font_size(geo.z));
@@ -555,18 +637,20 @@ 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,
-) {
+pub(crate) struct OverlayInput<'a> {
+    app: &'a mut SheetApp,
+    ui: &'a egui::Ui,
+    painter: &'a Painter,
+    geo: &'a Geo,
+    workbook: &'a Workbook,
+    sheet_index: usize,
+    sheet: &'a Sheet,
+    selection: &'a gridcraft_engine::Selection,
+}
+
+pub(crate) fn paint_overlays(input: OverlayInput<'_>) {
+    let OverlayInput { app, ui, painter: p, geo, workbook: wb, sheet_index: si, sheet: sh, selection: sel } = input;
     // Validation dropdown arrow for the active cell.
     if app.editor.is_none()
         && let Some(r) = validation_arrow(sh, geo, sel.active)
@@ -762,7 +846,7 @@ mod trace_arrow_tests {
         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);
+            paint_overlays(OverlayInput { app, ui, painter: &p, geo: &geo, workbook: &wb, sheet_index: si, sheet: sh, selection: &sel });
         });
         // No renderer consumes the font atlas upload here.
         out.textures_delta.clear();
diff --git a/crates/ui-egui/src/grid/tables.rs b/crates/ui-egui/src/grid/tables.rs
index a283b2b22..7fca436a4 100644
--- a/crates/ui-egui/src/grid/tables.rs
+++ b/crates/ui-egui/src/grid/tables.rs
@@ -1,5 +1,5 @@
 use super::geo::Geo;
-use super::*;
+use super::{CellRef, Painter, Pos2, RangeRef, Rect, Sheet, Stroke, StrokeKind, Tokens, pos2, vec2};
 
 pub fn filter_button_rect(geo: &Geo, sh: &Sheet, c: CellRef) -> Rect {
     let rect = geo.cell_rect(sh, c);
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index 7ff863263..45c336f87 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -418,7 +418,7 @@ mod tests {
     }
 
     #[test]
-    fn tags_reduce_to_a_supported_language() {
+    fn tags_reduce_to_supported_languages() {
         assert_eq!(Language::from_tag("ja-JP"), Some(Language::Ja));
         assert_eq!(Language::from_tag("en_US"), Some(Language::En));
         assert_eq!(Language::from_tag("es_MX"), Some(Language::Es));
@@ -430,6 +430,10 @@ mod tests {
         assert_eq!(Language::from_tag("RU_ru"), Some(Language::Ru));
         assert_eq!(Language::from_tag("de-DE"), Some(Language::De));
         assert_eq!(Language::from_tag("de_AT"), Some(Language::De));
+    }
+
+    #[test]
+    fn tags_reduce_to_supported_languages_with_locale_suffixes() {
         assert_eq!(Language::from_tag("de-CH"), Some(Language::De));
         assert_eq!(Language::from_tag("pt-BR"), Some(Language::PtBr));
         assert_eq!(Language::parse("pt"), Some(Language::PtBr));
@@ -441,6 +445,10 @@ mod tests {
         assert_eq!(Language::from_tag("fr_CA"), Some(Language::Fr));
         assert_eq!(Language::parse("fr"), Some(Language::Fr));
         assert_eq!(Language::from_tag("sr-Latn-RS"), Some(Language::Sr));
+    }
+
+    #[test]
+    fn tags_reduce_to_other_supported_languages() {
         assert_eq!(Language::from_tag("sr-RS"), Some(Language::Sr));
         assert_eq!(Language::parse("sr"), Some(Language::Sr));
         assert_eq!(Language::from_tag("tr-TR"), Some(Language::Tr));
@@ -452,6 +460,10 @@ mod tests {
         assert_eq!(Language::from_tag("it-IT"), Some(Language::It));
         assert_eq!(Language::from_tag("it_CH.UTF-8"), Some(Language::It));
         assert_eq!(Language::parse("it"), Some(Language::It));
+    }
+
+    #[test]
+    fn tags_reduce_to_remaining_supported_languages() {
         assert_eq!(Language::from_tag("uk-XX"), Some(Language::Uk));
         assert_eq!(Language::parse("uk"), Some(Language::Uk));
         assert_eq!(Language::from_tag("vi-VN"), Some(Language::Vi));
@@ -463,7 +475,6 @@ mod tests {
         assert_eq!(Language::from_tag("ro_MD.UTF-8"), Some(Language::Ro));
         assert_eq!(Language::parse("ro"), Some(Language::Ro));
     }
-
     #[test]
     fn an_unset_language_preference_is_english_until_the_app_applies_the_system_one() {
         // Deserializing never reads the host locale (tests stay deterministic); the desktop app
diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index 385ed076b..071a537d8 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -175,10 +175,10 @@ impl G<'_> {
             self.p.circle_stroke(self.pt(x, y), r * self.s, Stroke::new(1.0, c));
         }
     }
-    fn text(&self, x: f32, y: f32, t: &str, size: f32, c: Color32, bold: bool, italic: bool) {
-        let fam = if bold {
+    fn text(&self, x: f32, y: f32, t: &str, size: f32, c: Color32, style: (bool, bool)) {
+        let fam = if style.0 {
             crate::theme::CELL_BOLD
-        } else if italic {
+        } else if style.1 {
             crate::theme::CELL_ITALIC
         } else {
             crate::theme::CELL
@@ -269,14 +269,14 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
             g.stroke(&[(8.0, 6.0), (8.0, 8.5), (5.0, 8.5), (5.0, 10.0)], c);
             g.rect(4.0, 10.0, 2.0, 4.5, Some(c), None);
         }
-        Icon::Bold => g.text(8.0, 8.5, "B", 12.0, c, true, false),
-        Icon::Italic => g.text(8.0, 8.5, "I", 12.0, c, false, true),
+        Icon::Bold => g.text(8.0, 8.5, "B", 12.0, c, (true, false)),
+        Icon::Italic => g.text(8.0, 8.5, "I", 12.0, c, (false, true)),
         Icon::Underline => {
-            g.text(8.0, 7.5, "U", 11.0, c, false, false);
+            g.text(8.0, 7.5, "U", 11.0, c, (false, false));
             g.stroke(&[(4.0, 14.0), (12.0, 14.0)], c);
         }
         Icon::Strike => {
-            g.text(8.0, 8.0, "ab", 10.0, c, false, false);
+            g.text(8.0, 8.0, "ab", 10.0, c, (false, false));
             g.stroke(&[(2.5, 8.5), (13.5, 8.5)], c);
         }
         Icon::Borders | Icon::BorderAll => {
@@ -311,47 +311,20 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
             g.circle(13.5, 10.0, 1.2, Some(c), None);
         }
         Icon::FontColor => {
-            g.text(8.0, 7.0, "A", 11.0, c, false, false);
+            g.text(8.0, 7.0, "A", 11.0, c, (false, false));
         }
-        Icon::AlignTop | Icon::AlignMiddle | Icon::AlignBottom => {
-            let ys: [f32; 3] = match icon {
-                Icon::AlignTop => [3.0, 5.5, 8.0],
-                Icon::AlignMiddle => [5.5, 8.0, 10.5],
-                _ => [8.0, 10.5, 13.0],
-            };
-            let edge = match icon {
-                Icon::AlignTop => 1.5,
-                Icon::AlignMiddle => -1.0,
-                _ => 14.5,
-            };
-            if edge > 0.0 {
-                g.stroke(&[(2.0, edge), (14.0, edge)], light);
-            }
-            for (i, y) in ys.iter().enumerate() {
-                let w = if i == 1 { 8.0 } else { 10.0 };
-                g.stroke(&[(8.0 - w / 2.0, *y), (8.0 + w / 2.0, *y)], c);
-            }
-        }
-        Icon::AlignLeft | Icon::AlignCenter | Icon::AlignRight | Icon::IndentDec | Icon::IndentInc => {
-            for (i, y) in [3.5f32, 6.5, 9.5, 12.5].iter().enumerate() {
-                let w = if i % 2 == 0 { 12.0 } else { 8.0 };
-                let (x0, x1) = match icon {
-                    Icon::AlignLeft => (2.0, 2.0 + w),
-                    Icon::AlignRight => (14.0 - w, 14.0),
-                    Icon::AlignCenter => (8.0 - w / 2.0, 8.0 + w / 2.0),
-                    _ => (if i == 0 || i == 3 { 2.0 } else { 7.0 }, 14.0),
-                };
-                g.stroke(&[(x0, *y), (x1, *y)], c);
-            }
-            if icon == Icon::IndentInc {
-                g.poly(&[(2.0, 6.0), (5.0, 8.0), (2.0, 10.0)], blue);
-            }
-            if icon == Icon::IndentDec {
-                g.poly(&[(5.0, 6.0), (2.0, 8.0), (5.0, 10.0)], blue);
-            }
+        Icon::AlignTop
+        | Icon::AlignMiddle
+        | Icon::AlignBottom
+        | Icon::AlignLeft
+        | Icon::AlignCenter
+        | Icon::AlignRight
+        | Icon::IndentDec
+        | Icon::IndentInc => {
+            paint_alignment(&g, icon, c, light, blue);
         }
         Icon::Orientation => {
-            g.text(6.0, 9.0, "ab", 8.5, c, false, false);
+            g.text(6.0, 9.0, "ab", 8.5, c, (false, false));
             g.stroke(&[(9.0, 13.0), (14.0, 3.0)], blue);
             g.poly(&[(14.5, 2.0), (12.0, 4.0), (14.6, 5.2)], blue);
         }
@@ -373,18 +346,18 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
             g.poly(&[(3.0, 8.0), (5.5, 6.5), (5.5, 9.5)], blue);
             g.poly(&[(13.0, 8.0), (10.5, 6.5), (10.5, 9.5)], blue);
         }
-        Icon::Currency => g.text(8.0, 8.5, "$", 12.0, c, false, false),
-        Icon::Percent => g.text(8.0, 8.5, "%", 11.0, c, false, false),
-        Icon::Comma => g.text(8.0, 7.0, ",", 14.0, c, true, false),
+        Icon::Currency => g.text(8.0, 8.5, "$", 12.0, c, (false, false)),
+        Icon::Percent => g.text(8.0, 8.5, "%", 11.0, c, (false, false)),
+        Icon::Comma => g.text(8.0, 7.0, ",", 14.0, c, (true, false)),
         Icon::DecInc => {
-            g.text(5.0, 5.0, ".0", 6.5, c, false, false);
-            g.text(10.0, 11.0, ".00", 6.5, c, false, false);
+            g.text(5.0, 5.0, ".0", 6.5, c, (false, false));
+            g.text(10.0, 11.0, ".00", 6.5, c, (false, false));
             g.stroke(&[(2.0, 12.0), (5.0, 12.0)], blue);
             g.poly(&[(1.0, 12.0), (2.8, 10.6), (2.8, 13.4)], blue);
         }
         Icon::DecDec => {
-            g.text(6.0, 5.0, ".00", 6.5, c, false, false);
-            g.text(11.0, 11.0, ".0", 6.5, c, false, false);
+            g.text(6.0, 5.0, ".00", 6.5, c, (false, false));
+            g.text(11.0, 11.0, ".0", 6.5, c, (false, false));
             g.stroke(&[(2.0, 12.0), (5.5, 12.0)], blue);
             g.poly(&[(7.0, 12.0), (5.2, 10.6), (5.2, 13.4)], blue);
         }
@@ -427,7 +400,7 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
                 }
             }
         }
-        Icon::Sum => g.text(8.0, 8.0, "Σ", 13.0, c, false, false),
+        Icon::Sum => g.text(8.0, 8.0, "Σ", 13.0, c, (false, false)),
         Icon::FillDown => {
             g.rect(4.0, 2.0, 8.0, 12.0, Some(paper), Some(light));
             g.stroke(&[(8.0, 4.0), (8.0, 11.0)], blue);
@@ -438,8 +411,8 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
             g.poly(&[(8.0, 4.0), (10.5, 1.5), (14.5, 5.5), (12.0, 8.0)], red);
         }
         Icon::SortFilter => {
-            g.text(4.5, 4.5, "A", 6.0, c, false, false);
-            g.text(4.5, 11.5, "Z", 6.0, c, false, false);
+            g.text(4.5, 4.5, "A", 6.0, c, (false, false));
+            g.text(4.5, 11.5, "Z", 6.0, c, (false, false));
             g.stroke(&[(8.0, 3.0), (8.0, 13.0)], blue);
             g.poly(&[(6.5, 11.0), (9.5, 11.0), (8.0, 13.5)], blue);
             g.poly(&[(10.0, 3.0), (15.0, 3.0), (13.0, 7.5), (13.0, 12.0), (12.0, 11.0), (12.0, 7.5)], light);
@@ -492,7 +465,7 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
             g.rect(2.0, 2.0, 12.0, 12.0, None, Some(c));
             g.line(&[(4.5, 8.0), (7.0, 10.5), (11.5, 5.0)], c, 1.4);
         }
-        Icon::Fx => g.text(8.0, 8.0, "fx", 10.5, c, false, true),
+        Icon::Fx => g.text(8.0, 8.0, "fx", 10.5, c, (false, true)),
         Icon::Plus => {
             g.line(&[(8.0, 3.0), (8.0, 13.0)], c, 1.3);
             g.line(&[(3.0, 8.0), (13.0, 8.0)], c, 1.3);
@@ -564,13 +537,13 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
         }
         Icon::TextBox => {
             g.rect(2.0, 3.0, 12.0, 10.0, None, Some(c));
-            g.text(8.0, 8.0, "A", 8.0, c, false, false);
+            g.text(8.0, 8.0, "A", 8.0, c, (false, false));
         }
-        Icon::Symbol => g.text(8.0, 8.0, "Ω", 12.0, c, false, false),
-        Icon::Function => g.text(8.0, 8.0, "fx", 11.0, c, false, true),
+        Icon::Symbol => g.text(8.0, 8.0, "Ω", 12.0, c, (false, false)),
+        Icon::Function => g.text(8.0, 8.0, "fx", 11.0, c, (false, true)),
         Icon::Name => {
             g.rect(1.5, 4.0, 13.0, 8.0, None, Some(c));
-            g.text(8.0, 8.0, "ab", 8.0, c, false, false);
+            g.text(8.0, 8.0, "ab", 8.0, c, (false, false));
         }
         Icon::Trace => {
             g.circle(4.0, 12.0, 1.6, Some(blue), None);
@@ -588,8 +561,8 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
         Icon::Filter => g.poly(&[(2.0, 3.0), (14.0, 3.0), (9.5, 8.5), (9.5, 13.5), (6.5, 12.0), (6.5, 8.5)], c),
         Icon::SortAsc | Icon::SortDesc => {
             let (a, b) = if icon == Icon::SortAsc { ("A", "Z") } else { ("Z", "A") };
-            g.text(5.0, 4.5, a, 6.5, c, false, false);
-            g.text(5.0, 11.5, b, 6.5, c, false, false);
+            g.text(5.0, 4.5, a, 6.5, c, (false, false));
+            g.text(5.0, 11.5, b, 6.5, c, (false, false));
             g.stroke(&[(11.0, 2.5), (11.0, 13.0)], blue);
             g.poly(&[(9.0, 11.0), (13.0, 11.0), (11.0, 14.0)], blue);
         }
@@ -614,9 +587,9 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
                 g.stroke(&[(7.0, y), (14.0, y)], light);
             }
             match icon {
-                Icon::Group => g.text(3.0, 2.5, "+", 6.0, blue, true, false),
-                Icon::Ungroup => g.text(3.0, 2.5, "−", 6.0, blue, true, false),
-                _ => g.text(11.0, 13.0, "Σ", 6.0, blue, false, false),
+                Icon::Group => g.text(3.0, 2.5, "+", 6.0, blue, (true, false)),
+                Icon::Ungroup => g.text(3.0, 2.5, "−", 6.0, blue, (true, false)),
+                _ => g.text(11.0, 13.0, "Σ", 6.0, blue, (false, false)),
             }
         }
         Icon::Lock => {
@@ -624,7 +597,7 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) {
             g.line(&[(5.5, 7.0), (5.5, 4.5), (8.0, 2.5), (10.5, 4.5), (10.5, 7.0)], c, 1.2);
         }
         Icon::Spell => {
-            g.text(7.0, 6.0, "abc", 7.0, c, false, false);
+            g.text(7.0, 6.0, "abc", 7.0, c, (false, false));
             g.line(&[(4.0, 11.0), (6.5, 13.5), (12.0, 8.5)], green, 1.4);
         }
         Icon::Freeze => {
@@ -798,3 +771,42 @@ pub const LIBRARY: &[(&str, Icon)] = &[
 pub fn from_name(name: &str) -> Option<Icon> {
     LIBRARY.iter().find(|(n, _)| n.eq_ignore_ascii_case(name)).map(|(_, i)| *i)
 }
+
+fn paint_alignment(g: &G<'_>, icon: Icon, c: Color32, light: Color32, blue: Color32) {
+    if matches!(icon, Icon::AlignTop | Icon::AlignMiddle | Icon::AlignBottom) {
+        let ys: [f32; 3] = match icon {
+            Icon::AlignTop => [3.0, 5.5, 8.0],
+            Icon::AlignMiddle => [5.5, 8.0, 10.5],
+            _ => [8.0, 10.5, 13.0],
+        };
+        let edge = match icon {
+            Icon::AlignTop => 1.5,
+            Icon::AlignMiddle => -1.0,
+            _ => 14.5,
+        };
+        if edge > 0.0 {
+            g.stroke(&[(2.0, edge), (14.0, edge)], light);
+        }
+        for (i, y) in ys.iter().enumerate() {
+            let w = if i == 1 { 8.0 } else { 10.0 };
+            g.stroke(&[(8.0 - w / 2.0, *y), (8.0 + w / 2.0, *y)], c);
+        }
+    } else {
+        for (i, y) in [3.5f32, 6.5, 9.5, 12.5].iter().enumerate() {
+            let w = if i % 2 == 0 { 12.0 } else { 8.0 };
+            let (x0, x1) = match icon {
+                Icon::AlignLeft => (2.0, 2.0 + w),
+                Icon::AlignRight => (14.0 - w, 14.0),
+                Icon::AlignCenter => (8.0 - w / 2.0, 8.0 + w / 2.0),
+                _ => (if i == 0 || i == 3 { 2.0 } else { 7.0 }, 14.0),
+            };
+            g.stroke(&[(x0, *y), (x1, *y)], c);
+        }
+        if icon == Icon::IndentInc {
+            g.poly(&[(2.0, 6.0), (5.0, 8.0), (2.0, 10.0)], blue);
+        }
+        if icon == Icon::IndentDec {
+            g.poly(&[(5.0, 6.0), (2.0, 8.0), (5.0, 10.0)], blue);
+        }
+    }
+}
diff --git a/crates/ui-egui/src/keymap.rs b/crates/ui-egui/src/keymap.rs
index 54058dd71..ea5daf33c 100644
--- a/crates/ui-egui/src/keymap.rs
+++ b/crates/ui-egui/src/keymap.rs
@@ -60,15 +60,47 @@ fn borders(preset: &str) -> Shortcut {
 pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Option<Shortcut> {
     use Key::*;
     let navigation = matches!(key, ArrowLeft | ArrowRight | ArrowUp | ArrowDown | PageUp | PageDown | Home | End | Insert | Delete);
-    let k = if navigation { key } else { physical.unwrap_or(key) };
-    // Control itself (Excel for Mac also uses Control for these), Ctrl on Windows / Cmd on Mac,
-    // and Alt/Option alone.
-    let ctrl = m.ctrl && !m.alt;
-    let cmd = m.command && !m.alt;
-    let alt = m.alt && !m.ctrl && !m.command;
-    let ctrl_alt = m.alt && (m.ctrl || m.command);
-    let plain = !m.ctrl && !m.command && !m.alt;
-    let s = m.shift;
+    let key = if navigation { key } else { physical.unwrap_or(key) };
+    let ctx = LookupContext {
+        key,
+        modifiers: m,
+        ctrl: m.ctrl && !m.alt,
+        cmd: m.command && !m.alt,
+        alt: m.alt && !m.ctrl && !m.command,
+        ctrl_alt: m.alt && (m.ctrl || m.command),
+        plain: !m.ctrl && !m.command && !m.alt,
+        shift: m.shift,
+        mac,
+    };
+    lookup_number_formats(ctx)
+        .or_else(|| lookup_control_shortcuts(ctx))
+        .or_else(|| lookup_windows_shortcuts(ctx))
+        .or_else(|| lookup_platform_letters(ctx))
+        .or_else(|| lookup_selection_shortcuts(ctx))
+        .or_else(|| lookup_control_alt_shortcuts(ctx))
+        .or_else(|| lookup_alt_shortcuts(ctx))
+        .or_else(|| lookup_function_shortcuts(ctx))
+}
+
+#[derive(Clone, Copy)]
+struct LookupContext {
+    key: Key,
+    modifiers: Modifiers,
+    ctrl: bool,
+    cmd: bool,
+    alt: bool,
+    ctrl_alt: bool,
+    plain: bool,
+    shift: bool,
+    mac: bool,
+}
+
+fn lookup_number_formats(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
     Some(match k {
         // Ctrl+Shift+~ ! @ # $ % ^ & _ : number formats and borders (Windows and Mac).
         Backtick if ctrl && s => Shortcut::Run("home.numberFormat", json!({"format": "General"})),
@@ -89,9 +121,31 @@ pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Optio
         OpenBracket if ctrl => Shortcut::Run("formulas.selectPrecedents", json!({"all": true})),
         CloseBracket if ctrl && !s => run("formulas.selectDependents"),
         CloseBracket if ctrl => Shortcut::Run("formulas.selectDependents", json!({"all": true})),
+        _ => return None,
+    })
+}
+
+fn lookup_control_shortcuts(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Windows Ctrl+; is in `ribbon::shortcut`; Excel for Mac uses Control+; and Command+;.
         Semicolon if mac && ctrl => Shortcut::Date,
         Semicolon if mac && cmd && !s => Shortcut::Time,
+        _ => return None,
+    })
+}
+
+fn lookup_windows_shortcuts(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Ctrl+2..5 (Windows).
         Num2 if ctrl && !mac => run("home.bold"),
         Num3 if ctrl && !mac => run("home.italic"),
@@ -99,6 +153,17 @@ pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Optio
         Num5 if ctrl && !mac => run("home.strikethrough"),
         // Ctrl+6 hides and shows objects (Windows, and Control+6 in Excel for Mac).
         Num6 if ctrl && !s => run("view.showObjects"),
+        _ => return None,
+    })
+}
+
+fn lookup_platform_letters(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Letters that differ between Windows and Mac.
         L if (cmd || ctrl) && s => run("data.filter"),
         L if cmd && mac => run("home.alignLeft"),
@@ -119,6 +184,17 @@ pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Optio
         Period if cmd && s => run("home.increaseFontSize"),
         Comma if cmd && s => run("home.decreaseFontSize"),
         Space if cmd && s => run("edit.selectAll"),
+        _ => return None,
+    })
+}
+
+fn lookup_selection_shortcuts(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Shift+Space selects the row; Ctrl+Space (Windows) / Control+Space (Excel for Mac) the
         // column. Cmd+Space stays free: it is the macOS Spotlight shortcut.
         Space if plain && s => run("selection.row"),
@@ -127,6 +203,17 @@ pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Optio
         Home if cmd && s => Shortcut::ExtendToStart,
         End if cmd && s => Shortcut::ExtendToEnd,
         Home if plain && s => Shortcut::ExtendToRowStart,
+        _ => return None,
+    })
+}
+
+fn lookup_control_alt_shortcuts(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Ctrl+Alt / Cmd+Option combinations.
         V if ctrl_alt || (mac && m.ctrl && m.command) => Shortcut::Dialog("pasteSpecial", json!({})),
         Equals | Plus if ctrl_alt => Shortcut::Zoom(10),
@@ -139,6 +226,17 @@ pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Optio
         ArrowRight if ctrl_alt && mac => borders("right"),
         ArrowUp if ctrl_alt && mac => borders("top"),
         ArrowDown if ctrl_alt && mac => borders("bottom"),
+        _ => return None,
+    })
+}
+
+fn lookup_alt_shortcuts(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Alt / Option alone.
         Equals if alt && !s && !mac => run("formulas.autoSum"),
         ArrowDown if alt && !s => Shortcut::DropDown,
@@ -151,6 +249,17 @@ pub fn lookup(key: Key, physical: Option<Key>, m: Modifiers, mac: bool) -> Optio
         F1 if alt && s => run("home.insertSheet"),
         F1 if alt => run("insert.chart"),
         F10 if alt && s => Shortcut::Dialog("errorChecking", json!({})),
+        _ => return None,
+    })
+}
+
+fn lookup_function_shortcuts(ctx: LookupContext) -> Option<Shortcut> {
+    use Key::*;
+    let LookupContext { key: k, ctrl, cmd, alt, ctrl_alt, plain, shift: s, mac, .. } = ctx;
+    let _ = (ctrl, cmd, alt, ctrl_alt, plain, s, mac);
+    let m = ctx.modifiers;
+    let _ = m;
+    Some(match k {
         // Function keys.
         F1 if cmd && !s => run("view.collapseRibbon"),
         F2 if (cmd || ctrl) && s => Shortcut::Dialog("comment", json!({"threaded": true})),
diff --git a/crates/ui-egui/src/paper_view.rs b/crates/ui-egui/src/paper_view.rs
index 70a3f0e25..f444b6ac2 100644
--- a/crates/ui-egui/src/paper_view.rs
+++ b/crates/ui-egui/src/paper_view.rs
@@ -120,19 +120,20 @@ fn pages_iter(geo: &Geo, pg: &PageGrid) -> impl Iterator<Item = (usize, usize)>
 }
 
 /// Paints the desk, the pages and their cells; returns the per-page quadrants for the headings.
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn paint_pages(
-    app: &SheetApp,
-    p: &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)> {
+pub(crate) struct PagePaintInput<'a> {
+    pub(crate) app: &'a SheetApp,
+    pub(crate) painter: &'a Painter,
+    pub(crate) geo: &'a Geo,
+    pub(crate) workbook: &'a Workbook,
+    pub(crate) sheet_index: usize,
+    pub(crate) sheet: &'a Sheet,
+    pub(crate) selection: &'a gridcraft_engine::Selection,
+    pub(crate) outline: Rect,
+    pub(crate) tokens: &'a Tokens,
+}
+
+pub(crate) fn paint_pages(input: PagePaintInput<'_>, cf: &mut CfCache) -> Vec<grid::PaneQuad> {
+    let PagePaintInput { app, painter: p, geo, workbook: wb, sheet_index: si, sheet: sh, selection: sel, outline, tokens: t } = input;
     let mut quads = Vec::new();
     let Some(pg) = geo.paper.clone() else { return quads };
     p.rect_filled(geo.cells, 0.0, t.desk);
@@ -161,7 +162,7 @@ pub(crate) fn paint_pages(
         }
         painted += 1;
         let pc = p.with_clip_rect(clip);
-        grid::paint_quadrant(&pc, geo, wb, si, sh, rows, cols, cf, t);
+        grid::paint_quadrant(grid::QuadrantPaint { painter: &pc, geo, workbook: wb, sheet_index: si, sheet: sh, rows, cols, cf, tokens: t });
         if !pg.is_data_page(i, j) {
             // "Click to add data" pages: faded until something is typed there.
             pc.rect_filled(clip, 0.0, t.grid_bg.gamma_multiply(0.75));
@@ -170,7 +171,17 @@ pub(crate) fn paint_pages(
         }
         // The selection outline may straddle the margin edge (as at A1 in Normal view).
         let sel_clip = clip.expand(3.0).intersect(page).intersect(geo.cells);
-        grid::paint_selection(&p.with_clip_rect(sel_clip), geo, sh, sel, outline, t, app, rows, cols);
+        grid::paint_selection(grid::SelectionPaintInput {
+            painter: &p.with_clip_rect(sel_clip),
+            geo,
+            sheet: sh,
+            selection: sel,
+            outline,
+            tokens: t,
+            app,
+            rows,
+            cols,
+        });
     }
     quads
 }
diff --git a/crates/ui-egui/src/ribbon/automate.rs b/crates/ui-egui/src/ribbon/automate.rs
index 5a9de6b50..e994b997f 100644
--- a/crates/ui-egui/src/ribbon/automate.rs
+++ b/crates/ui-egui/src/ribbon/automate.rs
@@ -1,5 +1,5 @@
 use super::controls::control_keytip;
-use super::*;
+use super::{Icon, SheetApp, Ui, big_button, json};
 
 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() {
diff --git a/crates/ui-egui/src/ribbon/contextual.rs b/crates/ui-egui/src/ribbon/contextual.rs
index 497480191..469e76cf0 100644
--- a/crates/ui-egui/src/ribbon/contextual.rs
+++ b/crates/ui-egui/src/ribbon/contextual.rs
@@ -1,6 +1,6 @@
 use super::controls::{act, anchor_keytip, control_keytip, keytip, menu_items, sep};
 use super::galleries::{paint_table_swatch, table_gallery};
-use super::*;
+use super::{Color32, Icon, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, big_button, icon_button, json, keytip_table, vec2};
 
 /// 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) {
diff --git a/crates/ui-egui/src/ribbon/controls.rs b/crates/ui-egui/src/ribbon/controls.rs
index 88091de3e..774a2b40b 100644
--- a/crates/ui-egui/src/ribbon/controls.rs
+++ b/crates/ui-egui/src/ribbon/controls.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Rect, Sense, SheetApp, Stroke, StrokeKind, Style, Tokens, Ui, keytip_table, pos2, theme, vec2};
 
 pub(super) fn sep(ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
@@ -98,7 +98,7 @@ pub(crate) fn editable_combo(
     items: &[(&str, String)],
     forced: bool,
 ) -> ComboResult {
-    combo_popup(ui, anchor, salt, current_value, items, forced, true, None)
+    combo_popup(ui, anchor, salt, current_value, items, ComboPopupOptions { forced, filter: true, under: None })
 }
 
 /// The dropdown of [`editable_combo`] without the filter field: the whole list, picked by click or
@@ -112,7 +112,7 @@ pub(super) fn list_combo(
     current_value: &str,
     items: &[(&str, String)],
 ) -> ComboResult {
-    combo_popup(ui, anchor, salt, current_value, items, false, false, Some(under))
+    combo_popup(ui, anchor, salt, current_value, items, ComboPopupOptions { forced: false, filter: false, under: Some(under) })
 }
 
 /// What the header of a combo popup hands to its list: the rows to show and the highlighted one.
@@ -124,6 +124,12 @@ struct ComboHead {
     enter: bool,
 }
 
+struct ComboPopupOptions {
+    forced: bool,
+    filter: bool,
+    under: Option<Rect>,
+}
+
 /// 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 {
@@ -202,10 +208,9 @@ fn combo_popup(
     salt: &'static str,
     current_value: &str,
     items: &[(&str, String)],
-    forced: bool,
-    filter: bool,
-    under: Option<Rect>,
+    options: ComboPopupOptions,
 ) -> ComboResult {
+    let ComboPopupOptions { forced, filter, under } = options;
     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();
diff --git a/crates/ui-egui/src/ribbon/data.rs b/crates/ui-egui/src/ribbon/data.rs
index 52f6669f0..1cecdb2db 100644
--- a/crates/ui-egui/src/ribbon/data.rs
+++ b/crates/ui-egui/src/ribbon/data.rs
@@ -1,5 +1,5 @@
 use super::controls::{act, control_keytip, keytip, menu_items, sep};
-use super::*;
+use super::{Icon, SheetApp, Ui, big_button, json, keytip_table, small_button};
 
 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);
diff --git a/crates/ui-egui/src/ribbon/formulas.rs b/crates/ui-egui/src/ribbon/formulas.rs
index caac2da01..4f757bdac 100644
--- a/crates/ui-egui/src/ribbon/formulas.rs
+++ b/crates/ui-egui/src/ribbon/formulas.rs
@@ -1,6 +1,6 @@
 use super::controls::{act, anchor_keytip, control_keytip, invoke, keytip, menu_items, popup_command, sep};
 use super::home::autosum_menu;
-use super::*;
+use super::{Icon, SheetApp, Ui, big_button, big_split_button, json, keytip_table, small_button, small_split_button};
 
 /// How many cells Formulas › Error Checking › Circular References lists.
 const CIRCULAR_MENU_LIMIT: usize = 100;
diff --git a/crates/ui-egui/src/ribbon/galleries.rs b/crates/ui-egui/src/ribbon/galleries.rs
index 085ba0dc5..6aa5bcd6b 100644
--- a/crates/ui-egui/src/ribbon/galleries.rs
+++ b/crates/ui-egui/src/ribbon/galleries.rs
@@ -1,5 +1,5 @@
 use super::controls::act;
-use super::*;
+use super::{Align2, Cat, Rect, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, json, pos2, theme, vec2};
 
 /// A gallery of table styles drawn as mini tables.
 pub(super) fn table_gallery(app: &mut SheetApp, ui: &mut Ui, cmd: &str) {
diff --git a/crates/ui-egui/src/ribbon/home.rs b/crates/ui-egui/src/ribbon/home.rs
index b6886b02c..72fce56cb 100644
--- a/crates/ui-egui/src/ribbon/home.rs
+++ b/crates/ui-egui/src/ribbon/home.rs
@@ -3,7 +3,10 @@ use super::controls::{
     theme_colors,
 };
 use super::galleries::{cell_style_gallery, table_gallery};
-use super::*;
+use super::{
+    HAlign, Icon, Key, Modifiers, Rect, SheetApp, Style, Tokens, Ui, VAlign, big_button, color_palette, icon_button, json, keytip_table,
+    small_button, split_button, theme, toggle_button, vec2,
+};
 
 /// The Accounting Number Format dropdown: label and the code Excel applies for that symbol.
 const ACCOUNTING_SYMBOLS: &[(&str, &str)] = &[
diff --git a/crates/ui-egui/src/ribbon/insert.rs b/crates/ui-egui/src/ribbon/insert.rs
index 9319b23c5..63f61f755 100644
--- a/crates/ui-egui/src/ribbon/insert.rs
+++ b/crates/ui-egui/src/ribbon/insert.rs
@@ -1,5 +1,5 @@
 use super::controls::{act, anchor_keytip, control_keytip, invoke, popup_command, sep};
-use super::*;
+use super::{Icon, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, big_button, icons, json, small_button, vec2};
 
 /// 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) {
diff --git a/crates/ui-egui/src/ribbon/page_layout.rs b/crates/ui-egui/src/ribbon/page_layout.rs
index b8651b0f4..c0f5230ef 100644
--- a/crates/ui-egui/src/ribbon/page_layout.rs
+++ b/crates/ui-egui/src/ribbon/page_layout.rs
@@ -1,5 +1,5 @@
 use super::controls::{act, anchor_keytip, checkbox_on, control_keytip, invoke, keytip, menu_items, sep};
-use super::*;
+use super::{Color32, Icon, Sense, SheetApp, Tokens, Ui, big_button, json, keytip_table, vec2};
 
 pub(super) fn page_layout(app: &mut SheetApp, ui: &mut Ui) {
     let th = big_button(ui, Icon::Theme, "Themes", "Themes", true);
diff --git a/crates/ui-egui/src/ribbon/review.rs b/crates/ui-egui/src/ribbon/review.rs
index c8998531e..2f76148ed 100644
--- a/crates/ui-egui/src/ribbon/review.rs
+++ b/crates/ui-egui/src/ribbon/review.rs
@@ -1,5 +1,5 @@
 use super::controls::{act, anchor_keytip, control_keytip, menu_items, sep};
-use super::*;
+use super::{Icon, SheetApp, Stroke, StrokeKind, Tokens, Ui, big_button, json, small_button};
 
 pub(super) fn review(app: &mut SheetApp, ui: &mut Ui) {
     let __k = big_button(ui, Icon::Spell, "Spelling", "Spelling (F7)", false);
diff --git a/crates/ui-egui/src/ribbon/shortcuts.rs b/crates/ui-egui/src/ribbon/shortcuts.rs
index 7edf4c58c..3072693b3 100644
--- a/crates/ui-egui/src/ribbon/shortcuts.rs
+++ b/crates/ui-egui/src/ribbon/shortcuts.rs
@@ -1,4 +1,4 @@
-use super::*;
+use super::{Key, Modifiers, SheetApp, json};
 
 /// Command-key shortcuts when the grid has focus.
 pub fn shortcut(app: &mut SheetApp, key: Key, m: Modifiers) {
diff --git a/crates/ui-egui/src/ribbon/title_bar.rs b/crates/ui-egui/src/ribbon/title_bar.rs
index eb243149f..9f7c2197b 100644
--- a/crates/ui-egui/src/ribbon/title_bar.rs
+++ b/crates/ui-egui/src/ribbon/title_bar.rs
@@ -1,5 +1,5 @@
 use super::controls::{act, control_keytip};
-use super::*;
+use super::{Color32, Icon, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, icon_button, json, pos2, small_button, theme, theme_choices, vec2};
 
 /// 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
diff --git a/crates/ui-egui/src/ribbon/view.rs b/crates/ui-egui/src/ribbon/view.rs
index c21134791..34fa582ea 100644
--- a/crates/ui-egui/src/ribbon/view.rs
+++ b/crates/ui-egui/src/ribbon/view.rs
@@ -1,5 +1,5 @@
 use super::controls::{act, checkbox_on, control_keytip, invoke, keytip, menu_items, popup_command, sep};
-use super::*;
+use super::{Icon, Rect, SheetApp, Tokens, Ui, big_button, json, keytip_table, pos2, theme, vec2};
 
 /// 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) {
diff --git a/crates/ui-egui/src/services.rs b/crates/ui-egui/src/services.rs
index 1e6455860..748e23ab3 100644
--- a/crates/ui-egui/src/services.rs
+++ b/crates/ui-egui/src/services.rs
@@ -1,4 +1,10 @@
-use super::*;
+use super::printing;
+
+type PickSave = Box<dyn Fn(&str) -> Option<String>>;
+type OpenUrl = Box<dyn Fn(&str)>;
+type CopyHtml = Box<dyn FnMut(&str, &str) -> Result<(), String>>;
+type Download = Box<dyn Fn(&str, &[u8])>;
+type PrintPdf = Box<dyn Fn(&[u8])>;
 
 /// Host services the platform shell provides (file pickers, opening URLs).
 #[derive(Default)]
@@ -8,16 +14,16 @@ pub struct Services {
     /// 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>>>,
+    pub pick_save: Option<PickSave>,
     /// 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)>>,
+    pub open_url: Option<OpenUrl>,
     /// 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>>>,
+    pub copy_html: Option<CopyHtml>,
     /// 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.
@@ -27,14 +33,14 @@ pub struct Services {
     /// 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])>>,
+    pub download: Option<Download>,
     /// 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])>>,
+    pub print: Option<PrintPdf>,
 }
 
 /// Shared queue of files read asynchronously (browser file picker, drag and drop).
diff --git a/crates/ui-egui/src/theme/font_fallback.rs b/crates/ui-egui/src/theme/font_fallback.rs
index 940a871d5..1f5d70150 100644
--- a/crates/ui-egui/src/theme/font_fallback.rs
+++ b/crates/ui-egui/src/theme/font_fallback.rs
@@ -1,7 +1,9 @@
+#[cfg(not(target_arch = "wasm32"))]
+use super::Arc;
+use super::FontDefinitions;
 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
diff --git a/crates/ui-egui/src/theme/font_setup.rs b/crates/ui-egui/src/theme/font_setup.rs
index 749079e71..916ba4026 100644
--- a/crates/ui-egui/src/theme/font_setup.rs
+++ b/crates/ui-egui/src/theme/font_setup.rs
@@ -1,5 +1,7 @@
+#[cfg(not(target_arch = "wasm32"))]
+use super::Blob;
 use super::font_fallback::load_fallback;
-use super::*;
+use super::{Arc, Color32, FontData, FontDefinitions, FontFamily, FontId};
 
 /// 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
diff --git a/crates/ui-egui/src/theme/tests.rs b/crates/ui-egui/src/theme/tests.rs
index b8ad4416e..38cbbd257 100644
--- a/crates/ui-egui/src/theme/tests.rs
+++ b/crates/ui-egui/src/theme/tests.rs
@@ -183,7 +183,8 @@ fn fallback_covers_its_script() {
     // 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] = [
+    type Case = (&'static str, Vec<(String, u32)>, &'static str);
+    let cases: [Case; 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.
diff --git a/crates/xlsx/src/passthrough.rs b/crates/xlsx/src/passthrough.rs
index 04f757d3a..3e2fea105 100644
--- a/crates/xlsx/src/passthrough.rs
+++ b/crates/xlsx/src/passthrough.rs
@@ -50,7 +50,7 @@ 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};
+pub use write::{KeptOut, SheetIds, WorkbookKept, workbook_elements, write_package_rels, write_workbook};
 
 /// Most bytes kept for one workbook.
 pub const MAX_KEPT_TOTAL: usize = 256 * 1024 * 1024;
diff --git a/crates/xlsx/src/pivot/read.rs b/crates/xlsx/src/pivot/read.rs
index f811533ab..134a8ab22 100644
--- a/crates/xlsx/src/pivot/read.rs
+++ b/crates/xlsx/src/pivot/read.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CellRef, Ctx, DateSystem, El, HashMap, IoError, MAX_FIELDS, PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout,
+    PivotShowAs, PivotSort, PivotTable, PivotValue, RangeRef, abs_range, func_caption, func_from, number_to_text, quote_sheet, same,
+};
 
 // ================================================================ reading
 
diff --git a/crates/xlsx/src/pivot/write.rs b/crates/xlsx/src/pivot/write.rs
index 44e0c386a..a56bbf707 100644
--- a/crates/xlsx/src/pivot/write.rs
+++ b/crates/xlsx/src/pivot/write.rs
@@ -246,12 +246,7 @@ fn header_text(v: &Value) -> 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)?;
+fn cache_fields(sh: &gridcraft_model::Sheet, r: RangeRef) -> Vec<CField> {
     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();
@@ -280,42 +275,24 @@ fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cac
             formula: None,
         });
     }
+    fields
+}
+
+fn group_cache_fields(fields: &mut Vec<CField>, axis: &[&PivotField], date_system: DateSystem) {
     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()
+            && datetime_from_serial(date_system, s.min).is_some()
+            && datetime_from_serial(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 };
+    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;
         }
@@ -339,7 +316,7 @@ fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cac
         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 make = |by: PivotDateGroup| Group { by, base: *b, par: None, start, end, items: group_items(date_system, by, start, end) };
         let mut prev = *b;
         for (k, by) in list.iter().enumerate() {
             if k == 0 {
@@ -372,6 +349,39 @@ fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cac
             prev = new;
         }
     }
+}
+
+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 = cache_fields(sh, r);
+    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();
+    group_cache_fields(&mut fields, &axis, wb.date_system);
     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 {
@@ -598,11 +608,18 @@ fn cache_xml(c: &Cache, records_rid: Option<&str>, sys: DateSystem) -> String {
     s
 }
 
+struct PivotTableLayout<'a> {
+    row_fields: Vec<usize>,
+    column_fields: Vec<usize>,
+    hidden_fields: HashMap<usize, &'a PivotFilter>,
+    page_fields: Vec<(usize, &'a PivotFilter)>,
+    values: Vec<(usize, &'a PivotValue)>,
+}
+
 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();
+    let row_fields: Vec<usize> = c.axis_map.iter().take(pt.rows.len()).filter_map(|x| *x).collect();
+    let column_fields: 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();
@@ -625,12 +642,9 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
         }
     }
     let find_calc = |name: &str| c.fields.iter().position(|f| f.formula.is_some() && same(&f.name, name));
-    let vals: Vec<(usize, &PivotValue)> =
+    let values: 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 layout = PivotTableLayout { row_fields, column_fields, hidden_fields: hidden, page_fields: pages, values };
 
     let compact = pt.layout == PivotLayout::Compact;
     let name = if pt.name.trim().is_empty() { format!("PivotTable{}", idx + 1) } else { pt.name.clone() };
@@ -666,16 +680,16 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
     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();
+    let k = layout.values.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()));
+    let row_values = (k > 1 && pt.values_on_rows).then(|| values_at(row_map, layout.row_fields.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() {
+    let col_values = (k > 1 && !pt.values_on_rows).then_some(layout.column_fields.len());
+    let first_data_row = if layout.column_fields.is_empty() { 1 } else { 1 + layout.column_fields.len() + usize::from(col_values.is_some()) };
+    let row_levels = layout.row_fields.len() + usize::from(row_values.is_some());
+    let first_data_col = if row_levels == 0 && layout.column_fields.is_empty() {
         0
     } else if compact {
         1
@@ -683,27 +697,52 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
         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 hide_values_row = col_values.is_some() && layout.column_fields.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());
+    if !layout.page_fields.is_empty() {
+        let _ = write!(s, " rowPageCount=\"{}\" colPageCount=\"1\"", layout.page_fields.len());
     }
     s.push_str("/>");
 
-    // Fields.
-    let _ = write!(s, "<pivotFields count=\"{nf}\">");
+    write_pivot_fields(&mut s, pt, c, &layout);
+    axis_fields_xml(&mut s, "rowFields", &layout.row_fields, row_values);
+    axis_fields_xml(&mut s, "colFields", &layout.column_fields, col_values);
+    write_page_fields(&mut s, c, &layout);
+    write_data_fields(&mut s, c, &layout, fmt_id);
+    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
+}
+
+fn axis_field<'a>(pt: &'a PivotTable, c: &Cache, i: usize) -> Option<&'a PivotField> {
+    let p = c.axis_map.iter().position(|x| *x == Some(i))?;
+    pt.rows.iter().chain(pt.columns.iter()).nth(p)
+}
+
+fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &PivotTableLayout<'_>) {
+    let _ = write!(s, "<pivotFields count=\"{}\">", c.fields.len());
     for (i, f) in c.fields.iter().enumerate() {
         s.push_str("<pivotField");
-        let axis = if row_idx.contains(&i) {
+        let axis = if layout.row_fields.contains(&i) {
             Some("axisRow")
-        } else if col_idx.contains(&i) {
+        } else if layout.column_fields.contains(&i) {
             Some("axisCol")
-        } else if pages.iter().any(|(j, _)| *j == i) {
+        } else if layout.page_fields.iter().any(|(j, _)| *j == i) {
             Some("axisPage")
         } else {
             None
@@ -711,7 +750,7 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
         if let Some(ax) = axis {
             let _ = write!(s, " axis=\"{ax}\"");
         }
-        if vals.iter().any(|(j, _)| *j == i) {
+        if layout.values.iter().any(|(j, _)| *j == i) {
             s.push_str(" dataField=\"1\"");
         }
         if f.formula.is_some() {
@@ -725,7 +764,7 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
         if f.group.is_some() {
             s.push_str(" numFmtId=\"14\"");
         }
-        let filter = hidden.get(&i).copied();
+        let filter = layout.hidden_fields.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).
@@ -740,7 +779,7 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
             s.push_str(" multipleItemSelectionAllowed=\"1\"");
         }
         s.push_str(" showAll=\"0\"");
-        if let Some(af) = axis_field(i) {
+        if let Some(af) = axis_field(pt, c, i) {
             match af.sort {
                 PivotSort::Asc => s.push_str(" sortType=\"ascending\""),
                 PivotSort::Desc => s.push_str(" sortType=\"descending\""),
@@ -754,7 +793,7 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
             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 collapsed: &[String] = axis_field(pt, c, 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() {
@@ -776,84 +815,76 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
         }
     }
     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>");
+fn write_page_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>) {
+    if layout.page_fields.is_empty() {
+        return;
     }
-    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;
+    let _ = write!(s, "<pageFields count=\"{}\">", layout.page_fields.len());
+    for (i, filter) in &layout.page_fields {
+        let _ = write!(s, "<pageField fld=\"{i}\"");
+        if let Some(selected) = &filter.selected
+            && selected.len() == 1
+            && let Some(one) = selected.first()
+            && let Some(x) = c.fields.get(*i).and_then(|field| field.item_labels().iter().position(|label| same(label, one)))
+        {
+            let _ = write!(s, " item=\"{x}\"");
+        }
+        s.push_str(" hier=\"-1\"/>");
+    }
+    s.push_str("</pageFields>");
+}
+
+fn write_data_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>, fmt_id: &dyn Fn(&str) -> Option<u32>) {
+    if layout.values.is_empty() {
+        return;
+    }
+    let _ = write!(s, "<dataFields count=\"{}\">", layout.values.len());
+    let mut used: Vec<String> = Vec::new();
+    for (i, value) in &layout.values {
+        let base = if value.name.trim().is_empty() {
+            format!("{} of {}", func_caption(value.func), c.fields.get(*i).map(|f| f.name.as_str()).unwrap_or(""))
+        } else {
+            value.name.clone()
+        };
+        let mut name = base.clone();
+        let mut suffix = 2;
+        while used.iter().any(|existing| same(existing, &name)) {
+            name = format!("{base}{suffix}");
+            suffix += 1;
+        }
+        used.push(name.clone());
+        let _ = write!(s, "<dataField name=\"{}\" fld=\"{i}\"", esc_attr(&name));
+        if value.func != PivotFunc::Sum {
+            let _ = write!(s, " subtotal=\"{}\"", func_name(value.func));
+        }
+        let base_field = layout.row_fields.first().or(layout.column_fields.first()).copied().unwrap_or(0);
+        match value.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\"");
             }
-            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("/>");
+            PivotShowAs::Rank => {
+                let _ = write!(s, " baseField=\"{base_field}\" baseItem=\"0\"");
             }
         }
-        s.push_str("</dataFields>");
+        if let Some(id) = value.number_format.as_deref().and_then(fmt_id) {
+            let _ = write!(s, " numFmtId=\"{id}\"");
+        }
+        if value.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("<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
+    s.push_str("</dataFields>");
 }
 
 /// `<rowFields>`/`<colFields>`: the axis's cache field indices, with Σ Values (`-2`) at `values_at`.
diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs
index 55ef6757d..8b118ecdb 100644
--- a/crates/xlsx/src/read.rs
+++ b/crates/xlsx/src/read.rs
@@ -96,87 +96,10 @@ pub fn find_rel<'r>(rels: &'r [Rel], kind: &str) -> Option<&'r Rel> {
     rels.iter().find(|r| r.kind == kind)
 }
 
-pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
-    let pkg = Package::open(bytes)?;
-    let mut cx = Ctx {
-        pkg,
-        report: ReadReport::default(),
-        sst: vec![],
-        phonetics: vec![],
-        xf_map: vec![],
-        dxfs: vec![],
-        palette: crate::tables::INDEXED.to_vec(),
-        date_system: DateSystem::D1900,
-        styles: StyleTable::default(),
-        persons: Default::default(),
-        next_id: 1,
-        num_fmts: Default::default(),
-        cell_pictures: vec![],
-        cf_ext_ids: vec![],
-    };
-    let root_rels = cx.pkg.rels("")?;
-    let wb_part = find_rel(&root_rels, "officeDocument").map(|r| r.target.clone()).unwrap_or_else(|| "xl/workbook.xml".into());
-    let wb_xml = match cx.pkg.read_xml(&wb_part)? {
-        Some(x) => x,
-        None => {
-            if cx.pkg.has("xl/workbook.xml") && wb_part != "xl/workbook.xml" {
-                cx.pkg.read_xml("xl/workbook.xml")?.ok_or_else(|| IoError::Format("no workbook part".into()))?
-            } else if cx.pkg.has("content.xml") {
-                return Err(IoError::Format("this is an OpenDocument file, not XLSX".into()));
-            } else {
-                return Err(IoError::Format("no workbook part".into()));
-            }
-        }
-    };
-    if wb_xml.name != "workbook" {
-        return Err(IoError::Format(format!("unexpected root element <{}> in workbook part", wb_xml.name)));
-    }
-    let wb_rels = cx.pkg.rels(&wb_part)?;
-    let mut kept = crate::passthrough::KeptReader::new(&mut cx);
-    cx.cell_pictures = match crate::richdata::read(&mut cx, &wb_rels) {
-        Ok(pictures) => pictures,
-        Err(error) => {
-            cx.warn(format!("cell-picture data could not be read ({error}); scalar fallbacks were retained"));
-            vec![]
-        }
-    };
-    let mut wb = Workbook::new();
-    wb.sheets.clear();
-
-    // Theme, then styles: a font's link to the theme's body font is read against it.
-    if let Some(r) = find_rel(&wb_rels, "theme").cloned()
-        && let Some(x) = cx.optional_xml(&r.target)?
-    {
-        wb.theme = crate::theme::read_theme(&x);
-    }
-    // Cell checkboxes live in the feature property bags, which styles refer to.
-    let mut checkboxes = Vec::new();
-    if let Some(r) = find_rel(&wb_rels, "FeaturePropertyBag").cloned()
-        && let Some(x) = cx.optional_xml(&r.target)?
-    {
-        checkboxes = crate::feature_bags::checkbox_complements(&x);
-    }
-    if let Some(r) = find_rel(&wb_rels, "styles").cloned() {
-        if let Some(x) = cx.optional_xml(&r.target)? {
-            let StylesIn { xfs, dxfs, palette, named, num_fmts } = read_styles(&x, &checkboxes, &wb.theme.minor_font);
-            cx.num_fmts = num_fmts;
-            // Cell format 0 is the Normal cell format: everything on it (font, number format,
-            // fill, borders, alignment, protection) is what a cell without its own format shows
-            // (#1013).
-            if let Some(normal) = xfs.first() {
-                cx.styles = StyleTable::with_default(normal.clone());
-            }
-            cx.xf_map = xfs.into_iter().enumerate().map(|(i, s)| if i == 0 { StyleId::DEFAULT } else { cx.styles.intern(s) }).collect();
-            cx.dxfs = dxfs;
-            cx.palette = palette;
-            wb.cell_styles = named;
-        }
-    } else {
-        cx.warn("no styles part");
-    }
+fn read_shared_strings(cx: &mut Ctx<'_>, wb_rels: &[Rel]) -> Result<(), IoError> {
     // Shared strings, streamed item by item. Phonetic (furigana) runs are kept next to the text
     // they annotate, so an open + save does not delete them.
-    if let Some(r) = find_rel(&wb_rels, "sharedStrings").cloned() {
+    if let Some(r) = find_rel(wb_rels, "sharedStrings").cloned() {
         match cx.pkg.read(&r.target)? {
             Some(b) => {
                 let mut sst = Vec::new();
@@ -206,18 +129,67 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
         }
     }
 
-    if let Some(r) = find_rel(&wb_rels, "person").cloned()
-        && let Ok(Some(x)) = cx.pkg.read_xml(&r.target)
+    Ok(())
+}
+
+fn read_workbook_styles(cx: &mut Ctx<'_>, wb: &mut Workbook, wb_rels: &[Rel]) -> Result<(), IoError> {
+    // Theme, then styles: a font's link to the theme's body font is read against it.
+    if let Some(r) = find_rel(wb_rels, "theme").cloned()
+        && let Some(x) = cx.optional_xml(&r.target)?
     {
-        for p in x.kids("person") {
-            if let (Some(id), Some(n)) = (p.attr("id"), p.attr("displayName")) {
-                cx.persons.insert(id.to_string(), n.to_string());
+        wb.theme = crate::theme::read_theme(&x);
+    }
+    // Cell checkboxes live in the feature property bags, which styles refer to.
+    let mut checkboxes = Vec::new();
+    if let Some(r) = find_rel(wb_rels, "FeaturePropertyBag").cloned()
+        && let Some(x) = cx.optional_xml(&r.target)?
+    {
+        checkboxes = crate::feature_bags::checkbox_complements(&x);
+    }
+    if let Some(r) = find_rel(wb_rels, "styles").cloned() {
+        if let Some(x) = cx.optional_xml(&r.target)? {
+            let StylesIn { xfs, dxfs, palette, named, num_fmts } = read_styles(&x, &checkboxes, &wb.theme.minor_font);
+            cx.num_fmts = num_fmts;
+            // Cell format 0 is the Normal cell format: everything on it (font, number format,
+            // fill, borders, alignment, protection) is what a cell without its own format shows
+            // (#1013).
+            if let Some(normal) = xfs.first() {
+                cx.styles = StyleTable::with_default(normal.clone());
+            }
+            cx.xf_map = xfs.into_iter().enumerate().map(|(i, s)| if i == 0 { StyleId::DEFAULT } else { cx.styles.intern(s) }).collect();
+            cx.dxfs = dxfs;
+            cx.palette = palette;
+            wb.cell_styles = named;
+        }
+    } else {
+        cx.warn("no styles part");
+    }
+    Ok(())
+}
+
+/// Read the workbook XML selected by the package's root relationships.
+fn workbook_xml(pkg: &mut Package<'_>, part: &str) -> Result<El, IoError> {
+    let xml = match pkg.read_xml(part)? {
+        Some(xml) => xml,
+        None => {
+            if pkg.has("xl/workbook.xml") && part != "xl/workbook.xml" {
+                pkg.read_xml("xl/workbook.xml")?.ok_or_else(|| IoError::Format("no workbook part".into()))?
+            } else if pkg.has("content.xml") {
+                return Err(IoError::Format("this is an OpenDocument file, not XLSX".into()));
+            } else {
+                return Err(IoError::Format("no workbook part".into()));
             }
         }
+    };
+    if xml.name != "workbook" {
+        return Err(IoError::Format(format!("unexpected root element <{}> in workbook part", xml.name)));
     }
+    Ok(xml)
+}
 
-    // Workbook properties.
-    if let Some(p) = wb_xml.child("workbookPr") {
+/// Read workbook-level settings before processing the individual sheets.
+fn read_workbook_properties(cx: &mut Ctx<'_>, wb: &mut Workbook, xml: &El) {
+    if let Some(p) = xml.child("workbookPr") {
         if p.flag("date1904", false) {
             cx.date_system = DateSystem::D1904;
         }
@@ -228,7 +200,7 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
         };
     }
     wb.date_system = cx.date_system;
-    if let Some(c) = wb_xml.child("calcPr") {
+    if let Some(c) = xml.child("calcPr") {
         wb.calc.mode = match c.attr("calcMode") {
             Some("manual") => CalcMode::Manual,
             Some("autoNoTable") => CalcMode::AutomaticExceptTables,
@@ -243,10 +215,59 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
         }
         wb.calc.precision_as_displayed = !c.flag("fullPrecision", true);
     }
-    if let Some(p) = wb_xml.child("workbookProtection") {
+    if let Some(p) = xml.child("workbookProtection") {
         wb.protected_structure = p.flag("lockStructure", false);
         wb.structure_password = if wb.protected_structure { crate::sheet_read::read_password(p, "workbook") } else { None };
     }
+}
+
+pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
+    let pkg = Package::open(bytes)?;
+    let mut cx = Ctx {
+        pkg,
+        report: ReadReport::default(),
+        sst: vec![],
+        phonetics: vec![],
+        xf_map: vec![],
+        dxfs: vec![],
+        palette: crate::tables::INDEXED.to_vec(),
+        date_system: DateSystem::D1900,
+        styles: StyleTable::default(),
+        persons: Default::default(),
+        next_id: 1,
+        num_fmts: Default::default(),
+        cell_pictures: vec![],
+        cf_ext_ids: vec![],
+    };
+    let root_rels = cx.pkg.rels("")?;
+    let wb_part = find_rel(&root_rels, "officeDocument").map(|r| r.target.clone()).unwrap_or_else(|| "xl/workbook.xml".into());
+    let wb_xml = workbook_xml(&mut cx.pkg, &wb_part)?;
+    let wb_rels = cx.pkg.rels(&wb_part)?;
+    let mut kept = crate::passthrough::KeptReader::new(&mut cx);
+    cx.cell_pictures = match crate::richdata::read(&mut cx, &wb_rels) {
+        Ok(pictures) => pictures,
+        Err(error) => {
+            cx.warn(format!("cell-picture data could not be read ({error}); scalar fallbacks were retained"));
+            vec![]
+        }
+    };
+    let mut wb = Workbook::new();
+    wb.sheets.clear();
+
+    read_workbook_styles(&mut cx, &mut wb, &wb_rels)?;
+    read_shared_strings(&mut cx, &wb_rels)?;
+
+    if let Some(r) = find_rel(&wb_rels, "person").cloned()
+        && let Ok(Some(x)) = cx.pkg.read_xml(&r.target)
+    {
+        for p in x.kids("person") {
+            if let (Some(id), Some(n)) = (p.attr("id"), p.attr("displayName")) {
+                cx.persons.insert(id.to_string(), n.to_string());
+            }
+        }
+    }
+
+    read_workbook_properties(&mut cx, &mut wb, &wb_xml);
     let active_tab = wb_xml.path(&["bookViews", "workbookView"]).and_then(|v| v.attr_u32("activeTab")).unwrap_or(0) as usize;
 
     // Sheets. `file_to_model[i]` maps the i-th <sheet> to a model sheet index.
@@ -426,7 +447,10 @@ pub fn parse_print_area(text: &str) -> Option<RangeRef> {
     RangeRef::parse(&r)
 }
 
-pub fn parse_print_titles(text: &str) -> (Option<(u32, u32)>, Option<(u32, u32)>) {
+/// A print-titles span: the first and last row (or column) repeated on each page.
+type TitleSpan = Option<(u32, u32)>;
+
+pub fn parse_print_titles(text: &str) -> (TitleSpan, TitleSpan) {
     let mut rows = None;
     let mut cols = None;
     for part in text.split(',') {
diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs
index 57b5ac7e3..7a37e41d8 100644
--- a/crates/xlsx/src/sheet_read.rs
+++ b/crates/xlsx/src/sheet_read.rs
@@ -97,6 +97,24 @@ const MAX_DYNAMIC_CHECKS: u64 = 16_000_000;
 /// rule copies its element's whole range list, so rules × ranges must stay bounded.
 const MAX_COND_CELLS: u64 = 4_000_000;
 
+fn read_sheet_format(e: &El, sheet: &mut Sheet) {
+    if let Some(h) = e.attr_f64("defaultRowHeight") {
+        let px = pt_to_px(h);
+        if px > 0.0 {
+            sheet.default_row_height = px;
+        }
+    }
+    if let Some(w) = e.attr_f64("defaultColWidth") {
+        let px = col_width_to_px(w);
+        if px > 0.0 {
+            sheet.default_col_width = px;
+        }
+    } else if let Some(b) = e.attr_f64("baseColWidth") {
+        let px = ((b.clamp(0.0, 255.0) * 7.0 + 5.0) / 8.0).ceil() * 8.0;
+        sheet.default_col_width = px as f32;
+    }
+}
+
 pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<Sheet, IoError> {
     let bytes = cx.pkg.read(part)?.ok_or_else(|| IoError::Format(format!("missing part {part}")))?;
     let rels = cx.pkg.rels(part)?;
@@ -134,23 +152,7 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<Sheet, IoE
                 fit_to_page = e.child("pageSetUpPr").is_some_and(|p| p.flag("fitToPage", false));
             }
             "sheetViews" => read_views(e, &mut sheet),
-            "sheetFormatPr" => {
-                if let Some(h) = e.attr_f64("defaultRowHeight") {
-                    let px = pt_to_px(h);
-                    if px > 0.0 {
-                        sheet.default_row_height = px;
-                    }
-                }
-                if let Some(w) = e.attr_f64("defaultColWidth") {
-                    let px = col_width_to_px(w);
-                    if px > 0.0 {
-                        sheet.default_col_width = px;
-                    }
-                } else if let Some(b) = e.attr_f64("baseColWidth") {
-                    let px = ((b.clamp(0.0, 255.0) * 7.0 + 5.0) / 8.0).ceil() * 8.0;
-                    sheet.default_col_width = px as f32;
-                }
-            }
+            "sheetFormatPr" => read_sheet_format(e, &mut sheet),
             "cols" => read_cols(cx, e, &mut sheet, &mut column_assignments_left)?,
             "mergeCells" => {
                 for m in e.kids("mergeCell") {
diff --git a/crates/xlsx/src/sheet_read/parts.rs b/crates/xlsx/src/sheet_read/parts.rs
index c7626e6e9..3ff672289 100644
--- a/crates/xlsx/src/sheet_read/parts.rs
+++ b/crates/xlsx/src/sheet_read/parts.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    AutoFilter, CellRef, Comment, Ctx, El, FilterCriterion, HashMap, Hyperlink, MAX_COLS, MAX_HYPERLINK_BYTES, MAX_HYPERLINK_CELLS, MAX_ROWS,
+    NoteBox, NoteCorner, RangeRef, Rel, Sheet, Table, TableColumn, TotalsFn, XmlColumnPr, from_file, xml,
+};
 
 pub(super) fn read_hyperlinks(cx: &mut Ctx<'_>, name: &str, e: &El, rels: &[Rel], sheet: &mut Sheet) {
     let mut cells = 0u64;
diff --git a/crates/xlsx/src/sheet_read/rules.rs b/crates/xlsx/src/sheet_read/rules.rs
index e0ad3129f..4e4500707 100644
--- a/crates/xlsx/src/sheet_read/rules.rs
+++ b/crates/xlsx/src/sheet_read/rules.rs
@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    CfOperator, CfRule, CfValueKind, CondFormat, Ctx, El, ErrorStyle, MAX_COND_CELLS, RangeRef, Sheet, Validation, ValidationKind, from_file,
+    parse_sqref, read_color,
+};
 
 fn cf_op(s: Option<&str>) -> CfOperator {
     match s.unwrap_or("between") {
diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs
index b03bfbd5e..10bb3d21d 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, push_a1, push_esc, push_num, push_u64};
+use crate::xml::{encode_xstring, esc, esc_attr, num, push_a1, push_u64};
 
 mod parts;
 mod rules;
@@ -124,70 +124,7 @@ pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (
     }
     let _ = write!(s, "<dimension ref=\"{}\"/>", used.map(|u| u.a1()).unwrap_or_else(|| "A1".into()));
 
-    // sheetViews
-    s.push_str("<sheetViews><sheetView");
-    if selected {
-        s.push_str(" tabSelected=\"1\"");
-    }
-    if !sheet.show_gridlines {
-        s.push_str(" showGridLines=\"0\"");
-    }
-    if !sheet.show_headings {
-        s.push_str(" showRowColHeaders=\"0\"");
-    }
-    if sheet.show_formulas {
-        s.push_str(" showFormulas=\"1\"");
-    }
-    if !sheet.show_zeros {
-        s.push_str(" showZeros=\"0\"");
-    }
-    if !sheet.show_outline_symbols {
-        s.push_str(" showOutlineSymbols=\"0\"");
-    }
-    if sheet.right_to_left {
-        s.push_str(" rightToLeft=\"1\"");
-    }
-    if sheet.view != gridcraft_model::SheetViewMode::Normal {
-        let _ = write!(s, " view=\"{}\"", sheet.view.as_str());
-    }
-    if sheet.zoom != 100 && (10..=400).contains(&sheet.zoom) {
-        let _ = write!(s, " zoomScale=\"{0}\" zoomScaleNormal=\"{0}\"", sheet.zoom);
-    }
-    if sheet.view_top_left != CellRef::default() && sheet.freeze.is_none() {
-        let _ = write!(s, " topLeftCell=\"{}\"", sheet.view_top_left.a1());
-    }
-    s.push_str(" workbookViewId=\"0\">");
-    let active = sheet.view_active.a1();
-    match sheet.freeze {
-        Some((rows, cols)) if rows > 0 || cols > 0 => {
-            let pane = match (rows > 0, cols > 0) {
-                (true, true) => "bottomRight",
-                (true, false) => "bottomLeft",
-                _ => "topRight",
-            };
-            s.push_str("<pane");
-            if cols > 0 {
-                let _ = write!(s, " xSplit=\"{cols}\"");
-            }
-            if rows > 0 {
-                let _ = write!(s, " ySplit=\"{rows}\"");
-            }
-            let _ = write!(
-                s,
-                " topLeftCell=\"{}\" activePane=\"{pane}\" state=\"frozen\"/>",
-                CellRef::new(
-                    rows.max(sheet.view_top_left.row).min(gridcraft_core::MAX_ROWS - 1),
-                    cols.max(sheet.view_top_left.col).min(gridcraft_core::MAX_COLS - 1)
-                )
-                .a1()
-            );
-            let _ = write!(s, "<selection pane=\"{pane}\" activeCell=\"{active}\" sqref=\"{active}\"/>");
-        }
-        _ => {
-            let _ = write!(s, "<selection activeCell=\"{active}\" sqref=\"{active}\"/>");
-        }
-    }
-    s.push_str("</sheetView></sheetViews>");
+    write_sheet_views(&mut s, sheet, selected);
 
     // sheetFormatPr
     let max_row_outline = sheet.rows.values().map(|r| r.outline).max().unwrap_or(0);
@@ -252,80 +189,248 @@ pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (
         s.push_str("</cols>");
     }
 
-    // sheetData
-    // 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();
+    write_sheet_data(&mut s, SheetCellData { workbook: wb, index: si, sheet, overrides: &overrides, extra: &extra, dynamic: &dynamic }, &sid, out);
+
+    let prio = write_sheet_rules(&mut s, sheet, &mut rels, out);
+    let kept = write_sheet_printing(&mut s, sheet, &mut rels, out);
+
+    write_sheet_drawing(&mut s, wb, si, sheet, &mut rels, out);
+    write_sheet_notes(&mut s, sheet, si, &kept, &mut rels, out);
+    // Tables.
+    if !tables.is_empty() {
+        let mut parts = String::new();
+        let mut used_names: HashSet<String> = HashSet::new();
+        for (t, cols) in &tables {
+            out.tables += 1;
+            out.table_id += 1;
+            let n = out.tables;
+            let name = table_name(&t.name, &mut used_names, out.table_id);
+            let xml = table_xml(t, cols, &name, out.table_id, out);
+            out.part(&format!("xl/tables/table{n}.xml"), Some(CT_TABLE), xml.into_bytes());
+            let rid = rels.add("table", &format!("../tables/table{n}.xml"));
+            let _ = write!(parts, "<tablePart r:id=\"{rid}\"/>");
+        }
+        let _ = write!(s, "<tableParts count=\"{}\">{parts}</tableParts>", tables.len());
     }
-    s.reserve(keys.len().saturating_mul(32));
-    s.push_str("<sheetData>");
-    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;
+    write_sheet_extensions(&mut s, sheet, &prio);
+    s.push_str("</worksheet>");
+    (s, rels)
+}
+
+struct CellWriteInput<'a> {
+    reference: CellRef,
+    cell: Option<&'a Cell>,
+    picture: Option<&'a std::sync::Arc<gridcraft_model::CellPicture>>,
+    header_override: Option<&'a String>,
+    spill_value: Option<&'a Value>,
+    dynamic_range: Option<&'a RangeRef>,
+}
+
+fn write_sheet_extensions(s: &mut String, sheet: &Sheet, prio: &[u32]) {
+    // Excel 2010 extensions: solid data bars, then sparklines.
+    let solid_bars: Vec<(&CondFormat, u32)> = sheet
+        .cond_formats
+        .iter()
+        .enumerate()
+        .filter(|(_, cf)| !cf.ranges.is_empty() && matches!(cf.rule, CfRule::DataBar { gradient: false, .. }))
+        .map(|(i, cf)| (cf, prio.get(i).copied().unwrap_or(1)))
+        .collect();
+    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() {
+        s.push_str("<extLst>");
+    }
+    if !solid_bars.is_empty() {
+        let _ = write!(
+            s,
+            "<ext uri=\"{{78C0D931-6437-407d-A8A1-0F90B4350D7D}}\" xmlns:x14=\"{X14_NS}\" xmlns:xm=\"{XM_NS}\"><x14:conditionalFormattings>"
+        );
+        for (cf, p) in &solid_bars {
+            if let CfRule::DataBar { min, max, .. } = &cf.rule {
+                let (id, lo, hi) = (solid_bar_id(*p), x14_cfvo(min), x14_cfvo(max));
+                let _ = write!(s, "<x14:conditionalFormatting><x14:cfRule type=\"dataBar\" id=\"{id}\"><x14:dataBar gradient=\"0\">{lo}{hi}");
+                let _ = write!(s, "</x14:dataBar></x14:cfRule><xm:sqref>{}</xm:sqref></x14:conditionalFormatting>", sqref(&cf.ranges));
+            }
         }
-        let cells = keys.get(first..next).unwrap_or_default();
-        if cells.is_empty() && info == LineInfo::default() {
-            continue;
+        s.push_str("</x14:conditionalFormattings></ext>");
+    }
+    if !sheet.sparklines.is_empty() {
+        let _ = write!(s, "<ext uri=\"{{05C60535-1F16-4fd2-B633-F4F36F0B64E0}}\" xmlns:x14=\"{X14_NS}\"><x14:sparklineGroups xmlns:xm=\"{XM_NS}\">");
+        for sp in &sheet.sparklines {
+            let ty = match sp.kind {
+                SparklineKind::Line => "",
+                SparklineKind::Column => " type=\"column\"",
+                SparklineKind::WinLoss => " type=\"stacked\"",
+            };
+            let src =
+                if sp.source.contains('!') { sp.source.clone() } else { format!("{}!{}", gridcraft_formula::quote_sheet(&sheet.name), sp.source) };
+            let color = if sp.color == Color::Auto { "rgb=\"FF376092\"".to_string() } else { color_attrs(&sp.color) };
+            let _ = write!(
+                s,
+                "<x14:sparklineGroup displayEmptyCellsAs=\"gap\"{ty}{}><x14:colorSeries {color}/><x14:sparklines><x14:sparkline><xm:f>{}</xm:f><xm:sqref>{}</xm:sqref></x14:sparkline></x14:sparklines></x14:sparklineGroup>",
+                if sp.markers { " markers=\"1\"" } else { "" },
+                esc(&src),
+                sp.cell.a1()
+            );
         }
-        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));
+        s.push_str("</x14:sparklineGroups></ext>");
+    }
+    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() {
+        s.push_str("</extLst>");
+    }
+}
+
+fn write_sheet_notes(s: &mut String, sheet: &Sheet, si: usize, kept: &crate::passthrough::SheetKept<'_>, rels: &mut Rels, out: &mut Out) {
+    // Notes: comments part + VML so Excel shows them. Threaded comments also get a legacy note
+    // (its text with the replies as lines, for readers without threaded comments) linked by id.
+    if !sheet.comments.is_empty() {
+        out.comments += 1;
+        let n = out.comments;
+        let ids = thread_ids(sheet, si);
+        out.part(&format!("xl/comments{n}.xml"), Some(CT_COMMENTS), comments_xml(sheet, &ids).into_bytes());
+        if !ids.is_empty() {
+            let x = threaded_xml(sheet, &ids, &mut out.persons);
+            out.part(&format!("xl/threadedComments/threadedComment{n}.xml"), Some(CT_THREADED_COMMENTS), x.into_bytes());
+            rels.add_uri(REL_THREADED_COMMENT, &format!("../threadedComments/threadedComment{n}.xml"));
         }
-        if let Some(h) = info.size {
-            let _ = write!(s, " ht=\"{}\"{}", num(px_to_pt(h)), if info.custom { " customHeight=\"1\"" } else { "" });
+        out.default_type("vml", "application/vnd.openxmlformats-officedocument.vmlDrawing");
+        let vml_name = format!("xl/drawings/vmlDrawing{n}.vml");
+        let vml = kept.notes_vml(vml_xml(sheet, out.kept.notes_block(n)), &vml_name, out);
+        out.part(&vml_name, None, vml.into_bytes());
+        rels.add("comments", &format!("../comments{n}.xml"));
+        let rid = rels.add("vmlDrawing", &format!("../drawings/vmlDrawing{n}.vml"));
+        let _ = write!(s, "<legacyDrawing r:id=\"{rid}\"/>");
+    } else if let Some(rid) = kept.lone_vml(rels, out) {
+        let _ = write!(s, "<legacyDrawing r:id=\"{rid}\"/>");
+    }
+    s.push_str(&kept.elements());
+}
+
+fn write_sheet_drawing(s: &mut String, wb: &Workbook, si: usize, sheet: &Sheet, rels: &mut Rels, out: &mut Out) {
+    // Drawing: pictures, charts, shapes.
+    if !sheet.images.is_empty() || !sheet.charts.is_empty() || !sheet.shapes.is_empty() {
+        out.drawings += 1;
+        let dn = out.drawings;
+        let mut drels = Rels::default();
+        let mut objs: Vec<Obj<'_>> = vec![];
+        for img in &sheet.images {
+            if img.data.is_empty() {
+                continue;
+            }
+            let ext = image_ext(&img.mime, &img.data);
+            out.default_type(ext, image_content_type(ext));
+            let file = out.image_part(ext, &img.data);
+            let rid = drels.add("image", &format!("../media/{file}"));
+            objs.push(Obj::Image(img, rid));
         }
-        if info.hidden {
-            s.push_str(" hidden=\"1\"");
+        for ch in &sheet.charts {
+            out.charts += 1;
+            let rid = if crate::chartex::is_chartex(ch.kind) {
+                let n = out.charts;
+                let xml = crate::chartex::write_chartex(wb, si, ch, &mut out.chart_names);
+                out.part(&format!("xl/charts/chartEx{n}.xml"), Some(crate::chartex::CT_CHARTEX), xml.into_bytes());
+                // Excel expects a chartex part's style and colour parts.
+                out.part(&format!("xl/charts/style{n}.xml"), Some(crate::chartex::CT_STYLE), crate::chartex::style_xml().into_bytes());
+                out.part(&format!("xl/charts/colors{n}.xml"), Some(crate::chartex::CT_COLORS), crate::chartex::colors_xml().into_bytes());
+                let mut crels = Rels::default();
+                crels.add_uri(crate::chartex::REL_STYLE, &format!("style{n}.xml"));
+                crels.add_uri(crate::chartex::REL_COLORS, &format!("colors{n}.xml"));
+                out.part(&format!("xl/charts/_rels/chartEx{n}.xml.rels"), None, crels.xml().into_bytes());
+                drels.add_uri(crate::chartex::REL_CHARTEX, &format!("../charts/chartEx{n}.xml"))
+            } else {
+                let name = format!("xl/charts/chart{}.xml", out.charts);
+                out.part(&name, Some(CT_CHART), crate::chart::write_chart(wb, si, ch, &out.book_name).into_bytes());
+                drels.add("chart", &format!("../charts/chart{}.xml", out.charts))
+            };
+            objs.push(Obj::Chart(ch, rid));
         }
-        if info.outline > 0 {
-            let _ = write!(s, " outlineLevel=\"{}\"", info.outline.min(7));
+        for sh in &sheet.shapes {
+            objs.push(Obj::Shape(sh));
         }
-        if info.collapsed {
-            s.push_str(" collapsed=\"1\"");
+        out.part(&format!("xl/drawings/drawing{dn}.xml"), Some(CT_DRAWING), crate::drawing::write_drawing(sheet, &wb.theme, &objs).into_bytes());
+        if !drels.is_empty() {
+            out.part(&format!("xl/drawings/_rels/drawing{dn}.xml.rels"), None, drels.xml().into_bytes());
         }
-        if cells.is_empty() {
-            s.push_str("/>");
-            continue;
+        let rid = rels.add("drawing", &format!("../drawings/drawing{dn}.xml"));
+        let _ = write!(s, "<drawing r:id=\"{rid}\"/>");
+    }
+}
+
+fn write_sheet_printing<'a>(s: &mut String, sheet: &'a Sheet, rels: &mut Rels, out: &mut Out) -> crate::passthrough::SheetKept<'a> {
+    // Printing.
+    let p = &sheet.print;
+    if p.gridlines || p.headings || p.center_h || p.center_v {
+        s.push_str("<printOptions");
+        for (a, v) in [("horizontalCentered", p.center_h), ("verticalCentered", p.center_v), ("headings", p.headings), ("gridLines", p.gridlines)] {
+            if v {
+                let _ = write!(s, " {a}=\"1\"");
+            }
+        }
+        s.push_str("/>");
+    }
+    // Unmodelled content kept from the source file (printer settings, controls, OLE objects…).
+    let kept = crate::passthrough::SheetKept::write(sheet, rels, out);
+    let m = |i: usize| num(p.margins.get(i).copied().unwrap_or(0.75) as f64);
+    let _ =
+        write!(s, "<pageMargins left=\"{}\" right=\"{}\" top=\"{}\" bottom=\"{}\" header=\"{}\" footer=\"{}\"/>", m(0), m(1), m(2), m(3), m(4), m(5));
+    s.push_str("<pageSetup");
+    if let Some(id) = paper_id(&p.paper)
+        && id != 1
+    {
+        let _ = write!(s, " paperSize=\"{id}\"");
+    }
+    if p.scale != 100 && (10..=400).contains(&p.scale) {
+        let _ = write!(s, " scale=\"{}\"", p.scale);
+    }
+    if let Some((w, h)) = p.fit_to {
+        let _ = write!(s, " fitToWidth=\"{w}\" fitToHeight=\"{h}\"");
+    }
+    let _ = write!(s, " orientation=\"{}\"", if p.orientation == Orientation::Landscape { "landscape" } else { "portrait" });
+    if let Some(id) = kept.page_setup_id() {
+        let _ = write!(s, " r:id=\"{id}\"");
+    }
+    s.push_str("/>");
+    if p.has_header_footer() || p.different_first || p.different_odd_even || !p.hf_scale_with_doc || !p.hf_align_with_margins {
+        s.push_str("<headerFooter");
+        for (attr, on, default) in [
+            ("differentOddEven", p.different_odd_even, false),
+            ("differentFirst", p.different_first, false),
+            ("scaleWithDoc", p.hf_scale_with_doc, true),
+            ("alignWithMargins", p.hf_align_with_margins, true),
+        ] {
+            if on != default {
+                let _ = write!(s, " {attr}=\"{}\"", u8::from(on));
+            }
         }
         s.push('>');
-        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))
-            });
-            write_cell(&mut s, c, cell, sheet.cell_pictures.get(&c), ov, ex, array.as_ref(), &sid, out);
+        // CT_HeaderFooter's element order.
+        for (tag, text) in [
+            ("oddHeader", &p.header),
+            ("oddFooter", &p.footer),
+            ("evenHeader", &p.even_header),
+            ("evenFooter", &p.even_footer),
+            ("firstHeader", &p.first_header),
+            ("firstFooter", &p.first_footer),
+        ] {
+            if !text.is_empty() {
+                let _ = write!(s, "<{tag}>{}</{tag}>", esc(text));
+            }
+        }
+        s.push_str("</headerFooter>");
+    }
+    for (tag, list, max) in [("rowBreaks", &p.row_breaks, 16383u32), ("colBreaks", &p.col_breaks, 1048575)] {
+        let list: Vec<u32> = list.iter().copied().filter(|&b| b > 0).collect();
+        if !list.is_empty() {
+            let _ = write!(s, "<{tag} count=\"{0}\" manualBreakCount=\"{0}\">", list.len());
+            for b in list {
+                let _ = write!(s, "<brk id=\"{b}\" max=\"{max}\" man=\"1\"/>");
+            }
+            let _ = write!(s, "</{tag}>");
         }
-        s.push_str("</row>");
     }
-    s.push_str("</sheetData>");
 
+    kept
+}
+
+fn write_sheet_rules(s: &mut String, sheet: &Sheet, rels: &mut Rels, out: &mut Out) -> Vec<u32> {
     // sheetProtection
     if let Some(p) = &sheet.protection {
         s.push_str("<sheetProtection sheet=\"1\" objects=\"1\" scenarios=\"1\"");
@@ -433,236 +538,178 @@ pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (
         }
         s.push_str("</hyperlinks>");
     }
-    // Printing.
-    let p = &sheet.print;
-    if p.gridlines || p.headings || p.center_h || p.center_v {
-        s.push_str("<printOptions");
-        for (a, v) in [("horizontalCentered", p.center_h), ("verticalCentered", p.center_v), ("headings", p.headings), ("gridLines", p.gridlines)] {
-            if v {
-                let _ = write!(s, " {a}=\"1\"");
-            }
-        }
-        s.push_str("/>");
-    }
-    // Unmodelled content kept from the source file (printer settings, controls, OLE objects…).
-    let kept = crate::passthrough::SheetKept::write(sheet, &mut rels, out);
-    let m = |i: usize| num(p.margins.get(i).copied().unwrap_or(0.75) as f64);
-    let _ =
-        write!(s, "<pageMargins left=\"{}\" right=\"{}\" top=\"{}\" bottom=\"{}\" header=\"{}\" footer=\"{}\"/>", m(0), m(1), m(2), m(3), m(4), m(5));
-    s.push_str("<pageSetup");
-    if let Some(id) = paper_id(&p.paper)
-        && id != 1
-    {
-        let _ = write!(s, " paperSize=\"{id}\"");
-    }
-    if p.scale != 100 && (10..=400).contains(&p.scale) {
-        let _ = write!(s, " scale=\"{}\"", p.scale);
-    }
-    if let Some((w, h)) = p.fit_to {
-        let _ = write!(s, " fitToWidth=\"{w}\" fitToHeight=\"{h}\"");
-    }
-    let _ = write!(s, " orientation=\"{}\"", if p.orientation == Orientation::Landscape { "landscape" } else { "portrait" });
-    if let Some(id) = kept.page_setup_id() {
-        let _ = write!(s, " r:id=\"{id}\"");
-    }
-    s.push_str("/>");
-    if p.has_header_footer() || p.different_first || p.different_odd_even || !p.hf_scale_with_doc || !p.hf_align_with_margins {
-        s.push_str("<headerFooter");
-        for (attr, on, default) in [
-            ("differentOddEven", p.different_odd_even, false),
-            ("differentFirst", p.different_first, false),
-            ("scaleWithDoc", p.hf_scale_with_doc, true),
-            ("alignWithMargins", p.hf_align_with_margins, true),
-        ] {
-            if on != default {
-                let _ = write!(s, " {attr}=\"{}\"", u8::from(on));
-            }
-        }
-        s.push('>');
-        // CT_HeaderFooter's element order.
-        for (tag, text) in [
-            ("oddHeader", &p.header),
-            ("oddFooter", &p.footer),
-            ("evenHeader", &p.even_header),
-            ("evenFooter", &p.even_footer),
-            ("firstHeader", &p.first_header),
-            ("firstFooter", &p.first_footer),
-        ] {
-            if !text.is_empty() {
-                let _ = write!(s, "<{tag}>{}</{tag}>", esc(text));
-            }
-        }
-        s.push_str("</headerFooter>");
-    }
-    for (tag, list, max) in [("rowBreaks", &p.row_breaks, 16383u32), ("colBreaks", &p.col_breaks, 1048575)] {
-        let list: Vec<u32> = list.iter().copied().filter(|&b| b > 0).collect();
-        if !list.is_empty() {
-            let _ = write!(s, "<{tag} count=\"{0}\" manualBreakCount=\"{0}\">", list.len());
-            for b in list {
-                let _ = write!(s, "<brk id=\"{b}\" max=\"{max}\" man=\"1\"/>");
-            }
-            let _ = write!(s, "</{tag}>");
-        }
-    }
-
-    // Drawing: pictures, charts, shapes.
-    if !sheet.images.is_empty() || !sheet.charts.is_empty() || !sheet.shapes.is_empty() {
-        out.drawings += 1;
-        let dn = out.drawings;
-        let mut drels = Rels::default();
-        let mut objs: Vec<Obj<'_>> = vec![];
-        for img in &sheet.images {
-            if img.data.is_empty() {
-                continue;
-            }
-            let ext = image_ext(&img.mime, &img.data);
-            out.default_type(ext, image_content_type(ext));
-            let file = out.image_part(ext, &img.data);
-            let rid = drels.add("image", &format!("../media/{file}"));
-            objs.push(Obj::Image(img, rid));
-        }
-        for ch in &sheet.charts {
-            out.charts += 1;
-            let rid = if crate::chartex::is_chartex(ch.kind) {
-                let n = out.charts;
-                let xml = crate::chartex::write_chartex(wb, si, ch, &mut out.chart_names);
-                out.part(&format!("xl/charts/chartEx{n}.xml"), Some(crate::chartex::CT_CHARTEX), xml.into_bytes());
-                // Excel expects a chartex part's style and colour parts.
-                out.part(&format!("xl/charts/style{n}.xml"), Some(crate::chartex::CT_STYLE), crate::chartex::style_xml().into_bytes());
-                out.part(&format!("xl/charts/colors{n}.xml"), Some(crate::chartex::CT_COLORS), crate::chartex::colors_xml().into_bytes());
-                let mut crels = Rels::default();
-                crels.add_uri(crate::chartex::REL_STYLE, &format!("style{n}.xml"));
-                crels.add_uri(crate::chartex::REL_COLORS, &format!("colors{n}.xml"));
-                out.part(&format!("xl/charts/_rels/chartEx{n}.xml.rels"), None, crels.xml().into_bytes());
-                drels.add_uri(crate::chartex::REL_CHARTEX, &format!("../charts/chartEx{n}.xml"))
-            } else {
-                let name = format!("xl/charts/chart{}.xml", out.charts);
-                out.part(&name, Some(CT_CHART), crate::chart::write_chart(wb, si, ch, &out.book_name).into_bytes());
-                drels.add("chart", &format!("../charts/chart{}.xml", out.charts))
-            };
-            objs.push(Obj::Chart(ch, rid));
-        }
-        for sh in &sheet.shapes {
-            objs.push(Obj::Shape(sh));
-        }
-        out.part(&format!("xl/drawings/drawing{dn}.xml"), Some(CT_DRAWING), crate::drawing::write_drawing(sheet, &wb.theme, &objs).into_bytes());
-        if !drels.is_empty() {
-            out.part(&format!("xl/drawings/_rels/drawing{dn}.xml.rels"), None, drels.xml().into_bytes());
-        }
-        let rid = rels.add("drawing", &format!("../drawings/drawing{dn}.xml"));
-        let _ = write!(s, "<drawing r:id=\"{rid}\"/>");
-    }
-    // Notes: comments part + VML so Excel shows them. Threaded comments also get a legacy note
-    // (its text with the replies as lines, for readers without threaded comments) linked by id.
-    if !sheet.comments.is_empty() {
-        out.comments += 1;
-        let n = out.comments;
-        let ids = thread_ids(sheet, si);
-        out.part(&format!("xl/comments{n}.xml"), Some(CT_COMMENTS), comments_xml(sheet, &ids).into_bytes());
-        if !ids.is_empty() {
-            let x = threaded_xml(sheet, &ids, &mut out.persons);
-            out.part(&format!("xl/threadedComments/threadedComment{n}.xml"), Some(CT_THREADED_COMMENTS), x.into_bytes());
-            rels.add_uri(REL_THREADED_COMMENT, &format!("../threadedComments/threadedComment{n}.xml"));
-        }
-        out.default_type("vml", "application/vnd.openxmlformats-officedocument.vmlDrawing");
-        let vml_name = format!("xl/drawings/vmlDrawing{n}.vml");
-        let vml = kept.notes_vml(vml_xml(sheet, out.kept.notes_block(n)), &vml_name, out);
-        out.part(&vml_name, None, vml.into_bytes());
-        rels.add("comments", &format!("../comments{n}.xml"));
-        let rid = rels.add("vmlDrawing", &format!("../drawings/vmlDrawing{n}.vml"));
-        let _ = write!(s, "<legacyDrawing r:id=\"{rid}\"/>");
-    } else if let Some(rid) = kept.lone_vml(&mut rels, out) {
-        let _ = write!(s, "<legacyDrawing r:id=\"{rid}\"/>");
-    }
-    s.push_str(&kept.elements());
-    // Tables.
-    if !tables.is_empty() {
-        let mut parts = String::new();
-        let mut used_names: HashSet<String> = HashSet::new();
-        for (t, cols) in &tables {
-            out.tables += 1;
-            out.table_id += 1;
-            let n = out.tables;
-            let name = table_name(&t.name, &mut used_names, out.table_id);
-            let xml = table_xml(t, cols, &name, out.table_id, out);
-            out.part(&format!("xl/tables/table{n}.xml"), Some(CT_TABLE), xml.into_bytes());
-            let rid = rels.add("table", &format!("../tables/table{n}.xml"));
-            let _ = write!(parts, "<tablePart r:id=\"{rid}\"/>");
-        }
-        let _ = write!(s, "<tableParts count=\"{}\">{parts}</tableParts>", tables.len());
-    }
-    // Excel 2010 extensions: solid data bars, then sparklines.
-    let solid_bars: Vec<(&CondFormat, u32)> = sheet
-        .cond_formats
-        .iter()
-        .enumerate()
-        .filter(|(_, cf)| !cf.ranges.is_empty() && matches!(cf.rule, CfRule::DataBar { gradient: false, .. }))
-        .map(|(i, cf)| (cf, prio.get(i).copied().unwrap_or(1)))
-        .collect();
-    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() {
-        s.push_str("<extLst>");
-    }
-    if !solid_bars.is_empty() {
-        let _ = write!(
-            s,
-            "<ext uri=\"{{78C0D931-6437-407d-A8A1-0F90B4350D7D}}\" xmlns:x14=\"{X14_NS}\" xmlns:xm=\"{XM_NS}\"><x14:conditionalFormattings>"
-        );
-        for (cf, p) in &solid_bars {
-            if let CfRule::DataBar { min, max, .. } = &cf.rule {
-                let (id, lo, hi) = (solid_bar_id(*p), x14_cfvo(min), x14_cfvo(max));
-                let _ = write!(s, "<x14:conditionalFormatting><x14:cfRule type=\"dataBar\" id=\"{id}\"><x14:dataBar gradient=\"0\">{lo}{hi}");
-                let _ = write!(s, "</x14:dataBar></x14:cfRule><xm:sqref>{}</xm:sqref></x14:conditionalFormatting>", sqref(&cf.ranges));
-            }
-        }
-        s.push_str("</x14:conditionalFormattings></ext>");
-    }
-    if !sheet.sparklines.is_empty() {
-        let _ = write!(s, "<ext uri=\"{{05C60535-1F16-4fd2-B633-F4F36F0B64E0}}\" xmlns:x14=\"{X14_NS}\"><x14:sparklineGroups xmlns:xm=\"{XM_NS}\">");
-        for sp in &sheet.sparklines {
-            let ty = match sp.kind {
-                SparklineKind::Line => "",
-                SparklineKind::Column => " type=\"column\"",
-                SparklineKind::WinLoss => " type=\"stacked\"",
-            };
-            let src =
-                if sp.source.contains('!') { sp.source.clone() } else { format!("{}!{}", gridcraft_formula::quote_sheet(&sheet.name), sp.source) };
-            let color = if sp.color == Color::Auto { "rgb=\"FF376092\"".to_string() } else { color_attrs(&sp.color) };
-            let _ = write!(
-                s,
-                "<x14:sparklineGroup displayEmptyCellsAs=\"gap\"{ty}{}><x14:colorSeries {color}/><x14:sparklines><x14:sparkline><xm:f>{}</xm:f><xm:sqref>{}</xm:sqref></x14:sparkline></x14:sparklines></x14:sparklineGroup>",
-                if sp.markers { " markers=\"1\"" } else { "" },
-                esc(&src),
-                sp.cell.a1()
-            );
-        }
-        s.push_str("</x14:sparklineGroups></ext>");
-    }
-    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() {
-        s.push_str("</extLst>");
-    }
-    s.push_str("</worksheet>");
-    (s, rels)
+    prio
 }
 
-fn write_cell(
-    s: &mut String,
-    c: CellRef,
-    cell: Option<&Cell>,
-    picture: Option<&std::sync::Arc<gridcraft_model::CellPicture>>,
-    ov: Option<&String>,
-    extra: Option<&Value>,
-    dynamic: Option<&RangeRef>,
-    sid: &dyn Fn(gridcraft_model::StyleId) -> u32,
-    out: &mut Out,
-) {
+struct SheetCellData<'a> {
+    workbook: &'a Workbook,
+    index: usize,
+    sheet: &'a Sheet,
+    overrides: &'a BTreeMap<CellRef, String>,
+    extra: &'a BTreeMap<CellRef, Value>,
+    dynamic: &'a BTreeMap<CellRef, RangeRef>,
+}
+
+fn write_sheet_data(s: &mut String, data: SheetCellData<'_>, sid: &dyn Fn(gridcraft_model::StyleId) -> u32, out: &mut Out) {
+    let SheetCellData { workbook, index, sheet, overrides, extra, dynamic } = data;
+    // Cell storage is already row-major; sort only when extra cells need merging.
+    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>");
+    let mut row_infos = sheet.rows.iter().peekable();
+    let mut next = 0;
+    loop {
+        let cell_row = keys.get(next).map(|(cell, _)| cell.row);
+        let info_row = row_infos.peek().map(|(row, _)| **row);
+        let row = 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(|(entry_row, _)| **entry_row == row) {
+            Some((_, info)) => *info,
+            None => LineInfo::default(),
+        };
+        let first = next;
+        while keys.get(next).is_some_and(|(cell, _)| cell.row == row) {
+            next += 1;
+        }
+        let cells = keys.get(first..next).unwrap_or_default();
+        if cells.is_empty() && info == LineInfo::default() {
+            continue;
+        }
+        s.push_str("<row r=\"");
+        push_u64(s, u64::from(row) + 1);
+        s.push('"');
+        if let Some(st) = info.style {
+            let _ = write!(s, " s=\"{}\" customFormat=\"1\"", sid(st));
+        }
+        if let Some(h) = info.size {
+            let _ = write!(s, " ht=\"{}\"{}", num(px_to_pt(h)), if info.custom { " customHeight=\"1\"" } else { "" });
+        }
+        if info.hidden {
+            s.push_str(" hidden=\"1\"");
+        }
+        if info.outline > 0 {
+            let _ = write!(s, " outlineLevel=\"{}\"", info.outline.min(7));
+        }
+        if info.collapsed {
+            s.push_str(" collapsed=\"1\"");
+        }
+        if cells.is_empty() {
+            s.push_str("/>");
+            continue;
+        }
+        s.push('>');
+        for &(cell_ref, cell) in cells {
+            let ov = overrides.get(&cell_ref);
+            let ex = extra.get(&cell_ref);
+            let array = dynamic.get(&cell_ref).copied().or_else(|| {
+                let f = cell?.formula.as_ref()?;
+                (f.array.is_none() && crate::array_formula::needs_array(workbook, index, cell_ref, f)).then_some(RangeRef::cell(cell_ref))
+            });
+            write_cell(
+                s,
+                CellWriteInput {
+                    reference: cell_ref,
+                    cell,
+                    picture: sheet.cell_pictures.get(&cell_ref),
+                    header_override: ov,
+                    spill_value: ex,
+                    dynamic_range: array.as_ref(),
+                },
+                sid,
+                out,
+            );
+        }
+        s.push_str("</row>");
+    }
+    s.push_str("</sheetData>");
+}
+
+fn write_sheet_views(s: &mut String, sheet: &Sheet, selected: bool) {
+    s.push_str("<sheetViews><sheetView");
+    if selected {
+        s.push_str(" tabSelected=\"1\"");
+    }
+    if !sheet.show_gridlines {
+        s.push_str(" showGridLines=\"0\"");
+    }
+    if !sheet.show_headings {
+        s.push_str(" showRowColHeaders=\"0\"");
+    }
+    if sheet.show_formulas {
+        s.push_str(" showFormulas=\"1\"");
+    }
+    if !sheet.show_zeros {
+        s.push_str(" showZeros=\"0\"");
+    }
+    if !sheet.show_outline_symbols {
+        s.push_str(" showOutlineSymbols=\"0\"");
+    }
+    if sheet.right_to_left {
+        s.push_str(" rightToLeft=\"1\"");
+    }
+    if sheet.view != gridcraft_model::SheetViewMode::Normal {
+        let _ = write!(s, " view=\"{}\"", sheet.view.as_str());
+    }
+    if sheet.zoom != 100 && (10..=400).contains(&sheet.zoom) {
+        let _ = write!(s, " zoomScale=\"{0}\" zoomScaleNormal=\"{0}\"", sheet.zoom);
+    }
+    if sheet.view_top_left != CellRef::default() && sheet.freeze.is_none() {
+        let _ = write!(s, " topLeftCell=\"{}\"", sheet.view_top_left.a1());
+    }
+    s.push_str(" workbookViewId=\"0\">");
+    let active = sheet.view_active.a1();
+    match sheet.freeze {
+        Some((rows, cols)) if rows > 0 || cols > 0 => {
+            let pane = match (rows > 0, cols > 0) {
+                (true, true) => "bottomRight",
+                (true, false) => "bottomLeft",
+                _ => "topRight",
+            };
+            s.push_str("<pane");
+            if cols > 0 {
+                let _ = write!(s, " xSplit=\"{cols}\"");
+            }
+            if rows > 0 {
+                let _ = write!(s, " ySplit=\"{rows}\"");
+            }
+            let _ = write!(
+                s,
+                " topLeftCell=\"{}\" activePane=\"{pane}\" state=\"frozen\"/>",
+                CellRef::new(
+                    rows.max(sheet.view_top_left.row).min(gridcraft_core::MAX_ROWS - 1),
+                    cols.max(sheet.view_top_left.col).min(gridcraft_core::MAX_COLS - 1)
+                )
+                .a1()
+            );
+            let _ = write!(s, "<selection pane=\"{pane}\" activeCell=\"{active}\" sqref=\"{active}\"/>");
+        }
+        _ => {
+            let _ = write!(s, "<selection activeCell=\"{active}\" sqref=\"{active}\"/>");
+        }
+    }
+    s.push_str("</sheetView></sheetViews>");
+}
+
+fn write_cell(s: &mut String, input: CellWriteInput<'_>, sid: &dyn Fn(gridcraft_model::StyleId) -> u32, out: &mut Out) {
+    let CellWriteInput { reference: c, cell, picture, header_override: ov, spill_value: extra, dynamic_range: dynamic } = input;
     let style = cell.map(|x| sid(x.style)).unwrap_or(0);
     s.push_str("<c r=\"");
     push_a1(s, c);
     s.push('"');
     if style != 0 {
-        s.push_str(" s=\"");
-        push_u64(s, u64::from(style));
-        s.push('"');
+        let _ = write!(s, " s=\"{style}\"");
     }
     if let Some(picture) = picture {
         let vm = out.cell_pictures.index(picture);
@@ -704,19 +751,21 @@ fn write_cell(
         };
         s.push_str(t);
         s.push('>');
-        match f.array.or(dynamic.copied()) {
-            Some(r) => {
-                let _ = write!(s, "<f t=\"array\" ref=\"{}\">", r.a1());
+        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>");
             }
-            None => s.push_str("<f>"),
         }
-        push_esc(s, &crate::fmla::to_file(f));
-        s.push_str("</f>");
         match &value {
             Value::Number(n) => {
-                s.push_str("<v>");
-                push_num(s, *n);
-                s.push_str("</v>");
+                let _ = write!(s, "<v>{}</v>", num(*n));
             }
             Value::Text(t) => {
                 let _ = write!(s, "<v>{}</v>", esc(&encode_xstring(t)));
@@ -735,15 +784,11 @@ fn write_cell(
     match &value {
         Value::Empty | Value::Array(_) => s.push_str("/>"),
         Value::Number(n) => {
-            s.push_str("><v>");
-            push_num(s, *n);
-            s.push_str("</v></c>");
+            let _ = write!(s, "><v>{}</v></c>", num(*n));
         }
         Value::Text(t) => {
             let i = out.sst.index(t);
-            s.push_str(" t=\"s\"><v>");
-            push_u64(s, u64::from(i));
-            s.push_str("</v></c>");
+            let _ = write!(s, " t=\"s\"><v>{i}</v></c>");
         }
         Value::Bool(b) => {
             let _ = write!(s, " t=\"b\"><v>{}</v></c>", *b as u8);
diff --git a/crates/xlsx/src/tests/fixtures.rs b/crates/xlsx/src/tests/fixtures.rs
index 08da55991..6b9dff341 100644
--- a/crates/xlsx/src/tests/fixtures.rs
+++ b/crates/xlsx/src/tests/fixtures.rs
@@ -127,6 +127,12 @@ fn styles_theme_and_sizes() {
     let bytes = minimal(body, &[("xl/styles.xml", styles), ("xl/theme/theme1.xml", theme)], rels, "");
     let (wb, _) = read_xlsx(&bytes).unwrap();
     let s = wb.sheet(0).unwrap();
+    assert_style_definitions(&wb, s);
+    assert_theme(&wb);
+    assert_sheet_settings(s);
+}
+
+fn assert_style_definitions(wb: &gridcraft_model::Workbook, s: &gridcraft_model::Sheet) {
     let st1 = wb.styles.get(s.cell(at("A1")).unwrap().style);
     assert_eq!(st1.num_fmt.as_str(), "0.000\"kg\"");
     assert!(st1.font.bold && st1.font.italic && st1.font.strike);
@@ -152,6 +158,9 @@ fn styles_theme_and_sizes() {
     assert_eq!(st3.fill.pattern, PatternType::DarkGrid);
     assert_eq!(st3.fill.fg, Color::Theme(5, 0));
     assert_eq!(wb.styles.get(s.cell(at("D1")).unwrap().style).num_fmt.as_str(), "General");
+}
+
+fn assert_theme(wb: &gridcraft_model::Workbook) {
     // Theme: file order dk1, lt1… maps to lt1, dk1… in the model.
     assert_eq!(wb.theme.colors[0], 0xFFFFFF);
     assert_eq!(wb.theme.colors[1], 0x000000);
@@ -159,6 +168,9 @@ fn styles_theme_and_sizes() {
     assert_eq!(wb.theme.colors[3], 0x44546A);
     assert_eq!(wb.theme.colors[4], 0x4472C4);
     assert_eq!(wb.theme.major_font, "Calibri Light");
+}
+
+fn assert_sheet_settings(s: &gridcraft_model::Sheet) {
     // Sheet settings.
     assert_eq!(s.tab_color, Some(Color::Rgb(0x00B050)));
     assert_eq!(s.freeze, Some((2, 1)));
diff --git a/crates/xlsx/src/tests/malformed.rs b/crates/xlsx/src/tests/malformed.rs
index 4ee815e86..0fb9f1b43 100644
--- a/crates/xlsx/src/tests/malformed.rs
+++ b/crates/xlsx/src/tests/malformed.rs
@@ -46,6 +46,20 @@ fn missing_parts() {
     assert!(rep.warnings.iter().any(|w| w.contains("no worksheets")));
 }
 
+#[test]
+fn workbook_part_selection_and_validation() {
+    let root_rels = super::ROOT_RELS.replace("xl/workbook.xml", "xl/missing.xml");
+    let workbook = r#"<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"/>"#;
+    let fallback = make_zip(&[("_rels/.rels", root_rels.as_bytes()), ("xl/workbook.xml", workbook.as_bytes())]);
+    assert!(read_xlsx(&fallback).is_ok());
+
+    let wrong_root = make_zip(&[("xl/workbook.xml", b"<worksheet/>")]);
+    assert!(matches!(read_xlsx(&wrong_root), Err(IoError::Format(message)) if message.contains("unexpected root element <worksheet>")));
+
+    let ods = make_zip(&[("content.xml", b"<document/>")]);
+    assert!(matches!(read_xlsx(&ods), Err(IoError::Format(message)) if message.contains("OpenDocument")));
+}
+
 #[test]
 fn huge_coordinates_and_dimensions() {
     let body = r#"<dimension ref="A1:XFD1048576"/><cols><col min="1" max="4000000000" width="1e308"/><col min="0" max="0"/></cols>
diff --git a/crates/xlsx/src/tests/passthrough_tests.rs b/crates/xlsx/src/tests/passthrough_tests.rs
index 343bfa9ee..28113be0d 100644
--- a/crates/xlsx/src/tests/passthrough_tests.rs
+++ b/crates/xlsx/src/tests/passthrough_tests.rs
@@ -213,6 +213,14 @@ fn unmodelled_parts_survive_a_round_trip() {
     let out = write_xlsx(&wb).unwrap();
     let u = Unpacked::new(&out);
     u.assert_valid();
+    assert_kept_workbook_parts(&u);
+    let sheet = sheet_part(&u, "Data");
+    let sx = u.text(&sheet);
+    assert_kept_sheet_parts(&u, &sheet, &sx);
+    assert_round_trip_kept_content(&wb, &out);
+}
+
+fn assert_kept_workbook_parts(u: &Unpacked) {
     // Every kept part is in the output byte for byte.
     for d in [
         PRINTER,
@@ -244,34 +252,37 @@ fn unmodelled_parts_survive_a_round_trip() {
     let item = u.find(CUSTOM_XML.as_bytes())[0].clone();
     assert!(u.rels(&item).iter().any(|r| r.1.ends_with("/customXmlProps")));
     // Formulas using the link are written as they were.
-    let sheet = sheet_part(&u, "Data");
+    let sheet = sheet_part(u, "Data");
     let sx = u.text(&sheet);
     assert!(sx.contains("<f>[1]Sheet1!$A$1</f>"), "{sx}");
     assert!(sx.contains("<f>SUM([1]Sheet1!A1:A3)*2</f>"), "{sx}");
+}
+
+fn assert_kept_sheet_parts(u: &Unpacked, sheet: &str, sx: &str) {
     // Printer settings (#324).
-    let ps = attr_of(&sx, "pageSetup", "r:id");
-    let (ty, target) = u.target(&sheet, &ps);
+    let ps = attr_of(sx, "pageSetup", "r:id");
+    let (ty, target) = u.target(sheet, &ps);
     assert!(ty.ends_with("/printerSettings"));
     assert_eq!(u.parts.get(&target).unwrap(), PRINTER);
     // The OLE object and its preview image, re-linked.
-    let ole = attr_of(&sx, "oleObject", "r:id");
-    assert_eq!(u.parts.get(&u.target(&sheet, &ole).1).unwrap(), OLE);
-    let preview = attr_of(&sx, "objectPr", "r:id");
-    assert_eq!(u.parts.get(&u.target(&sheet, &preview).1).unwrap(), EMF);
+    let ole = attr_of(sx, "oleObject", "r:id");
+    assert_eq!(u.parts.get(&u.target(sheet, &ole).1).unwrap(), OLE);
+    let preview = attr_of(sx, "objectPr", "r:id");
+    assert_eq!(u.parts.get(&u.target(sheet, &preview).1).unwrap(), EMF);
     // Namespace declarations travel with the fragment.
-    assert_eq!(attr_of(&sx, "mc:AlternateContent", "xmlns:mc"), "http://schemas.openxmlformats.org/markup-compatibility/2006");
-    assert_eq!(attr_of(&sx, "mc:AlternateContent", "xmlns:x14"), "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main");
+    assert_eq!(attr_of(sx, "mc:AlternateContent", "xmlns:mc"), "http://schemas.openxmlformats.org/markup-compatibility/2006");
+    assert_eq!(attr_of(sx, "mc:AlternateContent", "xmlns:x14"), "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main");
     // The form control.
-    let ctrl = attr_of(&sx, "control", "r:id");
-    assert_eq!(u.parts.get(&u.target(&sheet, &ctrl).1).unwrap(), CTRL_PROP.as_bytes());
+    let ctrl = attr_of(sx, "control", "r:id");
+    assert_eq!(u.parts.get(&u.target(sheet, &ctrl).1).unwrap(), CTRL_PROP.as_bytes());
     // Schema order: pageSetup < legacyDrawing < oleObjects < controls.
     let pos = |t: &str| sx.find(t).unwrap_or_else(|| panic!("no {t}"));
     assert!(pos("<pageSetup") < pos("<legacyDrawing") && pos("<legacyDrawing") < pos("<oleObjects") && pos("<oleObjects") < pos("<controls"));
     // Query table: a sheet relationship only.
-    assert!(u.rels(&sheet).iter().any(|r| r.1.ends_with("/queryTable") && u.parts.get(&r.2).is_some_and(|b| b == QUERY_TABLE.as_bytes())));
+    assert!(u.rels(sheet).iter().any(|r| r.1.ends_with("/queryTable") && u.parts.get(&r.2).is_some_and(|b| b == QUERY_TABLE.as_bytes())));
     // One VML drawing: the kept control shapes plus GridCraft's note, in a fresh shape block.
-    let vml_id = attr_of(&sx, "legacyDrawing", "r:id");
-    let vml_part = u.target(&sheet, &vml_id).1;
+    let vml_id = attr_of(sx, "legacyDrawing", "r:id");
+    let vml_part = u.target(sheet, &vml_id).1;
     let vml = u.text(&vml_part);
     assert!(vml.contains("_x0000_s1025") && vml.contains("_x0000_s1026"));
     assert!(!vml.contains("old note") && !vml.contains("_x0000_s1027"), "the source's note shape is replaced");
@@ -280,9 +291,11 @@ fn unmodelled_parts_survive_a_round_trip() {
     let img = u.rels(&vml_part);
     assert_eq!(img.len(), 1);
     assert_eq!(u.parts.get(&img[0].2).unwrap(), EMF);
+}
 
+fn assert_round_trip_kept_content(wb: &gridcraft_model::Workbook, out: &[u8]) {
     // Reading the output keeps the same content again.
-    let (wb2, rep2) = read_xlsx(&out).unwrap();
+    let (wb2, rep2) = read_xlsx(out).unwrap();
     assert!(!rep2.warnings.iter().any(|w| w.contains("dropped")), "{:?}", rep2.warnings);
     let a = wb.sheet(0).unwrap().preserved.as_deref().unwrap();
     let b = wb2.sheet(0).unwrap().preserved.as_deref().unwrap();
@@ -293,7 +306,6 @@ fn unmodelled_parts_survive_a_round_trip() {
     assert_eq!(da, db);
     assert_eq!(a.elements.len(), b.elements.len());
     assert_eq!(wb.preserved.as_deref().unwrap().parts.len(), wb2.preserved.as_deref().unwrap().parts.len());
-    u.assert_valid();
 }
 
 #[test]
diff --git a/crates/xlsx/src/tests/pivot_tests.rs b/crates/xlsx/src/tests/pivot_tests.rs
index b9123e432..111eacd47 100644
--- a/crates/xlsx/src/tests/pivot_tests.rs
+++ b/crates/xlsx/src/tests/pivot_tests.rs
@@ -236,104 +236,119 @@ fn pivots_round_trip() {
 
 #[test]
 fn pivot_package_structure() {
-    let bytes = write_xlsx(&workbook()).unwrap();
-    let parts = unzip(&bytes);
+    let parts = unzip(&write_xlsx(&workbook()).unwrap());
+    assert_pivot_content_types(&parts);
+    assert_relationship_targets_exist(&parts);
+    let cache_ids = assert_workbook_cache_relationships(&parts);
+    assert_pivot_tables_reference_caches(&parts, &cache_ids);
+    assert_sheet_pivot_relationships(&parts);
+}
+
+fn assert_pivot_content_types(parts: &HashMap<String, Vec<u8>>) {
     let ct = xml::parse(parts.get("[Content_Types].xml").unwrap()).unwrap();
     let overrides: HashMap<String, String> = ct
         .kids("Override")
         .map(|o| (o.attr("PartName").unwrap().trim_start_matches('/').to_string(), o.attr("ContentType").unwrap().to_string()))
         .collect();
     let defaults: HashSet<String> = ct.kids("Default").map(|d| d.attr("Extension").unwrap().to_string()).collect();
-    // Every override names an existing part; every part has a content type.
-    for p in overrides.keys() {
-        assert!(parts.contains_key(p), "override for missing part {p}");
+    for part in overrides.keys() {
+        assert!(parts.contains_key(part), "override for missing part {part}");
     }
-    for p in parts.keys() {
-        if p == "[Content_Types].xml" {
-            continue;
-        }
-        let ext = p.rsplit('.').next().unwrap();
-        assert!(overrides.contains_key(p) || defaults.contains(ext), "no content type for {p}");
+    for part in parts.keys().filter(|p| p.as_str() != "[Content_Types].xml") {
+        let ext = part.rsplit('.').next().unwrap();
+        assert!(overrides.contains_key(part) || defaults.contains(ext), "no content type for {part}");
     }
-    let count = |ct: &str| overrides.values().filter(|v| v.as_str() == ct).count();
+    let count = |content_type: &str| overrides.values().filter(|value| value.as_str() == content_type).count();
     assert_eq!(count(crate::pivot::CT_PIVOT_TABLE), 3);
     assert_eq!(count(crate::pivot::CT_PIVOT_CACHE_DEF), 3);
     assert_eq!(count(crate::pivot::CT_PIVOT_CACHE_REC), 3);
-    // Every relationship target exists.
-    let mut kinds: Vec<String> = vec![];
-    for (name, data) in &parts {
-        if !name.ends_with(".rels") {
-            continue;
-        }
+}
+
+fn assert_relationship_targets_exist(parts: &HashMap<String, Vec<u8>>) {
+    let mut kinds: Vec<String> = Vec::new();
+    for (name, data) in parts.iter().filter(|(name, _)| name.ends_with(".rels")) {
         let dir = name.trim_end_matches(".rels").rsplit_once("/_rels/").map(|(d, _)| d).unwrap_or("");
-        let rels = xml::parse(data).unwrap();
-        for r in rels.kids("Relationship") {
-            if r.attr("TargetMode") == Some("External") {
+        for relation in xml::parse(data).unwrap().kids("Relationship") {
+            if relation.attr("TargetMode") == Some("External") {
                 continue;
             }
-            let target = crate::package::resolve(dir, r.attr("Target").unwrap());
+            let target = crate::package::resolve(dir, relation.attr("Target").unwrap());
             assert!(parts.contains_key(&target), "{name} points at missing {target}");
-            kinds.push(r.attr("Type").unwrap().rsplit('/').next().unwrap().to_string());
+            kinds.push(relation.attr("Type").unwrap().rsplit('/').next().unwrap().to_string());
         }
     }
-    for k in ["pivotTable", "pivotCacheDefinition", "pivotCacheRecords"] {
-        assert!(kinds.iter().any(|x| x == k), "no {k} relationship");
+    for kind in ["pivotTable", "pivotCacheDefinition", "pivotCacheRecords"] {
+        assert!(kinds.iter().any(|found| found == kind), "no {kind} relationship");
     }
-    // The workbook lists the caches by id with relationships of the right type.
-    let wbx = xml::parse(parts.get("xl/workbook.xml").unwrap()).unwrap();
-    let wb_rels = xml::parse(parts.get("xl/_rels/workbook.xml.rels").unwrap()).unwrap();
-    let caches: Vec<&xml::El> = wbx.child("pivotCaches").unwrap().kids("pivotCache").collect();
+}
+
+fn assert_workbook_cache_relationships(parts: &HashMap<String, Vec<u8>>) -> HashSet<String> {
+    let workbook = xml::parse(parts.get("xl/workbook.xml").unwrap()).unwrap();
+    let relationships = xml::parse(parts.get("xl/_rels/workbook.xml.rels").unwrap()).unwrap();
+    let caches: Vec<&xml::El> = workbook.child("pivotCaches").unwrap().kids("pivotCache").collect();
     assert_eq!(caches.len(), 3);
     let mut ids = HashSet::new();
-    for c in &caches {
-        assert!(ids.insert(c.attr("cacheId").unwrap().to_string()));
-        let rid = c.attr("id").unwrap();
-        let rel = wb_rels.kids("Relationship").find(|r| r.attr("Id") == Some(rid)).unwrap();
-        assert!(rel.attr("Type").unwrap().ends_with("/pivotCacheDefinition"));
+    for cache in &caches {
+        assert!(ids.insert(cache.attr("cacheId").unwrap().to_string()));
+        let rid = cache.attr("id").unwrap();
+        let relation = relationships.kids("Relationship").find(|r| r.attr("Id") == Some(rid)).unwrap();
+        assert!(relation.attr("Type").unwrap().ends_with("/pivotCacheDefinition"));
     }
-    // Each table's cacheId is one of the workbook's caches and its field counts agree.
-    for t in 1..=3 {
-        let pt = xml::parse(parts.get(&format!("xl/pivotTables/pivotTable{t}.xml")).unwrap()).unwrap();
-        assert!(ids.contains(pt.attr("cacheId").unwrap()));
-        let trels = xml::parse(parts.get(&format!("xl/pivotTables/_rels/pivotTable{t}.xml.rels")).unwrap()).unwrap();
-        let target = crate::package::resolve("xl/pivotTables", trels.kids("Relationship").next().unwrap().attr("Target").unwrap());
-        let cache = xml::parse(parts.get(&target).unwrap()).unwrap();
-        let nf = cache.child("cacheFields").unwrap().kids("cacheField").count();
-        assert_eq!(pt.child("pivotFields").unwrap().kids("pivotField").count(), nf);
-        assert_eq!(cache.child("cacheFields").unwrap().attr_u32("count"), Some(nf as u32));
-        // Item indices stay inside the shared/group items.
-        for (i, pf) in pt.child("pivotFields").unwrap().kids("pivotField").enumerate() {
-            let cf = cache.child("cacheFields").unwrap().kids("cacheField").nth(i).unwrap();
-            let n = cf
-                .path(&["fieldGroup", "groupItems"])
-                .map(|g| g.children.len())
-                .unwrap_or_else(|| cf.child("sharedItems").map(|s| s.children.len()).unwrap_or(0));
-            if let Some(items) = pf.child("items") {
-                assert_eq!(items.attr_u32("count"), Some(items.children.len() as u32));
-                for it in items.kids("item") {
-                    if let Some(x) = it.attr_u32("x") {
-                        assert!((x as usize) < n, "item x={x} out of {n} in table {t} field {i}");
-                    }
+    ids
+}
+
+fn assert_pivot_tables_reference_caches(parts: &HashMap<String, Vec<u8>>, ids: &HashSet<String>) {
+    for table_number in 1..=3 {
+        let table = xml::parse(parts.get(&format!("xl/pivotTables/pivotTable{table_number}.xml")).unwrap()).unwrap();
+        assert!(ids.contains(table.attr("cacheId").unwrap()));
+        let table_rels = xml::parse(parts.get(&format!("xl/pivotTables/_rels/pivotTable{table_number}.xml.rels")).unwrap()).unwrap();
+        let cache_path = crate::package::resolve("xl/pivotTables", table_rels.kids("Relationship").next().unwrap().attr("Target").unwrap());
+        let cache = xml::parse(parts.get(&cache_path).unwrap()).unwrap();
+        assert_pivot_table_fields_match_cache(&table, &cache);
+        assert_pivot_cache_records_match_fields(parts, &cache, &cache_path);
+    }
+}
+
+fn assert_pivot_table_fields_match_cache(table: &xml::El, cache: &xml::El) {
+    let cache_fields = cache.child("cacheFields").unwrap();
+    let field_count = cache_fields.kids("cacheField").count();
+    assert_eq!(table.child("pivotFields").unwrap().kids("pivotField").count(), field_count);
+    assert_eq!(cache_fields.attr_u32("count"), Some(field_count as u32));
+    for (field_index, pivot_field) in table.child("pivotFields").unwrap().kids("pivotField").enumerate() {
+        let cache_field = cache_fields.kids("cacheField").nth(field_index).unwrap();
+        let item_count = cache_field
+            .path(&["fieldGroup", "groupItems"])
+            .map(|items| items.children.len())
+            .unwrap_or_else(|| cache_field.child("sharedItems").map(|items| items.children.len()).unwrap_or(0));
+        if let Some(items) = pivot_field.child("items") {
+            assert_eq!(items.attr_u32("count"), Some(items.children.len() as u32));
+            for item in items.kids("item") {
+                if let Some(item_index) = item.attr_u32("x") {
+                    assert!((item_index as usize) < item_count, "item x={item_index} out of {item_count} in field {field_index}");
                 }
             }
         }
-        // Records match the database fields.
-        if let Some(rid) = cache.attr("id") {
-            let crels_name = target.replace("pivotCache/", "pivotCache/_rels/") + ".rels";
-            let crels = xml::parse(parts.get(&crels_name).unwrap()).unwrap();
-            let rel = crels.kids("Relationship").find(|r| r.attr("Id") == Some(rid)).unwrap();
-            let rec = xml::parse(parts.get(&crate::package::resolve("xl/pivotCache", rel.attr("Target").unwrap())).unwrap()).unwrap();
-            let db = cache.child("cacheFields").unwrap().kids("cacheField").filter(|f| f.attr("databaseField") != Some("0")).count();
-            assert_eq!(rec.attr_u32("count"), cache.attr_u32("recordCount"));
-            assert_eq!(rec.kids("r").count(), 8);
-            for r in rec.kids("r") {
-                assert_eq!(r.children.len(), db);
-            }
-        }
     }
-    // Sheet 2 (Report) relates to all three tables.
-    let srels = xml::parse(parts.get("xl/worksheets/_rels/sheet2.xml.rels").unwrap()).unwrap();
-    assert_eq!(srels.kids("Relationship").filter(|r| r.attr("Type").unwrap().ends_with("/pivotTable")).count(), 3);
+}
+
+fn assert_pivot_cache_records_match_fields(parts: &HashMap<String, Vec<u8>>, cache: &xml::El, cache_path: &str) {
+    let Some(rid) = cache.attr("id") else { return };
+    let rels_path = cache_path.replace("pivotCache/", "pivotCache/_rels/") + ".rels";
+    let cache_rels = xml::parse(parts.get(&rels_path).unwrap()).unwrap();
+    let relation = cache_rels.kids("Relationship").find(|r| r.attr("Id") == Some(rid)).unwrap();
+    let records_path = crate::package::resolve("xl/pivotCache", relation.attr("Target").unwrap());
+    let records = xml::parse(parts.get(&records_path).unwrap()).unwrap();
+    let database_fields = cache.child("cacheFields").unwrap().kids("cacheField").filter(|f| f.attr("databaseField") != Some("0")).count();
+    assert_eq!(records.attr_u32("count"), cache.attr_u32("recordCount"));
+    assert_eq!(records.kids("r").count(), 8);
+    for record in records.kids("r") {
+        assert_eq!(record.children.len(), database_fields);
+    }
+}
+
+fn assert_sheet_pivot_relationships(parts: &HashMap<String, Vec<u8>>) {
+    let sheet_rels = xml::parse(parts.get("xl/worksheets/_rels/sheet2.xml.rels").unwrap()).unwrap();
+    assert_eq!(sheet_rels.kids("Relationship").filter(|r| r.attr("Type").unwrap().ends_with("/pivotTable")).count(), 3);
 }
 
 #[test]
diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs
index 14fc784f9..2298e513f 100644
--- a/crates/xlsx/src/tests/roundtrip.rs
+++ b/crates/xlsx/src/tests/roundtrip.rs
@@ -490,7 +490,16 @@ fn full_roundtrip() {
     assert_eq!(write_xlsx(&wb).unwrap(), bytes, "output is deterministic");
     let (back, rep) = read_xlsx(&bytes).unwrap();
     assert!(rep.warnings.iter().all(|w| !w.contains("skipped") || w.contains("chart")), "{:?}", rep.warnings);
+    assert_workbook_metadata_roundtrip(&wb, &back);
 
+    let (a, b) = (wb.sheet(0).unwrap(), back.sheet(0).unwrap());
+    assert_sheet_cells_and_settings(&wb, &back, a, b);
+    assert_table_roundtrip(a, b);
+    assert_drawing_and_chart_roundtrip(a, b);
+    assert_eq!(back.sheet(1).unwrap().value(at("A1")), Value::Number(5.0));
+}
+
+fn assert_workbook_metadata_roundtrip(wb: &Workbook, back: &Workbook) {
     assert_eq!(back.date_system, wb.date_system);
     assert_eq!(back.calc, wb.calc);
     assert!(back.protected_structure);
@@ -505,8 +514,9 @@ fn full_roundtrip() {
     assert_eq!(back.sheets[2].visibility, Visibility::VeryHidden);
     assert_eq!(back.sheets[2].name, "2024");
     assert_eq!(back.sheets[2].comments, wb.sheets[2].comments);
+}
 
-    let (a, b) = (wb.sheet(0).unwrap(), back.sheet(0).unwrap());
+fn assert_sheet_cells_and_settings(wb: &Workbook, back: &Workbook, a: &Sheet, b: &Sheet) {
     assert_eq!(b.name, a.name);
     // Cells: values, formulas and resolved styles.
     let skip = [at("H2"), at("H3")];
@@ -542,6 +552,9 @@ fn full_roundtrip() {
     let mut sp = a.sparklines.clone();
     sp[0].source = "'Data & Stuff'!B2:B3".into();
     assert_eq!(b.sparklines, sp);
+}
+
+fn assert_table_roundtrip(a: &Sheet, b: &Sheet) {
     // Tables: name sanitized, ids reassigned.
     let (ta, tb) = (&a.tables[0], &b.tables[0]);
     assert_eq!(tb.name, "Sales_Table");
@@ -549,6 +562,9 @@ fn full_roundtrip() {
     assert_eq!((tb.banded_rows, tb.banded_cols, tb.first_col, tb.last_col, tb.filter_button), (true, true, true, false, true));
     assert_eq!(tb.filter, ta.filter, "the table's filter criteria survive (SUBTOTAL tells filtered rows apart)");
     assert_eq!(b.value(at("P1")), Value::text("Region"), "header cells carry the column names");
+}
+
+fn assert_drawing_and_chart_roundtrip(a: &Sheet, b: &Sheet) {
     // Drawings.
     assert_eq!(b.images.len(), 1);
     assert_eq!(b.images[0].data, a.images[0].data);
@@ -587,7 +603,6 @@ fn full_roundtrip() {
         }
         assert!(close(y.anchor.width, x.anchor.width) && close(y.anchor.height, x.anchor.height));
     }
-    assert_eq!(back.sheet(1).unwrap().value(at("A1")), Value::Number(5.0));
 }
 
 #[test]
diff --git a/crates/xlsx/src/tests/xls_tests.rs b/crates/xlsx/src/tests/xls_tests.rs
index da65de014..bd21b4939 100644
--- a/crates/xlsx/src/tests/xls_tests.rs
+++ b/crates/xlsx/src/tests/xls_tests.rs
@@ -307,58 +307,74 @@ fn reads_values_formulas_formats_and_layout() {
         assert!(report.warnings[0].contains("Excel 97-2003"), "{:?}", report.warnings);
         assert!(report.warnings.iter().any(|w| w.contains("Chart sheets")));
         assert_eq!(wb.sheets.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["Sheet1", "Data"]);
-        assert_eq!(v(&wb, 0, "A1"), Value::from("Hello"));
-        assert_eq!(v(&wb, 0, "B1"), Value::Number(1.5));
-        assert_eq!(v(&wb, 0, "C1"), Value::Number(42.0));
-        assert_eq!(v(&wb, 0, "D1"), Value::from("Wörld"));
-        assert_eq!(v(&wb, 0, "A2"), Value::Bool(true));
-        assert_eq!(v(&wb, 0, "B2"), Value::Error(CellError::Div0));
-        assert_eq!(v(&wb, 0, "C2"), Value::Number(7.0));
-        assert_eq!(v(&wb, 0, "D2"), Value::Number(1.5));
-        // Formulas: text plus the cached result.
-        assert_eq!(ftext(&wb, "A3").as_deref(), Some("B1*2"));
-        assert_eq!(v(&wb, 0, "A3"), Value::Number(3.0));
-        assert_eq!(ftext(&wb, "B3").as_deref(), Some("SUM(B1:C1)"));
-        assert_eq!(ftext(&wb, "C3").as_deref(), Some("A1&\"!\""));
-        assert_eq!(v(&wb, 0, "C3"), Value::from("Hello!"));
-        assert_eq!(ftext(&wb, "D3").as_deref(), Some("B1>1"));
-        assert_eq!(v(&wb, 0, "D3"), Value::Bool(true));
-        assert_eq!(ftext(&wb, "E3").as_deref(), Some("Rate*2"));
-        assert_eq!(ftext(&wb, "F3").as_deref(), Some("ROUND(B1,0)"));
-        assert_eq!(ftext(&wb, "G3").as_deref(), Some("Data!A1"));
-        assert_eq!(v(&wb, 0, "H3"), Value::Error(CellError::NA));
-        // Shared formula: relative offsets resolve per cell.
-        assert_eq!(ftext(&wb, "B5").as_deref(), Some("A5*10"));
-        assert_eq!(ftext(&wb, "B6").as_deref(), Some("A6*10"));
-        // Array formula: the anchor holds it; the other cell's cached result is dropped so that
-        // the formula fills the range on recalculation (as when an .xlsx is read, #156).
-        let c5 = wb.sheets[0].cell(CellRef::parse("C5").unwrap()).unwrap().formula.clone().unwrap();
-        assert_eq!((c5.text.as_str(), c5.array), ("A5:A6*2", Some(RangeRef::parse("C5:C6").unwrap())));
-        assert_eq!(ftext(&wb, "C6"), None);
-        assert_eq!(v(&wb, 0, "C6"), Value::Empty);
-        // Number formats, merges, sizes, names, print area; embedded chart records ignored.
-        let sh = &wb.sheets[0];
-        assert_eq!(wb.styles.get(sh.style_id(CellRef::parse("A4").unwrap())).num_fmt.as_str(), "yyyy-mm-dd");
-        assert_eq!(wb.styles.get(sh.style_id(CellRef::parse("B4").unwrap())).num_fmt.as_str(), "0.00%");
-        assert_eq!(sh.merges, vec![RangeRef::parse("A7:B7").unwrap()]);
-        assert!(sh.cols.get(&0).unwrap().size.unwrap() > sh.default_col_width);
-        assert_eq!(sh.rows.get(&0).unwrap().size, Some(40.0));
-        assert!(!sh.rows.get(&0).unwrap().hidden && sh.rows.get(&0).unwrap().custom);
-        assert_eq!(sh.print.print_area, RangeRef::parse("A1:B2"));
-        assert_eq!(v(&wb, 0, "J10"), Value::Empty);
-        assert_eq!(wb.names.len(), 1);
-        assert_eq!((wb.names[0].name.as_str(), wb.names[0].formula.as_str()), ("Rate", "Data!$A$1"));
-        assert_eq!(v(&wb, 1, "A1"), Value::Number(7.0));
-        assert_eq!(wb.date_system, DateSystem::D1900);
-        // The import saves as .xlsx and reads back.
-        let (back, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
-        assert_eq!(back.sheets[0].cell(CellRef::parse("A3").unwrap()).unwrap().formula.as_ref().unwrap().text, "B1*2");
-        assert_eq!(back.sheets[0].value(CellRef::parse("C3").unwrap()), Value::from("Hello!"));
+        assert_values_roundtrip(&wb);
+        assert_formula_roundtrip(&wb);
+        assert_layout_roundtrip(&wb);
+        assert_xlsx_conversion(&wb);
     }
     let (wb, _) = read_xls(&compound("Workbook", &sample(true))).unwrap();
     assert_eq!(wb.date_system, DateSystem::D1904);
 }
 
+fn assert_values_roundtrip(wb: &gridcraft_model::Workbook) {
+    assert_eq!(v(wb, 0, "A1"), Value::from("Hello"));
+    assert_eq!(v(wb, 0, "B1"), Value::Number(1.5));
+    assert_eq!(v(wb, 0, "C1"), Value::Number(42.0));
+    assert_eq!(v(wb, 0, "D1"), Value::from("Wörld"));
+    assert_eq!(v(wb, 0, "A2"), Value::Bool(true));
+    assert_eq!(v(wb, 0, "B2"), Value::Error(CellError::Div0));
+    assert_eq!(v(wb, 0, "C2"), Value::Number(7.0));
+    assert_eq!(v(wb, 0, "D2"), Value::Number(1.5));
+}
+
+fn assert_formula_roundtrip(wb: &gridcraft_model::Workbook) {
+    // Formulas: text plus the cached result.
+    assert_eq!(ftext(wb, "A3").as_deref(), Some("B1*2"));
+    assert_eq!(v(wb, 0, "A3"), Value::Number(3.0));
+    assert_eq!(ftext(wb, "B3").as_deref(), Some("SUM(B1:C1)"));
+    assert_eq!(ftext(wb, "C3").as_deref(), Some("A1&\"!\""));
+    assert_eq!(v(wb, 0, "C3"), Value::from("Hello!"));
+    assert_eq!(ftext(wb, "D3").as_deref(), Some("B1>1"));
+    assert_eq!(v(wb, 0, "D3"), Value::Bool(true));
+    assert_eq!(ftext(wb, "E3").as_deref(), Some("Rate*2"));
+    assert_eq!(ftext(wb, "F3").as_deref(), Some("ROUND(B1,0)"));
+    assert_eq!(ftext(wb, "G3").as_deref(), Some("Data!A1"));
+    assert_eq!(v(wb, 0, "H3"), Value::Error(CellError::NA));
+    // Shared formula: relative offsets resolve per cell.
+    assert_eq!(ftext(wb, "B5").as_deref(), Some("A5*10"));
+    assert_eq!(ftext(wb, "B6").as_deref(), Some("A6*10"));
+    // Array formula: the anchor holds it; the other cell's cached result is dropped so that
+    // the formula fills the range on recalculation (as when an .xlsx is read, #156).
+    let c5 = wb.sheets[0].cell(CellRef::parse("C5").unwrap()).unwrap().formula.clone().unwrap();
+    assert_eq!((c5.text.as_str(), c5.array), ("A5:A6*2", Some(RangeRef::parse("C5:C6").unwrap())));
+    assert_eq!(ftext(wb, "C6"), None);
+    assert_eq!(v(wb, 0, "C6"), Value::Empty);
+}
+
+fn assert_layout_roundtrip(wb: &gridcraft_model::Workbook) {
+    // Number formats, merges, sizes, names, print area; embedded chart records ignored.
+    let sh = &wb.sheets[0];
+    assert_eq!(wb.styles.get(sh.style_id(CellRef::parse("A4").unwrap())).num_fmt.as_str(), "yyyy-mm-dd");
+    assert_eq!(wb.styles.get(sh.style_id(CellRef::parse("B4").unwrap())).num_fmt.as_str(), "0.00%");
+    assert_eq!(sh.merges, vec![RangeRef::parse("A7:B7").unwrap()]);
+    assert!(sh.cols.get(&0).unwrap().size.unwrap() > sh.default_col_width);
+    assert_eq!(sh.rows.get(&0).unwrap().size, Some(40.0));
+    assert!(!sh.rows.get(&0).unwrap().hidden && sh.rows.get(&0).unwrap().custom);
+    assert_eq!(sh.print.print_area, RangeRef::parse("A1:B2"));
+    assert_eq!(v(wb, 0, "J10"), Value::Empty);
+    assert_eq!(wb.names.len(), 1);
+    assert_eq!((wb.names[0].name.as_str(), wb.names[0].formula.as_str()), ("Rate", "Data!$A$1"));
+    assert_eq!(v(wb, 1, "A1"), Value::Number(7.0));
+    assert_eq!(wb.date_system, DateSystem::D1900);
+}
+
+fn assert_xlsx_conversion(wb: &gridcraft_model::Workbook) {
+    // The import saves as .xlsx and reads back.
+    let (back, _) = read_xlsx(&write_xlsx(wb).unwrap()).unwrap();
+    assert_eq!(back.sheets[0].cell(CellRef::parse("A3").unwrap()).unwrap().formula.as_ref().unwrap().text, "B1*2");
+    assert_eq!(back.sheets[0].value(CellRef::parse("C3").unwrap()), Value::from("Hello!"));
+}
+
 #[test]
 fn text_result_of_a_formula_kept_as_its_value() {
     // A what-if data table cell ({=TABLE(B1,)}) can't be imported as a formula, so its saved result
diff --git a/crates/xlsx/src/write.rs b/crates/xlsx/src/write.rs
index b96df35c7..f03dd9b04 100644
--- a/crates/xlsx/src/write.rs
+++ b/crates/xlsx/src/write.rs
@@ -243,7 +243,6 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
     out.default_type("xml", "application/xml");
 
     // 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()
     } else {
@@ -251,92 +250,9 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
     };
 
     let mut wb_rels = Rels::default();
-    // Kept content first: the chart sheets among the worksheets need their relationship ids.
-    let kept = crate::passthrough::write_workbook(wb, &mut wb_rels, &mut out);
-    let mut pivots = crate::pivot::PivotWriter::default();
-    let mut sheets_xml = String::new();
-    let mut ids = crate::passthrough::SheetIds::new(wb, &kept);
-    for (i, sheet) in wb.sheets.iter().enumerate() {
-        sheets_xml.push_str(&kept.sheet_entries(i, false, &mut ids));
-        let (xml, mut rels) = crate::sheet_write::write_sheet(wb, i, i == active, &mut out);
-        pivots.add_sheet(wb, i, &mut out, &mut rels);
-        let name = format!("xl/worksheets/sheet{}.xml", i + 1);
-        out.part(&name, Some(CT_WORKSHEET), xml.into_bytes());
-        if !rels.is_empty() {
-            out.part(&format!("xl/worksheets/_rels/sheet{}.xml.rels", i + 1), None, rels.xml().into_bytes());
-        }
-        let rid = wb_rels.add("worksheet", &format!("worksheets/sheet{}.xml", i + 1));
-        let state = match sheet.visibility {
-            Visibility::Visible => "",
-            _ if !any_visible && i == active => "",
-            Visibility::Hidden => " state=\"hidden\"",
-            Visibility::VeryHidden => " state=\"veryHidden\"",
-        };
-        let name: String = sheet.name.chars().take(31).collect();
-        let sheet_id = ids.take(sheet.file_id);
-        let _ = write!(sheets_xml, "<sheet name=\"{}\" sheetId=\"{sheet_id}\"{state} r:id=\"{rid}\"/>", esc_attr(&name));
-    }
-    sheets_xml.push_str(&kept.sheet_entries(wb.sheets.len(), true, &mut ids));
+    let (sheets_xml, kept, pivots) = write_sheets(wb, &mut out, active, &mut wb_rels);
 
-    // Defined names, then print areas and titles.
-    let mut names = String::new();
-    let mut seen = std::collections::HashSet::new();
-    for n in &wb.names {
-        if n.name.is_empty() || !seen.insert((n.name.to_ascii_lowercase(), n.scope)) {
-            continue;
-        }
-        if let Some(sc) = n.scope
-            && sc >= wb.sheets.len()
-        {
-            continue;
-        }
-        let _ = write!(names, "<definedName name=\"{}\"", esc_attr(&n.name));
-        if let Some(sc) = n.scope {
-            let _ = write!(names, " localSheetId=\"{}\"", kept.file_index(sc));
-        }
-        if n.hidden {
-            names.push_str(" hidden=\"1\"");
-        }
-        if !n.comment.is_empty() {
-            let _ = write!(names, " comment=\"{}\"", esc_attr(&n.comment));
-        }
-        let _ = write!(names, ">{}</definedName>", esc(&crate::fmla::text_to_file(&n.formula)));
-    }
-    for (i, f) in out.chart_names.iter().enumerate() {
-        let _ = write!(
-            names,
-            "<definedName name=\"{}{i}\" hidden=\"1\">{}</definedName>",
-            crate::chartex::NAME_PREFIX,
-            esc(&crate::fmla::text_to_file(f))
-        );
-    }
-    for (i, sheet) in wb.sheets.iter().enumerate() {
-        let q = quote_sheet(&sheet.name);
-        if let Some(pa) = &sheet.print.print_area {
-            let _ = write!(
-                names,
-                "<definedName name=\"_xlnm.Print_Area\" localSheetId=\"{}\">{}!{}</definedName>",
-                kept.file_index(i),
-                esc(&q),
-                abs_range(pa)
-            );
-        }
-        let mut titles = vec![];
-        if let Some((c0, c1)) = sheet.print.title_cols {
-            titles.push(format!("{q}!{}", abs_range(&RangeRef::cols(c0.min(c1), c0.max(c1)))));
-        }
-        if let Some((r0, r1)) = sheet.print.title_rows {
-            titles.push(format!("{q}!{}", abs_range(&RangeRef::rows(r0.min(r1), r0.max(r1)))));
-        }
-        if !titles.is_empty() {
-            let _ = write!(
-                names,
-                "<definedName name=\"_xlnm.Print_Titles\" localSheetId=\"{}\">{}</definedName>",
-                kept.file_index(i),
-                esc(&titles.join(","))
-            );
-        }
-    }
+    let names = write_defined_names(wb, &kept, &out.chart_names);
 
     let mut w = format!("{XML_DECL}<workbook xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\">");
     // A workbook read from a file keeps its <fileVersion> as it was: Excel trusts the saved values
@@ -510,5 +426,106 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
     zip.finish()
 }
 
+fn write_sheets(
+    wb: &Workbook,
+    out: &mut Out,
+    active: usize,
+    wb_rels: &mut Rels,
+) -> (String, crate::passthrough::WorkbookKept, crate::pivot::PivotWriter) {
+    // Kept content first: the chart sheets among the worksheets need their relationship ids.
+    let kept = crate::passthrough::write_workbook(wb, wb_rels, out);
+    let mut pivots = crate::pivot::PivotWriter::default();
+    let mut sheets_xml = String::new();
+    let any_visible = wb.sheets.iter().any(|s| s.visibility == Visibility::Visible);
+    let mut ids = crate::passthrough::SheetIds::new(wb, &kept);
+    for (i, sheet) in wb.sheets.iter().enumerate() {
+        sheets_xml.push_str(&kept.sheet_entries(i, false, &mut ids));
+        let (xml, mut rels) = crate::sheet_write::write_sheet(wb, i, i == active, out);
+        pivots.add_sheet(wb, i, out, &mut rels);
+        let name = format!("xl/worksheets/sheet{}.xml", i + 1);
+        out.part(&name, Some(CT_WORKSHEET), xml.into_bytes());
+        if !rels.is_empty() {
+            out.part(&format!("xl/worksheets/_rels/sheet{}.xml.rels", i + 1), None, rels.xml().into_bytes());
+        }
+        let rid = wb_rels.add("worksheet", &format!("worksheets/sheet{}.xml", i + 1));
+        let state = match sheet.visibility {
+            Visibility::Visible => "",
+            _ if !any_visible && i == active => "",
+            Visibility::Hidden => " state=\"hidden\"",
+            Visibility::VeryHidden => " state=\"veryHidden\"",
+        };
+        let name: String = sheet.name.chars().take(31).collect();
+        let sheet_id = ids.take(sheet.file_id);
+        let _ = write!(sheets_xml, "<sheet name=\"{}\" sheetId=\"{sheet_id}\"{state} r:id=\"{rid}\"/>", esc_attr(&name));
+    }
+    sheets_xml.push_str(&kept.sheet_entries(wb.sheets.len(), true, &mut ids));
+
+    (sheets_xml, kept, pivots)
+}
+
+fn write_defined_names(wb: &Workbook, kept: &crate::passthrough::WorkbookKept, chart_names: &[String]) -> String {
+    // Defined names, then print areas and titles.
+    let mut names = String::new();
+    let mut seen = std::collections::HashSet::new();
+    for n in &wb.names {
+        if n.name.is_empty() || !seen.insert((n.name.to_ascii_lowercase(), n.scope)) {
+            continue;
+        }
+        if let Some(sc) = n.scope
+            && sc >= wb.sheets.len()
+        {
+            continue;
+        }
+        let _ = write!(names, "<definedName name=\"{}\"", esc_attr(&n.name));
+        if let Some(sc) = n.scope {
+            let _ = write!(names, " localSheetId=\"{}\"", kept.file_index(sc));
+        }
+        if n.hidden {
+            names.push_str(" hidden=\"1\"");
+        }
+        if !n.comment.is_empty() {
+            let _ = write!(names, " comment=\"{}\"", esc_attr(&n.comment));
+        }
+        let _ = write!(names, ">{}</definedName>", esc(&crate::fmla::text_to_file(&n.formula)));
+    }
+    for (i, f) in chart_names.iter().enumerate() {
+        let _ = write!(
+            names,
+            "<definedName name=\"{}{i}\" hidden=\"1\">{}</definedName>",
+            crate::chartex::NAME_PREFIX,
+            esc(&crate::fmla::text_to_file(f))
+        );
+    }
+    for (i, sheet) in wb.sheets.iter().enumerate() {
+        let q = quote_sheet(&sheet.name);
+        if let Some(pa) = &sheet.print.print_area {
+            let _ = write!(
+                names,
+                "<definedName name=\"_xlnm.Print_Area\" localSheetId=\"{}\">{}!{}</definedName>",
+                kept.file_index(i),
+                esc(&q),
+                abs_range(pa)
+            );
+        }
+        let mut titles = vec![];
+        if let Some((c0, c1)) = sheet.print.title_cols {
+            titles.push(format!("{q}!{}", abs_range(&RangeRef::cols(c0.min(c1), c0.max(c1)))));
+        }
+        if let Some((r0, r1)) = sheet.print.title_rows {
+            titles.push(format!("{q}!{}", abs_range(&RangeRef::rows(r0.min(r1), r0.max(r1)))));
+        }
+        if !titles.is_empty() {
+            let _ = write!(
+                names,
+                "<definedName name=\"_xlnm.Print_Titles\" localSheetId=\"{}\">{}</definedName>",
+                kept.file_index(i),
+                esc(&titles.join(","))
+            );
+        }
+    }
+
+    names
+}
+
 /// Cell metadata declaring dynamic-array formulas (MS-XLSX `XLDAPR`).
 const METADATA: &str = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<metadata xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:xda=\"http://schemas.microsoft.com/office/spreadsheetml/2017/dynamicarray\"><metadataTypes count=\"1\"><metadataType name=\"XLDAPR\" minSupportedVersion=\"120000\" copy=\"1\" pasteAll=\"1\" pasteValues=\"1\" merge=\"1\" splitFirst=\"1\" rowColShift=\"1\" clearFormats=\"1\" clearComments=\"1\" assign=\"1\" coerce=\"1\" cellMeta=\"1\"/></metadataTypes><futureMetadata name=\"XLDAPR\" count=\"1\"><bk><extLst><ext uri=\"{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}\"><xda:dynamicArrayProperties fDynamic=\"1\" fCollapsed=\"0\"/></ext></extLst></bk></futureMetadata><cellMetadata count=\"1\"><bk><rc t=\"1\" v=\"0\"/></bk></cellMetadata></metadata>";