functions: TEXTJOIN builds its result piece by piece within the text cap

TEXTJOIN converted every input and delimiter into an owned String before
joining, so many references to one long shared text copied gigabytes before
the joined length was ever checked. Errors are now found first without
building text (so they still win in argument order), then each piece and
delimiter is converted only as it is appended, stopping at the cap.

apps/gridcraft-cli/src/check/calc.rs

@@ -31,41 +31,20 @@ fn is_volatile(e: &Expr, volatile_names: &HashSet<String>) -> bool {
 }
 
 /// Upper-cased defined names whose formula is volatile, directly or through other names.
-///
-/// Volatility flows backwards along name references: each name is parsed and walked once, and a
-/// worklist carries volatility from a name to the names that use it. Rescanning every name until
-/// nothing changes was quadratic: a file listing its names so that each pass marked only one more
-/// did one full pass per name.
 pub(super) fn volatile_names(wb: &Workbook) -> HashSet<String> {
+    let parsed: Vec<(String, Option<Expr>)> =
+        wb.names.iter().map(|n| (n.name.to_ascii_uppercase(), gridcraft_engine::formula::parse(&n.formula).ok())).collect();
     let mut set = HashSet::new();
-    // Upper-cased name -> the names whose formulas refer to it.
-    let mut users: HashMap<String, Vec<String>> = HashMap::new();
-    let mut queue = Vec::new();
-    let none = HashSet::new();
-    for n in &wb.names {
-        let name = n.name.to_ascii_uppercase();
-        let Ok(e) = gridcraft_engine::formula::parse(&n.formula) else { continue };
-        if is_volatile(&e, &none) {
-            if set.insert(name.clone()) {
-                queue.push(name.clone());
+    // Each round adds at least one name or stops, so `len + 1` rounds reach the fixed point.
+    for _ in 0..=parsed.len() {
+        let before = set.len();
+        for (name, e) in &parsed {
+            if !set.contains(name) && e.as_ref().is_some_and(|e| is_volatile(e, &set)) {
+                set.insert(name.clone());
             }
-            continue;
         }
-        let mut used = BTreeSet::new();
-        e.walk(&mut |x| {
-            if let Expr::Name(r) = x {
-                used.insert(r.to_ascii_uppercase());
-            }
-        });
-        for r in used {
-            users.entry(r).or_default().push(name.clone());
-        }
-    }
-    while let Some(v) = queue.pop() {
-        for user in users.remove(&v).unwrap_or_default() {
-            if set.insert(user.clone()) {
-                queue.push(user);
-            }
+        if set.len() == before {
+            break;
         }
     }
     set

apps/gridcraft-cli/src/check/package.rs

@@ -6,10 +6,6 @@ const MAX_XML_PART: u64 = 64 * 1024 * 1024;
 /// Most zip entries looked at while validating a written package.
 const MAX_ENTRIES: usize = 200_000;
 
-/// Decompressed bytes that comparing one package's relationship kinds may read in total: the
-/// relationship parts themselves and the targets whose content is checked.
-const RELATIONSHIP_BUDGET: u64 = 512 * 1024 * 1024;
-
 /// Relationship kinds (lower case) whose absence after a save isn't a loss: the calculation chain is
 /// a cache Excel rebuilds, and GridCraft never writes it.
 pub(super) const REBUILT_KINDS: [&str; 1] = ["calcchain"];
@@ -121,30 +117,6 @@ fn read_zip_part(zip: &mut Zip<'_>, name: &str) -> Result<Vec<u8>, String> {
     Ok(buf)
 }
 
-enum PartError {
-    /// Reading the part would spend more than the remaining budget.
-    OverBudget,
-    Unreadable,
-}
-
-/// Reads a part like [`read_zip_part`], charging the decompressed bytes to `budget`.
-fn read_zip_part_within(zip: &mut Zip<'_>, name: &str, budget: &mut u64) -> Result<Vec<u8>, PartError> {
-    let f = zip.by_name(name).map_err(|_| PartError::Unreadable)?;
-    // One byte past what is left shows that the part doesn't fit.
-    let limit = MAX_XML_PART.min(budget.saturating_add(1));
-    let mut buf = Vec::new();
-    // Bytes read before a decompression error still count against the budget.
-    let res = f.take(limit).read_to_end(&mut buf);
-    let read = buf.len() as u64;
-    if read > *budget {
-        *budget = 0;
-        return Err(PartError::OverBudget);
-    }
-    *budget -= read;
-    res.map_err(|_| PartError::Unreadable)?;
-    Ok(buf)
-}
-
 /// Whether the producer flagged its cached results as stale with `<calcPr fullCalcOnLoad="1">`:
 /// libraries that don't calculate write it, and store 0 or nothing as every formula's value.
 pub(super) fn full_calc_on_load(bytes: &[u8]) -> bool {
@@ -260,30 +232,19 @@ pub fn validate_package(bytes: &[u8]) -> Result<Vec<String>, String> {
 /// nothing are left out, as a save may rightly drop them: a link to a place in the workbook
 /// (`#Sheet1!A1`, written as a cell's `location`) and a target part with nothing in it.
 pub(super) fn relationship_kinds(bytes: &[u8]) -> Result<BTreeMap<String, String>, String> {
-    relationship_kinds_within(bytes, RELATIONSHIP_BUDGET)
-}
-
-/// [`relationship_kinds`] reading at most `budget` decompressed bytes. `Err` once the relationship
-/// parts alone need more: their kinds can't be listed completely.
-fn relationship_kinds_within(bytes: &[u8], mut budget: u64) -> Result<BTreeMap<String, String>, String> {
     let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| format!("not a zip package: {e}"))?;
     let names = zip_names(&mut zip);
     let by_key: HashMap<String, &String> = names.iter().map(|n| (part_key(n), n)).collect();
     // Several relationships name the same part; each fresh check decompressed it again, so
     // repeated references to one highly compressible part multiplied the work. The verdict is
     // remembered per (part, named content) and the decompression the package can cause is
-    // budgeted as a whole, the relationship parts included: many large, unreferenced rels parts
-    // would otherwise each spend a full per-part allowance.
+    // budgeted as a whole (finding: repeated decompression).
     let mut verdicts: HashMap<(String, &'static str), bool> = HashMap::new();
+    let mut budget: u64 = 512 * 1024 * 1024;
     let mut kinds = BTreeMap::new();
     for n in names.iter().filter(|n| part_key(n).ends_with(".rels")) {
         let Some(src_dir) = rels_source_dir(&part_key(n)) else { continue };
-        let xml = match read_zip_part_within(&mut zip, n, &mut budget) {
-            Ok(xml) => xml,
-            Err(PartError::OverBudget) => return Err(format!("{n}: relationship check stopped at its decompression limit")),
-            Err(PartError::Unreadable) => continue,
-        };
-        let Ok(els) = xml_elements(&xml) else { continue };
+        let Ok(els) = read_zip_part(&mut zip, n).and_then(|xml| xml_elements(&xml)) else { continue };
         for (_, attrs) in els.iter().filter(|(el, _)| el == "Relationship") {
             let Some(kind) = attr(attrs, "Type").and_then(|t| t.rsplit('/').next()) else { continue };
             let target = attr(attrs, "Target").unwrap_or("");
@@ -368,36 +329,3 @@ fn holds_something_uncached(zip: &mut Zip<'_>, name: &str, marker: &'static str,
         buf.clear();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::io::Write as _;
-
-    use super::*;
-
-    /// A package with `count` relationship parts of `size` bytes each, none of them describing an
-    /// existing part.
-    fn many_rels(count: usize, size: usize) -> Vec<u8> {
-        let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
-        let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
-        let head = r#"<?xml version="1.0"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom" Target="https://example.com" TargetMode="External"/>"#;
-        let tail = "</Relationships>";
-        let filler = " ".repeat(size.saturating_sub(head.len() + tail.len()));
-        for i in 0..count {
-            z.start_file(format!("xl/_rels/part{i}.xml.rels"), opts).unwrap();
-            z.write_all(head.as_bytes()).unwrap();
-            z.write_all(filler.as_bytes()).unwrap();
-            z.write_all(tail.as_bytes()).unwrap();
-        }
-        z.finish().unwrap().into_inner()
-    }
-
-    #[test]
-    fn relationship_parts_count_against_the_decompression_budget() {
-        // Each part fits the per-part allowance, but together they need more than the budget.
-        let bytes = many_rels(8, 64 * 1024);
-        assert!(relationship_kinds_within(&bytes, 256 * 1024).is_err());
-        let kinds = relationship_kinds_within(&bytes, 1024 * 1024).unwrap();
-        assert_eq!(kinds.get("custom").map(String::as_str), Some("custom"));
-    }
-}

apps/gridcraft-cli/src/check/tests.rs

@@ -178,28 +178,6 @@ fn volatile_names_propagate() {
     assert_eq!(check(&wb, &Options::default()).calc.volatile, 1);
 }
 
-#[test]
-fn volatile_names_propagate_through_a_long_chain_in_one_walk() {
-    // Chain0 uses Chain1, Chain1 uses Chain2, ... and only the last is volatile: listed in this order, a rescan
-    // until nothing changes marked one name per pass (quadratic). Every name in the chain is
-    // volatile; a name off the chain is not.
-    const LEN: usize = 5_000;
-    let mut wb = book(&[("A1", "=1", n(1.0))]);
-    let name =
-        |name: String, formula: String| gridcraft_engine::model::DefinedName { name, scope: None, formula, comment: String::new(), hidden: false };
-    for i in 0..LEN {
-        let formula = if i + 1 == LEN { "NOW()".to_string() } else { format!("Chain{}+1", i + 1) };
-        wb.names.push(name(format!("Chain{i}"), formula));
-    }
-    wb.names.push(name("Plain".into(), "Chain0*0+Other".into()));
-    wb.names.push(name("Other".into(), "1".into()));
-    let set = volatile_names(&wb);
-    assert!((0..LEN).all(|i| set.contains(&format!("CHAIN{i}"))));
-    assert!(set.contains("PLAIN"));
-    assert!(!set.contains("OTHER"));
-    assert_eq!(set.len(), LEN + 1);
-}
-
 #[test]
 fn round_trip_of_a_simple_book_is_clean() {
     let mut wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("A2", "x", Value::text("x"))]);

apps/gridcraft-web/src/web.rs

@@ -193,7 +193,7 @@ fn services(inbox: Inbox, ctx: egui::Context) -> Services {
             let ctx = ctx.clone();
             wasm_bindgen_futures::spawn_local(async move {
                 let Some(file) = rfd::AsyncFileDialog::new()
-                    .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "slk", "json"])
+                    .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"])
                     .pick_file()
                     .await
                 else {

apps/gridcraft/Cargo.toml

@@ -37,13 +37,13 @@ winit = { version = "0.30", default-features = false, features = ["x11", "waylan
 craft-print = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7" }
 craft-update = { workspace = true }
 rfd = { workspace = true }
-arboard = { workspace = true, features = ["image-data"] }
+arboard = { workspace = true }
 gridcraft-mcp = { workspace = true }
 # The control channel's token (OS random numbers); already in the tree.
 getrandom = "0.4"
 
 [target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]
-arboard = { workspace = true, features = ["image-data", "wayland-data-control"] }
+arboard = { workspace = true, features = ["wayland-data-control"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 # Blocks on the start-up DirectX 12 adapter probe (`graphics.rs`); already in the tree via eframe.

apps/gridcraft/src/main.rs

@@ -154,7 +154,7 @@ fn read_clipboard<T>(
 fn services() -> Services {
     // Keep the owner alive: X11/Wayland serve clipboard data from this handle.
     let clipboard: Rc<RefCell<Option<arboard::Clipboard>>> = Rc::default();
-    let (html_clipboard, text_clipboard, image_clipboard) = (clipboard.clone(), clipboard.clone(), clipboard.clone());
+    let (html_clipboard, text_clipboard) = (clipboard.clone(), clipboard.clone());
     Services {
         copy_html: Some(Box::new(move |html, text| {
             let mut clipboard = clipboard.borrow_mut();
@@ -165,13 +165,9 @@ fn services() -> Services {
         })),
         paste_html: Some(Box::new(move || read_clipboard(&html_clipboard, |clipboard| clipboard.get().html()))),
         paste_text: Some(Box::new(move || read_clipboard(&text_clipboard, |clipboard| clipboard.get_text()))),
-        paste_image: Some(Box::new(move || {
-            let image = read_clipboard(&image_clipboard, |clipboard| clipboard.get_image())?;
-            image::RgbaImage::from_raw(u32::try_from(image.width).ok()?, u32::try_from(image.height).ok()?, image.bytes.into_owned())
-        })),
         pick_open: Some(Box::new(|| {
             rfd::FileDialog::new()
-                .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "slk", "json"])
+                .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"])
                 .add_filter("Excel Workbook", &["xlsx", "xlsm"])
                 .add_filter("Excel 97-2003 Workbook (import)", &["xls"])
                 .add_filter("Excel Binary Workbook (data import)", &["xlsb"])

crates/calc/src/eval.rs

@@ -325,11 +325,6 @@ impl<'h> Evaluator<'h> {
             Expr::Array(rows) => {
                 let h = rows.len();
                 let w = rows.first().map_or(0, Vec::len);
-                // A ragged literal is an error either way; one wide row and many empty ones must
-                // not reserve their rows-times-width product first.
-                if rows.iter().any(|row| row.len() != w) {
-                    return err(CellError::Value);
-                }
                 let mut data = Vec::with_capacity(h * w);
                 for row in rows {
                     for el in row {
@@ -364,10 +359,9 @@ impl<'h> Evaluator<'h> {
             return v.clone();
         }
         let wb = self.host.workbook();
-        // Sheet-qualified `Sheet1!Name`. The parser stores the sheet unquoted, so it is used as
-        // is (`' Sales '` keeps its spaces) and split at the last `!` (`'a!b'!Name`).
-        let (scope_sheet, bare) = match n.rsplit_once('!') {
-            Some((s, b)) => match wb.sheet_index(s) {
+        // Sheet-qualified `Sheet1!Name`.
+        let (scope_sheet, bare) = match n.split_once('!') {
+            Some((s, b)) => match wb.sheet_index(&gridcraft_core::unquote_sheet(s)) {
                 Some(i) => (i, b),
                 None => return err(CellError::Name),
             },

crates/calc/src/eval/array.rs

@@ -86,30 +86,6 @@ pub fn zip2(a: &Value, b: &Value, f: impl Fn(&Value, &Value) -> Value) -> Value
     }
 }
 
-/// [`zip2`] that stops at the first cell `f` refuses (`None`), before the rest is built: the
-/// result grows as cells are made rather than being reserved for the whole broadcast up front.
-fn try_zip2(a: &Value, b: &Value, mut f: impl FnMut(&Value, &Value) -> Option<Value>) -> Option<Value> {
-    Some(match (a, b) {
-        (Value::Array(x), Value::Array(y)) => {
-            let rows = broadcast_dim(x.rows, y.rows);
-            let cols = broadcast_dim(x.cols, y.cols);
-            if broadcast_len(rows, cols).is_none() {
-                return Some(Value::Error(CellError::Num));
-            }
-            let mut data = Vec::new();
-            for r in 0..rows {
-                for c in 0..cols {
-                    data.push(f(&x.get_broadcast(r, c), &y.get_broadcast(r, c))?);
-                }
-            }
-            Value::from(Array { rows, cols, data })
-        }
-        (Value::Array(x), s) => Value::from(Array { rows: x.rows, cols: x.cols, data: x.data.iter().map(|v| f(v, s)).collect::<Option<_>>()? }),
-        (s, Value::Array(y)) => Value::from(Array { rows: y.rows, cols: y.cols, data: y.data.iter().map(|v| f(s, v)).collect::<Option<_>>()? }),
-        (x, y) => f(x, y)?,
-    })
-}
-
 /// Cell count of a `rows`×`cols` broadcast result, or `None` when it would exceed [`MAX_CELLS`].
 /// Each operand passes its own size cap, but their broadcast product can be far larger
 /// (`SEQUENCE(1048576)*SEQUENCE(1,16384)` is 17 billion cells), so it is checked before allocating.
@@ -159,36 +135,10 @@ pub(super) fn single(v: Value) -> Option<Value> {
     }
 }
 
-/// Text bytes that one `&` over arrays may produce in all. Each piece is capped on its own, but a
-/// compact formula can broadcast a long text across millions of cells
-/// (`SEQUENCE(4000,4000)&REPT("x",30000)` is 480 GB): past this the whole result is `#NUM!`, the
-/// error for a result too large to hold, before the rest is built.
-pub(super) const MAX_CONCAT_ARRAY_BYTES: usize = 512 * 1024 * 1024;
-
 pub fn binary_values(op: BinOp, x: &Value, y: &Value, sys: gridcraft_core::DateSystem) -> Value {
-    if op == BinOp::Concat && (matches!(x, Value::Array(_)) || matches!(y, Value::Array(_))) {
-        return concat_arrays(x, y, sys, MAX_CONCAT_ARRAY_BYTES);
-    }
     zip2(x, y, |a, b| binary_scalar(op, a, b, sys))
 }
 
-/// `x & y` with at least one array operand, giving `#NUM!` once the texts built so far pass `budget`
-/// bytes.
-fn concat_arrays(x: &Value, y: &Value, sys: gridcraft_core::DateSystem, budget: usize) -> Value {
-    let mut used = 0usize;
-    try_zip2(x, y, |a, b| {
-        let v = binary_scalar(BinOp::Concat, a, b, sys);
-        if let Value::Text(t) = &v {
-            used = used.saturating_add(t.len());
-            if used > budget {
-                return None;
-            }
-        }
-        Some(v)
-    })
-    .unwrap_or(Value::Error(CellError::Num))
-}
-
 fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSystem) -> Value {
     if let Value::Error(e) = a {
         return Value::Error(*e);
@@ -237,35 +187,7 @@ fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSyste
 
 #[cfg(test)]
 mod tests {
-    use super::{Array, BinOp, CellError, MAX_CELLS, Value, broadcast_len, concat_arrays, try_zip2};
-
-    /// The broadcast stops at the first refused cell: nothing after it is visited.
-    #[test]
-    fn a_refused_cell_stops_the_broadcast() {
-        let col = Value::from(Array::column((0..4_000).map(|i| Value::number(i as f64)).collect()));
-        let row = Value::from(Array { rows: 1, cols: 4_000, data: (0..4_000).map(|i| Value::number(i as f64)).collect() });
-        let mut calls = 0;
-        let r = try_zip2(&col, &row, |a, _| {
-            calls += 1;
-            (calls <= 10).then(|| a.clone())
-        });
-        assert_eq!((r, calls), (None, 11));
-    }
-
-    #[test]
-    fn concatenating_arrays_stops_at_the_byte_budget() {
-        let sys = gridcraft_core::DateSystem::default();
-        let col = Value::from(Array::column((0..100).map(|i| Value::number(i as f64)).collect()));
-        let long = Value::text("x".repeat(100));
-        // 100 cells of 101 or 102 bytes each: about 10 KB in all.
-        let r = concat_arrays(&col, &long, sys, 20_000);
-        assert!(matches!(&r, Value::Array(a) if a.data.len() == 100), "{r:?}");
-        assert_eq!(concat_arrays(&col, &long, sys, 5_000), Value::Error(CellError::Num));
-        assert_eq!(concat_arrays(&long, &col, sys, 5_000), Value::Error(CellError::Num));
-        // Through the operator, a small result is unaffected.
-        let r = super::binary_values(BinOp::Concat, &col, &Value::text("a"), sys);
-        assert!(matches!(&r, Value::Array(a) if a.data.first() == Some(&Value::text("0a"))), "{r:?}");
-    }
+    use super::{MAX_CELLS, broadcast_len};
 
     #[test]
     fn broadcast_len_caps_at_max_cells() {

crates/calc/src/recalc.rs

@@ -24,7 +24,7 @@ mod pass_host;
 #[cfg(test)]
 use graph::Intervals;
 pub use graph::{FxHasher, Graph, Key};
-use graph::{HashMap, HashSet, Node, Taken};
+use graph::{HashMap, HashSet, Node};
 use pass_host::{PassHost, spills_as_before};
 
 /// Calculation state kept beside a workbook.
@@ -292,16 +292,17 @@ impl Calc {
                 }
             }
         }
-        // Spill areas of changed anchors also change. They stay rectangles: one seed per spilled
-        // cell listed the formulas reading the area once per cell.
-        let mut areas: Vec<(usize, RangeRef)> = cleared;
+        // Spill areas of changed anchors also change.
         for &k in changed {
             if let Some(r) = wb.sheet(k.0).and_then(|s| s.spill_ranges.get(&k.1)) {
-                areas.push((k.0, *r));
+                seeds.extend(r.iter().map(|c| (k.0, c)));
             }
         }
+        for (si, r) in &cleared {
+            seeds.extend(r.iter().map(|c| (*si, c)));
+        }
         let t0 = prof_now();
-        let dirty = self.dirty_closure(wb, &seeds, &areas);
+        let dirty = self.dirty_closure(wb, &seeds);
         let t1 = prof_now();
         let n = dirty.len();
         self.run(wb, dirty, false);
@@ -310,39 +311,16 @@ impl Calc {
         }
     }
 
-    /// The formulas to recalculate after `seeds` and every cell of `areas` changed: the seeds
-    /// that are formulas, and everything that reads them, directly or through other formulas.
-    fn dirty_closure(&self, wb: &Workbook, seeds: &[Key], areas: &[(usize, RangeRef)]) -> Vec<Key> {
+    fn dirty_closure(&self, _wb: &Workbook, seeds: &[Key]) -> Vec<Key> {
         let mut seen: HashSet<Key> = HashSet::default();
         let mut queue: VecDeque<Key> = VecDeque::new();
-        // Each range-index entry is listed once in the whole walk: many changed cells under one
-        // broad reference (or many formulas inside one) would otherwise list every formula reading
-        // it once per cell, which squared the work.
-        let mut taken = Taken::default();
-        let mut deps = Vec::new();
         for k in seeds {
             if self.graph.nodes.contains_key(k) && seen.insert(*k) {
                 queue.push_back(*k);
             }
-            deps.clear();
-            self.graph.dependents_untaken(k.0, k.1, &mut taken, &mut deps);
-            for d in deps.drain(..) {
-                if seen.insert(d) {
-                    queue.push_back(d);
-                }
-            }
-        }
-        for &(si, r) in areas {
-            if let Some(sh) = wb.sheet(si) {
-                for (c, _) in sh.cells.iter_range(r) {
-                    if self.graph.nodes.contains_key(&(si, c)) && seen.insert((si, c)) {
-                        queue.push_back((si, c));
-                    }
-                }
-            }
-            deps.clear();
-            self.graph.dependents_of_range(si, r, &mut deps);
-            for d in deps.drain(..) {
+            let mut deps = Vec::new();
+            self.graph.dependents(k.0, k.1, &mut deps);
+            for d in deps {
                 if seen.insert(d) {
                     queue.push_back(d);
                 }
@@ -353,9 +331,10 @@ impl Calc {
                 queue.push_back(*k);
             }
         }
+        let mut deps = Vec::new();
         while let Some(k) = queue.pop_front() {
             deps.clear();
-            self.graph.dependents_untaken(k.0, k.1, &mut taken, &mut deps);
+            self.graph.dependents(k.0, k.1, &mut deps);
             for d in deps.drain(..) {
                 if seen.insert(d) {
                     queue.push_back(d);
@@ -432,7 +411,7 @@ impl Calc {
             if spill_changes.is_empty() {
                 break;
             }
-            dirty = self.dirty_closure(wb, &spill_changes, &[]);
+            dirty = self.dirty_closure(wb, &spill_changes);
         }
         // Loops among formulas the run did not evaluate stay listed while they are still formulas.
         // Iterative calculation reports none.
@@ -712,149 +691,6 @@ pub(crate) mod tests {
         assert!(visited < 64, "visited {visited} nodes for no match");
     }
 
-    #[test]
-    fn untaken_queries_list_each_interval_once_in_all() {
-        // 1,000 ranges over every row of 5,000: point queries at every row used to list all 1,000
-        // each time (5 million matches); sharing `taken`, each range is listed once in all.
-        let n = 5_000u32;
-        let mut iv: Intervals<u32> = Intervals::default();
-        for t in 0..1_000 {
-            iv.insert(0, n, t);
-        }
-        for r in 0..n {
-            iv.insert(r, r, 10_000 + r);
-        }
-        iv.settle();
-        let mut taken = Vec::new();
-        let mut listed = Vec::new();
-        for row in 0..=n + 3 {
-            iv.query_untaken(row, row, &mut taken, &mut |t| {
-                listed.push(*t);
-                true
-            });
-        }
-        listed.sort_unstable();
-        let want: Vec<u32> = (0..1_000).chain(10_000..10_000 + n).collect();
-        assert_eq!(listed, want);
-        // An entry the caller declines is offered again.
-        let mut taken = Vec::new();
-        let mut offered = 0;
-        for _ in 0..3 {
-            iv.query_untaken(7, 7, &mut taken, &mut |t| {
-                if *t == 10_007 {
-                    offered += 1;
-                }
-                *t != 10_007
-            });
-        }
-        assert_eq!(offered, 3);
-    }
-
-    #[test]
-    fn dirty_closure_matches_a_walk_of_every_cell() {
-        // Random formulas over single cells, narrow ranges and wide (over 64 columns) ranges, some
-        // removed or left unsettled: the closure equals the one found by listing every dependent
-        // of every changed cell, area cells included, as before `taken` and areas existed.
-        use super::{HashSet, Node};
-        use crate::eval::Area;
-        use std::collections::VecDeque;
-        let mut s = 0x2545_F491_4F6C_DD1D;
-        for case in 0..40 {
-            let mut wb = Workbook::new();
-            let mut calc = Calc::new();
-            let pick = |s: &mut u64, n: u64| (rng(s) % n) as u32;
-            let mut keys: Vec<Key> = Vec::new();
-            for _ in 0..300 {
-                let k = (0, CellRef::new(pick(&mut s, 120), pick(&mut s, 150)));
-                let mut areas = Vec::new();
-                for _ in 0..1 + pick(&mut s, 3) {
-                    let start = CellRef::new(pick(&mut s, 120), pick(&mut s, 150));
-                    let end = match pick(&mut s, 3) {
-                        0 => start,
-                        1 => CellRef::new(start.row + pick(&mut s, 40), start.col + pick(&mut s, 5)),
-                        _ => CellRef::new(start.row + pick(&mut s, 20), start.col + 65 + pick(&mut s, 30)),
-                    };
-                    areas.push(Area { sheet: 0, range: RangeRef::new(start, end) });
-                }
-                if let Some(sh) = wb.sheet_mut(0) {
-                    sh.cells.set(k.1, Cell::formula(Formula::new("=1")));
-                }
-                calc.graph.insert(k, Node { areas, dynamic: false });
-                keys.push(k);
-                if rng(&mut s).is_multiple_of(7) {
-                    calc.graph.settle();
-                }
-            }
-            for _ in 0..30 {
-                let k = keys[(rng(&mut s) % keys.len() as u64) as usize];
-                calc.graph.remove(k);
-                if let Some(sh) = wb.sheet_mut(0) {
-                    sh.cells.remove(k.1);
-                }
-            }
-            if case % 2 == 0 {
-                calc.graph.settle();
-            }
-            let seeds: Vec<Key> = (0..1 + pick(&mut s, 25)).map(|_| (0, CellRef::new(pick(&mut s, 140), pick(&mut s, 220)))).collect();
-            let areas: Vec<(usize, RangeRef)> = (0..pick(&mut s, 3))
-                .map(|_| {
-                    let start = CellRef::new(pick(&mut s, 120), pick(&mut s, 150));
-                    (0, RangeRef::new(start, CellRef::new(start.row + pick(&mut s, 30), start.col + pick(&mut s, 80))))
-                })
-                .collect();
-            let got: HashSet<Key> = calc.dirty_closure(&wb, &seeds, &areas).into_iter().collect();
-            // The walk before: every area cell is a seed, and every cell lists all its dependents.
-            let mut all = seeds.clone();
-            for (si, r) in &areas {
-                all.extend(r.iter().map(|c| (*si, c)));
-            }
-            let mut want: HashSet<Key> = HashSet::default();
-            let mut queue: VecDeque<Key> = VecDeque::new();
-            let mut deps = Vec::new();
-            for k in &all {
-                if calc.graph.nodes.contains_key(k) && want.insert(*k) {
-                    queue.push_back(*k);
-                }
-                deps.clear();
-                calc.graph.dependents(k.0, k.1, &mut deps);
-                queue.extend(deps.iter().copied().filter(|d| want.insert(*d)));
-            }
-            while let Some(k) = queue.pop_front() {
-                deps.clear();
-                calc.graph.dependents(k.0, k.1, &mut deps);
-                queue.extend(deps.iter().copied().filter(|d| want.insert(*d)));
-            }
-            assert_eq!(got, want, "case {case}");
-        }
-    }
-
-    #[test]
-    fn clearing_a_spill_recalculates_formulas_reading_it_once_each() {
-        // 300 formulas read the area an anchor spills into; clearing the anchor changes all of it
-        // and every one of them is recalculated (they were listed once per spilled cell).
-        let mut wb = Workbook::new();
-        let mut calc = Calc::new();
-        let set = |wb: &mut Workbook, calc: &mut Calc, at: CellRef, input: &str| {
-            if let Some(sh) = wb.sheet_mut(0) {
-                if input.is_empty() {
-                    sh.cells.remove(at);
-                } else {
-                    sh.cells.set(at, Cell::formula(Formula::new(input)));
-                }
-            }
-            calc.cells_changed(wb, &[(0, at)]);
-        };
-        set(&mut wb, &mut calc, CellRef::new(0, 0), "=SEQUENCE(2000)");
-        for r in 0..300 {
-            set(&mut wb, &mut calc, CellRef::new(r, 2), "=COUNT(A1:A2000)");
-        }
-        assert_eq!(wb.sheet(0).map(|s| s.value(CellRef::new(299, 2))), Some(Value::Number(2000.0)));
-        set(&mut wb, &mut calc, CellRef::new(0, 0), "");
-        for r in 0..300 {
-            assert_eq!(wb.sheet(0).map(|s| s.value(CellRef::new(r, 2))), Some(Value::Number(0.0)), "row {r}");
-        }
-    }
-
     /// `rows` rows of six numbers (E:J) and `=SUM(E{r}:J{r})` in K.
     fn sum_rows(rows: u32) -> Workbook {
         let mut wb = Workbook::new();

crates/calc/src/recalc/graph.rs

@@ -151,54 +151,6 @@ impl<T: Copy + Ord> Intervals<T> {
         self.walk(1, 0, self.max_end.len() / 2, p, a, f)
     }
 
-    /// [`Intervals::query`] that skips entries an earlier call with the same `taken` already
-    /// took (and whole subtrees of them), so that a series of queries lists each interval once in
-    /// all. `f` answers whether it took the entry; one it declines is offered again later.
-    /// `taken` belongs to this index as it is now; start it empty. Pending insertions (a few at
-    /// most after [`Intervals::settle`]) are offered every time.
-    pub(super) fn query_untaken(&self, a: u32, b: u32, taken: &mut Vec<bool>, f: &mut dyn FnMut(&T) -> bool) {
-        for it in &self.pending {
-            if it.0 <= b && it.1 >= a {
-                f(&it.2);
-            }
-        }
-        let p = self.items.partition_point(|it| it.0 <= b);
-        if p == 0 {
-            return;
-        }
-        if taken.len() != self.max_end.len() {
-            *taken = vec![false; self.max_end.len()];
-        }
-        self.walk_untaken(1, 0, self.max_end.len() / 2, p, a, taken, f);
-    }
-
-    /// Returns whether everything under `node` has now been reported (or is dead).
-    #[allow(clippy::too_many_arguments)]
-    fn walk_untaken(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, taken: &mut [bool], f: &mut dyn FnMut(&T) -> bool) -> bool {
-        if taken.get(node).copied().unwrap_or(true) {
-            return true;
-        }
-        if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) {
-            return false;
-        }
-        let done = if hi - lo <= 1 {
-            match (self.items.get(lo), self.dead.get(lo)) {
-                (Some(it), Some(false)) if it.1 >= a => f(&it.2),
-                (Some(_), Some(true)) => true,
-                _ => false,
-            }
-        } else {
-            let mid = lo + (hi - lo) / 2;
-            let left = self.walk_untaken(2 * node, lo, mid, p, a, taken, f);
-            let right = self.walk_untaken(2 * node + 1, mid, hi, p, a, taken, f);
-            left && right
-        };
-        if done && let Some(slot) = taken.get_mut(node) {
-            *slot = true;
-        }
-        done
-    }
-
     fn walk(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, f: &mut dyn FnMut(&T)) -> usize {
         if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) {
             return 1;
@@ -216,13 +168,6 @@ impl<T: Copy + Ord> Intervals<T> {
     }
 }
 
-/// Range-index entries one dependency walk has already listed (see [`Graph::dependents_untaken`]).
-#[derive(Default)]
-pub(super) struct Taken {
-    cols: HashMap<(usize, u32), Vec<bool>>,
-    wide: HashMap<usize, Vec<bool>>,
-}
-
 #[derive(Clone, Debug, Default)]
 pub struct Graph {
     pub(super) nodes: HashMap<Key, Node>,
@@ -357,32 +302,6 @@ impl Graph {
         }
     }
 
-    /// [`Graph::dependents`] leaving out the formulas whose range reads an earlier call with the
-    /// same `taken` already listed. A walk over many changed cells that a few broad ranges cover
-    /// then lists those formulas once, instead of once per cell (which squared the work). The
-    /// graph must not change while `taken` is in use.
-    pub(super) fn dependents_untaken(&self, sheet: usize, c: CellRef, taken: &mut Taken, out: &mut Vec<Key>) {
-        if let Some(v) = self.cell_deps.get(&(sheet, c)) {
-            out.extend(v.iter().copied());
-        }
-        if let Some(v) = self.col_deps.get(&(sheet, c.col)) {
-            v.query_untaken(c.row, c.row, taken.cols.entry((sheet, c.col)).or_default(), &mut |k| {
-                out.push(*k);
-                true
-            });
-        }
-        if let Some(v) = self.wide_deps.get(&sheet) {
-            // A wide entry is taken once it covers the cell's column too.
-            v.query_untaken(c.row, c.row, taken.wide.entry(sheet).or_default(), &mut |(c0, c1, k)| {
-                let hit = *c0 <= c.col && c.col <= *c1;
-                if hit {
-                    out.push(*k);
-                }
-                hit
-            });
-        }
-    }
-
     /// Formulas that read any cell of `range` (a formula can be listed more than once).
     pub fn dependents_of_range(&self, sheet: usize, range: RangeRef, out: &mut Vec<Key>) {
         if range.count() <= 4096 {

crates/chart/src/render/cartesian.rs

@@ -1,6 +1,6 @@
 use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range};
 use super::legend::{cat_label, plot_kind};
-use super::lines::{decimate_area, draw_markers, draw_runs};
+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::{
     Chart, ChartData, ChartKind, Ctx, Fmt, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_LINE_PTS, MAX_MARKERS, Prim, Scale, SeriesData, TEXT,
@@ -96,11 +96,8 @@ fn series_spans(data: &ChartData, fams: &[Fam], sec: &[bool], ncat: usize) -> Ve
         } else {
             None
         };
-        // A series without values has no spans: 255 empty series over 20,000 categories would
-        // otherwise fill ~5 million entries.
-        let n = if s.values.is_empty() { 0 } else { ncat };
-        let mut row = Vec::with_capacity(n);
-        for j in 0..n {
+        let mut row = Vec::with_capacity(ncat);
+        for j in 0..ncat {
             let v = s.values.get(j).copied().flatten();
             let span = match (si.and_then(|p| stacks.get_mut(p)), fam) {
                 (Some((_, pos, neg)), Fam::ColStack | Fam::Col100) => v.and_then(|v| {
@@ -271,7 +268,10 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
                             base = vec![[b[0] - cw * 0.3, b[1]], [b[0] + cw * 0.3, b[1]]];
                         }
                     }
-                    let poly = decimate_area(top, base, MAX_LINE_PTS * 2);
+                    let top = decimate(top, MAX_LINE_PTS * 2);
+                    let base = decimate(base, MAX_LINE_PTS * 2);
+                    let mut poly = top;
+                    poly.extend(base.into_iter().rev());
                     if poly.len() >= 3 {
                         ctx.out.push(Prim::Polygon { pts: poly, fill: s.color, stroke: None });
                     }
@@ -453,18 +453,3 @@ pub(super) fn scatter(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
     }
     draw_trend_labels(ctx, plot, &trend_labels);
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty_series_get_no_span_entries() {
-        let empty = SeriesData::default();
-        let full = SeriesData { values: vec![Some(1.0); 3], ..SeriesData::default() };
-        let data = ChartData { series: vec![empty.clone(), full, empty], ..ChartData::default() };
-        let fams = [Fam::Col; 3];
-        let spans = series_spans(&data, &fams, &[false; 3], MAX_CATS);
-        assert_eq!(spans.iter().map(Vec::len).collect::<Vec<_>>(), [0, MAX_CATS, 0]);
-    }
-}

crates/chart/src/render/kinds.rs

@@ -203,11 +203,12 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne
 
 // ---------------------------------------------------------------- treemap
 
-/// Worst aspect ratio of a row with the given sum, smallest and largest area.
-fn worst(s: f64, mn: f64, mx: f64, side: f64) -> f64 {
+fn worst(row: &[f64], side: f64) -> f64 {
+    let s: f64 = row.iter().sum();
     if s <= 0.0 || side <= 0.0 {
         return f64::INFINITY;
     }
+    let (mn, mx) = row.iter().fold((f64::INFINITY, 0.0f64), |(a, b), v| (a.min(*v), b.max(*v)));
     let s2 = s * s;
     let w2 = side * side;
     (w2 * mx / s2).max(s2 / (w2 * mn))
@@ -224,8 +225,6 @@ fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
     let mut out = Vec::with_capacity(items.len());
     let mut rem = r;
     let mut row: Vec<(usize, f64)> = Vec::new();
-    // The row's sum, smallest and largest area, kept as items join so each step is O(1).
-    let (mut sum, mut mn, mut mx) = (0.0f64, f64::INFINITY, 0.0f64);
     let mut i = 0;
     let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| {
         let s: f64 = row.iter().map(|x| x.1).sum();
@@ -257,14 +256,15 @@ fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
     while let Some(&(j, v)) = items.get(i) {
         let a = v * scale;
         let side = rem.w.min(rem.h) as f64;
-        if row.is_empty() || worst(sum + a, mn.min(a), mx.max(a), side) <= worst(sum, mn, mx, side) {
+        let cur: Vec<f64> = row.iter().map(|x| x.1).collect();
+        let mut with = cur.clone();
+        with.push(a);
+        if row.is_empty() || worst(&with, side) <= worst(&cur, side) {
             row.push((j, a));
-            (sum, mn, mx) = (sum + a, mn.min(a), mx.max(a));
             i += 1;
         } else {
             layout(&row, &mut rem, &mut out);
             row.clear();
-            (sum, mn, mx) = (0.0, f64::INFINITY, 0.0);
         }
     }
     if !row.is_empty() {
@@ -279,7 +279,6 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
         s.values.iter().take(MAX_MARKERS).enumerate().filter_map(|(j, v)| v.filter(|v| *v > 0.0).map(|v| (j, v))).collect();
     items.sort_by(|a, b| b.1.total_cmp(&a.1));
     let f = Fmt::new(&s.number_format);
-    let value_of: std::collections::HashMap<usize, f64> = items.iter().copied().collect();
     for (j, b) in squarify(&items, area) {
         let fill = point_color(data, j);
         ctx.rect(b.x, b.y, b.w, b.h, fill, Some((WHITE, 1.5)));
@@ -287,7 +286,7 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
             let name = ctx.fit(&cat_label(data, j), LABEL_SIZE, b.w - 8.0);
             ctx.text(b.x + 4.0, b.y + 4.0, &name, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top));
             if chart.data_labels && b.h > LABEL_SIZE * 3.2 {
-                let v = value_of.get(&j).copied().unwrap_or(0.0);
+                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));
             }

crates/chart/src/render/lines.rs

@@ -54,86 +54,6 @@ pub(super) fn decimate(pts: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> {
     out
 }
 
-/// Decimates the top and baseline of an area chart together at the same horizontal indices so
-/// `area_mesh`'s paired vertical-strip topology (`pts[i]` ↔ `pts[2n - 1 - i]`) is preserved.
-pub(super) fn decimate_area(top: Vec<[f32; 2]>, base: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> {
-    let n = top.len().min(base.len());
-    if n == 0 {
-        return Vec::new();
-    }
-    if n <= max {
-        let mut poly = top;
-        poly.truncate(n);
-        poly.extend(base.into_iter().take(n).rev());
-        return poly;
-    }
-    let mut cols: Vec<[usize; 6]> = Vec::new();
-    let mut keep = Vec::with_capacity(max * 2);
-    let mut i = 0;
-    while i < n {
-        let col = top[i][0].floor();
-        let (start, mut t_mn, mut t_mx, mut b_mn, mut b_mx) = (i, i, i, i, i);
-        let mut k = i + 1;
-        while k < n && top[k][0].floor() == col {
-            if top[k][1] < top[t_mn][1] {
-                t_mn = k;
-            }
-            if top[k][1] > top[t_mx][1] {
-                t_mx = k;
-            }
-            if base[k][1] < base[b_mn][1] {
-                b_mn = k;
-            }
-            if base[k][1] > base[b_mx][1] {
-                b_mx = k;
-            }
-            k += 1;
-        }
-        let entry = [start, t_mn, t_mx, b_mn, b_mx, k - 1];
-        cols.push(entry);
-        let mut idx = entry;
-        idx.sort_unstable();
-        let mut last = usize::MAX;
-        for ix in idx {
-            if ix != last {
-                keep.push(ix);
-                last = ix;
-            }
-        }
-        i = k;
-    }
-    if keep.len() > max * 4 {
-        let max_groups = (max * 4 / 6).max(1);
-        let group_size = cols.len().div_ceil(max_groups);
-        keep.clear();
-        for ch in cols.chunks(group_size) {
-            let start = ch[0][0];
-            let end = ch.last().map_or(start, |c| c[5]);
-            let t_mn = ch.iter().map(|c| c[1]).min_by(|&a, &b| top[a][1].total_cmp(&top[b][1])).unwrap_or(start);
-            let t_mx = ch.iter().map(|c| c[2]).max_by(|&a, &b| top[a][1].total_cmp(&top[b][1])).unwrap_or(start);
-            let b_mn = ch.iter().map(|c| c[3]).min_by(|&a, &b| base[a][1].total_cmp(&base[b][1])).unwrap_or(start);
-            let b_mx = ch.iter().map(|c| c[4]).max_by(|&a, &b| base[a][1].total_cmp(&base[b][1])).unwrap_or(start);
-            let mut idx = [start, t_mn, t_mx, b_mn, b_mx, end];
-            idx.sort_unstable();
-            let mut last = usize::MAX;
-            for ix in idx {
-                if ix != last {
-                    keep.push(ix);
-                    last = ix;
-                }
-            }
-        }
-    }
-    let mut poly = Vec::with_capacity(keep.len() * 2);
-    for &ix in &keep {
-        poly.push(top[ix]);
-    }
-    for &ix in keep.iter().rev() {
-        poly.push(base[ix]);
-    }
-    poly
-}
-
 /// Draws a polyline split at gaps (`None`), decimated when long. With `smooth` (the plot box),
 /// each run is interpolated with a Catmull-Rom spline so the line curves through the data points.
 pub(super) fn draw_runs(ctx: &mut Ctx, pts: &[Option<[f32; 2]>], color: Rgba, width: f32, smooth: Option<Bx>) {
@@ -235,57 +155,4 @@ mod smooth_tests {
         assert!(out.len() > 5);
         assert!(out.iter().all(|p| (0.0..=300.0).contains(&p[0]) && (10.0..=110.0).contains(&p[1])));
     }
-
-    #[test]
-    fn decimate_area_preserves_paired_vertical_strips() {
-        let top: Vec<[f32; 2]> = (0..1000).map(|i| [i as f32 * 0.25, ((i * 37) % 100) as f32]).collect();
-        let base: Vec<[f32; 2]> = (0..1000).map(|i| [i as f32 * 0.25, 100.0]).collect();
-        let poly = decimate_area(top, base, 64);
-        assert_eq!(poly.len() % 2, 0);
-        let half = poly.len() / 2;
-        for i in 0..half {
-            assert_eq!(poly[i][0], poly[poly.len() - 1 - i][0]);
-            assert_eq!(poly[poly.len() - 1 - i][1], 100.0);
-        }
-    }
-
-    #[test]
-    fn decimate_area_preserves_extrema_across_3000_columns() {
-        // 3,000 occupied pixel columns with 6 points per column (18,000 points total),
-        // where each column has distinct top and baseline extrema so the initial per-column
-        // index list exceeds `MAX_LINE_PTS * 2 * 4` (6,400).
-        let max = MAX_LINE_PTS * 2;
-        let mut top = Vec::with_capacity(18_000);
-        let mut base = Vec::with_capacity(18_000);
-        for col in 0..3_000 {
-            let y_top = [50.0, 20.0, 80.0, 50.0, 50.0, 50.0];
-            let y_base = [150.0, 150.0, 150.0, 120.0, 180.0, 150.0];
-            for s in 0..6 {
-                let x = col as f32 + s as f32 * 0.1;
-                top.push([x, y_top[s]]);
-                base.push([x, y_base[s]]);
-            }
-        }
-        // Plant sharp spikes on both top and baseline in interior columns.
-        top[777 * 6 + 1][1] = 1.0;
-        top[1999 * 6 + 2][1] = 99.0;
-        base[1234 * 6 + 3][1] = 101.0;
-        base[2501 * 6 + 4][1] = 199.0;
-
-        let poly = decimate_area(top, base, max);
-        assert_eq!(poly.len() % 2, 0);
-        let half = poly.len() / 2;
-        assert!(half <= max * 4, "retained {half} paired vertices, limit is {}", max * 4);
-        for i in 0..half {
-            assert_eq!(poly[i][0], poly[poly.len() - 1 - i][0]);
-        }
-        let top_kept = &poly[..half];
-        let base_kept = &poly[half..];
-        assert_eq!(top_kept.first().map(|p| p[0]), Some(0.0));
-        assert_eq!(top_kept.last().map(|p| p[0]), Some(2999.5));
-        assert!(top_kept.iter().any(|p| p[1] == 1.0), "top min spike preserved");
-        assert!(top_kept.iter().any(|p| p[1] == 99.0), "top max spike preserved");
-        assert!(base_kept.iter().any(|p| p[1] == 101.0), "base min spike preserved");
-        assert!(base_kept.iter().any(|p| p[1] == 199.0), "base max spike preserved");
-    }
 }

crates/chart/src/resolve.rs

@@ -179,10 +179,9 @@ fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str) -> (
 /// Whether `t` names a defined name seen from `sheet` (`Name`, or `Sheet1!Name` looked up on
 /// that sheet), the way the evaluator looks names up.
 fn is_defined_name(wb: &Workbook, sheet: usize, t: &str) -> bool {
-    // `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012).
-    match gridcraft_core::split_sheet(t) {
-        (Some(s), bare) => wb.sheet_index(&s).is_some_and(|i| wb.name(bare, i).is_some()),
-        (None, _) => wb.name(t, sheet).is_some(),
+    match t.split_once('!') {
+        Some((s, bare)) => wb.sheet_index(s.trim_matches('\'')).is_some_and(|i| wb.name(bare, i).is_some()),
+        None => wb.name(t, sheet).is_some(),
     }
 }
 

crates/chart/src/tests.rs

@@ -1258,75 +1258,3 @@ fn box_whisker_draws_each_series_quartile_method() {
     // The boxes span 3.5 and 2.5 data units on the same value axis.
     assert!((heights[0] / heights[1] - 1.4).abs() < 0.001);
 }
-
-#[test]
-fn a_series_named_by_a_name_on_a_sheet_with_an_apostrophe_resolves() {
-    // #2012: `'Bob''s'!Title` kept the doubled quote, so the sheet wasn't found and the series
-    // was named by the literal text.
-    let mut wb = Workbook::new();
-    {
-        let s = wb.sheet_mut(0).unwrap();
-        s.name = "Bob's".into();
-        s.set_value(CellRef::new(0, 0), Value::from("Takings"));
-        s.set_value(CellRef::new(1, 0), Value::Number(4.0));
-        s.set_value(CellRef::new(2, 0), Value::Number(9.0));
-    }
-    wb.names.push(gridcraft_model::DefinedName {
-        name: "Title".into(),
-        scope: Some(0),
-        formula: "'Bob''s'!$A$1".into(),
-        comment: String::new(),
-        hidden: false,
-    });
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.series = vec![Series {
-        name: Some("'Bob''s'!Title".into()),
-        categories: None,
-        values: "'Bob''s'!$A$2:$A$3".into(),
-        bubble_sizes: None,
-        color: None,
-        secondary: false,
-        kind: None,
-        quartiles: Default::default(),
-        smooth: false,
-        trendlines: Vec::new(),
-    }];
-    let d = resolve(&wb, 0, &c);
-    assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings"));
-}
-
-#[test]
-fn a_series_named_by_a_name_on_a_sheet_with_a_bang_resolves() {
-    // `'a!b'!Title`: the sheet name holds a `!`, so the evaluator must split the parsed name at
-    // the last one, not the first.
-    let mut wb = Workbook::new();
-    {
-        let s = wb.sheet_mut(0).unwrap();
-        s.name = "a!b".into();
-        s.set_value(CellRef::new(0, 0), Value::from("Takings"));
-        s.set_value(CellRef::new(1, 0), Value::Number(4.0));
-        s.set_value(CellRef::new(2, 0), Value::Number(9.0));
-    }
-    wb.names.push(gridcraft_model::DefinedName {
-        name: "Title".into(),
-        scope: Some(0),
-        formula: "'a!b'!$A$1".into(),
-        comment: String::new(),
-        hidden: false,
-    });
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.series = vec![Series {
-        name: Some("'a!b'!Title".into()),
-        categories: None,
-        values: "'a!b'!$A$2:$A$3".into(),
-        bubble_sizes: None,
-        color: None,
-        secondary: false,
-        kind: None,
-        quartiles: Default::default(),
-        smooth: false,
-        trendlines: Vec::new(),
-    }];
-    let d = resolve(&wb, 0, &c);
-    assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings"));
-}

crates/core/src/addr.rs

@@ -188,12 +188,6 @@ impl RangeRef {
             end: CellRef::new(self.end.row.max(o.end.row), self.end.col.max(o.end.col)),
         }
     }
-    /// The top-left cell of a list of areas: the lowest row and the lowest column across all of
-    /// them, whatever order they are listed in. Excel writes the relative formulas of a
-    /// multi-area validation or conditional format for this cell. `None` for no areas.
-    pub fn top_left(ranges: &[RangeRef]) -> Option<CellRef> {
-        ranges.iter().copied().reduce(|a, b| a.union(&b)).map(|r| r.start)
-    }
     /// Row-major iterator over the cells. Callers must bound huge ranges themselves.
     pub fn iter(&self) -> impl Iterator<Item = CellRef> + '_ {
         let (r0, r1, c0, c1) = (self.start.row, self.end.row, self.start.col, self.end.col);
@@ -313,16 +307,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn top_left_spans_every_area_in_any_order() {
-        let areas: Vec<RangeRef> = ["H62:H68", "H26:H27", "H93:H95"].iter().filter_map(|a| RangeRef::parse(a)).collect();
-        assert_eq!(RangeRef::top_left(&areas), CellRef::parse("H26"));
-        // Lowest row and lowest column, even when they come from different areas.
-        let areas: Vec<RangeRef> = ["C5:D6", "E2", "B9"].iter().filter_map(|a| RangeRef::parse(a)).collect();
-        assert_eq!(RangeRef::top_left(&areas), CellRef::parse("B2"));
-        assert_eq!(RangeRef::top_left(&[]), None);
-    }
-
     #[test]
     fn sheet_quoting_follows_excel() {
         for quoted in [

crates/engine/src/cf.rs

@@ -244,7 +244,7 @@ impl CfCache {
         let v = sh.value(c);
         let no_stats = RuleStats::default();
         for (idx, cf) in rules {
-            let first = RangeRef::top_left(&cf.ranges).unwrap_or(c);
+            let first = cf.ranges.first().map(|r| r.start).unwrap_or(c);
             let st: &RuleStats = match stats_need(&cf.rule) {
                 Some(need) => &*self.stats.entry(idx).or_insert_with(|| RuleStats::build(sh, &cf.ranges, need)),
                 None => &no_stats,

crates/engine/src/clip_html.rs

@@ -17,13 +17,11 @@ const MAX_ROW_SPAN: usize = gridcraft_core::MAX_ROWS as usize;
 /// table is ignored: the HTML only refines cells of the tab-separated text, which stays the source.
 const MAX_HTML_CELLS: usize = 1_000_000;
 
-/// One table cell: its visible text, the number the source recorded for it, if any, and whether
-/// it is a header cell (`<th>`).
+/// One table cell: its visible text and the number the source recorded for it, if any.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub(crate) struct HtmlCell {
     pub text: String,
     pub num: Option<f64>,
-    pub header: bool,
 }
 
 /// The cells of the first table in `html`, row by row, read no further than `max_rows` rows of
@@ -90,7 +88,7 @@ pub(crate) fn table_cells(html: &str, max_rows: usize, max_cols: usize) -> Vec<V
                 let num = attr(attrs, "x:num").or_else(|| attr(attrs, "sdval")).and_then(|v| v.trim().parse::<f64>().ok()).filter(|n| n.is_finite());
                 let colspan = span(attrs, "colspan", MAX_SPAN);
                 let rowspan = span(attrs, "rowspan", MAX_ROW_SPAN);
-                cell = Some(OpenCell { cell: HtmlCell { text: String::new(), num, header: name == "th" }, colspan, rowspan });
+                cell = Some(OpenCell { cell: HtmlCell { text: String::new(), num }, colspan, rowspan });
             }
             ("td" | "th", true) | ("tr", true) => grid.finish(&mut cell),
             ("br", _) => {
@@ -378,18 +376,18 @@ mod tests {
             <tr><td colspan=2 x:num="2.5">2.50 &amp; up</td><td>x</td></tr><!--EndFragment--></table></body></html>"#;
         let rows = table_cells(excel, 2, 3);
         assert_eq!(rows.len(), 2);
-        assert_eq!(rows[0][0], HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0), ..HtmlCell::default() });
-        assert_eq!(rows[0][1], HtmlCell { text: "Name".into(), num: None, ..HtmlCell::default() });
+        assert_eq!(rows[0][0], HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0) });
+        assert_eq!(rows[0][1], HtmlCell { text: "Name".into(), num: None });
         assert_eq!(rows[1].len(), 3, "colspan keeps the next cell in its column");
         assert_eq!(rows[1][0].text, "2.50 & up");
         assert_eq!(rows[1][2].text, "x");
 
         let calc = r#"<table cellspacing="0" border="0"><colgroup width="85"></colgroup><tr>
             <td height="17" align="right" sdval="10000" sdnum="1033;0;[$Rp-421]#,##0.00"><font face="Liberation Sans">Rp10,000.00</font></td></tr></table>"#;
-        assert_eq!(table_cells(calc, 1, 1), vec![vec![HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0), ..HtmlCell::default() }]]);
+        assert_eq!(table_cells(calc, 1, 1), vec![vec![HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0) }]]);
 
         let quoted_gt = r#"<table><tr><td style='mso-number-format:"\[>=1000\]0"' x:num="1500">1500</td></tr></table>"#;
-        assert_eq!(table_cells(quoted_gt, 1, 1), vec![vec![HtmlCell { text: "1500".into(), num: Some(1500.0), ..HtmlCell::default() }]]);
+        assert_eq!(table_cells(quoted_gt, 1, 1), vec![vec![HtmlCell { text: "1500".into(), num: Some(1500.0) }]]);
     }
 
     #[test]
@@ -436,7 +434,7 @@ mod tests {
         assert!(cells <= MAX_HTML_CELLS, "{cells} cells");
         assert!(rows.iter().all(|r| r.len() <= MAX_SPAN));
         assert_eq!(rows[0].len(), MAX_SPAN, "the first span fills the sheet's width");
-        assert_eq!(rows[0][0], HtmlCell { text: "1".into(), num: Some(1.0), ..HtmlCell::default() });
+        assert_eq!(rows[0][0], HtmlCell { text: "1".into(), num: Some(1.0) });
 
         // Bounded by the pasted text's shape, the same markup yields just that shape.
         let rows = table_cells(&html, 3, 2);

crates/engine/src/cmd.rs

@@ -459,11 +459,8 @@ pub(crate) const TOUCH_LOG_LIMIT: usize = 1_000_000;
 pub(crate) const PROTECTED: &str = "The cell or chart you're trying to change is on a protected sheet.";
 
 /// Refuses an edit that changed what a locked cell on a protected sheet holds (its value or
-/// formula), or that unlocked it, whichever command made it. Sheets are matched by name, so
-/// moving, renaming or deleting a sheet isn't an edit of its cells. A sort or duplicate removal
-/// that moves an unlocked cell with equal content onto a locked one changes no content but would
-/// leave the cell editable, so the effective lock (row and column formats included) is compared
-/// as well.
+/// formula), whichever command made it. Sheets are matched by name, so moving, renaming or
+/// deleting a sheet isn't an edit of its cells.
 fn check_protection(old: &Workbook, new: &Workbook, unlocked: &[(String, String)]) -> Result<()> {
     for sh in &old.sheets {
         if !sh.is_protected() {
@@ -474,8 +471,7 @@ fn check_protection(old: &Workbook, new: &Workbook, unlocked: &[(String, String)
             continue;
         }
         for c in sh.cells.diff(&after.cells) {
-            let unlocked_now = !new.styles.get(after.style_id(c)).protection.locked;
-            if (unlocked_now || !same_content(sh.cell(c), after.cell(c)))
+            if !same_content(sh.cell(c), after.cell(c))
                 && old.styles.get(sh.style_id(c)).protection.locked
                 && let Some(m) = locked_cell_error(sh, c, unlocked)
             {
@@ -503,14 +499,10 @@ pub(crate) fn refuse_unless_allowed(s: &Session, sheet: usize, what: &str, pick:
 pub(crate) fn locked_cell_error(sh: &gridcraft_model::Sheet, c: CellRef, unlocked: &[(String, String)]) -> Option<String> {
     let mut needs_password = None;
     for r in sh.edit_ranges.iter().filter(|r| r.contains(c)) {
-        // A range limited to Windows users or groups (a security descriptor) can't be checked
-        // here, so without a password it stays locked rather than opening to every editor.
-        if (r.password.is_none() && r.security_descriptor.is_none()) || unlocked.iter().any(|(s, t)| *s == sh.name && *t == r.title) {
+        if r.password.is_none() || unlocked.iter().any(|(s, t)| *s == sh.name && *t == r.title) {
             return None;
         }
-        if r.password.is_some() {
-            needs_password.get_or_insert(r.title.as_str());
-        }
+        needs_password.get_or_insert(r.title.as_str());
     }
     Some(match needs_password {
         Some(t) => format!("The range \"{t}\" needs its password before it can be changed (Review › Allow Edit Ranges)."),

crates/engine/src/cmd/data/filter.rs

@@ -270,7 +270,6 @@ pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) {
 
 pub(super) fn clear_filter(s: &mut Session, _: &Json) -> Result<Json> {
     let sheet = s.doc()?.wb.active_sheet();
-    crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
         if let Some(a) = sh.autofilter.as_mut() {
@@ -284,7 +283,6 @@ pub(super) fn clear_filter(s: &mut Session, _: &Json) -> Result<Json> {
 
 pub(super) fn reapply(s: &mut Session, _: &Json) -> Result<Json> {
     let sheet = s.doc()?.wb.active_sheet();
-    crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
     edit(s, |cx| {
         apply_filter(&mut cx.wb, sheet);
         cx.structural = true;

crates/engine/src/cmd/data/grouping.rs

@@ -21,15 +21,6 @@ fn outline_lines(s: &Session, p: &Json) -> Result<(bool, u32, u32)> {
     }
 }
 
-/// Outline commands change line visibility and grouping: a protected sheet must allow formatting that axis.
-fn refuse_unless_outline_allowed(s: &Session, sheet: usize, rows: bool) -> Result<()> {
-    if rows {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting rows", |p| p.format_rows)
-    } else {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting columns", |p| p.format_columns)
-    }
-}
-
 pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
     let si = target_sheet(s, p)?;
     // The selection belongs to the active sheet, so another sheet needs its lines.
@@ -37,7 +28,6 @@ pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
         return Err(bad(if on { "data.group" } else { "data.ungroup" }, "missing `rows` or `cols`: the selection is on the active sheet"));
     }
     let (rows, a, b) = outline_lines(s, p)?;
-    refuse_unless_outline_allowed(s, si, rows)?;
     edit(s, |cx| {
         let sh = cx.sheet_mut(si)?;
         let before = outline::summary_before(sh, rows);
@@ -68,7 +58,6 @@ pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
 /// + button, saved to XLSX); showing keeps inner groups that were collapsed on their own collapsed.
 pub(super) fn detail(s: &mut Session, p: &Json, hide: bool) -> Result<Json> {
     let (rows, a, b) = outline_lines(s, p)?;
-    refuse_unless_outline_allowed(s, s.doc()?.wb.active_sheet(), rows)?;
     let want = p.get("level").and_then(Json::as_u64).map(|l| l.min(outline::MAX_LEVEL as u64) as u8);
     edit(s, |cx| {
         let si = cx.sheet_index();
@@ -134,12 +123,6 @@ pub(super) fn show_levels(s: &mut Session, p: &Json) -> Result<Json> {
             msg: "give `rows` or `cols`: the outline level to show (1 = top-level summaries only)".into(),
         });
     }
-    let active = s.doc()?.wb.active_sheet();
-    for (n, is_rows) in [(rows, true), (cols, false)] {
-        if n.is_some() {
-            refuse_unless_outline_allowed(s, active, is_rows)?;
-        }
-    }
     edit(s, |cx| {
         let si = cx.sheet_index();
         let sh = cx.sheet_mut(si)?;

crates/engine/src/cmd/data/tests.rs

@@ -480,45 +480,6 @@ fn a_list_typed_without_quotes_is_saved_as_a_quoted_list() {
     assert_eq!(sheet_xml(&reopened), xml, "a second save writes the same rules");
 }
 
-#[test]
-fn a_relative_list_source_is_read_from_the_cell_being_checked() {
-    // As in Excel, `=$B1:$B2` on A3:A4,A1:A2 is written for A1 (the top-left cell of all the
-    // areas) and lists B4:B5 at A4. It used to list B1:B2 in every cell.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "B1:B5", "values": [["a"], ["b"], ["c"], ["d"], ["e"]]})).unwrap();
-    s.execute("data.validation", json!({"range": "A3:A4,A1:A2", "type": "list", "formula1": "=$B1:$B2"})).unwrap();
-    let wb = s.doc().unwrap().wb.clone();
-    let dv = wb.active().unwrap().validations[0].clone();
-    for (cell, items) in [("A1", ["a", "b"]), ("A2", ["b", "c"]), ("A3", ["c", "d"]), ("A4", ["d", "e"])] {
-        let at = CellRef::parse(cell).unwrap();
-        assert_eq!(list_items(&wb, 0, at, &dv), items, "{cell}");
-        for v in ["a", "b", "c", "d", "e"] {
-            assert_eq!(check_validation(&wb, 0, at, v).is_none(), items.contains(&v), "{cell} with {v}");
-        }
-    }
-}
-
-#[test]
-fn a_list_source_that_takes_in_the_cell_does_not_list_the_value_being_typed() {
-    // `=$A1:$A2` on A2:A3 is A1:A2 at A2 and A2:A3 at A3. The list is the one before the entry, as
-    // in Excel; a new value used to land in its own source and pass.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:A2", "values": [["x"], ["y"]]})).unwrap();
-    s.execute("data.validation", json!({"range": "A2:A3", "type": "list", "formula1": "=$A1:$A2"})).unwrap();
-    let wb = &s.doc().unwrap().wb;
-    for (cell, accepted, refused) in [("A2", &["x", "y"][..], &["new"][..]), ("A3", &["y"], &["x", "new"])] {
-        let at = CellRef::parse(cell).unwrap();
-        for v in accepted {
-            assert!(check_validation(wb, 0, at, v).is_none(), "{cell} refuses {v}");
-        }
-        for v in refused {
-            assert!(check_validation(wb, 0, at, v).is_some(), "{cell} accepts {v}");
-        }
-    }
-}
-
 #[test]
 fn a_rule_with_an_unknown_type_operator_or_error_style_is_refused() {
     // A typo used to give a rule that validates nothing (`type="none"`) or the wrong check,

crates/engine/src/cmd/data/validation.rs

@@ -38,18 +38,11 @@ fn subtract_range(r: RangeRef, cut: &RangeRef) -> Vec<RangeRef> {
 }
 
 /// Removes the cells of `cuts` from every validation, keeping the rest of each rule's ranges.
-/// When the rule's top-left cell goes, its relative formulas are rewritten for the new top-left
-/// cell, so the cells left keep checking the same cells.
 pub(in super::super) fn remove_validation_cells(validations: &mut Vec<Validation>, cuts: &[RangeRef]) {
     for dv in validations.iter_mut() {
-        let before = RangeRef::top_left(&dv.ranges);
         for cut in cuts {
             dv.ranges = dv.ranges.iter().flat_map(|r| subtract_range(*r, cut)).collect();
         }
-        if let (Some(from), Some(to)) = (before, RangeRef::top_left(&dv.ranges)) {
-            dv.f1 = move_rule_formula(&dv.f1, from, to);
-            dv.f2 = dv.f2.take().map(|f| move_rule_formula(&f, from, to));
-        }
     }
     validations.retain(|d| !d.ranges.is_empty());
 }
@@ -152,10 +145,8 @@ fn list_source(f: &str) -> String {
     format!("\"{}\"", t.replace('"', "\"\""))
 }
 
-/// List entries of a list validation (literal or from a range) for the cell `at`. A relative
-/// source is written for the rule's top-left cell and read from `at`, as in Excel (`=$B1:$B3` on
-/// A1:A9 lists B5:B7 at A5).
-pub fn list_items(wb: &Workbook, sheet: usize, at: CellRef, dv: &Validation) -> Vec<String> {
+/// List entries of a list validation (literal or from a range).
+pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec<String> {
     let f = dv.f1.trim();
     if is_literal_list(f) {
         // A quoted list is a string literal: `""` inside stands for one `"`.
@@ -165,8 +156,8 @@ pub fn list_items(wb: &Workbook, sheet: usize, at: CellRef, dv: &Validation) ->
         };
         return items.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect();
     }
-    let first = RangeRef::top_left(&dv.ranges).unwrap_or(at);
-    match gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at)) {
+    let at = dv.ranges.first().map(|r| r.start).unwrap_or_default();
+    match gridcraft_calc::evaluate(wb, sheet, at, f) {
         Value::Array(a) => a.data.iter().filter(|v| !v.is_empty()).map(Value::display).collect(),
         v if !v.is_empty() && !v.is_error() => vec![v.display()],
         _ => vec![],
@@ -184,10 +175,9 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) -
         return None;
     }
     let v = gridcraft_core::parse::parse_input(input, wb.date_system).value;
-    // The formulas are written for the top-left cell of all the areas and see the value being entered,
+    // The formulas are written for the first cell of the range and see the value being entered,
     // as in Excel (a custom `=A1>10` on A1:A9 checks A5's new value at A5).
-    let first = RangeRef::top_left(&dv.ranges).unwrap_or(at);
-    let original = wb;
+    let first = dv.ranges.first().map(|r| r.start).unwrap_or(at);
     let entered;
     let wb = if sh.value(at) == v {
         wb
@@ -203,9 +193,7 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) -
     let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at));
     let num = |f: &str| eval(f).to_number().ok();
     let ok = match dv.kind {
-        // The list is the one the dropdown showed before the entry, as in Excel: a source that takes
-        // in the cell itself (`=$A1:$A2` on A2:A3 is A2:A3 at A3) doesn't list the value being typed.
-        ValidationKind::List => list_items(original, sheet, at, dv).iter().any(|x| x.eq_ignore_ascii_case(input)),
+        ValidationKind::List => list_items(wb, sheet, dv).iter().any(|x| x.eq_ignore_ascii_case(input)),
         ValidationKind::Custom => eval(&dv.f1).to_bool().unwrap_or(false),
         ValidationKind::TextLength => {
             let n = input.chars().count() as f64;

crates/engine/src/cmd/edit.rs

@@ -23,7 +23,7 @@ use cell::{cell_set, range_fill, range_set_values};
 pub(crate) use cell::{check_arg_counts, input_to_cell, is_formula_input, json_to_input, parse_typed_formula};
 #[cfg(test)]
 pub(crate) use clipboard::parse_tsv;
-use clipboard::{clear_clipboard, copy, cut, paste, range_move};
+use clipboard::{clear_clipboard, copy, cut, paste};
 use fill::{auto_fill, fill_dir, fill_series, flash_fill};
 #[cfg(test)]
 use find::replace_ci;
@@ -36,7 +36,7 @@ use go_to::go_to_special;
 use go_to::{GO_TO_MAX_AREAS, GO_TO_RECENT, reference_parts};
 use paste_special::paste_special;
 pub(crate) use paste_special::{rewrite_all_formulas, rewrite_cell_links, rewrite_python_refs};
-use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_next_corner, selection_set};
+use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_set};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
@@ -62,15 +62,6 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "selection.set", "Select", [], None, "{range: \"A1:B2,D4\" | cell, active?: \"A1\", sheet?}", has_doc, selection_set),
         cmd!(noundo "selection.move", "Move Selection", [], None, "{dr, dc, extend?: bool, jump?: bool (Ctrl+arrow), page?: bool}", has_doc, selection_move),
         cmd!(noundo "selection.next", "Next Cell in Selection", [], None, "{forward?: true, byRow?: false} (Enter/Tab inside a selection)", has_doc, selection_next),
-        cmd!(
-            noundo "selection.nextCorner",
-            "Next Corner of Selection",
-            [],
-            Some("Ctrl+."),
-            "{} (the active cell moves clockwise to the next corner of the selected area, which stays selected)",
-            has_doc,
-            selection_next_corner
-        ),
         cmd!(noundo "edit.selectAll", "Select All", ["Edit"], Some("Cmd+A"), "{} (current region first, then the whole sheet)", has_doc, select_all),
         cmd!(noundo "selection.currentRegion", "Select Current Region", [], Some("Ctrl+Shift+8"), "{}", has_doc, select_region),
         cmd!(noundo "selection.row", "Select Entire Row", [], Some("Shift+Space"), "{}", has_doc, select_row),
@@ -90,15 +81,6 @@ pub fn specs() -> Vec<CommandSpec> {
             has_doc,
             paste
         ),
-        cmd!(
-            "range.move",
-            "Drag and Drop",
-            [],
-            None,
-            "{range?, to: \"C3\", overwrite?: bool} (drag the selection's border: a cut and paste that asks before replacing data unless overwrite)",
-            has_doc,
-            range_move
-        ),
         CommandSpec {
             shortcut_mac: Some("Ctrl+Cmd+V"),
             ..cmd!(
@@ -144,13 +126,13 @@ pub fn specs() -> Vec<CommandSpec> {
             fill_series
         ),
         cmd!("edit.flashFill", "Flash Fill", ["Home", "Editing", "Fill"], Some("Ctrl+E"), "{range?}", has_doc, flash_fill),
-        cmd!(noundo "edit.find", "Find…", ["Home", "Editing", "Find & Select"], Some("Cmd+F"), "{what, matchCase?, wholeCell?, lookIn?: formulas|values, byColumns?, all?: bool, within?: sheet|workbook|selection} (selection: only the selected cells; Find Next keeps them selected and moves the active cell)", has_doc, find),
+        cmd!(noundo "edit.find", "Find…", ["Home", "Editing", "Find & Select"], Some("Cmd+F"), "{what, matchCase?, wholeCell?, lookIn?: formulas|values, byColumns?, all?: bool, within?: sheet|workbook}", has_doc, find),
         cmd!(
             "edit.replace",
             "Replace…",
             ["Home", "Editing", "Find & Select"],
             Some("Ctrl+H"),
-            "{what, with, matchCase?, wholeCell?, all?: true, within?: sheet|workbook|selection} → {replaced, skipped?} (in a Python cell the code is edited; skipped counts Python cells whose code would no longer fit)",
+            "{what, with, matchCase?, wholeCell?, all?: true, within?: sheet|workbook} → {replaced, skipped?} (in a Python cell the code is edited; skipped counts Python cells whose code would no longer fit)",
             has_doc,
             replace
         ),
@@ -262,36 +244,21 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
             })
         })
     };
-    // Notes and links aren't cell contents, so the cell comparison that guards a protected sheet
-    // doesn't see them go: a locked cell's are refused here, stored cell or not.
-    if matches!(what, "all" | "comments" | "hyperlinks") {
-        let d = s.doc()?;
-        if let Some(sh) = d.wb.sheet(sheet).filter(|sh| sh.is_protected()) {
-            for &whole in &ranges {
-                let skip = filtered_rows(sh, whole);
-                let notes = matches!(what, "all" | "comments").then(|| sh.comments.keys()).into_iter().flatten();
-                let links = matches!(what, "all" | "hyperlinks").then(|| sh.hyperlinks.keys()).into_iter().flatten();
-                for &c in notes.chain(links).filter(|c| whole.contains(**c) && !skip.contains(&c.row)) {
-                    if d.wb.styles.get(sh.style_id(c)).protection.locked
-                        && let Some(m) = locked_cell_error(sh, c, &d.unlocked_ranges)
-                    {
-                        return Err(EngineError::Other(m));
-                    }
-                }
-            }
-        }
-    }
     edit(s, |cx| {
-        for &whole in &ranges {
-            // Cells are only stored inside the used range. Notes and links are kept apart from
-            // them, so they are cleared over the whole range: one from a file can sit on a cell
-            // with nothing stored in it.
-            let used = cx.wb.sheet(sheet).and_then(|sh| sh.used_range()).and_then(|u| whole.intersection(&u));
-            let skip = cx.wb.sheet(sheet).map(|sh| filtered_rows(sh, whole)).unwrap_or_default();
-            let cells: Vec<(CellRef, Cell)> = match (cx.wb.sheet(sheet), used) {
-                (Some(sh), Some(r)) => sh.cells.iter_range(r).filter(|(c, _)| !skip.contains(&c.row)).map(|(c, x)| (c, x.clone())).collect(),
-                _ => Vec::new(),
+        for r in &ranges {
+            let r = match cx.wb.sheet(sheet).and_then(|sh| sh.used_range()) {
+                Some(u) => match r.intersection(&u) {
+                    Some(x) => x,
+                    None => continue,
+                },
+                None => continue,
             };
+            let skip = cx.wb.sheet(sheet).map(|sh| filtered_rows(sh, r)).unwrap_or_default();
+            let cells: Vec<(CellRef, Cell)> = cx
+                .wb
+                .sheet(sheet)
+                .map(|sh| sh.cells.iter_range(r).filter(|(c, _)| !skip.contains(&c.row)).map(|(c, x)| (c, x.clone())).collect())
+                .unwrap_or_default();
             // Report every stored cell we touch, even beyond a million coordinates in a sparse
             // selection. Removed formula anchors must also reach calc so their spills disappear.
             cx.changed.extend(cells.iter().map(|(c, _)| (sheet, *c)));
@@ -311,18 +278,6 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
                     }
                 }
             }
-            let cleared = |c: CellRef| whole.contains(c) && !skip.contains(&c.row);
-            // A removed note or link changes its cell even with nothing stored there.
-            let metadata: Vec<CellRef> = cx
-                .wb
-                .sheet(sheet)
-                .map(|sh| {
-                    let notes = matches!(what, "all" | "comments").then(|| sh.comments.keys()).into_iter().flatten();
-                    let links = matches!(what, "all" | "hyperlinks").then(|| sh.hyperlinks.keys()).into_iter().flatten();
-                    notes.chain(links).copied().filter(|c| cleared(*c)).collect()
-                })
-                .unwrap_or_default();
-            cx.changed.extend(metadata.into_iter().map(|c| (sheet, c)));
             let sh = cx.sheet_mut(sheet)?;
             for (c, mut cell) in cells {
                 match what {
@@ -339,15 +294,14 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
                     _ => {}
                 }
             }
+            let cleared = |c: CellRef| r.contains(c) && !skip.contains(&c.row);
             if matches!(what, "all" | "comments") {
                 sh.comments.retain(|c, _| !cleared(*c));
             }
             if matches!(what, "all" | "hyperlinks") {
                 sh.hyperlinks.retain(|c, _| !cleared(*c));
             }
-            if let Some(r) = used
-                && matches!(what, "all" | "formats")
-            {
+            if matches!(what, "all" | "formats") {
                 let mut unmerged = false;
                 sh.merges.retain(|m| {
                     let keep = !r.contains_range(m) || skip.range(m.start.row..=m.end.row).next().is_some();

crates/engine/src/cmd/edit/clipboard.rs

@@ -1,8 +1,7 @@
 use super::cell::input_to_cell;
 use super::paste_special::paste_special;
 use super::{
-    Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, bad, bool_param, cell_param_on, edit, json, ok, str_param, target_ranges,
-    target_sheet,
+    Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, cell_param_on, edit, json, ok, str_param, target_ranges, target_sheet,
 };
 
 // ---------------------------------------------------------------- clipboard
@@ -164,40 +163,6 @@ pub(super) fn paste(s: &mut Session, p: &Json) -> Result<Json> {
     paste_special(s, &json!({"what": "all", "at": p.get("at").cloned().unwrap_or(Json::Null)}))
 }
 
-/// Drag and drop (dragging the selection's border): moves `range` so its top-left cell lands on
-/// `to`, as Cut and Paste would. Like Excel, it asks before replacing cells that hold data or show a
-/// spilled value (other than the moved cells themselves); run it again with `overwrite: true` to replace them. A
-/// refused or failed move leaves the clipboard as it was.
-pub(super) fn range_move(s: &mut Session, p: &Json) -> Result<Json> {
-    let sheet = target_sheet(s, p)?;
-    let to = cell_param_on(s, p, "to", sheet)?.ok_or_else(|| bad("range.move", "missing `to`"))?;
-    let kept = s.clipboard.take();
-    let moved = cut(s, p).and_then(|_| {
-        let src = s.clipboard.as_ref().map(|c| c.range).unwrap_or_default();
-        let dest = to.offset(i64::from(src.height()) - 1, i64::from(src.width()) - 1).map(|end| RangeRef::new(to, end));
-        if bool_param(p, "overwrite") != Some(true)
-            && let Some(dest) = dest
-            && let Some(sh) = s.doc()?.wb.sheet(sheet)
-            && (sh.cells.iter_range(dest).any(|(c, cell)| !src.contains(c) && cell.has_content())
-                || sh.spill.range(dest.start..=dest.end).any(|(c, v)| dest.contains(*c) && !src.contains(*c) && *v != Value::Empty))
-        {
-            return Err(EngineError::Confirm("There's already data here. Do you want to replace it?".into()));
-        }
-        // On the range's sheet, which `paste` would leave to the active one. The selection
-        // belongs to the active sheet: it follows the moved cells only when they are on it.
-        let selection = s.doc()?.selection.clone();
-        let pasted = paste_special(s, &json!({"what": "all", "at": to.a1(), "sheet": sheet}))?;
-        if sheet != s.doc()?.wb.active_sheet() {
-            s.doc_mut()?.selection = selection;
-        }
-        Ok(pasted)
-    });
-    if moved.is_err() {
-        s.clipboard = kept;
-    }
-    moved
-}
-
 fn paste_text(s: &mut Session, p: &Json, text: &str) -> Result<Json> {
     let sheet = target_sheet(s, p)?;
     let at = cell_param_on(s, p, "at", sheet)?.unwrap_or(s.doc()?.selection.current().start);
@@ -261,55 +226,16 @@ pub(crate) fn parse_tsv(text: &str) -> Vec<Vec<String>> {
     let mut row = Vec::new();
     let mut field = String::new();
     let mut chars = text.chars().peekable();
-    // Text read again as unquoted, ahead of the rest of the input: a field that opened with a
-    // quote but turned out not to be quoted.
-    let mut replay: std::collections::VecDeque<char> = std::collections::VecDeque::new();
-    // Text is replayed at most as much as the input is long; past that, quotes are text, so
-    // hostile input full of fields that only look quoted reads in linear time.
-    let mut replay_budget = text.len();
     let mut quoted = false;
     let mut at_start = true;
-    // A quoted field's text as it stands in the input, for a field that turns out not to be one.
-    let mut raw = String::new();
-    loop {
-        let c = match replay.pop_front().or_else(|| chars.next()) {
-            Some(c) => c,
-            // A quote that never closes: the field is its text as written.
-            None if quoted => {
-                quoted = false;
-                field.clear();
-                field.push('"');
-                replay_budget = replay_budget.saturating_sub(raw.len());
-                replay.extend(raw.chars().skip(1));
-                raw.clear();
-                continue;
-            }
-            None => break,
-        };
+    while let Some(c) = chars.next() {
         if quoted {
-            raw.push(c);
             if c == '"' {
-                let next = replay.front().copied().or_else(|| chars.peek().copied());
-                if next == Some('"') {
+                if chars.peek() == Some(&'"') {
                     field.push('"');
-                    raw.push('"');
-                    if replay.pop_front().is_none() {
-                        chars.next();
-                    }
+                    chars.next();
                 } else {
                     quoted = false;
-                    // A field is quoted only when its closing quote ends it, as Excel reads it:
-                    // `"hi" there` is that text, quotes included, and a tab or line break inside
-                    // it still ends the cell, as if the leading quote weren't there.
-                    if !matches!(next, None | Some('\t' | '\n' | '\r')) {
-                        field.clear();
-                        field.push('"');
-                        replay_budget = replay_budget.saturating_sub(raw.len());
-                        let rest: Vec<char> = std::mem::take(&mut raw).chars().skip(1).collect();
-                        for ch in rest.into_iter().rev() {
-                            replay.push_front(ch);
-                        }
-                    }
                 }
             } else {
                 field.push(c);
@@ -317,10 +243,9 @@ pub(crate) fn parse_tsv(text: &str) -> Vec<Vec<String>> {
             continue;
         }
         match c {
-            '"' if at_start && replay_budget > 0 => {
+            '"' if at_start => {
                 quoted = true;
                 at_start = false;
-                raw = String::from('"');
             }
             '\t' => {
                 row.push(std::mem::take(&mut field));

crates/engine/src/cmd/edit/find.rs

@@ -62,8 +62,6 @@ pub(super) fn find(s: &mut Session, p: &Json) -> Result<Json> {
     let by_cols = bool_param(p, "byColumns").unwrap_or(false);
     let all = bool_param(p, "all").unwrap_or(false);
     let workbook = str_param(p, "within") == Some("workbook");
-    // `selection`: only the selected cells of the active sheet, as Excel searches a selected range.
-    let in_selection = str_param(p, "within") == Some("selection");
     s.last_find = Some(p.clone());
     let d = s.doc()?;
     let sheets: Vec<usize> = if workbook { (0..d.wb.sheets.len()).collect() } else { vec![d.wb.active_sheet()] };
@@ -73,7 +71,6 @@ pub(super) fn find(s: &mut Session, p: &Json) -> Result<Json> {
         let mut cells: Vec<(CellRef, String)> = sh
             .cells
             .iter()
-            .filter(|(c, _)| !in_selection || d.selection.contains(*c))
             .filter_map(|(c, cell)| {
                 let text = if values || cell.formula.is_none() || crate::display::formula_hidden(&d.wb, sh, c) {
                     crate::display::cell_text(&d.wb, sh, c)
@@ -103,12 +100,7 @@ pub(super) fn find(s: &mut Session, p: &Json) -> Result<Json> {
     let Some((si, c, t)) = next else { return Err(EngineError::Other("not found".into())) };
     let dd = s.doc_mut()?;
     dd.wb_switch_sheet(si);
-    if in_selection {
-        // The range stays selected and the active cell moves through it, as in Excel.
-        dd.selection.active = c;
-    } else {
-        dd.selection = crate::Selection::at(c);
-    }
+    dd.selection = crate::Selection::at(c);
     Ok(json!({"cell": c.a1(), "sheet": si, "value": t, "count": hits.len()}))
 }
 
@@ -122,7 +114,6 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
     let whole = bool_param(p, "wholeCell").unwrap_or(false);
     let all = bool_param(p, "all").unwrap_or(true);
     let workbook = str_param(p, "within") == Some("workbook");
-    let selection = (str_param(p, "within") == Some("selection")).then(|| s.doc().map(|d| d.selection.clone())).transpose()?;
     let active = s.doc()?.selection.active;
     let mut skipped = 0usize;
     let n = edit(s, |cx| {
@@ -132,7 +123,7 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
             let cells: Vec<(CellRef, String)> =
                 cx.wb.sheet(si).map(|sh| sh.cells.iter().map(|(c, _)| (c, sh.input_text(c))).collect()).unwrap_or_default();
             for (c, text) in cells {
-                if (!all && c != active) || selection.as_ref().is_some_and(|sel| !sel.contains(c)) {
+                if !all && c != active {
                     continue;
                 }
                 if !matches(&text, &what, case, whole) {

crates/engine/src/cmd/edit/paste_special.rs

@@ -284,7 +284,7 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
                 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 = RangeRef::top_left(&dv.ranges).unwrap_or(sc);
+                    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)];

crates/engine/src/cmd/edit/selection.rs

@@ -137,23 +137,6 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result<Json> {
     Ok(json!({"active": d.selection.active.a1()}))
 }
 
-pub(super) fn selection_next_corner(s: &mut Session, _: &Json) -> Result<Json> {
-    let d = s.doc_mut()?;
-    let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };
-    // A corner in a merged cell lands on its top-left cell. One in a hidden row or column, one
-    // the sheet's protection doesn't let you select, and a merged cell that starts outside the
-    // selected area are skipped.
-    let area = d.selection.current();
-    let stop = |c: CellRef| {
-        Some(sheet.merge_at(c).map_or(c, |m| m.start))
-            .filter(|c| area.contains(*c) && !sheet.is_row_hidden(c.row) && !sheet.is_col_hidden(c.col) && cell_selectable(&d.wb, sheet, *c))
-    };
-    let mut next = d.selection.clone();
-    next.next_corner_by(stop);
-    d.selection = next;
-    Ok(json!({"active": d.selection.active.a1(), "selection": d.selection.a1()}))
-}
-
 pub(super) fn select_all(s: &mut Session, _: &Json) -> Result<Json> {
     let d = s.doc_mut()?;
     let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) };

crates/engine/src/cmd/edit/tests.rs

@@ -307,9 +307,6 @@ fn tsv() {
     assert_eq!(parse_tsv("a\tb\n1\t2\n"), vec![vec!["a", "b"], vec!["1", "2"]]);
     assert_eq!(parse_tsv("\"x\ty\"\tz"), vec![vec!["x\ty", "z"]]);
     assert_eq!(parse_tsv("\"he said \"\"hi\"\"\""), vec![vec!["he said \"hi\""]]);
-    // #2225: a quote that doesn't close the field leaves it as written, as Excel pastes it.
-    assert_eq!(parse_tsv("\"hi\" there\tx\n"), vec![vec!["\"hi\" there", "x"]]);
-    assert_eq!(parse_tsv("say \"hi\"\n"), vec![vec!["say \"hi\""]]);
 }
 
 #[test]
@@ -356,74 +353,6 @@ fn cut_paste_that_overflows_the_grid_moves_nothing() {
     assert_eq!(get(&mut s, "XFD2")["value"], json!(2.0));
 }
 
-#[test]
-fn drag_and_drop_asks_before_replacing_data() {
-    // #3136: dragging column B's border onto column A replaced A without asking.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:B3", "values": [["Apple", "Kiwi"], ["Pear", "Plum"], ["Fig", "Lime"]]})).unwrap();
-    s.execute("edit.copy", json!({"range": "D9"})).unwrap();
-    let text = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["input"].clone();
-    let r = s.execute("range.move", json!({"range": "B:B", "to": "A1"}));
-    let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") };
-    assert_eq!(q, "There's already data here. Do you want to replace it?");
-    // Nothing moved, and the copy made before is still on the clipboard.
-    assert_eq!(text(&mut s, "A1"), json!("Apple"));
-    assert_eq!(text(&mut s, "B1"), json!("Kiwi"));
-    assert!(s.clipboard.as_ref().is_some_and(|c| !c.cut && c.range.a1() == "D9"));
-    // Confirmed, column B replaces column A.
-    s.execute("range.move", json!({"range": "B:B", "to": "A1", "overwrite": true})).unwrap();
-    assert_eq!(text(&mut s, "A1"), json!("Kiwi"));
-    assert_eq!(text(&mut s, "A3"), json!("Lime"));
-    assert_eq!(text(&mut s, "B1"), json!(""));
-    // Onto empty cells, or overlapping only the moved cells themselves, nothing is asked.
-    s.execute("range.move", json!({"range": "A1:A3", "to": "A2"})).unwrap();
-    assert_eq!(text(&mut s, "A4"), json!("Lime"));
-    s.execute("range.move", json!({"range": "A2:A4", "to": "C2"})).unwrap();
-    assert_eq!(text(&mut s, "C2"), json!("Kiwi"));
-    assert!(s.execute("range.move", json!({"range": "C2"})).is_err(), "`to` is required");
-}
-
-#[test]
-fn drag_and_drop_asks_before_replacing_spilled_values() {
-    // Cells showing a dynamic array's spilled values hold no cell of their own, but they are data.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("cell.set", json!({"cell": "A1", "input": "=SEQUENCE(3)"})).unwrap();
-    s.execute("range.setValues", json!({"range": "C2:C3", "values": [["Kiwi"], ["Plum"]]})).unwrap();
-    let r = s.execute("range.move", json!({"range": "C2:C3", "to": "A2"}));
-    let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") };
-    assert_eq!(q, "There's already data here. Do you want to replace it?");
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    assert_eq!(sh.value(CellRef::new(2, 2)), Value::text("Plum"));
-    s.execute("range.move", json!({"range": "C2:C3", "to": "A2", "overwrite": true})).unwrap();
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    assert_eq!(sh.value(CellRef::new(1, 0)), Value::text("Kiwi"));
-}
-
-#[test]
-fn drag_and_drop_on_another_sheet_stays_on_that_sheet() {
-    // The move was checked on the range's sheet but pasted on the active one, replacing its data
-    // without asking.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.insertSheet", json!({"name": "Two"})).unwrap();
-    s.execute("range.setValues", json!({"range": "B1:B2", "values": [["Kiwi"], ["Plum"]]})).unwrap();
-    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-    s.execute("cell.set", json!({"cell": "A1", "input": "Keep"})).unwrap();
-    s.execute("selection.set", json!({"range": "C5"})).unwrap();
-    s.execute("range.move", json!({"range": "Two!B1:B2", "to": "A1"})).unwrap();
-    // Sheet1 stays active with its own selection; the moved cells are on Two.
-    assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
-    assert_eq!(s.doc().unwrap().selection.a1(), "C5");
-    let wb = &s.doc().unwrap().wb;
-    let two = wb.sheet_index("Two").unwrap();
-    assert_eq!(wb.sheet(0).unwrap().value(CellRef::new(0, 0)), Value::text("Keep"));
-    assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(0, 0)), Value::text("Kiwi"));
-    assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(1, 0)), Value::text("Plum"));
-    assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(0, 1)), Value::Empty);
-}
-
 #[test]
 fn replace_case_insensitive() {
     assert_eq!(replace_ci("Apple apple APPLE", "apple", "pear"), "pear pear pear");
@@ -442,141 +371,3 @@ fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() {
     let sh = s.doc().unwrap().wb.active().unwrap();
     assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text));
 }
-
-#[test]
-fn next_corner_of_selection_goes_clockwise_and_anchors_there() {
-    // #1442, as Excel does it: B2 → D2 → D4 → B4 → B2, the area stays selected, and Shift+arrows
-    // then move the corner opposite the new active cell.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("selection.set", json!({"range": "B2:D4", "active": "B2"})).unwrap();
-    let mut seen = Vec::new();
-    for _ in 0..4 {
-        let r = s.execute("selection.nextCorner", json!({})).unwrap();
-        assert_eq!(r["selection"], "B2:D4");
-        seen.push(r["active"].as_str().unwrap().to_string());
-    }
-    assert_eq!(seen, ["D2", "D4", "B4", "B2"]);
-    s.execute("selection.nextCorner", json!({})).unwrap();
-    s.execute("selection.nextCorner", json!({})).unwrap();
-    s.execute("selection.move", json!({"dr": 0, "dc": 1, "extend": true})).unwrap();
-    assert_eq!(s.doc().unwrap().selection.current().a1(), "C2:D4");
-    // One row goes end to end; a single cell stays.
-    s.execute("selection.set", json!({"range": "B2:D2", "active": "B2"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "D2");
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B2");
-    s.execute("selection.set", json!({"range": "C5"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C5");
-}
-
-#[test]
-fn next_corner_skips_corners_the_sheet_protection_does_not_let_you_select() {
-    // With locked cells unselectable, Ctrl+. goes on to the next corner it may select.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.lockCell", json!({"range": "B2:C3", "on": false})).unwrap();
-    s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap();
-    s.execute("review.protectSheet", json!({"selectLockedCells": false})).unwrap();
-    let r = s.execute("selection.nextCorner", json!({})).unwrap();
-    assert_eq!((r["active"].as_str(), r["selection"].as_str()), (Some("B3"), Some("B2:D3")), "D2 and D3 are locked");
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B2");
-}
-
-#[test]
-fn next_corner_stops_once_on_a_merged_corner_at_its_top_left_cell() {
-    // A corner inside a merged cell is that merged cell, whose active cell is its top-left one.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.mergeCells", json!({"range": "C2:D2"})).unwrap();
-    s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap();
-    let seen: Vec<String> = (0..4).map(|_| s.execute("selection.nextCorner", json!({})).unwrap()["active"].as_str().unwrap().to_string()).collect();
-    assert_eq!(seen, ["C2", "D3", "B3", "B2"]);
-    // A selection that is one merged cell has no other corner.
-    s.execute("selection.set", json!({"range": "C2:D2", "active": "C2"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C2");
-}
-
-#[test]
-fn next_corner_skips_hidden_corners_and_stays_inside_the_selected_area() {
-    // A corner in a hidden column is passed over, as keyboard moves pass over hidden cells.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.hideColumns", json!({"cols": "D:D"})).unwrap();
-    s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B3");
-    // Column C selected with B1:C1 merged: its top corner's merged cell starts in column B,
-    // outside the selection, so the active cell doesn't go there.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.mergeCells", json!({"range": "B1:C1"})).unwrap();
-    s.execute("selection.set", json!({"cell": "C5"})).unwrap();
-    s.execute("selection.column", json!({})).unwrap();
-    let r = s.execute("selection.nextCorner", json!({})).unwrap();
-    assert_eq!((r["active"].as_str(), r["selection"].as_str()), (Some("C1048576"), Some("C:C")));
-}
-
-#[test]
-fn copy_quotes_only_cells_with_tabs_or_line_breaks() {
-    // #2225: a cell holding a quote was wrapped in quotes on copy; Excel quotes only text with a
-    // tab or line break, and pastes the result back as the same cells.
-    let mut s = Session::new();
-    s.new_workbook();
-    for (cell, input) in [("A1", "say \"hi\""), ("A2", "plain"), ("A3", "\"hi\" there"), ("A4", "x \"q\"\ny"), ("A5", "tab\tinside")] {
-        s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap();
-    }
-    let text = s.execute("edit.copy", json!({"range": "A1:A5"})).unwrap()["text"].as_str().unwrap().to_string();
-    assert_eq!(text, "say \"hi\"\nplain\n\"hi\" there\n\"x \"\"q\"\"\ny\"\n\"tab\tinside\"\n");
-    let rows = parse_tsv(&text);
-    let cells: Vec<&str> = rows.iter().map(|r| r[0].as_str()).collect();
-    assert_eq!(cells, ["say \"hi\"", "plain", "\"hi\" there", "x \"q\"\ny", "tab\tinside"]);
-}
-
-#[test]
-fn a_field_that_is_not_really_quoted_keeps_its_separators() {
-    // A field opening with a quote is quoted only if a closing quote ends it; when it doesn't (or
-    // never closes), the text is read as written, and the tabs and line breaks inside it still
-    // separate cells, as they would have without the leading quote.
-    assert_eq!(parse_tsv("\"a\tb\"x\tc"), vec![vec!["\"a", "b\"x", "c"]]);
-    assert_eq!(parse_tsv("\"a\tb\nc"), vec![vec!["\"a", "b"], vec!["c"]]);
-    assert_eq!(parse_tsv("\"a\tb\tc\n"), vec![vec!["\"a", "b", "c"]]);
-    // Cells copied without quotes (they hold no tab or line break) read back as the same cells.
-    let mut s = Session::new();
-    s.new_workbook();
-    for (cell, input) in [("A1", "'\"a"), ("B1", "b\"x"), ("C1", "c")] {
-        s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap();
-    }
-    let text = s.execute("edit.copy", json!({"range": "A1:C1"})).unwrap()["text"].as_str().unwrap().to_string();
-    assert_eq!(parse_tsv(&text), vec![vec!["\"a", "b\"x", "c"]], "{text:?}");
-    // Many fields that only look quoted: each is replayed at most once (the replay budget is the
-    // input's length), and every one is still its own cell.
-    let hostile = "\"x\t".repeat(50_000);
-    assert_eq!(parse_tsv(&hostile).first().map(Vec::len), Some(50_001));
-}
-
-/// `within: selection` searches only the selected cells, as Excel does with a range selected
-/// (#3224): Find All lists them, Find Next moves the active cell through them and keeps the range
-/// selected, and Replace changes only them.
-#[test]
-fn find_and_replace_within_the_selection() {
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:B4", "values": [["pear", "pear"], ["plum", "pear"], ["pear", "fig"], ["pear", "pear"]]}))
-        .unwrap();
-    s.execute("selection.set", json!({"range": "B1:B4"})).unwrap();
-    let all = s.execute("edit.find", json!({"what": "pear", "all": true, "within": "selection"})).unwrap();
-    let cells: Vec<&str> = all["results"].as_array().unwrap().iter().filter_map(|r| r["cell"].as_str()).collect();
-    assert_eq!(cells, ["B1", "B2", "B4"], "only column B");
-    assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B2");
-    assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B4");
-    assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B1", "wraps inside the range");
-    let sel = &s.doc().unwrap().selection;
-    assert_eq!((sel.a1(), sel.active.a1()), ("B1:B4".to_string(), "B1".to_string()), "the range stays selected");
-    assert!(s.execute("edit.find", json!({"what": "plum", "within": "selection"})).is_err(), "A2 is outside the range");
-    assert_eq!(s.execute("edit.replace", json!({"what": "pear", "with": "kiwi", "within": "selection"})).unwrap()["replaced"], 3);
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    let at = |a: &str| sh.value(CellRef::parse(a).unwrap());
-    assert_eq!((at("A1"), at("B1"), at("B4"), at("A4")), (Value::text("pear"), Value::text("kiwi"), Value::text("kiwi"), Value::text("pear")));
-    // The sheet scope is unchanged.
-    let all = s.execute("edit.find", json!({"what": "pear", "all": true})).unwrap();
-    assert_eq!(all["count"], 3, "A1, A3 and A4 on the whole sheet");
-}

crates/engine/src/cmd/format/sizes.rs

@@ -9,17 +9,6 @@ use super::{
 /// sheet is `sheet`, else the prefix, else the active one. The selection belongs to the active
 /// sheet, so another sheet needs explicit lines.
 fn line_targets(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> {
-    let (sheet, lines) = resolve_lines(s, p, rows)?;
-    // Sizes and visibility are formatting of the line, which a protected sheet must allow.
-    if rows {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting rows", |p| p.format_rows)?;
-    } else {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting columns", |p| p.format_columns)?;
-    }
-    Ok((sheet, lines))
-}
-
-fn resolve_lines(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> {
     let key = if rows { "rows" } else { "cols" };
     let mut sheet = target_sheet(s, p)?;
     if let Some(t) = str_param(p, key) {

crates/engine/src/cmd/insert.rs

@@ -1100,10 +1100,6 @@ fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
         .unwrap_or_else(|| if data.starts_with(&[0x89, b'P', b'N', b'G']) { "image/png".into() } else { "image/jpeg".into() });
     let (w, h) = crate::io::image_size(&data).unwrap_or((320, 240));
     let d = s.doc()?;
-    // Sheet protection locks drawing objects, as for a text box's text.
-    if d.wb.active().is_some_and(|sh| sh.is_protected()) {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
     let id = d.wb.next_object_id();
     let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
     let scale = (640.0 / w.max(1) as f32).min(1.0);
@@ -1737,13 +1733,7 @@ fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
             sh.cond_formats.clear();
         } else {
             for cf in sh.cond_formats.iter_mut() {
-                let before = RangeRef::top_left(&cf.ranges);
                 cf.ranges.retain(|r| !ranges.iter().any(|x| x.intersects(r)));
-                // The relative formulas are written for the top-left cell: when it goes, they're
-                // rewritten for the new one, so the areas left keep reading the same cells.
-                if let (Some(from), Some(to)) = (before, RangeRef::top_left(&cf.ranges)) {
-                    rebase_cf_formulas(&mut cf.rule, from, to);
-                }
             }
             sh.cond_formats.retain(|c| !c.ranges.is_empty());
         }
@@ -1751,19 +1741,6 @@ fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
     })
 }
 
-/// Moves the relative references of a rule's per-cell formulas written for `from` to `to`.
-fn rebase_cf_formulas(rule: &mut CfRule, from: CellRef, to: CellRef) {
-    let mv = |f: &str| crate::cmd::data::move_rule_formula(f, from, to);
-    match rule {
-        CfRule::CellIs { a, b, .. } => {
-            *a = mv(a);
-            *b = b.as_deref().map(mv);
-        }
-        CfRule::Expression { formula, .. } => *formula = mv(formula),
-        _ => {}
-    }
-}
-
 fn manage_cf(s: &mut Session, p: &Json) -> Result<Json> {
     let sheet = target_sheet(s, p)?;
     if p.get("delete").is_none() && p.get("moveUp").is_none() && p.get("moveDown").is_none() {

crates/engine/src/cmd/pivot/create.rs

@@ -67,6 +67,9 @@ fn field_list(v: Option<&Json>) -> Vec<Json> {
 }
 
 pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure && matches!(str_param(p, "destination"), None | Some("new")) {
+        return Err(other("The workbook is protected and cannot be changed."));
+    }
     let source = source_param(s, p)?;
     let active = s.doc()?.wb.active_sheet();
     // Validate the source now (header names, size).
@@ -95,10 +98,6 @@ pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
         let at = RangeRef::parse(body).map(|r| r.start).ok_or_else(|| bad("insert.pivotTable", format!("not a cell: `{dest}`")))?;
         Some((si, at))
     };
-    // Decided on the resolved destination: `New`, ` new ` and an empty one all make a sheet.
-    if target.is_none() && s.doc()?.wb.protected_structure {
-        return Err(other("The workbook is protected and cannot be changed."));
-    }
     let replace = bool_param(p, "replace").unwrap_or(false);
     let rows = field_list(p.get("rows"));
     let columns = field_list(p.get("columns"));

crates/engine/src/cmd/pivot/fields.rs

@@ -507,13 +507,9 @@ pub(super) fn value_settings(s: &mut Session, p: &Json) -> Result<Json> {
         let mut v = cur.clone();
         if let Some(f) = func {
             v.func = f;
-            // An automatic caption follows the function. Count Numbers was captioned "Count
-            // Numbers of …" before it took Excel's "Count of …", and saved workbooks still carry it.
-            let is_auto = |base: &str| {
-                cur.name.eq_ignore_ascii_case(base) || cur.name.strip_prefix(base).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit()))
-            };
-            let legacy = cur.func == PivotFunc::CountNumbers && is_auto(&format!("Count Numbers of {}", cur.source_col));
-            if is_auto(&auto_name(cur.func, &cur.source_col)) || legacy {
+            // An automatic caption follows the function.
+            let auto = auto_name(cur.func, &cur.source_col);
+            if cur.name.eq_ignore_ascii_case(&auto) || cur.name.strip_prefix(auto.as_str()).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit())) {
                 v.name = unique_value_name(pt, &auto_name(f, &cur.source_col), Some(i));
             }
         }

crates/engine/src/cmd/pivot/tests.rs

@@ -168,19 +168,6 @@ fn filters_and_report_filter_rows() {
     assert!(s.execute("pivot.filter", json!({"field": "Product", "selected": []})).is_err());
 }
 
-/// A selection of the most labels allowed (100,000) is looked up once per record, not scanned: the
-/// report still filters case-insensitively.
-#[test]
-fn a_huge_filter_selection_is_matched_through_a_set() {
-    let mut s = sales();
-    s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
-    let mut selected: Vec<String> = (0..99_999).map(|i| format!("Region {i}")).collect();
-    selected.push("EAST".into());
-    s.execute("pivot.filter", json!({"field": "Region", "selected": selected})).unwrap();
-    let gt = find_row(&s, "Grand Total").unwrap();
-    assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(415.0));
-}
-
 #[test]
 fn show_values_as() {
     let mut s = sales();
@@ -1026,36 +1013,3 @@ fn detail_cells_are_the_cells_show_details_takes() {
     let pt = &d.wb.active().unwrap().pivots[0];
     assert!(crate::pivot::detail_cells(&d.wb, pt, d.wb.active_sheet()).unwrap_err().contains("out of date"));
 }
-
-#[test]
-fn rank_ties_are_dense_and_count_numbers_is_captioned_count_of() {
-    // #1448 items 10 and 12: Excel ranks 5, 4, 3, 3, 4 as 1, 2, 3, 3, 2 (GridCraft gave 1, 2, 4,
-    // 4, 2), and captions a Count Numbers field "Count of Val".
-    let mut s = Session::new();
-    s.new_workbook();
-    let rows = json!([["Key", "Val"], ["A", 5], ["B", 4], ["C", 3], ["D", 3], ["E", 4]]);
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    s.execute("insert.pivotTable", json!({"source": "Sheet1!$A$1:$B$6", "destination": "Sheet1!D3", "rows": ["Key"], "values": ["Val"]})).unwrap();
-    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "rank"})).unwrap();
-    let ranks: Vec<Value> = ["E4", "E5", "E6", "E7", "E8"].iter().map(|a| val(&s, a)).collect();
-    assert_eq!(ranks, [1.0, 2.0, 3.0, 3.0, 2.0].map(Value::Number));
-    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "normal", "func": "countNumbers"})).unwrap();
-    assert_eq!(text(&s, "E3"), "Count of Val");
-}
-
-#[test]
-fn legacy_count_numbers_caption_follows_the_function() {
-    // Workbooks saved before Count Numbers was captioned "Count of" carry "Count Numbers of Val";
-    // that is still an automatic caption, so it follows a new function. A custom name stays.
-    let mut s = Session::new();
-    s.new_workbook();
-    let rows = json!([["Key", "Val"], ["A", 5], ["B", 4]]);
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    s.execute("insert.pivotTable", json!({"source": "Sheet1!$A$1:$B$3", "destination": "Sheet1!D3", "rows": ["Key"], "values": ["Val"]})).unwrap();
-    for (legacy, after) in [("Count Numbers of Val", "Sum of Val"), ("Count Numbers of Val2", "Sum of Val"), ("Numbers counted", "Numbers counted")] {
-        s.execute("pivot.valueSettings", json!({"index": 0, "func": "countNumbers", "name": legacy})).unwrap();
-        assert_eq!(text(&s, "E3"), legacy);
-        s.execute("pivot.valueSettings", json!({"index": 0, "func": "sum"})).unwrap();
-        assert_eq!(text(&s, "E3"), after, "{legacy}");
-    }
-}

crates/engine/src/cmd/print/header_footer.rs

@@ -153,17 +153,6 @@ pub struct HfSection {
     pub size: Option<f32>,
 }
 
-/// Most bytes one section's expanded text may hold. A code like `&A` adds the whole sheet name
-/// (or file path) each time it appears, and a JSON workbook's names have no length limit.
-const MAX_SECTION_BYTES: usize = 64 * 1024;
-
-/// Appends `s` unless the section would pass [`MAX_SECTION_BYTES`]; what doesn't fit is left out.
-fn push_field(text: &mut String, s: &str) {
-    if text.len().saturating_add(s.len()) <= MAX_SECTION_BYTES {
-        text.push_str(s);
-    }
-}
-
 /// Expands a header/footer string into its left, centre and right sections.
 pub fn expand_header_footer(spec: &str, cx: &HfContext) -> [HfSection; 3] {
     let mut out: [HfSection; 3] = Default::default();
@@ -198,14 +187,14 @@ pub fn expand_header_footer(spec: &str, cx: &HfContext) -> [HfSection; 3] {
                         i += 1 + digits.len();
                     }
                 }
-                push_field(&mut sec.text, &n.to_string());
+                sec.text.push_str(&n.to_string());
             }
-            'N' | 'n' => push_field(&mut sec.text, &cx.pages.to_string()),
-            'D' | 'd' => push_field(&mut sec.text, &cx.date),
-            'T' | 't' => push_field(&mut sec.text, &cx.time),
-            'A' | 'a' => push_field(&mut sec.text, &cx.sheet),
-            'F' | 'f' => push_field(&mut sec.text, &cx.file),
-            'Z' | 'z' => push_field(&mut sec.text, &cx.path),
+            'N' | 'n' => sec.text.push_str(&cx.pages.to_string()),
+            'D' | 'd' => sec.text.push_str(&cx.date),
+            'T' | 't' => sec.text.push_str(&cx.time),
+            'A' | 'a' => sec.text.push_str(&cx.sheet),
+            'F' | 'f' => sec.text.push_str(&cx.file),
+            'Z' | 'z' => sec.text.push_str(&cx.path),
             '&' => sec.text.push('&'),
             'B' | 'b' => sec.bold = !sec.bold,
             'I' | 'i' => sec.italic = !sec.italic,

crates/engine/src/cmd/print/tests.rs

@@ -414,12 +414,6 @@ fn pdf_contains_text_and_header_codes_expand() {
     assert_eq!(r.text, "P4/9 9:00 AM");
     assert_eq!(expand_header_footer("plain", &cx)[1].text, "plain");
     assert_eq!(expand_header_footer("&", &cx)[1].text, "");
-    // A megabyte sheet name repeated by 5,000 `&A` codes stops at the section's 64 KiB.
-    let long = HfContext { sheet: "S".repeat(1024 * 1024), ..cx };
-    let [_, c, _] = expand_header_footer(&"&A".repeat(5_000), &long);
-    assert!(c.text.is_empty(), "the name alone is over the limit");
-    let short = HfContext { sheet: "S".repeat(1000), ..Default::default() };
-    assert_eq!(expand_header_footer(&"&A".repeat(5_000), &short)[1].text.len(), 65_000);
 }
 
 #[test]
@@ -701,79 +695,6 @@ fn bands_unit() {
     assert!(w.len() > 2);
 }
 
-/// The wrapper `wrap_lines` replaced, re-measuring strings, as the reference for its lines.
-fn wrap_lines_remeasuring(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
-    let mut out = Vec::new();
-    for para in text.split('\n') {
-        let mut line = String::new();
-        for word in para.split(' ') {
-            let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") };
-            if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width {
-                line = cand;
-            } else {
-                out.push(std::mem::take(&mut line));
-                line = word.to_string();
-            }
-            while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 {
-                let chars: Vec<char> = line.chars().collect();
-                let (mut lo, mut hi) = (1usize, chars.len());
-                while lo < hi {
-                    let mid = lo + (hi - lo).div_ceil(2);
-                    let cut: String = chars[..mid].iter().collect();
-                    if gridcraft_pdf::text_width(font, size, &cut) <= width {
-                        lo = mid;
-                    } else {
-                        hi = mid - 1;
-                    }
-                }
-                if lo == chars.len() {
-                    break;
-                }
-                out.push(chars[..lo].iter().collect());
-                line = chars[lo..].iter().collect();
-            }
-            if out.len() > 2000 {
-                return out;
-            }
-        }
-        out.push(line);
-    }
-    out
-}
-
-#[test]
-fn wrap_lines_matches_the_remeasuring_wrapper() {
-    let texts = [
-        "the quick brown fox jumps",
-        "Supercalifragilistic",
-        "a  b   c\n\nverylongwordthatneedsbreaking short\nend ",
-        "Wide WWWWWWWWWW words, iiiiiiii narrow ones; mixed MMMMiiiiMMMM",
-        "€ ü ß — unicode Ünïcödé text",
-        "",
-        " ",
-    ];
-    for text in texts {
-        for font in [Font::Helvetica, Font::HelveticaBold, Font::Courier] {
-            for (size, width) in [(10.0, 50.0), (10.0, 20.0), (11.0, 1.0), (8.0, 300.0), (12.0, 0.0)] {
-                assert_eq!(wrap_lines(text, font, size, width), wrap_lines_remeasuring(text, font, size, width), "{text:?} {font:?} {size} {width}");
-            }
-        }
-    }
-}
-
-#[test]
-fn wrapping_a_long_word_in_a_narrow_box_stops_at_the_line_limit() {
-    // One character per line: the old wrapper re-measured and copied the rest of the word for
-    // each of the 100,000 lines before checking the limit.
-    let word = "w".repeat(100_000);
-    let lines = wrap_lines(&word, Font::Helvetica, 10.0, 1.0);
-    assert!(lines.len() <= 2002, "{}", lines.len());
-    assert!(lines.iter().all(|l| l == "w"));
-    // A long paragraph in a very wide box is one line.
-    let para = vec!["word"; 50_000].join(" ");
-    assert_eq!(wrap_lines(&para, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
-}
-
 #[test]
 fn center_across_spans_following_empty_center_across_cells() {
     let mut styles = StyleTable::default();

crates/engine/src/cmd/print/text.rs

@@ -3,57 +3,42 @@ use super::{CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, Sheet
 
 const PAD_PX: f32 = 2.0;
 
-/// Most lines [`wrap_lines`] returns (it may return one more, the rest of a paragraph).
-const MAX_WRAP_LINES: usize = 2000;
-
 /// Word-wraps `text` to `width` points.
-///
-/// Widths are kept as running sums of glyph widths (the sum `text_width` makes), so each
-/// character is measured once: re-measuring the line for every word, or the rest of an
-/// over-long word for every piece cut from it, made a long paragraph or word quadratic.
 pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
-    let units_of = |s: &str| -> u64 { s.chars().map(|c| u64::from(font.char_width(c))).sum() };
-    let fits = |units: u64| units as f32 * size / 1000.0 <= width;
-    let space = units_of(" ");
     let mut out = Vec::new();
     for para in text.split('\n') {
         let mut line = String::new();
-        let mut line_units: u64 = 0;
         for word in para.split(' ') {
-            let word_units = units_of(word);
-            if line.is_empty() {
-                line.push_str(word);
-                line_units = word_units;
-            } else if fits(line_units + space + word_units) {
-                line.push(' ');
-                line.push_str(word);
-                line_units += space + word_units;
+            let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") };
+            if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width {
+                line = cand;
             } else {
                 out.push(std::mem::take(&mut line));
-                line.push_str(word);
-                line_units = word_units;
+                line = word.to_string();
             }
-            // Break a single over-long word by characters: each piece is the longest that fits
-            // (at least one character).
-            if !fits(line_units) && line.chars().nth(1).is_some() {
-                let mut piece = String::new();
-                let mut units: u64 = 0;
-                for c in line.chars() {
-                    let w = u64::from(font.char_width(c));
-                    if !piece.is_empty() && !fits(units + w) {
-                        out.push(std::mem::take(&mut piece));
-                        units = 0;
-                        if out.len() > MAX_WRAP_LINES {
-                            return out;
-                        }
+            // Break a single over-long word by characters. The cut that fits is found by binary
+            // search (each try measures one candidate prefix), so an over-long word costs
+            // O(n log n) measurements instead of re-measuring the whole cut per character for
+            // every emitted line (`a` × 100k pasted text would be cubic worst case).
+            while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 {
+                let chars: Vec<char> = line.chars().collect();
+                let (mut lo, mut hi) = (1usize, chars.len());
+                while lo < hi {
+                    let mid = lo + (hi - lo).div_ceil(2);
+                    let cut: String = chars[..mid].iter().collect();
+                    if gridcraft_pdf::text_width(font, size, &cut) <= width {
+                        lo = mid;
+                    } else {
+                        hi = mid - 1;
                     }
-                    piece.push(c);
-                    units += w;
                 }
-                line = piece;
-                line_units = units;
+                if lo == chars.len() {
+                    break;
+                }
+                out.push(chars[..lo].iter().collect());
+                line = chars[lo..].iter().collect();
             }
-            if out.len() > MAX_WRAP_LINES {
+            if out.len() > 2000 {
                 return out;
             }
         }

crates/engine/src/cmd/sheet.rs

@@ -398,10 +398,10 @@ fn move_columns(s: &mut Session, p: &Json) -> Result<Json> {
     {
         return Err(EngineError::Other("To prevent possible loss of data, columns cannot be shifted off of the worksheet.".into()));
     }
-    // The checks must authorize the sheet this command modifies, not whatever sheet is active:
-    // both get the index `target_sheet` resolved (from `sheet`, or a `Sheet!` range or cell).
-    check_lines_protection(s, &json!({"cols": RangeRef::cols(before, before).a1(), "sheet": sheet}), Axis::Cols, before, count, true)?;
-    check_lines_protection(s, &json!({"cols": RangeRef::cols(from, end - 1).a1(), "sheet": sheet}), Axis::Cols, from, count, false)?;
+    // The checks must authorize the sheet this command modifies (`target_sheet`), not whatever
+    // sheet is active: both carry the command's own `sheet` parameter on.
+    check_lines_protection(s, &json!({"cols": RangeRef::cols(before, before).a1(), "sheet": p.get("sheet")}), Axis::Cols, before, count, true)?;
+    check_lines_protection(s, &json!({"cols": RangeRef::cols(from, end - 1).a1(), "sheet": p.get("sheet")}), Axis::Cols, from, count, false)?;
 
     let moved_from = if before <= from { from + count } else { from };
     if moved_from.checked_add(count).is_none_or(|end| end > MAX_COLS) {

crates/engine/src/cmd/view.rs

@@ -40,27 +40,6 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("view.showZeros", "Show Zeros", [], None, "{on?}", has_doc, |s, p| sheet_flag(s, p, "zeros")),
         cmd!("view.showOutlineSymbols", "Show Outline Symbols", [], Some("Ctrl+8"), "{on?}", has_doc, |s, p| sheet_flag(s, p, "outlineSymbols")),
         cmd!("view.showObjects", "Show Objects", [], Some("Ctrl+6"), "{on?}", has_doc, show_objects),
-        cmd!(
-            "view.showSheetTabs",
-            "Show Sheet Tabs",
-            [],
-            None,
-            "{on?} (File › Options › Advanced, this workbook; toggles without `on`)",
-            has_doc,
-            |s, p| { workbook_view_flag(s, p, "sheetTabs") }
-        ),
-        cmd!(
-            "view.showHorizontalScrollBar",
-            "Show Horizontal Scroll Bar",
-            [],
-            None,
-            "{on?} (this workbook; toggles without `on`)",
-            has_doc,
-            |s, p| { workbook_view_flag(s, p, "horizontal") }
-        ),
-        cmd!("view.showVerticalScrollBar", "Show Vertical Scroll Bar", [], None, "{on?} (this workbook; toggles without `on`)", has_doc, |s, p| {
-            workbook_view_flag(s, p, "vertical")
-        }),
         cmd!("view.rightToLeft", "Sheet Right-to-Left", ["Page Layout", "Sheet Options"], None, "{on?}", has_doc, |s, p| sheet_flag(s, p, "rtl")),
         cmd!("view.zoom", "Zoom", ["View", "Zoom"], None, "{percent: 10..400}", has_doc, zoom),
         cmd!("view.zoom100", "100%", ["View", "Zoom"], None, "{}", has_doc, |s, _| zoom(s, &json!({"percent": 100}))),
@@ -210,21 +189,6 @@ fn sheet_flag(s: &mut Session, p: &Json, which: &str) -> Result<Json> {
     })
 }
 
-/// File › Options › Advanced › Display options for this workbook: the sheet tabs and the two
-/// scroll bars, saved with the workbook (`<workbookView showSheetTabs … />`).
-fn workbook_view_flag(s: &mut Session, p: &Json, which: &str) -> Result<Json> {
-    edit(s, |cx| {
-        let view = &mut cx.wb.view;
-        let slot = match which {
-            "sheetTabs" => &mut view.show_sheet_tabs,
-            "horizontal" => &mut view.show_horizontal_scroll,
-            _ => &mut view.show_vertical_scroll,
-        };
-        *slot = bool_param(p, "on").unwrap_or(!*slot);
-        Ok(json!({"on": *slot}))
-    })
-}
-
 /// Ctrl+6: hides every object, or shows them again. Placeholders (from a file) count as shown.
 fn show_objects(s: &mut Session, p: &Json) -> Result<Json> {
     use gridcraft_model::ShowObjects;

crates/engine/src/display.rs

@@ -156,9 +156,7 @@ pub fn range_text(wb: &Workbook, sheet: usize, r: RangeRef) -> String {
             }
             first = false;
             let t = cell_text(wb, sh, CellRef::new(row, col));
-            // Like Excel, only text with a tab or line break is quoted (its quotes doubled);
-            // `say "hi"` is copied as it is (#2225).
-            if t.contains(['\t', '\n', '\r']) {
+            if t.contains(['\t', '\n', '"']) {
                 out.push('"');
                 out.push_str(&t.replace('"', "\"\""));
                 out.push('"');

crates/engine/src/fill.rs

@@ -575,9 +575,20 @@ pub fn series(cx: &mut Ctx, sheet: usize, options: SeriesOptions<'_>) -> Result<
                     match (unit, d) {
                         ("month", Some(_)) => (step as i64).checked_mul(i as i64).and_then(|m| add_months_clamped(sys, start, m)).unwrap_or(v),
                         ("year", Some(_)) => (step as i64).checked_mul(i as i64 * 12).and_then(|m| add_months_clamped(sys, start, m)).unwrap_or(v),
-                        // Whole weeks at a time: a huge step costs no more than a small one.
-                        ("weekday", Some(_)) => add_weekdays(sys, v, step as i64)
-                            .ok_or_else(|| crate::EngineError::Other("The weekday series runs past the supported date range.".into()))?,
+                        ("weekday", Some(_)) => {
+                            let mut n = v;
+                            let mut left = step.abs() as i64;
+                            while left > 0 {
+                                n += step.signum();
+                                let Some(day) = datetime_from_serial(sys, n) else {
+                                    return Err(crate::EngineError::Other("The weekday series runs past the supported date range.".into()));
+                                };
+                                if day.weekday != 0 && day.weekday != 6 {
+                                    left -= 1;
+                                }
+                            }
+                            n
+                        }
                         _ => v + step,
                     }
                 }

crates/engine/src/io.rs

@@ -1,4 +1,4 @@
-//! Opening and saving files: XLSX, legacy XLS import, XLSB and ODS data import, SYLK import, CSV/TSV, JSON (debug), HTML export.
+//! Opening and saving files: XLSX, legacy XLS import, XLSB and ODS data import, CSV/TSV, JSON (debug), HTML export.
 
 use std::fmt::Write as _;
 
@@ -7,8 +7,6 @@ use gridcraft_model::{Sheet, Workbook};
 
 use crate::{EngineError, Result};
 
-mod sylk;
-
 /// File formats GridCraft reads or writes.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum FileKind {
@@ -21,8 +19,6 @@ pub enum FileKind {
     Tsv,
     Json,
     Html,
-    /// SYLK symbolic link text (import only).
-    Sylk,
 }
 
 impl FileKind {
@@ -37,7 +33,6 @@ impl FileKind {
             "tsv" | "tab" | "txt" => FileKind::Tsv,
             "json" | "scjson" => FileKind::Json,
             "html" | "htm" => FileKind::Html,
-            "slk" => FileKind::Sylk,
             _ => return None,
         })
     }
@@ -296,9 +291,6 @@ fn read_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook,
         })?;
         return Ok((wb, report.warnings));
     }
-    if let Some(read) = read_html_table(name, kind, bytes, csv_as_text) {
-        return read;
-    }
     match kind {
         Some(FileKind::Json) => {
             let mut wb: Workbook = serde_json::from_slice(bytes).map_err(|e| EngineError::Other(format!("not a GridCraft JSON workbook: {e}")))?;
@@ -318,11 +310,6 @@ fn read_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook,
             }
             Ok((wb, warnings))
         }
-        Some(FileKind::Sylk) => {
-            let (mut wb, warnings) = sylk::read(name, bytes)?;
-            rename_first_sheet(&mut wb, name);
-            Ok((wb, warnings))
-        }
         Some(FileKind::Tsv) => {
             let opts = gridcraft_xlsx::CsvOptions { delimiter: b'\t', parse_values: !csv_as_text, ..Default::default() };
             let (mut wb, report) = gridcraft_xlsx::read_csv_with_report(bytes, &opts).map_err(|e| EngineError::Other(e.to_string()))?;
@@ -359,112 +346,9 @@ fn part_too_large_message(name: &str, part: &str, size: u64) -> String {
     )
 }
 
-/// How much of a text file is read to tell whether it is a web page.
-const HTML_SNIFF_BYTES: usize = 64 << 10;
-
-/// A web page that holds a table, whatever its extension: a web app's "Export to Excel" is often
-/// HTML saved as `.xls` (#3166). Excel opens its table as a sheet (after warning that the format
-/// and extension don't match): the cells read like typed input (or as text with `csv_as_text`),
-/// header cells (`<th>`) are bold and centred, and the sheet takes the name the page gives it
-/// (`<x:Name>`) or the file's. `None` when the bytes aren't such a page.
-fn read_html_table(name: &str, kind: Option<FileKind>, bytes: &[u8], csv_as_text: bool) -> Option<Result<(Workbook, Vec<String>)>> {
-    // Every other text file (CSV, TSV, JSON) passes through here: look at the start only, and decode
-    // the whole file once it is known to be a page within the size a text import takes.
-    if matches!(kind, Some(FileKind::Json)) || bytes.len() > gridcraft_xlsx::MAX_CSV_BYTES {
-        return None;
-    }
-    let start = gridcraft_xlsx::decode_text(bytes.get(..HTML_SNIFF_BYTES).unwrap_or(bytes));
-    // Comments an exporter writes before the page (`<!-- ... -->`) don't make it something else.
-    let mut rest = start.trim_start_matches('\u{feff}').trim_start();
-    while let Some(after) = rest.strip_prefix("<!--") {
-        match after.find("-->").and_then(|end| after.get(end + 3..)) {
-            Some(more) => rest = more.trim_start(),
-            None => break,
-        }
-    }
-    let head: String = rest.chars().take(16).collect::<String>().to_ascii_lowercase();
-    if !["<!doctype html", "<html", "<table", "<head", "<body", "<meta"].iter().any(|t| head.starts_with(t)) {
-        return None;
-    }
-    // Decoded as a CSV is (BOM, UTF-8, else Windows-1252/1256), so a legacy page keeps its letters.
-    let text = gridcraft_xlsx::decode_text(bytes);
-    let rows = crate::clip_html::table_cells(&text, gridcraft_core::MAX_ROWS as usize, gridcraft_core::MAX_COLS as usize);
-    if rows.iter().all(Vec::is_empty) {
-        return None;
-    }
-    // The cells go through the CSV reader, so numbers, dates and text read exactly as they do there.
-    let mut tsv = String::new();
-    for row in &rows {
-        let fields: Vec<String> = row
-            .iter()
-            .map(|cell| {
-                // The number the page recorded (`x:num`) only when values are read; as text, the
-                // cell keeps the text it shows.
-                let field = match cell.num.filter(|_| !csv_as_text) {
-                    Some(n) => gridcraft_core::number_to_text(n),
-                    // Whitespace is already collapsed; non-breaking spaces stay, as in Excel.
-                    None => cell.text.clone(),
-                };
-                if field.contains(['\t', '\n', '\r', '"']) { format!("\"{}\"", field.replace('"', "\"\"")) } else { field }
-            })
-            .collect();
-        tsv.push_str(&fields.join("\t"));
-        tsv.push('\n');
-    }
-    let opts = gridcraft_xlsx::CsvOptions { delimiter: b'\t', parse_values: !csv_as_text, ..Default::default() };
-    let read = gridcraft_xlsx::read_csv_with_report(tsv.as_bytes(), &opts).map_err(|e| EngineError::Other(e.to_string()));
-    Some(read.map(|(mut wb, report)| {
-        wb.csv_delimiter = None;
-        // Header cells are bold and centred on top of the style the CSV reader gave them, so a
-        // date in a header keeps its date format.
-        let headers: Vec<CellRef> = rows
-            .iter()
-            .enumerate()
-            .flat_map(|(r, row)| row.iter().enumerate().filter(|(_, cell)| cell.header && !cell.text.trim().is_empty()).map(move |(c, _)| CellRef::new(r as u32, c as u32)))
-            .collect();
-        let mut bold: std::collections::HashMap<gridcraft_model::StyleId, gridcraft_model::StyleId> = std::collections::HashMap::new();
-        for at in headers {
-            let Some(base) = wb.sheet(0).map(|sh| sh.style_id(at)) else { continue };
-            let id = *bold.entry(base).or_insert_with(|| {
-                wb.styles.derive(base, |st| {
-                    st.font.bold = true;
-                    st.align.h = gridcraft_model::HAlign::Center;
-                })
-            });
-            if let Some(sh) = wb.sheet_mut(0) {
-                sh.set_style(at, id);
-            }
-        }
-        let page_name = find_between(&text, "<x:Name>", "</x:Name>").map(|n| crate::clip_html::normalized(n.trim()));
-        match page_name.filter(|n| !n.is_empty()) {
-            Some(sheet) => set_first_sheet_name(&mut wb, &sheet),
-            None => rename_first_sheet(&mut wb, name),
-        }
-        let mut warnings = report.warnings;
-        if !matches!(kind, Some(FileKind::Html)) {
-            warnings.insert(0, format!("'{name}' is a web page (HTML), not a workbook in the format its name says: its table was opened as a sheet. Save as .xlsx to keep your changes."));
-        }
-        (wb, warnings)
-    }))
-}
-
-/// The text between the first `open` and the `close` after it, matched case-insensitively.
-fn find_between<'a>(text: &'a str, open: &str, close: &str) -> Option<&'a str> {
-    let lower = text.to_ascii_lowercase();
-    let start = lower.find(&open.to_ascii_lowercase())?.checked_add(open.len())?;
-    let len = lower.get(start..)?.find(&close.to_ascii_lowercase())?;
-    text.get(start..start.checked_add(len)?)
-}
-
 /// A CSV opens as a sheet named after the file (like Excel).
 fn rename_first_sheet(wb: &mut Workbook, path: &str) {
     let stem = std::path::Path::new(path).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Sheet1");
-    set_first_sheet_name(wb, stem);
-}
-
-/// Names the first sheet `name`, without the characters a sheet name can't hold and cut to 31
-/// characters; an empty or reserved result keeps the default name.
-fn set_first_sheet_name(wb: &mut Workbook, stem: &str) {
     let clean: String = stem.chars().filter(|c| !matches!(c, ':' | '\\' | '/' | '?' | '*' | '[' | ']')).take(31).collect();
     let clean = clean.trim_matches('\'').to_string();
     // "History" is reserved (see `Workbook::check_sheet_name`): keep the default name instead.
@@ -505,9 +389,6 @@ pub fn save_bytes_as(wb: &Workbook, path: &str, kind: FileKind) -> Result<Vec<u8
         }
         FileKind::Xlsb => Err(EngineError::Other("XLSB is supported for data import only. Save as .xlsx or another supported export format.".into())),
         FileKind::Ods => Err(EngineError::Other("ODS is supported for data import only. Save as .xlsx or another supported export format.".into())),
-        FileKind::Sylk => {
-            Err(EngineError::Other("SYLK (.slk) is supported for import only. Save as .xlsx or another supported export format.".into()))
-        }
         // A workbook read from CSV keeps the separator it was read with (a `;` file stays `;`).
         FileKind::Csv => wb.sheet(sheet).map(|sh| csv(wb, sh, wb.csv_delimiter.unwrap_or(b','))).transpose().map(Option::unwrap_or_default),
         FileKind::Tsv => wb.sheet(sheet).map(|sh| csv(wb, sh, b'\t')).transpose().map(Option::unwrap_or_default),

crates/engine/src/io/sylk.rs

@@ -1,328 +0,0 @@
-//! SYLK (`.slk`) import: the symbolic link text format older spreadsheets and some legacy systems
-//! export. One record per line, fields separated by `;` (`;;` is a literal semicolon):
-//!
-//! - `ID` starts the file; `E` ends it.
-//! - `C;Y<row>;X<col>;K<value>;E<formula>` is a cell. `Y` and `X` may be left out to stay on the
-//!   current row or column. `K` is a number, `"text"`, `TRUE`/`FALSE` or an error; `E` is a
-//!   formula in R1C1 notation; `S;R<row>;C<col>` shares the formula of another cell.
-//! - `P;P<code>` adds a number format to the file's list; `F;P<n>;Y<row>;X<col>` gives a cell the
-//!   n-th format (0-based), and `F;W<first> <last> <width>` sets column widths in characters.
-//!
-//! Other records (fonts, options, window settings) are skipped. Formulas are converted to A1 with
-//! the same relative and absolute references, as Excel does when it opens the file.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use gridcraft_core::{CellError, CellRef, MAX_COLS, MAX_ROWS, Value, col_to_letters};
-use gridcraft_model::{Cell, Formula, NumFmt, Sheet, Style, Workbook};
-
-use crate::{EngineError, Result};
-
-/// The largest SYLK file read, as for other text imports: past it the file is refused.
-const MAX_BYTES: usize = 512 << 20;
-/// Column-width records kept from one file; each can cover every column.
-const MAX_WIDTH_RECORDS: usize = 1024;
-
-/// Reads a SYLK file into a one-sheet workbook. Returns the workbook and its warnings.
-pub fn read(name: &str, bytes: &[u8]) -> Result<(Workbook, Vec<String>)> {
-    if bytes.len() > MAX_BYTES {
-        return Err(EngineError::Other(format!("We can't open '{name}': the SYLK file is larger than {} MB.", MAX_BYTES >> 20)));
-    }
-    let text = match std::str::from_utf8(bytes) {
-        Ok(s) => s.to_string(),
-        // Older exports are in a single-byte code page: keep each byte as its Latin-1 character.
-        Err(_) => bytes.iter().map(|&b| char::from(b)).collect(),
-    };
-    let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
-    if !text.starts_with("ID") {
-        return Err(EngineError::Other(format!("We can't open '{name}': it isn't a SYLK file (it doesn't start with an ID record).")));
-    }
-    let mut sheet = Sheet::new("Sheet1");
-    let mut formats: Vec<String> = Vec::new();
-    // Cells' number formats by index into `formats`, applied once every format is known.
-    let mut cell_formats: Vec<(CellRef, usize)> = Vec::new();
-    let mut formulas: HashMap<CellRef, String> = HashMap::new();
-    let mut widths: Vec<(u32, u32, f64)> = Vec::new();
-    let (mut row, mut col) = (0u32, 0u32);
-    let mut skipped = 0usize;
-    for line in text.lines() {
-        let fields = split_fields(line);
-        let Some((kind, rest)) = fields.split_first() else { continue };
-        match kind.as_str() {
-            "C" => {
-                let (mut value, mut formula, mut shared) = (None, None, None::<(Option<u32>, Option<u32>)>);
-                let mut bad = false;
-                for f in rest {
-                    let (tag, arg) = f.split_at(f.chars().next().map_or(0, char::len_utf8));
-                    match tag {
-                        "Y" => match position(arg, MAX_ROWS) {
-                            Some(r) => row = r,
-                            None => bad = true,
-                        },
-                        "X" => match position(arg, MAX_COLS) {
-                            Some(c) => col = c,
-                            None => bad = true,
-                        },
-                        "K" => value = Some(parse_value(arg)),
-                        "E" => formula = Some(arg.to_string()),
-                        "S" => shared = Some((None, None)),
-                        // In a shared-formula cell, R and C name the cell whose formula it shares.
-                        "R" if shared.is_some() => shared = shared.map(|(_, c)| (position(arg, MAX_ROWS), c)),
-                        "C" if shared.is_some() => shared = shared.map(|(r, _)| (r, position(arg, MAX_COLS))),
-                        _ => {}
-                    }
-                }
-                if bad {
-                    skipped += 1;
-                    continue;
-                }
-                let at = CellRef::new(row, col);
-                if let Some((Some(r), Some(c))) = shared {
-                    formula = formulas.get(&CellRef::new(r, c)).cloned();
-                }
-                let mut cell = sheet.cell(at).cloned().unwrap_or_else(|| Cell::value(Value::Empty));
-                if let Some(v) = value {
-                    cell.value = v;
-                }
-                if let Some(r1c1) = formula {
-                    let a1 = r1c1_formula_to_a1(&r1c1, at);
-                    let f = Formula::new(&a1);
-                    if f.expr.is_some() {
-                        cell.formula = Some(Arc::new(f));
-                        formulas.insert(at, r1c1);
-                    } else {
-                        skipped += 1;
-                    }
-                }
-                sheet.set_cell(at, cell);
-            }
-            "F" => {
-                let mut format = None;
-                for f in rest {
-                    let (tag, arg) = f.split_at(f.chars().next().map_or(0, char::len_utf8));
-                    match tag {
-                        "Y" => row = position(arg, MAX_ROWS).unwrap_or(row),
-                        "X" => col = position(arg, MAX_COLS).unwrap_or(col),
-                        "P" => format = arg.parse::<usize>().ok(),
-                        "W" => {
-                            let mut parts = arg.split_whitespace();
-                            if let (Some(first), Some(last), Some(width)) = (parts.next(), parts.next(), parts.next())
-                                && let (Some(first), Some(last), Ok(width)) =
-                                    (position(first, MAX_COLS), position(last, MAX_COLS), width.parse::<f64>())
-                                && first <= last
-                                && (0.0..=255.0).contains(&width)
-                                // A file of width records can't make the import loop over every column
-                                // again and again.
-                                && widths.len() < MAX_WIDTH_RECORDS
-                            {
-                                widths.push((first, last, width));
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                if let Some(format) = format {
-                    cell_formats.push((CellRef::new(row, col), format));
-                }
-            }
-            // Number formats only: `P;F…` and `P;E…` are fonts.
-            "P" => {
-                if let Some(code) = rest.first().and_then(|f| f.strip_prefix('P')) {
-                    formats.push(code.to_string());
-                }
-            }
-            "E" => break,
-            _ => {}
-        }
-    }
-    for (first, last, width) in widths {
-        let size = crate::cmd::format::chars_to_points(width) as f32;
-        for c in first..=last {
-            sheet.cols.entry(c).or_default().size = Some(size);
-        }
-    }
-    let mut wb = Workbook::new();
-    let mut styles = HashMap::new();
-    for (at, index) in cell_formats {
-        let Some(code) = formats.get(index).filter(|code| !code.is_empty() && *code != "General") else { continue };
-        let style = *styles.entry(index).or_insert_with(|| wb.styles.intern(Style { num_fmt: NumFmt(Arc::from(code.as_str())), ..Style::default() }));
-        let mut cell = sheet.cell(at).cloned().unwrap_or_else(|| Cell::value(Value::Empty));
-        cell.style = style;
-        sheet.set_cell(at, cell);
-    }
-    if let Some(first) = wb.sheet_mut(0) {
-        sheet.name = std::mem::take(&mut first.name);
-        *first = sheet;
-    }
-    let mut warnings = Vec::new();
-    if skipped > 0 {
-        warnings.push(format!("{name}: {skipped} SYLK records GridCraft couldn't read were skipped"));
-    }
-    Ok((wb, warnings))
-}
-
-/// A record's fields: `;` separates them and `;;` is a literal semicolon.
-fn split_fields(line: &str) -> Vec<String> {
-    let mut fields = vec![String::new()];
-    let mut chars = line.trim_end_matches('\r').chars().peekable();
-    while let Some(c) = chars.next() {
-        if c == ';' {
-            if chars.peek() == Some(&';') {
-                chars.next();
-                if let Some(f) = fields.last_mut() {
-                    f.push(';');
-                }
-            } else {
-                fields.push(String::new());
-            }
-        } else if let Some(f) = fields.last_mut() {
-            f.push(c);
-        }
-    }
-    fields
-}
-
-/// A 1-based row or column number → 0-based, within `max`.
-fn position(arg: &str, max: u32) -> Option<u32> {
-    arg.trim().parse::<u32>().ok().filter(|n| (1..=max).contains(n)).map(|n| n - 1)
-}
-
-/// A `K` value: `"text"` (everything between the first and the last quote, as written), a
-/// boolean, an error or a number.
-fn parse_value(arg: &str) -> Value {
-    if let Some(text) = arg.strip_prefix('"') {
-        let text = text.strip_suffix('"').unwrap_or(text);
-        return Value::Text(Arc::from(text));
-    }
-    if arg.eq_ignore_ascii_case("TRUE") || arg.eq_ignore_ascii_case("FALSE") {
-        return Value::Bool(arg.eq_ignore_ascii_case("TRUE"));
-    }
-    if let Some(e) = CellError::parse(arg) {
-        return Value::Error(e);
-    }
-    match arg.trim().parse::<f64>() {
-        Ok(n) if n.is_finite() => Value::Number(n),
-        _ => Value::Text(Arc::from(arg)),
-    }
-}
-
-/// One part of an R1C1 reference: `R`/`C` followed by an absolute number, a bracketed offset or
-/// nothing (the cell's own row or column).
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum Part {
-    Absolute(u32),
-    Relative(i64),
-}
-
-impl Part {
-    /// The 0-based index and whether it is absolute, or `None` when it falls off the sheet.
-    fn resolve(self, base: u32, max: u32) -> Option<(u32, bool)> {
-        match self {
-            Part::Absolute(n) => (1..=max).contains(&n).then(|| (n - 1, true)),
-            Part::Relative(k) => i64::from(base).checked_add(k).and_then(|v| u32::try_from(v).ok()).filter(|v| *v < max).map(|v| (v, false)),
-        }
-    }
-}
-
-/// Parses the number after `R` or `C` at `i`: digits, `[offset]` or nothing. Returns the part and
-/// the index after it, or `None` when the text isn't a reference part.
-fn parse_part(chars: &[char], i: usize) -> Option<(Part, usize)> {
-    match chars.get(i) {
-        Some('[') => {
-            let close = chars[i..].iter().position(|&c| c == ']')? + i;
-            let inner: String = chars[i + 1..close].iter().collect();
-            Some((Part::Relative(inner.parse().ok()?), close + 1))
-        }
-        Some(c) if c.is_ascii_digit() => {
-            let end = chars[i..].iter().position(|c| !c.is_ascii_digit()).map_or(chars.len(), |p| p + i);
-            let n: String = chars[i..end].iter().collect();
-            Some((Part::Absolute(n.parse().unwrap_or(u32::MAX)), end))
-        }
-        _ => Some((Part::Relative(0), i)),
-    }
-}
-
-fn is_word_char(c: char) -> bool {
-    c.is_alphanumeric() || matches!(c, '_' | '.' | '\\' | '?' | '$')
-}
-
-/// Rewrites the R1C1 references in a SYLK formula as A1 references for the cell at `at`:
-/// `RC[-1]` → `B2`, `R1C1` → `$A$1`, `R[-2]C:R[-1]C` → `D2:D3`, a whole column `C4` → `$D:$D` and
-/// a whole row `R3` → `$3:$3`. Text in quotes and quoted sheet names are left alone; a reference
-/// off the sheet becomes `#REF!`.
-pub(crate) fn r1c1_formula_to_a1(formula: &str, at: CellRef) -> String {
-    let chars: Vec<char> = formula.chars().collect();
-    let mut out = String::with_capacity(formula.len());
-    let mut i = 0;
-    while i < chars.len() {
-        let c = chars[i];
-        if c == '"' || c == '\'' {
-            // Copy the quoted run as it is; a doubled quote stays inside it.
-            let mut j = i + 1;
-            while j < chars.len() && !(chars[j] == c && chars.get(j + 1) != Some(&c)) {
-                j += if chars[j] == c { 2 } else { 1 };
-            }
-            let stop = (j + 1).min(chars.len());
-            out.extend(&chars[i..stop]);
-            i = stop;
-            continue;
-        }
-        let starts_word = i == 0 || !is_word_char(chars[i - 1]);
-        if starts_word
-            && matches!(c, 'R' | 'r' | 'C' | 'c')
-            && let Some((text, next)) = reference_at(&chars, i, at)
-        {
-            out.push_str(&text);
-            i = next;
-            continue;
-        }
-        // Copy the rest of a word as it is, so `ROUND` or `Sheet2` isn't read as a reference.
-        if is_word_char(c) {
-            let end = (i..chars.len()).find(|&j| !is_word_char(chars[j])).unwrap_or(chars.len());
-            out.extend(&chars[i..end]);
-            i = end;
-        } else {
-            out.push(c);
-            i += 1;
-        }
-    }
-    out
-}
-
-/// The A1 text of the R1C1 reference starting at `i`, and the index after it, or `None` when the
-/// word there isn't a reference (a function or a name).
-fn reference_at(chars: &[char], i: usize, at: CellRef) -> Option<(String, usize)> {
-    let mut j = i;
-    let mut row = None;
-    let mut col = None;
-    if matches!(chars.get(j), Some('R' | 'r')) {
-        let (part, next) = parse_part(chars, j + 1)?;
-        row = Some(part);
-        j = next;
-    }
-    if matches!(chars.get(j), Some('C' | 'c')) {
-        let (part, next) = parse_part(chars, j + 1)?;
-        col = Some(part);
-        j = next;
-    }
-    if row.is_none() && col.is_none() {
-        return None;
-    }
-    // A reference ends the word: `ROUND(`, `RATE` or `R2D2` are names.
-    if chars.get(j).is_some_and(|&c| is_word_char(c) || c == '(' || c == '[' || c == '!') {
-        return None;
-    }
-    let row_text = |p: Part| p.resolve(at.row, MAX_ROWS).map(|(r, abs)| format!("{}{}", if abs { "$" } else { "" }, r + 1));
-    let col_text = |p: Part| p.resolve(at.col, MAX_COLS).map(|(c, abs)| format!("{}{}", if abs { "$" } else { "" }, col_to_letters(c)));
-    // One side of a range (`R2:R4`, `C1:C3`) is written alone; a lone row or column is the whole of it.
-    let prev = chars[..i].iter().rev().find(|c| !c.is_whitespace());
-    let in_range = prev == Some(&':') || chars[j..].iter().find(|c| !c.is_whitespace()) == Some(&':');
-    let text = match (row, col) {
-        (Some(r), Some(c)) => row_text(r).zip(col_text(c)).map(|(r, c)| format!("{c}{r}")),
-        (Some(r), None) => row_text(r).map(|r| if in_range { r } else { format!("{r}:{r}") }),
-        (None, Some(c)) => col_text(c).map(|c| if in_range { c } else { format!("{c}:{c}") }),
-        (None, None) => None,
-    };
-    Some((text.unwrap_or_else(|| "#REF!".into()), j))
-}

crates/engine/src/io/tests.rs

@@ -604,160 +604,3 @@ fn opening_google_sheets_export_unwraps_only_formulas_gridcraft_calculates() {
     assert_eq!(text("A2").as_deref(), Some("IFERROR(__XLUDF.DUMMYFUNCTION(\"GOOGLETRANSLATE(\"\"hi\"\",\"\"en\"\",\"\"fr\"\")\"),\"salut\")"));
     assert_eq!(opened.sheets[0].cells.get(CellRef::parse("A2").unwrap()).map(|c| c.value.clone()), Some(Value::text("salut")));
 }
-
-#[test]
-fn a_web_page_saved_as_xls_opens_its_table() {
-    // #3166: a web app's "Export to Excel" is an HTML table saved as .xls; it opened as lines of
-    // markup. Excel opens the table: values read as typed, <th> bold and centred, <x:Name> names
-    // the sheet.
-    let page = "\u{feff}<html xmlns:x=\"urn:schemas-microsoft-com:office:excel\"><head><meta charset=\"UTF-8\">\
-        <!--[if gte mso 9]><xml><x:ExcelWorksheets><x:ExcelWorksheet><x:Name>Orders</x:Name></x:ExcelWorksheet></x:ExcelWorksheets></xml><![endif]-->\
-        </head><body><table><thead><tr><th>Item</th><th>Qty</th><th>Code</th></tr></thead><tbody>\
-        <tr><td>Kiwi &amp;\n Lime</td><td>12</td><td>007</td></tr><tr><td>Plum</td><td x:num=\"4.5\">4,50</td><td>042</td></tr>\
-        </tbody></table></body></html>";
-    let (wb, warnings) = open_bytes("orders.xls", page.as_bytes()).unwrap();
-    assert!(warnings.first().is_some_and(|w| w.contains("is a web page (HTML)")), "{warnings:?}");
-    let sh = wb.sheet(0).unwrap();
-    assert_eq!(sh.name, "Orders");
-    let v = |a: &str| sh.value(CellRef::parse(a).unwrap());
-    assert_eq!(v("A1"), gridcraft_core::Value::text("Item"));
-    assert_eq!(v("A2"), gridcraft_core::Value::text("Kiwi & Lime"));
-    assert_eq!(v("B2"), gridcraft_core::Value::number(12.0));
-    assert_eq!(v("C2"), gridcraft_core::Value::number(7.0), "read like typed input, as Excel does");
-    assert_eq!(v("B3"), gridcraft_core::Value::number(4.5), "the number the page recorded");
-    let style = |a: &str| wb.styles.get(sh.style_id(CellRef::parse(a).unwrap())).clone();
-    assert!(style("A1").font.bold && style("A1").align.h == gridcraft_model::HAlign::Center);
-    assert!(!style("A2").font.bold);
-    // Opened as text, codes keep their zeros; a page named .html gets no warning.
-    let (wb, warnings) = open_bytes_with("orders.html", page.as_bytes(), None, true).unwrap();
-    assert!(warnings.is_empty(), "{warnings:?}");
-    assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("C2").unwrap()), gridcraft_core::Value::text("007"));
-    // Plain text that merely starts with a tag-like word is still read as CSV.
-    let (wb, _) = open_bytes("notes.csv", b"<b>,1\nx,2\n").unwrap();
-    assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::number(2.0));
-}
-
-#[test]
-fn a_web_page_table_keeps_its_characters_text_and_header_formats() {
-    // A page saved in Windows-1252 keeps its accented letters (it read as replacement characters).
-    let mut page = b"<html><body><table><tr><th>Caf".to_vec();
-    page.push(0xE9);
-    page.extend_from_slice(b"</th><th>2024-01-15</th></tr><tr><td>Plum</td><td x:num=\"4.5\">4,50</td></tr></table></body></html>");
-    let (wb, _) = open_bytes("menu.xls", &page).unwrap();
-    let sh = wb.sheet(0).unwrap();
-    assert_eq!(sh.value(CellRef::parse("A1").unwrap()), gridcraft_core::Value::text("Café"));
-    // A date in a header cell stays a date, bold and centred (its format was replaced).
-    let b1 = wb.styles.get(sh.style_id(CellRef::parse("B1").unwrap()));
-    assert!(matches!(sh.value(CellRef::parse("B1").unwrap()), gridcraft_core::Value::Number(_)));
-    assert!(b1.font.bold && b1.align.h == gridcraft_model::HAlign::Center);
-    assert_ne!(b1.num_fmt.as_str(), "General", "the date keeps its date format");
-    assert_eq!(sh.value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::number(4.5));
-    // Opened as text, a cell keeps the text it shows, not the number the page recorded for it.
-    let (wb, _) = open_bytes_with("menu.xls", &page, None, true).unwrap();
-    assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::text("4,50"));
-}
-
-#[test]
-fn a_web_page_table_opens_after_a_leading_comment_and_keeps_nonbreaking_spaces() {
-    // An exporter's comment before <html> still makes a web page; `&nbsp;` stays a non-breaking
-    // space, as Excel keeps it, while ordinary whitespace collapses.
-    let page = "<!-- exported by a web app -->\n<html><body><table><tr><td>New&nbsp;&nbsp;York</td><td>a \n b</td></tr></table></body></html>";
-    let (wb, warnings) = open_bytes("cities.xls", page.as_bytes()).unwrap();
-    assert!(warnings.first().is_some_and(|w| w.contains("is a web page (HTML)")), "{warnings:?}");
-    let sh = wb.sheet(0).unwrap();
-    assert_eq!(sh.value(CellRef::parse("A1").unwrap()), gridcraft_core::Value::text("New\u{a0}\u{a0}York"));
-    assert_eq!(sh.value(CellRef::parse("B1").unwrap()), gridcraft_core::Value::text("a b"));
-}
-
-/// A small SYLK file written the way spreadsheets export one: a header, number formats, column
-/// widths, cells that carry on from the last row or column, formulas in R1C1 and a shared formula.
-const SYLK: &str = "ID;PTEST;N;E\r\nP;PGeneral\r\nP;P0.00\r\nP;Pyyyy\\-mm\\-dd\r\nF;W1 1 18\r\nF;W2 3 9\r\nB;Y5;X7\r\n\
-C;Y1;X1;K\"Item\"\r\nC;X2;K\"Qty\"\r\nC;X4;K\"Total\"\r\n\
-C;Y2;X1;K\"Bolts;; small\"\r\nC;X2;K12\r\nF;P1;F$2G;X3\r\nC;X3;K0.35\r\nC;X4;K4.2;ERC[-2]*RC[-1]\r\n\
-C;X5;K52;ER2C2+R[1]C[-3]\r\nC;X6;KTRUE\r\nC;X7;K8.4;ERC[-3]*2\r\n\
-C;Y3;X1;K\"Nuts \"\"hex\"\"\"\r\nC;X2;K40\r\nC;X3;K0.12\r\nC;X4;K4.8;ERC[-2]*RC[-1]\r\nC;X5;K\"big\";EIF(R4C4>5,\"big\",\"small\")\r\nC;X7;K9.6;S;R2;C7\r\n\
-C;Y4;X1;K\"Sum\"\r\nC;X4;K9;ESUM(R[-2]C:R[-1]C)\r\nC;X5;K#DIV/0!;E1/0\r\nC;X7;K18;ESUM(C4)\r\n\
-F;P2;FG0G;Y5;X2\r\nC;Y5;X2;K45000\r\nC;X3;K\"R2C3\";E\"R2C3\"\r\nE\r\n";
-
-#[test]
-fn sylk_files_open_with_values_formulas_formats_and_widths() {
-    let (wb, warnings) = open_bytes("Parts list.slk", SYLK.as_bytes()).unwrap();
-    assert!(warnings.is_empty(), "{warnings:?}");
-    let sh = wb.sheet(0).unwrap();
-    assert_eq!(sh.name, "Parts list", "the sheet is named after the file");
-    let at = |a: &str| CellRef::parse(a).unwrap();
-    let formula = |a: &str| sh.cell(at(a)).and_then(|c| c.formula.as_ref()).map(|f| f.text.clone());
-    let text = |s: &str| gridcraft_core::Value::Text(s.into());
-    assert_eq!(sh.value(at("A1")), text("Item"));
-    assert_eq!(sh.value(at("A2")), text("Bolts; small"), ";; is a semicolon");
-    assert_eq!(sh.value(at("A3")), text("Nuts \"\"hex\"\""), "text is kept between the outer quotes as written");
-    assert_eq!(sh.value(at("B2")), gridcraft_core::Value::Number(12.0));
-    assert_eq!(sh.value(at("F2")), gridcraft_core::Value::Bool(true));
-    assert_eq!(sh.value(at("E4")), gridcraft_core::Value::Error(gridcraft_core::CellError::Div0));
-    assert_eq!(sh.value(at("D4")), gridcraft_core::Value::Number(9.0), "a formula keeps the value the file cached");
-    assert_eq!(formula("D2").as_deref(), Some("B2*C2"));
-    assert_eq!(formula("E2").as_deref(), Some("$B$2+B3"));
-    assert_eq!(formula("E3").as_deref(), Some("IF($D$4>5,\"big\",\"small\")"));
-    assert_eq!(formula("D4").as_deref(), Some("SUM(D2:D3)"));
-    assert_eq!(formula("G3").as_deref(), Some("D3*2"), "a shared formula is the other cell's, moved");
-    assert_eq!(formula("G4").as_deref(), Some("SUM($D:$D)"), "C4 alone is the whole column");
-    assert_eq!(formula("C5").as_deref(), Some("\"R2C3\""), "text in quotes isn't a reference");
-    // `F;P1;X3` formats the cell on the current row only.
-    let fmt = |a: &str| wb.styles.get(sh.style_id(at(a))).num_fmt.0.to_string();
-    assert_eq!(fmt("C2"), "0.00");
-    assert_eq!(fmt("C3"), "General");
-    assert_eq!(fmt("B5"), "yyyy\\-mm\\-dd");
-    // Widths are in characters, like the Column Width dialog's.
-    let chars = |c: u32| gridcraft_model::points_to_chars(f64::from(sh.col_width(c)));
-    assert_eq!((chars(0), chars(1), chars(2)), (18.0, 9.0, 9.0));
-    assert_eq!(sh.cols.get(&3).and_then(|i| i.size), None, "column D keeps the default width");
-}
-
-#[test]
-fn sylk_r1c1_formulas_become_a1() {
-    let b2 = CellRef::parse("B2").unwrap();
-    for (r1c1, a1) in [
-        ("RC", "B2"),
-        ("R[1]C[-1]", "A3"),
-        ("R1C1:R2C2", "$A$1:$B$2"),
-        ("R3", "$3:$3"),
-        ("R1:R[2]", "$1:4"),
-        ("C[1]", "C:C"),
-        ("SUM(C3:C4)", "SUM($C:$D)"),
-        ("ROUND(RC[1],2)+RATE(1,2,3)", "ROUND(C2,2)+RATE(1,2,3)"),
-        ("'R1C1 sheet'!R1C1", "'R1C1 sheet'!$A$1"),
-        ("Sheet2!RC", "Sheet2!B2"),
-        ("R2D2+rc", "R2D2+B2"),
-        ("R[-5]C", "#REF!"),
-        ("\"RC\"&R1C1", "\"RC\"&$A$1"),
-    ] {
-        assert_eq!(sylk::r1c1_formula_to_a1(r1c1, b2), a1, "{r1c1}");
-    }
-}
-
-#[test]
-fn sylk_rejects_other_files_and_survives_damage() {
-    assert!(open_bytes("not.slk", b"A,B\n1,2\n").is_err(), "a SYLK file starts with ID");
-    // Positions off the sheet, broken numbers, a missing end and a format past the list.
-    let (wb, warnings) =
-        open_bytes("damaged.slk", b"ID;P\nC;Y0;X1;K1\nC;Y2;X99999;K2\nC;Y3;X1;K1e999\nF;P7;Y3;X1\nF;W5 2 9\nC;Y4;X1;K5;E(((\n").unwrap();
-    let sh = wb.sheet(0).unwrap();
-    assert_eq!(sh.cells.iter().count(), 2, "{:?}", sh.cells.iter().collect::<Vec<_>>());
-    assert_eq!(sh.value(CellRef::parse("A3").unwrap()), gridcraft_core::Value::Text("1e999".into()));
-    assert_eq!(warnings.len(), 1, "skipped records are reported: {warnings:?}");
-}
-
-#[test]
-fn sylk_survives_huge_relative_offsets_and_width_floods() {
-    // Relative offsets at the edge of i64 fall off the sheet instead of overflowing.
-    let text = b"ID;P\nC;Y1;X1;K0;ER[9223372036854775807]C\nC;Y2;X1;K0;ER[-9223372036854775808]C[-9223372036854775808]\nE\n";
-    assert!(open_bytes("offsets.slk", text).is_ok());
-    // Width records over every column, many times over: the import keeps a bounded number.
-    let mut flood = b"ID;P\n".to_vec();
-    for _ in 0..5000 {
-        flood.extend_from_slice(b"F;W1 16384 12\n");
-    }
-    flood.extend_from_slice(b"C;Y1;X1;K1\nE\n");
-    let (wb, _) = open_bytes("widths.slk", &flood).unwrap();
-    assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("A1").unwrap()), gridcraft_core::Value::Number(1.0));
-}

crates/engine/src/pivot/compute.rs

@@ -77,8 +77,6 @@ struct AggregateInput<'a> {
     extra: &'a [usize],
     filters: &'a [(usize, &'a PivotFilter, PivotDateGroup, bool)],
     filter_fmts: &'a [String],
-    /// Each filter's selected labels, ASCII-lowercased, so a record's test is one probe.
-    filter_sets: &'a [Option<HashSet<String>>],
     row_fmts: &'a [String],
     col_fmts: &'a [String],
     empty: bool,
@@ -101,10 +99,10 @@ fn aggregate_record(
     ri: usize,
     rec: &[Value],
 ) -> Result<(), String> {
-    for (((c, _, group, _), fmt), selected) in input.filters.iter().zip(input.filter_fmts).zip(input.filter_sets) {
-        if let Some(selected) = selected {
+    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.contains(&label.to_ascii_lowercase()) {
+            if !selected.iter().any(|value| value.eq_ignore_ascii_case(&label)) {
                 return Ok(());
             }
         }
@@ -357,19 +355,15 @@ fn ranked_value(raw: Value, lookup: &ValueLookup<'_>, context: &ShowContext<'_>)
     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();
-    // Excel's ranks are dense: ties share a rank and the next value takes the next one
-    // (5, 4, 3, 3, 4 rank 1, 2, 3, 3, 2), so count the distinct larger values.
-    let mut larger: Vec<f64> = siblings
-        .into_iter()
-        .filter_map(|sibling| {
-            let mut path = parent.to_vec();
-            path.push(sibling);
-            number(&lookup.get(&path, context.col_path, context.value_index)).filter(|value| *value > me)
-        })
-        .collect();
-    larger.sort_by(f64::total_cmp);
-    larger.dedup();
-    Value::number(larger.len() as f64 + 1.0)
+    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 {
@@ -477,8 +471,6 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
 
     // ---- aggregate
     let filter_fmts: Vec<String> = filters.iter().map(|f| fmt_of(f.0)).collect();
-    let filter_sets: Vec<Option<HashSet<String>>> =
-        filters.iter().map(|(_, field, _, _)| field.selected.as_ref().map(|s| s.iter().map(|v| v.to_ascii_lowercase()).collect())).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();
     let aggregate = aggregate_source(
@@ -492,7 +484,6 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro
             extra: &extra,
             filters: &filters,
             filter_fmts: &filter_fmts,
-            filter_sets: &filter_sets,
             row_fmts: &row_fmts,
             col_fmts: &col_fmts,
             empty,

crates/engine/src/pivot/items.rs

@@ -197,8 +197,7 @@ impl Acc {
     }
 }
 
-/// Excel's caption verb for a function ("Sum of Sales"). Count Numbers is captioned "Count of
-/// Sales", as Excel names it and as the XLSX reader names a value field saved without a name.
+/// Excel's caption verb for a function ("Sum of Sales").
 pub fn func_caption(f: PivotFunc) -> &'static str {
     match f {
         PivotFunc::Sum => "Sum",
@@ -207,7 +206,7 @@ pub fn func_caption(f: PivotFunc) -> &'static str {
         PivotFunc::Max => "Max",
         PivotFunc::Min => "Min",
         PivotFunc::Product => "Product",
-        PivotFunc::CountNumbers => "Count",
+        PivotFunc::CountNumbers => "Count Numbers",
         PivotFunc::StdDev => "StdDev",
         PivotFunc::StdDevP => "StdDevp",
         PivotFunc::Var => "Var",

crates/engine/src/selection.rs

@@ -128,32 +128,6 @@ impl Selection {
     }
 }
 
-impl Selection {
-    /// Ctrl+. (Next Corner of Selection): the active cell moves clockwise to the next corner of
-    /// the current area (top-left, top-right, bottom-right, bottom-left) and becomes the anchor,
-    /// so Shift+arrows then move the opposite corner. The area stays selected. From a cell that
-    /// isn't a corner the next corner is the top-left one; a single cell stays where it is.
-    pub fn next_corner(&mut self) {
-        self.next_corner_by(Some);
-    }
-
-    /// [`Selection::next_corner`] where `stop` says where each corner takes the active cell: the
-    /// top-left cell of a merged cell the corner is in, or `None` for a corner that can't be
-    /// selected (it is skipped). Corners that end up on the active cell are one stop with it.
-    pub fn next_corner_by(&mut self, stop: impl Fn(CellRef) -> Option<CellRef>) {
-        let r = self.current();
-        let corners = [r.start, CellRef::new(r.start.row, r.end.col), r.end, CellRef::new(r.end.row, r.start.col)];
-        let next = match corners.iter().rposition(|c| stop(*c) == Some(self.active)) {
-            Some(i) => (1..=4).filter_map(|k| corners.get((i + k) % 4)).filter_map(|c| stop(*c)).find(|c| *c != self.active),
-            None => corners.iter().find_map(|c| stop(*c)),
-        };
-        if let Some(next) = next {
-            self.active = next;
-            self.anchor = next;
-        }
-    }
-}
-
 /// Ctrl+arrow: jump to the edge of the current data region (Excel's End mode).
 pub fn jump(sheet: &Sheet, from: CellRef, dr: i64, dc: i64) -> CellRef {
     if dr == 0 && dc == 0 {

crates/engine/src/tests.rs

@@ -2743,78 +2743,6 @@ fn validation_formulas_are_relative_and_see_the_new_value() {
     assert!(!ok(&mut s, "C1", "50"));
 }
 
-#[test]
-fn multi_area_rule_formulas_are_relative_to_the_top_left_cell_of_all_areas() {
-    // Issue #3152: Excel writes the formula for the top-left cell of all the areas (H26), whatever
-    // order they are listed in, not for the first area listed (H62).
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "F26:F27", "values": [[4], [5]]})).unwrap();
-    s.execute("data.validation", json!({"range": "H62:H68,H26:H27,H93:H95", "type": "custom", "formula1": "=MOD($H26,$F26)=0"})).unwrap();
-    let ok = |s: &mut Session, cell: &str, input: &str| s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == true;
-    assert!(ok(&mut s, "H26", "4"));
-    assert!(ok(&mut s, "H26", "8"));
-    assert!(!ok(&mut s, "H26", "3"));
-    assert!(ok(&mut s, "H27", "10"));
-    assert!(!ok(&mut s, "H27", "4"));
-
-    // Conditional formats anchor on the same cell: `=D2>0` on D5:D6,D2:D3 checks D2 at D2.
-    s.execute("range.setValues", json!({"range": "D2:D6", "values": [[1], [0], [0], [1], [0]]})).unwrap();
-    s.execute("home.conditionalFormat", json!({"range": "D5:D6,D2:D3", "rule": {"type": "expression", "formula": "=D2>0", "preset": "greenFill"}}))
-        .unwrap();
-    let wb = s.doc().unwrap().wb.clone();
-    let mut cache = crate::cf::CfCache::new();
-    let mut styled = |c: &str| cache.look(&wb, 0, CellRef::parse(c).unwrap()).and_then(|l| l.style).is_some();
-    assert_eq!([styled("D2"), styled("D3"), styled("D5"), styled("D6")], [true, false, true, false]);
-}
-
-#[test]
-fn removing_a_rules_top_left_cell_rewrites_its_formulas_for_the_new_one() {
-    let mut s = s();
-    let ok = |s: &mut Session, cell: &str, input: &str| s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == true;
-    let f1 = |s: &Session| s.doc().unwrap().wb.active().unwrap().validations[0].f1.clone();
-
-    // One area: clearing A1 off A1:A9 leaves A2:A9, whose cells still check themselves.
-    s.execute("data.validation", json!({"range": "A1:A9", "type": "custom", "formula1": "=A1>10"})).unwrap();
-    s.execute("data.validation", json!({"range": "A1", "clear": true})).unwrap();
-    assert_eq!(f1(&s), "A2>10");
-    assert!(ok(&mut s, "A2", "20"));
-    assert!(!ok(&mut s, "A2", "5"));
-    s.execute("data.validation", json!({"range": "A1:A9", "clear": true})).unwrap();
-
-    // Several areas: clearing H26 moves the top-left cell to H27, where `$H27,$F27` is checked.
-    s.execute("range.setValues", json!({"range": "F26:F27", "values": [[4], [5]]})).unwrap();
-    s.execute("data.validation", json!({"range": "H62:H68,H26:H27", "type": "custom", "formula1": "=MOD($H26,$F26)=0"})).unwrap();
-    s.execute("data.validation", json!({"range": "H26", "clear": true})).unwrap();
-    assert_eq!(f1(&s), "MOD($H27,$F27)=0");
-    assert!(ok(&mut s, "H27", "10"));
-    assert!(!ok(&mut s, "H27", "4"));
-    // Absolute and literal formulas don't move.
-    s.execute("data.validation", json!({"range": "J1:J3", "type": "list", "formula1": "=$B$1:$B$2"})).unwrap();
-    s.execute("data.validation", json!({"range": "J1", "clear": true})).unwrap();
-    let dv = s.doc().unwrap().wb.active().unwrap().validations.iter().find(|d| d.ranges[0].a1() == "J2:J3").unwrap().f1.clone();
-    assert_eq!(dv, "$B$1:$B$2");
-
-    // Conditional formats: Clear Rules on D2 drops the D2:D3 area, and D5:D6 keeps reading itself.
-    s.execute("range.setValues", json!({"range": "D2:D6", "values": [[1], [0], [0], [0], [1]]})).unwrap();
-    s.execute("home.conditionalFormat", json!({"range": "D5:D6,D2:D3", "rule": {"type": "expression", "formula": "=D2>0", "preset": "greenFill"}}))
-        .unwrap();
-    s.execute("range.setValues", json!({"range": "E2:E6", "values": [[1], [0], [0], [0], [1]]})).unwrap();
-    s.execute("range.setValues", json!({"range": "G2:G6", "values": [[0], [9], [9], [9], [0]]})).unwrap();
-    s.execute(
-        "home.conditionalFormat",
-        json!({"range": "E5:E6,E2:E3", "rule": {"type": "cellIs", "operator": "greater", "value": "=G2", "preset": "lightRedFill"}}),
-    )
-    .unwrap();
-    s.execute("home.clearRules", json!({"range": "D2,E2"})).unwrap();
-    let rules: Vec<gridcraft_model::CfRule> = s.doc().unwrap().wb.active().unwrap().cond_formats.iter().map(|c| c.rule.clone()).collect();
-    assert!(rules.iter().any(|r| matches!(r, gridcraft_model::CfRule::Expression { formula, .. } if formula == "D5>0")), "{rules:?}");
-    assert!(rules.iter().any(|r| matches!(r, gridcraft_model::CfRule::CellIs { a, .. } if a == "G5")), "{rules:?}");
-    let wb = s.doc().unwrap().wb.clone();
-    let mut cache = crate::cf::CfCache::new();
-    let mut styled = |c: &str| cache.look(&wb, 0, CellRef::parse(c).unwrap()).and_then(|l| l.style).is_some();
-    assert_eq!([styled("D5"), styled("D6"), styled("E5"), styled("E6")], [false, true, false, true]);
-}
-
 #[test]
 fn samples_build() {
     for (name, _) in crate::sample::SAMPLES {
@@ -3975,24 +3903,6 @@ fn fill_series_weekday_out_of_range_step_errors() {
     assert_eq!(v(&s, "A2"), Value::Empty);
 }
 
-/// A step of a million weekdays moves whole weeks at a time instead of visiting every day, and
-/// lands where counting day by day would.
-#[test]
-fn fill_series_weekday_large_step_is_arithmetic() {
-    let mut s = s();
-    // 45005 is Monday 20 March 2023; five weekdays on from a Monday is the next Monday.
-    s.execute("cell.set", json!({"cell": "A1", "input": "45005"})).unwrap();
-    s.execute("edit.fillSeries", json!({"range": "A1:A3", "direction": "columns", "type": "date", "dateUnit": "weekday", "step": 1_000_000}))
-        .unwrap();
-    assert_eq!(v(&s, "A2"), Value::Number(45005.0 + 1_400_000.0));
-    assert_eq!(v(&s, "A3"), Value::Number(45005.0 + 2_800_000.0));
-    s.execute("cell.set", json!({"cell": "B1", "input": "45009"})).unwrap();
-    s.execute("edit.fillSeries", json!({"range": "B1:B3", "direction": "columns", "type": "date", "dateUnit": "weekday", "step": -1})).unwrap();
-    // Friday 24 March 2023 back one weekday at a time: Thursday, Wednesday.
-    assert_eq!(v(&s, "B2"), Value::Number(45008.0));
-    assert_eq!(v(&s, "B3"), Value::Number(45007.0));
-}
-
 #[test]
 fn fill_series_month_leap_year() {
     let s = series_date("2028-01-31", "A1:A3", "month");
@@ -5315,42 +5225,6 @@ fn move_columns_checks_the_protection_of_the_named_sheet() {
     assert_eq!(v(&s, "A1"), Value::text("A"));
 }
 
-#[test]
-fn move_columns_checks_the_protection_of_a_sheet_named_by_its_range() {
-    // A `Sheet!` range or cell picks the sheet the move modifies; the protection checks must
-    // authorize that sheet too, not the active one.
-    let mut s = s();
-    s.execute("home.insertSheet", json!({"name": "P"})).unwrap();
-    s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2, 3, 4]]})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-    for key in ["range", "cell"] {
-        let err = s.execute("sheet.moveColumns", json!({key: "P!A1", "cols": "B:C", "before": 4})).expect_err("moving columns on a protected sheet");
-        assert!(err.to_string().contains("protected"), "{err}");
-    }
-    let d = s.doc().unwrap();
-    let sh = &d.wb.sheets[d.wb.sheet_index("P").unwrap()];
-    let pv: Vec<Value> = (0..4).map(|c| sh.value(CellRef::new(0, c))).collect();
-    assert_eq!(pv, vec![Value::number(1.0), Value::number(2.0), Value::number(3.0), Value::number(4.0)]);
-}
-
-#[test]
-fn sorting_cannot_unlock_a_locked_cell_by_moving_equal_content_onto_it() {
-    // An unlocked 2 sorted onto a locked 2 leaves the content as it was, but would make the cell
-    // editable; the sort is refused instead.
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "A1", "values": [[2], [2], [1]]})).unwrap();
-    s.execute("home.lockCell", json!({"range": "A1", "on": false})).unwrap();
-    s.execute("home.lockCell", json!({"range": "A3", "on": false})).unwrap();
-    s.execute("review.protectSheet", json!({"sort": true})).unwrap();
-    let before = s.doc().unwrap().wb.clone();
-    let err =
-        s.execute("data.sort", json!({"range": "A1:A3", "header": false, "keys": [{"column": "A", "order": "asc"}]})).expect_err("sort unlocking A2");
-    assert!(err.to_string().contains("protected sheet"), "{err}");
-    assert_eq!(*s.doc().unwrap().wb, *before);
-    assert!(s.execute("cell.set", json!({"cell": "A2", "input": "9"})).is_err(), "A2 stays locked");
-}
-
 #[test]
 fn a_script_cannot_switch_windows() {
     // Stored scripts are scoped to their workbook: a step that activates another window would
@@ -5475,177 +5349,3 @@ fn a_view_kept_through_redo_doesnt_make_the_saved_workbook_dirty() {
     assert_eq!(d.wb.active().unwrap().view, gridcraft_model::SheetViewMode::PageBreakPreview);
     assert!(!d.is_dirty(), "back at the saved edits, the view alone isn't a change");
 }
-
-#[test]
-fn workbook_display_options_are_commands() {
-    // #3101: Show sheet tabs / horizontal / vertical scroll bar, toggling without `on`, saved with
-    // the workbook and undoable.
-    let mut s = Session::new();
-    s.new_workbook();
-    let view = |s: &Session| s.doc().unwrap().wb.view;
-    assert_eq!(s.execute("view.showSheetTabs", json!({})).unwrap()["on"], json!(false));
-    assert_eq!(s.execute("view.showHorizontalScrollBar", json!({"on": false})).unwrap()["on"], json!(false));
-    assert_eq!(s.execute("view.showVerticalScrollBar", json!({"on": false})).unwrap()["on"], json!(false));
-    let v = view(&s);
-    assert!(!v.show_sheet_tabs && !v.show_horizontal_scroll && !v.show_vertical_scroll);
-    let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&s.doc().unwrap().wb).unwrap()).unwrap();
-    assert_eq!(back.view, v, "saved with the workbook");
-    s.execute("edit.undo", json!({})).unwrap();
-    assert!(view(&s).show_vertical_scroll);
-    assert_eq!(s.execute("view.showSheetTabs", json!({})).unwrap()["on"], json!(true), "toggles back");
-}
-
-/// A link from a file can sit on a cell with nothing stored in it, past the used range (or on a
-/// sheet with no cells at all). Clear Hyperlinks, and Remove Hyperlink in the cell menu, must
-/// still remove it.
-#[test]
-fn clear_hyperlinks_removes_links_on_cells_with_nothing_stored() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap();
-    let link = || gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true };
-    let (a1, c5) = (CellRef::parse("A1").unwrap(), CellRef::parse("C5").unwrap());
-    std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().hyperlinks.insert(c5, link());
-    s.execute("edit.clearHyperlinks", json!({"range": "C5"})).unwrap();
-    assert!(!s.doc().unwrap().wb.active().unwrap().hyperlinks.contains_key(&c5), "the link past the used range is removed");
-
-    // No cells at all.
-    s.execute("edit.clearAll", json!({"range": "A1"})).unwrap();
-    std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().hyperlinks.insert(a1, link());
-    s.execute("edit.clearHyperlinks", json!({"range": "A1"})).unwrap();
-    assert!(!s.doc().unwrap().wb.active().unwrap().hyperlinks.contains_key(&a1), "the link on an empty sheet is removed");
-}
-
-/// Notes and links aren't cell contents, so the cell comparison that guards a protected sheet
-/// doesn't see them go: Clear Hyperlinks and Clear Comments refuse locked cells themselves,
-/// stored or not.
-#[test]
-fn clearing_links_and_notes_respects_sheet_protection() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap();
-    let link = || gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true };
-    let (a1, c5) = (CellRef::parse("A1").unwrap(), CellRef::parse("C5").unwrap());
-    {
-        let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-        sh.hyperlinks.insert(a1, link());
-        sh.hyperlinks.insert(c5, link());
-    }
-    s.execute("review.newNote", json!({"cell": "C5", "text": "note", "author": "Example"})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    for (cmd, range) in [("edit.clearHyperlinks", "A1"), ("edit.clearHyperlinks", "C5"), ("edit.clearComments", "C5")] {
-        assert!(s.execute(cmd, json!({"range": range})).is_err(), "{cmd} on locked {range}");
-    }
-    let sh = s.doc().unwrap().wb.active().unwrap().clone();
-    assert!(sh.hyperlinks.contains_key(&a1) && sh.hyperlinks.contains_key(&c5) && sh.comments.contains_key(&c5), "nothing removed");
-
-    s.execute("review.unprotectSheet", json!({})).unwrap();
-    s.execute("edit.clearHyperlinks", json!({"range": "A1:C5"})).unwrap();
-    s.execute("edit.clearComments", json!({"range": "C5"})).unwrap();
-    let sh = s.doc().unwrap().wb.active().unwrap().clone();
-    assert!(sh.hyperlinks.is_empty() && sh.comments.is_empty());
-}
-
-/// A removed link or note is a change to its cell even when nothing is stored there, so a
-/// recorded macro's footprint lists it.
-#[test]
-fn clearing_links_and_notes_records_their_cells() {
-    let mut s = s();
-    let c5 = CellRef::parse("C5").unwrap();
-    std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb)
-        .sheet_mut(0)
-        .unwrap()
-        .hyperlinks
-        .insert(c5, gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true });
-    s.execute("review.newNote", json!({"cell": "D7", "text": "note", "author": "Example"})).unwrap();
-    s.doc_mut().unwrap().touched = Some(Vec::new());
-    s.execute("edit.clearHyperlinks", json!({"range": "C5"})).unwrap();
-    s.execute("edit.clearComments", json!({"range": "D7"})).unwrap();
-    let touched: Vec<String> = s.doc().unwrap().touched.clone().unwrap_or_default().into_iter().map(|(_, c)| c.a1()).collect();
-    assert!(touched.contains(&"C5".to_string()) && touched.contains(&"D7".to_string()), "{touched:?}");
-}
-
-/// The locked-cell check for notes and links keeps Allow Edit Ranges: a range without a password
-/// allows them at once, one with a password once it's unlocked in this session.
-#[test]
-fn clearing_links_and_notes_keeps_allow_edit_ranges() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap();
-    let link = || gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true };
-    let (a1, c5) = (CellRef::parse("A1").unwrap(), CellRef::parse("C5").unwrap());
-    {
-        let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-        sh.hyperlinks.insert(a1, link());
-        sh.hyperlinks.insert(c5, link());
-    }
-    s.execute("review.newNote", json!({"cell": "C5", "text": "note", "author": "Example"})).unwrap();
-    // Ranges are added before protecting: a protected sheet refuses `add`.
-    s.execute("review.allowEditRanges", json!({"action": "add", "title": "Open", "range": "A1"})).unwrap();
-    s.execute("review.allowEditRanges", json!({"action": "add", "title": "Kept", "range": "C5", "password": "example"})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-
-    s.execute("edit.clearHyperlinks", json!({"range": "A1"})).unwrap();
-    assert!(s.execute("edit.clearComments", json!({"range": "C5"})).is_err(), "a password range stays locked until unlocked");
-    s.execute("review.allowEditRanges", json!({"action": "unlock", "title": "Kept", "password": "example"})).unwrap();
-    s.execute("edit.clearHyperlinks", json!({"range": "C5"})).unwrap();
-    s.execute("edit.clearComments", json!({"range": "C5"})).unwrap();
-    let sh = s.doc().unwrap().wb.active().unwrap().clone();
-    assert!(sh.hyperlinks.is_empty() && sh.comments.is_empty());
-}
-
-#[test]
-fn protected_sheet_refuses_layout_commands_its_permissions_do_not_allow() {
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "A1", "values": [["h"], [1], [2]]})).unwrap();
-    s.execute("data.filter", json!({"range": "A1:A3"})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    for (id, params) in [
-        ("home.rowHeight", json!({"rows": "1:1", "height": 40})),
-        ("home.columnWidth", json!({"cols": "A:A", "width": 80})),
-        ("data.group", json!({"rows": "2:3"})),
-        ("data.showLevels", json!({"rows": 1})),
-        ("data.clearFilter", json!({})),
-        ("data.reapply", json!({})),
-        ("insert.picture", json!({"base64": "iVBORw0KGgo="})),
-    ] {
-        let err = s.execute(id, params).expect_err(id).to_string();
-        assert!(err.contains("protected"), "{id}: {err}");
-    }
-    // With the permissions ticked the same layout commands run.
-    s.execute("review.unprotectSheet", json!({})).unwrap();
-    s.execute("review.protectSheet", json!({"formatRows": true, "formatColumns": true, "autofilter": true})).unwrap();
-    for (id, params) in [
-        ("home.rowHeight", json!({"rows": "1:1", "height": 40})),
-        ("home.columnWidth", json!({"cols": "A:A", "width": 80})),
-        ("data.reapply", json!({})),
-    ] {
-        s.execute(id, params).unwrap_or_else(|e| panic!("{id}: {e}"));
-    }
-}
-
-#[test]
-fn an_edit_range_limited_to_windows_users_stays_locked() {
-    use gridcraft_model::EditRange;
-    let mut s = s();
-    let a1 = CellRef::parse("A1").unwrap();
-    let range = |sd: Option<&str>| EditRange {
-        title: "T".into(),
-        ranges: vec![gridcraft_core::RangeRef::cell(a1)],
-        password: None,
-        security_descriptor: sd.map(str::to_string),
-    };
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    sh.edit_ranges.push(range(None));
-    assert!(crate::cmd::locked_cell_error(sh, a1, &[]).is_none(), "an open range");
-    sh.edit_ranges = vec![range(Some("D:(A;;GA;;;WD)"))];
-    assert!(crate::cmd::locked_cell_error(sh, a1, &[]).is_some(), "a user-limited range");
-}
-
-#[test]
-fn pivot_new_sheet_destination_respects_workbook_structure_protection() {
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Sales"], ["N", 1], ["S", 2]]})).unwrap();
-    s.execute("review.protectWorkbook", json!({"on": true})).unwrap();
-    for dest in ["new", "NEW", " new ", ""] {
-        assert!(s.execute("insert.pivotTable", json!({"source": "A1:B3", "destination": dest})).is_err(), "destination {dest:?}");
-    }
-    assert!(s.execute("insert.pivotTable", json!({"source": "A1:B3", "location": "New"})).is_err());
-}

crates/formula/src/input.rs

@@ -61,7 +61,7 @@ impl FormulaLocale {
 pub fn parse_input(src: &str, locale: FormulaLocale, known_name: impl Fn(&str) -> bool) -> Result<Expr, ParseError> {
     let mut expr = parser::parse_syntax(src, locale)?;
     if locale == FormulaLocale::Es {
-        normalize(&mut expr, &known_name, &mut Bindings::default(), 0, false)?;
+        normalize(&mut expr, &known_name, &mut Vec::new(), 0, false)?;
     }
     Ok(expr)
 }
@@ -96,7 +96,7 @@ pub fn print_input(expr: &Expr, locale: FormulaLocale, known_name: impl Fn(&str)
         return Ok(crate::print(expr));
     }
     let mut expr = expr.clone();
-    normalize(&mut expr, &known_name, &mut Bindings::default(), 0, true)?;
+    normalize(&mut expr, &known_name, &mut Vec::new(), 0, true)?;
     let canonical = crate::print(&expr);
     let tokens = crate::lexer::tokenize(&canonical).map_err(|e| ParseError { msg: e.msg, pos: e.pos })?;
     let mut out = String::new();
@@ -131,47 +131,11 @@ pub(crate) fn boolean_alias(name: &str) -> Option<bool> {
     }
 }
 
-/// The LET/LAMBDA names in scope, with how many times each is bound, so a lookup is one probe
-/// instead of a scan of every binding for each call.
-#[derive(Default)]
-struct Bindings {
-    stack: Vec<String>,
-    counts: std::collections::HashMap<String, usize>,
-}
-
-impl Bindings {
-    fn len(&self) -> usize {
-        self.stack.len()
-    }
-
-    fn push(&mut self, name: &str) {
-        let key = crate::fold_name(name);
-        *self.counts.entry(key.clone()).or_default() += 1;
-        self.stack.push(key);
-    }
-
-    fn truncate(&mut self, len: usize) {
-        while self.stack.len() > len {
-            let Some(key) = self.stack.pop() else { break };
-            if let Some(n) = self.counts.get_mut(&key) {
-                *n -= 1;
-                if *n == 0 {
-                    self.counts.remove(&key);
-                }
-            }
-        }
-    }
-
-    fn contains(&self, name: &str) -> bool {
-        self.counts.contains_key(&crate::fold_name(name))
-    }
-}
-
-fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut Bindings, depth: usize, display: bool) -> Result<(), ParseError> {
+fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut Vec<String>, depth: usize, display: bool) -> Result<(), ParseError> {
     if depth > parser::MAX_DEPTH {
         return Err(ParseError { msg: "formula is nested too deeply".into(), pos: 0 });
     }
-    let bound = |name: &str, bindings: &Bindings| bindings.contains(name) || known_name(name);
+    let bound = |name: &str, bindings: &[String]| bindings.iter().rev().any(|n| crate::same_name(n, name)) || known_name(name);
     match expr {
         Expr::Bool(value) if display => {
             let alias = if *value { "VERDADERO" } else { "FALSO" };
@@ -192,7 +156,7 @@ fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut
                         // The new name is not in scope in its own value expression.
                         normalize(value, known_name, bindings, depth + 1, display)?;
                         if let Expr::Name(name) = declaration {
-                            bindings.push(name);
+                            bindings.push(name.clone());
                         }
                     }
                 }
@@ -205,7 +169,7 @@ fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut
             if let Some((body, params)) = args.split_last_mut() {
                 for param in params {
                     if let Expr::Name(name) = param {
-                        bindings.push(name);
+                        bindings.push(name.clone());
                     }
                 }
                 normalize(body, known_name, bindings, depth + 1, display)?;

crates/functions/src/dynamic.rs

@@ -760,13 +760,6 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R<Value> {
     let total = opt_count(args, 4)?.unwrap_or(1);
     let sort = opt_count(args, 5)?.unwrap_or(1);
     let filter = opt_arr(args, 6)?;
-    let relationship = opt_count(args, 7)?.unwrap_or(0);
-    // A total depth of N adds subtotals for the first N - 1 key columns, so it can't exceed the
-    // key columns, and a flat table (field_relationship 1) has no levels to subtotal.
-    let depth = total.unsigned_abs() as usize;
-    if depth > rf.cols.max(1) || (depth > 1 && relationship == 1) {
-        return Err(CellError::Value);
-    }
     let p = prepare(&[&rf], &vals, fh, filter.as_ref())?;
     let keys: Vec<Vec<Value>> = p.rows.iter().map(|&r| key_row(&rf, r)).collect();
     let mut groups: HashMap<String, Vec<usize>> = HashMap::new();
@@ -798,22 +791,13 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R<Value> {
         lines
             .sort_by(|a, b| cmp_keys(&[a.get(ci).cloned().unwrap_or(Value::Empty)], &[b.get(ci).cloned().unwrap_or(Value::Empty)], &[sort.signum()]));
     }
-    if depth > 1 {
-        let mut rows_of = |keys: &[Value]| groups.get(&row_key(keys)).cloned().unwrap_or_default();
-        // The header and total lines count too, so the whole result is checked before it is built.
-        let around = usize::from(p.show_headers) + usize::from(total != 0);
-        let width = rf.cols.saturating_add(vals.cols);
-        let fits = |n: usize| check_output_size(n.saturating_add(around), width);
-        lines = with_subtotals(lines, depth, rf.cols, total < 0, &fits, &mut rows_of, &mut agg_row)?;
-    }
     let mut out = Vec::new();
     if p.show_headers {
         let mut h = p.field_headers.clone();
         h.extend(p.value_headers.iter().cloned());
         out.push(h);
     }
-    // With subtotals Excel calls the last line "Grand Total".
-    let mut total_line = vec![Value::from(if depth > 1 { "Grand Total" } else { "Total" })];
+    let mut total_line = vec![Value::from("Total")];
     total_line.resize(rf.cols, Value::Empty);
     total_line.extend(agg_row(&p.rows));
     if total < 0 {
@@ -828,84 +812,6 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R<Value> {
     from_rows(out, &Value::Empty)
 }
 
-/// GROUPBY's subtotals: `lines` (`key_cols` keys, then values) with the lines of each group of a
-/// key level kept together in the order the groups first appear, and for every key level above
-/// `depth` a line after the group (before it when `before`): the group's keys, blanks for the deeper
-/// keys, and the values aggregated over the group's source rows (`rows_of` maps a line's keys to them).
-///
-/// No recursion, so a deep total depth can't exhaust the stack: each line gets the id of its key
-/// prefix at every level (ids count up as prefixes first appear), a stable sort by those ids brings
-/// each group together, and one walk adds a subtotal where a group starts or ends. `fits` gets the
-/// line count as the groups are found, so an oversized result is refused before it is built.
-fn with_subtotals(
-    mut lines: Vec<Vec<Value>>,
-    depth: usize,
-    key_cols: usize,
-    before: bool,
-    fits: &dyn Fn(usize) -> R<()>,
-    rows_of: &mut dyn FnMut(&[Value]) -> Vec<usize>,
-    agg: &mut dyn FnMut(&[usize]) -> Vec<Value>,
-) -> R<Vec<Vec<Value>>> {
-    let levels = depth.saturating_sub(1);
-    if levels == 0 {
-        return Ok(lines);
-    }
-    let mut ids: HashMap<(usize, String), usize> = HashMap::new();
-    let mut paths: Vec<Vec<usize>> = Vec::with_capacity(lines.len());
-    for line in &lines {
-        let mut parent = usize::MAX;
-        let mut path = Vec::with_capacity(levels);
-        for level in 0..levels {
-            let next = ids.len();
-            parent = *ids.entry((parent, row_key(line.get(level..=level).unwrap_or_default()))).or_insert(next);
-            path.push(parent);
-        }
-        fits(lines.len().saturating_add(ids.len()))?;
-        paths.push(path);
-    }
-    let mut group_rows: Vec<Vec<usize>> = vec![Vec::new(); ids.len()];
-    for (line, path) in lines.iter().zip(&paths) {
-        let rows = rows_of(line.get(..key_cols).unwrap_or_default());
-        for &id in path {
-            if let Some(g) = group_rows.get_mut(id) {
-                g.extend_from_slice(&rows);
-            }
-        }
-    }
-    let mut subtotal = |keys: &[Value], level: usize, id: usize| -> Vec<Value> {
-        let mut line: Vec<Value> = keys.iter().take(level + 1).cloned().collect();
-        line.resize(key_cols, Value::Empty);
-        line.extend(agg(group_rows.get(id).map(Vec::as_slice).unwrap_or_default()));
-        line
-    };
-    let mut order: Vec<usize> = (0..lines.len()).collect();
-    order.sort_by(|&a, &b| paths.get(a).cmp(&paths.get(b)));
-    let mut out = Vec::with_capacity(lines.len().saturating_add(ids.len()));
-    let mut prev: Option<(Vec<Value>, &[usize])> = None;
-    for &i in &order {
-        let (Some(line), Some(path)) = (lines.get_mut(i).map(std::mem::take), paths.get(i)) else { continue };
-        // The first level at which this line leaves the previous line's groups.
-        let split = prev.as_ref().map_or(0, |(_, p)| p.iter().zip(path).take_while(|(a, b)| a == b).count());
-        if before {
-            for (level, &id) in path.iter().enumerate().skip(split) {
-                out.push(subtotal(&line, level, id));
-            }
-        } else if let Some((keys, p)) = &prev {
-            for (level, &id) in p.iter().enumerate().skip(split).rev() {
-                out.push(subtotal(keys, level, id));
-            }
-        }
-        prev = Some((line.get(..key_cols).unwrap_or_default().to_vec(), path));
-        out.push(line);
-    }
-    if !before && let Some((keys, p)) = &prev {
-        for (level, &id) in p.iter().enumerate().rev() {
-            out.push(subtotal(keys, level, id));
-        }
-    }
-    Ok(out)
-}
-
 /// Height and width of a PIVOTBY grid: `header_rows` (one per column field, plus the value-name row) and
 /// `body_rows` (row keys plus the total row), each `lead` row-field cells wide plus `value_cols` cells per column key.
 fn pivot_dims(header_rows: usize, body_rows: usize, col_keys: usize, value_cols: usize, lead: usize) -> (usize, usize) {
@@ -1359,78 +1265,6 @@ mod tests {
         is_err(ev("GROUPBY", vec![rf(region), av(col(&[1.0])), t("SUM")]), CellError::Value);
     }
 
-    #[test]
-    fn groupby_subtotals_past_the_size_limit_are_refused_before_they_are_built() {
-        // One row with 4000 key columns at depth 4000 asks for 3999 subtotal lines, each 4001 cells
-        // wide: 16 million cells, over the limit. It is #NUM! before any subtotal line exists (it
-        // used to build them all, nesting 4000 levels deep, and refuse them afterwards).
-        let keys = av(arr(vec![(0..4000).map(|i| nv(f64::from(i))).collect()]));
-        is_err(ev("GROUPBY", vec![keys, av(col(&[1.0])), t("SUM"), empty(), n(4000.0)]), CellError::Num);
-    }
-
-    #[test]
-    fn groupby_total_depth_adds_subtotals() {
-        // #1456 item 1, values as Excel 365 shows them.
-        let keys2 = || av(arr(vec![vec![tv("a"), tv("x")], vec![tv("a"), tv("y")], vec![tv("b"), tv("x")]]));
-        let vals3 = || av(col(&[1.0, 2.0, 3.0]));
-        let e = Value::Empty;
-        let r = ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(2.0)]);
-        assert_eq!(
-            rows_of(&r),
-            vec![
-                vec![tv("a"), tv("x"), nv(1.0)],
-                vec![tv("a"), tv("y"), nv(2.0)],
-                vec![tv("a"), e.clone(), nv(3.0)],
-                vec![tv("b"), tv("x"), nv(3.0)],
-                vec![tv("b"), e.clone(), nv(3.0)],
-                vec![tv("Grand Total"), e.clone(), nv(6.0)],
-            ]
-        );
-        let r = ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(-2.0)]);
-        assert_eq!(
-            rows_of(&r),
-            vec![
-                vec![tv("Grand Total"), e.clone(), nv(6.0)],
-                vec![tv("a"), e.clone(), nv(3.0)],
-                vec![tv("a"), tv("x"), nv(1.0)],
-                vec![tv("a"), tv("y"), nv(2.0)],
-                vec![tv("b"), e.clone(), nv(3.0)],
-                vec![tv("b"), tv("x"), nv(3.0)],
-            ]
-        );
-        let keys3 = || {
-            av(arr(vec![
-                vec![tv("a"), tv("x"), tv("p")],
-                vec![tv("a"), tv("x"), tv("q")],
-                vec![tv("a"), tv("y"), tv("p")],
-                vec![tv("b"), tv("x"), tv("p")],
-            ]))
-        };
-        let vals4 = || av(col(&[1.0, 2.0, 3.0, 4.0]));
-        let r = ev("GROUPBY", vec![keys3(), vals4(), t("SUM"), empty(), n(3.0)]);
-        let line = |k: [&str; 3], v: f64| k.iter().map(|s| if s.is_empty() { Value::Empty } else { tv(s) }).chain([nv(v)]).collect::<Vec<_>>();
-        assert_eq!(
-            rows_of(&r),
-            vec![
-                line(["a", "x", "p"], 1.0),
-                line(["a", "x", "q"], 2.0),
-                line(["a", "x", ""], 3.0),
-                line(["a", "y", "p"], 3.0),
-                line(["a", "y", ""], 3.0),
-                line(["a", "", ""], 6.0),
-                line(["b", "x", "p"], 4.0),
-                line(["b", "x", ""], 4.0),
-                line(["b", "", ""], 4.0),
-                line(["Grand Total", "", ""], 10.0),
-            ]
-        );
-        // Depth 1 keeps "Total"; a depth past the key columns, or subtotals of a flat table, are errors.
-        let r = ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(1.0)]);
-        assert_eq!(rows_of(&r).last().unwrap(), &vec![tv("Total"), e, nv(6.0)]);
-        is_err(ev("GROUPBY", vec![av(arr(vec![vec![tv("a")], vec![tv("b")]])), av(col(&[1.0, 2.0])), t("SUM"), empty(), n(2.0)]), CellError::Value);
-        is_err(ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(2.0), empty(), empty(), n(1.0)]), CellError::Value);
-    }
-
     #[test]
     fn pivotby() {
         let (region, item, amt) = sales();

crates/functions/src/stat/descriptive.rs

@@ -50,27 +50,12 @@ pub(super) fn median(v: Vec<f64>) -> R<f64> {
 
 /// Values occurring at least twice, ordered by first occurrence, with their (equal, maximal) count.
 fn modes(v: &[f64]) -> Vec<f64> {
-    // Index of each distinct number in `counts`, so counting is linear rather than a search of
-    // every distinct number so far. Keyed by bits with -0 folded into 0 (they compare equal); NaN
-    // never equals anything, so it is never merged.
-    let mut index: std::collections::HashMap<u64, usize> = std::collections::HashMap::new();
     let mut counts: Vec<(f64, usize)> = Vec::new();
     for &x in v {
-        if x.is_nan() {
+        if let Some(e) = counts.iter_mut().find(|e| e.0 == x) {
+            e.1 += 1;
+        } else {
             counts.push((x, 1));
-            continue;
-        }
-        let key = if x == 0.0 { 0 } else { x.to_bits() };
-        match index.entry(key) {
-            std::collections::hash_map::Entry::Occupied(e) => {
-                if let Some(c) = counts.get_mut(*e.get()) {
-                    c.1 += 1;
-                }
-            }
-            std::collections::hash_map::Entry::Vacant(e) => {
-                e.insert(counts.len());
-                counts.push((x, 1));
-            }
         }
     }
     let best = counts.iter().map(|e| e.1).max().unwrap_or(0);
@@ -466,15 +451,11 @@ pub(super) fn frequency(a: &[Arg], _: C) -> R<Value> {
     if bins.is_empty() {
         return col_value(vec![data.len() as f64]);
     }
-    // a NaN bin equals no value (and would break the ascending order searched below)
-    let mut order: Vec<usize> = (0..bins.len()).filter(|&i| bins.get(i).is_some_and(|b| !b.is_nan())).collect();
+    let mut order: Vec<usize> = (0..bins.len()).collect();
     order.sort_by(|&i, &j| bins.get(i).copied().unwrap_or(0.0).total_cmp(&bins.get(j).copied().unwrap_or(0.0)));
     let mut counts = vec![0.0; bins.len() + 1];
     for x in data {
-        // `order` sorts the bins ascending, so the bins `x` exceeds come first: binary search for
-        // the first bin at or above `x` (the first of equal bins, as a linear scan would find).
-        let pos = if x.is_nan() { order.len() } else { order.partition_point(|&i| bins.get(i).copied().unwrap_or(f64::INFINITY) < x) };
-        let slot = order.get(pos).copied().unwrap_or(bins.len());
+        let slot = order.iter().find(|&&i| x <= bins.get(i).copied().unwrap_or(f64::INFINITY)).copied().unwrap_or(bins.len());
         if let Some(c) = counts.get_mut(slot) {
             *c += 1.0;
         }

crates/functions/src/stat/tests.rs

@@ -617,23 +617,3 @@ fn aggregate_helper() {
     close(aggregate_values_k(9, &vals, &nv(2.0)), 9.0);
     is_err(aggregate_values_k(14, &vals, &nv(10.0)), CellError::Num);
 }
-
-/// Security: FREQUENCY finds each value's bin by binary search, and MODE counts distinct numbers
-/// through an index, so neither is quadratic in its inputs. Results are as before: unsorted and
-/// duplicate bins keep their positions (a value goes to the first of equal bins), and tied modes
-/// come in first-occurrence order.
-#[test]
-fn frequency_and_mode_scale_with_their_inputs() {
-    let f = ev("FREQUENCY", vec![c(&[1.0, 2.0, 2.0, 3.0, 5.0, 9.0, -1.0]), c(&[3.0, 2.0, 2.0, 0.0])]);
-    assert_eq!(rows_of(&f), vec![vec![nv(1.0)], vec![nv(3.0)], vec![nv(0.0)], vec![nv(1.0)], vec![nv(2.0)]]);
-    // NaN data goes to the overflow bin, and a NaN bin takes nothing
-    let f = ev("FREQUENCY", vec![c(&[f64::NAN, 0.5, 2.0]), c(&[f64::NAN, 1.0])]);
-    assert_eq!(rows_of(&f), vec![vec![nv(0.0)], vec![nv(1.0)], vec![nv(2.0)]]);
-    let data: Vec<f64> = (0..200_000).map(|i| f64::from(i) + 1e6).collect();
-    let bins: Vec<f64> = (0..200_000).map(f64::from).collect();
-    let f = ev("FREQUENCY", vec![c(&data), c(&bins)]);
-    assert_eq!(rows_of(&f).last(), Some(&vec![nv(200_000.0)]));
-    let distinct = ev("MODE", vec![c(&data)]);
-    is_err(distinct, CellError::NA);
-    assert_eq!(rows_of(&ev("MODE.MULT", vec![c(&[3.0, 0.0, 1.0, -0.0, 3.0, 1.0])])), vec![vec![nv(3.0)], vec![nv(0.0)], vec![nv(1.0)]]);
-}

crates/functions/src/text.rs

@@ -1,7 +1,5 @@
 //! Text functions.
 
-use std::collections::HashMap;
-
 use gridcraft_core::parse::parse_number_text_in;
 use gridcraft_core::{CellError, Value, number_to_text};
 
@@ -55,25 +53,41 @@ fn concat(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     check_len(out)
 }
 
+/// The error `v.to_text()` would give, found without building any text.
+fn text_error(v: &Value) -> Option<CellError> {
+    match v {
+        Value::Error(e) => Some(*e),
+        Value::Array(a) => a.data.first().and_then(text_error),
+        _ => None,
+    }
+}
+
 fn textjoin(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
-    let delims: Vec<String> = as_array(&arg(a, 0)?.value).iter().map(|v| v.to_text()).collect::<R<_>>()?;
+    // Errors are found first, in argument order, so they win as before; text is then built one
+    // piece at a time into the capped output, so many references to one long text (or a long
+    // delimiter list) stop at the cap instead of first copying every piece.
+    let delims = as_array(&arg(a, 0)?.value);
+    if let Some(e) = delims.iter().find_map(text_error) {
+        return Err(e);
+    }
     let ignore = boolean(a, 1)?;
-    let mut items = Vec::new();
-    for x in a.iter().skip(2) {
-        for v in as_array(&x.value).iter() {
-            let s = v.to_text()?;
-            if ignore && s.is_empty() {
-                continue;
-            }
-            items.push(s);
-        }
+    let items: Vec<_> = a.iter().skip(2).map(|x| as_array(&x.value)).collect();
+    if let Some(e) = items.iter().flat_map(|x| x.iter()).find_map(text_error) {
+        return Err(e);
     }
     let mut out = String::new();
-    for (i, s) in items.iter().enumerate() {
-        if i > 0 && !delims.is_empty() {
-            push_capped(&mut out, &delims[(i - 1) % delims.len()])?;
+    let mut joined = 0usize;
+    for v in items.iter().flat_map(|x| x.iter()) {
+        let s = v.to_text()?;
+        if ignore && s.is_empty() {
+            continue;
         }
-        push_capped(&mut out, s)?;
+        if joined > 0 && !delims.data.is_empty() {
+            let d = delims.data.get((joined - 1) % delims.data.len()).map(Value::to_text).transpose()?.unwrap_or_default();
+            push_capped(&mut out, &d)?;
+        }
+        push_capped(&mut out, &s)?;
+        joined += 1;
     }
     check_len(out)
 }
@@ -341,11 +355,11 @@ fn numbervalue(a: &[Arg], c: &mut dyn Ctx) -> R<Value> {
     if body.is_empty() {
         return num_val(0.0);
     }
-    // Count the trailing percent signs and cut them off in place: copying the rest once per sign
-    // made a long run of them quadratic.
-    let kept = body.trim_end_matches('%').len();
-    let pct = body.len() - kept;
-    body.truncate(kept);
+    let mut pct = 0;
+    while let Some(b) = body.strip_suffix('%') {
+        body = b.to_string();
+        pct += 1;
+    }
     let mut seen_dec = false;
     let mut out = String::new();
     for c in body.chars() {
@@ -543,52 +557,23 @@ fn delimiters(v: &Value) -> R<Vec<Vec<char>>> {
     as_array(v).iter().map(|d| d.to_text().map(|s| chars(&s))).collect()
 }
 
-/// Most delimiter characters compared in one search: text length × delimiters is the formula's
-/// to choose, so the search gives up with `#VALUE!` rather than run on.
-const MAX_MATCH_WORK: u64 = 100_000_000;
-
 /// Non-overlapping delimiter matches (start, end) in char positions, in ascending order. Scans left
 /// to right preferring the longest delimiter starting at each position, or (`from_end`) right to
 /// left preferring the longest delimiter ending at each position. Empty delimiters are ignored unless all
-/// delimiters are empty, in which case every position matches with zero length. Repeated
-/// delimiters are tried once, and only those whose first (or, from the end, last) character is the
-/// one at hand; a search past [`MAX_MATCH_WORK`] is `#VALUE!`.
-fn find_matches(text: &[char], delims: &[Vec<char>], insensitive: bool, from_end: bool) -> R<Vec<(usize, usize)>> {
+/// delimiters are empty, in which case every position matches with zero length.
+fn find_matches(text: &[char], delims: &[Vec<char>], insensitive: bool, from_end: bool) -> Vec<(usize, usize)> {
     let t = if insensitive { fold(text) } else { text.to_vec() };
-    let mut ds: Vec<Vec<char>> = delims.iter().filter(|d| !d.is_empty()).map(|d| if insensitive { fold(d) } else { d.clone() }).collect();
+    let ds: Vec<Vec<char>> = delims.iter().filter(|d| !d.is_empty()).map(|d| if insensitive { fold(d) } else { d.clone() }).collect();
     if ds.is_empty() {
-        return Ok((0..=t.len()).map(|i| (i, i)).collect());
+        return (0..=t.len()).map(|i| (i, i)).collect();
     }
-    ds.sort_unstable();
-    ds.dedup();
-    // Delimiters by the character a match is anchored on.
-    let mut by_char: HashMap<char, Vec<&[char]>> = HashMap::new();
-    for d in &ds {
-        let anchor = if from_end { d.last() } else { d.first() };
-        if let Some(&c) = anchor {
-            by_char.entry(c).or_default().push(d);
-        }
-    }
-    let mut work = 0u64;
-    let mut longest = |candidates: Option<&Vec<&[char]>>, fits: &dyn Fn(&[char]) -> bool| -> R<Option<usize>> {
-        let mut best = None;
-        for d in candidates.into_iter().flatten() {
-            work = work.saturating_add(d.len() as u64);
-            if work > MAX_MATCH_WORK {
-                return Err(CellError::Value);
-            }
-            if fits(d) {
-                best = best.max(Some(d.len()));
-            }
-        }
-        Ok(best)
-    };
     let mut out = Vec::new();
     if from_end {
         let mut j = t.len();
         while j > 0 {
-            let at = t.get(j - 1).and_then(|c| by_char.get(c));
-            match longest(at, &|d| j.checked_sub(d.len()).and_then(|st| t.get(st..j)).is_some_and(|w| w == d))? {
+            let best =
+                ds.iter().filter(|d| j.checked_sub(d.len()).and_then(|st| t.get(st..j)).is_some_and(|w| w == d.as_slice())).map(Vec::len).max();
+            match best {
                 Some(l) => {
                     out.push((j - l, j));
                     j -= l;
@@ -597,12 +582,12 @@ fn find_matches(text: &[char], delims: &[Vec<char>], insensitive: bool, from_end
             }
         }
         out.reverse();
-        return Ok(out);
+        return out;
     }
     let mut i = 0;
     while i < t.len() {
-        let at = t.get(i).and_then(|c| by_char.get(c));
-        match longest(at, &|d| t.get(i..i + d.len()).is_some_and(|w| w == d))? {
+        let best = ds.iter().filter(|d| t.get(i..i + d.len()).is_some_and(|w| w == d.as_slice())).map(Vec::len).max();
+        match best {
             Some(l) => {
                 out.push((i, i + l));
                 i += l;
@@ -610,7 +595,7 @@ fn find_matches(text: &[char], delims: &[Vec<char>], insensitive: bool, from_end
             None => i += 1,
         }
     }
-    Ok(out)
+    out
 }
 
 fn text_before_after(a: &[Arg], before: bool) -> R<Value> {
@@ -622,7 +607,7 @@ fn text_before_after(a: &[Arg], before: bool) -> R<Value> {
     if !(0..=1).contains(&mode) || inst == 0 || inst.unsigned_abs() as usize > s.len().max(1) {
         return Err(CellError::Value);
     }
-    let mut m = find_matches(&s, &delims, mode == 1, inst < 0)?;
+    let mut m = find_matches(&s, &delims, mode == 1, inst < 0);
     if match_end {
         if inst > 0 {
             if m.last().is_none_or(|x| x.0 != s.len()) {
@@ -651,18 +636,18 @@ fn textafter(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     text_before_after(a, false)
 }
 
-fn split_by(s: &[char], delims: &[Vec<char>], insensitive: bool) -> R<Vec<Vec<char>>> {
+fn split_by(s: &[char], delims: &[Vec<char>], insensitive: bool) -> Vec<Vec<char>> {
     if delims.iter().all(Vec::is_empty) {
-        return Ok(vec![s.to_vec()]);
+        return vec![s.to_vec()];
     }
     let mut out = Vec::new();
     let mut last = 0;
-    for (st, en) in find_matches(s, delims, insensitive, false)? {
+    for (st, en) in find_matches(s, delims, insensitive, false) {
         out.push(s[last..st].to_vec());
         last = en;
     }
     out.push(s[last..].to_vec());
-    Ok(out)
+    out
 }
 
 fn textsplit(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
@@ -679,12 +664,12 @@ fn textsplit(a: &[Arg], _c: &mut dyn Ctx) -> R<Value> {
     }
     let pad = if has(a, 5) { scalar(arg(a, 5)?) } else { Value::Error(CellError::NA) };
     let mut rows: Vec<Vec<String>> = Vec::new();
-    for r in split_by(&s, &row_d, mode == 1)? {
+    for r in split_by(&s, &row_d, mode == 1) {
         if ignore && r.is_empty() {
             continue;
         }
         let cells: Vec<String> =
-            split_by(&r, &col_d, mode == 1)?.into_iter().filter(|c| !(ignore && c.is_empty())).map(|c| c.into_iter().collect()).collect();
+            split_by(&r, &col_d, mode == 1).into_iter().filter(|c| !(ignore && c.is_empty())).map(|c| c.into_iter().collect()).collect();
         if ignore && cells.is_empty() {
             continue;
         }
@@ -1115,15 +1100,6 @@ mod tests {
 
     use crate::util::testutil::*;
 
-    /// Trailing percent signs each divide by 100, and a long run of them is cut off in one pass.
-    #[test]
-    fn numbervalue_percent_signs() {
-        close(ev("NUMBERVALUE", vec![t("5%%")]), 0.0005);
-        close(ev("NUMBERVALUE", vec![t("1,5%"), t(","), t(".")]), 0.015);
-        let many = format!("1{}", "%".repeat(32_000));
-        close(ev("NUMBERVALUE", vec![t(&many)]), 0.0);
-    }
-
     #[test]
     fn bahttext() {
         let bt = |x: f64| ev("BAHTTEXT", vec![n(x)]);
@@ -1171,6 +1147,22 @@ mod tests {
         assert_eq!(rows_of(&ev("CONCATENATE", vec![av(row_t(&["a", "b"])), t("x")])), vec![vec![tv("ax"), tv("bx")]]);
     }
 
+    /// Security: TEXTJOIN builds its result piece by piece and stops at the text cap, rather
+    /// than first copying every input (100,000 references to one 32,767-character text were
+    /// 3 GB of copies). Errors among the inputs still win, in argument order.
+    #[test]
+    fn textjoin_stops_at_the_text_cap() {
+        use gridcraft_core::Array;
+        let long = tv(&"x".repeat(32_767));
+        let many = || av(Array::filled(100_000, 1, long.clone()).into());
+        is_err(ev("TEXTJOIN", vec![t(","), b(true), many()]), CellError::Value);
+        is_err(ev("TEXTJOIN", vec![av(Array::filled(1, 100_000, long.clone()).into()), b(false), t("a"), t("b")]), CellError::Value);
+        is_err(ev("TEXTJOIN", vec![t(","), b(true), many(), e(CellError::Div0)]), CellError::Div0);
+        is_err(ev("TEXTJOIN", vec![av(arr(vec![vec![tv(","), Value::Error(CellError::NA)]])), b(true), t("a")]), CellError::NA);
+        // Delimiters cycle and are converted only where used.
+        is_text(ev("TEXTJOIN", vec![av(arr(vec![vec![nv(1.0), tv(";")]])), b(false), t("a"), t("b"), t("c"), t("d")]), "a1b;c1d");
+    }
+
     fn row_t(xs: &[&str]) -> Value {
         arr(vec![xs.iter().map(|x| tv(x)).collect()])
     }
@@ -1406,24 +1398,6 @@ mod tests {
         is_text(ev("TEXTAFTER", vec![t("aaa"), t("aa"), n(1.0)]), "a");
     }
 
-    /// Thousands of copies of one delimiter are tried once; delimiters that can't start where the
-    /// scan stands aren't compared; a search over a budget of comparisons is `#VALUE!`.
-    #[test]
-    fn delimiter_matching_stays_bounded() {
-        let text = "ab,".repeat(10_000);
-        let same: Vec<&str> = vec![","; 50_000];
-        let v = ev("TEXTSPLIT", vec![t(&text), av(row_t(&same))]);
-        assert_eq!(rows_of(&v).first().map(Vec::len), Some(10_001));
-        // Distinct long delimiters that start and end like every position: refused, not run.
-        let long: Vec<String> = (0..5_000).map(|i| format!("a{i}{}", "a".repeat(1_000))).collect();
-        let long: Vec<&str> = long.iter().map(String::as_str).collect();
-        is_err(ev("TEXTSPLIT", vec![t(&"a".repeat(30_000)), av(row_t(&long))]), CellError::Value);
-        is_err(ev("TEXTBEFORE", vec![t(&"a".repeat(30_000)), av(row_t(&long)), n(-1.0)]), CellError::Value);
-        // Longest match wins at a position, from either end.
-        is_text(ev("TEXTBEFORE", vec![t("x--y-z"), av(row_t(&["-", "--"]))]), "x");
-        is_text(ev("TEXTAFTER", vec![t("x--y-z"), av(row_t(&["-", "--"])), n(-1.0)]), "z");
-    }
-
     #[test]
     fn split() {
         let v = ev("TEXTSPLIT", vec![t("a,b;c,d"), t(","), t(";")]);

crates/model/src/workbook.rs

@@ -95,10 +95,6 @@ pub struct CalcSettings {
     pub max_change: f64,
     /// Use precision as displayed.
     pub precision_as_displayed: bool,
-    /// R1C1 reference style (`<calcPr refMode="R1C1"/>`): kept with the file and written back;
-    /// GridCraft itself shows and takes A1 references.
-    #[serde(default)]
-    pub r1c1: bool,
 }
 
 impl Default for CalcSettings {
@@ -109,7 +105,6 @@ impl Default for CalcSettings {
             max_iterations: Self::DEFAULT_ITERATIONS,
             max_change: Self::DEFAULT_CHANGE,
             precision_as_displayed: false,
-            r1c1: false,
         }
     }
 }
@@ -205,12 +200,6 @@ pub struct Workbook {
     pub calc: CalcSettings,
     #[serde(default, skip_serializing_if = "is_all")]
     pub show_objects: ShowObjects,
-    /// Trust Center › Privacy Options › "Remove personal information from file properties on save"
-    /// (`<workbookPr filterPrivacy="1"/>`): kept with the file, and while it is on the author and
-    /// company are left out of the XLSX files GridCraft writes, as Excel leaves them empty. Other
-    /// formats aren't filtered: the workbook's own serialization still holds them.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub remove_personal_info: bool,
     /// Read and set with [`Workbook::active_sheet`] and [`Workbook::set_active_sheet`].
     pub active_sheet: ActiveSheet,
     /// The workbook window's display settings (`<workbookView>`), kept across an open + save.
@@ -349,7 +338,6 @@ impl Workbook {
             date_system: DateSystem::D1900,
             calc: CalcSettings::default(),
             show_objects: ShowObjects::All,
-            remove_personal_info: false,
             active_sheet: ActiveSheet::default(),
             view: WorkbookView::default(),
             props: DocProps::default(),

crates/numfmt/src/decimal.rs

@@ -136,9 +136,6 @@ pub(crate) fn fixed(a: f64, decimals: usize) -> (String, String) {
 /// General format squeezed into `max_chars` characters. Excel shows fewer decimals, then
 /// scientific notation, then "####" when a column is narrow; `None` means the caller paints "####".
 pub fn format_general_fit(n: f64, max_chars: usize) -> Option<String> {
-    // The widest fixed rendering of a double is about 330 characters; a larger request only
-    // pads zero decimals the trim below throws away.
-    let max_chars = max_chars.min(1024);
     if !n.is_finite() {
         return None;
     }
@@ -217,8 +214,6 @@ mod tests {
     fn general_fit() {
         assert_eq!(format_general_fit(1e11, 11).as_deref(), Some("1E+11"));
         assert_eq!(format_general_fit(12345678901.0, 11).as_deref(), Some("12345678901"));
-        // A huge width neither allocates width-sized padding nor changes the text.
-        assert_eq!(format_general_fit(1.5, usize::MAX).as_deref(), Some("1.5"));
         assert_eq!(format_general_fit(123456789012.0, 11).as_deref(), Some("1.23457E+11"));
         assert_eq!(format_general_fit(0.1 + 0.2, 11).as_deref(), Some("0.3"));
         assert_eq!(format_general_fit(1.0 / 3.0, 11).as_deref(), Some("0.333333333"));

crates/ui-egui/src/app.rs

@@ -107,9 +107,7 @@ impl SheetApp {
     pub fn logic(&mut self, ctx: &egui::Context) {
         self.ensure_text_width(ctx);
         // A keytip control request lives one frame: the ribbon consumes it during `ui`, and
-        // anything that never reached a control (collapsed ribbon, tab switch) is dropped. One
-        // made with a switch to the control's tab waits, with its window, for the next `ui` of
-        // that window.
+        // anything that never reached a control (collapsed ribbon, tab switch) is dropped.
         self.ui.keytip_invoke = None;
         // Floating pictures' textures go with their workbook, even when no sheet is painted.
         let open: Vec<u64> = self.session.documents().iter().map(|d| d.uid).collect();
@@ -196,9 +194,6 @@ impl SheetApp {
         let t0 = now_ms();
         // A script may have switched windows since the last frame.
         self.follow_active_window();
-        // This window's key tip request that waited for this frame (its tab or ribbon was just
-        // shown); any other window's request was dropped before it.
-        self.ui.keytip_invoke = self.ui.keytip_invoke_next.take();
         text_box::before_ui(self, &ctx);
         // Another window came forward without going through a command (which settles drafts
         // first): the draft goes into its own window instead of floating over this one. If its

crates/ui-egui/src/app/clipboard.rs

@@ -48,41 +48,12 @@ impl SheetApp {
     }
 
     /// Ribbon and menu Paste: paste the text on the system clipboard, as Cmd/Ctrl+V does. With no
-    /// text there but a picture, the picture is pasted. With neither, no host clipboard (web), or
-    /// the text that was there when GridCraft last copied without publishing, GridCraft's own
-    /// clipboard is pasted.
+    /// text there, no host clipboard (web), or the text that was there when GridCraft last copied
+    /// without publishing, GridCraft's own clipboard is pasted.
     pub fn paste_from_clipboard(&mut self) {
         match self.system_clipboard_text() {
             Some(text) if self.session.clipboard.is_none() || self.clipboard_text_at_copy.as_ref() != Some(&text) => self.paste_external(text),
-            Some(_) => self.run_or_alert("edit.paste", json!({})),
-            None => match self.services.paste_image.as_mut().and_then(|read| read()) {
-                Some(image) => self.paste_picture(image),
-                None => self.run_or_alert("edit.paste", json!({})),
-            },
-        }
-    }
-
-    /// Paste a picture from the system clipboard (a screenshot, an image copied in a browser) as
-    /// a floating picture whose top-left corner is the active cell, as Excel does.
-    pub fn paste_picture(&mut self, image: image::RgbaImage) {
-        match encode_png(&image) {
-            Ok(png) => self.run_or_alert("insert.picture", json!({"base64": gridcraft_engine::io::base64_encode(&png), "mime": "image/png"})),
-            Err(e) => self.alert(e),
-        }
-    }
-
-    /// Cmd/Ctrl+V with a picture and no text on the clipboard (egui's `Event::PasteImage`).
-    pub fn paste_color_image(&mut self, image: &egui::ColorImage) {
-        let [w, h] = image.size;
-        // A side too large for u32 is too large to paste; check before copying the pixels.
-        let (w, h) = (u32::try_from(w).unwrap_or(u32::MAX), u32::try_from(h).unwrap_or(u32::MAX));
-        if let Err(e) = check_picture_size(w, h) {
-            return self.alert(e);
-        }
-        let rgba = image.pixels.iter().flat_map(|c| c.to_srgba_unmultiplied()).collect();
-        match image::RgbaImage::from_raw(w, h, rgba) {
-            Some(image) => self.paste_picture(image),
-            None => self.alert("The picture on the clipboard can't be read.".into()),
+            _ => self.run_or_alert("edit.paste", json!({})),
         }
     }
 
@@ -104,29 +75,3 @@ impl SheetApp {
         }
     }
 }
-
-/// Largest clipboard picture pasted, per side and in total (an 8K screenshot fits).
-const MAX_PICTURE_SIDE: u32 = 16_384;
-const MAX_PICTURE_PIXELS: u64 = 64 * 1024 * 1024;
-
-/// Refuse empty clipboard pictures and sizes that would exhaust memory.
-fn check_picture_size(w: u32, h: u32) -> Result<(), String> {
-    if w == 0 || h == 0 {
-        return Err("The picture on the clipboard is empty.".into());
-    }
-    if w > MAX_PICTURE_SIDE || h > MAX_PICTURE_SIDE || u64::from(w) * u64::from(h) > MAX_PICTURE_PIXELS {
-        return Err("The picture on the clipboard is too large to paste.".into());
-    }
-    Ok(())
-}
-
-/// PNG bytes of a clipboard picture, refusing sizes that would exhaust memory.
-fn encode_png(image: &image::RgbaImage) -> Result<Vec<u8>, String> {
-    let (w, h) = image.dimensions();
-    check_picture_size(w, h)?;
-    let mut png = Vec::new();
-    image
-        .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
-        .map_err(|e| format!("The picture on the clipboard can't be pasted: {e}"))?;
-    Ok(png)
-}

crates/ui-egui/src/app/commands.rs

@@ -163,19 +163,8 @@ impl SheetApp {
                 Ok(Json::Null)
             }
             "view.expandFormulaBar" => {
-                // `lines` is where a drag of the bar's bottom edge left it: one line collapses it,
-                // more expands it to that height, which expanding returns to afterwards.
-                if let Some(lines) = p.get("lines").and_then(Json::as_u64) {
-                    let lines = usize::try_from(lines).unwrap_or(usize::MAX).clamp(1, crate::formula_bar::MAX_DRAG_LINES);
-                    self.ui.formula_bar_expanded = lines > 1;
-                    if lines > 1 {
-                        self.ui.formula_bar_lines = lines;
-                    }
-                    Ok(json!({"on": self.ui.formula_bar_expanded, "lines": self.ui.formula_bar_lines}))
-                } else {
-                    self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded);
-                    Ok(json!({"on": self.ui.formula_bar_expanded}))
-                }
+                self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded);
+                Ok(json!({"on": self.ui.formula_bar_expanded}))
             }
             "view.darkMode" => {
                 let current = if self.ui.system_theme { self.effective_dark } else { self.ui.dark };
@@ -202,10 +191,6 @@ impl SheetApp {
                 self.ui.autocomplete = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.autocomplete);
                 Ok(json!({"on": self.ui.autocomplete}))
             }
-            "options.highlightActiveRow" => {
-                self.ui.highlight_active_row = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.highlight_active_row);
-                Ok(json!({"on": self.ui.highlight_active_row}))
-            }
             "view.interfaceScale" => {
                 // `{"percent": 125}` or `{"percent": "auto"}`; out-of-range values are clamped.
                 let percent = match p.get("percent") {

crates/ui-egui/src/app/keys.rs

@@ -59,22 +59,7 @@ impl SheetApp {
                 // Route to the ribbon control that owns this keytip: it opens its dropdown or
                 // runs its click handler with the right params (the engine command alone would
                 // be missing them).
-                //
-                // A control on another tab (a legacy menu key such as Alt+I, S for the Symbol
-                // gallery) shows its tab first, so the control is drawn and takes the request.
-                keytips::Action::Control(id) => {
-                    // A collapsed ribbon draws no controls either: it is expanded the same way.
-                    let other_tab = gridcraft_engine::find_command(id).and_then(|c| c.menu.first()).filter(|t| **t != self.ui.ribbon_tab);
-                    if other_tab.is_some() || self.ui.ribbon_collapsed {
-                        if let Some(tab) = other_tab {
-                            self.run_or_alert("ui.ribbonTab", json!({"tab": tab}));
-                        }
-                        self.ui.ribbon_collapsed = false;
-                        self.ui.keytip_invoke_next = Some(id);
-                    } else {
-                        self.ui.keytip_invoke = Some(id);
-                    }
-                }
+                keytips::Action::Control(id) => self.ui.keytip_invoke = Some(id),
             }
         }
     }

crates/ui-egui/src/backstage/options.rs

@@ -2,8 +2,7 @@ use super::{Key, Language, Modifiers, SheetApp, Ui, dim, i18n, json, section, ve
 
 /// Excel's File › Options page: General (display theme, interface language and Show formula bar),
 /// Editing (AutoComplete) and Save (the autosave checkbox toggling `app.ui.autosave`), plus Formulas
-/// (calculation mode and iterative calculation) and the display options for this workbook (sheet
-/// tabs and scroll bars) when a document is active. Theme, language, formula
+/// (calculation mode and iterative calculation) when a document is active. Theme, language, formula
 /// bar, AutoComplete and calculation changes run their commands through `run_or_alert`; calculation
 /// settings are saved with the workbook.
 pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) {
@@ -15,10 +14,6 @@ pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) {
     if ui.checkbox(&mut formula_bar, lang.tr("Show formula bar")).changed() {
         app.run_or_alert("view.formulaBar", json!({"on": formula_bar}));
     }
-    let mut highlight_row = app.ui.highlight_active_row;
-    if ui.checkbox(&mut highlight_row, lang.tr("Highlight the active cell's row")).changed() {
-        app.run_or_alert("options.highlightActiveRow", json!({"on": highlight_row}));
-    }
     ui.add_space(18.0);
     section(ui, lang, "Options|Editing");
     let mut autocomplete = app.ui.autocomplete;
@@ -31,20 +26,7 @@ pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) {
     if ui.checkbox(&mut autosave, lang.tr("Save .xlsx workbooks automatically after every change")).changed() {
         app.toggle_autosave();
     }
-    let Some((calc, view)) = app.session.active().map(|d| (d.wb.calc.clone(), d.wb.view)) else { return };
-    ui.add_space(18.0);
-    // Excel's Advanced › Display options for this workbook: saved with the workbook (#3101).
-    section(ui, lang, "Display options for this workbook");
-    for (on, label, id) in [
-        (view.show_horizontal_scroll, "Show horizontal scroll bar", "view.showHorizontalScrollBar"),
-        (view.show_vertical_scroll, "Show vertical scroll bar", "view.showVerticalScrollBar"),
-        (view.show_sheet_tabs, "Show sheet tabs", "view.showSheetTabs"),
-    ] {
-        let mut on = on;
-        if ui.checkbox(&mut on, lang.tr(label)).changed() {
-            app.run_or_alert(id, json!({"on": on}));
-        }
-    }
+    let Some(calc) = app.session.active().map(|d| d.wb.calc.clone()) else { return };
     ui.add_space(18.0);
     section(ui, lang, "Formulas");
     ui.label(lang.tr("Workbook calculation"));

crates/ui-egui/src/chartview.rs

@@ -316,12 +316,11 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo
                 p.add(PathShape::convex_polygon(vec![pos2(r.center().x, r.top()), r.right_bottom(), r.left_bottom()], fill, Stroke::new(1.0, line)));
             }
             ShapeKind::Ink => {
-                let pt = gridcraft_engine::cmd::draw::ink_width(sp);
-                let w = pt * geo.z;
+                let w = gridcraft_engine::cmd::draw::ink_width(sp) * geo.z;
                 let pts: Vec<Pos2> =
                     gridcraft_engine::cmd::draw::ink_points(sp).iter().map(|q| pos2(r.left() + q[0] * geo.z, r.top() + q[1] * geo.z)).collect();
                 if pts.len() >= 2 {
-                    let col = ink_color(line, pt);
+                    let col = if w > 8.0 { line.gamma_multiply(0.45) } else { line };
                     p.add(PathShape::line(pts, PathStroke::new(w, col)));
                 }
                 label = false;
@@ -557,9 +556,3 @@ pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Re
     }
     None
 }
-
-/// The colour ink is painted in: a highlighter (a stroke over 8 pt wide) is translucent, by its
-/// width in points, so the live pen stroke and the committed ink agree at every zoom.
-pub(crate) fn ink_color(line: Color32, width_pt: f32) -> Color32 {
-    if width_pt > 8.0 { line.gamma_multiply(0.45) } else { line }
-}

crates/ui-egui/src/control.rs

@@ -263,17 +263,12 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) -
                 ("ui.ribbonTab", "Ribbon Tab", ""),
                 ("app.checkForUpdates", "Check for Updates…", ""),
                 ("view.collapseRibbon", "Collapse Ribbon", ""),
-                (
-                    "view.expandFormulaBar",
-                    "Expand Formula Bar",
-                    "{on?: bool} (toggles without it) → {on}; {lines: int} sets the expanded height (1 collapses) → {on, lines}",
-                ),
+                ("view.expandFormulaBar", "Expand Formula Bar", "{on?: bool} (toggles without it) → {on}"),
                 ("ui.pythonMode", "Python Mode", "{on?: bool} (toggles without it) → {on}; a refused start is an error"),
                 ("view.darkMode", "Dark Mode", ""),
                 ("view.theme", "Display Theme", ""),
                 ("view.animations", "Animations", "{on?: bool} (toggles without it) → {on}"),
                 ("options.autoComplete", "Enable AutoComplete for cell values", "{on?: bool} (toggles without it) → {on}"),
-                ("options.highlightActiveRow", "Highlight the active cell's row", "{on?: bool} (toggles without it) → {on}"),
                 ("view.interfaceScale", "Interface Size", "{percent: 75–200 | \"auto\"} (100 = auto; clamped)"),
                 ("ui.dialog", "Open Dialog", ""),
                 ("ui.backstage", "File (Backstage view)", "{page?: home|new|open|info|saveAs|print|export|options|account|close}"),

crates/ui-egui/src/dialogs.rs

@@ -564,8 +564,6 @@ impl Dialog {
                     d.values.insert("text".into(), json!(text));
                     d.values.insert("tooltip".into(), json!(link.tooltip));
                     d.original_link_text = Some(text);
-                    // As in Excel, the dialog on a linked cell edits that link.
-                    d.title = "Edit Hyperlink".into();
                 }
                 d
             }

crates/ui-egui/src/dialogs/find.rs

@@ -40,21 +40,7 @@ pub(super) fn find(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) {
     d.values.insert("matchCase".into(), json!(case));
     d.values.insert("wholeCell".into(), json!(whole));
     d.values.insert("within".into(), json!(if wb { "workbook" } else { "sheet" }));
-    // As in Excel, a selected range (more than one cell) limits the search on the sheet to it.
-    // One selected cell, merged or not, searches the sheet, as in Excel.
-    let range_selected = app.session.active().is_some_and(|doc| {
-        let sel = &doc.selection;
-        let one_merged = sel.ranges.len() == 1 && doc.wb.active().and_then(|sh| sh.merge_at(sel.current().start)).is_some_and(|m| m == sel.current());
-        !sel.is_single_cell() && !one_merged
-    });
-    let within = if wb {
-        "workbook"
-    } else if range_selected {
-        "selection"
-    } else {
-        "sheet"
-    };
-    let base = json!({"what": what, "matchCase": case, "wholeCell": whole, "within": within});
+    let base = json!({"what": what, "matchCase": case, "wholeCell": whole, "within": if wb { "workbook" } else { "sheet" }});
     ui.horizontal(|ui| {
         if d.tab == "Replace" {
             if ui.button("Replace All").clicked() {

crates/ui-egui/src/dialogs/paste.rs

@@ -5,8 +5,6 @@ use super::{Dialog, Field, Json, Key, SheetApp, Stroke, json, theme, vec2};
 /// come from the dialog's `fields`, so the letter shortcuts and the control channel see the same.
 pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) {
     let lang = app.ui.language;
-    // L, the Paste Link button's access key, pastes at once as the button does.
-    let link_now = d.values.remove(PASTE_LINK_NOW).is_some_and(|v| v == json!(true));
     let t = theme::Tokens::get(ui.ctx());
     type Choice = (&'static str, &'static str, Vec<(&'static str, &'static str)>);
     let choices: Vec<Choice> = d
@@ -58,7 +56,7 @@ pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialo
     ui.separator();
     ui.horizontal(|ui| {
         // Excel's Paste Link pastes references to the copied cells straight away.
-        if ui.button(lang.tr("Paste Link")).on_hover_text(lang.tr("Paste formulas that refer to the copied cells")).clicked() || link_now {
+        if ui.button(lang.tr("Paste Link")).on_hover_text(lang.tr("Paste formulas that refer to the copied cells")).clicked() {
             d.values.insert("what".into(), json!("all"));
             d.values.insert("operation".into(), json!("none"));
             d.values.insert("link".into(), json!(true));
@@ -76,45 +74,6 @@ pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialo
     });
 }
 
-/// Set by the Paste Link access key for the next frame of the dialog, which then pastes.
-const PASTE_LINK_NOW: &str = "pasteLinkNow";
-
-/// What one of Paste Special's access keys does: choose an option of a group, or flip a box.
-#[derive(Clone, Copy)]
-enum Mnemonic {
-    Set(&'static str, &'static str),
-    Toggle(&'static str),
-    /// The Paste Link button: pastes at once.
-    PasteLink,
-}
-
-/// Excel's access keys in Paste Special (#1482): the Paste choices, the operations, the two check
-/// boxes and the Paste Link button, each the letter Excel underlines.
-fn mnemonic_action(key: Key) -> Option<(char, Mnemonic)> {
-    use Mnemonic::{Set, Toggle};
-    Some(match key {
-        Key::A => ('a', Set("what", "all")),
-        Key::F => ('f', Set("what", "formulas")),
-        Key::V => ('v', Set("what", "values")),
-        Key::T => ('t', Set("what", "formats")),
-        Key::C => ('c', Set("what", "comments")),
-        Key::N => ('n', Set("what", "validation")),
-        Key::X => ('x', Set("what", "allExceptBorders")),
-        Key::W => ('w', Set("what", "columnWidths")),
-        Key::R => ('r', Set("what", "formulasAndNumberFormats")),
-        Key::U => ('u', Set("what", "valuesAndNumberFormats")),
-        Key::O => ('o', Set("operation", "none")),
-        Key::D => ('d', Set("operation", "add")),
-        Key::S => ('s', Set("operation", "subtract")),
-        Key::M => ('m', Set("operation", "multiply")),
-        Key::I => ('i', Set("operation", "divide")),
-        Key::B => ('b', Toggle("skipBlanks")),
-        Key::E => ('e', Toggle("transpose")),
-        Key::L => ('l', Mnemonic::PasteLink),
-        _ => return None,
-    })
-}
-
 /// Paste Special's legacy mnemonics select options; Enter still performs the paste.
 pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) {
     if ctx.text_edit_focused() {
@@ -129,7 +88,14 @@ pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) {
     });
     let mac = ctx.os() == egui::os::OperatingSystem::Mac;
     let allowed = |m: egui::Modifiers| !m.ctrl && !m.command && !m.mac_cmd && !(m.alt && (mac || right_alt));
-    let mnemonic = |key| mnemonic_action(key).map(|(letter, _)| letter);
+    let mnemonic = |key| match key {
+        Key::T => Some('t'),
+        Key::V => Some('v'),
+        Key::F => Some('f'),
+        Key::C => Some('c'),
+        Key::E => Some('e'),
+        _ => None,
+    };
     let mut text_to_consume = Vec::new();
     for event in ctx.input(|i| i.events.clone()) {
         let egui::Event::Key { key, pressed: true, repeat, modifiers, .. } = event else { continue };
@@ -141,18 +107,17 @@ pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) {
         if repeat {
             continue;
         }
-        match mnemonic_action(key).map(|(_, action)| action) {
-            Some(Mnemonic::Set(field, value)) => {
-                d.values.insert(field.into(), json!(value));
-            }
-            Some(Mnemonic::Toggle(field)) => {
-                let on = d.values.get(field).and_then(Json::as_bool).unwrap_or(false);
-                d.values.insert(field.into(), json!(!on));
-            }
-            Some(Mnemonic::PasteLink) => {
-                d.values.insert(PASTE_LINK_NOW.into(), json!(true));
-            }
-            None => {}
+        if key == Key::E {
+            let transpose = d.values.get("transpose").and_then(Json::as_bool).unwrap_or(false);
+            d.values.insert("transpose".into(), json!(!transpose));
+        } else {
+            let what = match key {
+                Key::T => "formats",
+                Key::V => "values",
+                Key::F => "formulas",
+                _ => "comments",
+            };
+            d.values.insert("what".into(), json!(what));
         }
     }
     // Browsers can deliver Text before or after Key. Act only on Key, then remove

crates/ui-egui/src/editor.rs

@@ -375,7 +375,7 @@ pub fn formula_refs(text: &str) -> Vec<(usize, usize, RangeRef, Option<String>,
     let offset = text.len() - body.len();
     let Ok(toks) = gridcraft_engine::formula::lexer::tokenize(body) else { return vec![] };
     let mut out: Vec<(usize, usize, RangeRef, Option<String>, usize)> = Vec::new();
-    let mut seen: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
+    let mut seen: Vec<String> = Vec::new();
     let mut i = 0;
     while i < toks.len() {
         use gridcraft_engine::formula::lexer::Tok;
@@ -407,8 +407,13 @@ pub fn formula_refs(text: &str) -> Vec<(usize, usize, RangeRef, Option<String>,
                 continue;
             };
             let key = body.get(start..end).unwrap_or("").replace('$', "").to_ascii_uppercase();
-            let next = seen.len();
-            let idx = *seen.entry(key).or_insert(next);
+            let idx = match seen.iter().position(|k| *k == key) {
+                Some(k) => k,
+                None => {
+                    seen.push(key);
+                    seen.len() - 1
+                }
+            };
             out.push((start + offset, end + offset, range, sheet, idx % REF_COLOR_COUNT));
             continue;
         }

crates/ui-egui/src/formula_bar.rs

@@ -12,14 +12,6 @@ use crate::theme::{self, Tokens};
 
 /// Lines the formula bar (and the in-cell editor) grows to before it scrolls.
 pub const MAX_LINES: usize = 5;
-/// The most lines a drag of the bar's bottom edge can give it (the window caps it at half its
-/// height first).
-pub const MAX_DRAG_LINES: usize = 100;
-/// How far the bar's bottom edge reaches up into the bar as a resize handle (its bottom margin).
-const HANDLE: f32 = 4.0;
-/// What an expanded bar leaves below it: the status bar (26) and sheet tabs (32), and the
-/// worksheet's column headings and two rows, so the grid never disappears in a short window.
-const KEEP_BELOW: f32 = 26.0 + 32.0 + crate::grid::COL_HEADER_H + 2.0 * gridcraft_engine::model::DEFAULT_ROW_HEIGHT;
 /// The bar's height at one line.
 const ONE_LINE: f32 = 30.0;
 /// What the bar adds around the field's rows: the panel's margins (3 + 3), the field's (3 + 3)
@@ -48,22 +40,11 @@ pub struct BarLayout {
     pub visible_lines: usize,
     /// The caret while editing in the bar.
     pub caret: Option<Rect>,
-    /// The bottom edge that resizes the bar.
-    pub handle: Rect,
 }
 
 impl Default for BarLayout {
     fn default() -> Self {
-        BarLayout {
-            name_box: Rect::NOTHING,
-            buttons: Rect::NOTHING,
-            field: Rect::NOTHING,
-            height: 0.0,
-            lines: 1,
-            visible_lines: 1,
-            caret: None,
-            handle: Rect::NOTHING,
-        }
+        BarLayout { name_box: Rect::NOTHING, buttons: Rect::NOTHING, field: Rect::NOTHING, height: 0.0, lines: 1, visible_lines: 1, caret: None }
     }
 }
 
@@ -92,15 +73,13 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
     let font = theme::ui_font(13.0);
     let row_h = ui.ctx().fonts_mut(|f| f.row_height(&font));
     let last = BarLayout::get(ui.ctx());
-    // Height follows the content's line count (last frame's), 1 to MAX_LINES; expanded (the
-    // chevron), it is the height the bottom edge was dragged to. It eases only when that target
-    // changes.
-    let most = max_lines(ui.ctx().content_rect().height(), ui.available_rect_before_wrap().height(), row_h);
-    let lines = if app.ui.formula_bar_expanded { app.ui.formula_bar_lines.clamp(1, most) } else { last.lines.clamp(1, MAX_LINES) };
+    // Height follows the content's line count (last frame's), 1 to MAX_LINES; the chevron pins it
+    // at MAX_LINES. It eases only when that target changes.
+    let lines = if app.ui.formula_bar_expanded { MAX_LINES } else { last.lines.clamp(1, MAX_LINES) };
     let target = one_line(row_h) + (lines - 1) as f32 * row_h;
     let h = ui.ctx().animate_value_with_time(egui::Id::unique("formula_bar.height"), target, EASE_SECONDS);
     let mut layout = BarLayout { height: h, ..Default::default() };
-    let panel = egui::Panel::top("formula_bar")
+    egui::Panel::top("formula_bar")
         .exact_size(h)
         .frame(egui::Frame::NONE.fill(t.window).inner_margin(egui::Margin { left: 8, right: 8, top: 3, bottom: 3 }))
         .show(ui, |ui| {
@@ -177,62 +156,9 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
                 }
             });
         });
-    layout.handle = resize_handle(app, ui, panel.response.rect, row_h, most);
     ui.ctx().data_mut(|d| d.insert_temp(BarLayout::id(), layout));
 }
 
-/// The most lines the bar takes in a window `window_h` tall with `room` left under the ribbon:
-/// half the window, as in Excel (never fewer than the chevron's [`MAX_LINES`]), and no more than
-/// leaves [`KEEP_BELOW`] for the status bar, sheet tabs and a few rows of the grid.
-fn max_lines(window_h: f32, room: f32, row_h: f32) -> usize {
-    let lines_in = |h: f32| {
-        let fit = ((h - one_line(row_h)) / row_h).floor();
-        if fit.is_finite() && fit > 0.0 { fit as usize + 1 } else { 1 }
-    };
-    lines_in(window_h * 0.5).clamp(MAX_LINES, MAX_DRAG_LINES).min(lines_in(room - KEEP_BELOW))
-}
-
-/// The lines a bar whose top is at `top` shows with its bottom edge dragged to `y`, in whole lines.
-fn dragged_lines(y: f32, top: f32, row_h: f32, most: usize) -> usize {
-    let extra = ((y - top - one_line(row_h)) / row_h).round();
-    if extra.is_finite() && extra > 0.0 { (extra as usize + 1).min(most) } else { 1 }
-}
-
-/// The bar's bottom edge: dragging it sets the bar's height in whole lines, as in Excel. The bar
-/// follows the pointer; the release runs `view.expandFormulaBar` with the lines, so one drag is
-/// one step (one line collapses the bar).
-fn resize_handle(app: &mut SheetApp, ui: &mut egui::Ui, bar: Rect, row_h: f32, most: usize) -> Rect {
-    let handle = Rect::from_x_y_ranges(bar.x_range(), (bar.bottom() - HANDLE)..=bar.bottom());
-    let resp = ui.interact(handle, egui::Id::unique("formula_bar.resize"), Sense::drag());
-    let name = app.ui.language.tr("Resize formula bar");
-    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, name));
-    if resp.hovered() || resp.dragged() {
-        ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeVertical);
-    }
-    // The state before the drag: the preview changes it, the release puts it back for the command.
-    let before = resp.id.with("before");
-    if resp.drag_started() {
-        let state = (app.ui.formula_bar_expanded, app.ui.formula_bar_lines);
-        ui.ctx().data_mut(|d| d.insert_temp(before, state));
-    }
-    if let Some(p) = resp.interact_pointer_pos().filter(|_| resp.dragged() || resp.drag_stopped()) {
-        let lines = dragged_lines(p.y, bar.top(), row_h, most);
-        if resp.drag_stopped() {
-            if let Some((expanded, kept)) = ui.ctx().data_mut(|d| d.remove_temp::<(bool, usize)>(before)) {
-                (app.ui.formula_bar_expanded, app.ui.formula_bar_lines) = (expanded, kept);
-            }
-            app.run_or_alert("view.expandFormulaBar", json!({"lines": lines}));
-        } else {
-            app.ui.formula_bar_expanded = lines > 1;
-            if lines > 1 {
-                app.ui.formula_bar_lines = lines;
-            }
-            ui.ctx().request_repaint();
-        }
-    }
-    handle
-}
-
 /// Resolve ownership on every frame; never cache a spill range in presentation state.
 pub(crate) fn active_spill_anchor(app: &SheetApp) -> Option<gridcraft_engine::core::CellRef> {
     let d = app.session.active()?;

crates/ui-egui/src/grid.rs

@@ -22,8 +22,6 @@ 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 active_row;
-pub use active_row::active_row_band;
 mod cell_paint;
 mod cursor;
 mod editor;
@@ -103,10 +101,6 @@ pub enum Drag {
     Select,
     Rows(u32),
     Cols(u32),
-    /// Point mode over the row headers: the formula's reference runs from this row to the pointer.
-    PointRows(u32),
-    /// Point mode over the column headers: the formula's reference runs from this column to the pointer.
-    PointCols(u32),
     /// Reordering one contiguous whole-column selection by its header.
     MoveCols {
         source: RangeRef,

crates/ui-egui/src/grid/active_row.rs

@@ -1,28 +0,0 @@
-//! "Highlight the active cell's row" (File ▸ Options ▸ General): a tint across the whole row of
-//! the active cell, so the eye keeps its place in a wide table.
-
-use super::geo::Geo;
-use super::quadrant::QuadrantPaint;
-use super::{Rect, Sheet, pos2};
-
-/// The tinted band of `row` inside one quadrant (`rows` x `cols`): none when the row is outside
-/// the quadrant or hidden.
-pub fn active_row_band(geo: &Geo, sh: &Sheet, row: u32, rows: (u32, u32), cols: (u32, u32)) -> Option<Rect> {
-    let height = sh.row_height(row) * geo.z;
-    if row < rows.0 || row > rows.1 || height <= 0.0 {
-        return None;
-    }
-    let top = geo.y(sh, row);
-    let right = geo.x(sh, cols.1) + sh.col_width(cols.1) * geo.z;
-    Some(Rect::from_min_max(pos2(geo.x(sh, cols.0), top), pos2(right, top + height)))
-}
-
-/// Paints the band of one quadrant, when the preference is on. With `within`, only the part of it
-/// inside that area (text running past its cell has just cleared it).
-pub(super) fn paint_active_row(q: &QuadrantPaint<'_>, within: Option<Rect>) {
-    let Some(band) = q.active_row.and_then(|row| active_row_band(q.geo, q.sheet, row, q.rows, q.cols)) else { return };
-    let part = within.map_or(band, |area| band.intersect(area));
-    if part.is_positive() {
-        q.painter.rect_filled(part, 0.0, q.tokens.active_row);
-    }
-}

crates/ui-egui/src/grid/cell_paint.rs

@@ -194,7 +194,7 @@ pub(super) fn merged_edges(wb: &Workbook, si: usize, sh: &Sheet, geo: &Geo, area
         if sh.col_width(col) == 0.0 {
             continue;
         }
-        let (x0, x1) = (geo.x(sh, col), geo.x_end(sh, col));
+        let (x0, x1) = (geo.x(sh, col), geo.x(sh, col.saturating_add(1)));
         let top = look(wb, si, sh, CellRef::new(m.start.row, col), cf).0.style.borders.top;
         let bottom = look(wb, si, sh, CellRef::new(m.end.row, col), cf).0.style.borders.bottom;
         out.push((top, [pos2(x0, rect.top()), pos2(x1, rect.top())]));
@@ -205,7 +205,7 @@ pub(super) fn merged_edges(wb: &Workbook, si: usize, sh: &Sheet, geo: &Geo, area
         if sh.row_height(row) == 0.0 {
             continue;
         }
-        let (y0, y1) = (geo.y(sh, row), geo.y_end(sh, row));
+        let (y0, y1) = (geo.y(sh, row), geo.y(sh, row.saturating_add(1)));
         let left = look(wb, si, sh, CellRef::new(row, m.start.col), cf).0.style.borders.left;
         let right = look(wb, si, sh, CellRef::new(row, m.end.col), cf).0.style.borders.right;
         out.push((left, [pos2(rect.left(), y0), pos2(rect.left(), y1)]));

crates/ui-egui/src/grid/cursor.rs

@@ -48,7 +48,7 @@ fn drag_cursor(drag: &Drag, rtl: bool) -> Option<CursorIcon> {
     match drag {
         Drag::None => None,
         Drag::Select => Some(CursorIcon::Cell),
-        Drag::Rows(_) | Drag::Cols(_) | Drag::PointRows(_) | Drag::PointCols(_) => Some(CursorIcon::Default),
+        Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default),
         Drag::Fill { .. } => Some(CursorIcon::Crosshair),
         Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { handle: None, .. } => Some(CursorIcon::Move),
         Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn),

crates/ui-egui/src/grid/editor.rs

@@ -125,7 +125,7 @@ pub(super) fn list_picker(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_
         app.grid.list_picker = None;
         return;
     };
-    let items = gridcraft_engine::cmd::data::list_items(&wb, si, c, &dv);
+    let items = gridcraft_engine::cmd::data::list_items(&wb, si, &dv);
     let r = geo.cell_rect(sh, c);
     // Fit the popup to its rows (up to LIST_PICKER_MAX_ROWS); without a minimum the scroll area collapses to its 64 px default.
     let height = list_picker_height(items.len(), LIST_PICKER_ROW_H, ui.spacing().item_spacing.y);

crates/ui-egui/src/grid/geo.rs

@@ -158,21 +158,11 @@ impl Geo {
             self.cells.top() + self.frozen_h + (self.ri.start(row) as f32 - self.ri.start(self.fr) as f32 - self.scroll.y) * self.z
         }
     }
-    /// Screen x of `col`'s right edge. Not `x(col + 1)`: across the freeze line (and between
-    /// pages) the next column is laid out elsewhere (#2544).
-    pub fn x_end(&self, sh: &Sheet, col: u32) -> f32 {
-        self.x(sh, col) + sh.col_width(col) * self.z
-    }
-    /// Screen y of `row`'s bottom edge (see `x_end`).
-    pub fn y_end(&self, sh: &Sheet, row: u32) -> f32 {
-        self.y(sh, row) + sh.row_height(row) * self.z
-    }
-    /// Columns `a` and `b` are on the same side of the freeze line, so they scroll together.
-    pub fn same_col_pane(&self, a: u32, b: u32) -> bool {
-        (a < self.fc) == (b < self.fc)
-    }
     pub fn cell_rect(&self, sh: &Sheet, c: CellRef) -> Rect {
-        Rect::from_min_max(pos2(self.x(sh, c.col), self.y(sh, c.row)), pos2(self.x_end(sh, c.col), self.y_end(sh, c.row)))
+        Rect::from_min_max(
+            pos2(self.x(sh, c.col), self.y(sh, c.row)),
+            pos2(self.x(sh, c.col) + sh.col_width(c.col) * self.z, self.y(sh, c.row) + sh.row_height(c.row) * self.z),
+        )
     }
     pub fn range_rect(&self, sh: &Sheet, r: RangeRef) -> Rect {
         let a = self.cell_rect(sh, r.start);

crates/ui-egui/src/grid/interact.rs

@@ -225,10 +225,10 @@ fn handle_draw_tool(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool {
                         ))
                     })
                     .collect();
-                // The line under the pointer is the ink the stroke will commit (#1786).
-                let theme = app.session.active().map(|d| d.wb.theme.clone()).unwrap_or_default();
-                let (color, width) = pen_ink(&app.session.draw_color, app.session.draw_width, &theme);
-                input.ui.painter().add(egui::epaint::PathShape::line(pts, egui::epaint::PathStroke::new(width * geo.z, color)));
+                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);
@@ -249,17 +249,6 @@ fn handle_draw_tool(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool {
     false
 }
 
-/// The colour and width (points) of the ink a pen stroke commits, as `draw.stroke` stores it (the
-/// pen's colour, pen blue by default; its width, 2 pt by default, kept to 0.5–40 pt and stored
-/// whole) and as Ink shapes paint it (a highlighter, over 8 pt, is translucent).
-pub(crate) fn pen_ink(color: &str, width: f32, theme: &gridcraft_engine::model::Theme) -> (Color32, f32) {
-    let pen_blue = gridcraft_engine::model::Color::rgb(0x1F, 0x5F, 0xC9);
-    let line = gridcraft_engine::model::Color::from_hex(color).unwrap_or(pen_blue);
-    let width = if width <= 0.0 { 2.0 } else { width }.clamp(0.5, 40.0).round().max(1.0);
-    let color = line.resolve(theme).map(crate::theme::color32).unwrap_or(Color32::from_rgb(0x1F, 0x5F, 0xC9));
-    (crate::chartview::ink_color(color, width), width)
-}
-
 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);
@@ -318,7 +307,6 @@ fn handle_column_header_press(app: &mut SheetApp, input: &InteractionInput<'_>,
             return;
         }
         if point_header(app, wb, sh, RangeRef::cols(c, c), mods.shift, mods.command) {
-            point_header_first_move(app, input);
             return;
         }
         // An armed Format Painter paints the columns dragged over instead of moving them.
@@ -349,7 +337,6 @@ fn handle_row_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, p:
         }
         let r = geo.row_at(sh, p.y);
         if point_header(app, wb, sh, RangeRef::rows(r, r), mods.shift, mods.command) {
-            point_header_first_move(app, input);
             return;
         }
         let range = if mods.shift { RangeRef::rows(sel.anchor.row.min(r), sel.anchor.row.max(r)) } else { RangeRef::rows(r, r) };
@@ -625,10 +612,6 @@ fn handle_dragging(app: &mut SheetApp, input: &InteractionInput<'_>) {
                     app.session.run("selection.set", json!({"range": RangeRef::cols(anchor.min(c), anchor.max(c)).a1(), "active": sel.active.a1()}));
                 scroll_by(app, vec2(auto.x, 0.0));
             }
-            drag @ (Drag::PointRows(_) | Drag::PointCols(_)) => {
-                point_header_to(app, geo, sh, wb, &drag, p);
-                scroll_by(app, if matches!(drag, Drag::PointRows(_)) { vec2(0.0, auto.y) } else { vec2(auto.x, 0.0) });
-            }
             Drag::MoveCols { source, .. } => {
                 let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0));
                 let midpoint = geo.x(sh, col) + sh.col_width(col) * geo.z * 0.5;
@@ -705,14 +688,6 @@ fn handle_release(app: &mut SheetApp, input: &InteractionInput<'_>) {
             }
             // Whole rows or columns clicked or dragged over by their headers.
             Drag::Rows(_) | Drag::Cols(_) => format_painter_apply(app),
-            // The release may be the first frame to report the pointer's last position.
-            drag @ (Drag::PointRows(_) | Drag::PointCols(_)) => {
-                if resp.drag_stopped()
-                    && let Some(p) = pos
-                {
-                    point_header_to(app, geo, sh, wb, &drag, p);
-                }
-            }
             // Esc mid-drag lands here too (egui ends the drag on Esc): no menu, and the key is
             // spent on the drag so the grid's Esc doesn't also drop the copy.
             Drag::Fill { target: Some(t), menu: true } => {
@@ -744,9 +719,9 @@ fn handle_release(app: &mut SheetApp, input: &InteractionInput<'_>) {
             }
             Drag::Move { to: Some(to), .. } => {
                 let src = sel.current();
-                // Dropping on cells that hold data asks first, as in Excel.
                 if to != src.start {
-                    crate::macro_ui::call(app, "GridCraft", "range.move", json!({"range": src.a1(), "to": to.a1()}));
+                    let _ = app.session.run("edit.cut", json!({"range": src.a1()}));
+                    let _ = app.run("edit.paste", json!({"at": to.a1()}));
                 }
             }
             Drag::MoveCols { source, before: Some(before) } => {
@@ -776,13 +751,11 @@ fn format_painter_apply(app: &mut SheetApp) {
     }
 }
 
-/// Point mode on a header: inserts a whole-row or whole-column reference instead of selecting,
-/// and dragging on from there extends it.
+/// Point mode on a header: inserts a whole-row or whole-column reference instead of selecting.
 fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, extend: bool, add: bool) -> bool {
     let Some(ed) = app.editor.as_mut().filter(|ed| ed.can_point()) else { return false };
     let edit_sheet = ed.sheet;
     let active_sheet = wb.active_sheet();
-    let pressed = range;
     let range = if extend {
         ed.point
             .and_then(|point| crate::editor::formula_refs(&ed.text).into_iter().find(|(start, end, ..)| (*start, *end) == point))
@@ -803,7 +776,9 @@ fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef,
     } else {
         range
     };
-    let reference = header_reference(ed, wb, sh, range);
+    let reference = range.a1();
+    let reference =
+        if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference };
     if add {
         ed.append_ref(&reference);
     } else {
@@ -812,53 +787,9 @@ fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef,
     ed.point_anchor = None;
     ed.point_cell = Some(range.start);
     ed.request_focus = true;
-    // The drag keeps the end of the reference the press didn't land on.
-    app.grid.drag = if range.is_full_cols() {
-        Drag::PointCols(if range.start.col == pressed.start.col { range.end.col } else { range.start.col })
-    } else {
-        Drag::PointRows(if range.start.row == pressed.start.row { range.end.row } else { range.start.row })
-    };
     true
 }
 
-fn header_reference(ed: &EditState, wb: &Workbook, sh: &Sheet, range: RangeRef) -> String {
-    let reference = range.a1();
-    if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference }
-}
-
-/// The frame that starts a drag reports no `dragged()`, so its movement is applied here.
-fn point_header_first_move(app: &mut SheetApp, input: &InteractionInput<'_>) {
-    if input.response.drag_started()
-        && let Some(p) = input.position
-    {
-        let drag = app.grid.drag.clone();
-        point_header_to(app, input.geo, input.sheet, input.workbook, &drag, p);
-    }
-}
-
-/// Point mode dragged over the headers: the pointed reference runs from the anchor to the pointer.
-fn point_header_to(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, drag: &Drag, p: Pos2) {
-    // The pointer's end moves with Shift+arrow next; the opposite corner keeps it a whole column or row.
-    let (range, pointer, opposite) = match *drag {
-        Drag::PointCols(anchor) => {
-            let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0));
-            let range = RangeRef::cols(anchor.min(col), anchor.max(col));
-            (range, CellRef::new(range.start.row, col), CellRef::new(range.end.row, anchor))
-        }
-        Drag::PointRows(anchor) => {
-            let row = geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0));
-            let range = RangeRef::rows(anchor.min(row), anchor.max(row));
-            (range, CellRef::new(row, range.start.col), CellRef::new(anchor, range.end.col))
-        }
-        _ => return,
-    };
-    let Some(ed) = app.editor.as_mut().filter(|ed| ed.point_at_caret()) else { return };
-    let reference = header_reference(ed, wb, sh, range);
-    ed.insert_ref(&reference);
-    ed.point_cell = Some(pointer);
-    ed.point_anchor = Some((wb.active_sheet(), opposite));
-}
-
 fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p: Pos2) {
     let cell = CellRef::new(
         geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)),
@@ -960,7 +891,7 @@ fn freeze_boundary(geo: &Geo, sh: &Sheet, p: Pos2, cols: bool) -> u32 {
             return 0;
         }
         let c = geo.col_at(sh, p.x);
-        let (l, r) = (geo.x(sh, c), geo.x_end(sh, c));
+        let (l, r) = (geo.x(sh, c), geo.x(sh, c.saturating_add(1).min(MAX_COLS - 1)));
         let b = if p.x - l > r - p.x { c.saturating_add(1) } else { c };
         let room = geo.ci.at((((geo.cells.width() - 40.0) / geo.z).max(0.0)) as f64);
         b.min(room).min(MAX_COLS - 1)
@@ -969,7 +900,7 @@ fn freeze_boundary(geo: &Geo, sh: &Sheet, p: Pos2, cols: bool) -> u32 {
             return 0;
         }
         let rr = geo.row_at(sh, p.y);
-        let (t, b2) = (geo.y(sh, rr), geo.y_end(sh, rr));
+        let (t, b2) = (geo.y(sh, rr), geo.y(sh, rr.saturating_add(1).min(MAX_ROWS - 1)));
         let b = if p.y - t > b2 - p.y { rr.saturating_add(1) } else { rr };
         let room = geo.ri.at((((geo.cells.height() - 40.0) / geo.z).max(0.0)) as f64);
         b.min(room).min(MAX_ROWS - 1)
@@ -1107,27 +1038,9 @@ pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, exte
         to
     };
     let text = if extend { RangeRef::new(anchor, to).a1() } else { to.a1() };
-    let text = if ed.sheet != d.wb.active_sheet() { format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&sheet.name)) } else { text };
     let sheet = d.wb.active_sheet();
     ed.insert_ref(&text);
     ed.point_cell = Some(to);
     ed.point_anchor = Some((sheet, anchor));
     app.grid.ensure_visible = true;
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn the_pen_preview_is_the_ink_the_stroke_commits() {
-        // #1786: the preview was always blue at 2 pt, whatever the pen.
-        let theme = gridcraft_engine::model::Theme::default();
-        assert_eq!(pen_ink("#C00000", 3.0, &theme), (Color32::from_rgb(0xC0, 0, 0), 3.0));
-        assert_eq!(pen_ink("", 0.0, &theme), (Color32::from_rgb(0x1F, 0x5F, 0xC9), 2.0), "no pen chosen yet: pen blue, 2 pt");
-        assert_eq!(pen_ink("not a colour", 0.2, &theme), (Color32::from_rgb(0x1F, 0x5F, 0xC9), 1.0));
-        // A highlighter is wide and translucent, as the committed ink is painted.
-        let (c, w) = pen_ink("#FFFF00", 12.0, &theme);
-        assert_eq!((c, w), (Color32::from_rgb(0xFF, 0xFF, 0).gamma_multiply(0.45), 12.0));
-    }
-}

crates/ui-egui/src/grid/keyboard.rs

@@ -51,9 +51,11 @@ pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Res
                 app.copy_to_clipboard(ctx, "edit.cut");
             }
             egui::Event::Paste(text) => app.paste_external(text),
-            // A picture with no text on the clipboard (a screenshot, a browser image) is pasted as
-            // a floating picture at the active cell, as Excel does.
-            egui::Event::PasteImage(image) => app.paste_color_image(&image),
+            // GridCraft has no image-clipboard pipeline and no cell-picture insert-from-clipboard
+            // command. Choosing to ignore `PasteImage` is explicit: inserting the bytes as a
+            // floating picture without a chosen anchor/size would be a new feature, not parity.
+            // A text representation, when the clipboard has one, still arrives as `Paste` above.
+            egui::Event::PasteImage(_) => {}
             // PRIMARY middle-click paste belongs to egui's TextEdit; the grid has no caret to
             // insert text at, so a middle click on a cell is deliberately not a paste.
             egui::Event::MiddleClickPaste { .. } => {}

crates/ui-egui/src/grid/menus.rs

@@ -129,9 +129,6 @@ pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
         egui::Frame::popup(ui.style()).show(ui, |ui| {
             ui.set_min_width(200.0);
             let insert_copied = insert_copied_item(app);
-            // On a cell with a link Excel offers to edit, open or remove it (#2120).
-            let link =
-                app.session.active().and_then(|d| d.wb.active().and_then(|sh| sh.hyperlinks.get(&d.selection.active)).map(|l| l.target.clone()));
             let mut items: Vec<(&str, &str)> = vec![
                 ("Cut", "edit.cut"),
                 ("Copy", "edit.copy"),
@@ -157,14 +154,6 @@ pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
             if let Some(item) = insert_copied {
                 items.insert(6, item);
             }
-            if link.is_some()
-                && let Some(i) = items.iter().position(|(_, id)| *id == "ui:insertLink")
-            {
-                items.splice(
-                    i..=i,
-                    [("Edit Hyperlink…", "ui:insertLink"), ("Open Hyperlink", "ui:openLink"), ("Remove Hyperlink", "edit.clearHyperlinks")],
-                );
-            }
             if show_details_offered(app)
                 && let Some(i) = items.iter().position(|(_, id)| *id == "data.sortDescending")
             {
@@ -189,11 +178,6 @@ pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) {
                         "ui:newNote" => app.open_dialog("comment", json!({"threaded": false})),
                         "ui:defineName" => app.open_dialog("defineName", json!({})),
                         "ui:insertLink" => app.open_dialog("insertLink", json!({})),
-                        "ui:openLink" => {
-                            if let Some(target) = &link {
-                                super::interact::follow_link(app, target);
-                            }
-                        }
                         "ui:pickList" => app.open_dialog("pickList", json!({})),
                         "ui:filterValue" => {
                             if let Some(d) = app.session.active() {

crates/ui-egui/src/grid/quadrant.rs

@@ -1,4 +1,3 @@
-use super::active_row::paint_active_row;
 use super::cell_paint::{
     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,
@@ -103,8 +102,6 @@ pub(crate) struct QuadrantPaint<'a> {
     pub(crate) cols: (u32, u32),
     pub(crate) cf: &'a mut CfCache,
     pub(crate) tokens: &'a Tokens,
-    /// The row to tint, when "Highlight the active cell's row" is on.
-    pub(crate) active_row: Option<u32>,
 }
 
 /// Paint a worksheet quadrant, including backgrounds, borders, and text.
@@ -121,8 +118,6 @@ pub(crate) fn paint_quadrant(mut quadrant: QuadrantPaint<'_>) {
     let cells = visible_cells(&quadrant);
     let looks = paint_backgrounds(&mut quadrant, &cells, &merges);
     let outside = outside_text_cells(&mut quadrant, &merges);
-    // Over the fills and under the text and borders.
-    paint_active_row(&quadrant, None);
     paint_cells(&mut quadrant, &looks, &outside, &merges);
     paint_borders(&mut quadrant, &looks, &merges);
     paint_sparklines(&quadrant, range);
@@ -147,17 +142,21 @@ fn paint_gridlines(q: &QuadrantPaint<'_>) {
     if sh.show_gridlines {
         let stroke = Stroke::new(1.0, t.gridline);
         let top = geo.y(sh, r0);
-        let bottom = geo.y_end(sh, r1);
+        let bottom = geo.y(sh, r1 + 1);
         let left = geo.x(sh, c0);
-        let right = geo.x_end(sh, c1);
-        let xs = (c0..=c1).filter(|&c| sh.col_width(c) > 0.0).map(|c| geo.x(sh, c)).chain([right]);
-        for x in xs {
-            let x = x.round() - 0.5;
+        let right = geo.x(sh, c1 + 1);
+        for c in c0..=c1 + 1 {
+            if c <= c1 && sh.col_width(c) == 0.0 {
+                continue;
+            }
+            let x = geo.x(sh, c).round() - 0.5;
             p.line_segment([pos2(x, top), pos2(x, bottom)], stroke);
         }
-        let ys = (r0..=r1).filter(|&r| sh.row_height(r) > 0.0).map(|r| geo.y(sh, r)).chain([bottom]);
-        for y in ys {
-            let y = y.round() - 0.5;
+        for r in r0..=r1 + 1 {
+            if r <= r1 && sh.row_height(r) == 0.0 {
+                continue;
+            }
+            let y = geo.y(sh, r).round() - 0.5;
             p.line_segment([pos2(left, y), pos2(right, y)], stroke);
         }
     }
@@ -225,6 +224,7 @@ fn outside_text_cells(q: &mut QuadrantPaint<'_>, merges: &[RangeRef]) -> Vec<(Ce
     // Text cells just outside the quadrant whose text may overflow into it: the nearest non-empty
     // cell left of `c0` and right of `c1` in each row (within the same frozen / scrolled pane).
     let mut outside: Vec<(CellRef, Rect, Look, Option<CfLook>)> = Vec::new();
+    let same_pane = |col: u32| (col < geo.fc) == (c0 < geo.fc);
     for r in r0..=r1 {
         if sh.row_height(r) == 0.0 {
             continue;
@@ -232,7 +232,7 @@ fn outside_text_cells(q: &mut QuadrantPaint<'_>, merges: &[RangeRef]) -> Vec<(Ce
         let left = (c0.saturating_sub(20)..c0).rev().map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n));
         let right = (c1.saturating_add(1)..=c1.saturating_add(20).min(MAX_COLS - 1)).map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n));
         for n in [left, right].into_iter().flatten() {
-            if geo.same_col_pane(n.col, c0) && sh.col_width(n.col) > 0.0 && in_merge(n).is_none() {
+            if same_pane(n.col) && sh.col_width(n.col) > 0.0 && in_merge(n).is_none() {
                 let (lk, cfl) = look(wb, si, sh, n, cf);
                 outside.push((n, geo.cell_rect(sh, n), lk, cfl));
             }
@@ -278,9 +278,6 @@ fn paint_cell_decorations(q: &QuadrantPaint<'_>, c: CellRef, rect: Rect, lk: &Lo
     false
 }
 
-/// Most repeats of a fill character laid out in one cell.
-const MAX_FILL_REPEATS: usize = 8192;
-
 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);
@@ -336,9 +333,7 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option<CfLo
     let z = geo.z;
     let (c0, c1) = q.cols;
     let in_merge = |cell| merges.iter().find(|m| m.contains(cell)).copied();
-    // Text overflows only into empty cells of its own pane: the frozen and scrolled columns move
-    // apart when scrolling (#2544).
-    let empty_ok = |cell: CellRef| geo.same_col_pane(cell.col, c.col) && sh.value_ref(cell).is_none_or(Value::is_empty) && in_merge(cell).is_none();
+    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;
     }
@@ -435,8 +430,7 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option<CfLo
     {
         let base_w = w;
         let cw = p.layout_no_wrap(ch.to_string(), font.clone(), color).size().x.max(1.0);
-        // A merged cell's width counts offscreen columns: no screen shows more repeats than this.
-        let n = ((((avail_w - 2.0 * pad) - base_w) / cw).floor().max(0.0) as usize).min(MAX_FILL_REPEATS);
+        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));
@@ -460,12 +454,12 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option<CfLo
         let mut right = rect.right();
         let mut left = rect.left();
         if across_end > c.col {
-            right = geo.x_end(sh, across_end);
+            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_end(sh, cc);
+                right = geo.x(sh, cc + 1);
                 cc += 1;
             }
         }
@@ -484,11 +478,9 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option<CfLo
             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);
-                paint_active_row(q, Some(extra_l));
             }
             if extra_r.width() > 0.0 {
                 p.rect_filled(extra_r, 0.0, t.grid_bg);
-                paint_active_row(q, Some(extra_r));
             }
         }
     }

crates/ui-egui/src/grid/show.rs

@@ -20,7 +20,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
     let available = ui.available_rect_before_wrap();
     // A right-to-left sheet has its vertical scrollbar on the left.
     let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left);
-    let bar = vertical_bar_width(app, available);
+    let bar = 14.0_f32.min(available.width());
     let rect = if rtl {
         Rect::from_min_max(pos2(available.left() + bar, available.top()), available.max)
     } else {
@@ -213,12 +213,6 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) {
     update_clipboard_repaint(app, ui, now);
 }
 
-/// The vertical scroll bar's width: none when the workbook hides it (File › Options ›
-/// Display options for this workbook), and the grid takes its room.
-fn vertical_bar_width(app: &SheetApp, available: Rect) -> f32 {
-    if app.session.active().is_none_or(|d| d.wb.view.show_vertical_scroll) { 14.0_f32.min(available.width()) } else { 0.0 }
-}
-
 fn vertical_scroll_track(available: Rect, grid: Rect, rtl: bool) -> (f32, f32) {
     if rtl { (available.left(), grid.left()) } else { (grid.right(), available.right()) }
 }
@@ -410,19 +404,7 @@ fn paint_panes(input: PanesInput<'_>, cf: &mut CfCache) -> Vec<PaneQuad> {
             continue;
         }
         let p = painter.with_clip_rect(*clip);
-        let active_row = app.ui.highlight_active_row.then_some(sel.active.row);
-        paint_quadrant(QuadrantPaint {
-            painter: &p,
-            geo,
-            workbook: wb,
-            sheet_index: si,
-            sheet: sh,
-            rows: *rows,
-            cols: *cols,
-            cf,
-            tokens: t,
-            active_row,
-        });
+        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.
@@ -438,10 +420,6 @@ fn paint_panes(input: PanesInput<'_>, cf: &mut CfCache) -> Vec<PaneQuad> {
 /// The worksheet is painted virtually, so it needs its own scrollbar rather than a
 /// ScrollArea containing all million rows. Keep the scroll extent stable during a drag.
 fn vertical_scrollbar(app: &mut SheetApp, ui: &mut egui::Ui, sh: &Sheet, geo: &Geo, track_x: (f32, f32), limit: f32, t: &Tokens) {
-    // A workbook that hides its vertical scroll bar leaves it no width.
-    if track_x.1 <= track_x.0 {
-        return;
-    }
     let track = Rect::from_min_max(pos2(track_x.0, geo.cells.top() + geo.frozen_h), pos2(track_x.1, geo.cells.bottom()));
     if track.height() <= 0.0 || track.width() <= 0.0 {
         return;

crates/ui-egui/src/i18n/cs.rs

@@ -335,16 +335,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "Obecné",
         "Options|Save" => "Uložit",
         "Show formula bar" => "Zobrazit řádek vzorců",
-        "Highlight the active cell's row" => "Zvýraznit řádek aktivní buňky",
-        "Display options for this workbook" => "Možnosti zobrazení pro tento sešit",
-        "Show horizontal scroll bar" => "Zobrazit vodorovný posuvník",
-        "Show vertical scroll bar" => "Zobrazit svislý posuvník",
-        "Show sheet tabs" => "Zobrazit karty listů",
-        "Edit Hyperlink…" => "Upravit hypertextový odkaz…",
-        "Edit Hyperlink" => "Upravit hypertextový odkaz",
-        "Open Hyperlink" => "Otevřít hypertextový odkaz",
-        "Remove Hyperlink" => "Odebrat hypertextový odkaz",
-        "Resize formula bar" => "Změnit velikost řádku vzorců",
         "Enable AutoComplete for cell values" => "Povolit automatické dokončování hodnot buněk",
         "Save .xlsx workbooks automatically after every change" => "Automaticky ukládat sešity .xlsx po každé změně",
         "Workbook calculation" => "Výpočet sešitu",

crates/ui-egui/src/i18n/de.rs

@@ -350,16 +350,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "Allgemein",
         "Options|Save" => "Speichern",
         "Show formula bar" => "Bearbeitungsleiste anzeigen",
-        "Highlight the active cell's row" => "Zeile der aktiven Zelle hervorheben",
-        "Display options for this workbook" => "Optionen für die Anzeige dieser Arbeitsmappe",
-        "Show horizontal scroll bar" => "Horizontale Bildlaufleiste anzeigen",
-        "Show vertical scroll bar" => "Vertikale Bildlaufleiste anzeigen",
-        "Show sheet tabs" => "Blattregisterkarten anzeigen",
-        "Edit Hyperlink…" => "Link bearbeiten…",
-        "Edit Hyperlink" => "Link bearbeiten",
-        "Open Hyperlink" => "Link öffnen",
-        "Remove Hyperlink" => "Link entfernen",
-        "Resize formula bar" => "Größe der Bearbeitungsleiste ändern",
         "Enable AutoComplete for cell values" => "AutoVervollständigen für Zellwerte aktivieren",
         "Save .xlsx workbooks automatically after every change" => ".xlsx-Arbeitsmappen nach jeder Änderung automatisch speichern",
         "Workbook calculation" => "Arbeitsmappenberechnung",

crates/ui-egui/src/i18n/es.rs

@@ -337,16 +337,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "General",
         "Options|Save" => "Guardar",
         "Show formula bar" => "Mostrar barra de fórmulas",
-        "Highlight the active cell's row" => "Resaltar la fila de la celda activa",
-        "Display options for this workbook" => "Opciones de presentación para este libro",
-        "Show horizontal scroll bar" => "Mostrar barra de desplazamiento horizontal",
-        "Show vertical scroll bar" => "Mostrar barra de desplazamiento vertical",
-        "Show sheet tabs" => "Mostrar pestañas de hojas",
-        "Edit Hyperlink…" => "Modificar hipervínculo…",
-        "Edit Hyperlink" => "Modificar hipervínculo",
-        "Open Hyperlink" => "Abrir hipervínculo",
-        "Remove Hyperlink" => "Quitar hipervínculo",
-        "Resize formula bar" => "Cambiar el tamaño de la barra de fórmulas",
         "Enable AutoComplete for cell values" => "Habilitar Autocompletar para valores de celda",
         "Save .xlsx workbooks automatically after every change" => "Guardar automáticamente los libros .xlsx tras cada cambio",
         "Workbook calculation" => "Cálculo del libro",

crates/ui-egui/src/i18n/it.rs

@@ -410,7 +410,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|Save" => "Salvataggio",
         "Options|Editing" => "Modifica",
         "Show formula bar" => "Mostra barra della formula",
-        "Highlight the active cell's row" => "Evidenzia la riga della cella attiva",
         "Enable AutoComplete for cell values" => "Abilita Completamento automatico per i valori delle celle",
         "Save .xlsx workbooks automatically after every change" => "Salva automaticamente le cartelle di lavoro .xlsx dopo ogni modifica",
         "Workbook calculation" => "Calcolo della cartella di lavoro",

crates/ui-egui/src/i18n/ko.rs

@@ -426,16 +426,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "일반",
         "Options|Save" => "저장",
         "Show formula bar" => "수식 입력줄 표시",
-        "Highlight the active cell's row" => "활성 셀의 행 강조 표시",
-        "Display options for this workbook" => "이 통합 문서의 표시 옵션",
-        "Show horizontal scroll bar" => "가로 스크롤 막대 표시",
-        "Show vertical scroll bar" => "세로 스크롤 막대 표시",
-        "Show sheet tabs" => "시트 탭 표시",
-        "Edit Hyperlink…" => "하이퍼링크 편집…",
-        "Edit Hyperlink" => "하이퍼링크 편집",
-        "Open Hyperlink" => "하이퍼링크 열기",
-        "Remove Hyperlink" => "하이퍼링크 제거",
-        "Resize formula bar" => "수식 입력줄 크기 조정",
         "Enable AutoComplete for cell values" => "셀 값에 자동 완성 사용",
         "Save .xlsx workbooks automatically after every change" => "변경할 때마다 .xlsx 통합 문서를 자동으로 저장",
         "Workbook calculation" => "통합 문서 계산",

crates/ui-egui/src/i18n/pt.rs

@@ -416,16 +416,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "Geral",
         "Options|Save" => "Salvar",
         "Show formula bar" => "Mostrar barra de fórmulas",
-        "Highlight the active cell's row" => "Realçar a linha da célula ativa",
-        "Display options for this workbook" => "Opções de exibição para esta pasta de trabalho",
-        "Show horizontal scroll bar" => "Mostrar barra de rolagem horizontal",
-        "Show vertical scroll bar" => "Mostrar barra de rolagem vertical",
-        "Show sheet tabs" => "Mostrar guias de planilhas",
-        "Edit Hyperlink…" => "Editar hiperlink…",
-        "Edit Hyperlink" => "Editar hiperlink",
-        "Open Hyperlink" => "Abrir hiperlink",
-        "Remove Hyperlink" => "Remover hiperlink",
-        "Resize formula bar" => "Redimensionar a barra de fórmulas",
         "Enable AutoComplete for cell values" => "Habilitar AutoConclusão para valores de célula",
         "Save .xlsx workbooks automatically after every change" => "Salvar pastas de trabalho .xlsx automaticamente após cada alteração",
         "Workbook calculation" => "Cálculo da pasta de trabalho",

crates/ui-egui/src/i18n/ru.rs

@@ -426,16 +426,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "Общие",
         "Options|Save" => "Сохранение",
         "Show formula bar" => "Показывать строку формул",
-        "Highlight the active cell's row" => "Выделять строку активной ячейки",
-        "Display options for this workbook" => "Параметры отображения для этой книги",
-        "Show horizontal scroll bar" => "Показывать горизонтальную полосу прокрутки",
-        "Show vertical scroll bar" => "Показывать вертикальную полосу прокрутки",
-        "Show sheet tabs" => "Показывать ярлычки листов",
-        "Edit Hyperlink…" => "Изменить гиперссылку…",
-        "Edit Hyperlink" => "Изменить гиперссылку",
-        "Open Hyperlink" => "Открыть гиперссылку",
-        "Remove Hyperlink" => "Удалить гиперссылку",
-        "Resize formula bar" => "Изменить размер строки формул",
         "Enable AutoComplete for cell values" => "Включить автозавершение значений ячеек",
         "Save .xlsx workbooks automatically after every change" => "Автоматически сохранять книги .xlsx после каждого изменения",
         "Workbook calculation" => "Вычисления в книге",

crates/ui-egui/src/i18n/zh.rs

@@ -418,16 +418,6 @@ pub(super) fn translate(text: &str) -> Option<&'static str> {
         "Options|General" => "常规",
         "Options|Save" => "保存",
         "Show formula bar" => "显示编辑栏",
-        "Highlight the active cell's row" => "突出显示活动单元格所在行",
-        "Display options for this workbook" => "此工作簿的显示选项",
-        "Show horizontal scroll bar" => "显示水平滚动条",
-        "Show vertical scroll bar" => "显示垂直滚动条",
-        "Show sheet tabs" => "显示工作表标签",
-        "Edit Hyperlink…" => "编辑超链接…",
-        "Edit Hyperlink" => "编辑超链接",
-        "Open Hyperlink" => "打开超链接",
-        "Remove Hyperlink" => "删除超链接",
-        "Resize formula bar" => "调整编辑栏大小",
         "Enable AutoComplete for cell values" => "为单元格值启用记忆式键入",
         "Save .xlsx workbooks automatically after every change" => "每次更改后自动保存 .xlsx 工作簿",
         "Workbook calculation" => "工作簿计算",

crates/ui-egui/src/keymap.rs

@@ -115,8 +115,6 @@ fn lookup_number_formats(ctx: LookupContext) -> Option<Shortcut> {
         Num7 if ctrl && s => borders("outside"),
         Minus if ctrl && s => borders("none"),
         Num8 if ctrl && s => run("selection.currentRegion"),
-        // Ctrl+. (Control on a Mac too): Next Corner of Selection.
-        Period if ctrl && !s => run("selection.nextCorner"),
         Semicolon if ctrl && s => Shortcut::Time,
         Quote if ctrl && s => Shortcut::ValueAbove,
         Quote if ctrl => Shortcut::FormulaAbove,

crates/ui-egui/src/keytips/keytip_table.rs

@@ -48,13 +48,6 @@ pub fn is_group_level(seq: &str) -> bool {
     matches!(lookup(seq), Some(Entry::Continue)) || (lookup(seq).is_none() && has_deeper(seq))
 }
 
-/// False under a legacy Excel 2003 menu letter that has no ribbon tab (Alt+I, D, V, T): Excel
-/// paints no badges for those, so the ribbon stays as it is while the sequence is typed.
-pub fn paints_badges(prefix: &str) -> bool {
-    let Some(root) = prefix.get(..1) else { return true };
-    SEQUENCES.iter().any(|(seq, entry)| matches!(entry, Entry::Tab(_)) && seq.starts_with(root))
-}
-
 fn matches_target(action: &Action, target: &str) -> bool {
     match action {
         Action::Command(id) | Action::CommandWith(id, _) | Action::Pending(id) | Action::Control(id) => *id == target,
@@ -221,22 +214,6 @@ mod tests {
         assert!(!has_deeper("X"));
     }
 
-    #[test]
-    fn legacy_menu_letters_finish_without_badges() {
-        assert_eq!(lookup("IR"), Some(Entry::Finish(Action::Command("home.insertRows"))));
-        assert_eq!(lookup("DS"), Some(Entry::Finish(Action::Dialog("sort"))));
-        assert_eq!(lookup("EAA"), Some(Entry::Finish(Action::Command("edit.clearAll"))));
-        for root in ["I", "D", "V", "T"] {
-            assert!(is_group_level(root), "{root} waits for the menu letter");
-            assert!(!paints_badges(root), "{root} has no tab, so no badges");
-        }
-        assert!(paints_badges(""), "tab badges");
-        assert!(paints_badges("HO"));
-        assert!(paints_badges("J"), "the Draw tab's two-letter unit");
-        assert!(paints_badges("E"), "E and O stay aliases of Home");
-        assert_eq!(sequences_for("home.insertRows"), vec!["HIR", "IR"], "the ribbon sequence stays first");
-    }
-
     #[test]
     fn group_extension_paints_only_continue_levels() {
         assert_eq!(group_extension("H", &["dialog:pasteSpecial"]), vec!["HV"]);

crates/ui-egui/src/keytips/keytip_table/generated.rs

@@ -372,48 +372,5 @@ pub const SEQUENCES: &[(&str, Entry)] = &[
     ("FN", Entry::Finish(Action::Command("file.new"))),    // Excel: New page; New page
     ("FO", Entry::Finish(Action::Command("file.open"))),   // Excel: Open page; fires immediately in Excel; deeper aliases dropped as unreachable
     ("FP", Entry::Finish(Action::Command("file.print"))),  // Excel: Print page; containment(Print)
-    ("IR", Entry::Finish(Action::Command("home.insertRows"))), // Excel: Insert > Rows; Legacy Excel 2003 menu path (#941).
-    ("IC", Entry::Finish(Action::Command("home.insertColumns"))), // Excel: Insert > Columns; Legacy Excel 2003 menu path (#941).
-    ("IE", Entry::Finish(Action::Dialog("insertCells"))),  // Excel: Insert > Cells; Legacy Excel 2003 menu path (#941).
-    ("IW", Entry::Finish(Action::Command("home.insertSheet"))), // Excel: Insert > Worksheet; Legacy Excel 2003 menu path (#941).
-    ("IF", Entry::Finish(Action::Dialog("insertFunction"))), // Excel: Insert > Function; Legacy Excel 2003 menu path (#941).
-    ("IND", Entry::Finish(Action::Dialog("defineName"))),  // Excel: Insert > Name > Define; Legacy Excel 2003 menu path (#941).
-    ("IS", Entry::Finish(Action::Control("insert.symbol"))), // Excel: Insert > Symbol; Legacy Excel 2003 menu path (#941).
-    ("ED", Entry::Finish(Action::Dialog("deleteCells"))),  // Excel: Edit > Delete; Legacy Excel 2003 menu path (#941).
-    ("EM", Entry::Finish(Action::Dialog("moveSheet"))),    // Excel: Edit > Move or Copy Sheet; Legacy Excel 2003 menu path (#941).
-    ("EL", Entry::Finish(Action::Command("home.deleteSheet"))), // Excel: Edit > Delete Sheet; Legacy Excel 2003 menu path (#941).
-    ("EAA", Entry::Finish(Action::Command("edit.clearAll"))), // Excel: Edit > Clear > All; Legacy Excel 2003 menu path (#941).
-    ("EAC", Entry::Finish(Action::Command("edit.clearContents"))), // Excel: Edit > Clear > Contents; Legacy Excel 2003 menu path (#941).
-    ("EAM", Entry::Finish(Action::Command("edit.clearComments"))), // Excel: Edit > Clear > Comments; Legacy Excel 2003 menu path (#941).
-    ("EF", Entry::Finish(Action::Dialog("find"))),         // Excel: Edit > Find; Legacy Excel 2003 menu path (#941).
-    ("EG", Entry::Finish(Action::Dialog("goTo"))),         // Excel: Edit > Go To; Legacy Excel 2003 menu path (#941).
-    ("ORA", Entry::Finish(Action::Command("home.autofitRowHeight"))), // Excel: Format > Row > AutoFit; Legacy Excel 2003 menu path (#941).
-    ("ORE", Entry::Finish(Action::Dialog("rowHeight"))),   // Excel: Format > Row > Height; Legacy Excel 2003 menu path (#941).
-    ("ORH", Entry::Finish(Action::Command("home.hideRows"))), // Excel: Format > Row > Hide; Legacy Excel 2003 menu path (#941).
-    ("ORU", Entry::Finish(Action::Command("home.unhideRows"))), // Excel: Format > Row > Unhide; Legacy Excel 2003 menu path (#941).
-    ("OCW", Entry::Finish(Action::Dialog("columnWidth"))), // Excel: Format > Column > Width; Legacy Excel 2003 menu path (#941).
-    ("OCH", Entry::Finish(Action::Command("home.hideColumns"))), // Excel: Format > Column > Hide; Legacy Excel 2003 menu path (#941).
-    ("OCU", Entry::Finish(Action::Command("home.unhideColumns"))), // Excel: Format > Column > Unhide; Legacy Excel 2003 menu path (#941).
-    ("OHR", Entry::Finish(Action::Dialog("renameSheet"))), // Excel: Format > Sheet > Rename; Legacy Excel 2003 menu path (#941).
-    ("OHH", Entry::Finish(Action::Command("sheet.hide"))), // Excel: Format > Sheet > Hide; Legacy Excel 2003 menu path (#941).
-    ("OHU", Entry::Finish(Action::Command("sheet.unhide"))), // Excel: Format > Sheet > Unhide; Legacy Excel 2003 menu path (#941).
-    ("OE", Entry::Finish(Action::Command("home.formatCells"))), // Excel: Format > Cells; Legacy Excel 2003 menu path (#941).
-    ("OD", Entry::Finish(Action::Command("home.conditionalFormat"))), // Excel: Format > Conditional Formatting; Legacy Excel 2003 menu path (#941).
-    ("DFF", Entry::Finish(Action::Command("data.filter"))), // Excel: Data > Filter > AutoFilter; Legacy Excel 2003 menu path (#941).
-    ("DS", Entry::Finish(Action::Dialog("sort"))),         // Excel: Data > Sort; Legacy Excel 2003 menu path (#941).
-    ("DGG", Entry::Finish(Action::Command("data.group"))), // Excel: Data > Group and Outline > Group; Legacy Excel 2003 menu path (#941).
-    ("DGU", Entry::Finish(Action::Command("data.ungroup"))), // Excel: Data > Group and Outline > Ungroup; Legacy Excel 2003 menu path (#941).
-    ("DGS", Entry::Finish(Action::Command("data.showDetail"))), // Excel: Data > Group and Outline > Show Detail; Legacy Excel 2003 menu path (#941).
-    ("DGH", Entry::Finish(Action::Command("data.hideDetail"))), // Excel: Data > Group and Outline > Hide Detail; Legacy Excel 2003 menu path (#941).
-    ("DL", Entry::Finish(Action::Command("data.validation"))), // Excel: Data > Validation; Legacy Excel 2003 menu path (#941).
-    ("DT", Entry::Finish(Action::Command("data.dataTable"))), // Excel: Data > Table (what-if data table); Legacy Excel 2003 menu path (#941).
-    ("VN", Entry::Finish(Action::Command("view.normal"))), // Excel: View > Normal; Legacy Excel 2003 menu path (#941).
-    ("VP", Entry::Finish(Action::Command("view.pageBreakPreview"))), // Excel: View > Page Break Preview; Legacy Excel 2003 menu path (#941).
-    ("VZ", Entry::Finish(Action::Dialog("zoom"))),         // Excel: View > Zoom; Legacy Excel 2003 menu path (#941).
-    ("TO", Entry::Finish(Action::Dialog("options"))),      // Excel: Tools > Options; Legacy Excel 2003 menu path (#941).
-    ("TUA", Entry::Finish(Action::Command("formulas.removeArrows"))), // Excel: Tools > Formula Auditing > Remove All Arrows; Legacy Excel 2003 menu path (#941).
-    ("TUD", Entry::Finish(Action::Command("formulas.traceDependents"))), // Excel: Tools > Formula Auditing > Trace Dependents; Legacy Excel 2003 menu path (#941).
-    ("TUT", Entry::Finish(Action::Command("formulas.tracePrecedents"))), // Excel: Tools > Formula Auditing > Trace Precedents; Legacy Excel 2003 menu path (#941).
-    ("FU", Entry::Finish(Action::Dialog("pageSetup"))),                  // Excel: File > Page Setup; Legacy Excel 2003 menu path (#941).
-    ("Q", Entry::Finish(Action::Pending("ui.search"))), // pending; Excel: Search / Tell Me; Alt+Q search box does not exist yet (issue #49)
+    ("Q", Entry::Finish(Action::Pending("ui.search"))),    // pending; Excel: Search / Tell Me; Alt+Q search box does not exist yet (issue #49)
 ];

crates/ui-egui/src/keytips/keytips.json

@@ -2582,307 +2582,6 @@
    "excel": "Print page",
    "note": "containment(Print)"
   },
-  {
-   "seq": "IR",
-   "kind": "command",
-   "target": "home.insertRows",
-   "excel": "Insert > Rows",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "IC",
-   "kind": "command",
-   "target": "home.insertColumns",
-   "excel": "Insert > Columns",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "IE",
-   "kind": "dialog",
-   "target": "insertCells",
-   "excel": "Insert > Cells",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "IW",
-   "kind": "command",
-   "target": "home.insertSheet",
-   "excel": "Insert > Worksheet",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "IF",
-   "kind": "dialog",
-   "target": "insertFunction",
-   "excel": "Insert > Function",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "IND",
-   "kind": "dialog",
-   "target": "defineName",
-   "excel": "Insert > Name > Define",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "IS",
-   "kind": "control",
-   "target": "insert.symbol",
-   "excel": "Insert > Symbol",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "ED",
-   "kind": "dialog",
-   "target": "deleteCells",
-   "excel": "Edit > Delete",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EM",
-   "kind": "dialog",
-   "target": "moveSheet",
-   "excel": "Edit > Move or Copy Sheet",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EL",
-   "kind": "command",
-   "target": "home.deleteSheet",
-   "excel": "Edit > Delete Sheet",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EAA",
-   "kind": "command",
-   "target": "edit.clearAll",
-   "excel": "Edit > Clear > All",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EAC",
-   "kind": "command",
-   "target": "edit.clearContents",
-   "excel": "Edit > Clear > Contents",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EAM",
-   "kind": "command",
-   "target": "edit.clearComments",
-   "excel": "Edit > Clear > Comments",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EF",
-   "kind": "dialog",
-   "target": "find",
-   "excel": "Edit > Find",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "EG",
-   "kind": "dialog",
-   "target": "goTo",
-   "excel": "Edit > Go To",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "ORA",
-   "kind": "command",
-   "target": "home.autofitRowHeight",
-   "excel": "Format > Row > AutoFit",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "ORE",
-   "kind": "dialog",
-   "target": "rowHeight",
-   "excel": "Format > Row > Height",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "ORH",
-   "kind": "command",
-   "target": "home.hideRows",
-   "excel": "Format > Row > Hide",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "ORU",
-   "kind": "command",
-   "target": "home.unhideRows",
-   "excel": "Format > Row > Unhide",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OCW",
-   "kind": "dialog",
-   "target": "columnWidth",
-   "excel": "Format > Column > Width",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OCH",
-   "kind": "command",
-   "target": "home.hideColumns",
-   "excel": "Format > Column > Hide",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OCU",
-   "kind": "command",
-   "target": "home.unhideColumns",
-   "excel": "Format > Column > Unhide",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OHR",
-   "kind": "dialog",
-   "target": "renameSheet",
-   "excel": "Format > Sheet > Rename",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OHH",
-   "kind": "command",
-   "target": "sheet.hide",
-   "excel": "Format > Sheet > Hide",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OHU",
-   "kind": "command",
-   "target": "sheet.unhide",
-   "excel": "Format > Sheet > Unhide",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OE",
-   "kind": "command",
-   "target": "home.formatCells",
-   "excel": "Format > Cells",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "OD",
-   "kind": "command",
-   "target": "home.conditionalFormat",
-   "excel": "Format > Conditional Formatting",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DFF",
-   "kind": "command",
-   "target": "data.filter",
-   "excel": "Data > Filter > AutoFilter",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DS",
-   "kind": "dialog",
-   "target": "sort",
-   "excel": "Data > Sort",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DGG",
-   "kind": "command",
-   "target": "data.group",
-   "excel": "Data > Group and Outline > Group",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DGU",
-   "kind": "command",
-   "target": "data.ungroup",
-   "excel": "Data > Group and Outline > Ungroup",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DGS",
-   "kind": "command",
-   "target": "data.showDetail",
-   "excel": "Data > Group and Outline > Show Detail",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DGH",
-   "kind": "command",
-   "target": "data.hideDetail",
-   "excel": "Data > Group and Outline > Hide Detail",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DL",
-   "kind": "command",
-   "target": "data.validation",
-   "excel": "Data > Validation",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "DT",
-   "kind": "command",
-   "target": "data.dataTable",
-   "excel": "Data > Table (what-if data table)",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "VN",
-   "kind": "command",
-   "target": "view.normal",
-   "excel": "View > Normal",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "VP",
-   "kind": "command",
-   "target": "view.pageBreakPreview",
-   "excel": "View > Page Break Preview",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "VZ",
-   "kind": "dialog",
-   "target": "zoom",
-   "excel": "View > Zoom",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "TO",
-   "kind": "dialog",
-   "target": "options",
-   "excel": "Tools > Options",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "TUA",
-   "kind": "command",
-   "target": "formulas.removeArrows",
-   "excel": "Tools > Formula Auditing > Remove All Arrows",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "TUD",
-   "kind": "command",
-   "target": "formulas.traceDependents",
-   "excel": "Tools > Formula Auditing > Trace Dependents",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "TUT",
-   "kind": "command",
-   "target": "formulas.tracePrecedents",
-   "excel": "Tools > Formula Auditing > Trace Precedents",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
-  {
-   "seq": "FU",
-   "kind": "dialog",
-   "target": "pageSetup",
-   "excel": "File > Page Setup",
-   "note": "Legacy Excel 2003 menu path (#941)."
-  },
   {
    "seq": "Q",
    "kind": "command",

crates/ui-egui/src/lib.rs

@@ -88,18 +88,12 @@ pub struct UiState {
     pub ribbon_tab: String,
     pub ribbon_collapsed: bool,
     pub formula_bar_expanded: bool,
-    /// Lines the expanded formula bar shows: the height its bottom edge was last dragged to.
-    /// Expanding it again (the chevron, Ctrl+Shift+U) returns to that height.
-    pub formula_bar_lines: usize,
     pub status_bar: bool,
     /// Motion in the UI: the selection outline glides to a new selection (View ▸ Animations).
     pub animations: bool,
     /// Enable AutoComplete for cell values (File ▸ Options ▸ Editing): typed text is completed
     /// from the one matching entry in the same column.
     pub autocomplete: bool,
-    /// Tint the active cell's whole row (File ▸ Options ▸ General), on every sheet and workbook, so
-    /// the eye keeps its place across a wide table. A preference: nothing goes into the file.
-    pub highlight_active_row: bool,
     /// AutoSave (the title-bar switch): save saved-to-file .xlsx workbooks shortly after every
     /// change. A preference like the rest of this struct — it stays on across restarts (#1901).
     pub autosave: bool,
@@ -108,10 +102,6 @@ pub struct UiState {
     /// [`keytips::Action::Control`], consumed (and cleared) by the control's render site.
     #[serde(skip)]
     pub keytip_invoke: Option<&'static str>,
-    /// A keytip control request for the next frame: its tab was switched to this frame, so its
-    /// control is drawn only then.
-    #[serde(skip)]
-    pub keytip_invoke_next: Option<&'static str>,
     /// Interface language. English by default (so tests and headless renders never depend on the
     /// host's locale); the desktop app starts from [`i18n::Language::system`] when `ui.json` has
     /// no usable language (see [`i18n::saved_language`]). An unknown saved value reads as English
@@ -147,15 +137,12 @@ impl Default for UiState {
             ribbon_tab: "Home".into(),
             ribbon_collapsed: false,
             formula_bar_expanded: false,
-            formula_bar_lines: formula_bar::MAX_LINES,
             status_bar: true,
             animations: true,
             autocomplete: true,
-            highlight_active_row: false,
             autosave: false,
             recent: vec![],
             keytip_invoke: None,
-            keytip_invoke_next: None,
             language: i18n::Language::En,
             interface_scale: 100,
         }

crates/ui-egui/src/macro_editor.rs

@@ -459,7 +459,10 @@ pub fn parse_refs(text: &str) -> Vec<(Option<String>, RangeRef)> {
     text.split(',')
         .filter_map(|part| {
             let part = part.trim();
-            let (sheet, body) = gridcraft_engine::core::split_sheet(part);
+            let (sheet, body) = match part.rsplit_once('!') {
+                Some((s, b)) => (Some(s.trim().trim_matches('\'').replace("''", "'")), b),
+                None => (None, part),
+            };
             RangeRef::parse(&body.replace('$', "")).map(|r| (sheet, r))
         })
         .take(500)
@@ -2396,15 +2399,6 @@ pub fn paint_overlay(p: &egui::Painter, geo: &crate::grid::Geo, sh: &gridcraft_e
 mod tests {
     use super::*;
 
-    #[test]
-    fn example_references_unquote_sheet_names_as_formulas_do() {
-        // #2012: one shared reading of `'Bob''s'!A1` and `'a!b'!A1`.
-        let refs = parse_refs("'Bob''s'!$A$1:$B$2, 'a!b'!C3, D4");
-        let sheets: Vec<Option<String>> = refs.iter().map(|(s, _)| s.clone()).collect();
-        assert_eq!(sheets, [Some("Bob's".to_string()), Some("a!b".to_string()), None]);
-        assert_eq!(refs.iter().map(|(_, r)| r.a1()).collect::<Vec<_>>(), ["A1:B2", "C3", "D4"]);
-    }
-
     #[test]
     fn an_edited_input_keeps_a_shape_a_macro_may_declare() {
         let range = NamedInput { rows: [2, 10], cols: [3, 3], header: true, col_types: vec![ColType::Number; 3], ..NamedInput::default() };

crates/ui-egui/src/paper_view.rs

@@ -162,26 +162,10 @@ pub(crate) fn paint_pages(input: PagePaintInput<'_>, cf: &mut CfCache) -> Vec<gr
         }
         painted += 1;
         let pc = p.with_clip_rect(clip);
-        let active_row = app.ui.highlight_active_row.then_some(sel.active.row);
-        grid::paint_quadrant(grid::QuadrantPaint {
-            painter: &pc,
-            geo,
-            workbook: wb,
-            sheet_index: si,
-            sheet: sh,
-            rows,
-            cols,
-            cf,
-            tokens: t,
-            active_row,
-        });
+        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));
-            // The fade would all but hide the active row's band: it goes on again.
-            if let Some(band) = active_row.and_then(|row| grid::active_row_band(geo, sh, row, rows, cols)) {
-                pc.rect_filled(band, 0.0, t.active_row);
-            }
             let size = (14.0 * geo.z / DISPLAY_SCALE).clamp(8.0, 22.0);
             pc.text(clip.center(), Align2::CENTER_CENTER, tr(app, "Click to add data"), theme::ui_font(size), Color32::from_gray(150));
         }

crates/ui-egui/src/ribbon/controls.rs

@@ -27,15 +27,7 @@ pub(super) fn act(app: &mut SheetApp, id: &str, params: serde_json::Value) {
 
 /// Keytips are painted, not focusable widgets: the grid retains keyboard focus.
 pub(super) fn keytip(app: &SheetApp, ui: &Ui, sequence: &str, at: egui::Pos2) {
-    let Some(rest) = app
-        .keytips
-        .prefix()
-        .filter(|prefix| keytip_table::paints_badges(prefix))
-        .and_then(|prefix| sequence.strip_prefix(prefix))
-        .filter(|s| !s.is_empty())
-    else {
-        return;
-    };
+    let Some(rest) = app.keytips.prefix().and_then(|prefix| sequence.strip_prefix(prefix)).filter(|s| !s.is_empty()) else { return };
     let t = Tokens::get(ui.ctx());
     let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("ribbon_keytips"))).with_clip_rect(ui.clip_rect());
     let text = painter.layout_no_wrap(rest.into(), theme::ui_bold(10.5), t.text);

crates/ui-egui/src/ribbon/home.rs

@@ -622,13 +622,10 @@ fn size_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) {
     let arrow_rect = Rect::from_min_max(egui::pos2(frame.right() - 16.0, frame.top() + 1.0), egui::pos2(frame.right() - 1.0, frame.bottom() - 1.0));
     let mut field_ui =
         ui.new_child(egui::UiBuilder::new().max_rect(text_rect.shrink2(vec2(6.0, 0.0))).layout(egui::Layout::left_to_right(egui::Align::Center)));
-    // The text edit is `interact_size.y` tall and puts its text at the top of that unless told
-    // otherwise: center it, on the Font name's baseline (#3155).
     let out = egui::TextEdit::singleline(&mut text)
         .id(field)
         .font(theme::ui_font(12.5))
         .frame(egui::Frame::NONE)
-        .align(egui::Align2::LEFT_CENTER)
         .desired_width(text_rect.width() - 12.0)
         .show(&mut field_ui);
     let resp = out.response;

crates/ui-egui/src/ribbon/insert.rs

@@ -213,9 +213,7 @@ pub(super) fn insert(app: &mut SheetApp, ui: &mut Ui) {
     });
     let sym = big_button(ui, Icon::Symbol, "Symbol", "Symbol", true);
     control_keytip(app, ui, &sym, "insert.symbol");
-    // Opened by its key tip too (Alt+I, S): the gallery picks the symbol, nothing is inserted before.
-    let forced = invoke(app, "insert.symbol");
-    egui::Popup::menu(&sym).open_memory(popup_command(forced, sym.clicked())).show(|ui| {
+    egui::Popup::menu(&sym).show(|ui| {
         ui.set_width(260.0);
         ui.horizontal_wrapped(|ui| {
             for ch in [

crates/ui-egui/src/services.rs

@@ -32,9 +32,6 @@ pub struct Services {
     /// gets it from egui's `Event::Paste`). `None` from the host, or no service (web), pastes
     /// GridCraft's own clipboard.
     pub paste_text: Option<Box<dyn FnMut() -> Option<String>>>,
-    /// Read the picture on the system clipboard for the ribbon and menu Paste commands when it
-    /// holds no text (Cmd/Ctrl+V gets it from egui's `Event::PasteImage`).
-    pub paste_image: Option<Box<dyn FnMut() -> Option<image::RgbaImage>>>,
     /// Web: deliver a file to the user (name, bytes).
     pub download: Option<Download>,
     /// Web: start an asynchronous file pick; the bytes arrive later in `inbox`.

crates/ui-egui/src/tabs.rs

@@ -100,40 +100,29 @@ fn tab_split_handle(app: &mut SheetApp, ui: &mut Ui, split: Rect, bar: (f32, f32
 /// Draws the worksheet tab strip: navigation, scroll/reveal, rename/drag/move with optional copy, context menu, new-sheet button, split handle and grid scrollbar.
 pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
-    // Only the controls drawn this frame have a rectangle: a hidden one keeps no stale geometry.
-    app.grid.hscroll = None;
-    app.grid.tab_split = None;
-    // File › Options › Advanced › Display options for this workbook (#3101): with neither the
-    // sheet tabs nor the horizontal scroll bar, the bar isn't there at all.
-    let view = app.session.active().map(|d| d.wb.view).unwrap_or_default();
-    if !view.show_sheet_tabs && !view.show_horizontal_scroll {
-        return;
-    }
     egui::Panel::bottom("sheet_tabs").exact_size(32.0).frame(egui::Frame::NONE.fill(t.tab_bar)).show(ui, |ui| {
         let rect = ui.max_rect();
         ui.painter().line_segment([rect.left_top(), rect.right_top()], Stroke::new(1.0, t.ribbon_border));
         ui.horizontal_centered(|ui| {
             ui.spacing_mut().item_spacing.x = 0.0;
             ui.add_space(8.0);
-            if view.show_sheet_tabs {
-                if crate::widgets::icon_button(ui, Icon::Left, t.text_dim, app.ui.language.tr("Previous sheet"), vec2(24.0, 24.0)).clicked() {
-                    app.run_or_alert("sheet.previous", json!({}));
-                }
-                if crate::widgets::icon_button(ui, Icon::Right, t.text_dim, app.ui.language.tr("Next sheet"), vec2(24.0, 24.0)).clicked() {
-                    app.run_or_alert("sheet.next", json!({}));
-                }
-                let all = crate::widgets::icon_button(ui, Icon::SheetList, t.text_dim, app.ui.language.tr("All sheets"), vec2(24.0, 24.0));
-                all.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, app.ui.language.tr("All sheets")));
-                let items = app.session.active().map(|d| navigator_items(&d.wb.sheets)).unwrap_or_default();
-                let active = app.session.active().map(|d| d.wb.active_sheet().to_string()).unwrap_or_default();
-                let rows: Vec<(&str, String)> = items.iter().map(|(i, name)| (i.as_str(), name.clone())).collect();
-                if let crate::ribbon::ComboResult::Picked(i) = crate::ribbon::editable_combo(ui, &all, "sheet_navigator", &active, &rows, false)
-                    && let Ok(i) = i.parse::<usize>()
-                {
-                    activate_sheet(app, i);
-                }
-                ui.add_space(8.0);
+            if crate::widgets::icon_button(ui, Icon::Left, t.text_dim, app.ui.language.tr("Previous sheet"), vec2(24.0, 24.0)).clicked() {
+                app.run_or_alert("sheet.previous", json!({}));
             }
+            if crate::widgets::icon_button(ui, Icon::Right, t.text_dim, app.ui.language.tr("Next sheet"), vec2(24.0, 24.0)).clicked() {
+                app.run_or_alert("sheet.next", json!({}));
+            }
+            let all = crate::widgets::icon_button(ui, Icon::SheetList, t.text_dim, app.ui.language.tr("All sheets"), vec2(24.0, 24.0));
+            all.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, app.ui.language.tr("All sheets")));
+            let items = app.session.active().map(|d| navigator_items(&d.wb.sheets)).unwrap_or_default();
+            let active = app.session.active().map(|d| d.wb.active_sheet().to_string()).unwrap_or_default();
+            let rows: Vec<(&str, String)> = items.iter().map(|(i, name)| (i.as_str(), name.clone())).collect();
+            if let crate::ribbon::ComboResult::Picked(i) = crate::ribbon::editable_combo(ui, &all, "sheet_navigator", &active, &rows, false)
+                && let Ok(i) = i.parse::<usize>()
+            {
+                activate_sheet(app, i);
+            }
+            ui.add_space(8.0);
             let Some(d) = app.session.active() else { return };
             let (bar_left, bar_width) = (ui.cursor().left(), ui.available_width());
             let uid = d.uid;
@@ -154,8 +143,6 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
             // After the handle at the scrollbar's left edge is dragged, the tabs and New sheet
             // take the share it was dragged to.
             let tabs_width = match share {
-                // Without the scroll bar the tabs have the whole bar.
-                _ if !view.show_horizontal_scroll => (bar_width - NEW_SHEET_WIDTH).max(0.0),
                 Some(share) => (bar_width * share - NEW_SHEET_WIDTH).max(0.0),
                 None => (bar_width * 0.6).max(100.0),
             };
@@ -168,159 +155,154 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
                 data.insert_temp(reveal_id, reveal_key);
                 changed
             });
-            if view.show_sheet_tabs {
-                ui.allocate_ui_with_layout(vec2(tabs_width, 30.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
-                    // Translate vertical wheel movement into horizontal
-                    // worksheet-tab scrolling.
-                    let wheel_scroll = if ui.rect_contains_pointer(ui.max_rect()) {
-                        ui.input(|i| {
-                            let d = i.smooth_scroll_delta;
-                            if d.x.abs() > d.y.abs() { d.x } else { d.y }
-                        })
-                    } else {
-                        0.0
-                    };
+            ui.allocate_ui_with_layout(vec2(tabs_width, 30.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                // Translate vertical wheel movement into horizontal
+                // worksheet-tab scrolling.
+                let wheel_scroll = if ui.rect_contains_pointer(ui.max_rect()) {
+                    ui.input(|i| {
+                        let d = i.smooth_scroll_delta;
+                        if d.x.abs() > d.y.abs() { d.x } else { d.y }
+                    })
+                } else {
+                    0.0
+                };
 
-                    egui::ScrollArea::horizontal()
-                        .id_salt("worksheet_tabs_horizontal")
-                        .auto_shrink([true, false])
-                        .min_scrolled_width(0.0)
-                        .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysHidden)
-                        .show(ui, |ui| {
-                            if wheel_scroll.abs() > 0.0 {
-                                ui.scroll_with_delta(vec2(wheel_scroll, 0.0));
-                            }
-                            ui.horizontal(|ui| {
-                                ui.spacing_mut().item_spacing.x = 0.0;
-                                for (i, name, color, active) in sheets {
-                                    let renaming = app.grid.renaming_tab == Some(i);
-                                    let font = if active { theme::ui_bold(13.0) } else { theme::ui_font(13.0) };
-                                    let tw = ui.painter().layout_no_wrap(name.clone(), font.clone(), t.text).size().x;
-                                    let w = (tw + 32.0).max(72.0);
-                                    let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click_and_drag());
-                                    if active && reveal_active {
-                                        resp.scroll_to_me(None);
+                egui::ScrollArea::horizontal()
+                    .id_salt("worksheet_tabs_horizontal")
+                    .auto_shrink([true, false])
+                    .min_scrolled_width(0.0)
+                    .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysHidden)
+                    .show(ui, |ui| {
+                        if wheel_scroll.abs() > 0.0 {
+                            ui.scroll_with_delta(vec2(wheel_scroll, 0.0));
+                        }
+                        ui.horizontal(|ui| {
+                            ui.spacing_mut().item_spacing.x = 0.0;
+                            for (i, name, color, active) in sheets {
+                                let renaming = app.grid.renaming_tab == Some(i);
+                                let font = if active { theme::ui_bold(13.0) } else { theme::ui_font(13.0) };
+                                let tw = ui.painter().layout_no_wrap(name.clone(), font.clone(), t.text).size().x;
+                                let w = (tw + 32.0).max(72.0);
+                                let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click_and_drag());
+                                if active && reveal_active {
+                                    resp.scroll_to_me(None);
+                                }
+                                let r = r.shrink2(vec2(0.0, 1.0));
+                                if active {
+                                    ui.painter().rect_filled(Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max), 4.0, t.tab_active);
+                                    ui.painter().rect_stroke(
+                                        Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max),
+                                        4.0,
+                                        Stroke::new(1.0, t.ribbon_border),
+                                        StrokeKind::Inside,
+                                    );
+                                } else if resp.hovered() {
+                                    ui.painter().rect_filled(r, 4.0, t.hover);
+                                }
+                                if let Some(c) = color {
+                                    let band = Rect::from_min_size(pos2(r.left() + 6.0, r.bottom() - 4.0), vec2(r.width() - 12.0, 3.0));
+                                    ui.painter().rect_filled(band, 1.0, theme::color32(c));
+                                } else if active {
+                                    let band = Rect::from_center_size(pos2(r.center().x, r.bottom() - 3.0), vec2(tw.min(48.0), 2.5));
+                                    ui.painter().rect_filled(band, 1.0, t.accent);
+                                }
+                                if renaming {
+                                    let mut text = app.grid.rename_text.clone();
+                                    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(6.0, 5.0))));
+                                    let ed = child
+                                        .add(egui::TextEdit::singleline(&mut text).font(theme::ui_font(13.0)).desired_width(r.width() - 12.0))
+                                        .accessible_name(app.ui.language.tr("Sheet Name"));
+                                    app.grid.rename_text = text.clone();
+                                    if rename_needs_focus(ed.has_focus(), ed.lost_focus()) {
+                                        ed.request_focus();
                                     }
-                                    let r = r.shrink2(vec2(0.0, 1.0));
-                                    if active {
-                                        ui.painter().rect_filled(Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max), 4.0, t.tab_active);
-                                        ui.painter().rect_stroke(
-                                            Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max),
-                                            4.0,
-                                            Stroke::new(1.0, t.ribbon_border),
-                                            StrokeKind::Inside,
-                                        );
-                                    } else if resp.hovered() {
-                                        ui.painter().rect_filled(r, 4.0, t.hover);
-                                    }
-                                    if let Some(c) = color {
-                                        let band = Rect::from_min_size(pos2(r.left() + 6.0, r.bottom() - 4.0), vec2(r.width() - 12.0, 3.0));
-                                        ui.painter().rect_filled(band, 1.0, theme::color32(c));
-                                    } else if active {
-                                        let band = Rect::from_center_size(pos2(r.center().x, r.bottom() - 3.0), vec2(tw.min(48.0), 2.5));
-                                        ui.painter().rect_filled(band, 1.0, t.accent);
-                                    }
-                                    if renaming {
-                                        let mut text = app.grid.rename_text.clone();
-                                        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(6.0, 5.0))));
-                                        let ed = child
-                                            .add(egui::TextEdit::singleline(&mut text).font(theme::ui_font(13.0)).desired_width(r.width() - 12.0))
-                                            .accessible_name(app.ui.language.tr("Sheet Name"));
-                                        app.grid.rename_text = text.clone();
-                                        if rename_needs_focus(ed.has_focus(), ed.lost_focus()) {
-                                            ed.request_focus();
+                                    if ed.lost_focus() {
+                                        if !ui.input(|i| i.key_pressed(egui::Key::Escape)) && text != name {
+                                            app.run_or_alert("sheet.rename", json!({"sheet": i, "name": text}));
                                         }
-                                        if ed.lost_focus() {
-                                            if !ui.input(|i| i.key_pressed(egui::Key::Escape)) && text != name {
-                                                app.run_or_alert("sheet.rename", json!({"sheet": i, "name": text}));
-                                            }
-                                            app.grid.renaming_tab = None;
-                                        }
-                                    } else {
-                                        ui.painter().text(r.center(), Align2::CENTER_CENTER, &name, font, if active { t.accent } else { t.text });
+                                        app.grid.renaming_tab = None;
                                     }
-                                    // A right-click activates the tab too, as in Excel, so the menu's sheet commands (Protect
-                                    // Sheet, Select All Sheets) act on the sheet that was clicked rather than the one that was active.
-                                    if resp.clicked() || (resp.secondary_clicked() && !active) {
-                                        activate_sheet(app, i);
+                                } else {
+                                    ui.painter().text(r.center(), Align2::CENTER_CENTER, &name, font, if active { t.accent } else { t.text });
+                                }
+                                // A right-click activates the tab too, as in Excel, so the menu's sheet commands (Protect
+                                // Sheet, Select All Sheets) act on the sheet that was clicked rather than the one that was active.
+                                if resp.clicked() || (resp.secondary_clicked() && !active) {
+                                    activate_sheet(app, i);
+                                }
+                                if resp.double_clicked() {
+                                    app.grid.renaming_tab = Some(i);
+                                    app.grid.rename_text = name.clone();
+                                }
+                                // Drag to reorder; with the copy modifier held, drop a copy instead.
+                                let copy = drop_copies_sheet(ui.input(|inp| inp.modifiers), ui.ctx().os() == egui::os::OperatingSystem::Mac);
+                                if resp.dragged() && copy {
+                                    ui.ctx().set_cursor_icon(egui::CursorIcon::Copy);
+                                }
+                                if resp.drag_stopped()
+                                    && let Some(p) = ui.input(|inp| inp.pointer.interact_pos())
+                                {
+                                    let dx = p.x - r.center().x;
+                                    let steps = (dx / w).round() as i64;
+                                    if let Some(params) = tab_drop(i, steps, copy) {
+                                        app.run_or_alert("sheet.move", params);
                                     }
-                                    if resp.double_clicked() {
+                                }
+                                resp.context_menu(|ui| {
+                                    ui.set_min_width(180.0);
+                                    if ui.button(app.ui.language.tr("Insert Sheet")).clicked() {
+                                        app.run_or_alert("home.insertSheet", json!({"before": i}));
+                                    }
+                                    if ui.button(app.ui.language.tr("Delete")).clicked() {
+                                        app.run_or_alert("home.deleteSheet", json!({"sheet": i}));
+                                    }
+                                    if ui.button(app.ui.language.tr("Rename")).clicked() {
                                         app.grid.renaming_tab = Some(i);
                                         app.grid.rename_text = name.clone();
                                     }
-                                    // Drag to reorder; with the copy modifier held, drop a copy instead.
-                                    let copy = drop_copies_sheet(ui.input(|inp| inp.modifiers), ui.ctx().os() == egui::os::OperatingSystem::Mac);
-                                    if resp.dragged() && copy {
-                                        ui.ctx().set_cursor_icon(egui::CursorIcon::Copy);
+                                    if ui.button(app.ui.language.tr("Move or Copy…")).clicked() {
+                                        app.open_dialog("moveSheet", json!({"sheet": i}));
                                     }
-                                    if resp.drag_stopped()
-                                        && let Some(p) = ui.input(|inp| inp.pointer.interact_pos())
-                                    {
-                                        let dx = p.x - r.center().x;
-                                        let steps = (dx / w).round() as i64;
-                                        if let Some(params) = tab_drop(i, steps, copy) {
-                                            app.run_or_alert("sheet.move", params);
-                                        }
+                                    if ui.button(app.ui.language.tr("Duplicate")).clicked() {
+                                        app.run_or_alert("sheet.move", json!({"sheet": i, "to": i + 1, "copy": true}));
                                     }
-                                    resp.context_menu(|ui| {
-                                        ui.set_min_width(180.0);
-                                        if ui.button(app.ui.language.tr("Insert Sheet")).clicked() {
-                                            app.run_or_alert("home.insertSheet", json!({"before": i}));
-                                        }
-                                        if ui.button(app.ui.language.tr("Delete")).clicked() {
-                                            app.run_or_alert("home.deleteSheet", json!({"sheet": i}));
-                                        }
-                                        if ui.button(app.ui.language.tr("Rename")).clicked() {
-                                            app.grid.renaming_tab = Some(i);
-                                            app.grid.rename_text = name.clone();
-                                        }
-                                        if ui.button(app.ui.language.tr("Move or Copy…")).clicked() {
-                                            app.open_dialog("moveSheet", json!({"sheet": i}));
-                                        }
-                                        if ui.button(app.ui.language.tr("Duplicate")).clicked() {
-                                            app.run_or_alert("sheet.move", json!({"sheet": i, "to": i + 1, "copy": true}));
-                                        }
-                                        ui.menu_button(app.ui.language.tr("Tab Color"), |ui| {
-                                            let colors = app.session.active().map(|d| d.wb.theme.colors).unwrap_or_default();
-                                            if let Some(c) = crate::widgets::color_palette_fixed(ui, &colors, app.ui.language.tr("No Color")) {
-                                                app.run_or_alert("sheet.tabColor", json!({"sheet": i, "color": c}));
-                                                ui.close();
-                                            }
-                                        });
-                                        ui.separator();
-                                        if ui.button(app.ui.language.tr("Hide")).clicked() {
-                                            app.run_or_alert("sheet.hide", json!({"sheet": i}));
-                                        }
-                                        if ui.button(app.ui.language.tr("Unhide…")).clicked() {
-                                            app.run_or_alert("sheet.unhide", json!({}));
-                                        }
-                                        ui.separator();
-                                        let protected = app.active_sheet_protected();
-                                        if ui
-                                            .button(if protected {
-                                                app.ui.language.tr("Unprotect Sheet…")
-                                            } else {
-                                                app.ui.language.tr("Protect Sheet…")
-                                            })
-                                            .clicked()
-                                        {
-                                            app.open_dialog("protectSheet", json!({}));
-                                        }
-                                        if ui.button(app.ui.language.tr("Select All Sheets")).clicked() {
+                                    ui.menu_button(app.ui.language.tr("Tab Color"), |ui| {
+                                        let colors = app.session.active().map(|d| d.wb.theme.colors).unwrap_or_default();
+                                        if let Some(c) = crate::widgets::color_palette_fixed(ui, &colors, app.ui.language.tr("No Color")) {
+                                            app.run_or_alert("sheet.tabColor", json!({"sheet": i, "color": c}));
                                             ui.close();
                                         }
                                     });
-                                }
-                            });
+                                    ui.separator();
+                                    if ui.button(app.ui.language.tr("Hide")).clicked() {
+                                        app.run_or_alert("sheet.hide", json!({"sheet": i}));
+                                    }
+                                    if ui.button(app.ui.language.tr("Unhide…")).clicked() {
+                                        app.run_or_alert("sheet.unhide", json!({}));
+                                    }
+                                    ui.separator();
+                                    let protected = app.active_sheet_protected();
+                                    if ui
+                                        .button(if protected {
+                                            app.ui.language.tr("Unprotect Sheet…")
+                                        } else {
+                                            app.ui.language.tr("Protect Sheet…")
+                                        })
+                                        .clicked()
+                                    {
+                                        app.open_dialog("protectSheet", json!({}));
+                                    }
+                                    if ui.button(app.ui.language.tr("Select All Sheets")).clicked() {
+                                        ui.close();
+                                    }
+                                });
+                            }
                         });
-                });
-                ui.add_space(6.0);
-                if crate::widgets::icon_button(ui, Icon::Plus, t.text_dim, app.ui.language.tr("New sheet (⇧F11)"), vec2(26.0, 26.0)).clicked() {
-                    app.run_or_alert("home.insertSheet", json!({}));
-                }
-            }
-            if !view.show_horizontal_scroll {
-                return;
+                    });
+            });
+            ui.add_space(6.0);
+            if crate::widgets::icon_button(ui, Icon::Plus, t.text_dim, app.ui.language.tr("New sheet (⇧F11)"), vec2(26.0, 26.0)).clicked() {
+                app.run_or_alert("home.insertSheet", json!({}));
             }
             // The track ends where the grid does, so it stops under the vertical scrollbar.
             let avail = ui.available_rect_before_wrap();
@@ -330,14 +312,8 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) {
             let split_left =
                 share.map_or(avail.left(), |share| (bar_left + bar_width * share).min(right - SPLIT_WIDTH - MIN_TRACK).max(avail.left()));
             let split = Rect::from_min_max(pos2(split_left, avail.top()), pos2(split_left + SPLIT_WIDTH, avail.bottom()));
-            // Without sheet tabs there is nothing to split: the scroll bar takes the bar.
-            let track_left = if view.show_sheet_tabs {
-                tab_split_handle(app, ui, split, (bar_left, bar_width), right, uid, &t);
-                split.right()
-            } else {
-                avail.left()
-            };
-            let track = Rect::from_min_max(pos2(track_left, avail.center().y - 7.0), pos2(right, avail.center().y + 7.0));
+            tab_split_handle(app, ui, split, (bar_left, bar_width), right, uid, &t);
+            let track = Rect::from_min_max(pos2(split.right(), avail.center().y - 7.0), pos2(right, avail.center().y + 7.0));
             crate::grid::horizontal_scrollbar(app, ui, track, &t);
         });
     });

crates/ui-egui/src/theme.rs

@@ -63,8 +63,6 @@ pub struct Tokens {
     pub header_sel_text: Color32,
     pub header_all_bg: Color32,
     pub sel_fill: Color32,
-    /// The tint over the active cell's row (File ▸ Options ▸ General).
-    pub active_row: Color32,
     pub sel_border: Color32,
     pub input_bg: Color32,
     pub input_border: Color32,
@@ -219,7 +217,6 @@ impl Tokens {
             header_sel_text: pick(dark, Color32::from_rgb(0x0B, 0x5E, 0x31), Color32::from_rgb(0x6F, 0xD3, 0x9A)),
             header_all_bg: pick(dark, Color32::from_rgb(0xC8, 0xE6, 0xD3), Color32::from_rgb(0x2E, 0x55, 0x3E)),
             sel_fill: pick(dark, Color32::from_rgba_unmultiplied(0x10, 0x7C, 0x41, 0x1C), Color32::from_rgba_unmultiplied(0x10, 0x7C, 0x41, 0x24)),
-            active_row: pick(dark, Color32::from_rgba_unmultiplied(0x10, 0x7C, 0x41, 0x2C), Color32::from_rgba_unmultiplied(0x6F, 0xD3, 0x9A, 0x30)),
             sel_border: Color32::from_rgb(0x10, 0x7C, 0x41),
             input_bg: pick(dark, Color32::WHITE, Color32::from_rgb(0x1F, 0x1F, 0x1F)),
             input_border: pick(dark, Color32::from_rgb(0xD1, 0xD1, 0xD1), Color32::from_rgb(0x50, 0x50, 0x50)),

crates/ui-egui/src/window_ui.rs

@@ -31,8 +31,6 @@ pub struct WindowUi {
     ribbon_tab: String,
     /// The status bar's Ready/Enter/Edit, which follows the window's cell draft.
     mode: gridcraft_engine::Mode,
-    /// A key tip's control request waiting for the frame that draws this window's ribbon.
-    keytip_invoke_next: Option<&'static str>,
 }
 
 impl WindowUi {
@@ -72,7 +70,6 @@ impl SheetApp {
             open_switch_windows,
             ribbon_tab,
             mode,
-            keytip_invoke_next,
         } = w;
         std::mem::swap(&mut self.editor, editor);
         std::mem::swap(&mut self.text_box_editor, text_box_editor);
@@ -89,7 +86,6 @@ impl SheetApp {
         std::mem::swap(&mut self.open_switch_windows, open_switch_windows);
         std::mem::swap(&mut self.ui.ribbon_tab, ribbon_tab);
         std::mem::swap(&mut self.session.mode, mode);
-        std::mem::swap(&mut self.ui.keytip_invoke_next, keytip_invoke_next);
     }
 
     /// The window whose interface state is in the per-window fields.
@@ -102,14 +98,6 @@ impl SheetApp {
     /// in (a window never seen before starts fresh). A closed window's state is dropped.
     pub fn follow_active_window(&mut self) {
         let active = self.session.active_window();
-        // A window hidden while parked (from another window's View › Hide) isn't drawn either:
-        // its waiting key tip request goes, as it does for a window hidden as it is left.
-        let session = &self.session;
-        for (id, parked) in &mut self.parked {
-            if session.window(*id).is_some_and(|w| w.hidden) {
-                parked.keytip_invoke_next = None;
-            }
-        }
         if active == self.ui_window {
             return;
         }
@@ -120,12 +108,7 @@ impl SheetApp {
         };
         let mut outgoing = WindowUi::fresh(&self.grid, &self.ui.ribbon_tab);
         self.swap_window_ui(&mut outgoing);
-        if let Some(window) = self.session.window(previous) {
-            // A hidden window isn't drawn: a key tip request waiting for its next frame would
-            // fire whenever it is shown again, so it goes.
-            if window.hidden {
-                outgoing.keytip_invoke_next = None;
-            }
+        if self.session.window(previous).is_some() {
             self.parked.insert(previous, outgoing);
         }
         if let Some(mut incoming) = active.and_then(|w| self.parked.remove(&w)) {