Release 0.16.1

.github/workflows/house-rules.yml

@@ -1,28 +0,0 @@
-name: House rules
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - AGENTS.md
-      - CLAUDE.md
-      - .github/workflows/house-rules.yml
-  pull_request:
-    paths:
-      - AGENTS.md
-      - CLAUDE.md
-      - .github/workflows/house-rules.yml
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: house-rules-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  house-rules:
-    uses: storytold/craft-common-actions/.github/workflows/house-rules.yml@main
-    with:
-      rust: true

AGENTS.md

@@ -1,62 +1,12 @@
-<!-- craft-house-rules:start core source=dde09ea31e2e457f5b4653a6e76f7cdf55944bdf sha256=540e6cea75d12d0710c3dca89658328e81e508ecef102446ca5bb95b7c0b92bb -->
-## House rules
-
-These apply in every Craft repository. A later rule may be stricter, not weaker. The source is `standards/house-rules-core.md` in `storytold/craft-contrib`. Propose changes there, not in a copy.
-
-1. **A person is accountable.** Whoever runs an agent answers for what it opens and for its review comments.
-2. **Check, then claim.** Before writing code, read the issue comments, search pull requests for `#N` and the keywords, and check recent commits on `main`. Comment on the issue first. Release a claim you will not finish.
-3. **Verify, don't guess.** Open a definition before using it. Confirm the cause in the code, even when someone names a location.
-4. **Keep fixes narrow and tested.** Fix what the issue describes, where the bug is. Add a test that fails without the fix.
-5. **Review the diff before opening a pull request.** Identifiers exist as used, the test fails without the fix, nothing unrelated changed, and the description is true.
-6. **Look for a better pull request.** If another fixes the same thing, close yours when it is better or equal, and say why.
-7. **Report only what ran.** Say what you tested and what you could not run. Without a local build or test, say so and rely on CI before marking ready.
-8. **`main` changes through a pull request.** Do not push to it. Branch protection enforces this. There is no exception.
-9. **Stop and ask only about** licensing outside the allowlist, publishing, releases, a new remote, secrets, spending money, destructive git, and anything else hard to undo. Otherwise keep working. `plan/` is a gitignored notebook, not rules. Without it, do not ask for it and do not stop.
-10. **Keep secrets and personal details out** of the repository, logs and requests.
-11. **CI stays shared.** Workflows call `storytold/craft-common-actions`. Do not change CI in a feature or fix pull request. If CI cannot cover a change, open an issue there.
-12. **Guards say why.** A check that looks removable says what it prevents. Read that before changing it.
-13. **Instructions must be readable by everyone.** No notes about one machine, and no links to files a reader cannot open. `craftrules` is retired. Do not link to it.
-14. **Keep pull requests moving.** Concurrent pull requests are fine; unanswered actionable feedback is not. Respond in 7 days, a reminder at 14, closure eligible at 30, from when an actionable request waits on the author. Suggestions and unconfirmed bot findings do not start the clock. A fix, explanation or agreed plan resets it; unrelated activity does not. Waiting on a reviewer or maintainer pauses it and does not count against the author. A maintainer decides closure; it is never automatic. Reuse search results, do not poll, and stop at a rate limit.
-15. **No agent attribution.** A pull request does not say an agent wrote it. A repository rule may not require that.
-<!-- craft-house-rules:end -->
-<!-- craft-house-rules:start rust source=dde09ea31e2e457f5b4653a6e76f7cdf55944bdf sha256=387e0ccb4b49e567f60951d7d6fff7305054c89f43ad812b9993dc7c38528013 -->
-## Rust Craft repositories
-
-These apply to native Craft apps and to shared Rust libraries. Select them by repository type. A repository that merely contains some Rust does not take this block. Rules later in a repository's file may be stricter, but not weaker. The source is `standards/house-rules-rust.md` in [storytold/craft-contrib](https://github.com/storytold/craft-contrib).
-
-1. **Never crash.** Non-test code does not panic and has no `unsafe`, except where the repository file names an exception. Return errors, treat input as hostile, and bound recursion and allocations. New production crate roots copy the `deny` attribute from an existing crate: `clippy::unwrap_used`, `clippy::expect_used`, `clippy::panic`, `clippy::unimplemented`, `clippy::todo`, `clippy::unreachable`. Every crash fix comes with a test that panicked before the fix.
-2. **Clean room.** Learn from observed behaviour and public specifications. Do not copy another product's code, assets, strings or artwork. Check a dependency's licence before adding it.
-3. **Assets and fonts.** Every asset is original or suitably licensed, and is recorded in `ATTRIBUTION.md` in the same change. Font files live in [storytold/craft-fonts](https://github.com/storytold/craft-fonts), not in the app repository.
-4. **Rust only for native Craft apps.** No handwritten JavaScript or TypeScript, and no Tauri, Electron or webview shell, in those apps. Shared tooling follows its documented technical scope and maintainer-approved exceptions. Craft PR Review's existing Tauri and TypeScript UI is one such exception. It does not relax this rule for native apps. Preserve any existing web build.
-5. **Time goes through `chrono`.** Do not hand-roll calendar conversion. For dates beyond what `chrono` can represent, follow [standards/time.md](https://github.com/storytold/craft-contrib/blob/main/standards/time.md).
-6. **Contributor credits.** Add or edit only your own person's entry in `contributors/people.toml`, and only after asking them. Never guess a name or hand-edit `contributors.json`.
-
-## Licence allowlist
-
-Dependencies and assets use SPDX identifiers. An expression is allowed when every identifier is in this list. A repository may name a shorter list. It may not add an identifier here by editing its own copy of these rules.
-
-- `ISC`
-- `MIT`
-- `BSD-2-Clause`
-- `BSD-3-Clause`
-- `Apache-2.0`
-- `OFL-1.1`
-- `Ubuntu-font-1.0`
-- `Bitstream-Vera`
-- `CC0-1.0`
-- `CC-BY-4.0`
-- `CC-BY-SA-4.0`
-- `LicenseRef-Public-Domain`
-
-`LicenseRef-Storyteller-Trademark` is not in this list. It covers Storyteller brand marks only, where a repository already says so.
-<!-- craft-house-rules:end -->
-
 # GridCraft — instructions for agents
 
 GridCraft is a clean-room, open-source, Rust-native spreadsheet targeting Microsoft Excel parity — and superiority (speed, openness, agent control). It runs natively on macOS, Windows, Linux and BSD, and on the web via WASM. Siblings with the same conventions: `../designcraft` (InDesign-class, the closest reference), `../photocraft` (Photoshop), `../vectorcraft` (Illustrator), `../pdfcraft` (Acrobat), `../filmcraft` (Premiere), `../lightcraft` (Lightroom), `../effectcraft` (After Effects).
 
 ## Start every session here
-Read [`ROADMAP.md`](ROADMAP.md) and [`docs/gaps.md`](docs/gaps.md). `plan/` is an optional gitignored notebook (status, execution notes, `plan/excel/*.md`). Do not ask for it and do not stop when it is absent. Screenshots of Microsoft software stay in that notebook and are never committed.
+1. Read `plan/STATUS.md` (current milestone, next task), then the task in `plan/execution-plan.md` and the relevant `plan/architecture.md` section. Behaviour reference: `plan/excel/*.md` (`observed-ui.md` holds measured observations of the running app).
+2. Follow the autonomous operation protocol (`plan/execution-plan.md` §7). Don't stop to ask unless §7 lists the decision as the user's.
+
+`plan/` is gitignored (local only).
 
 ## Assets and iconography — absolute rule
 **No Microsoft, Adobe, Avid, Autodesk (or any other vendor's) iconography, images, artwork, fonts, templates, themes or sample files — ever.** This is the most important rule in this repository; breaking it is a serious failure.
@@ -85,6 +35,7 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr
 - **Programmatic calls never open dialogs**: a command with empty params runs with defaults or returns an error; only menu-style invocation opens a dialog (`UiRequest::Dialog`).
 - **Layering** is enforced by `cargo xtask layers`: `core`/`numfmt` (L0) → `formula`/`functions` (L1) → `model`/`calc`/`xlsx` (L2) → `chart` (L3) → `engine` (L5) → `ui-egui`/`mcp` (L6) → `apps/*` (L7). Nothing below L6 depends on egui/eframe/winit/rfd. **The UI crate is swappable.**
 - **The UI is thin**: panels read engine state and act through `app.run(id, params)`. Colours come from `theme::Tokens`.
+- **Time goes through `chrono`** (workspace dependency). Never hand-roll UTC/calendar conversion (days-to-date algorithms, leap-year math). A crate owns only its output format string. The one exception is range extension: past the years chrono can represent, shift the date by whole 400-year Gregorian cycles (146,097 days, after which the calendar repeats), let chrono compute the month and day, and add the cycles back to the year (splitting seconds into hours, minutes and seconds is plain arithmetic).
 - **Rust only** (no handwritten JS/TS). **Never break wasm** (`cargo xtask wasm`).
 - **Quality gates** before every commit: `cargo xtask ci` (fmt, clippy -D warnings, tests, assets, layers, wasm). One task id per commit (`M2.1: borders gallery`).
 
@@ -93,8 +44,8 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr
 - Drive it: `gridcraft-cli send 7979 <method> '<json>'` (reads the token file the app printed on stderr), or JSON lines on `127.0.0.1:7979` whose first line is `{"id":0,"method":"auth","params":{"token":"…"}}` (token: `$XDG_RUNTIME_DIR/gridcraft/control-7979.token`, or your own `GRIDCRAFT_CONTROL_TOKEN`), e.g. `{"id":1,"method":"engine.execute","params":{"command":"cell.set","params":{"cell":"B2","input":"=SUM(A1:A9)"}}}` then `{"id":2,"method":"ui.screenshot","params":{"path":"/tmp/shot.png"}}`. Methods: `crates/ui-egui/src/control.rs`, docs: `docs/control-protocol.md`.
 - **Offscreen UI render** (no window, from a source checkout): `cargo run -p gridcraft-ui-egui --example snapshot -- --sample sales out.png`.
 - Headless: `gridcraft-cli eval '=SUM(1,2,3)'`, `gridcraft-cli run --in book.xlsx --cmd 'home.bold={"range":"A1:C1"}' --out book.xlsx`, `gridcraft-cli mcp`.
-- **For UI work, look at the result** (snapshot PNG) and, when available, compare with `plan/excel/observed-ui.md`. Without that optional notebook, verify the intended behaviour against the task and committed documentation.
-- macOS has no `timeout`; use `perl -e 'alarm 60; exec @ARGV' cmd`.
+- **For UI work, look at the result** (snapshot PNG) and compare with `plan/excel/observed-ui.md`.
+- Shell gotcha: `mv`/`cp` are aliased interactive here — use `/bin/mv -f` / `/bin/cp -f`. macOS has no `timeout`; use `perl -e 'alarm 60; exec @ARGV' cmd`.
 - Parallel agents: separate `CARGO_TARGET_DIR` per agent; edit only the crates you own; delete your target dir when done.
 
 ## Roadmap
@@ -119,5 +70,3 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr
 - Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
 - Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
 - Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
-
-New workspace crates include `workspace = true` under `[lints]` in `Cargo.toml`. Production crate roots declare the crate-level lint attributes before modules; crate-level `//!` documentation may precede them.

CLAUDE.md

@@ -1 +1,56 @@
-@AGENTS.md
+# GridCraft — instructions for agents
+
+GridCraft is a clean-room, open-source, Rust-native spreadsheet targeting Microsoft Excel parity — and superiority (speed, openness, agent control). It runs natively on macOS, Windows, Linux and BSD, and on the web via WASM. Siblings with the same conventions: `../designcraft` (InDesign-class, the closest reference), `../photocraft` (Photoshop), `../vectorcraft` (Illustrator), `../pdfcraft` (Acrobat), `../filmcraft` (Premiere), `../lightcraft` (Lightroom), `../effectcraft` (After Effects).
+
+## Start every session here
+1. Read `plan/STATUS.md` (current milestone, next task), then the task in `plan/execution-plan.md` and the relevant `plan/architecture.md` section. Behaviour reference: `plan/excel/*.md` (`observed-ui.md` holds measured observations of the running app).
+2. Follow the autonomous operation protocol (`plan/execution-plan.md` §7). Don't stop to ask unless §7 lists the decision as the user's.
+
+`plan/` is gitignored (local only).
+
+## Assets and iconography — absolute rule
+**No Microsoft, Adobe, Avid, Autodesk (or any other vendor's) iconography, images, artwork, fonts, templates, themes or sample files — ever.** This is the most important rule in this repository; breaking it is a serious failure.
+- Every asset in the repo is original work by GridCraft contributors, or public domain / CC0, or open source / Creative Commons that allows redistribution (or licensed open source by the contributor who created it).
+- Every asset file has a row in [`ATTRIBUTION.md`](ATTRIBUTION.md) (author, source, licence). `cargo xtask assets` enforces it. Adding an asset without a row is a bug.
+- Prefer art generated in code: the UI icon set (`crates/ui-egui/src/icons.rs`), table and cell style palettes, themes and sample workbooks are drawn/defined in code and original.
+- Never copy Office's icons, ribbon artwork, theme XML, table-style definitions, templates, clip art or wording beyond feature names. Excel feature *names* (menu labels, function names) are fine.
+- Screenshots of Microsoft software are never committed (they live only in `plan/excel/screenshots/`).
+- The ArtCraft brand files in `docs/brand/` are ArtCraft trademarks under `docs/brand/LICENSE-brand.txt`, the one exception.
+
+## Never crash
+People trust GridCraft with their numbers; a crash loses their work. **This outranks feature work.**
+- **No panics in non-test code:** no `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!`; no `unsafe` (`unsafe_code = "forbid"`).
+- **Errors are `Result<T, E>`** through the crate's error type and `?`.
+- **Input-derived numbers are hostile** (files, formulas, commands, MCP/control params): `get()` instead of indexing, checked/saturating arithmetic, cap input-sized allocations (huge ranges, `REPT`, `SEQUENCE`, whole-column references).
+- **Bound recursion** (formula nesting, dependency chains, names referring to names).
+- **Last-resort guard:** `Session::execute` catches escaped panics and restores the workbook. It's a safety net, not a licence.
+- **Prove it:** every crash fix lands with a regression test (`tests::every_command_survives_empty_params` fuzzes every command; `crates/engine/tests/it/command_sequence_fuzz.rs` fuzzes random command sequences against undo/redo, XLSX round-trip and full-recalc invariants; soak it with `GRIDCRAFT_FUZZ_SEEDS`/`GRIDCRAFT_FUZZ_STEPS`, replay with `GRIDCRAFT_FUZZ_SEED`).
+- Production crate roots carry `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`; every new workspace crate must also include `[lints] workspace = true` in `Cargo.toml` to inherit `[workspace.lints]`.
+
+## Non-negotiables
+- **Clean-room.** Microsoft Excel is installed on the dev machine and may be *observed* black-box: run it, use its UI with synthetic workbooks, take screenshots (by window id) stored only under `plan/excel/screenshots/`. Never read, disassemble or copy anything inside the Office bundle, never commit files produced by Excel, never copy GPL/AGPL/LGPL code (LibreOffice, Gnumeric…). Function behaviour comes from public documentation and observation.
+- **Fonts live in [`storytold/craft-fonts`](https://github.com/storytold/craft-fonts)**, never in this repo. It is an optional build input (`CRAFT_FONTS_DIR`); without it the app uses system fonts and egui's defaults.
+- **Test corpora** (real Excel-authored files) live in a separate corpus repo, fetched pinned and sha256-verified. Never commit large binary fixtures; build test workbooks in code.
+- **Everything is a command.** User-visible behaviour = a command in `crates/engine/src/cmd/*` (id, label, ribbon path, shortcut, params doc, `enabled`, `run`) + tests. Ids follow Excel's ribbon (`home.bold`, `insert.chart`, `data.sortAscending`) plus primitives (`cell.set`, `selection.set`, `range.setValues`). UI-only commands live in `crates/ui-egui`. The control channel, CLI and MCP reach all of them.
+- **Programmatic calls never open dialogs**: a command with empty params runs with defaults or returns an error; only menu-style invocation opens a dialog (`UiRequest::Dialog`).
+- **Layering** is enforced by `cargo xtask layers`: `core`/`numfmt` (L0) → `formula`/`functions` (L1) → `model`/`calc`/`xlsx` (L2) → `chart` (L3) → `engine` (L5) → `ui-egui`/`mcp` (L6) → `apps/*` (L7). Nothing below L6 depends on egui/eframe/winit/rfd. **The UI crate is swappable.**
+- **The UI is thin**: panels read engine state and act through `app.run(id, params)`. Colours come from `theme::Tokens`.
+- **Rust only** (no handwritten JS/TS). **Never break wasm** (`cargo xtask wasm`).
+- **Quality gates** before every commit: `cargo xtask ci` (fmt, clippy -D warnings, tests, assets, layers, wasm). One task id per commit (`M2.1: borders gallery`).
+
+## Running and looking at the app
+- `cargo run --release -p gridcraft -- --sample sales --control 7979` (sample workbook + control channel).
+- Drive it: `gridcraft-cli send 7979 <method> '<json>'` (reads the token file the app printed on stderr), or JSON lines on `127.0.0.1:7979` whose first line is `{"id":0,"method":"auth","params":{"token":"…"}}` (token: `$XDG_RUNTIME_DIR/gridcraft/control-7979.token`, or your own `GRIDCRAFT_CONTROL_TOKEN`), e.g. `{"id":1,"method":"engine.execute","params":{"command":"cell.set","params":{"cell":"B2","input":"=SUM(A1:A9)"}}}` then `{"id":2,"method":"ui.screenshot","params":{"path":"/tmp/shot.png"}}`. Methods: `crates/ui-egui/src/control.rs`, docs: `docs/control-protocol.md`.
+- **Offscreen UI render** (no window, from a source checkout): `cargo run -p gridcraft-ui-egui --example snapshot -- --sample sales out.png`.
+- Headless: `gridcraft-cli eval '=SUM(1,2,3)'`, `gridcraft-cli run --in book.xlsx --cmd 'home.bold={"range":"A1:C1"}' --out book.xlsx`, `gridcraft-cli mcp`.
+- **For UI work, look at the result** (snapshot PNG) and compare with `plan/excel/observed-ui.md`.
+- Shell gotcha: `mv`/`cp` are aliased interactive here — use `/bin/mv -f` / `/bin/cp -f`. macOS has no `timeout`; use `perl -e 'alarm 60; exec @ARGV' cmd`.
+- Parallel agents: separate `CARGO_TARGET_DIR` per agent; edit only the crates you own; delete your target dir when done.
+
+## Roadmap
+`ROADMAP.md` (committed) is the one-page summary: stage, headline numbers, dimensions, languages, progress log. It points at the detail in `docs/`: `target-app-parity.md` (authoritative assessment), `gaps.md` (ranked work list: pick from it), `roadmap.md` (current focus, beta gates, milestones), `architecture.md`, and the area checklists `function-parity.md`, `chart-parity.md`, `file-format-parity.md`, `ui-parity.md`, `hardware-parity.md`, `localization-parity.md`. Update the affected docs (and their timestamp lines and revision history) whenever work lands. `cargo xtask parity` regenerates `docs/parity-checklist.md` from `crates/engine/src/catalog.rs`.
+
+## CI workflows
+- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
+- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
+- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.

Cargo.lock

@@ -220,7 +220,7 @@ dependencies = [
  "objc2-foundation 0.3.2",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
  "wl-clipboard-rs",
  "x11rb",
 ]
@@ -995,26 +995,6 @@ dependencies = [
  "zip 9.1.0",
 ]
 
-[[package]]
-name = "craft-web-api"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
-dependencies = [
- "js-sys",
- "serde_json",
- "wasm-bindgen",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "craft-web-host"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "craft-window"
 version = "0.1.0"
@@ -1366,19 +1346,6 @@ dependencies = [
  "winit",
 ]
 
-[[package]]
-name = "egui_extras"
-version = "0.37.0"
-source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
-dependencies = [
- "ahash",
- "egui",
- "enum-map",
- "itertools",
- "log",
- "profiling",
-]
-
 [[package]]
 name = "egui_glow"
 version = "0.37.0"
@@ -1446,26 +1413,6 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
 
-[[package]]
-name = "enum-map"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4532960034c15ba2f55e9eee631040ecc473c32e6c4b200828c759840f13a06"
-dependencies = [
- "enum-map-derive",
-]
-
-[[package]]
-name = "enum-map-derive"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7127272f64b3e098f7d81f350d672081b879bff896d219c42370dc858b1af9ff"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 3.0.6",
-]
-
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -1531,7 +1478,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2022,7 +1969,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "arboard",
  "chrono",
@@ -2049,7 +1996,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-calc"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-core",
  "gridcraft-formula",
@@ -2061,7 +2008,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-chart"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-calc",
  "gridcraft-core",
@@ -2072,7 +2019,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-cli"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-engine",
  "gridcraft-mcp",
@@ -2084,7 +2031,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-core"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "chrono",
  "js-sys",
@@ -2095,7 +2042,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-engine"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-calc",
  "gridcraft-chart",
@@ -2118,7 +2065,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-formula"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-core",
  "serde",
@@ -2127,7 +2074,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-functions"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-core",
  "regex",
@@ -2135,7 +2082,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-math"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "ratex-font",
  "ratex-layout",
@@ -2145,7 +2092,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-mcp"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-engine",
  "log",
@@ -2154,7 +2101,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-model"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-core",
  "gridcraft-formula",
@@ -2167,24 +2114,23 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-numfmt"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-core",
 ]
 
 [[package]]
 name = "gridcraft-pdf"
-version = "0.16.0"
+version = "0.16.1"
 
 [[package]]
 name = "gridcraft-ui-egui"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "craft-ui",
  "craft-update",
  "craft-window",
  "egui",
- "egui_extras",
  "egui_kittest",
  "epaint_default_fonts",
  "gridcraft-chart",
@@ -2204,10 +2150,8 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-web"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
- "craft-web-api",
- "craft-web-host",
  "eframe",
  "egui",
  "gridcraft-engine",
@@ -2223,7 +2167,7 @@ dependencies = [
 
 [[package]]
 name = "gridcraft-xlsx"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "aes",
  "gridcraft-core",
@@ -3563,7 +3507,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4019,7 +3963,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4404,7 +4348,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4463,7 +4407,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5214,7 +5158,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.5",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6207,7 +6151,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6674,7 +6618,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 
 [[package]]
 name = "xtask"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "gridcraft-engine",
  "serde_json",
@@ -7023,6 +6967,11 @@ name = "egui_demo_lib"
 version = "0.37.0"
 source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
 
+[[patch.unused]]
+name = "egui_extras"
+version = "0.37.0"
+source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
+
 [[patch.unused]]
 name = "egui_inspection"
 version = "0.37.0"

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/gridcraft", "apps/gridcraft-cli", "xtask"]
 
 [workspace.package]
-version = "0.16.0"
+version = "0.16.1"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"

ROADMAP.md

@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away
 
-> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (form controls: buttons, sliders and spin buttons; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis take ranges by selection on the grid; earlier: Python mode in the formula bar; earlier: Python cells stored and kept in files; earlier: equations: Insert › Equation, editor, gridcraft-math; earlier: What-if and analysis: Solver Sensitivity report for Simplex LP and GRG Nonlinear; earlier: floating objects: one selection, eight resize handles, keyboard delete; earlier: Chart data tables: live source values beneath column, bar, line, area and compatible combo charts; legend keys and borders; XLSX round-trip and print/PDF; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and Insert Function categories; XLSX workbook-view selection, bounded tab ratios and sheet-edit regressions; readiness estimates unchanged; earlier: CSV and text open detects each column's date order, so day-first dates are not silently swapped) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis take ranges by selection on the grid; earlier: Python mode in the formula bar; earlier: Python cells stored and kept in files; earlier: equations: Insert › Equation, editor, gridcraft-math; earlier: What-if and analysis: Solver Sensitivity report for Simplex LP and GRG Nonlinear; earlier: floating objects: one selection, eight resize handles, keyboard delete; earlier: Chart data tables: live source values beneath column, bar, line, area and compatible combo charts; legend keys and borders; XLSX round-trip and print/PDF; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and Insert Function categories; XLSX workbook-view selection, bounded tab ratios and sheet-edit regressions; readiness estimates unchanged; earlier: CSV and text open detects each column's date order, so day-first dates are not silently swapped) · **Target:** Microsoft Excel (Microsoft 365)
 
 GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX
 is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web.
@@ -22,7 +22,7 @@ This page is the summary. The detail is in:
 | Number | Value | Kind |
 |---|---|---|
 | 2026-10-14 | Editing a cell with text that would read back as a number, boolean, date or formula (entered with a leading apostrophe) shows the apostrophe in the editor and formula bar, so Enter unchanged keeps it text (#1362) |
-| **Feature breadth** (weighted) | **~75%** | estimated, anchored on two measurements: ribbon catalog 281 / 296 (94.9%), worksheet functions 513 / 523 (98.1%; 504 working, 96.4%) |
+| **Feature breadth** (weighted) | **~75%** | estimated, anchored on two measurements: ribbon catalog 277 / 292 (94.9%), worksheet functions 513 / 523 (98.1%; 504 working, 96.4%) |
 | **Ready for real work** | **~50%** | estimated from written weights (51.6); [target-app-parity.md](docs/target-app-parity.md) |
 | **Mainstream practitioner** | **~50%** | estimated: typical analyst/finance user, weekly features, × 0.90 interaction × 0.92 stability × 0.88 file exchange; [method](docs/target-app-parity.md#mainstream-practitioner) |
 | **Essentials user** | **~63%** | estimated: core features only, × 0.92 launch/stability × 0.95 clarity × 0.90 opening sent files; [method](docs/target-app-parity.md#essentials-user) |
@@ -135,8 +135,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | What landed |
 |---|---|
-| 2026-11-06 | A sheet keeps its own scroll position when sheets are inserted, deleted or moved before it: a new PivotTable or inserted sheet opens at the top instead of where its neighbour was scrolled; a closed window's positions are let go (#3485) |
-| 2026-11-02 | Form controls: Insert › Controls places buttons, sliders (scroll bars) and spin buttons on the sheet. A slider or spin button holds a whole number from 0 to 30000 in a linked cell (a drag or a held arrow is one undo step, and editing the cell moves the control); a button runs a macro or one command through the macro policy, asking first in a workbook opened from a file; Assign Action and Format Control edit them, and XLSX files read and write them (control properties, `<controls>` and VML), alongside the form controls GridCraft keeps unchanged |
 | 2026-11-02 | Dialogs take ranges by selection on the grid: reference boxes (RefEdit) with a collapse button that shrinks the dialog while the person selects, in Goal Seek, Solver (including the Model Range of Load/Save) and Data Analysis; while collapsed, the arrow keys move the selection and Shift+arrow extends it, and F4 cycles a reference's anchors |
 | 2026-11-02 | Python mode in the formula bar: Ctrl+Alt+Shift+P, `=PY` then Tab, or editing a Python cell edits its code in the formula bar, with Enter for a new line, Tab to indent and Ctrl+Enter to commit through `python.set`. The code still doesn't run |
 | 2026-11-02 | Python cells as data: `python.set` stores code in a cell, Python cells copy, move, fill and undo like formulas, and `.xlsx` reads and writes Python cells as [MS-XLSX] specifies (`_xlfn._xlws.PY(index,0 or 1)`, the code in the workbook's Python part) with cached values and spills, so such workbooks open with their results; nothing runs Python (new code shows `#BLOCKED!`), and opening a file limits code size, result size and spill ranges |
@@ -178,7 +176,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 | 2026-10-15 | File › Options › Formulas: Maximum Iterations and Maximum Change fields for iterative calculation, disabled while it is off, with Excel's limits (1 to 32767, 0 or more) |
 | 2026-10-15 | Function help follows the interface language: argument hints, autocomplete, Insert Function (search and readable categories) and the Formulas-tab menus read per-language tables of descriptions and argument names; Spanish keeps its 10 functions in the new format |
 | 2026-10-15 | Row auto-fit counts a cell's line breaks only when the cell wraps, as Excel does: a file whose unwrapped cells hold multi-line text no longer opens with tall rows (typing a break still turns wrap on and grows the row) |
-| 2026-10-14 | Set precision as displayed is applied: with the option on, formula results, spills and numbers typed or reformatted are stored as their number format shows them and formulas calculate from those values; `formulas.calculationOptions` gains `precisionAsDisplayed` (turning it on rounds existing constants; locked constants on a protected sheet keep their value; numbers written to a new sheet are rounded too) (#1343) |
 | 2026-10-14 | Lookups (MATCH, XMATCH, VLOOKUP, HLOOKUP, XLOOKUP, LOOKUP) compare numbers exactly like Excel, so a computed key such as `=0.1+0.2` no longer finds 0.3; `=` and COUNTIF/SUMIF keep their 15-digit comparison |
 | 2026-10-14 | Functions: EOMONTH, EDATE, WORKDAY, NETWORKDAYS, YEARFRAC, WEEKNUM, the bond and coupon functions, DISC, BIN2DEC, IM* and the other Analysis ToolPak functions give `#VALUE!` for a reference to more than one cell in a value argument, as Excel 365 does, instead of spilling; array constants and computed arrays still lift |
 | 2026-10-14 | Protect Sheet on a protected sheet: Home › Format, its keytips (HOP, RPS) and the tab menu now read Unprotect Sheet… and unprotect (straight away without a password); a protected sheet that forbids selecting locked (or unlocked) cells is enforced for clicks, arrows and Go To, and the Protect Sheet dialog has the select options (#1346) |
@@ -187,7 +184,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 | 2026-10-14 | Recalculation: a dynamic array's anchor given a new formula that reads its old spill area (`A1` was `=SEQUENCE(3)`, becomes `=SUM(A2:A3)+1` or `=SEQUENCE(1,A2+1)`) sees that area empty instead of the old values |
 | 2026-10-14 | Recalculation: when two arrays of one recalculation want the same empty cells, the formulas that read the one laid out second (at its anchor or over the cells it would have spilled into) read `#SPILL!` and empty cells instead of its values |
 | 2026-10-14 | Border keytips: each Alt, H, B letter applies the preset Excel's Borders menu gives it (H,B,O bottom, H,B,B bottom double, H,B,N no border, H,B,A all borders and the rest); they all drew a bottom border before. H,B,M opens Format Cells on the Border tab |
-| 2026-10-13 | Charts: label shortening needs about nine text measurements instead of up to 400, side legends stop measuring once the column is at its cap and treemap layout avoids per-item allocation (#1149) |
 | 2026-10-13 | Formula-entry Command/Ctrl-click inserts another reference with the locale's argument separator; Shift-click extends from a stable, sheet-aware anchor. Pointer tests cover repeated clicks, reversed ranges, ordinary replacement, typed separators, Spanish syntax, sheet switches and keyboard continuation. Readiness estimates unchanged. |
 | 2026-10-13 | `formulas.evaluate` (`gridcraft-cli eval`, MCP `evaluate_formula`) refuses what entering the formula in a cell refuses, with the reason (`=SUM(1;2)`: "expected `,` or `)`"), instead of `#NAME?` for any formula that doesn't parse |
 | 2026-10-13 | Colour menus: Fill Color, Font Color and the Format Cells pickers end with Recent Colors (the last ten custom colours) and More Colors… (hue/saturation area, RGB, hex box, preview, OK/Cancel) (#928) |
@@ -198,8 +194,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 | 2026-10-13 | Conditional formatting: a rule gathers range statistics only when it reads them (top/bottom, above average, duplicates, scales, bars, icons) and borrows them instead of copying them per cell, so the per-frame lookup of an expression or cell-value rule no longer visits its whole range (#1098, part 1) |
 | 2026-10-12 | Next/previous sheet navigation stops at the first/last visible worksheet instead of activating a hidden boundary sheet; the current selection is retained |
 | 2026-10-21 | Macro engine ([macros.md](docs/macros.md)): typed, declarative macros saved in the workbook (a JSON field; hidden names in xlsx); declared inputs checked with messages that name the cells; tokens (`Input.col(2)`, `Row`, `Output`, `Name:Total`, `{{…}}` in formulas); one undo step with full rollback; a footprint dry run with ask, fail, overwrite, shift down or shift right; a policy that keeps macros away from files and the app, with approval for macros in opened files; Repeat, If and Stop steps; a debugger; a relative recorder; `macro.*` commands beside the unchanged Automate scripts |
-| 2026-10-13 | Charts: work and memory are bounded by series x points (2,000,000 per chart: every series keeps its first points; 16 trendlines per chart), hairline columns and bars are merged per pixel column, series ranges are clipped before they are evaluated, the moving average is linear and rendering clean data no longer copies it (#1147) |
-| 2026-10-13 | Charts: one combo plot-kind rule for resolving and drawing; ticks of a scale off the step grid keep their own values (#1146) |
 | 2026-10-12 | Security: the `--control` server requires an auth token (random, kept in a 0600 file or chosen with `GRIDCRAFT_CONTROL_TOKEN`) on each connection's first line and closes bad connections (#777) |
 | 2026-10-12 | Rows auto-fit oversized fonts: opening a file and whole-row/column formatting grow non-custom rows to their tallest font (#833) |
 | 2026-10-12 | Number formats: parsing a format code is linear in its length (long runs of `[`, `,` or `/` no longer take quadratic time), and an unclosed `[` is a literal when splitting sections as well as when tokenizing (#810) |
@@ -263,8 +257,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-06 | trivial | Progress log: scroll positions follow their sheet through sheet inserts, deletes and moves (#3485) |
-| 2026-11-02 | minor | Form controls; catalog 277 / 292 → 281 / 296 (Developer › Controls); progress log row |
 | 2026-11-02 | minor | Progress log: RefEdit reference boxes in dialogs |
 | 2026-11-02 | minor | Progress log: Python mode in the formula bar |
 | 2026-11-02 | minor | Progress log: Python cells as data |
@@ -294,7 +286,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 | 2026-10-16 | minor | Progress log: floating pictures' textures bounded and kept per workbook |
 | 2026-10-16 | trivial | Progress log: web preferences kept between visits (#1562) |
 | 2026-10-16 | minor | Progress log: interface fonts held once instead of twice |
-| 2026-10-14 | minor | Progress log: Set precision as displayed applied in calculation (#1343) |
 | 2026-10-14 | minor | Progress log: `.xls` import reads cell formatting |
 | 2026-10-14 | minor | Progress log: lookups compare numbers exactly |
 | 2026-10-14 | minor | Progress log: Analysis ToolPak value arguments reject multi-cell references |

apps/gridcraft-web/Cargo.toml

@@ -16,10 +16,6 @@ path = "src/main.rs"
 [dependencies]
 gridcraft-engine = { workspace = true }
 gridcraft-ui-egui = { workspace = true }
-# The host messages (storytold/craft-libs): one contract and one bridge for the web builds.
-# The page command API (storytold/craft-libs#413): window.gridcraft over the control channel.
-craft-web-api = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
-craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
 egui = { workspace = true }
 log = { workspace = true }
 serde_json = { workspace = true }
@@ -30,4 +26,4 @@ rfd = { workspace = true }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "Event", "EventTarget", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "HtmlIFrameElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Clipboard", "ClipboardItem", "Navigator", "MessageEvent", "UrlSearchParams", "AddEventListenerOptions", "Storage", "CustomEvent", "CustomEventInit"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "HtmlIFrameElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Clipboard", "ClipboardItem", "Navigator", "MessageEvent", "UrlSearchParams", "AddEventListenerOptions", "Storage"] }

apps/gridcraft-web/src/api.rs

@@ -1,151 +0,0 @@
-//! `window.gridcraft`: the page command API (`craft-web-api`, storytold/craft-libs#413) over the
-//! app's own control channel, the one the desktop control server drives (`docs/control-protocol.md`).
-//!
-//! The crate owns the JavaScript side (`request`, `execute`, `commands`, `docInspect`, `uiInspect`,
-//! `screenshot`, as promises with a timeout). This module is GridCraft's part: a [`Request`] that
-//! queues a [`ControlRequest`] for the app, which answers it on its next frame, and waits for the
-//! reply. A call the page gave up on is released ([`Pending`]), so the app skips it if it has not started it, instead of
-//! applying a command the page was told had failed.
-
-use std::sync::Arc;
-use std::sync::atomic::AtomicU8;
-use std::sync::mpsc::{Receiver, TryRecvError};
-
-use gridcraft_ui_egui::ControlRequest;
-use serde_json::{Value, json};
-
-/// How often a waiting call looks for the app's reply, in milliseconds (about a frame).
-#[cfg(target_arch = "wasm32")]
-const POLL_MS: i32 = 16;
-
-/// A queued control request whose reply has not arrived. Dropping it before the reply (the page's
-/// timeout fired, or the call was abandoned) releases the request: the app skips it if it has not started it (one it has taken still finishes).
-struct Pending {
-    reply: Receiver<Value>,
-    state: Arc<AtomicU8>,
-    answered: bool,
-}
-
-impl Pending {
-    /// `Some` once the app has answered or gone away; `None` while the request is still waiting.
-    fn poll(&mut self) -> Option<Value> {
-        match self.reply.try_recv() {
-            Ok(reply) => {
-                self.answered = true;
-                Some(reply)
-            }
-            Err(TryRecvError::Empty) => None,
-            Err(TryRecvError::Disconnected) => {
-                self.answered = true;
-                Some(json!({"ok": false, "error": "the app dropped the request"}))
-            }
-        }
-    }
-}
-
-impl Drop for Pending {
-    fn drop(&mut self) {
-        if !self.answered {
-            ControlRequest::abandon(&self.state);
-        }
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-pub use web::install;
-
-#[cfg(target_arch = "wasm32")]
-mod web {
-    use std::rc::Rc;
-    use std::sync::mpsc::channel;
-
-    use craft_web_api::methods::Methods;
-    use craft_web_api::page::{PageApi, Request};
-    use gridcraft_ui_egui::{ControlRequest, SheetApp};
-    use serde_json::json;
-    use wasm_bindgen_futures::JsFuture;
-
-    use super::{POLL_MS, Pending};
-
-    /// The app id in `window.<app>`.
-    const APP: &str = "gridcraft";
-
-    /// Give the app its control queue and put `window.gridcraft` on the page. An existing
-    /// `window.gridcraft` keeps the functions it already has.
-    pub fn install(app: &mut SheetApp, ctx: egui::Context) {
-        let (queue, requests) = channel::<ControlRequest>();
-        app.control_rx = Some(requests);
-        let request: Request = Rc::new(move |method, params| {
-            let (control, reply) = ControlRequest::new(method, params);
-            let mut pending = Pending { reply, state: control.state.clone(), answered: false };
-            if queue.send(control).is_err() {
-                pending.answered = true;
-                return Box::pin(async { json!({"ok": false, "error": "the app is not running"}) });
-            }
-            ctx.request_repaint();
-            Box::pin(async move {
-                loop {
-                    if let Some(reply) = pending.poll() {
-                        return reply;
-                    }
-                    sleep(POLL_MS).await;
-                }
-            })
-        });
-        if let Err(e) = Rc::new(PageApi::new(APP, Methods::default(), request)).install() {
-            log::warn!("couldn't install window.{APP}: {e:?}");
-        }
-    }
-
-    async fn sleep(ms: i32) {
-        let promise = js_sys::Promise::new(&mut |resolve, _| {
-            if let Some(window) = web_sys::window() {
-                let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms);
-            }
-        });
-        let _ = JsFuture::from(promise).await;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::atomic::Ordering;
-
-    use super::*;
-
-    /// `ControlRequest`'s `state` values (`gridcraft_ui_egui::control`): the app has started it, or its
-    /// sender gave up.
-    const TAKEN: u8 = 1;
-    const ABANDONED: u8 = 2;
-
-    fn pending() -> (Pending, ControlRequest) {
-        let (control, reply) = ControlRequest::new("document.inspect", json!({}));
-        (Pending { reply, state: control.state.clone(), answered: false }, control)
-    }
-
-    #[test]
-    fn a_call_the_page_gave_up_on_is_released_so_the_app_skips_it() {
-        let (waiting, control) = pending();
-        drop(waiting);
-        assert_eq!(control.state.load(Ordering::SeqCst), ABANDONED);
-        assert!(!control.take(), "the app must not run a request the page was told had failed");
-    }
-
-    #[test]
-    fn an_answered_call_is_not_released() {
-        let (mut waiting, control) = pending();
-        assert!(control.take());
-        control.reply.send(json!({"ok": true, "result": 1})).unwrap_or_default();
-        assert_eq!(waiting.poll(), Some(json!({"ok": true, "result": 1})));
-        drop(waiting);
-        assert_eq!(control.state.load(Ordering::SeqCst), TAKEN);
-    }
-
-    #[test]
-    fn a_request_the_app_never_runs_waits_until_it_is_dropped() {
-        let (mut waiting, control) = pending();
-        assert_eq!(waiting.poll(), None);
-        drop(control);
-        assert_eq!(waiting.poll().and_then(|r| r["ok"].as_bool()), Some(false), "the app went away");
-    }
-}

apps/gridcraft-web/src/host.rs

@@ -1,64 +1,57 @@
-//! Host modes: a page that runs GridCraft (as an iframe, or in its own document) opens workbooks
-//! in it and stores what it saves instead of the browser downloading. The messages and the two
-//! transports are `craft-web-host`'s (storytold/craft-libs), the same contract as the other Craft
-//! apps' bridges, with the `gridcraft:` prefix. This module is GridCraft's part of it.
+//! The `postMessage` bridge to a same-origin parent page (`?host=parent`), for pages that embed
+//! GridCraft in an `<iframe>` (such as a Nextcloud app). Messages are plain objects with a `type`:
 //!
-//! - `?host=parent` (an `<iframe>`, such as a Nextcloud app) talks to the same-origin parent over
-//!   `postMessage`; `data-host="page"` on the canvas (the page's own document, no iframe) uses
-//!   DOM `CustomEvent`s on the canvas instead. `?host=parent` wins when both are present. With no
-//!   parent, or a parent on another origin, there is no bridge: the normal app with downloads.
-//! - `gridcraft:ready` once the app is listening; send a file now. GridCraft reads bytes, so it
-//!   says `file: false` and a host sends `bytes`.
-//! - `gridcraft:open` (from the host): `{ name, bytes }`. It opens like a workbook picked with
-//!   File › Open or dropped on the window; a file over [`MAX_OPEN_BYTES`] is refused before it is
-//!   copied.
-//! - `gridcraft:save` (to the host): `{ name, saveAs, bytes }` for every file GridCraft would
-//!   otherwise download: Save and Save As (an .xlsx workbook) and Export as PDF. The host stores
-//!   it and reports failures itself. GridCraft doesn't tell the host which saves make a file the
-//!   document, so `saveAs` is always `false`.
-//! - `gridcraft:dirty` whenever unsaved changes appear or go away, `gridcraft:failed` when the
-//!   app couldn't start.
+//! - `gridcraft:ready` (to the parent): `{ version }`, the app is listening; send a file now.
+//! - `gridcraft:open` (from the parent): `{ name, bytes }`, bytes an `ArrayBuffer` or
+//!   `Uint8Array`. It opens like a workbook picked with File › Open or dropped on the window.
+//! - `gridcraft:save` (to the parent): `{ name, bytes }` (a transferred `ArrayBuffer`) for every
+//!   file GridCraft would otherwise download: Save and Save As (an .xlsx workbook) and Export
+//!   as PDF. The parent stores it and reports failures itself.
+//! - `gridcraft:dirty` (to the parent): `{ dirty }` whenever unsaved changes appear or go away.
+//! - `gridcraft:failed` (to the parent): `{ error }` when the app couldn't start.
 //!
-//! In both host modes the page starts with an empty workbook instead of a sample, saves and PDF
-//! exports are handed to the page rather than downloaded, and `?author=` names the user for new
-//! notes and comments.
+//! Only the parent window on the page's own origin is heard or answered. In host mode the page
+//! starts with an empty workbook instead of a sample, and the parent guards leaving the page.
 
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 
-use craft_web_host::web::{FileData, Host, Message};
 use gridcraft_ui_egui::{Inbox, Services, SheetApp};
+use wasm_bindgen::JsCast as _;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::closure::Closure;
 
-use crate::hostmode::open_name;
-
-/// The app id in the host messages (`gridcraft:ready`).
-const APP: &str = "gridcraft";
-
-/// Saved files that count as a workbook: the document is then clean under the name it was saved as.
+/// Saving one of these hands the whole workbook to the parent, which stores it: the workbook
+/// counts as saved under that name, as it would after Save on the desktop.
 const WORKBOOK_EXTS: &[&str] = &["xlsx"];
 
-/// The largest workbook taken from the host page, refused before it is copied.
-const MAX_OPEN_BYTES: u64 = 512 << 20;
-
 /// The longest user name taken from `?author=`.
 const MAX_AUTHOR_CHARS: usize = 200;
 
 #[derive(Clone)]
 pub struct Bridge {
-    host: Rc<Host>,
-    /// Names of the files handed to the host since the last frame.
+    window: web_sys::Window,
+    parent: web_sys::Window,
+    origin: String,
+    /// Names of the files handed to the parent since the last frame.
     saved: Rc<RefCell<Vec<String>>>,
+    /// The unsaved-changes state last reported to the parent.
+    reported: Rc<Cell<Option<bool>>>,
 }
 
 impl Bridge {
-    /// The bridge for this page, or `None` when GridCraft isn't hosted: no `?host=parent` and no
-    /// `data-host="page"` on the canvas, an unframed `?host=parent` page (it stays the normal app
-    /// with downloads), or a parent on another origin.
-    pub fn detect(canvas: &web_sys::HtmlCanvasElement) -> Option<Self> {
-        Some(Self { host: Rc::new(Host::connect(APP, canvas)?), saved: Rc::default() })
+    /// `None` when the page isn't framed (there is no parent to talk to).
+    pub fn new() -> Option<Self> {
+        let window = web_sys::window()?;
+        let parent = window.parent().ok().flatten()?;
+        if js_sys::Object::is(&parent, &window) {
+            return None;
+        }
+        let origin = window.location().origin().ok()?;
+        Some(Self { window, parent, origin, saved: Rc::default(), reported: Rc::default() })
     }
 
-    /// Send saved and exported files to the host instead of downloading them, and hear files
+    /// Send saved and exported files to the parent instead of downloading them, and hear files
     /// from it.
     pub fn connect(&self, services: &mut Services, inbox: Inbox, ctx: egui::Context) {
         self.listen(inbox, ctx);
@@ -79,16 +72,15 @@ impl Bridge {
     }
 
     pub fn post_ready(&self) {
-        let _ = self.host.post_ready(env!("CARGO_PKG_VERSION"), false);
+        self.send(&[("type", "gridcraft:ready".into()), ("version", env!("CARGO_PKG_VERSION").into())]);
     }
 
     pub fn post_failed(&self, error: &str) {
-        let _ = self.host.post_failed(error, None);
+        self.send(&[("type", "gridcraft:failed".into()), ("error", error.into())]);
     }
 
-    /// After each frame: a workbook handed to the host this frame counts as saved under the
-    /// name it was saved as, and the host hears when unsaved changes appear or go away (the
-    /// crate does not repeat a state it already reported).
+    /// After each frame: a workbook handed to the parent this frame counts as saved under the
+    /// name it was saved as, and the parent hears when unsaved changes appear or go away.
     pub fn sync(&self, app: &mut SheetApp) {
         let saved = std::mem::take(&mut *self.saved.borrow_mut());
         if let Some(name) = saved.iter().rev().find(|name| is_workbook(name))
@@ -99,45 +91,76 @@ impl Bridge {
                 doc.title = name.clone();
             }
         }
-        self.host.post_dirty(app.session.documents().iter().any(|d| d.is_dirty()));
+        let dirty = app.session.documents().iter().any(|d| d.is_dirty());
+        if self.reported.get() != Some(dirty) && self.send(&[("type", "gridcraft:dirty".into()), ("dirty", dirty.into())]) {
+            self.reported.set(Some(dirty));
+        }
     }
 
     fn post_save(&self, path: &str, bytes: &[u8]) -> Result<(), String> {
-        let name = file_name(path);
-        self.host.post_save(&name, bytes, None, false)?;
+        let name = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());
+        let buffer = js_sys::Uint8Array::from(bytes).buffer();
+        let message = message(&[("type", "gridcraft:save".into()), ("name", name.as_str().into()), ("bytes", buffer.clone().into())])
+            .ok_or_else(|| "couldn't build the message".to_string())?;
+        self.parent
+            .post_message_with_transfer(&message, &self.origin, &js_sys::Array::of1(&buffer))
+            .map_err(|e| e.as_string().unwrap_or_else(|| format!("{e:?}")))?;
         self.saved.borrow_mut().push(name);
         Ok(())
     }
 
     fn listen(&self, inbox: Inbox, ctx: egui::Context) {
-        self.host.listen(move |message| {
-            if let Message::Open { name, data } = message {
-                deliver_open(&inbox, &ctx, &name, &data);
+        let parent = self.parent.clone();
+        let origin = self.origin.clone();
+        let on_message = Closure::<dyn FnMut(web_sys::MessageEvent)>::new(move |event: web_sys::MessageEvent| {
+            if event.origin() != origin || !event.source().is_some_and(|s| js_sys::Object::is(&s, &parent)) {
+                return;
             }
+            let data = event.data();
+            if string(&data, "type").as_deref() != Some("gridcraft:open") {
+                return;
+            }
+            let name = string(&data, "name").filter(|n| !n.trim().is_empty()).unwrap_or_else(|| "Book.xlsx".to_string());
+            let Some(bytes) = bytes(&data) else { return };
+            inbox.lock().unwrap_or_else(|e| e.into_inner()).push((name, bytes));
+            ctx.request_repaint();
         });
+        if self.window.add_event_listener_with_callback("message", on_message.as_ref().unchecked_ref()).is_ok() {
+            // The listener lives as long as the page.
+            on_message.forget();
+        }
     }
-}
 
-/// The file an open message carries, pushed onto the inbox for the next frame, like a dropped
-/// file. A host's file is untrusted input: an oversized one is refused before it is copied into
-/// the app's memory (the data's own length, not the host's claim).
-fn deliver_open(inbox: &Inbox, ctx: &egui::Context, name: &str, data: &FileData) {
-    let FileData::Bytes(array) = data else {
-        log::warn!("host file {name} came as a File; GridCraft reads bytes only; not opened");
-        return;
-    };
-    if data.size() > MAX_OPEN_BYTES as f64 {
-        log::warn!("host file is {} bytes, over the {} MiB host open limit; not opened", data.size(), MAX_OPEN_BYTES >> 20);
-        return;
+    /// Post a message to the parent; false if it couldn't be sent.
+    fn send(&self, fields: &[(&str, JsValue)]) -> bool {
+        message(fields).is_some_and(|m| self.parent.post_message(&m, &self.origin).is_ok())
     }
-    inbox.lock().unwrap_or_else(|e| e.into_inner()).push((open_name(name), array.to_vec()));
-    ctx.request_repaint();
 }
 
 fn is_workbook(name: &str) -> bool {
     name.rsplit_once('.').is_some_and(|(_, ext)| WORKBOOK_EXTS.iter().any(|e| ext.eq_ignore_ascii_case(e)))
 }
 
-fn file_name(path: &str) -> String {
-    std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string())
+fn message(fields: &[(&str, JsValue)]) -> Option<js_sys::Object> {
+    let m = js_sys::Object::new();
+    for (key, value) in fields {
+        js_sys::Reflect::set(&m, &JsValue::from_str(key), value).ok()?;
+    }
+    Some(m)
+}
+
+fn string(data: &JsValue, key: &str) -> Option<String> {
+    js_sys::Reflect::get(data, &JsValue::from_str(key)).ok()?.as_string()
+}
+
+/// `bytes` as an `ArrayBuffer` or `Uint8Array`.
+fn bytes(data: &JsValue) -> Option<Vec<u8>> {
+    let bytes = js_sys::Reflect::get(data, &JsValue::from_str("bytes")).ok()?;
+    if let Some(array) = bytes.dyn_ref::<js_sys::Uint8Array>() {
+        Some(array.to_vec())
+    } else if bytes.is_instance_of::<js_sys::ArrayBuffer>() {
+        Some(js_sys::Uint8Array::new(&bytes).to_vec())
+    } else {
+        None
+    }
 }

apps/gridcraft-web/src/hostmode.rs

@@ -1,28 +0,0 @@
-//! Pure host-mode rules, shared by the bridge ([`crate::host`]) and testable without a browser
-//! (like [`crate::prefs`]): the name the bridge fills in when a host's open request has none.
-//! Which pages host the app is `craft-web-host`'s.
-
-/// The file name used when an open request carries no usable one.
-pub const DEFAULT_OPEN_NAME: &str = "Book.xlsx";
-
-/// The name `craft-web-host` gives an open request that carries no usable one (it cleans a host's
-/// name and falls back to this).
-const NAMELESS: &str = "document";
-
-/// A usable file name for an open request: the cleaned name the crate hands over, or
-/// [`DEFAULT_OPEN_NAME`] when the host sent none.
-pub fn open_name(name: &str) -> String {
-    if name == NAMELESS { DEFAULT_OPEN_NAME.to_string() } else { name.to_string() }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn open_names_fall_back_to_the_default_when_the_host_sent_none() {
-        assert_eq!(open_name("Budget.xlsx"), "Budget.xlsx");
-        assert_eq!(open_name("Sheet2!Book.xlsx"), "Sheet2!Book.xlsx");
-        assert_eq!(open_name("document"), DEFAULT_OPEN_NAME, "what the crate says for a missing or blank name");
-    }
-}

apps/gridcraft-web/src/main.rs

@@ -10,24 +10,15 @@
 //!
 //! URL query flags: `?webgl` forces WebGL2; `?sample=sales|budget|grades` opens a sample;
 //! `?host=parent` (inside an `<iframe>`) talks to a same-origin parent page instead: it sends the
-//! workbook to open and stores what GridCraft saves (`host`). A page can host GridCraft in its
-//! own document (no iframe) with `data-host="page"` on the canvas, talking over DOM `CustomEvent`s
-//! on the canvas. `&author=` names the user for notes and comments in either host mode.
-//! `window.gridcraft` (`craft-web-api`) is the page command API in every mode: `request`,
-//! `execute`, `commands`, `docInspect`, `uiInspect` and `screenshot` over the control methods
-//! (`api`).
-//! `?chrome=none|notitlebar|nofiletab` leaves the title bar and/or the File tab undrawn for a host
-//! that embeds the sheet in its own window (see `Chrome`). Preferences (theme, interface size,
-//! editing options…) are kept in `localStorage` (`prefs`).
+//! workbook to open and stores what GridCraft saves (`host`), and `&author=` names the user for
+//! notes and comments. `?chrome=none|notitlebar|nofiletab` leaves the title bar and/or the File tab
+//! undrawn for a host that embeds the sheet in its own window (see `Chrome`). Preferences (theme,
+//! interface size, editing options…) are kept in `localStorage` (`prefs`).
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
-#[cfg(any(target_arch = "wasm32", test))]
-mod api;
 #[cfg(target_arch = "wasm32")]
 mod host;
 #[cfg(any(target_arch = "wasm32", test))]
-mod hostmode;
-#[cfg(any(target_arch = "wasm32", test))]
 mod prefs;
 #[cfg(target_arch = "wasm32")]
 mod web;

apps/gridcraft-web/src/web.rs

@@ -37,12 +37,9 @@ pub fn start() {
         {
             create.instance_descriptor.backends = eframe::wgpu::Backends::GL;
         }
-        // Host modes (`craft-web-host`): `?host=parent`, a same-origin page framing GridCraft (such
-        // as a Nextcloud app), opens workbooks in it and stores what it saves (`host`). Unframed
-        // there is no parent, so that URL on its own stays the normal app with downloads.
-        // `data-host="page"` on the canvas opts a page in instead: it runs GridCraft in its own
-        // document and talks over DOM `CustomEvent`s on the canvas.
-        let bridge = crate::host::Bridge::detect(&canvas);
+        // `?host=parent`: a same-origin page framing GridCraft (such as a Nextcloud app) opens
+        // workbooks in it and stores what it saves (`host`).
+        let bridge = if query_param("host").as_deref() == Some("parent") { crate::host::Bridge::new() } else { None };
         let app_bridge = bridge.clone();
         let result = eframe::WebRunner::new()
             .start(
@@ -51,7 +48,7 @@ pub fn start() {
                 Box::new(move |cc| {
                     let inbox: Inbox = Inbox::default();
                     let mut session = Session::new();
-                    // In host mode the host sends the workbook to edit; no sample meanwhile.
+                    // In host mode the parent sends the workbook to edit; no sample meanwhile.
                     let q = if app_bridge.is_some() { String::new() } else { query() };
                     if let Some(name) = q.split(['?', '&']).find_map(|kv| kv.strip_prefix("sample=")) {
                         let _ = session.execute("file.new", serde_json::json!({"sample": name}));
@@ -99,7 +96,6 @@ pub fn start() {
                         }
                         bridge.post_ready();
                     }
-                    crate::api::install(&mut app, cc.egui_ctx.clone());
                     Ok(Box::new(WebShell { app, inbox, bridge: app_bridge, prefs }))
                 }),
             )

contributors/people.toml

@@ -33,8 +33,7 @@ sync_github_name = false
 
 [people.vangel76]
 real_name = "Valentin Klein"
-display_name = "vangel76"
-sync_github_name = false
+sync_github_name = true
 
 [people.MacJedi42]
 sync_github_name = true

crates/calc/src/eval.rs

@@ -115,12 +115,6 @@ pub trait Host {
     fn visit_range(&mut self, _sheet: usize, _range: RangeRef, _f: &mut dyn FnMut(&Value) -> bool) -> bool {
         false
     }
-    /// `(sum, count)` of the numbers in a block that holds nothing but constants (no formula,
-    /// error or spilled value), added row-major from `0.0` exactly as `visit_range` would hand
-    /// them over. `None`: the block isn't like that, or this host can't tell.
-    fn range_sum(&mut self, _sheet: usize, _range: RangeRef) -> Option<(f64, u64)> {
-        None
-    }
     /// While a formula is calculated on demand inside another one: `stack_position()` where the
     /// outermost one started, which the stack budget is counted from.
     fn stack_top(&self) -> Option<usize> {

crates/calc/src/eval/call.rs

@@ -383,15 +383,6 @@ impl<'h> Evaluator<'h> {
     /// Adds one area to `acc`; `Err` is the result the function ends with.
     fn aggregate_area(&mut self, kind: Agg, a: &Area, acc: &mut Acc) -> Result<(), Ev> {
         if !a.range.is_single() {
-            // Adding the block's remembered sum to anything but +0.0 would add in another order.
-            // COUNT never reads the sum, so it may reuse every block.
-            if (kind == Agg::Count || acc.sum.to_bits() == 0)
-                && let Some((sum, count)) = self.host.range_sum(a.sheet, a.range)
-            {
-                acc.sum = sum;
-                acc.count = acc.count.saturating_add(count);
-                return Ok(());
-            }
             let mut error = None;
             let walked = self.host.visit_range(a.sheet, a.range, &mut |v| match acc.add_cell(kind, v) {
                 Ok(()) => true,

crates/calc/src/lib.rs

@@ -4,13 +4,10 @@
 #![forbid(unsafe_code)]
 
 pub mod eval;
-mod precision;
 pub mod recalc;
-mod spill_index;
 mod trimrange;
 
 pub use eval::{Area, SPECIAL_FUNCTIONS, is_known_function};
-pub use precision::DisplayedPrecision;
 pub use recalc::{Calc, Key, evaluate, now_serial};
 
 #[cfg(test)]

crates/calc/src/precision.rs

@@ -1,52 +0,0 @@
-//! "Set precision as displayed" (File › Options › Advanced; `fullPrecision="0"` in `.xlsx`,
-//! CalcPrecision in `.xls`): with it on, a number is stored as its cell's number format shows it,
-//! and formulas read those rounded values. The rounding itself is the number format crate's
-//! ([`gridcraft_numfmt::NumberFormat::round_as_displayed`]); this module looks up each cell's
-//! format, parsing every style's code once.
-
-use std::collections::HashMap;
-
-use gridcraft_core::{CellRef, Value};
-use gridcraft_model::{StyleId, Workbook};
-use gridcraft_numfmt::NumberFormat;
-
-/// Rounds values to their cell's displayed precision, remembering each style's parsed format.
-/// Styles don't change while it is used (one recalculation pass, one sweep of a workbook).
-#[derive(Default)]
-pub struct DisplayedPrecision {
-    /// Parsed format per style; `None` for General, which keeps the full value.
-    formats: HashMap<StyleId, Option<NumberFormat>>,
-}
-
-impl DisplayedPrecision {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// `n` as the format of `c` on sheet `sheet` displays it (the cell's own style, else its
-    /// row's, else its column's, as the grid shows it).
-    pub fn round(&mut self, wb: &Workbook, sheet: usize, c: CellRef, n: f64) -> f64 {
-        let Some(sh) = wb.sheet(sheet) else { return n };
-        let id = sh.style_id(c);
-        let fmt = self.formats.entry(id).or_insert_with(|| {
-            let f = NumberFormat::parse_cached(wb.styles.get(id).num_fmt.as_str());
-            (!f.is_general()).then_some(f)
-        });
-        match fmt {
-            Some(f) => f.round_as_displayed(n),
-            None => n,
-        }
-    }
-
-    /// Like [`DisplayedPrecision::round`] for a value: only numbers change.
-    pub fn round_value(&mut self, wb: &Workbook, sheet: usize, c: CellRef, v: Value) -> Value {
-        match v {
-            Value::Number(n) => {
-                let r = self.round(wb, sheet, c, n);
-                // Bit-equal results keep the value as it was (no needless change for undo/diffs).
-                if r.to_bits() == n.to_bits() { Value::Number(n) } else { Value::Number(r) }
-            }
-            v => v,
-        }
-    }
-}

crates/calc/src/recalc.rs

@@ -10,24 +10,13 @@
 //! and the formulas that read one are evaluated again until the loop settles
 //! (`PassHost::iterate_loops`).
 
-use std::collections::{BTreeMap, BTreeSet, VecDeque};
+use std::collections::VecDeque;
 
 use gridcraft_core::{Array, CellError, CellRef, RangeRef, Value};
 use gridcraft_formula::Expr;
 use gridcraft_model::{CalcMode, Workbook};
 
 use crate::eval::{Evaluator, Host, precedents, stack_position};
-use crate::spill_index::{SpillIndex, indexing_pays};
-
-/// Changed cells (in one `cells_changed`) from which a sheet's spill areas may be indexed.
-const INDEX_SPILLS_FROM: usize = 16;
-
-/// Whether a sheet's spill areas are indexed for a batch of `batch` changed cells of which
-/// `on_sheet` are on that sheet: the batch must be a paste, and registering the areas must cost
-/// less than walking them once for each of the sheet's own changed cells.
-fn index_spills<'a>(batch: usize, on_sheet: usize, areas: impl ExactSizeIterator<Item = &'a RangeRef>) -> bool {
-    batch > INDEX_SPILLS_FROM && areas.len() > 0 && indexing_pays(areas, on_sheet)
-}
 
 mod graph;
 mod pass_host;
@@ -48,61 +37,11 @@ pub struct Calc {
     /// Cells whose formulas have errors from cycles.
     pub circular: Vec<Key>,
     pub last_recalc_cells: usize,
-    /// The cells whose value is `#SPILL!`, kept so that finding the formulas an emptied cell or a
-    /// freed spill area may unblock doesn't walk every formula or window of cells. Filled in
-    /// `rebuild`, kept up to date by `cells_changed` and by the write-back of a run; an entry is
-    /// always checked against the workbook before it is used.
-    spill_errors: SpillErrors,
-}
-
-/// A set of cells by row, each row's columns in their own set: a window of rows and columns is
-/// found by one column range per row that has an entry, so the cost follows the cells in the
-/// window, not those to the side of it in the same rows.
-#[derive(Clone, Debug, Default)]
-struct SpillErrors {
-    rows: BTreeMap<(usize, u32), BTreeSet<u32>>,
-}
-
-impl SpillErrors {
-    fn is_empty(&self) -> bool {
-        self.rows.is_empty()
-    }
-
-    fn clear(&mut self) {
-        self.rows.clear();
-    }
-
-    fn insert(&mut self, (sheet, c): Key) {
-        self.rows.entry((sheet, c.row)).or_default().insert(c.col);
-    }
-
-    fn remove(&mut self, (sheet, c): &Key) {
-        if let Some(cols) = self.rows.get_mut(&(*sheet, c.row)) {
-            cols.remove(&c.col);
-            if cols.is_empty() {
-                self.rows.remove(&(*sheet, c.row));
-            }
-        }
-    }
-
-    /// The cells of `sheet` in `rows` x `cols` (both inclusive), in row-major order.
-    fn range(&self, sheet: usize, rows: (u32, u32), cols: (u32, u32)) -> impl Iterator<Item = CellRef> + '_ {
-        self.rows
-            .range((sheet, rows.0)..=(sheet, rows.1))
-            .flat_map(move |(&(_, row), set)| set.range(cols.0..=cols.1).map(move |&col| CellRef::new(row, col)))
-    }
 }
 
 impl Default for Calc {
     fn default() -> Self {
-        Calc {
-            graph: Graph::default(),
-            rng: 0x9E37_79B9_7F4A_7C15,
-            fixed_now: None,
-            circular: vec![],
-            last_recalc_cells: 0,
-            spill_errors: SpillErrors::default(),
-        }
+        Calc { graph: Graph::default(), rng: 0x9E37_79B9_7F4A_7C15, fixed_now: None, circular: vec![], last_recalc_cells: 0 }
     }
 }
 
@@ -186,15 +125,12 @@ impl Calc {
     pub fn rebuild(&mut self, wb: &Workbook) {
         self.graph = Graph::default();
         let mut circ = Vec::new();
-        self.spill_errors.clear();
         for (si, sheet) in wb.sheets.iter().enumerate() {
             for (c, cell) in sheet.cells.iter() {
-                if cell.value == Value::Error(CellError::Spill) {
-                    self.spill_errors.insert((si, c));
-                }
                 if let Some(f) = &cell.formula
-                    && let Some((areas, dynamic)) = f.with_expr(|e| precedents(wb, si, e))
+                    && let Some(e) = f.expr()
                 {
+                    let (areas, dynamic) = precedents(wb, si, &e);
                     self.graph.insert((si, c), Node { areas, dynamic });
                     if cell.value == Value::Error(CellError::Circ) {
                         circ.push((si, c));
@@ -252,20 +188,6 @@ impl Calc {
         out
     }
 
-    /// The cells of `sheet` in `rows` x `cols` (inclusive, `cols` a lower and an upper column) that
-    /// show `#SPILL!`, in row-major order.
-    fn spill_errors_in(&self, wb: &Workbook, sheet: usize, rows: (u32, u32), cols: (u32, u32)) -> Vec<CellRef> {
-        let Some(sh) = wb.sheet(sheet) else { return Vec::new() };
-        self.spill_errors.range(sheet, rows, cols).filter(|c| sh.cells.get(*c).is_some_and(|x| x.value == Value::Error(CellError::Spill))).collect()
-    }
-
-    /// The formulas showing `#SPILL!` on `sheet` at or above and to the left of `end`: what a
-    /// cell emptied or a spill area freed there may unblock.
-    fn unblock_candidates(&self, wb: &Workbook, sheet: usize, end: CellRef) -> Vec<Key> {
-        let cells = self.spill_errors_in(wb, sheet, (0, end.row), (0, end.col));
-        cells.into_iter().filter(|c| self.graph.nodes.contains_key(&(sheet, *c))).map(|c| (sheet, c)).collect()
-    }
-
     /// Recalculates every formula (F9 / Ctrl+Alt+F9, and after loading).
     pub fn recalc_all(&mut self, wb: &mut Workbook) {
         self.rebuild(wb);
@@ -287,19 +209,14 @@ impl Calc {
     pub fn cells_changed(&mut self, wb: &mut Workbook, changed: &[Key]) {
         let mut cleared: Vec<(usize, RangeRef)> = Vec::new();
         for &k in changed {
-            if wb.sheet(k.0).and_then(|s| s.cell(k.1)).is_some_and(|c| c.value == Value::Error(CellError::Spill)) {
-                self.spill_errors.insert(k);
-            } else {
-                self.spill_errors.remove(&k);
-            }
-            let precedent =
-                wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.as_ref()).and_then(|f| f.with_expr(|e| precedents(wb, k.0, e)));
+            let formula = wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.clone());
             let py = wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.py.as_ref());
             let python = py.is_some();
             // A Python cell whose result (if any) is not an array spills nothing.
             let spills = py.and_then(|p| p.result_value()).is_some_and(|v| matches!(v, Value::Array(_)));
-            match precedent {
-                Some((areas, dynamic)) => {
+            match formula.and_then(|f| f.expr()) {
+                Some(e) => {
+                    let (areas, dynamic) = precedents(wb, k.0, &e);
                     self.graph.insert(k, Node { areas, dynamic });
                 }
                 // See `rebuild`: its spill is laid out again from its result when it is calculated.
@@ -332,7 +249,6 @@ impl Calc {
                         && cell.formula.is_some()
                     {
                         cell.value = Value::Error(CellError::Name);
-                        self.spill_errors.remove(&k);
                     }
                 }
             }
@@ -348,40 +264,17 @@ impl Calc {
         let mut emptied: Vec<Key> = Vec::new();
         // Typing into (or clearing) a cell a dynamic array spills over (or would spill over)
         // re-evaluates the anchor, which may now be blocked or unblocked.
-        // With many changed cells (a paste) a sheet's spill areas are indexed once instead of being
-        // walked for each one, when registering them costs less than walking them would.
-        let mut areas = SpillIndex::default();
-        let mut strategy: HashMap<usize, bool> = HashMap::default();
-        let mut per_sheet: HashMap<usize, usize> = HashMap::default();
-        for k in changed {
-            *per_sheet.entry(k.0).or_insert(0) += 1;
-        }
-        let mut at = Vec::new();
         for &k in changed {
             if let Some(sh) = wb.sheet(k.0) {
-                let indexed = *strategy.entry(k.0).or_insert_with(|| {
-                    let indexed = index_spills(changed.len(), per_sheet[&k.0], sh.spill_ranges.values());
-                    if indexed {
-                        for (anchor, r) in &sh.spill_ranges {
-                            areas.insert_rect((k.0, *anchor), *r, false);
-                        }
-                    }
-                    indexed
-                });
-                if indexed {
-                    // Anchor order, as walking `spill_ranges` gives.
-                    areas.meeting(k.0, RangeRef::new(k.1, k.1), &mut at);
-                    seeds.extend(at.iter().filter(|a| **a != k.1).map(|a| (k.0, *a)));
-                } else {
-                    for (anchor, r) in &sh.spill_ranges {
-                        if *anchor != k.1 && r.contains(k.1) {
-                            seeds.push((k.0, *anchor));
-                        }
+                for (anchor, r) in &sh.spill_ranges {
+                    if *anchor != k.1 && r.contains(k.1) {
+                        seeds.push((k.0, *anchor));
                     }
                 }
-                if !self.spill_errors.is_empty() {
-                    let (r0, c0) = (k.1.row.saturating_sub(64), k.1.col.saturating_sub(64));
-                    seeds.extend(self.spill_errors_in(wb, k.0, (r0, k.1.row), (c0, k.1.col)).into_iter().filter(|c| *c != k.1).map(|c| (k.0, c)));
+                for (c, cell) in sh.cells.iter_range(RangeRef::new(CellRef::new(k.1.row.saturating_sub(64), k.1.col.saturating_sub(64)), k.1)) {
+                    if c != k.1 && cell.value == Value::Error(CellError::Spill) {
+                        seeds.push((k.0, c));
+                    }
                 }
                 if !sh.cells.has(k.1) {
                     match emptied.iter_mut().find(|x| x.0 == k.0) {
@@ -393,7 +286,11 @@ impl Calc {
         }
         // An emptied cell can unblock an anchor any distance above or to the left of it.
         for (si, end) in emptied {
-            seeds.extend(self.unblock_candidates(wb, si, end));
+            for &(s, c) in self.graph.nodes.keys() {
+                if s == si && c.row <= end.row && c.col <= end.col && wb.sheet(s).is_some_and(|sh| sh.value(c) == Value::Error(CellError::Spill)) {
+                    seeds.push((s, c));
+                }
+            }
         }
         // Spill areas of changed anchors also change. They stay rectangles: one seed per spilled
         // cell listed the formulas reading the area once per cell.
@@ -557,15 +454,10 @@ impl Calc {
         let mut freed = Vec::new();
         for (key, value) in results {
             let Some(sheet) = wb.sheet_mut(key.0) else { continue };
-            if let Some(cell) = sheet.cells.get_mut(key.1) {
-                if value == Value::Error(CellError::Spill) {
-                    self.spill_errors.insert(key);
-                } else {
-                    self.spill_errors.remove(&key);
-                }
-                if cell.value != value {
-                    cell.value = value;
-                }
+            if let Some(cell) = sheet.cells.get_mut(key.1)
+                && cell.value != value
+            {
+                cell.value = value;
             }
         }
         for key in dirty {
@@ -595,7 +487,6 @@ impl Calc {
                 if blocked {
                     if let Some(cell) = sheet.cells.get_mut(key.1) {
                         cell.value = Value::Error(CellError::Spill);
-                        self.spill_errors.insert(*key);
                     }
                     let mut blocked_dependents = Vec::new();
                     self.graph.dependents_of_range(key.0, range, &mut blocked_dependents);
@@ -622,7 +513,14 @@ impl Calc {
             }
         }
         for (sheet_index, range) in freed {
-            spill_changes.extend(self.unblock_candidates(wb, sheet_index, range.end));
+            for &(sheet, cell) in self.graph.nodes.keys() {
+                let was_blocked_cell = cell.row <= range.end.row
+                    && cell.col <= range.end.col
+                    && wb.sheet(sheet).is_some_and(|sheet| sheet.value(cell) == Value::Error(CellError::Spill));
+                if sheet == sheet_index && was_blocked_cell {
+                    spill_changes.push((sheet, cell));
+                }
+            }
         }
         spill_changes
     }
@@ -679,7 +577,7 @@ pub(crate) mod tests {
     use gridcraft_core::{CellRef, RangeRef, Value};
     use gridcraft_model::{Cell, Formula, Workbook};
 
-    use super::{Calc, HashMap, Host, Intervals, Key, PassHost, index_spills};
+    use super::{Calc, HashMap, Host, Intervals, Key, PassHost};
 
     /// xorshift64 for repeatable pseudo-random cases.
     fn rng(state: &mut u64) -> u64 {
@@ -696,19 +594,6 @@ pub(crate) mod tests {
         v
     }
 
-    /// One changed cell on a sheet with many small spills does not index them just because the
-    /// batch (mostly on another sheet) is large; the sheet's own share of the batch decides.
-    #[test]
-    fn the_spill_index_is_chosen_from_the_sheets_own_changed_cells() {
-        let small: Vec<RangeRef> = (0..1_000).map(|i| RangeRef::new(CellRef::new(i * 3, 0), CellRef::new(i * 3 + 2, 0))).collect();
-        // Same areas, same batch of 5000: indexed when 5000 of them are on the sheet, walked when 1 is.
-        assert!(index_spills(5_000, 5_000, small.iter()));
-        assert!(!index_spills(5_000, 1, small.iter()));
-        // Not a paste, or nothing to index: never.
-        assert!(!index_spills(16, 16, small.iter()));
-        assert!(!index_spills(5_000, 5_000, [].iter()));
-    }
-
     /// A 1,000 x 1,000 Python result laid out from A1 in a pass, with the same values already
     /// spilled on the sheet from the last calculation, as a full recalculation finds them.
     fn big_python_spill() -> (Workbook, HashMap<Key, Value>) {
@@ -751,39 +636,6 @@ pub(crate) mod tests {
         assert!(!host.visit_range(0, inside, &mut |_| true), "an overlapping read leaves the block to range_values");
     }
 
-    /// A Python array laid out in this pass is seen by the indexed readers, whether the sheet
-    /// has no spill from before or an older, smaller one.
-    #[test]
-    fn a_python_spill_found_in_the_pass_is_read_through_the_index() {
-        for stale in [false, true] {
-            let mut wb = Workbook::new();
-            let sh = wb.sheet_mut(0).unwrap();
-            let anchor = CellRef::new(0, 0);
-            let py = gridcraft_model::PyCode::new("grid");
-            sh.set_cell(anchor, Cell { value: Value::Number(0.0), py: Some(std::sync::Arc::new(py)), ..Cell::default() });
-            if stale {
-                // The last calculation spilled a 2 x 2 block of 100s.
-                sh.spill_ranges.insert(anchor, RangeRef::new(anchor, CellRef::new(1, 1)));
-                for c in RangeRef::new(anchor, CellRef::new(1, 1)).iter().skip(1) {
-                    sh.spill.insert(c, Value::Number(100.0));
-                }
-            }
-            let data: Vec<Value> = (1..=9).map(|i| Value::Number(f64::from(i))).collect();
-            let array = gridcraft_core::Array::new(3, 3, data).unwrap();
-            let mut python = HashMap::default();
-            python.insert((0, anchor), Value::Array(std::sync::Arc::new(array)));
-            let exprs = HashMap::default();
-            let mut rng = 1u64;
-            let mut host = PassHost::new(&wb, &exprs, &mut rng, 0.0).with_python(python);
-            assert_eq!(host.cell_value(0, anchor), Value::Number(1.0));
-            let all = RangeRef::parse("A1:C3").unwrap();
-            let sum: f64 = host.range_values(0, all).iter().map(|v| if let Value::Number(n) = v { *n } else { 0.0 }).sum();
-            assert_eq!(sum, 45.0, "stale={stale}: a SUM over the new 3 x 3 spill reads all of it");
-            assert_eq!(host.cell_value(0, CellRef::new(2, 2)), Value::Number(9.0), "stale={stale}");
-            assert!(!host.visit_range(0, all, &mut |_| true), "stale={stale}: the new spill leaves the block to range_values");
-        }
-    }
-
     #[test]
     fn intervals_match_a_linear_scan() {
         let mut iv: Intervals<u32> = Intervals::default();

crates/calc/src/recalc/pass_host.rs

@@ -1,6 +1,5 @@
 use super::graph::{HashMap, HashSet, Key};
 use super::{Evaluator, Host, Workbook, stack_position};
-use crate::spill_index::{Cover, SpillIndex};
 use gridcraft_core::{Array, CellError, CellRef, RangeRef, Value};
 use gridcraft_formula::Expr;
 
@@ -14,9 +13,6 @@ const MAX_NESTED: usize = 64;
 /// evaluated again), however high Maximum Iterations is.
 const MAX_ITERATION_WORK: usize = 10_000_000;
 
-/// A block's results by last row: its sum and count, or `None` when it can't be summed from constants.
-type BlockSums = std::collections::BTreeMap<u32, Option<(f64, u64)>>;
-
 pub(super) struct PassHost<'a> {
     wb: &'a Workbook,
     exprs: &'a HashMap<Key, std::sync::Arc<Expr>>,
@@ -25,8 +21,6 @@ pub(super) struct PassHost<'a> {
     in_progress: HashSet<Key>,
     /// New spills found during the pass: anchor → array.
     pub(super) spills: HashMap<Key, std::sync::Arc<Array>>,
-    /// Where the areas in `spills` are, so a read finds the ones it meets without scanning them all.
-    spill_index: SpillIndex,
     /// Used range per sheet: the workbook doesn't change during a pass, and working it out walks
     /// every row, so once per sheet rather than once per range read.
     used: HashMap<usize, Option<RangeRef>>,
@@ -70,17 +64,10 @@ pub(super) struct PassHost<'a> {
     pub(super) tainted: HashSet<Key>,
     /// Whether the formula being evaluated has read a previous value.
     taint: bool,
-    /// "Set precision as displayed" is on: results are rounded to their cells' formats before
-    /// they are stored or read by other formulas.
-    precision: Option<crate::DisplayedPrecision>,
     /// `stack_position()` where the outermost formula being calculated started.
     stack_top: usize,
     /// Whether an evaluation ran past the stack budget since the innermost formula started.
     out_of_stack: bool,
-    /// Sum and count of blocks that hold only constants, for `range_sum`. Keyed by sheet, first
-    /// cell and last column; each value maps a last row to the block's result (`None`: the block
-    /// has a formula, a Python cell, an error value or a spilled value, so every longer one has too).
-    sums: HashMap<(usize, CellRef, u32), BlockSums>,
     /// The kept results of the Python cells in the pass: a Python cell isn't evaluated, its
     /// result is laid out (an array spills from the cell, as a formula's does). Each one is in
     /// `pending` until it is laid out, so a formula that reads it first gets its new value.
@@ -96,7 +83,6 @@ impl<'a> PassHost<'a> {
             pending: exprs.keys().copied().collect(),
             in_progress: HashSet::default(),
             spills: HashMap::default(),
-            spill_index: SpillIndex::default(),
             used: HashMap::default(),
             rng,
             now,
@@ -118,10 +104,8 @@ impl<'a> PassHost<'a> {
             members: HashSet::default(),
             tainted: HashSet::default(),
             taint: false,
-            precision: wb.calc.precision_as_displayed.then(crate::DisplayedPrecision::new),
             stack_top: 0,
             out_of_stack: false,
-            sums: HashMap::default(),
             python: HashMap::default(),
         }
     }
@@ -135,30 +119,6 @@ impl<'a> PassHost<'a> {
     }
 }
 
-/// Most spill areas a range read meets before they are checked for overlapping one another by
-/// walking all of the pass's spills instead of comparing pairs.
-const MAX_UNORDERED_HITS: usize = 16;
-
-/// Whether an array at `anchor` covers `c`.
-fn spill_covers(anchor: CellRef, arr: &Array, c: CellRef) -> bool {
-    c.row >= anchor.row && c.col >= anchor.col && ((c.row - anchor.row) as usize) < arr.rows && ((c.col - anchor.col) as usize) < arr.cols
-}
-
-/// Whether two of the spill areas anchored at `hits` share a cell inside `range`.
-fn spill_hits_overlap(index: &SpillIndex, sheet: usize, hits: &[CellRef], range: RangeRef) -> bool {
-    let rects: Vec<RangeRef> = hits.iter().filter_map(|a| index.area(sheet, *a)).filter(|(_, empty)| !empty).map(|(r, _)| r).collect();
-    rects.iter().enumerate().any(|(i, a)| {
-        rects.iter().skip(i + 1).any(|b| {
-            a.intersects(b)
-                && RangeRef::new(
-                    CellRef::new(a.start.row.max(b.start.row), a.start.col.max(b.start.col)),
-                    CellRef::new(a.end.row.min(b.end.row), a.end.col.min(b.end.col)),
-                )
-                .intersects(&range)
-        })
-    })
-}
-
 /// Whether an array result at `k` can't spill: it is in a table, or its area runs off the sheet,
 /// overlaps merged cells, holds other cells, or another formula's spill (unless that formula is
 /// recalculated in this pass, and so may spill elsewhere now).
@@ -197,6 +157,13 @@ pub(super) fn spills_as_before(sheet: &gridcraft_model::Sheet, anchor: CellRef,
             .all(|(i, c)| c == anchor || (!sheet.cells.has(c) && sheet.spill.get(&c) == Some(arr.data.get(i).unwrap_or(&Value::Empty))))
 }
 
+/// The area an array anchored at `anchor` covers.
+fn array_area(anchor: CellRef, a: &Array) -> RangeRef {
+    let end =
+        CellRef::new(anchor.row.saturating_add((a.rows as u32).saturating_sub(1)), anchor.col.saturating_add((a.cols as u32).saturating_sub(1)));
+    RangeRef::new(anchor, end)
+}
+
 /// The spilled values `sheet` stores inside `range`, passed to `f` until it returns false. Values
 /// outside the range are not walked: with fewer rows in the range than spilled values, each row
 /// is looked up on its own; otherwise one ordered scan visits each spilled value at most once.
@@ -377,43 +344,20 @@ impl PassHost<'_> {
                     let data = a.data.iter().map(|x| if matches!(x, Value::Empty) { Value::Number(0.0) } else { x.clone() }).collect();
                     Array::new(a.rows, a.cols, data).map(std::sync::Arc::new).unwrap_or(a)
                 };
-                // Precision as displayed: each element takes the format of the cell it lands in.
-                let a = match self.precision.as_mut() {
-                    Some(p) if a.data.iter().any(|x| matches!(x, Value::Number(_))) => {
-                        let cols = a.cols.max(1);
-                        let data = a
-                            .data
-                            .iter()
-                            .enumerate()
-                            .map(|(i, x)| {
-                                let at = CellRef::new(k.1.row.saturating_add((i / cols) as u32), k.1.col.saturating_add((i % cols) as u32));
-                                p.round_value(self.wb, k.0, at, x.clone())
-                            })
-                            .collect();
-                        Array::new(a.rows, a.cols, data).map(std::sync::Arc::new).unwrap_or(a)
-                    }
-                    _ => a,
-                };
                 // A dynamic-array formula anchors a spill range even while its result is one
                 // value -- a FILTER matching one row, a SORT or UNIQUE over one item -- so `C1#`
                 // is the 1 x 1 range and `ROWS(C1#)` is 1, as in Excel (#1491). A formula that
                 // returns a scalar never reaches this arm, so it does not become an anchor.
-                self.spill_index.insert(k, a.rows, a.cols);
                 self.spills.insert(k, a.clone());
                 a.data.first().cloned().unwrap_or_default()
             }
             Value::Empty => Value::Number(0.0),
-            v @ Value::Number(_) => match self.precision.as_mut() {
-                Some(p) => p.round_value(self.wb, k.0, k.1, v),
-                None => v,
-            },
             v => v,
         };
         // An array that can't spill is #SPILL! for the formulas evaluated after it in this pass too.
         let v = match self.spills.get(&k) {
             Some(a) if spill_blocked(self, k, a) => {
                 self.spills.remove(&k);
-                self.spill_index.remove(k);
                 Value::Error(CellError::Spill)
             }
             _ => v,
@@ -433,7 +377,6 @@ impl PassHost<'_> {
                     && a.cols >= 1
                     && a.rows.checked_mul(a.cols).is_some_and(|n| n == a.data.len() && n <= gridcraft_model::python::MAX_RESULT_CELLS);
                 if sane {
-                    self.spill_index.insert(k, a.rows, a.cols);
                     self.spills.insert(k, a.clone());
                     a.data.first().cloned().unwrap_or_default()
                 } else {
@@ -445,7 +388,6 @@ impl PassHost<'_> {
         let v = match self.spills.get(&k) {
             Some(a) if spill_blocked(self, k, a) => {
                 self.spills.remove(&k);
-                self.spill_index.remove(k);
                 Value::Error(CellError::Spill)
             }
             _ => v,
@@ -492,11 +434,7 @@ impl PassHost<'_> {
         while passes < max_iterations.min(max_passes) && !self.converged(max_change) {
             self.prev = again.iter().filter_map(|k| self.results.remove(k).map(|v| (*k, v))).collect();
             self.pending = set.clone();
-            let gone: Vec<Key> = self.spills.keys().filter(|a| set.contains(a)).copied().collect();
-            for a in gone {
-                self.spills.remove(&a);
-                self.spill_index.remove(a);
-            }
+            self.spills.retain(|a, _| !set.contains(a));
             for k in &again {
                 self.calculate(*k);
             }
@@ -580,19 +518,17 @@ impl Host for PassHost<'_> {
         if self.pending.contains(&k) || self.results.contains_key(&k) {
             return self.compute(k);
         }
-        // A cell covered by a spill computed in this pass. Where several overlap, the first in
-        // `spills`' iteration order counts, as it always has.
-        let covering = match self.spill_index.covering(sheet, c) {
-            Cover::None => None,
-            Cover::One(a) => self.spills.get_key_value(&(sheet, a)),
-            Cover::Many => self.spills.iter().find(|(a, arr)| a.0 == sheet && spill_covers(a.1, arr, c)),
-        };
-        if let Some((anchor, arr)) = covering {
-            let (dr, dc) = ((c.row - anchor.1.row) as usize, (c.col - anchor.1.col) as usize);
-            if self.iterate && self.tainted.contains(anchor) {
-                self.taint = true;
+        // A cell covered by a spill computed in this pass.
+        for (anchor, arr) in &self.spills {
+            if anchor.0 == sheet && c.row >= anchor.1.row && c.col >= anchor.1.col {
+                let (dr, dc) = ((c.row - anchor.1.row) as usize, (c.col - anchor.1.col) as usize);
+                if dr < arr.rows && dc < arr.cols {
+                    if self.iterate && self.tainted.contains(anchor) {
+                        self.taint = true;
+                    }
+                    return arr.get(dr, dc).cloned().unwrap_or_default();
+                }
             }
-            return arr.get(dr, dc).cloned().unwrap_or_default();
         }
         self.wb.sheet(sheet).map(|s| s.value(c)).unwrap_or_default()
     }
@@ -631,44 +567,46 @@ impl Host for PassHost<'_> {
             }
         }
         if !self.spills.is_empty() {
-            let mut hits = Vec::new();
-            self.spill_index.meeting(sheet, range, &mut hits);
+            // Only the part of each array inside the range is walked: a large array beside a small
+            // read costs nothing.
+            let mut new: Vec<(usize, Value)> = Vec::new();
+            for (a, arr) in self.spills.iter().filter(|(a, _)| a.0 == sheet) {
+                let area = array_area(a.1, arr);
+                if !area.intersects(&range) {
+                    continue;
+                }
+                let (r0, r1) = (area.start.row.max(range.start.row), area.end.row.min(range.end.row));
+                let (c0, c1) = (area.start.col.max(range.start.col), area.end.col.min(range.end.col));
+                for row in r0..=r1 {
+                    for col in c0..=c1 {
+                        let c = CellRef::new(row, col);
+                        if c == a.1 {
+                            continue;
+                        }
+                        let v = arr.get((row - a.1.row) as usize, (col - a.1.col) as usize).cloned().unwrap_or_default();
+                        new.push(((row - range.start.row) as usize * w + (col - range.start.col) as usize, v));
+                    }
+                }
+            }
+            #[cfg(test)]
+            {
+                self.spill_visits += new.len();
+            }
             // Iterating: an array spilled by a formula that read a previous value.
-            if self.iterate && hits.iter().any(|a| self.tainted.contains(&(sheet, *a))) {
+            if self.iterate
+                && self.spills.iter().any(|(a, arr)| {
+                    let end = CellRef::new(
+                        a.1.row.saturating_add((arr.rows as u32).saturating_sub(1)),
+                        a.1.col.saturating_add((arr.cols as u32).saturating_sub(1)),
+                    );
+                    a.0 == sheet && self.tainted.contains(a) && RangeRef::new(a.1, end).intersects(&range)
+                })
+            {
                 self.taint = true;
             }
-            // Where areas overlap inside the range, the last in `spills`' iteration order wins,
-            // as it always has; otherwise the order doesn't matter.
-            let ordered = hits.len() > MAX_UNORDERED_HITS || spill_hits_overlap(&self.spill_index, sheet, &hits, range);
-            let mut put = |anchor: CellRef, arr: &Array| {
-                if arr.rows == 0 || arr.cols == 0 {
-                    return;
-                }
-                let (r0, c0) = (range.start.row.max(anchor.row), range.start.col.max(anchor.col));
-                let r1 = range.end.row.min(anchor.row.saturating_add((arr.rows as u32).saturating_sub(1)));
-                let c1 = range.end.col.min(anchor.col.saturating_add((arr.cols as u32).saturating_sub(1)));
-                for r in r0..=r1 {
-                    for cc in c0..=c1 {
-                        if (r, cc) != (anchor.row, anchor.col)
-                            && let Some(slot) = out.get_mut((r - range.start.row) as usize * w + (cc - range.start.col) as usize)
-                        {
-                            *slot = arr.get((r - anchor.row) as usize, (cc - anchor.col) as usize).cloned().unwrap_or_default();
-                        }
-                    }
-                }
-            };
-            if ordered {
-                let wanted: HashSet<Key> = hits.iter().map(|a| (sheet, *a)).collect();
-                for (a, arr) in &self.spills {
-                    if wanted.contains(a) {
-                        put(a.1, arr);
-                    }
-                }
-            } else {
-                for a in &hits {
-                    if let Some(arr) = self.spills.get(&(sheet, *a)) {
-                        put(*a, arr);
-                    }
+            for (i, v) in new {
+                if let Some(slot) = out.get_mut(i) {
+                    *slot = v;
                 }
             }
         }
@@ -687,8 +625,7 @@ impl Host for PassHost<'_> {
         }
         // Spilled values sit between the stored cells (and the formulas just calculated may have
         // produced some): leave such blocks to `range_values`.
-        let mut arrays = Vec::new();
-        self.spill_index.meeting(sheet, range, &mut arrays);
+        let arrays = self.spills.iter().any(|(a, arr)| a.0 == sheet && array_area(a.1, arr).intersects(&range));
         let mut stored = false;
         let _seen = stored_spill_in(sh, range, &mut |_, _| {
             stored = true;
@@ -698,7 +635,7 @@ impl Host for PassHost<'_> {
         {
             self.spill_visits += _seen;
         }
-        if !arrays.is_empty() || stored {
+        if arrays || stored {
             return false;
         }
         for (c, cell) in sh.cells.iter_range(range) {
@@ -709,50 +646,6 @@ impl Host for PassHost<'_> {
         }
         true
     }
-    fn range_sum(&mut self, sheet: usize, range: RangeRef) -> Option<(f64, u64)> {
-        // Constants can't change during a pass, so a block's result stays valid for it. Spills
-        // found in this pass (and iteration, which tracks what a read depends on) go the long way.
-        if self.iterate || self.spills.keys().any(|a| a.0 == sheet) {
-            return None;
-        }
-        let sh = self.wb.sheet(sheet)?;
-        let (key, last) = ((sheet, range.start, range.end.col), range.end.row);
-        let known = self.sums.entry(key).or_default();
-        if let Some(r) = known.get(&last) {
-            return *r;
-        }
-        // Start from the longest shorter block of the same rows from the top: summing row-major
-        // from there on is the same additions in the same order as one walk from the start.
-        let (from, mut sum, mut count) = match known.range(..last).next_back() {
-            Some((_, None)) => {
-                known.insert(last, None);
-                return None;
-            }
-            Some((&row, &Some((sum, count)))) => (row + 1, sum, count),
-            None => (range.start.row, 0.0, 0),
-        };
-        let rest = RangeRef::new(CellRef::new(from, range.start.col), range.end);
-        let mut plain = sh.spill.range(rest.start..=rest.end).all(|(c, _)| !rest.contains(*c));
-        if plain {
-            for (_, cell) in sh.cells.iter_range(rest) {
-                match &cell.value {
-                    _ if cell.formula.is_some() || cell.py.is_some() => plain = false,
-                    Value::Error(_) => plain = false,
-                    Value::Number(n) => {
-                        sum += n;
-                        count = u64::saturating_add(count, 1);
-                    }
-                    _ => {}
-                }
-                if !plain {
-                    break;
-                }
-            }
-        }
-        let result = plain.then_some((sum, count));
-        known.insert(last, result);
-        result
-    }
     fn used_range(&mut self, sheet: usize) -> Option<RangeRef> {
         let wb = self.wb;
         *self.used.entry(sheet).or_insert_with(|| wb.sheet(sheet).and_then(|s| s.used_range()))

crates/calc/src/spill_index.rs

@@ -1,296 +0,0 @@
-//! A spatial index over spill areas: which areas cover a cell, and which meet a range, without
-//! looking at every area. Areas are registered in 16 x 16 cell blocks, so a lookup touches one
-//! block (a cell) or the blocks a range covers (a range) rather than every spill on the sheet.
-//! An area that would take more than `BIG_AREA_BLOCKS` blocks (a full-height column spill takes
-//! 65,536) is not registered in blocks but kept in a short list that every lookup tests directly,
-//! so registering costs what the area's size warrants only for small areas.
-
-use crate::recalc::{FxHasher, Key};
-use gridcraft_core::{CellRef, RangeRef};
-use std::hash::BuildHasherDefault;
-
-type HashMap<K, V> = std::collections::HashMap<K, V, BuildHasherDefault<FxHasher>>;
-
-/// Block edge in cells (rows and columns).
-const BLOCK: u32 = 16;
-
-/// Areas spanning more blocks than this are tested directly instead of being registered.
-const BIG_AREA_BLOCKS: u64 = 1024;
-
-/// One indexed area: its rectangle, and whether it covers no cells (an array with no rows or no
-/// columns still meets the ranges its anchor is in, as a 1 x 1 area does for taint tracking).
-#[derive(Clone, Copy)]
-struct Entry {
-    rect: RangeRef,
-    empty: bool,
-}
-
-#[derive(Default)]
-struct SheetAreas {
-    entries: HashMap<CellRef, Entry>,
-    blocks: HashMap<(u32, u32), Vec<CellRef>>,
-    /// Anchors of the areas too big to register in blocks.
-    big: Vec<CellRef>,
-}
-
-/// What covers a cell.
-pub(crate) enum Cover {
-    None,
-    One(CellRef),
-    /// Several areas overlap here: the caller decides which one counts.
-    Many,
-}
-
-#[derive(Default)]
-pub(crate) struct SpillIndex {
-    sheets: HashMap<usize, SheetAreas>,
-}
-
-fn block_span(rect: &RangeRef) -> (u32, u32, u32, u32) {
-    (rect.start.row / BLOCK, rect.end.row / BLOCK, rect.start.col / BLOCK, rect.end.col / BLOCK)
-}
-
-fn block_count(rect: &RangeRef) -> u64 {
-    let (r0, r1, c0, c1) = block_span(rect);
-    u64::from(r1 - r0 + 1) * u64::from(c1 - c0 + 1)
-}
-
-/// Whether registering `areas` in blocks costs less than checking each of them against each of
-/// `lookups` cells would: a few block entries cost about one containment check each. A tall or
-/// wide area is not registered at all (see `BIG_AREA_BLOCKS`) and so costs nothing here.
-pub(crate) fn indexing_pays<'a>(areas: impl ExactSizeIterator<Item = &'a RangeRef>, lookups: usize) -> bool {
-    const BLOCK_COST: u64 = 16;
-    let budget = (lookups as u64).saturating_mul(areas.len() as u64) / BLOCK_COST;
-    let mut blocks = 0u64;
-    for r in areas {
-        let n = block_count(r);
-        if n > BIG_AREA_BLOCKS {
-            continue;
-        }
-        blocks = blocks.saturating_add(n);
-        if blocks > budget {
-            return false;
-        }
-    }
-    true
-}
-
-impl SpillIndex {
-    /// Whether any area is indexed on `sheet`.
-    #[cfg(test)]
-    pub(crate) fn has_sheet(&self, sheet: usize) -> bool {
-        self.sheets.get(&sheet).is_some_and(|s| !s.entries.is_empty())
-    }
-
-    /// Indexes the area an array of `rows` x `cols` anchored at `anchor` covers (replacing the
-    /// one already indexed for that anchor).
-    pub(crate) fn insert(&mut self, (sheet, anchor): Key, rows: usize, cols: usize) {
-        let end =
-            CellRef::new(anchor.row.saturating_add((rows as u32).saturating_sub(1)), anchor.col.saturating_add((cols as u32).saturating_sub(1)));
-        self.insert_rect((sheet, anchor), RangeRef::new(anchor, end), rows == 0 || cols == 0);
-    }
-
-    /// Indexes an area given as a range.
-    pub(crate) fn insert_rect(&mut self, (sheet, anchor): Key, rect: RangeRef, empty: bool) {
-        self.remove((sheet, anchor));
-        let areas = self.sheets.entry(sheet).or_default();
-        if block_count(&rect) > BIG_AREA_BLOCKS {
-            areas.big.push(anchor);
-        } else {
-            let (r0, r1, c0, c1) = block_span(&rect);
-            for br in r0..=r1 {
-                for bc in c0..=c1 {
-                    areas.blocks.entry((br, bc)).or_default().push(anchor);
-                }
-            }
-        }
-        areas.entries.insert(anchor, Entry { rect, empty });
-    }
-
-    pub(crate) fn remove(&mut self, (sheet, anchor): Key) {
-        let Some(areas) = self.sheets.get_mut(&sheet) else { return };
-        let Some(old) = areas.entries.remove(&anchor) else { return };
-        if block_count(&old.rect) > BIG_AREA_BLOCKS {
-            areas.big.retain(|a| *a != anchor);
-            return;
-        }
-        let (r0, r1, c0, c1) = block_span(&old.rect);
-        for br in r0..=r1 {
-            for bc in c0..=c1 {
-                if let Some(list) = areas.blocks.get_mut(&(br, bc)) {
-                    list.retain(|a| *a != anchor);
-                    if list.is_empty() {
-                        areas.blocks.remove(&(br, bc));
-                    }
-                }
-            }
-        }
-    }
-
-    /// The areas that cover `c`.
-    pub(crate) fn covering(&self, sheet: usize, c: CellRef) -> Cover {
-        let Some(areas) = self.sheets.get(&sheet) else { return Cover::None };
-        let in_block = areas.blocks.get(&(c.row / BLOCK, c.col / BLOCK)).map_or(&[][..], |l| l.as_slice());
-        let mut found = Cover::None;
-        for a in in_block.iter().chain(&areas.big) {
-            if let Some(e) = areas.entries.get(a)
-                && !e.empty
-                && e.rect.contains(c)
-            {
-                found = match found {
-                    Cover::None => Cover::One(*a),
-                    _ => return Cover::Many,
-                };
-            }
-        }
-        found
-    }
-
-    /// The anchors of the areas whose rectangle meets `range` (an empty area counts through its
-    /// anchor cell), sorted by anchor.
-    pub(crate) fn meeting(&self, sheet: usize, range: RangeRef, out: &mut Vec<CellRef>) {
-        out.clear();
-        let Some(areas) = self.sheets.get(&sheet) else { return };
-        let (r0, r1, c0, c1) = block_span(&range);
-        let touched = u64::from(r1 - r0 + 1) * u64::from(c1 - c0 + 1);
-        if touched > 4 * areas.entries.len() as u64 + 16 {
-            // A range wider than the areas are many: look at each area once.
-            out.extend(areas.entries.iter().filter(|(_, e)| e.rect.intersects(&range)).map(|(a, _)| *a));
-        } else {
-            for br in r0..=r1 {
-                for bc in c0..=c1 {
-                    if let Some(list) = areas.blocks.get(&(br, bc)) {
-                        out.extend(list.iter().copied().filter(|a| areas.entries.get(a).is_some_and(|e| e.rect.intersects(&range))));
-                    }
-                }
-            }
-            out.extend(areas.big.iter().copied().filter(|a| areas.entries.get(a).is_some_and(|e| e.rect.intersects(&range))));
-        }
-        out.sort_unstable();
-        out.dedup();
-    }
-
-    /// The rectangle indexed for `anchor` and whether it covers no cells.
-    pub(crate) fn area(&self, sheet: usize, anchor: CellRef) -> Option<(RangeRef, bool)> {
-        self.sheets.get(&sheet)?.entries.get(&anchor).map(|e| (e.rect, e.empty))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn at(r: u32, c: u32) -> CellRef {
-        CellRef::new(r, c)
-    }
-
-    #[test]
-    fn finds_the_areas_covering_a_cell_and_meeting_a_range() {
-        let mut ix = SpillIndex::default();
-        ix.insert((0, at(0, 0)), 40, 3);
-        ix.insert((0, at(30, 1)), 1, 40);
-        ix.insert((1, at(0, 0)), 5, 5);
-        assert!(matches!(ix.covering(0, at(39, 2)), Cover::One(a) if a == at(0, 0)));
-        assert!(matches!(ix.covering(0, at(30, 2)), Cover::Many));
-        assert!(matches!(ix.covering(0, at(40, 0)), Cover::None));
-        assert!(matches!(ix.covering(2, at(0, 0)), Cover::None));
-        let mut hits = Vec::new();
-        ix.meeting(0, RangeRef::new(at(30, 30), at(50, 60)), &mut hits);
-        assert_eq!(hits, vec![at(30, 1)]);
-        ix.meeting(0, RangeRef::new(at(0, 0), at(1_000_000, 16_000)), &mut hits);
-        assert_eq!(hits, vec![at(0, 0), at(30, 1)]);
-        ix.remove((0, at(30, 1)));
-        assert!(matches!(ix.covering(0, at(30, 2)), Cover::One(_)));
-        assert!(ix.has_sheet(1) && !ix.has_sheet(2));
-        ix.insert((0, at(0, 0)), 1, 1);
-        assert!(matches!(ix.covering(0, at(39, 2)), Cover::None));
-    }
-
-    #[test]
-    fn tall_or_wide_areas_are_not_registered_in_blocks() {
-        let column = RangeRef::new(at(0, 0), at(1_048_575, 0));
-        assert!(block_count(&column) > BIG_AREA_BLOCKS);
-        let mut ix = SpillIndex::default();
-        ix.insert_rect((0, at(0, 0)), column, false);
-        assert!(ix.sheets[&0].blocks.is_empty());
-        assert!(matches!(ix.covering(0, at(900_000, 0)), Cover::One(a) if a == at(0, 0)));
-        assert!(matches!(ix.covering(0, at(900_000, 1)), Cover::None));
-        let mut hits = Vec::new();
-        ix.meeting(0, RangeRef::new(at(5, 0), at(6, 3)), &mut hits);
-        assert_eq!(hits, vec![at(0, 0)]);
-        ix.remove((0, at(0, 0)));
-        assert!(matches!(ix.covering(0, at(900_000, 0)), Cover::None) && ix.sheets[&0].big.is_empty());
-        // Registering a big area costs nothing (lookups test it directly), so a small paste still indexes next to many small areas.
-        assert!(indexing_pays([column].iter(), 17));
-        // Many small areas pay back for a paste of a hundred cells, but not for a handful.
-        let small: Vec<RangeRef> = (0..1_000).map(|i| RangeRef::new(at(i * 3, 0), at(i * 3 + 2, 0))).collect();
-        assert!(indexing_pays(small.iter(), 100));
-        assert!(!indexing_pays(small.iter(), 17));
-    }
-
-    /// The index against the old way: test every area for every lookup. Mixed shapes: small,
-    /// thin and tall, wide, big (kept out of the blocks), empty, on two sheets, replaced and removed.
-    #[test]
-    fn matches_a_scan_of_every_area_on_mixed_shapes() {
-        let mut seed = 0x2545_F491_4F6C_DD1Du64;
-        let mut next = |n: u32| {
-            seed ^= seed << 13;
-            seed ^= seed >> 7;
-            seed ^= seed << 17;
-            (seed >> 11) as u32 % n
-        };
-        let mut ix = SpillIndex::default();
-        let mut model: std::collections::BTreeMap<(usize, CellRef), (RangeRef, bool)> = Default::default();
-        for step in 0..3_000 {
-            let sheet = next(2) as usize;
-            let anchor = at(next(400) * 5, next(40) * 3);
-            if next(4) == 0 {
-                ix.remove((sheet, anchor));
-                model.remove(&(sheet, anchor));
-            } else {
-                let (rows, cols) = match next(8) {
-                    0 => (0, 1 + next(5) as usize),
-                    1 => (1 + next(5) as usize, 0),
-                    2 => (5_000 + next(100_000) as usize, 1),
-                    3 => (1, 1 + next(40_000) as usize),
-                    4 => (200 + next(300) as usize, 40 + next(40) as usize),
-                    _ => (1 + next(60) as usize, 1 + next(40) as usize),
-                };
-                ix.insert((sheet, anchor), rows, cols);
-                let end = at(anchor.row + (rows as u32).saturating_sub(1), anchor.col + (cols as u32).saturating_sub(1));
-                model.insert((sheet, anchor), (RangeRef::new(anchor, end), rows == 0 || cols == 0));
-            }
-            if step % 7 != 0 {
-                continue;
-            }
-            let sheet = next(3) as usize;
-            for _ in 0..20 {
-                let cell = at(next(2_100), next(130));
-                let want: Vec<CellRef> =
-                    model.iter().filter(|((s, _), (r, e))| *s == sheet && !e && r.contains(cell)).map(|((_, a), _)| *a).collect();
-                match ix.covering(sheet, cell) {
-                    Cover::None => assert!(want.is_empty(), "{cell:?}"),
-                    Cover::One(a) => assert_eq!(want, vec![a], "{cell:?}"),
-                    Cover::Many => assert!(want.len() > 1, "{cell:?}"),
-                }
-                let (r0, c0) = (next(2_100), next(130));
-                let (tall, wide) = (if next(5) == 0 { 3_000 } else { 40 }, if next(5) == 0 { 130 } else { 20 });
-                let range = RangeRef::new(at(r0, c0), at(r0 + next(tall), c0 + next(wide)));
-                let want: Vec<CellRef> = model.iter().filter(|((s, _), (r, _))| *s == sheet && r.intersects(&range)).map(|((_, a), _)| *a).collect();
-                let mut got = Vec::new();
-                ix.meeting(sheet, range, &mut got);
-                assert_eq!(got, want, "{range:?}");
-            }
-        }
-    }
-
-    #[test]
-    fn an_area_without_cells_covers_none_but_is_met_at_its_anchor() {
-        let mut ix = SpillIndex::default();
-        ix.insert((0, at(3, 3)), 0, 4);
-        assert!(matches!(ix.covering(0, at(3, 3)), Cover::None));
-        let mut hits = Vec::new();
-        ix.meeting(0, RangeRef::new(at(3, 3), at(3, 3)), &mut hits);
-        assert_eq!(hits, vec![at(3, 3)]);
-    }
-}

crates/calc/src/tests.rs

@@ -1922,72 +1922,6 @@ fn offset_extreme_arguments_return_ref() {
     }
 }
 
-/// "Set precision as displayed": results are rounded to their cell's format before they are
-/// stored and before other formulas read them. Values observed in Excel (COM,
-/// `Workbook.PrecisionAsDisplayed = True`) with the same synthetic formulas.
-#[test]
-fn precision_as_displayed_rounds_results_by_cell_format() {
-    let fmt = |t: &mut T, at: &str, code: &str| {
-        let id = t.wb.styles.intern(gridcraft_model::Style { num_fmt: gridcraft_model::NumFmt::new(code), ..Default::default() });
-        t.wb.sheet_mut(0).unwrap().set_style(c(at), id);
-    };
-    let mut t = T::new();
-    t.set("A1", "=-130+657.91");
-    t.set("A2", "=A1*10");
-    t.set("A3", "=A1/7");
-    // Cross-cell: E2 rounds what it reads from E1; E1 itself (General) keeps full precision.
-    t.set("E1", "=10/3");
-    t.set("E2", "=E1");
-    t.set("E3", "=E2*10");
-    t.set("E4", "=E1*10");
-    // A spill: each element takes the format of the cell it lands in.
-    t.set("F1", "=SEQUENCE(3,1,0.123,0.111)");
-    t.set("G4", "=SUM(F1:F3)");
-    t.set("H1", "=TRUE");
-    t.set("H2", "=\"1.5\"");
-    // A conditional format rounds by the sign's section, not the one displayed: `[<1]0.00;0`
-    // shows 2+1/3 as `2` but stores 2.33, and stores -10/3 as -3.
-    t.set("J1", "=2+1/3");
-    t.set("J2", "=-10/3");
-    t.set("K1", "=J1*3");
-    t.set("K2", "=J2*3");
-    fmt(&mut t, "J1", "[<1]0.00;0");
-    fmt(&mut t, "J2", "[<1]0.00;0");
-    fmt(&mut t, "A1", "0");
-    fmt(&mut t, "A3", "0.0000");
-    fmt(&mut t, "E2", "0");
-    fmt(&mut t, "F1", "0.0");
-    fmt(&mut t, "F2", "0.0");
-    fmt(&mut t, "H1", "0");
-    fmt(&mut t, "H2", "0");
-    // Off: formats don't change values.
-    t.calc.recalc_all(&mut t.wb);
-    assert_eq!(t.num("A1"), -130.0 + 657.91);
-    assert_eq!(t.num("E2"), 10.0 / 3.0);
-    t.wb.calc.precision_as_displayed = true;
-    t.calc.recalc_all(&mut t.wb);
-    assert_eq!((t.num("A1"), t.num("A2"), t.num("A3")), (528.0, 5280.0, 75.4286));
-    assert_eq!((t.num("E1"), t.num("E2"), t.num("E3"), t.num("E4")), (10.0 / 3.0, 3.0, 30.0, 10.0 / 3.0 * 10.0));
-    let sh = t.wb.sheet(0).unwrap();
-    assert_eq!(
-        (sh.value(c("F1")), sh.value(c("F2")), sh.value(c("F3"))),
-        (Value::Number(0.1), Value::Number(0.2), Value::Number(0.123 + 0.111 * 2.0))
-    );
-    assert_eq!(t.num("G4"), 0.1 + 0.2 + (0.123 + 0.111 * 2.0));
-    assert_eq!((t.num("J1"), t.num("J2"), t.num("K1"), t.num("K2")), (2.33, -3.0, 2.33 * 3.0, -9.0));
-    // Booleans and text are left alone.
-    assert_eq!((t.get("H1"), t.get("H2")), (Value::Bool(true), Value::from("1.5")));
-    // An edit recalculates through the rounded values too.
-    t.set("A1", "=-130+657.41");
-    fmt(&mut t, "A1", "0");
-    t.calc.cells_changed(&mut t.wb, &[(0, c("A1"))]);
-    assert_eq!((t.num("A1"), t.num("A2")), (527.0, 5270.0));
-    // Off again: a recalculation brings back full precision.
-    t.wb.calc.precision_as_displayed = false;
-    t.calc.recalc_all(&mut t.wb);
-    assert_eq!(t.num("A2"), (-130.0 + 657.41) * 10.0);
-}
-
 #[test]
 fn analysis_toolpak_value_params_reject_multi_cell_references() {
     // Excel 365 (observed): EOMONTH, WORKDAY, COUPDAYS, BIN2DEC... give #VALUE! for a reference to more
@@ -2379,354 +2313,6 @@ fn loan_schedule_residue_keeps_excels_sign() {
     assert_eq!(t.get("P7"), Value::Text("".into()));
 }
 
-#[test]
-fn clearing_a_cell_unblocks_the_arrays_above_and_left_of_it() {
-    let mut t = T::new();
-    for r in 1..=50 {
-        t.set(&format!("D{r}"), &format!("={r}*2"));
-    }
-    t.set("B2", "7");
-    t.set("B1", "=SEQUENCE(3)");
-    t.set("C1", "=SEQUENCE(1,3)");
-    t.set("A20", "=B1+1");
-    assert_eq!(t.get("B1"), Value::Error(CellError::Spill));
-    assert_eq!(t.get("A20"), Value::Error(CellError::Spill));
-    // Emptied: the array above it spills.
-    t.wb.sheet_mut(0).unwrap().cells.remove(c("B2"));
-    t.calc.cells_changed(&mut t.wb, &[(0, c("B2"))]);
-    assert_eq!(t.num("B3"), 3.0);
-    assert_eq!(t.num("A20"), 2.0);
-    // Typing over the area blocks it again; far from it, nothing is disturbed.
-    t.set("B3", "9");
-    assert_eq!(t.get("B1"), Value::Error(CellError::Spill));
-    t.set("D50", "1");
-    assert_eq!(t.get("B1"), Value::Error(CellError::Spill));
-    assert_eq!(t.num("D49"), 98.0);
-    // Clearing it again frees the array.
-    t.set("B3", "");
-    assert_eq!(t.num("B3"), 3.0);
-}
-
-/// A sheet with `#SPILL!` cells in rows 0..64, columns 100..16384 (as blocked arrays leave), none
-/// near column A.
-fn spill_error_field() -> T {
-    let mut t = T::new();
-    let sh = t.wb.sheet_mut(0).unwrap();
-    for r in 0..64 {
-        for col in 100..16_384 {
-            sh.cells.set(CellRef::new(r, col), Cell::value(Value::Error(CellError::Spill)));
-        }
-    }
-    t.calc.recalc_all(&mut t.wb);
-    t
-}
-
-#[test]
-fn an_edit_far_left_of_many_spill_errors_does_not_disturb_them() {
-    let mut t = spill_error_field();
-    t.set("A65", "5");
-    assert_eq!(t.num("A65"), 5.0);
-    assert_eq!(t.get("CW1"), Value::Error(CellError::Spill));
-    assert_eq!(t.get("XFD64"), Value::Error(CellError::Spill));
-    // A blocked formula inside the window is still found when a cell to its right is cleared.
-    t.set("DA66", "7");
-    t.set("CZ66", "=SEQUENCE(1,3)");
-    assert_eq!(t.get("CZ66"), Value::Error(CellError::Spill));
-    t.wb.sheet_mut(0).unwrap().cells.remove(c("DA66"));
-    t.calc.cells_changed(&mut t.wb, &[(0, c("DA66"))]);
-    assert_eq!(t.num("DA66"), 2.0);
-}
-
-/// Probe: single-cell edits in column A below a block of `#SPILL!` cells to its right.
-/// `cargo test -p gridcraft-calc --release -- --ignored --nocapture spill_error_field_probe`
-#[test]
-#[ignore]
-#[allow(clippy::disallowed_methods)]
-fn spill_error_field_probe() {
-    let mut t = spill_error_field();
-    let mut best = std::time::Duration::MAX;
-    for i in 0..9 {
-        let start = std::time::Instant::now();
-        for _ in 0..100 {
-            t.set("A65", &format!("{i}"));
-        }
-        best = best.min(start.elapsed());
-    }
-    eprintln!("100 edits of A65 beside 1,040,000 spill errors: best of 9 = {best:?}");
-}
-
-/// A full-height column spill (inside the 10,000,000-cell cap) and a paste of 17 cells elsewhere:
-/// the paste must not register the spill's 65,536 blocks, and a paste over the spill must still
-/// block it.
-fn tall_spill_book() -> T {
-    let mut t = T::new();
-    t.set("A1", "=SEQUENCE(1048576)");
-    t.calc.recalc_all(&mut t.wb);
-    assert_eq!(t.num("A1048576"), 1_048_576.0);
-    t
-}
-
-fn paste_into(t: &mut T, cells: &[(u32, u32)]) {
-    let changed: Vec<(usize, CellRef)> = cells.iter().map(|&(r, c)| (0, CellRef::new(r, c))).collect();
-    for k in &changed {
-        t.wb.sheet_mut(0).unwrap().cells.set(k.1, Cell::value(Value::Number(1.0)));
-    }
-    t.calc.cells_changed(&mut t.wb, &changed);
-}
-
-#[test]
-fn a_paste_beside_a_tall_spill_leaves_it_alone_and_one_over_it_blocks_it() {
-    let mut t = tall_spill_book();
-    let beside: Vec<(u32, u32)> = (0..17).map(|i| (i, 5)).collect();
-    paste_into(&mut t, &beside);
-    assert_eq!(t.num("A1048576"), 1_048_576.0);
-    let over: Vec<(u32, u32)> = (0..17).map(|i| (500_000 + i, if i == 9 { 0 } else { 5 })).collect();
-    paste_into(&mut t, &over);
-    assert_eq!(t.get("A1"), Value::Error(CellError::Spill));
-}
-
-/// Probe: `cells_changed` for a 17-cell paste in column F beside the tall spill.
-/// `cargo test -p gridcraft-calc --release -- --ignored --nocapture tall_spill_paste_probe`
-#[test]
-#[ignore]
-#[allow(clippy::disallowed_methods)]
-fn tall_spill_paste_probe() {
-    let mut t = tall_spill_book();
-    let mut best = std::time::Duration::MAX;
-    for round in 0..9u32 {
-        let beside: Vec<(u32, u32)> = (0..17).map(|i| (round * 20 + i, 5)).collect();
-        let start = std::time::Instant::now();
-        paste_into(&mut t, &beside);
-        best = best.min(start.elapsed());
-    }
-    eprintln!("tall spill, 17-cell paste beside it: best of 9 = {best:?}");
-}
-
-#[test]
-fn many_spills_are_read_and_blocked_by_a_paste() {
-    let mut t = T::new();
-    // 40 arrays of 3 rows side by side in rows 1-3, and a reader of a range over two of them.
-    for i in 0..40u32 {
-        let anchor = CellRef::new(0, 2 * i);
-        t.wb.sheet_mut(0).unwrap().cells.set(anchor, Cell::formula(Formula::new(&format!("=SEQUENCE(3,1,{})", 10 * i))));
-    }
-    t.set("A10", "=SUM(C1:F3)");
-    t.set("A12", "=COUNT(C1:F3)");
-    t.set("A11", "=C2*1");
-    t.calc.recalc_all(&mut t.wb);
-    assert_eq!(t.num("A10"), (10 + 11 + 12 + 20 + 21 + 22) as f64);
-    assert_eq!(t.num("A11"), 11.0);
-    assert_eq!(t.num("A12"), 6.0);
-    // Pasting 20 cells (more than one spill's width worth, so the changed set is indexed) over
-    // the second row of every other array blocks those arrays; the rest are unchanged.
-    let changed: Vec<(usize, CellRef)> = (0..20u32).map(|i| (0, CellRef::new(1, 4 * i))).collect();
-    for k in &changed {
-        t.wb.sheet_mut(0).unwrap().cells.set(k.1, Cell::value(Value::Number(1.0)));
-    }
-    t.calc.cells_changed(&mut t.wb, &changed);
-    assert_eq!(t.get("E1"), Value::Error(CellError::Spill));
-    assert_eq!(t.get("C1"), Value::Number(10.0));
-    assert_eq!(t.get("G2"), Value::Number(31.0));
-    assert_eq!(t.get("A10"), Value::Error(CellError::Spill));
-    assert_eq!(t.num("A12"), 4.0);
-}
-
-#[test]
-fn a_paste_over_small_and_tall_spills_blocks_those_it_touches() {
-    let mut t = T::new();
-    for i in 0..40u32 {
-        t.wb.sheet_mut(0).unwrap().cells.set(CellRef::new(0, 2 * i), Cell::formula(Formula::new("=SEQUENCE(3)")));
-    }
-    t.wb.sheet_mut(0).unwrap().cells.set(CellRef::new(0, 200), Cell::formula(Formula::new("=SEQUENCE(1048576)")));
-    t.calc.recalc_all(&mut t.wb);
-    // 20 cells: the middle row of the small arrays in columns 0, 8, 16 ... 72 (columns 80 and up hit
-    // nothing), and one deep inside the tall one.
-    let mut cells: Vec<(u32, u32)> = (0..19u32).map(|i| (1, 8 * i)).collect();
-    cells.push((700_000, 200));
-    paste_into(&mut t, &cells);
-    assert_eq!(t.get("A1"), Value::Error(CellError::Spill));
-    assert_eq!(t.get("GS1"), Value::Error(CellError::Spill));
-    assert_eq!(t.num("C1"), 1.0);
-    assert_eq!(t.num("C3"), 3.0);
-    assert_eq!(t.get("I1"), Value::Error(CellError::Spill));
-    assert_eq!(t.num("E3"), 3.0);
-}
-
-#[test]
-fn a_big_paste_on_one_sheet_and_one_cell_over_many_spills_on_another() {
-    let mut t = T::new();
-    t.wb.sheets.push(std::sync::Arc::new(gridcraft_model::Sheet::new("Data")));
-    for i in 0..1_500u32 {
-        t.wb.sheet_mut(1).unwrap().cells.set(CellRef::new(4 * i, 0), Cell::formula(Formula::new(&format!("=SEQUENCE(3,1,{})", 10 * i))));
-    }
-    t.calc.recalc_all(&mut t.wb);
-    assert_eq!(t.wb.sheet(1).unwrap().value(CellRef::new(4 * 700 + 2, 0)), Value::Number(7002.0));
-    // 5000 cells pasted on the first sheet, one over the middle of the 701st array on the second.
-    let mut changed: Vec<(usize, CellRef)> = (0..5_000u32).map(|i| (0, CellRef::new(i / 50, i % 50))).collect();
-    changed.push((1, CellRef::new(4 * 700 + 1, 0)));
-    for k in &changed {
-        t.wb.sheet_mut(k.0).unwrap().cells.set(k.1, Cell::value(Value::Number(1.0)));
-    }
-    t.calc.cells_changed(&mut t.wb, &changed);
-    let data = t.wb.sheet(1).unwrap();
-    assert_eq!(data.value(CellRef::new(4 * 700, 0)), Value::Error(CellError::Spill));
-    assert_eq!(data.value(CellRef::new(4 * 699 + 2, 0)), Value::Number(6992.0));
-    assert_eq!(data.value(CellRef::new(4 * 701 + 2, 0)), Value::Number(7012.0));
-}
-
-/// `SUM`, `COUNT` and `AVERAGE` over blocks of constants share one pass-wide answer per block, and a
-/// running total extends the shorter block's. Every result must equal the left-to-right sum of the
-/// cells, bit for bit, with text, blanks, errors, formulas and a nonzero start in the mix.
-#[test]
-fn aggregates_over_ranges_match_a_plain_fold_bit_for_bit() {
-    struct Rng(u64);
-    impl Rng {
-        fn next(&mut self, n: u64) -> u64 {
-            self.0 ^= self.0 << 13;
-            self.0 ^= self.0 >> 7;
-            self.0 ^= self.0 << 17;
-            self.0 % n
-        }
-    }
-    let nums = [0.1, 0.2, 0.3, 1e16, -1e16, 1.0, 3.7, -0.0, 12345.678, 1e-9, 7.0];
-    let rows = 40u32;
-    let mut rng = Rng(0x9E37_79B9_7F4A_7C15);
-    let mut wb = Workbook::new();
-    let fresh = |rng: &mut Rng, plain: bool| match rng.next(if plain { 8 } else { 14 }) {
-        0 => Cell::value(Value::text("t")),
-        1 => Cell::default(),
-        2 => Cell::value(Value::Bool(true)),
-        3 if !plain => Cell::value(Value::Error(CellError::NA)),
-        4 if !plain => Cell::formula(Formula::new("=A1*2")),
-        5 if !plain => Cell::formula(Formula::new("=\"x\"&B2")),
-        _ => Cell::value(Value::Number(nums[rng.next(nums.len() as u64) as usize])),
-    };
-    // Columns A:C mostly numbers; E holds a formula column and some errors only in a few rows.
-    for r in 0..rows {
-        for col in 0..3 {
-            let plain = !(r % 13 == 7 && col == 1);
-            wb.sheet_mut(0).unwrap().cells.set(CellRef::new(r, col), fresh(&mut rng, plain));
-        }
-    }
-    // Formulas in column H and up: (function, optional leading number, blocks).
-    type Oracle<'a> = (CellRef, &'a str, Option<f64>, Vec<(u32, u32, u32, u32)>);
-    let mut oracle: Vec<Oracle> = vec![];
-    let funcs = ["SUM", "COUNT", "AVERAGE"];
-    let mut at = 0;
-    let mut add = |wb: &mut Workbook, f: &'static str, lead: Option<f64>, blocks: Vec<(u32, u32, u32, u32)>| {
-        let args: Vec<String> = blocks
-            .iter()
-            .map(|&(r0, c0, r1, c1)| format!("{}{}:{}{}", (b'A' + c0 as u8) as char, r0 + 1, (b'A' + c1 as u8) as char, r1 + 1))
-            .collect();
-        let lead_s = lead.map(|l| format!("{l:e},")).unwrap_or_default();
-        let cell = CellRef::new(at % rows, 7 + at / rows);
-        wb.sheet_mut(0).unwrap().cells.set(cell, Cell::formula(Formula::new(&format!("={f}({lead_s}{})", args.join(",")))));
-        oracle.push((cell, f, lead, blocks));
-        at += 1;
-    };
-    // Running totals over a clean column and over a column with an error further down.
-    for r in 0..rows {
-        add(&mut wb, "SUM", None, vec![(0, 0, r, 0)]);
-        add(&mut wb, "SUM", None, vec![(0, 1, r, 1)]);
-        add(&mut wb, "COUNT", None, vec![(0, 0, r, 2)]);
-    }
-    for _ in 0..120 {
-        let (r0, r1) = (rng.next(rows as u64) as u32, rng.next(rows as u64) as u32);
-        let (c0, c1) = (rng.next(3) as u32, rng.next(3) as u32);
-        let n = 1 + rng.next(2) as usize;
-        let blocks = (0..n).map(|_| (r0.min(r1), c0.min(c1), r0.max(r1), c0.max(c1))).collect();
-        let lead = [None, Some(1e16), Some(0.5), Some(2.0)][rng.next(4) as usize];
-        let f = funcs[rng.next(3) as usize];
-        add(&mut wb, f, lead, blocks);
-    }
-    let check = |wb: &Workbook, when: &str| {
-        let sh = wb.sheet(0).unwrap();
-        for (cell, f, lead, blocks) in &oracle {
-            let (mut sum, mut count, mut error) = (lead.unwrap_or(0.0), u64::from(lead.is_some()), None);
-            for &(r0, c0, r1, c1) in blocks {
-                for r in r0..=r1 {
-                    for col in c0..=c1 {
-                        match sh.value(CellRef::new(r, col)) {
-                            Value::Number(n) => {
-                                sum += n;
-                                count += 1;
-                            }
-                            Value::Error(e) if *f != "COUNT" => error = error.or(Some(e)),
-                            _ => {}
-                        }
-                    }
-                }
-            }
-            let want = match (error, *f) {
-                (Some(e), _) => Value::Error(e),
-                (_, "SUM") => Value::number(sum),
-                (_, "COUNT") => Value::number(count as f64),
-                (_, _) if count == 0 => Value::Error(CellError::Div0),
-                _ => Value::number(sum / count as f64),
-            };
-            let got = sh.value(*cell);
-            let same = match (&got, &want) {
-                (Value::Number(a), Value::Number(b)) => a.to_bits() == b.to_bits(),
-                (a, b) => a == b,
-            };
-            assert!(same, "{when}: {:?} = {:?}, plain fold {:?}", cell, got, want);
-        }
-    };
-    let mut calc = Calc::new();
-    calc.rebuild(&wb);
-    calc.recalc_all(&mut wb);
-    check(&wb, "full recalc");
-    for round in 0..30 {
-        let mut changed = vec![];
-        for _ in 0..1 + rng.next(4) {
-            let at = CellRef::new(rng.next(rows as u64) as u32, rng.next(3) as u32);
-            wb.sheet_mut(0).unwrap().cells.set(at, fresh(&mut rng, round % 2 == 0));
-            changed.push((0, at));
-        }
-        calc.cells_changed(&mut wb, &changed);
-        check(&wb, &format!("edit round {round}"));
-    }
-}
-
-/// `rebuild` and `cells_changed` read formulas through `Formula::with_expr`, which borrows the
-/// cached tree or parses on the fly. The dependency graph must come out the same for formulas that
-/// carry their tree and for formulas that only carry their text (as after loading a file).
-#[test]
-fn graph_built_from_text_only_formulas_matches_cached() {
-    fn run(cached: bool) -> Vec<Value> {
-        let mut t = T::new();
-        t.set("A1", "2");
-        for (at, f) in [("B1", "=A1*10"), ("C1", "=B1+A1"), ("D1", "=SUM(A1:C1)"), ("E1", "=NOPE(")] {
-            // E1 does not parse, so it has no tree either way and only covers the `None` branch.
-            let mut formula = Formula::new(f);
-            if !cached {
-                formula.expr = None;
-            }
-            t.wb.sheet_mut(0).unwrap().cells.set(c(at), Cell::formula(formula));
-        }
-        t.calc.rebuild(&t.wb);
-        t.calc.recalc_all(&mut t.wb);
-        let mut out: Vec<Value> = ["B1", "C1", "D1", "E1"].iter().map(|a| t.get(a)).collect();
-        // Editing the input must reach the dependents through the rebuilt graph.
-        t.set("A1", "5");
-        out.extend(["B1", "C1", "D1"].iter().map(|a| t.get(a)));
-        // A text-only formula that is rewritten through `cells_changed` joins the graph too.
-        let mut formula = Formula::new("=A1+100");
-        if !cached {
-            formula.expr = None;
-        }
-        t.wb.sheet_mut(0).unwrap().cells.set(c("F1"), Cell::formula(formula));
-        t.calc.cells_changed(&mut t.wb, &[(0, c("F1"))]);
-        t.set("A1", "7");
-        out.push(t.get("F1"));
-        out
-    }
-    let cached = run(true);
-    assert_eq!(cached, run(false));
-    assert_eq!(cached[4], Value::Number(50.0));
-    assert_eq!(cached[7], Value::Number(107.0));
-}
-
 /// Makes `at` a Python cell showing `cached` (its value before this calculation), with `result`
 /// as its kept result, and returns the cell's key for `Calc::cells_changed`.
 fn plant_python(t: &mut T, at: &str, cached: Value, result: Value) -> (usize, CellRef) {

crates/chart/src/axis.rs

@@ -25,11 +25,9 @@ impl Scale {
         (0..=n)
             .map(|i| {
                 let v = self.min + i as f64 * self.step;
-                // Snap away accumulated float error, but only onto a multiple of the step that is
-                // really that close: a `min` off the step grid must keep its own ticks.
+                // Snap away accumulated float error.
                 let snapped = (v / self.step).round() * self.step;
-                let v = if (snapped - v).abs() < self.step * 1e-9 { snapped } else { v };
-                if v.abs() < self.step * 1e-9 { 0.0 } else { v }
+                if snapped.abs() < self.step * 1e-9 { 0.0 } else { snapped }
             })
             .collect()
     }
@@ -109,6 +107,11 @@ pub fn nice_scale(lo: f64, hi: f64, force_zero: bool) -> Scale {
     Scale { min, max, step }
 }
 
+/// Exact fixed scale (100% stacked axes).
+pub(crate) fn fixed_scale(min: f64, max: f64, step: f64) -> Scale {
+    Scale { min, max, step }
+}
+
 /// A number format prepared once and reused for many labels.
 pub(crate) struct Fmt {
     general: bool,

crates/chart/src/render.rs

@@ -1,12 +1,11 @@
 //! Chart layout: title, legend, axes and every chart kind, drawn into [`Prim`]s.
 
-use std::borrow::Cow;
 use std::f32::consts::{PI, TAU};
 
 use gridcraft_model::{Chart, ChartKind, LineDash, QuartileMethod, Theme, TrendlineKind};
 
-use crate::axis::{Fmt, Scale, clean, nice_scale};
-use crate::resolve::{MAX_POINTS, MAX_SERIES, MAX_TRENDLINES, points_per_series, series_color};
+use crate::axis::{Fmt, Scale, clean, fixed_scale, nice_scale};
+use crate::resolve::{MAX_POINTS, MAX_SERIES, MAX_TRENDLINES, series_color};
 use crate::trend::{auto_name, fit_trendline, moving_average};
 use crate::{ChartData, HAlign, Measure, Prim, Rgba, SeriesData, VAlign};
 
@@ -20,7 +19,7 @@ mod trend;
 
 use cartesian::{cartesian, scatter};
 use frame::{Bx, axis_titles, chart_title};
-use kinds::{box_whisker, doughnut, funnel, histogram, pie, radar, stock, treemap, waterfall};
+use kinds::{box_whisker, funnel, histogram, pie, radar, stock, treemap, waterfall};
 use legend::draw_legend;
 pub use legend::{Swatch, legend_entries};
 pub use trend::supports_trendline;
@@ -45,66 +44,31 @@ const MAX_LINE_PTS: usize = 2000;
 const MAX_MARKERS: usize = 5000;
 /// Data labels are skipped when a series has more points than this.
 const MAX_LABELS: usize = 200;
-/// Columns and bars narrower than this (in pixels) are merged per pixel column into one rectangle.
-const MIN_BAR_PX: f32 = 0.25;
-/// Most wedges a doughnut draws for the whole chart. The per-series and per-category limits do not
-/// bound their product: 255 series of 20,000 categories would be millions of wedges. Every drawable
-/// ring shares this budget, so the innermost ring keeps its largest slices and the outer rings are
-/// capped instead of the chart dropping rings wholesale.
-pub(crate) const MAX_WEDGES: usize = 2_048;
 
 struct Ctx<'a> {
     out: Vec<Prim>,
     m: &'a dyn Measure,
 }
 
-#[cfg(test)]
-#[path = "render_perf_tests.rs"]
-mod perf_tests;
-
 impl Ctx<'_> {
     fn tw(&self, s: &str, size: f32) -> f32 {
         let w = self.m.text_width(s, size, false);
         if w.is_finite() { w.max(0.0) } else { 0.0 }
     }
-    /// `s` shortened with an ellipsis to fit `maxw`; empty when not even one character fits.
-    ///
-    /// Binary search over the number of kept characters (at most 400 are tried), about nine
-    /// `Measure` calls instead of one per character. It assumes the width of `prefix + "…"` does not
-    /// shrink as the prefix grows, which holds for per-character advance sums (`ApproxMeasure`, the
-    /// PDF metrics) and for the UI's text layout up to kerning of a few hundredths of a point; with
-    /// such a non-monotone measure the result may differ from the old linear scan by a character.
-    /// A label with a line break is not monotone (the ellipsis moves to a new line and the widest
-    /// line can get shorter), so it takes the linear scan, longest prefix first.
     fn fit(&self, s: &str, size: f32, maxw: f32) -> String {
         if self.tw(s, size) <= maxw {
             return s.to_string();
         }
-        // Byte offset where each of the first 400 characters starts; a prefix of `k` characters
-        // (k < number of characters, so the offset exists) ends at `starts[k]`.
-        let starts: Vec<usize> = s.char_indices().map(|(i, _)| i).take(400).collect();
-        let top = starts.len().saturating_sub(1);
-        let fits = |k: usize| -> bool {
-            let end = starts.get(k).copied().unwrap_or(s.len());
-            let mut t = String::with_capacity(end + 3);
-            t.push_str(s.get(..end).unwrap_or(""));
-            t.push('…');
-            self.tw(&t, size) <= maxw
-        };
-        if s.contains('\n') {
-            let k = (1..=top).rev().find(|&k| fits(k));
-            return k.map_or_else(String::new, |k| format!("{}…", s.get(..starts.get(k).copied().unwrap_or(s.len())).unwrap_or("")));
-        }
-        let (mut lo, mut hi) = (0usize, top);
-        while lo < hi {
-            let mid = lo + (hi - lo).div_ceil(2);
-            if fits(mid) {
-                lo = mid;
-            } else {
-                hi = mid - 1;
+        let chars: Vec<char> = s.chars().collect();
+        let mut n = chars.len().min(400);
+        while n > 0 {
+            n -= 1;
+            let t: String = chars.iter().take(n).collect::<String>() + "…";
+            if self.tw(&t, size) <= maxw {
+                return if n == 0 { String::new() } else { t };
             }
         }
-        if lo == 0 { String::new() } else { format!("{}…", s.get(..starts.get(lo).copied().unwrap_or(s.len())).unwrap_or("")) }
+        String::new()
     }
     fn text(&mut self, x: f32, y: f32, s: &str, size: f32, color: Rgba, (align, valign): (HAlign, VAlign)) {
         if s.is_empty() {
@@ -132,7 +96,7 @@ fn sanitize_vals(v: &[Option<f64>]) -> Vec<Option<f64>> {
     v.iter().take(MAX_POINTS).map(|x| x.filter(|n| n.is_finite()).map(clean)).collect()
 }
 
-pub(crate) fn sanitize(d: &ChartData) -> ChartData {
+fn sanitize(d: &ChartData) -> ChartData {
     ChartData {
         palette: d.palette.iter().take(MAX_POINTS).copied().collect(),
         categories: d.categories.iter().take(MAX_POINTS).cloned().collect(),
@@ -157,62 +121,12 @@ pub(crate) fn sanitize(d: &ChartData) -> ChartData {
     }
 }
 
-/// Whether `v` survives `sanitize_vals` unchanged.
-fn is_clean(v: &Option<f64>) -> bool {
-    v.is_none_or(|n| n.is_finite() && clean(n) == n)
-}
-
-/// Whether [`sanitize`] and [`apply_budget`] would change `d`.
-fn needs_sanitizing(d: &ChartData) -> bool {
-    let cap = points_per_series(d.series.len());
-    let long = |n: usize| n > cap;
-    let mut trendlines = 0usize;
-    d.palette.len() > MAX_POINTS
-        || long(d.categories.len())
-        || d.category_levels.len() > 3
-        || d.category_levels.iter().any(|l| l.len() > MAX_POINTS)
-        || d.series.len() > MAX_SERIES
-        || d.series.iter().any(|s| {
-            trendlines += s.trendlines.len();
-            long(s.values.len())
-                || !s.values.iter().all(is_clean)
-                || s.x.as_ref().is_some_and(|x| long(x.len()) || !x.iter().all(is_clean))
-                || s.sizes.as_ref().is_some_and(|x| long(x.len()) || !x.iter().all(is_clean))
-                || s.trendlines.len() > MAX_TRENDLINES
-        })
-        || trendlines > MAX_TRENDLINES
-}
-
-/// Enforces the chart's budget of points (`MAX_TOTAL_POINTS` = series x points: every series and
-/// the category list keep their first `MAX_TOTAL_POINTS / series` points) and of trendlines
-/// (`MAX_TRENDLINES` per chart, in series order).
-fn apply_budget(mut d: ChartData) -> ChartData {
-    let cap = points_per_series(d.series.len());
-    d.categories.truncate(cap);
-    let mut trendlines = MAX_TRENDLINES;
-    for s in &mut d.series {
-        s.values.truncate(cap);
-        for v in [&mut s.x, &mut s.sizes].into_iter().flatten() {
-            v.truncate(cap);
-        }
-        s.trendlines.truncate(trendlines);
-        trendlines = trendlines.saturating_sub(s.trendlines.len());
-    }
-    d
-}
-
-/// The data `render` draws: `d` itself when it is already clean and within budget (the usual
-/// case: no copy), else a cleaned, truncated copy.
-pub(crate) fn sanitized(d: &ChartData) -> Cow<'_, ChartData> {
-    if needs_sanitizing(d) { Cow::Owned(apply_budget(sanitize(d))) } else { Cow::Borrowed(d) }
-}
-
 /// Lays out and draws a chart into a `w`×`h` box at the origin. Empty for a degenerate box.
 pub fn render(chart: &Chart, data: &ChartData, w: f32, h: f32, m: &dyn Measure) -> Vec<Prim> {
     if !(w.is_finite() && h.is_finite()) || w < 1.0 || h < 1.0 || w > 1e7 || h > 1e7 {
         return vec![];
     }
-    let data = sanitized(data);
+    let data = sanitize(data);
     let mut ctx = Ctx { out: Vec::new(), m };
     ctx.out.push(Prim::Rect { x: 0.0, y: 0.0, w, h, fill: Some(WHITE), stroke: Some((GRID, 1.0)), radius: 0.0 });
     let pad = (w.min(h) * 0.04).clamp(2.0, 10.0);
@@ -239,7 +153,7 @@ fn draw_kind(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
     use ChartKind::*;
     match chart.kind {
         Pie => pie(ctx, chart, data, area, 0.0, false),
-        Doughnut => doughnut(ctx, chart, data, area),
+        Doughnut => pie(ctx, chart, data, area, 0.5, false),
         Sunburst => pie(ctx, chart, data, area, 0.2, true),
         Treemap => treemap(ctx, chart, data, area),
         Funnel => funnel(ctx, chart, data, area),

crates/chart/src/render/cartesian.rs

@@ -3,8 +3,8 @@ use super::legend::{cat_label, plot_kind};
 use super::lines::{decimate_area, 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, MIN_BAR_PX, Prim, Rgba, Scale,
-    SeriesData, TEXT, VAlign, WHITE, clean, nice_scale,
+    Chart, ChartData, ChartKind, Ctx, Fmt, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_LINE_PTS, MAX_MARKERS, Prim, Scale, SeriesData, TEXT,
+    VAlign, WHITE, clean, fixed_scale, nice_scale,
 };
 
 // ---------------------------------------------------------------- cartesian (column/bar/line/area/combo)
@@ -51,110 +51,6 @@ fn is_line(f: Fam) -> bool {
     matches!(f, Fam::Line | Fam::LineStack)
 }
 
-/// Bars that fall into one pixel column, merged: extent along the category axis (`a0..=a1`, the
-/// bars' start positions) and along the value axis (`lo..hi`).
-struct BarRun {
-    bucket: f32,
-    a0: f32,
-    a1: f32,
-    lo: f32,
-    hi: f32,
-    /// More than one bar was merged.
-    merged: bool,
-}
-
-impl BarRun {
-    fn new(pos: f32, lo: f32, hi: f32) -> Self {
-        BarRun { bucket: pos.floor(), a0: pos, a1: pos, lo, hi, merged: false }
-    }
-    /// Whether `lo..hi` touches the run's value span; a disjoint bar would be joined by a filled gap.
-    fn touches(&self, lo: f32, hi: f32) -> bool {
-        lo <= self.hi && hi >= self.lo
-    }
-    fn add(&mut self, pos: f32, lo: f32, hi: f32) {
-        self.merged = true;
-        self.a0 = self.a0.min(pos);
-        self.a1 = self.a1.max(pos);
-        self.lo = self.lo.min(lo);
-        self.hi = self.hi.max(hi);
-    }
-    /// `band` is the part of the pixel column reserved for this series (`start`, `len`): in a
-    /// clustered chart a merged run stays inside it, so the other series keep a visible strip.
-    fn draw(&self, ctx: &mut Ctx, bw: f32, horizontal: bool, color: Rgba, band: Option<(f32, f32)>) {
-        let (a0, along) = match band {
-            Some((start, len)) if self.merged => (self.bucket + start, len),
-            _ => (self.a0, self.a1 - self.a0 + bw),
-        };
-        if horizontal {
-            ctx.rect(self.lo, a0, self.hi - self.lo, along, color, None);
-        } else {
-            ctx.rect(a0, self.lo, along, self.hi - self.lo, color, None);
-        }
-    }
-}
-
-/// Whether bars of width `bw` are merged per pixel column (never when they carry data labels).
-fn merge_hairlines(bw: f32, labels_on: bool) -> bool {
-    bw < MIN_BAR_PX && !labels_on
-}
-
-/// Draws the bars of one series: a rectangle each, or, for hairline bars, one merged [`BarRun`]
-/// per pixel column.
-struct BarSink {
-    run: Option<BarRun>,
-    bw: f32,
-    horizontal: bool,
-    color: Rgba,
-    nslots: f32,
-    k: f32,
-}
-
-impl BarSink {
-    fn new(bw: f32, horizontal: bool, color: Rgba, nslots: f32, k: f32) -> Self {
-        BarSink { run: None, bw, horizontal, color, nslots, k }
-    }
-    /// Start of this series' slot along the category axis, for the category centered at `c`.
-    fn pos(&self, c: f32) -> f32 {
-        if self.horizontal { c + self.nslots * self.bw / 2.0 - (self.k + 1.0) * self.bw } else { c - self.nslots * self.bw / 2.0 + self.k * self.bw }
-    }
-    /// This series' strip of a pixel column (offset, length) when the columns hold several
-    /// clustered series, in the direction the slots run.
-    fn band(&self) -> Option<(f32, f32)> {
-        (self.nslots > 1.0).then(|| {
-            let idx = if self.horizontal { self.nslots - 1.0 - self.k } else { self.k };
-            (idx / self.nslots, 1.0 / self.nslots)
-        })
-    }
-    /// Draws the bar at category center `c` spanning `lo..lo + len` on the value axis, or, when
-    /// `merge` is set, adds it to the current run.
-    fn bar(&mut self, ctx: &mut Ctx, merge: bool, c: f32, lo: f32, len: f32) {
-        let pos = self.pos(c);
-        let band = self.band();
-        if !merge {
-            if self.horizontal {
-                ctx.rect(lo, pos, len, self.bw, self.color, None);
-            } else {
-                ctx.rect(pos, lo, self.bw, len, self.color, None);
-            }
-            return;
-        }
-        match &mut self.run {
-            Some(m) if m.bucket == pos.floor() && m.touches(lo, lo + len) => m.add(pos, lo, lo + len),
-            run => {
-                if let Some(m) = run.replace(BarRun::new(pos, lo, lo + len)) {
-                    m.draw(ctx, self.bw, self.horizontal, self.color, band);
-                }
-            }
-        }
-    }
-    fn finish(self, ctx: &mut Ctx) {
-        let band = self.band();
-        if let Some(m) = self.run {
-            m.draw(ctx, self.bw, self.horizontal, self.color, band);
-        }
-    }
-}
-
 fn series_spans(data: &ChartData, fams: &[Fam], sec: &[bool], ncat: usize) -> Vec<Vec<Option<(f64, f64)>>> {
     // Totals for 100% stacking, per axis and family (100% columns and 100% areas stack apart).
     let mut totals: Vec<((bool, Fam), Vec<f64>)> = Vec::new();
@@ -245,12 +141,11 @@ fn axis_scales(data: &ChartData, fams: &[Fam], sec: &[bool], spans: &[Vec<Option
         let all100 = members.iter().all(|i| fams.get(*i).is_some_and(|f| is_100(*f)));
         let range = value_range(members.iter().flat_map(|i| {
             let line = fams.get(*i).is_some_and(|f| is_line(*f));
-            // Lines contribute only their top value, bars both ends (no per-point `Vec`).
-            spans.get(*i).into_iter().flatten().flatten().flat_map(move |(b, t)| [*b, *t].into_iter().skip(usize::from(line)))
+            spans.get(*i).into_iter().flatten().flatten().flat_map(move |(b, t)| if line { vec![*t] } else { vec![*b, *t] })
         }));
         let (lo, hi) = range.unwrap_or((0.0, 0.0));
         let (scale, fmt) = if all100 {
-            (Scale { min: if lo < -1e-9 { -1.0 } else { 0.0 }, max: if hi > 1e-9 || lo >= -1e-9 { 1.0 } else { 0.0 }, step: 0.2 }, Fmt::new("0%"))
+            (fixed_scale(if lo < -1e-9 { -1.0 } else { 0.0 }, if hi > 1e-9 || lo >= -1e-9 { 1.0 } else { 0.0 }, 0.2), Fmt::new("0%"))
         } else {
             let code = members.first().and_then(|i| data.series.get(*i)).map(|s| s.number_format.as_str()).unwrap_or("General");
             (nice_scale(lo, hi, force_zero), Fmt::new(code))
@@ -292,7 +187,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
     if ncat == 0 {
         return;
     }
-    let kinds: Vec<ChartKind> = data.series.iter().enumerate().map(|(i, s)| if horizontal { chart.kind } else { plot_kind(chart, s, i) }).collect();
+    let kinds: Vec<ChartKind> = data.series.iter().map(|s| if horizontal { chart.kind } else { plot_kind(chart, s) }).collect();
     let fams: Vec<Fam> = kinds.iter().map(|k| family(*k)).collect();
     let any_primary = data.series.iter().any(|s| !s.secondary);
     let sec: Vec<bool> = data.series.iter().map(|s| s.secondary && any_primary && !horizontal).collect();
@@ -383,16 +278,19 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
                 }
                 1 => {
                     let k = slot_of.get(i).copied().unwrap_or(0) as f32;
-                    // Hairline bars are merged per pixel column (their envelope is what shows).
-                    let cull = merge_hairlines(bw, labels_on);
-                    let mut sink = BarSink::new(bw, horizontal, s.color, nslots, k);
                     for (j, sp) in row.iter().enumerate() {
                         let Some((b, t)) = sp else { continue };
                         let (pb, pt) = (vpos(*b, &sc), vpos(*t, &sc));
                         let c = center(j);
                         let lo = pb.min(pt);
                         let len = (pb - pt).abs();
-                        sink.bar(ctx, cull, c, lo, len);
+                        if horizontal {
+                            let y = c + nslots * bw / 2.0 - (k + 1.0) * bw;
+                            ctx.rect(lo, y, len, bw, s.color, None);
+                        } else {
+                            let x = c - nslots * bw / 2.0 + k * bw;
+                            ctx.rect(x, lo, bw, len, s.color, None);
+                        }
                         if labels_on && let Some(v) = s.values.get(j).copied().flatten() {
                             let t = fmt.format(v, None);
                             let stacked = fam != Fam::Col;
@@ -418,7 +316,6 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
                             }
                         }
                     }
-                    sink.finish(ctx);
                 }
                 _ => {
                     let pts: Vec<Option<[f32; 2]>> = row.iter().enumerate().map(|(j, sp)| sp.map(|(_, t)| [center(j), vpos(t, &sc)])).collect();

crates/chart/src/render/kinds.rs

@@ -1,8 +1,8 @@
 use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range};
 use super::legend::{cat_label, point_color};
 use super::{
-    AXIS, Chart, ChartData, Ctx, DOWN, Fmt, GRID, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_MARKERS, MAX_SERIES, MAX_WEDGES, Prim,
-    QuartileMethod, Rgba, STOCK, SeriesData, TAU, TEXT, UP, VAlign, WHITE, clean, nice_scale,
+    AXIS, Chart, ChartData, Ctx, DOWN, Fmt, GRID, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_MARKERS, Prim, QuartileMethod, STOCK, SeriesData,
+    TAU, TEXT, UP, VAlign, WHITE, clean, nice_scale,
 };
 
 // ---------------------------------------------------------------- histogram
@@ -163,66 +163,6 @@ pub(super) fn funnel(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
 
 // ---------------------------------------------------------------- pie, doughnut, sunburst
 
-/// At most `cap` of the largest values, in category order. When a ring has more categories than
-/// its share of the wedge budget allows, the big slices survive rather than the first ones.
-fn largest_slices(vals: &[f64], cap: usize) -> Vec<(usize, f64)> {
-    let mut idx: Vec<usize> = (0..vals.len()).collect();
-    if idx.len() > cap {
-        // Partition descends by value, so the first `cap` entries are the largest ones.
-        idx.select_nth_unstable_by(cap - 1, |a, b| vals[*b].total_cmp(&vals[*a]));
-        idx.truncate(cap);
-        idx.sort_unstable();
-    }
-    idx.into_iter().map(|j| (j, vals[j])).collect()
-}
-
-/// One ring's geometry and separator stroke: the slices of a ring differ only in angle and colour.
-struct Ring {
-    cx: f32,
-    cy: f32,
-    outer: f32,
-    inner: f32,
-    stroke: Option<(Rgba, f32)>,
-}
-
-/// A wedge of `ring`, split at 12 o'clock when it crosses the end of the circle.
-fn wedge(ctx: &mut Ctx, ring: &Ring, a0: f32, sweep: f32, fill: Rgba) {
-    let Ring { cx, cy, outer, inner, stroke } = *ring;
-    if sweep <= 1e-4 {
-        return;
-    }
-    // A slice that starts past 12 o'clock still has to be split against 12 o'clock, not against
-    // its unwrapped start: otherwise the half after TAU is drawn from 0 over its neighbours.
-    let a0 = a0.rem_euclid(TAU);
-    let a1 = a0 + sweep;
-    if a1 <= TAU {
-        ctx.out.push(Prim::Wedge { cx, cy, r_outer: outer, r_inner: inner, a0, a1, fill, stroke });
-        return;
-    }
-    // The halves are filled without a stroke: each would outline its own radial edge at 12
-    // o'clock, painting the white separator straight through the slice.
-    ctx.out.push(Prim::Wedge { cx, cy, r_outer: outer, r_inner: inner, a0, a1: TAU, fill, stroke: None });
-    ctx.out.push(Prim::Wedge { cx, cy, r_outer: outer, r_inner: inner, a0: 0.0, a1: a1 - TAU, fill, stroke: None });
-    if let Some((color, width)) = stroke {
-        // One outline for the whole slice: the outer and inner arcs run through 12 o'clock, and
-        // the two radial edges at the slice's own start and end close the path.
-        let arc = |r: f32, from: f32, to: f32| -> Vec<[f32; 2]> {
-            let steps = ((r.abs() * (to - from).abs() / 2.0).ceil() as usize).clamp(4, 512);
-            let at = |a: f32| [cx + r * a.sin(), cy - r * a.cos()];
-            (0..=steps).map(|k| at(from + (to - from) * k as f32 / steps as f32)).collect()
-        };
-        let mut pts = arc(outer, a0, a1);
-        if inner > 0.0 {
-            pts.extend(arc(inner, a1, a0));
-        } else {
-            pts.push([cx, cy]);
-        }
-        let start = pts[0];
-        pts.push(start);
-        ctx.out.push(Prim::Line { pts, color, width, dash: false });
-    }
-}
-
 pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inner: f32, names: bool) {
     let Some(s) = data.series.first() else { return };
     let vals: Vec<f64> = s.values.iter().take(MAX_CATS).map(|v| v.map(f64::abs).unwrap_or(0.0)).collect();
@@ -236,15 +176,14 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne
         return;
     }
     let ri = r * inner;
-    let ring = Ring { cx, cy, outer: r, inner: ri, stroke: Some((WHITE, 1.5)) };
     let f = Fmt::new(&s.number_format);
-    let mut a = (chart.first_slice_angle % 360) as f32 * TAU / 360.0;
+    let mut a = 0.0f32;
     let mut labels = Vec::new();
     for (j, v) in vals.iter().enumerate() {
         let sweep = (*v / total) as f32 * TAU;
         if sweep > 1e-4 {
             let fill = point_color(data, j);
-            wedge(ctx, &ring, a, sweep, fill);
+            ctx.out.push(Prim::Wedge { cx, cy, r_outer: r, r_inner: ri, a0: a, a1: (a + sweep).min(TAU), fill, stroke: Some((WHITE, 1.5)) });
             if (chart.data_labels || names) && vals.len() <= MAX_LABELS {
                 let t = if names { cat_label(data, j) } else { f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None) };
                 let mid = a + sweep / 2.0;
@@ -262,85 +201,9 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne
     }
 }
 
-/// Excel's doughnut: every series is one concentric ring, the first series innermost (measured in
-/// Excel: ring outer radii ≈0.83, 0.92 and 1.0 of the plot radius for series 1, 2 and 3). The hole
-/// size and first slice angle come from the chart; each ring is scaled to its own total.
-pub(super) fn doughnut(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) {
-    let nser = data.series.len().min(MAX_SERIES);
-    if nser == 0 {
-        return;
-    }
-    let (cx, cy) = (area.cx(), area.cy());
-    let r = area.w.min(area.h) / 2.0 * 0.92;
-    if r < 2.0 {
-        return;
-    }
-    let hole = f32::from(chart.hole_size.clamp(10, 90)) / 100.0;
-    let ri = r * hole;
-    let thick = (r - ri) / nser as f32;
-    // A ring thinner than a pixel would vanish. Rather than suppressing the whole chart when there
-    // are more series than the annulus has pixels, keep the outer rings at one pixel each and drop
-    // the innermost series that no longer fit: Excel's order makes the first series the innermost,
-    // so the outermost rings are the ones worth keeping.
-    let band = thick.max(1.0);
-    let start = (chart.first_slice_angle % 360) as f32 * TAU / 360.0;
-    // Only rings with a pixel of band are drawn, and the wedge budget is shared across them in
-    // drawing order: the innermost ring (the first series) gets its slices first, and the outer
-    // rings are capped instead of the series × category product growing without bound.
-    let rings: Vec<(&SeriesData, f32, f32)> = data
-        .series
-        .iter()
-        .take(nser)
-        .enumerate()
-        .filter_map(|(si, s)| {
-            let outer = (r - (nser - 1 - si) as f32 * band).min(r);
-            let inner = (r - (nser - si) as f32 * band).max(ri);
-            (outer - inner >= 1.0).then_some((s, outer, inner))
-        })
-        .collect();
-    let mut budget = MAX_WEDGES;
-    let mut labels = Vec::new();
-    for (k, (s, outer, inner)) in rings.iter().enumerate() {
-        // The white separator is 1.5 units wide, wider than a one-pixel band: on a thin ring it
-        // would paint over the fill of this ring and its neighbour, so such rings keep only fill.
-        let stroke = if outer - inner > 1.0 { Some((WHITE, 1.5)) } else { None };
-        let ring = Ring { cx, cy, outer: *outer, inner: *inner, stroke };
-        let vals: Vec<f64> = s.values.iter().take(MAX_CATS).map(|v| v.map(f64::abs).unwrap_or(0.0)).collect();
-        let cap = (budget / (rings.len() - k)).max(1);
-        let slices = largest_slices(&vals, cap);
-        let total: f64 = slices.iter().map(|(_, v)| *v).sum();
-        if !(total.is_finite() && total > 0.0) {
-            continue;
-        }
-        let n = slices.len();
-        budget = budget.saturating_sub(n);
-        let f = Fmt::new(&s.number_format);
-        let mut a = start;
-        for (j, v) in slices {
-            let sweep = (v / total) as f32 * TAU;
-            if sweep > 1e-4 {
-                let fill = point_color(data, j);
-                wedge(ctx, &ring, a, sweep, fill);
-                if chart.data_labels && n <= MAX_LABELS {
-                    let t = f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None);
-                    let mid = a + sweep / 2.0;
-                    let rr = (outer + inner) / 2.0;
-                    if ctx.tw(&t, LABEL_SIZE) <= (sweep * rr).max(outer - inner) && sweep * rr >= LABEL_SIZE {
-                        labels.push((cx + rr * mid.sin(), cy - rr * mid.cos(), t, on(fill)));
-                    }
-                }
-            }
-            a += sweep;
-        }
-    }
-    for (x, y, t, c) in labels {
-        ctx.text(x, y, &t, LABEL_SIZE, c, (HAlign::Center, VAlign::Middle));
-    }
-}
-
 // ---------------------------------------------------------------- treemap
 
-/// Worst aspect ratio of a row with the given area sum, smallest and largest item, laid along `side`.
+/// 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 {
     if s <= 0.0 || side <= 0.0 {
         return f64::INFINITY;
@@ -350,9 +213,8 @@ fn worst(s: f64, mn: f64, mx: f64, side: f64) -> f64 {
     (w2 * mx / s2).max(s2 / (w2 * mn))
 }
 
-/// Squarified treemap layout of (index, value) items, sorted descending, into `r`; each block
-/// comes back with its index and value.
-pub(super) fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, f64, Bx)> {
+/// Squarified treemap layout of (index, area) items, sorted descending, into `r`.
+fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
     let total: f64 = items.iter().map(|i| i.1).sum();
     let area = (r.w as f64) * (r.h as f64);
     if !(total > 0.0 && area > 0.0) {
@@ -361,10 +223,11 @@ pub(super) fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, f64, Bx)> {
     let scale = area / total;
     let mut out = Vec::with_capacity(items.len());
     let mut rem = r;
-    let mut row: Vec<(usize, f64, f64)> = Vec::new();
+    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, f64)], rem: &mut Bx, out: &mut Vec<(usize, f64, Bx)>| {
+    let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| {
         let s: f64 = row.iter().map(|x| x.1).sum();
         if s <= 0.0 {
             return;
@@ -372,9 +235,9 @@ pub(super) fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, f64, Bx)> {
         if rem.w >= rem.h {
             let cw = (s / rem.h.max(1e-6) as f64) as f32;
             let mut y = rem.y;
-            for (j, a, v) in row {
+            for (j, a) in row {
                 let h = (*a / cw.max(1e-6) as f64) as f32;
-                out.push((*j, *v, Bx { x: rem.x, y, w: cw, h }));
+                out.push((*j, Bx { x: rem.x, y, w: cw, h }));
                 y += h;
             }
             rem.x += cw;
@@ -382,9 +245,9 @@ pub(super) fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, f64, Bx)> {
         } else {
             let rh = (s / rem.w.max(1e-6) as f64) as f32;
             let mut x = rem.x;
-            for (j, a, v) in row {
+            for (j, a) in row {
                 let w = (*a / rh.max(1e-6) as f64) as f32;
-                out.push((*j, *v, Bx { x, y: rem.y, w, h: rh }));
+                out.push((*j, Bx { x, y: rem.y, w, h: rh }));
                 x += w;
             }
             rem.y += rh;
@@ -394,12 +257,9 @@ pub(super) fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, f64, Bx)> {
     while let Some(&(j, v)) = items.get(i) {
         let a = v * scale;
         let side = rem.w.min(rem.h) as f64;
-        // Sum, smallest and largest item of the open row, kept incrementally (same fold order as
-        // summing the row afresh, so the numbers are bit-identical).
-        let with = (sum + a, mn.min(a), mx.max(a));
-        if row.is_empty() || worst(with.0, with.1, with.2, side) <= worst(sum, mn, mx, side) {
-            row.push((j, a, v));
-            (sum, mn, mx) = with;
+        if row.is_empty() || worst(sum + a, mn.min(a), mx.max(a), side) <= worst(sum, mn, mx, 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);
@@ -419,13 +279,15 @@ 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);
-    for (j, v, b) in squarify(&items, area) {
+    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)));
         if b.w > 24.0 && b.h > LABEL_SIZE * 1.6 {
             let name = ctx.fit(&cat_label(data, j), LABEL_SIZE, b.w - 8.0);
             ctx.text(b.x + 4.0, b.y + 4.0, &name, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top));
             if chart.data_labels && b.h > LABEL_SIZE * 3.2 {
+                let v = value_of.get(&j).copied().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/legend.rs

@@ -15,10 +15,9 @@ pub enum Swatch {
     Marker,
 }
 
-/// The kind series `i` is drawn as (per-series kinds only apply to combo charts); the same rule
-/// as `series_plot_kind`, applied to the already resolved series kind.
-pub(super) fn plot_kind(chart: &Chart, s: &SeriesData, i: usize) -> ChartKind {
-    crate::resolve::plot_kind(chart.kind, Some(s.kind), i)
+/// The kind a series is drawn as (per-series kinds only apply to combo charts).
+pub(super) fn plot_kind(chart: &Chart, s: &SeriesData) -> ChartKind {
+    if chart.kind == ChartKind::Combo { if s.kind == ChartKind::Combo { ChartKind::Line } else { s.kind } } else { chart.kind }
 }
 
 /// Colour of point `j` for charts that colour by point (pie, doughnut, treemap, sunburst).
@@ -43,8 +42,6 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa
         return vec![];
     }
     match chart.kind {
-        // Pie, doughnut (Excel's default `varyColors=1`, so every ring repeats the category colours
-        // and the legend names categories rather than series), treemap and sunburst.
         ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst => {
             let n = first_len(data).min(MAX_CATS);
             (0..n).map(|j| (cat_label(data, j), point_color(data, j), Swatch::Box)).collect()
@@ -61,9 +58,8 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa
             let series = data.series.iter().take(MAX_SERIES);
             let mut out: Vec<(String, Rgba, Swatch)> = series
                 .clone()
-                .enumerate()
-                .map(|(i, s)| {
-                    let sw = match plot_kind(chart, s, i) {
+                .map(|s| {
+                    let sw = match plot_kind(chart, s) {
                         ChartKind::Line | ChartKind::LineStacked | ChartKind::Radar | ChartKind::ScatterLines => Swatch::Line,
                         ChartKind::LineMarkers => Swatch::LineMarker,
                         ChartKind::Scatter | ChartKind::Bubble => Swatch::Marker,
@@ -73,7 +69,7 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa
                 })
                 .collect();
             // Trendlines follow the series, named "Linear (Sales)" unless given a name.
-            for (_, s) in series.enumerate().filter(|(i, s)| supports_trendline(plot_kind(chart, s, *i))) {
+            for s in series.filter(|s| supports_trendline(plot_kind(chart, s))) {
                 for t in s.trendlines.iter().take(MAX_TRENDLINES) {
                     out.push((t.spec.name.clone().unwrap_or_else(|| auto_name(t.spec.kind, &s.name)), t.color, Swatch::Line));
                 }
@@ -85,7 +81,7 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa
 
 // ---------------------------------------------------------------- legend
 
-pub(super) fn swatch_w(sw: Swatch, s: f32) -> f32 {
+fn swatch_w(sw: Swatch, s: f32) -> f32 {
     if sw == Swatch::Box { s } else { s * 2.0 }
 }
 
@@ -149,16 +145,7 @@ pub(super) fn draw_legend(ctx: &mut Ctx, entries: &[(String, Rgba, Swatch)], pos
             if pos == LegendPos::Bottom { Bx { h: area.h - used, ..area } } else { Bx { y: area.y + used, h: area.h - used, ..area } }
         }
         LegendPos::Left | LegendPos::Right => {
-            // Widest entry, capped at 35% of the area: once the cap is reached the rest cannot change it.
-            let cap = area.w * 0.35;
-            let mut colw = 0.0f32;
-            for e in entries {
-                if colw >= cap {
-                    break;
-                }
-                colw = colw.max(item_w(ctx, e));
-            }
-            let colw = colw.min(cap);
+            let colw = entries.iter().map(|e| item_w(ctx, e)).fold(0.0f32, f32::max).min(area.w * 0.35);
             let max_rows = ((area.h / row_h).floor() as usize).max(1);
             let n = entries.len().min(max_rows);
             let lh = n as f32 * row_h;

crates/chart/src/render/table.rs

@@ -70,7 +70,7 @@ pub(super) fn draw(ctx: &mut Ctx, chart: &Chart, data: &ChartData, plot: Bx, lay
         let y = top + (layout.headers as f32 + i as f32 + 0.5) * layout.row_height;
         let name_x = if settings.show_keys { x0 + 25.0 } else { x0 + 4.0 };
         if settings.show_keys {
-            let swatch = match plot_kind(chart, series, i) {
+            let swatch = match plot_kind(chart, series) {
                 ChartKind::Line | ChartKind::LineStacked => Swatch::Line,
                 ChartKind::LineMarkers => Swatch::LineMarker,
                 _ => Swatch::Box,

crates/chart/src/render_perf_tests.rs

@@ -1,298 +0,0 @@
-//! Equality and counter tests for the label-fitting, legend-measuring and treemap rewrites.
-//! The old implementations live here as references.
-
-use std::cell::Cell;
-
-use super::kinds::squarify;
-use super::legend::swatch_w;
-use super::*;
-use crate::{ApproxMeasure, Measure};
-use gridcraft_model::LegendPos;
-
-/// The pre-rewrite `Ctx::fit`: one `Measure` call per candidate length, longest first.
-fn fit_reference(ctx: &Ctx, s: &str, size: f32, maxw: f32) -> String {
-    if ctx.tw(s, size) <= maxw {
-        return s.to_string();
-    }
-    let chars: Vec<char> = s.chars().collect();
-    let mut n = chars.len().min(400);
-    while n > 0 {
-        n -= 1;
-        let t: String = chars.iter().take(n).collect::<String>() + "…";
-        if ctx.tw(&t, size) <= maxw {
-            return if n == 0 { String::new() } else { t };
-        }
-    }
-    String::new()
-}
-
-/// Counts calls; advances differ per character (wide CJK/emoji, zero-width combining marks) and
-/// "AV"-style pairs are kerned tighter, but a character never makes the text narrower.
-struct Varied {
-    calls: Cell<usize>,
-}
-
-impl Measure for Varied {
-    fn text_width(&self, text: &str, size: f32, bold: bool) -> f32 {
-        self.calls.set(self.calls.get() + 1);
-        let mut w = 0.0f32;
-        let mut prev = ' ';
-        for c in text.chars() {
-            let adv = match c as u32 {
-                0x300..=0x36f => 0.0,
-                0x1f300..=0x1faff | 0x4e00..=0x9fff => 1.0,
-                u => 0.3 + (u % 7) as f32 * 0.07,
-            };
-            let kern = if prev == 'A' && c == 'V' { 0.1 } else { 0.0 };
-            w += (adv - kern) * size;
-            prev = c;
-        }
-        if bold { w * 1.1 } else { w }
-    }
-}
-
-struct Counting<'a>(&'a dyn Measure, Cell<usize>);
-
-impl Measure for Counting<'_> {
-    fn text_width(&self, text: &str, size: f32, bold: bool) -> f32 {
-        self.1.set(self.1.get() + 1);
-        self.0.text_width(text, size, bold)
-    }
-}
-
-/// Like a text layout that breaks at `\n`: the width is that of the widest line. Adding a
-/// newline can make the text narrower, so the width of `prefix + "…"` is not monotone.
-struct WidestLine;
-
-impl Measure for WidestLine {
-    fn text_width(&self, text: &str, size: f32, _bold: bool) -> f32 {
-        text.split('\n')
-            .map(|line| {
-                line.chars()
-                    .map(|c| {
-                        size * if c == 'i' {
-                            0.25
-                        } else if c == 'M' {
-                            0.9
-                        } else {
-                            0.5
-                        }
-                    })
-                    .sum::<f32>()
-            })
-            .fold(0.0, f32::max)
-    }
-}
-
-fn corpus() -> Vec<String> {
-    let mut v: Vec<String> =
-        ["", "a", "ab", "Hello, world", "AVAVAV tight", "日本語のラベルです", "👨‍👩‍👧 family 🎉 party", "e\u{301}e\u{301}e\u{301} combining", "…", "……"]
-            .iter()
-            .map(|s| s.to_string())
-            .collect();
-    v.push("x".repeat(399));
-    v.push("x".repeat(400));
-    v.push("x".repeat(401));
-    v.push("é🎉".repeat(500));
-    v.push("long label ".repeat(100));
-    for s in ["iiii\nMM", "iiii\n", "\niiii", "ab\ncd\nef", "iiiiiiii\niiiiMMMM\nMM", "line one\nline two is longer\nx"] {
-        v.push(s.to_string());
-    }
-    v
-}
-
-fn run_fit(m: &dyn Measure) {
-    let ctx = Ctx { out: vec![], m };
-    for s in corpus() {
-        for size in [9.0f32, 11.0, 40.0] {
-            for maxw in [-5.0, 0.0, 0.4, 6.0, 25.0, 61.5, 120.0, 800.0, 1e6, f32::INFINITY, f32::NAN] {
-                assert_eq!(ctx.fit(&s, size, maxw), fit_reference(&ctx, &s, size, maxw), "{s:?} size {size} maxw {maxw}");
-            }
-        }
-    }
-}
-
-#[test]
-fn fit_matches_linear_reference() {
-    run_fit(&ApproxMeasure);
-    run_fit(&Varied { calls: Cell::new(0) });
-    run_fit(&WidestLine);
-}
-
-#[test]
-fn a_multiline_label_keeps_its_fitting_prefix() {
-    // The whole label is 18 wide and "iii…" is 12.5, both too wide for 10.5, but "iiii\n…" is
-    // 10 wide and fits. A binary search that stops at the failing midpoint would return nothing.
-    let ctx = Ctx { out: vec![], m: &WidestLine };
-    let s = "iiii\nMM";
-    let size = 10.0;
-    let maxw = 10.5;
-    assert!(ctx.tw(s, size) > maxw);
-    assert!(ctx.tw("iii…", size) > maxw && ctx.tw("iiii\n…", size) <= maxw);
-    assert_eq!(ctx.fit(s, size, maxw), "iiii\n…");
-}
-
-#[test]
-fn fit_measures_logarithmically() {
-    let long = "x".repeat(1000);
-    let c = Counting(&ApproxMeasure, Cell::new(0));
-    let ctx = Ctx { out: vec![], m: &c };
-    let r = ctx.fit(&long, 11.0, 60.0);
-    assert!(r.ends_with('…') && r.chars().count() > 3);
-    // 1 whole-string check + ceil(log2(399)) + 1 probes; the old scan needed ~390 here.
-    assert!(c.1.get() <= 12, "{} Measure calls", c.1.get());
-    let c2 = Counting(&ApproxMeasure, Cell::new(0));
-    let ctx2 = Ctx { out: vec![], m: &c2 };
-    assert_eq!(ctx2.fit("short", 11.0, 500.0), "short");
-    assert_eq!(c2.1.get(), 1);
-}
-
-fn legend_entries(n: usize, label: &dyn Fn(usize) -> String) -> Vec<(String, Rgba, Swatch)> {
-    (0..n).map(|i| (label(i), [10, 20, 30, 255], if i % 3 == 0 { Swatch::Line } else { Swatch::Box })).collect()
-}
-
-/// Colour column width as the old code computed it, from the returned remaining area.
-fn old_colw(m: &dyn Measure, entries: &[(String, Rgba, Swatch)], area: Bx) -> f32 {
-    let ctx = Ctx { out: vec![], m };
-    let size = LABEL_SIZE;
-    let s = size * 0.8;
-    entries.iter().map(|e| swatch_w(e.2, s) + 4.0 + ctx.tw(&e.0, size)).fold(0.0f32, f32::max).min(area.w * 0.35)
-}
-
-#[test]
-fn side_legend_matches_old_column_width_and_stops_measuring_at_the_cap() {
-    let area = Bx { x: 0.0, y: 0.0, w: 400.0, h: 300.0 };
-    let labels: [&dyn Fn(usize) -> String; 3] =
-        [&|i| format!("entry {i}"), &|i| if i == 7 { "w".repeat(80) } else { format!("e{i}") }, &|i| "very long legend label ".repeat(1 + i % 3)];
-    for pos in [LegendPos::Left, LegendPos::Right] {
-        for (k, label) in labels.iter().enumerate() {
-            for n in [0usize, 1, 5, 40] {
-                let entries = legend_entries(n, label);
-                let mut ctx = Ctx { out: vec![], m: &ApproxMeasure };
-                let rest = draw_legend(&mut ctx, &entries, pos, area);
-                let colw = old_colw(&ApproxMeasure, &entries, area);
-                assert!((rest.w - (area.w - (colw + 8.0))).abs() < 1e-4, "{pos:?} labels {k} n {n}");
-            }
-        }
-    }
-    // 20,000 entries whose first one already fills the 35% cap: the old code measured all of them
-    // plus the drawn rows, now only the first entry and the drawn rows are measured.
-    let entries = legend_entries(20_000, &|i| if i == 0 { "w".repeat(200) } else { format!("e{i}") });
-    let c = Counting(&ApproxMeasure, Cell::new(0));
-    let mut ctx = Ctx { out: vec![], m: &c };
-    let _ = draw_legend(&mut ctx, &entries, LegendPos::Right, area);
-    let drawn = ctx.out.iter().filter(|p| matches!(p, Prim::Text { .. })).count();
-    assert!(c.1.get() <= drawn * 10 + 5, "{} Measure calls for {drawn} drawn entries", c.1.get());
-    assert!(c.1.get() < 500);
-}
-
-/// The pre-rewrite `worst`/`squarify` (a `Vec` per item, row recomputed from scratch).
-fn worst_reference(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))
-}
-
-fn squarify_reference(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
-    let total: f64 = items.iter().map(|i| i.1).sum();
-    let area = (r.w as f64) * (r.h as f64);
-    if !(total > 0.0 && area > 0.0) {
-        return vec![];
-    }
-    let scale = area / total;
-    let mut out = Vec::with_capacity(items.len());
-    let mut rem = r;
-    let mut row: Vec<(usize, f64)> = Vec::new();
-    let mut i = 0;
-    let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| {
-        let s: f64 = row.iter().map(|x| x.1).sum();
-        if s <= 0.0 {
-            return;
-        }
-        if rem.w >= rem.h {
-            let cw = (s / rem.h.max(1e-6) as f64) as f32;
-            let mut y = rem.y;
-            for (j, a) in row {
-                let h = (*a / cw.max(1e-6) as f64) as f32;
-                out.push((*j, Bx { x: rem.x, y, w: cw, h }));
-                y += h;
-            }
-            rem.x += cw;
-            rem.w = (rem.w - cw).max(0.0);
-        } else {
-            let rh = (s / rem.w.max(1e-6) as f64) as f32;
-            let mut x = rem.x;
-            for (j, a) in row {
-                let w = (*a / rh.max(1e-6) as f64) as f32;
-                out.push((*j, Bx { x, y: rem.y, w, h: rh }));
-                x += w;
-            }
-            rem.y += rh;
-            rem.h = (rem.h - rh).max(0.0);
-        }
-    };
-    while let Some(&(j, v)) = items.get(i) {
-        let a = v * scale;
-        let side = rem.w.min(rem.h) as f64;
-        let cur: Vec<f64> = row.iter().map(|x| x.1).collect();
-        let mut with = cur.clone();
-        with.push(a);
-        if row.is_empty() || worst_reference(&with, side) <= worst_reference(&cur, side) {
-            row.push((j, a));
-            i += 1;
-        } else {
-            layout(&row, &mut rem, &mut out);
-            row.clear();
-        }
-    }
-    if !row.is_empty() {
-        layout(&row, &mut rem, &mut out);
-    }
-    out
-}
-
-#[test]
-fn squarify_matches_reference() {
-    let mut seed = 0x2545_f491_4f6c_dd1du64;
-    let mut rnd = move || {
-        seed ^= seed << 13;
-        seed ^= seed >> 7;
-        seed ^= seed << 17;
-        (seed >> 11) as f64 / (1u64 << 53) as f64
-    };
-    let mut cases: Vec<Vec<f64>> = vec![
-        vec![],
-        vec![5.0],
-        vec![6.0, 6.0, 4.0, 3.0, 2.0, 2.0, 1.0],
-        vec![3.0, 0.0, 0.0, 1.0],
-        vec![0.0, 0.0],
-        vec![4.0, -1.0, 2.0],
-        vec![4.0, f64::NAN, 2.0, 1.0],
-        vec![f64::INFINITY, 1.0],
-        vec![1e-300, 1e-310, 0.0],
-    ];
-    for n in [2usize, 9, 40, 300] {
-        let mut v: Vec<f64> = (0..n).map(|_| rnd() * 100.0).collect();
-        v.sort_by(|a, b| b.total_cmp(a));
-        cases.push(v);
-    }
-    for r in [Bx { x: 0.0, y: 0.0, w: 300.0, h: 200.0 }, Bx { x: 5.0, y: 7.0, w: 90.0, h: 400.0 }, Bx { x: 0.0, y: 0.0, w: 0.0, h: 50.0 }] {
-        for vals in &cases {
-            let items: Vec<(usize, f64)> = vals.iter().copied().enumerate().collect();
-            let new: Vec<(usize, Bx)> = squarify(&items, r)
-                .into_iter()
-                .map(|(j, v, b)| {
-                    assert!(vals.get(j).is_some_and(|x| x.to_bits() == v.to_bits()), "value carried through");
-                    (j, b)
-                })
-                .collect();
-            let old = squarify_reference(&items, r);
-            assert_eq!(format!("{new:?}"), format!("{old:?}"), "{vals:?} in {r:?}");
-        }
-    }
-}

crates/chart/src/resolve.rs

@@ -1,7 +1,7 @@
 //! Pulls chart data (names, categories, values, formats, colours) out of a workbook.
 
 use gridcraft_calc::evaluate;
-use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value, category_levels, number_to_text};
+use gridcraft_core::{CellRef, RangeRef, Value, category_levels, number_to_text};
 use gridcraft_model::{Chart, ChartKind, Theme, Workbook, style::apply_tint};
 use gridcraft_numfmt::{NumberFormat, format_value};
 
@@ -11,17 +11,8 @@ use crate::{ChartData, Rgba, SeriesData, TrendlineData};
 pub(crate) const MAX_POINTS: usize = 100_000;
 /// Cap on series per chart.
 pub(crate) const MAX_SERIES: usize = 255;
-/// Cap on trendlines per chart (not per series: each one is a fit over a series' points).
+/// Cap on trendlines drawn per series.
 pub(crate) const MAX_TRENDLINES: usize = 16;
-/// Budget for series x points in one chart. When a chart would hold more, every series (and the
-/// category list) keeps its first `MAX_TOTAL_POINTS / series` points; no series is dropped.
-pub(crate) const MAX_TOTAL_POINTS: usize = 2_000_000;
-
-/// Points kept per series (and categories) in a chart of `series` series: `MAX_POINTS`, or less
-/// when `series x MAX_POINTS` would pass `MAX_TOTAL_POINTS`.
-pub(crate) fn points_per_series(series: usize) -> usize {
-    (MAX_TOTAL_POINTS / series.clamp(1, MAX_SERIES)).clamp(1, MAX_POINTS)
-}
 
 /// Tints used for series beyond the six theme accents: lighter, darker, lighter still…
 const CYCLE_TINTS: [f64; 6] = [0.0, 0.4, -0.25, 0.6, -0.5, 0.2];
@@ -86,51 +77,10 @@ fn union_parts(f: &str) -> Option<Vec<&str>> {
 /// Evaluates a series formula to a flat list of values (row-major), capped. A union of
 /// references (`(A1:A3,A5)`, as PivotCharts use) is read part by part.
 fn eval_list(wb: &Workbook, sheet: usize, formula: &str) -> Vec<Value> {
-    eval_list_in(wb, sheet, formula, MAX_POINTS, 0)
+    eval_list_in(wb, sheet, formula, 0)
 }
 
-/// calc reads a reference of up to this many cells at its full size and trims a larger one to the
-/// sheet's used range (`FULL_SIZE_CELLS` in `gridcraft_calc::eval`). A clipped reference must stay
-/// above it, or the clip would turn a trimmed read into a full-size one with trailing blanks.
-const CALC_FULL_SIZE_CELLS: u64 = 16_384;
-/// Bounded references up to this many cells are read at their full size too
-/// (`FULL_SIZE_BOUNDED_CELLS` in `gridcraft_calc::eval`).
-const CALC_FULL_SIZE_BOUNDED_CELLS: u64 = 1_048_576;
-
-/// `formula` as a plain reference (`Sheet!A1:A1000000`) cut after the rows that can still hold
-/// one of the first `limit` points, so that calc never reads the rest; `None` when `formula` is
-/// no reference or already small enough. Values are read row by row, and calc trims only the
-/// bottom and right of a reference, so keeping `limit` rows keeps the first `limit` values.
-fn clipped_reference(wb: &Workbook, sheet: usize, formula: &str, limit: usize) -> Option<String> {
-    let (sh, mut r) = parse_ref(wb, sheet, formula)?;
-    let cells = u64::from(r.height()).saturating_mul(u64::from(r.width()));
-    // calc trims a block that runs to the sheet's edge, and any block over a column's worth, to
-    // the used range. Do it here, or the clipped block below would be read at its full size.
-    let to_edge = r.end.row == MAX_ROWS - 1 || r.end.col == MAX_COLS - 1;
-    let trimmed = cells > CALC_FULL_SIZE_CELLS && (to_edge || cells > CALC_FULL_SIZE_BOUNDED_CELLS);
-    let mut changed = false;
-    if trimmed {
-        let end = match wb.sheet(sh).and_then(|s| s.used_range()) {
-            Some(u) => CellRef::new(r.end.row.min(u.end.row.max(r.start.row)), r.end.col.min(u.end.col.max(r.start.col))),
-            None => r.start,
-        };
-        changed = end != r.end;
-        r = RangeRef::new(r.start, end);
-    }
-    let prefix = formula.rfind('!').and_then(|i| formula.get(..=i)).unwrap_or("");
-    let (h, w) = (u64::from(r.height()), u64::from(r.width()));
-    if h.saturating_mul(w) > CALC_FULL_SIZE_CELLS {
-        let keep = (limit as u64).max(CALC_FULL_SIZE_CELLS / w + 1);
-        if h > keep {
-            let end = CellRef::new(r.start.row.saturating_add(u32::try_from(keep).ok()?).saturating_sub(1), r.end.col);
-            r = RangeRef::new(r.start, end);
-            changed = true;
-        }
-    }
-    changed.then(|| format!("{prefix}{r}"))
-}
-
-fn eval_list_in(wb: &Workbook, sheet: usize, formula: &str, limit: usize, depth: u32) -> Vec<Value> {
+fn eval_list_in(wb: &Workbook, sheet: usize, formula: &str, depth: u32) -> Vec<Value> {
     let f = formula.trim();
     if f.is_empty() {
         return vec![];
@@ -140,17 +90,16 @@ fn eval_list_in(wb: &Workbook, sheet: usize, formula: &str, limit: usize, depth:
     {
         let mut out = Vec::new();
         for p in parts {
-            if out.len() >= limit {
+            if out.len() >= MAX_POINTS {
                 break;
             }
-            let rest = limit - out.len();
-            out.extend(eval_list_in(wb, sheet, p, rest, depth + 1).into_iter().take(rest));
+            let rest = MAX_POINTS - out.len();
+            out.extend(eval_list_in(wb, sheet, p, depth + 1).into_iter().take(rest));
         }
         return out;
     }
-    let clipped = clipped_reference(wb, sheet, f, limit);
-    match evaluate(wb, sheet, CellRef::default(), clipped.as_deref().unwrap_or(f)) {
-        Value::Array(a) => a.iter().take(limit).cloned().collect(),
+    match evaluate(wb, sheet, CellRef::default(), f) {
+        Value::Array(a) => a.iter().take(MAX_POINTS).cloned().collect(),
         v => vec![v],
     }
 }
@@ -162,8 +111,8 @@ fn to_num(v: &Value) -> Option<f64> {
     }
 }
 
-fn nums(wb: &Workbook, sheet: usize, formula: &str, limit: usize) -> Vec<Option<f64>> {
-    eval_list_in(wb, sheet, formula, limit, 0).iter().map(to_num).collect()
+fn nums(wb: &Workbook, sheet: usize, formula: &str) -> Vec<Option<f64>> {
+    eval_list(wb, sheet, formula).iter().map(to_num).collect()
 }
 
 /// Number format code of the first cell of a reference ("General" when not a reference).
@@ -188,38 +137,9 @@ fn value_text(v: &Value) -> String {
 /// the outer levels of a multi-level axis: a category range wider than a column of values (or
 /// taller than a row of values) groups its innermost labels, year beside month. Each outer level
 /// has one entry per category, non-empty where a group starts, as the cells are.
-fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str, limit: usize) -> (Vec<String>, Vec<Vec<String>>) {
+fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str) -> (Vec<String>, Vec<Vec<String>>) {
+    let vals = eval_list(wb, sheet, formula);
     let cells: Option<(usize, RangeRef)> = parse_ref(wb, sheet, formula);
-    let value_range = parse_ref(wb, sheet, values).map(|(_, r)| r);
-    // Bound the category dimension by `limit` and read only the cells the levels use (the
-    // innermost label line and up to three outer ones), so that every kept category keeps its
-    // cells in every level. Counting raw cells would cut a two-level axis in the middle.
-    let levels = cells.and_then(|(_, r)| category_levels(&r, value_range.as_ref()));
-    let (cells, read) = match (cells, levels) {
-        (Some((sh, r)), Some(lv)) => {
-            let cut = u32::try_from(limit.saturating_sub(1)).unwrap_or(u32::MAX);
-            let outer = lv.outer;
-            let end = if lv.by_columns {
-                CellRef::new(r.end.row.min(r.start.row.saturating_add(cut)), r.end.col)
-            } else {
-                CellRef::new(r.end.row, r.end.col.min(r.start.col.saturating_add(cut)))
-            };
-            let start = if lv.by_columns {
-                CellRef::new(r.start.row, r.start.col.max(end.col.saturating_sub(outer)))
-            } else {
-                CellRef::new(r.start.row.max(end.row.saturating_sub(outer)), r.start.col)
-            };
-            let r = RangeRef::new(start, end);
-            let prefix = formula.rfind('!').and_then(|i| formula.get(..=i)).unwrap_or("");
-            let cap = (r.width() as usize).saturating_mul(r.height() as usize);
-            (Some((sh, r)), Some((format!("{prefix}{r}"), cap)))
-        }
-        (c, _) => (c, None),
-    };
-    let vals = match &read {
-        Some((f, cap)) => eval_list_in(wb, sheet, f, *cap, 0),
-        None => eval_list_in(wb, sheet, formula, limit, 0),
-    };
     let src = cells.and_then(|(sh, r)| wb.sheet(sh).map(|s| (s, r)));
     let texts: Vec<String> = vals
         .iter()
@@ -239,7 +159,8 @@ fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str, limi
         })
         .collect();
     let Some((_, r)) = src else { return (texts, vec![]) };
-    let Some(levels) = levels else { return (texts, vec![]) };
+    let value_range = parse_ref(wb, sheet, values).map(|(_, r)| r);
+    let Some(levels) = category_levels(&r, value_range.as_ref()) else { return (texts, vec![]) };
     let (w, h) = (r.width().max(1) as usize, r.height().max(1) as usize);
     if texts.len() != w.saturating_mul(h) {
         return (texts, vec![]); // truncated or not a plain block: a flat list
@@ -280,7 +201,7 @@ fn series_name(wb: &Workbook, sheet: usize, name: &str) -> String {
     t.to_string()
 }
 
-pub(crate) fn effective_kind(chart_kind: ChartKind, series_kind: Option<ChartKind>, i: usize) -> ChartKind {
+fn effective_kind(chart_kind: ChartKind, series_kind: Option<ChartKind>, i: usize) -> ChartKind {
     match (chart_kind, series_kind) {
         (ChartKind::Combo, Some(k)) if k != ChartKind::Combo => k,
         (ChartKind::Combo, _) => {
@@ -295,15 +216,9 @@ pub(crate) fn effective_kind(chart_kind: ChartKind, series_kind: Option<ChartKin
     }
 }
 
-/// The kind series `i` is drawn as: its own kind in a combo chart (first series a column, the
-/// rest lines when it has none), else the chart's. The one rule shared by resolving and drawing.
-pub(crate) fn plot_kind(chart_kind: ChartKind, series_kind: Option<ChartKind>, i: usize) -> ChartKind {
-    if chart_kind == ChartKind::Combo { effective_kind(chart_kind, series_kind, i) } else { chart_kind }
-}
-
 /// The kind series `i` of `chart` is drawn as: its own kind in a combo chart, else the chart's.
 pub fn series_plot_kind(chart: &Chart, i: usize) -> ChartKind {
-    plot_kind(chart.kind, chart.series.get(i).and_then(|s| s.kind), i)
+    if chart.kind == ChartKind::Combo { effective_kind(chart.kind, chart.series.get(i).and_then(|s| s.kind), i) } else { chart.kind }
 }
 
 /// Evaluates a chart's series formulas: names, values, categories (default "1", "2", …), X
@@ -313,43 +228,37 @@ pub fn resolve(wb: &Workbook, sheet: usize, chart: &Chart) -> ChartData {
     let numeric_x = matches!(chart.kind, ChartKind::Scatter | ChartKind::ScatterLines | ChartKind::Bubble);
     let mut series = Vec::new();
     let mut categories: Option<Vec<String>> = None;
-    let limit = points_per_series(chart.series.len());
-    let mut trend_left = MAX_TRENDLINES;
     let mut category_levels = Vec::new();
     for (i, s) in chart.series.iter().take(MAX_SERIES).enumerate() {
-        let values = nums(wb, sheet, &s.values, limit);
+        let values = nums(wb, sheet, &s.values);
         let name = s.name.as_deref().map(|n| series_name(wb, sheet, n)).filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Series{}", i + 1));
         let color =
             s.color.as_ref().and_then(|c| c.resolve(&wb.theme)).map(|[r, g, b]| [r, g, b, 0xFF]).unwrap_or_else(|| series_color(&wb.theme, i));
         let kind = effective_kind(chart.kind, s.kind, i);
         let x = match (&s.categories, numeric_x || matches!(kind, ChartKind::Scatter | ChartKind::ScatterLines | ChartKind::Bubble)) {
             // X values with text in them (labels) are ignored: the points are numbered 1..n.
-            (Some(f), true) => {
-                Some(eval_list_in(wb, sheet, f, limit, 0)).filter(|xs| !xs.iter().any(Value::is_text)).map(|xs| xs.iter().map(to_num).collect())
-            }
+            (Some(f), true) => Some(eval_list(wb, sheet, f)).filter(|xs| !xs.iter().any(Value::is_text)).map(|xs| xs.iter().map(to_num).collect()),
             _ => None,
         };
         if categories.is_none()
             && let Some(f) = &s.categories
         {
-            let (mut c, outer) = category_table(wb, sheet, f, &s.values, limit);
-            c.truncate(limit);
+            let (c, outer) = category_table(wb, sheet, f, &s.values);
             if !c.is_empty() {
                 categories = Some(c);
                 category_levels = outer;
             }
         }
-        let sizes = s.bubble_sizes.as_deref().map(|f| nums(wb, sheet, f, limit));
+        let sizes = s.bubble_sizes.as_deref().map(|f| nums(wb, sheet, f));
         let trendlines = s
             .trendlines
             .iter()
-            .take(trend_left)
+            .take(MAX_TRENDLINES)
             .map(|t| TrendlineData {
                 spec: t.clone(),
                 color: t.color.as_ref().and_then(|c| c.resolve(&wb.theme)).map(|[r, g, b]| [r, g, b, 0xFF]).unwrap_or(color),
             })
-            .collect::<Vec<_>>();
-        trend_left = trend_left.saturating_sub(trendlines.len());
+            .collect();
         series.push(SeriesData {
             name,
             values,
@@ -368,69 +277,3 @@ pub fn resolve(wb: &Workbook, sheet: usize, chart: &Chart) -> ChartData {
     let palette = default_palette(&wb.theme, n.min(PALETTE_CYCLE));
     ChartData { categories, category_levels, series, palette }
 }
-
-#[cfg(test)]
-mod tests {
-    use gridcraft_model::Workbook;
-
-    use super::*;
-
-    fn book(rows: u32, cols: u32) -> Workbook {
-        let mut wb = Workbook::new();
-        if let Some(s) = wb.sheet_mut(0) {
-            s.name = "My Sheet".into();
-            for r in 0..rows {
-                for c in 0..cols {
-                    s.set_value(CellRef::new(r, c), Value::Number(f64::from(r * 10 + c)));
-                }
-            }
-        }
-        wb
-    }
-
-    #[test]
-    fn a_long_reference_is_clipped_before_it_is_evaluated() {
-        let wb = book(120_000, 3);
-        let rows = |f: &str, limit| {
-            let g = clipped_reference(&wb, 0, f, limit)?;
-            let (_, r) = parse_ref(&wb, 0, &g)?;
-            Some((g, u64::from(r.height())))
-        };
-        // 1,000,000 rows: at most `MAX_POINTS` of them are asked for.
-        assert_eq!(rows("'My Sheet'!$A$1:$A$1000000", MAX_POINTS), Some(("'My Sheet'!A1:A100000".to_string(), 100_000)));
-        assert_eq!(rows("A5:A1048576", MAX_POINTS).map(|r| r.1), Some(100_000));
-        assert_eq!(rows("A:A", 50_000).map(|r| r.1), Some(50_000));
-        // Never below what keeps calc trimming the clipped reference like the whole one.
-        assert_eq!(rows("A1:A1000000", 100).map(|r| r.1), Some(16_385));
-        // Wide references keep whole rows.
-        assert_eq!(rows("A1:C1000000", MAX_POINTS).map(|r| r.1), Some(100_000));
-        // Small references, single cells and anything that isn't a plain reference are left alone.
-        assert_eq!(rows("A1:A9000", MAX_POINTS), None);
-        assert_eq!(rows("A1:A20000", MAX_POINTS), None);
-        assert_eq!(rows("B2", MAX_POINTS), None);
-        assert_eq!(rows("SUM(A1:A1000000)", MAX_POINTS), None);
-        assert_eq!(rows("{1,2,3}", MAX_POINTS), None);
-    }
-
-    #[test]
-    fn clipping_does_not_change_the_points() {
-        for (rows, cols) in [(10, 1), (30_000, 1), (30_000, 2), (3, 4)] {
-            let wb = book(rows, cols);
-            for f in ["'My Sheet'!A1:A1000000", "'My Sheet'!$A$3:$B$1048576", "A:A", "A1:C1000000", "(A1:A1000000,B1:B1000000)", "A2:A20000"] {
-                for limit in [100, 7_843, 25_000, MAX_POINTS] {
-                    let clipped = eval_list_in(&wb, 0, f, limit, 0);
-                    let whole: Vec<Value> = match evaluate(&wb, 0, CellRef::default(), f) {
-                        Value::Array(a) => a.iter().take(limit).cloned().collect(),
-                        v => vec![v],
-                    };
-                    if f.starts_with('(') {
-                        // A union is read part by part; each part keeps its own order.
-                        assert!(clipped.len() <= limit);
-                        continue;
-                    }
-                    assert_eq!(clipped, whole, "{f} limit {limit} on {rows}x{cols}");
-                }
-            }
-        }
-    }
-}

crates/chart/src/tests.rs

@@ -5,7 +5,6 @@ use gridcraft_model::{Anchor, Chart, ChartKind, Color, LegendPos, Series, Sparkl
 
 use crate::*;
 
-mod budget;
 mod data_table;
 
 const ALL_KINDS: [ChartKind; 26] = [
@@ -49,8 +48,6 @@ fn chart(kind: ChartKind) -> Chart {
         data_table: None,
         gridlines: true,
         style: 0,
-        hole_size: 75,
-        first_slice_angle: 0,
         x_title: Some("Quarter".into()),
         y_title: Some("Revenue".into()),
         source: None,
@@ -152,317 +149,6 @@ fn every_kind_renders_sanely() {
     }
 }
 
-#[test]
-fn doughnut_draws_each_series_as_a_ring() {
-    let mut c = chart(ChartKind::Doughnut);
-    c.title = None;
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.hole_size = 25;
-    c.first_slice_angle = 0;
-    let d = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: ["A", "B", "C"].iter().map(|s| s.to_string()).collect(),
-        series: vec![
-            series("Inner", &[1.0, 2.0, 3.0], [20, 96, 130, 255], ChartKind::Doughnut),
-            series("Middle", &[3.0, 2.0, 1.0], [221, 132, 82, 255], ChartKind::Doughnut),
-            series("Outer", &[1.0, 1.0, 1.0], [89, 161, 79, 255], ChartKind::Doughnut),
-        ],
-    };
-    let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure);
-    let wedges: Vec<(f32, f32, f32)> = prims
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Wedge { r_outer, r_inner, a0, .. } => Some((*r_outer, *r_inner, *a0)),
-            _ => None,
-        })
-        .collect();
-    assert_eq!(wedges.len(), 9, "three rings of three slices");
-    // Excel draws the first series as the innermost ring; the hole is 25% of the radius.
-    assert!(wedges[0].0 < wedges[3].0 && wedges[3].0 < wedges[6].0, "{wedges:?}");
-    assert!(wedges[0].1 > 0.0, "hole: {wedges:?}");
-}
-
-#[test]
-fn doughnut_with_many_series_still_draws_the_outer_rings() {
-    let mut c = chart(ChartKind::Doughnut);
-    c.title = None;
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.hole_size = 75;
-    // The annulus is a few dozen pixels tall and there are far more series than pixels, so every
-    // ring is thinner than 1 px. The chart used to draw nothing at all.
-    let many = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: ["A", "B"].iter().map(|s| s.to_string()).collect(),
-        series: (0..255).map(|i| series(&format!("S{i}"), &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut)).collect(),
-    };
-    let single = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: ["A", "B"].iter().map(|s| s.to_string()).collect(),
-        // Two series, so the title fallback (a lone series names the chart) does not shrink the plot.
-        series: vec![
-            series("Only", &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut),
-            series("Other", &[1.0, 1.0], [221, 132, 82, 255], ChartKind::Doughnut),
-        ],
-    };
-    let (w, h) = (640.0, 400.0);
-    let radii = |d: &ChartData| -> Vec<f32> {
-        render(&c, d, w, h, &ApproxMeasure)
-            .iter()
-            .filter_map(|p| match p {
-                Prim::Wedge { r_outer, .. } => Some(*r_outer),
-                _ => None,
-            })
-            .collect()
-    };
-    let outer = radii(&many);
-    assert!(!outer.is_empty(), "a sub-pixel ring must not suppress the whole chart");
-    let mut distinct = outer.clone();
-    distinct.sort_by(f32::total_cmp);
-    distinct.dedup();
-    assert!(distinct.len() > 8, "only {} rings drawn", distinct.len());
-    assert!(distinct.len() < 255, "too many rings for the pixels available: {}", distinct.len());
-    // The outermost ring still reaches the plot radius the single-ring chart uses.
-    let r = radii(&single).into_iter().fold(0.0f32, f32::max);
-    let drawn = distinct.last().copied().unwrap_or(0.0);
-    assert!((drawn - r).abs() < 0.01, "outermost ring {drawn} of {r}");
-}
-
-#[test]
-fn doughnut_one_pixel_rings_skip_the_separator_stroke() {
-    let mut c = chart(ChartKind::Doughnut);
-    c.title = None;
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.hole_size = 75;
-    // 255 series over a 46-pixel annulus: every drawn ring is one pixel tall, narrower than the
-    // 1.5-pixel white separator, which would otherwise paint over both neighbouring rings.
-    let thin = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: ["A", "B"].iter().map(|s| s.to_string()).collect(),
-        series: (0..255).map(|i| series(&format!("S{i}"), &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut)).collect(),
-    };
-    let strokes: Vec<Option<(Rgba, f32)>> = render(&c, &thin, 640.0, 400.0, &ApproxMeasure)
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Wedge { stroke, .. } => Some(*stroke),
-            _ => None,
-        })
-        .collect();
-    assert!(!strokes.is_empty(), "the chart must still draw its rings");
-    assert!(strokes.iter().all(Option::is_none), "a 1.5px stroke covers a 1px band: {strokes:?}");
-
-    // A ring with room for the separator keeps it.
-    let thick = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: ["A", "B"].iter().map(|s| s.to_string()).collect(),
-        series: vec![
-            series("Inner", &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut),
-            series("Outer", &[1.0, 1.0], [221, 132, 82, 255], ChartKind::Doughnut),
-        ],
-    };
-    let strokes: Vec<Option<(Rgba, f32)>> = render(&c, &thick, 640.0, 400.0, &ApproxMeasure)
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Wedge { stroke, .. } => Some(*stroke),
-            _ => None,
-        })
-        .collect();
-    assert!(!strokes.is_empty());
-    assert!(strokes.iter().all(Option::is_some), "wide rings keep their separators: {strokes:?}");
-}
-
-#[test]
-fn doughnut_wedge_budget_bounds_many_series_and_categories() {
-    let mut c = chart(ChartKind::Doughnut);
-    c.title = None;
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.hole_size = 75;
-    c.first_slice_angle = 0;
-    // 20,000 categories across 80 series would be hundreds of thousands of wedges: the per-series
-    // limit does not bound the product. The first ten categories of every ring are the largest.
-    let cats = 20_000usize;
-    let values: Vec<f64> = (0..cats).map(|j| if j < 10 { 1000.0 } else { 1.0 }).collect();
-    let d = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: (0..cats).map(|j| format!("C{j}")).collect(),
-        series: (0..80)
-            .map(|i| SeriesData { name: format!("S{i}"), values: values.iter().map(|v| Some(*v)).collect(), ..SeriesData::default() })
-            .collect(),
-    };
-    let wedges: Vec<(f32, f32)> = render(&c, &d, 640.0, 400.0, &ApproxMeasure)
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Wedge { r_outer, a0, a1, .. } => Some((*r_outer, *a1 - *a0)),
-            _ => None,
-        })
-        .collect();
-    assert!(!wedges.is_empty(), "the innermost ring must still be drawn");
-    let mut radii: Vec<f32> = wedges.iter().map(|(r, _)| *r).collect();
-    radii.sort_by(f32::total_cmp);
-    radii.dedup();
-    assert!(radii.len() > 1, "every drawable ring is capped, not dropped");
-    // A slice crossing 12 o'clock is split into two primitives, so each ring may add one.
-    let budget = crate::render::MAX_WEDGES + radii.len();
-    assert!(wedges.len() <= budget, "{} wedges for {} rings", wedges.len(), radii.len());
-
-    // The first (innermost) ring keeps its largest slices and still fills the circle.
-    let inner: Vec<f32> = wedges.iter().filter(|(r, _)| *r == radii[0]).map(|(_, a)| *a).collect();
-    assert!(inner.len() < cats, "the ring was not capped: {}", inner.len());
-    assert_eq!(inner.iter().filter(|a| **a > 0.1).count(), 10, "largest slices went missing");
-    let cover: f32 = inner.iter().sum();
-    assert!((cover - std::f32::consts::TAU).abs() < 0.01, "first ring covers {cover}");
-}
-
-#[test]
-fn doughnut_first_slice_angle_rotates_the_start() {
-    let mut c = chart(ChartKind::Doughnut);
-    c.title = None;
-    c.legend = LegendPos::None;
-    c.first_slice_angle = 90;
-    let d = ChartData {
-        category_levels: vec![],
-        palette: vec![],
-        categories: ["A", "B"].iter().map(|s| s.to_string()).collect(),
-        series: vec![series("Only", &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut)],
-    };
-    let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure);
-    let first = prims.iter().find_map(|p| match p {
-        Prim::Wedge { a0, .. } => Some(*a0),
-        _ => None,
-    });
-    assert!(first.is_some_and(|a| (a - std::f32::consts::FRAC_PI_2).abs() < 0.01), "{first:?}");
-}
-
-/// Every slice must occupy exactly its angular share, even when the first slice angle pushes the
-/// start past 12 o'clock (the split at TAU used to put whole slices over their neighbours).
-#[test]
-fn rotated_wedges_cover_each_slice_once_without_overlap() {
-    const TAU: f32 = std::f32::consts::TAU;
-    for kind in [ChartKind::Doughnut, ChartKind::Pie] {
-        for angle in [180u16, 270] {
-            let mut c = chart(kind);
-            c.title = None;
-            c.legend = LegendPos::None;
-            c.data_labels = false;
-            c.first_slice_angle = angle;
-            let d = ChartData {
-                category_levels: vec![],
-                palette: vec![[230, 126, 34, 255], [39, 174, 96, 255], [142, 68, 173, 255]],
-                categories: ["A", "B", "C", "D"].iter().map(|s| s.to_string()).collect(),
-                series: vec![series("Only", &[1.0; 4], [20, 96, 130, 255], kind)],
-            };
-            let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure);
-            let wedges: Vec<(f32, f32)> = prims
-                .iter()
-                .filter_map(|p| match p {
-                    Prim::Wedge { a0, a1, .. } => Some((*a0, *a1)),
-                    _ => None,
-                })
-                .collect();
-            assert!(wedges.len() >= 4, "{kind:?} at {angle}: {wedges:?}");
-            for (a0, a1) in &wedges {
-                assert!((0.0..TAU).contains(a0), "{kind:?} at {angle}: start {a0} outside [0, TAU)");
-                assert!(*a1 > *a0 && *a1 <= TAU + 1e-4, "{kind:?} at {angle}: bad sweep {a0}..{a1}");
-            }
-            // Sample away from the boundaries: a correct four-slice chart covers every angle once.
-            let steps = 1440;
-            for k in 0..steps {
-                let theta = (k as f32 + 0.5) * TAU / steps as f32;
-                let cover = wedges.iter().filter(|(a0, a1)| theta >= *a0 && theta < *a1).count();
-                assert_eq!(cover, 1, "{kind:?} at {angle}: {theta} covered {cover} times by {wedges:?}");
-            }
-        }
-    }
-}
-
-/// A slice that crosses 12 o'clock is filled as two halves but outlined once: stroking each half
-/// separately ran the white separator along the shared radial edge, straight through the slice.
-#[test]
-fn slice_crossing_twelve_has_no_internal_seam() {
-    const TAU: f32 = std::f32::consts::TAU;
-    let mut c = chart(ChartKind::Pie);
-    c.title = None;
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.first_slice_angle = 90;
-    let a = [230, 126, 34, 255];
-    let b = [39, 174, 96, 255];
-    let d = ChartData {
-        category_levels: vec![],
-        palette: vec![a, b],
-        categories: ["A", "B"].iter().map(|s| s.to_string()).collect(),
-        series: vec![series("Only", &[1.0, 1.0], a, ChartKind::Pie)],
-    };
-    let (w, h) = (400u32, 400u32);
-    let prims = render(&c, &d, w as f32, h as f32, &ApproxMeasure);
-    // The second slice starts at 270° and wraps past 0°, so it is drawn as two unstroked halves.
-    let mut halves = 0;
-    let mut cx = 0.0;
-    let mut cy = 0.0;
-    let mut r = 0.0;
-    for p in &prims {
-        if let Prim::Wedge { cx: x, cy: y, r_outer, a0, a1, fill, stroke, .. } = p
-            && *fill == b
-        {
-            assert!(stroke.is_none(), "a split half must not stroke its shared edge: {p:?}");
-            assert!(*a0 == 0.0 || *a1 == TAU, "the crossing slice is split at 12 o'clock: {p:?}");
-            halves += 1;
-            (cx, cy, r) = (*x, *y, *r_outer);
-        }
-    }
-    assert_eq!(halves, 2, "one slice crosses 12 o'clock");
-    // Exactly one outline covers the whole crossing slice, drawn as line primitives.
-    assert_eq!(prims.iter().filter(|p| matches!(p, Prim::Line { color, .. } if *color == [255, 255, 255, 255])).count(), 1, "{prims:?}");
-    // No white pixel inside the slice along 12 o'clock, where the shared edge used to be stroked.
-    let img = rasterize(&prims, w, h, [255, 255, 255, 255]);
-    for t in [0.3f32, 0.5, 0.7] {
-        assert_eq!(pixel(&img, w, cx as u32, (cy - r * t) as u32), b, "white seam at {t} of the slice");
-    }
-}
-
-#[test]
-fn doughnut_legend_names_categories_and_matches_every_ring() {
-    let mut c = chart(ChartKind::Doughnut);
-    c.title = None;
-    c.data_labels = false;
-    c.legend = LegendPos::Right;
-    c.first_slice_angle = 180;
-    let d = ChartData {
-        category_levels: vec![],
-        palette: vec![[230, 126, 34, 255], [39, 174, 96, 255], [142, 68, 173, 255]],
-        categories: ["A", "B", "C", "D"].iter().map(|s| s.to_string()).collect(),
-        series: vec![
-            series("Outer", &[1.0; 4], [20, 96, 130, 255], ChartKind::Doughnut),
-            series("Inner", &[1.0; 4], [221, 132, 82, 255], ChartKind::Doughnut),
-        ],
-    };
-    let entries = legend_entries(&c, &d);
-    assert_eq!(entries.iter().map(|(name, _, _)| name.as_str()).collect::<Vec<_>>(), ["A", "B", "C", "D"]);
-
-    let start = f32::from(c.first_slice_angle) * std::f32::consts::TAU / 360.0;
-    let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure);
-    let mut rings = Vec::new();
-    for p in &prims {
-        let Prim::Wedge { r_outer, a0, a1, fill, .. } = p else { continue };
-        rings.push(*r_outer);
-        let rel = ((a0 + a1) / 2.0 - start).rem_euclid(std::f32::consts::TAU);
-        let cat = ((rel / (std::f32::consts::TAU / 4.0)) as usize).min(3);
-        assert_eq!(*fill, entries[cat].1, "ring wedge at {a0}..{a1} does not match legend entry {}", entries[cat].0);
-    }
-    rings.sort_by(f32::total_cmp);
-    rings.dedup();
-    assert_eq!(rings.len(), 2, "two series must draw two rings");
-}
-
 #[test]
 fn legend_counts() {
     let d = sample(ChartKind::ColumnClustered);
@@ -775,11 +461,7 @@ fn pie_starts_at_twelve_clockwise() {
     assert!(wedges.windows(2).all(|w| w[1].0 >= w[0].1 - 1e-4));
     assert!((wedges[5].1 - std::f32::consts::TAU).abs() < 1e-3);
     assert!(wedges.iter().all(|w| w.2 == 0.0 && w.3.map(|s| s.0) == Some([255; 4])));
-    let mut c = chart(ChartKind::Doughnut);
-    c.hole_size = 50;
-    let mut d = sample(ChartKind::Doughnut);
-    d.series.truncate(1);
-    let prims = render(&c, &d, 400.0, 400.0, &ApproxMeasure);
+    let prims = render(&chart(ChartKind::Doughnut), &d, 400.0, 400.0, &ApproxMeasure);
     let ok = prims.iter().any(|p| matches!(p, Prim::Wedge { r_outer, r_inner, .. } if (r_inner / r_outer - 0.5).abs() < 1e-3));
     assert!(ok);
 }
@@ -1419,38 +1101,6 @@ fn area_charts_draw_source_value_labels_only_when_enabled() {
     }
 }
 
-#[test]
-fn drawing_and_resolving_agree_on_the_combo_plot_kind() {
-    // Resolved series carry `effective_kind`; drawing re-derives the kind from it. Both paths
-    // must give the same kind for every chart kind, series kind (or none) and series index.
-    let series_kinds = std::iter::once(None).chain(ALL_KINDS.iter().map(|k| Some(*k)));
-    for ck in ALL_KINDS {
-        for sk in series_kinds.clone() {
-            for i in 0..3 {
-                let mut c = chart(ck);
-                c.series = (0..3).map(|j| Series { kind: if j == i { sk } else { None }, ..Default::default() }).collect();
-                let from_chart = series_plot_kind(&c, i);
-                let resolved = crate::resolve::effective_kind(ck, sk, i);
-                assert_eq!(crate::resolve::plot_kind(ck, Some(resolved), i), from_chart, "{ck:?} {sk:?} {i}");
-                if ck != ChartKind::Combo {
-                    assert_eq!(from_chart, ck);
-                } else {
-                    assert_ne!(from_chart, ChartKind::Combo);
-                }
-            }
-        }
-    }
-}
-
-#[test]
-fn ticks_of_a_scale_off_the_step_grid_start_at_its_min() {
-    let s = Scale { min: 3.0, max: 7.0, step: 4.0 };
-    assert_eq!(s.ticks(), vec![3.0, 7.0]);
-    // Aligned scales still snap float error away.
-    let s = Scale { min: 0.0, max: 1.0, step: 0.1 };
-    assert!((s.ticks()[3] - 0.3).abs() < 1e-12 && s.ticks()[0] == 0.0);
-}
-
 #[test]
 fn hundred_percent_stacked_areas_fill_each_category_to_its_total() {
     let d = ChartData {

crates/chart/src/tests/budget.rs

@@ -1,279 +0,0 @@
-//! Work and memory are bounded by the product of the chart limits (series x points, trendlines
-//! per chart, hairline bars), and clean data is rendered without a copy.
-
-use std::borrow::Cow;
-
-use gridcraft_core::{CellRef, Value};
-use gridcraft_model::{ChartKind, Series, Trendline, TrendlineKind, Workbook};
-
-use super::{assert_sane, chart};
-use crate::render::{sanitize, sanitized};
-use crate::resolve::{MAX_POINTS, MAX_TOTAL_POINTS, MAX_TRENDLINES, points_per_series};
-use crate::*;
-
-fn data_of(series: usize, points: usize) -> ChartData {
-    ChartData {
-        palette: vec![],
-        categories: (0..points).map(|i| i.to_string()).collect(),
-        category_levels: vec![],
-        series: (0..series)
-            .map(|s| SeriesData {
-                name: format!("S{s}"),
-                values: (0..points).map(|i| Some(((i * 7 + s * 13) % 100 + 1) as f64)).collect(),
-                color: series_color(&Default::default(), s),
-                ..SeriesData::default()
-            })
-            .collect(),
-    }
-}
-
-fn series_rects(prims: &[Prim], color: Rgba) -> Vec<(f32, f32, f32, f32)> {
-    prims
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Rect { x, y, w, h, fill: Some(f), .. } if *f == color => Some((*x, *y, *w, *h)),
-            _ => None,
-        })
-        .collect()
-}
-
-#[test]
-fn the_point_budget_keeps_every_series_with_fewer_points() {
-    assert_eq!(points_per_series(1), MAX_POINTS);
-    assert_eq!(points_per_series(20), MAX_POINTS);
-    assert_eq!(points_per_series(21), MAX_TOTAL_POINTS / 21);
-    assert_eq!(points_per_series(255), MAX_TOTAL_POINTS / 255);
-    assert_eq!(points_per_series(0), MAX_POINTS);
-
-    // 25 series x 100,000 points is 2.5 million: over budget.
-    let d = data_of(25, MAX_POINTS);
-    let kept = sanitized(&d);
-    assert_eq!(kept.series.len(), 25, "no series is dropped");
-    assert!(kept.series.iter().all(|s| s.values.len() == MAX_TOTAL_POINTS / 25));
-    assert_eq!(kept.categories.len(), MAX_TOTAL_POINTS / 25);
-    assert!(kept.series.iter().map(|s| s.values.len()).sum::<usize>() <= MAX_TOTAL_POINTS);
-    // The first points are the ones kept.
-    assert_eq!(kept.series[3].values[..5], d.series[3].values[..5]);
-
-    // Drawing it stays bounded: hairline columns are merged per pixel column.
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.data_labels = false;
-    c.legend = LegendPos::None;
-    let prims = render(&c, &d, 400.0, 300.0, &ApproxMeasure);
-    assert_sane(&prims, 400.0, 300.0);
-    assert!(prims.len() < 25 * 450 + 200, "{} primitives", prims.len());
-}
-
-#[test]
-fn trendlines_are_limited_per_chart() {
-    let line = |kind| TrendlineData { spec: Trendline { kind, ..Trendline::default() }, color: [1, 2, 3, 255] };
-    let mut d = data_of(3, 30);
-    for s in &mut d.series {
-        s.trendlines = vec![line(TrendlineKind::Linear); 10];
-    }
-    let kept = sanitized(&d);
-    let counts: Vec<usize> = kept.series.iter().map(|s| s.trendlines.len()).collect();
-    assert_eq!(counts, vec![10, MAX_TRENDLINES - 10, 0], "series order decides which trendlines stay");
-    let entries = legend_entries(&chart(ChartKind::Line), &kept);
-    assert_eq!(entries.len(), 3 + MAX_TRENDLINES);
-}
-
-#[test]
-fn hairline_columns_are_merged_and_wide_ones_are_not() {
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.data_labels = false;
-    c.legend = LegendPos::None;
-
-    // Wide bars (>= 0.25 px): one rectangle per series and category, as before.
-    let d = data_of(3, 40);
-    let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure);
-    for s in &d.series {
-        assert_eq!(series_rects(&prims, s.color).len(), 40);
-    }
-
-    // 4 series x 20,000 categories in 400 px: the bars are hairlines.
-    let d = data_of(4, 20_000);
-    let prims = render(&c, &d, 400.0, 300.0, &ApproxMeasure);
-    assert_sane(&prims, 400.0, 300.0);
-    for s in &d.series {
-        let n = series_rects(&prims, s.color).len();
-        assert!((1..=420).contains(&n), "{n} rectangles for one series");
-    }
-
-    // The merged rectangles keep the envelope: alternating 1 and 10 draws the full-height bar.
-    let mut d = data_of(1, 20_000);
-    for (i, v) in d.series[0].values.iter_mut().enumerate() {
-        *v = Some(if i % 2 == 0 { 1.0 } else { 10.0 });
-    }
-    let prims = render(&c, &d, 400.0, 300.0, &ApproxMeasure);
-    let rects = series_rects(&prims, d.series[0].color);
-    let tallest = rects.iter().map(|r| r.3).fold(0.0f32, f32::max);
-    assert!(rects.len() > 100 && tallest > 100.0);
-    assert!(rects.iter().all(|r| (r.3 - tallest).abs() < 0.01), "every pixel column shows the tall bar");
-    // And together they cover the plot's width without a gap wider than a pixel.
-    let mut xs: Vec<(f32, f32)> = rects.iter().map(|r| (r.0, r.0 + r.2)).collect();
-    xs.sort_by(|a, b| a.0.total_cmp(&b.0));
-    assert!(xs.windows(2).all(|w| w[1].0 - w[0].1 < 1.0));
-
-    // Horizontal bars too.
-    let mut c = chart(ChartKind::BarClustered);
-    c.data_labels = false;
-    c.legend = LegendPos::None;
-    let prims = render(&c, &d, 400.0, 300.0, &ApproxMeasure);
-    let n = series_rects(&prims, d.series[0].color).len();
-    assert!((1..=320).contains(&n), "{n} bars");
-}
-
-#[test]
-fn clustered_hairline_series_keep_a_visible_strip() {
-    // Four series of similar height, 20,000 categories in 400 px: every pixel column holds a
-    // merged bar of each series, and they must not cover each other.
-    for kind in [ChartKind::ColumnClustered, ChartKind::BarClustered] {
-        let horizontal = kind == ChartKind::BarClustered;
-        let mut c = chart(kind);
-        c.data_labels = false;
-        c.legend = LegendPos::None;
-        let mut d = data_of(4, 20_000);
-        for (s, series) in d.series.iter_mut().enumerate() {
-            for (i, v) in series.values.iter_mut().enumerate() {
-                *v = Some(50.0 + ((i + s) % 3) as f64);
-            }
-        }
-        let prims = render(&c, &d, 400.0, 300.0, &ApproxMeasure);
-        let along = |r: &(f32, f32, f32, f32)| if horizontal { (r.1, r.1 + r.3) } else { (r.0, r.0 + r.2) };
-        let mut strips: Vec<(f32, f32, usize)> = Vec::new();
-        for (s, series) in d.series.iter().enumerate() {
-            strips.extend(series_rects(&prims, series.color).iter().map(|r| (along(r).0, along(r).1, s)));
-        }
-        strips.sort_by(|a, b| a.0.total_cmp(&b.0));
-        assert!(strips.len() > 400);
-        // Rectangles of different series never overlap (more than rounding).
-        for w in strips.windows(2) {
-            assert!(w[0].2 == w[1].2 || w[1].0 >= w[0].1 - 1e-3, "series {} and {} overlap", w[0].2, w[1].2);
-        }
-        // And all four series show up in the same pixel column.
-        let col = strips[strips.len() / 2].0.floor();
-        let seen: std::collections::BTreeSet<usize> = strips.iter().filter(|s| s.0.floor() == col).map(|s| s.2).collect();
-        assert_eq!(seen.len(), 4, "series visible in pixel column {col}");
-    }
-}
-
-#[test]
-fn stacked_hairline_bars_do_not_fill_the_gap_between_disjoint_spans() {
-    // Series 1 alternates +10 (stacked on the 100) and -10 (below zero): its two spans in one
-    // pixel column are 100..110 and -10..0, and the 100 units between them must stay empty.
-    let mut c = chart(ChartKind::ColumnStacked);
-    c.data_labels = false;
-    c.legend = LegendPos::None;
-    let mut d = data_of(2, 20_000);
-    for v in d.series[0].values.iter_mut() {
-        *v = Some(100.0);
-    }
-    for (i, v) in d.series[1].values.iter_mut().enumerate() {
-        *v = Some(if i % 2 == 0 { 10.0 } else { -10.0 });
-    }
-    let prims = render(&c, &d, 400.0, 300.0, &ApproxMeasure);
-    let rects = series_rects(&prims, d.series[1].color);
-    let tallest = rects.iter().map(|r| r.3).fold(0.0f32, f32::max);
-    assert!(!rects.is_empty() && tallest < 60.0, "tallest merged bar is {tallest} px");
-}
-
-#[test]
-fn clean_data_is_rendered_without_a_copy() {
-    let d = data_of(3, 50);
-    assert!(matches!(sanitized(&d), Cow::Borrowed(_)));
-
-    // Dirty data takes the copying path and comes out as `sanitize` has always produced it.
-    let mut dirty = data_of(3, 50);
-    dirty.series[0].values[4] = Some(f64::NAN);
-    dirty.series[1].values[5] = Some(f64::INFINITY);
-    dirty.series[2].values[6] = Some(1e301);
-    dirty.series[2].x = Some(vec![Some(f64::NEG_INFINITY), Some(2.0)]);
-    dirty.series[1].sizes = Some(vec![Some(-1e305)]);
-    let got = sanitized(&dirty);
-    assert!(matches!(got, Cow::Owned(_)));
-    assert_eq!(*got, sanitize(&dirty));
-    assert_eq!(got.series[0].values[4], None);
-    assert_eq!(got.series[2].values[6], Some(1e300));
-
-    // Over the series cap (within the point budget) the same.
-    let many = data_of(300, 3);
-    let got = sanitized(&many);
-    assert_eq!(got.series.len(), 255);
-    assert_eq!(*got, sanitize(&many));
-
-    // Too many category levels take the copying path too.
-    let mut levels = data_of(3, 50);
-    levels.category_levels = vec![vec!["a".into()]; 5];
-    let got = sanitized(&levels);
-    assert!(matches!(got, Cow::Owned(_)));
-    assert_eq!(got.category_levels.len(), 3);
-}
-
-#[test]
-fn resolve_keeps_every_series_within_the_point_budget() {
-    // 40 series x 60,000 points is 2.4 million: over the 2 million budget.
-    let mut wb = Workbook::new();
-    if let Some(s) = wb.sheet_mut(0) {
-        for r in 0..60_000u32 {
-            s.set_value(CellRef::new(r, 0), Value::Number(f64::from(r)));
-        }
-    }
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.series =
-        (0..40).map(|_| Series { values: "Sheet1!$A$1:$A$1000000".into(), categories: Some("A1:A1000000".into()), ..Series::default() }).collect();
-    let d = resolve(&wb, 0, &c);
-    assert_eq!(d.series.len(), 40);
-    assert!(d.series.iter().all(|s| s.values.len() == MAX_TOTAL_POINTS / 40));
-    assert_eq!(d.categories.len(), MAX_TOTAL_POINTS / 40);
-    assert_eq!(d.series[7].values.first(), Some(&Some(0.0)));
-    // Trendlines: 16 per chart, in series order.
-    c.series = (0..4).map(|_| Series { values: "A1:A5".into(), trendlines: vec![Default::default(); 9], ..Series::default() }).collect();
-    let counts: Vec<usize> = resolve(&wb, 0, &c).series.iter().map(|s| s.trendlines.len()).collect();
-    assert_eq!(counts, vec![9, 7, 0, 0]);
-}
-
-/// 100 series lower the per-series cap to 20,000, below the number of category cells of a
-/// two-level axis (#1155). Each kept category keeps its inner label and its outer level.
-fn two_level_chart(n: u32, vertical: bool) -> ChartData {
-    let at = |i: u32, level: u32| if vertical { CellRef::new(i, level) } else { CellRef::new(level, i) };
-    let mut wb = Workbook::new();
-    if let Some(s) = wb.sheet_mut(0) {
-        for i in 0..n {
-            s.set_value(at(i, 0), Value::Text(format!("Y{}", i / 3).into()));
-            s.set_value(at(i, 1), Value::Text(format!("C{i}").into()));
-            s.set_value(at(i, 2), Value::Number(f64::from(i)));
-        }
-    }
-    let cats = format!("{}:{}", at(0, 0), at(n - 1, 1));
-    let values = format!("{}:{}", at(0, 2), at(n - 1, 2));
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.series = (0..100).map(|_| Series { values: values.clone(), categories: Some(cats.clone()), ..Series::default() }).collect();
-    resolve(&wb, 0, &c)
-}
-
-#[test]
-fn multi_level_categories_keep_their_levels_under_the_point_cap() {
-    for vertical in [true, false] {
-        let d = two_level_chart(15_000, vertical);
-        assert_eq!(d.series[0].values.len(), 15_000, "vertical {vertical}");
-        assert_eq!(d.categories.len(), 15_000, "vertical {vertical}");
-        assert_eq!(d.categories[0], "C0");
-        assert_eq!(d.categories[14_999], "C14999");
-        assert_eq!(d.category_levels.len(), 1, "one outer level, vertical {vertical}");
-        assert_eq!(d.category_levels[0].len(), 15_000);
-        assert_eq!(d.category_levels[0][3], "Y1");
-    }
-}
-
-#[test]
-fn multi_level_categories_longer_than_the_cap_are_cut_together_with_their_levels() {
-    // 25,000 categories against a cap of 20,000.
-    let d = two_level_chart(25_000, true);
-    let cap = points_per_series(100);
-    assert_eq!(d.categories.len(), cap);
-    assert_eq!(d.category_levels.len(), 1);
-    assert_eq!(d.category_levels[0].len(), cap);
-    assert_eq!(d.categories[cap - 1], format!("C{}", cap - 1));
-    assert_eq!(d.category_levels[0][cap - 3], format!("Y{}", (cap - 3) / 3));
-}

crates/chart/src/tests/data_table.rs

@@ -1,35 +1,6 @@
 use super::*;
 use gridcraft_model::ChartDataTable;
 
-#[test]
-fn combo_table_keys_use_each_series_index() {
-    let mut c = chart(ChartKind::Combo);
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.data_table = Some(ChartDataTable::default());
-    let mut d = sample(c.kind);
-    // The public renderer also accepts Combo series: the first defaults to columns, later ones to lines.
-    for s in &mut d.series {
-        s.kind = ChartKind::Combo;
-    }
-    let p = render(&c, &d, 900.0, 500.0, &ApproxMeasure);
-    assert_sane(&p, 900.0, 500.0);
-    let header_y = p
-        .iter()
-        .find_map(|p| match p {
-            Prim::Text { text, y, .. } if text == "Q1" => Some(*y),
-            _ => None,
-        })
-        .unwrap();
-    for (i, s) in d.series.iter().enumerate() {
-        let boxes = p.iter().filter(|p| matches!(p, Prim::Rect { y, fill: Some(f), .. } if *f == s.color && *y > header_y)).count();
-        let lines =
-            p.iter().filter(|p| matches!(p, Prim::Line { pts, color, .. } if *color == s.color && pts.iter().all(|p| p[1] > header_y))).count();
-        assert_eq!(boxes, usize::from(i == 0), "series {i}: column key");
-        assert_eq!(lines, usize::from(i > 0), "series {i}: line key");
-    }
-}
-
 #[test]
 fn tables_draw_source_values_for_every_supported_chart_kind() {
     for kind in ALL_KINDS {

crates/chart/src/trend.rs

@@ -72,12 +72,7 @@ pub(crate) fn fit_trendline(t: &Trendline, pts: &[(f64, f64)]) -> Option<TrendFi
     let mut aty = vec![0.0f64; m];
     for &(x, y) in &data {
         let u = (x - center) / scale;
-        // `d` is at most 6, so the powers `first..=d` always fit the array (no allocation per point).
-        let mut buf = [0.0f64; 7];
-        for (slot, k) in buf.iter_mut().zip(first..=d) {
-            *slot = u.powi(k as i32);
-        }
-        let pows = buf.get(..m)?;
+        let pows: Vec<f64> = (first..=d).map(|k| u.powi(k as i32)).collect();
         for (i, pi) in pows.iter().enumerate() {
             if let Some(v) = aty.get_mut(i) {
                 *v += pi * (y - b0);
@@ -263,45 +258,10 @@ fn trim_zeros(s: &str) -> String {
 
 /// Moving average of `period` consecutive points in plotted order: point `i` (from
 /// `period - 1`) is `(xᵢ, mean(yᵢ₋ₚ₊₁..=yᵢ))`. Empty when there are fewer points than `period`.
-///
-/// Linear in the number of points: the points are cut into blocks of `period`, and a window is
-/// the tail of one block plus the head of the next, taken from running sums that only ever add
-/// (a running sum that also subtracts would lose small values after a huge one passed through).
 pub(crate) fn moving_average(pts: &[(f64, f64)], period: u32) -> Vec<(f64, f64)> {
     let p = period.clamp(2, 255) as usize;
     let pts: Vec<(f64, f64)> = pts.iter().copied().filter(|(x, y)| x.is_finite() && y.is_finite()).collect();
-    let n = pts.len();
-    if n < p {
-        return vec![];
-    }
-    // `head[i]`: sum of the block's points up to and including `i`; `tail[i]`: from `i` to the block's end.
-    let mut head = vec![0.0f64; n];
-    let mut tail = vec![0.0f64; n];
-    for (b, block) in pts.chunks(p).enumerate() {
-        let (mut h, mut t) = (0.0f64, 0.0f64);
-        for k in 0..block.len() {
-            h += block.get(k).map_or(0.0, |q| q.1);
-            if let Some(v) = head.get_mut(b * p + k) {
-                *v = h;
-            }
-            let r = block.len() - 1 - k;
-            t += block.get(r).map_or(0.0, |q| q.1);
-            if let Some(v) = tail.get_mut(b * p + r) {
-                *v = t;
-            }
-        }
-    }
-    (p - 1..n)
-        .filter_map(|i| {
-            let s = i + 1 - p;
-            let mut sum = tail.get(s)? + if s.is_multiple_of(p) { 0.0 } else { *head.get(i)? };
-            if !sum.is_finite() {
-                // A block sum overflowed although the window itself may not: sum it directly.
-                sum = pts.get(s..=i)?.iter().map(|q| q.1).sum();
-            }
-            Some((pts.get(i)?.0, sum / p as f64))
-        })
-        .collect()
+    pts.windows(p).filter_map(|w| w.last().map(|(x, _)| (*x, w.iter().map(|q| q.1).sum::<f64>() / p as f64))).collect()
 }
 
 /// Excel's automatic trendline name for the legend, e.g. `Linear (Sales)`.
@@ -316,177 +276,3 @@ pub(crate) fn auto_name(kind: TrendlineKind, series: &str) -> String {
     };
     format!("{k} ({series})")
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// xorshift64 for repeatable pseudo-random data.
-    struct Rng(u64);
-
-    impl Rng {
-        fn next(&mut self) -> u64 {
-            self.0 ^= self.0 << 13;
-            self.0 ^= self.0 >> 7;
-            self.0 ^= self.0 << 17;
-            self.0
-        }
-        fn unit(&mut self) -> f64 {
-            (self.next() % 1_000_000) as f64 / 1_000_000.0 - 0.5
-        }
-    }
-
-    /// The window-by-window moving average this module used to compute.
-    fn moving_average_naive(pts: &[(f64, f64)], period: u32) -> Vec<(f64, f64)> {
-        let p = period.clamp(2, 255) as usize;
-        let pts: Vec<(f64, f64)> = pts.iter().copied().filter(|(x, y)| x.is_finite() && y.is_finite()).collect();
-        pts.windows(p).filter_map(|w| w.last().map(|(x, _)| (*x, w.iter().map(|q| q.1).sum::<f64>() / p as f64))).collect()
-    }
-
-    #[test]
-    fn linear_moving_average_matches_the_window_sums() {
-        let mut r = Rng(0x9E37_79B9_7F4A_7C15);
-        for case in 0..60 {
-            let n = (r.next() % 700) as usize;
-            let pts: Vec<(f64, f64)> = (0..n)
-                .map(|i| {
-                    let y = match case % 5 {
-                        0 => r.unit() * 100.0,
-                        1 => 1e9 + r.unit(),
-                        // A huge value passing through must not leave rounding residue behind.
-                        2 => {
-                            if r.next().is_multiple_of(50) {
-                                1e300 * r.unit().signum()
-                            } else {
-                                r.unit()
-                            }
-                        }
-                        3 => {
-                            if i % 2 == 0 {
-                                1e15
-                            } else {
-                                -1e15 + r.unit()
-                            }
-                        }
-                        _ => {
-                            if r.next().is_multiple_of(9) {
-                                f64::NAN
-                            } else {
-                                r.unit() * 1e-3
-                            }
-                        }
-                    };
-                    (i as f64, y)
-                })
-                .collect();
-            for period in [0, 2, 3, 7, 50, 255, 400] {
-                let fast = moving_average(&pts, period);
-                let slow = moving_average_naive(&pts, period);
-                assert_eq!(fast.len(), slow.len(), "case {case} period {period}");
-                let p = period.clamp(2, 255) as usize;
-                let finite: Vec<(f64, f64)> = pts.iter().copied().filter(|(x, y)| x.is_finite() && y.is_finite()).collect();
-                for (i, ((fx, fy), (sx, sy))) in fast.iter().zip(&slow).enumerate() {
-                    assert_eq!(fx, sx);
-                    let mass: f64 = finite.iter().skip(i).take(p).map(|q| q.1.abs()).sum::<f64>() / p as f64;
-                    assert!((fy - sy).abs() <= 1e-12 * mass, "case {case} period {period} point {i}: {fy} vs {sy}");
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn moving_average_recomputes_a_window_whose_block_sums_overflow() {
-        let pts: Vec<(f64, f64)> = [0.0, -1e308, 1e308, 1e308, -1e308].iter().enumerate().map(|(i, y)| (i as f64, *y)).collect();
-        let fast = moving_average(&pts, 4);
-        let slow = moving_average_naive(&pts, 4);
-        assert_eq!(fast, slow);
-        assert!(fast.iter().all(|q| q.1.is_finite()));
-    }
-
-    /// The trendline fit as it was written with a `Vec` of powers per data point.
-    fn fit_reference(t: &Trendline, pts: &[(f64, f64)]) -> Option<TrendFit> {
-        let kind = t.kind;
-        let d = degree(kind)?;
-        let data: Vec<(f64, f64)> = pts
-            .iter()
-            .filter(|(x, y)| x.is_finite() && y.is_finite() && (!log_x(kind) || *x > 0.0) && (!log_y(kind) || *y > 0.0))
-            .map(|&(x, y)| (if log_x(kind) { x.ln() } else { x }, if log_y(kind) { y.ln() } else { y }))
-            .collect();
-        if data.len() < 2 || data.len() <= d {
-            return None;
-        }
-        let fixed = match kind {
-            TrendlineKind::Linear | TrendlineKind::Polynomial(_) => t.intercept,
-            TrendlineKind::Exponential => t.intercept.filter(|b| *b > 0.0).map(f64::ln),
-            _ => None,
-        }
-        .filter(|b| b.is_finite());
-        let n = data.len() as f64;
-        let center = if fixed.is_some() { 0.0 } else { data.iter().map(|p| p.0).sum::<f64>() / n };
-        let scale = data.iter().map(|p| (p.0 - center).abs()).fold(0.0f64, f64::max);
-        if !(scale.is_finite() && scale > 0.0) {
-            return None;
-        }
-        let first = usize::from(fixed.is_some());
-        let b0 = fixed.unwrap_or(0.0);
-        let m = d + 1 - first;
-        let mut ata = vec![vec![0.0f64; m]; m];
-        let mut aty = vec![0.0f64; m];
-        for &(x, y) in &data {
-            let u = (x - center) / scale;
-            let pows: Vec<f64> = (first..=d).map(|k| u.powi(k as i32)).collect();
-            for (i, pi) in pows.iter().enumerate() {
-                aty[i] += pi * (y - b0);
-                for (j, pj) in pows.iter().enumerate() {
-                    ata[i][j] += pi * pj;
-                }
-            }
-        }
-        let sol = solve(ata, aty)?;
-        let mut a = vec![b0; d + 1];
-        for (k, v) in sol.into_iter().enumerate() {
-            a[k + first] = v;
-        }
-        let coef = expand(&a, center, scale)?;
-        let fit = TrendFit { kind, coef, center, scale, a, r2: None };
-        let mean = data.iter().map(|p| p.1).sum::<f64>() / n;
-        let (mut ss_res, mut ss_tot) = (0.0f64, 0.0f64);
-        for &(x, y) in &data {
-            ss_res += (y - fit.poly(x)).powi(2);
-            ss_tot += if fixed.is_some() { (y - b0).powi(2) } else { (y - mean).powi(2) };
-        }
-        let r2 = (ss_tot > 0.0 && ss_tot.is_finite() && ss_res.is_finite()).then(|| 1.0 - ss_res / ss_tot);
-        Some(TrendFit { r2, ..fit })
-    }
-
-    #[test]
-    fn fit_without_a_vec_per_point_is_bit_identical() {
-        let mut r = Rng(0x1234_5678_9ABC_DEF1);
-        let kinds = [
-            TrendlineKind::Linear,
-            TrendlineKind::Exponential,
-            TrendlineKind::Logarithmic,
-            TrendlineKind::Power,
-            TrendlineKind::Polynomial(2),
-            TrendlineKind::Polynomial(3),
-            TrendlineKind::Polynomial(6),
-            TrendlineKind::MovingAverage(3),
-        ];
-        for case in 0..40 {
-            let n = 2 + (r.next() % 60) as usize;
-            let pts: Vec<(f64, f64)> = (0..n)
-                .map(|i| {
-                    let x = i as f64 * (1.0 + r.unit()) + 1.0;
-                    let y = if case % 4 == 0 { f64::NAN } else { (r.unit() + 0.6) * 10f64.powi((case % 7) - 2) };
-                    (x, if case % 4 == 0 && i % 3 != 0 { r.unit() + 1.0 } else { y })
-                })
-                .collect();
-            for kind in kinds {
-                for intercept in [None, Some(0.5), Some(-1.0)] {
-                    let t = Trendline { kind, intercept, ..Trendline::default() };
-                    assert_eq!(fit_trendline(&t, &pts), fit_reference(&t, &pts), "case {case} {kind:?} {intercept:?}");
-                }
-            }
-        }
-    }
-}

crates/core/src/addr.rs

@@ -296,40 +296,10 @@ pub fn split_sheet(reference: &str) -> (Option<String>, &str) {
     }
 }
 
-/// The areas of a reference list, split at the commas between them. A comma inside a quoted
-/// sheet name (`'Sales, West'!A1`) is part of the name, and a doubled quote inside the quotes
-/// (`'O''Brien, Jr'!A1`) is an escaped quote, not the end of the name: a quote toggles the
-/// quoted state, so a doubled one toggles it twice.
-pub fn split_areas(reference: &str) -> Vec<&str> {
-    let mut areas = Vec::new();
-    let (mut start, mut quoted) = (0, false);
-    for (i, c) in reference.char_indices() {
-        match c {
-            '\'' => quoted = !quoted,
-            ',' if !quoted => {
-                areas.push(reference.get(start..i).unwrap_or_default());
-                start = i.saturating_add(1);
-            }
-            _ => {}
-        }
-    }
-    areas.push(reference.get(start..).unwrap_or_default());
-    areas
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn areas_split_only_at_commas_outside_quoted_sheet_names() {
-        assert_eq!(split_areas("B2:B4,D1"), ["B2:B4", "D1"]);
-        assert_eq!(split_areas("'Sales, West'!$A$1"), ["'Sales, West'!$A$1"]);
-        assert_eq!(split_areas("'O''Brien, Jr'!A1:B2,D4"), ["'O''Brien, Jr'!A1:B2", "D4"]);
-        assert_eq!(split_areas("'Q1, Q2'!A1,'Q3, Q4'!B2"), ["'Q1, Q2'!A1", "'Q3, Q4'!B2"]);
-        assert_eq!(split_areas(""), [""]);
-    }
-
     #[test]
     fn range_parse_rejects_signed_rows() -> Result<(), std::io::Error> {
         assert!(RangeRef::parse("+1:+3").is_none());

crates/core/src/lib.rs

@@ -11,7 +11,7 @@ pub mod value;
 
 pub use addr::{
     CategoryLevels, CellRef, MAX_COLS, MAX_ROWS, RangeRef, category_levels, col_to_letters, letters_to_col, quote_sheet, sheet_needs_quotes,
-    split_areas, split_sheet, unquote_sheet,
+    split_sheet, unquote_sheet,
 };
 pub use date::DateSystem;
 pub use value::{Array, CellError, Value, compare, compare_numbers, compare_text, number_to_text, sort_compare};

crates/engine/src/catalog.rs

@@ -275,11 +275,6 @@ pub const CATALOG: &[(&str, &str, &str, &str)] = &[
     ("automate.allScripts", "Automate", "Scripting Tools", "All Scripts"),
     ("automate.recordActions", "Automate", "Scripting Tools", "Record Actions"),
     ("automate.trustScripts", "Automate", "Scripting Tools", "Trust Scripts"),
-    // Developer (Insert › Controls in GridCraft)
-    ("insert.button", "Developer", "Controls", "Button (Form Control)"),
-    ("insert.spinButton", "Developer", "Controls", "Spin Button (Form Control)"),
-    ("insert.slider", "Developer", "Controls", "Scroll Bar (Form Control)"),
-    ("control.format", "Developer", "Controls", "Properties"),
     // Table Design
     ("table.rename", "Table Design", "Properties", "Table Name"),
     ("table.resize", "Table Design", "Properties", "Resize Table"),

crates/engine/src/cmd.rs

@@ -2,7 +2,6 @@
 //! `data.sortAscending`) plus primitive editing commands (`cell.set`, `selection.set`).
 
 pub mod analysis;
-pub mod controls;
 pub mod data;
 pub mod draw;
 pub mod edit;
@@ -166,7 +165,6 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(format::specs());
         v.extend(sheet::specs());
         v.extend(insert::specs());
-        v.extend(controls::specs());
         v.extend(equation::specs());
         v.extend(data::specs());
         v.extend(formulas::specs());
@@ -406,7 +404,7 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
         edits: Vec::new(),
     };
     let r = f(&mut ctx)?;
-    let Ctx { mut wb, mut changed, structural, mut fit_rows, protection_checked, edits, .. } = ctx;
+    let Ctx { mut wb, changed, structural, mut fit_rows, protection_checked, edits, .. } = ctx;
     // Equations whose source changed (or that arrived without a layout, as from a paste) are
     // laid out here, so painting only ever reads the cache.
     wb.refresh_equations();
@@ -416,9 +414,6 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
     if !structural {
         check_arrays(&d.wb, &wb)?;
     }
-    if wb.calc.precision_as_displayed {
-        round_edited_as_displayed(&d.wb, &mut wb, &mut changed, structural);
-    }
     if let Some(log) = d.touched.as_mut() {
         for (si, c) in changed.iter().take(TOUCH_LOG_LIMIT.saturating_sub(log.len())) {
             if let Some(sh) = wb.sheet(*si) {
@@ -440,7 +435,6 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
     } else if !changed.is_empty() {
         d.calc.cells_changed(&mut wb, &changed);
     }
-    controls::sync_linked_values(&mut wb);
     if let Some(t0) = t0 {
         eprintln!("commit: + recalc {:?}", since(t0));
     }
@@ -457,117 +451,6 @@ pub(crate) fn commit<R>(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result<R>)
     Ok(r)
 }
 
-/// "Set precision as displayed": a number typed, pasted or reformatted is stored as its format
-/// shows it (Excel rounds a constant when it is entered and when its cell's format changes,
-/// observed through COM). Only cells the edit touched are visited, so this costs nothing for
-/// the rest of the workbook; formula cells whose format changed are recalculated, and the
-/// recalculation rounds them. A structural edit recalculates everything anyway, so it only
-/// rounds its constants (a sheet the edit created, for one, holds written numbers).
-fn round_edited_as_displayed(old: &Workbook, wb: &mut Workbook, changed: &mut Vec<gridcraft_calc::Key>, structural: bool) {
-    let mut prec = gridcraft_calc::DisplayedPrecision::new();
-    for si in 0..wb.sheets.len() {
-        let Some(after) = wb.sheets.get(si) else { continue };
-        // Sheets are matched by name. A sheet the edit created has no earlier version, so all of
-        // its cells are new.
-        let before = old.sheet_index(&after.name).and_then(|i| old.sheets.get(i));
-        if before.is_some_and(|b| std::sync::Arc::ptr_eq(b, after)) {
-            continue;
-        }
-        let diffs: Vec<CellRef> = match before {
-            Some(before) => before.cells.diff(&after.cells),
-            None => after.cells.iter().map(|(c, _)| c).collect(),
-        };
-        let mut anchors = std::collections::HashSet::new();
-        for &c in &diffs {
-            if !structural && after.cell(c).is_some_and(|cell| cell.formula.is_some()) {
-                changed.push((si, c));
-                anchors.insert(c);
-            }
-        }
-        let updates = displayed_updates(&mut prec, wb, si, diffs.iter().copied());
-        // A spill destination is no stored cell: reformatting it (or its row or column) leaves
-        // no change in the store, so its anchor is recalculated to round the new element.
-        if let (Some(before), false) = (before, structural) {
-            for (&anchor, range) in &after.spill_ranges {
-                if !anchors.contains(&anchor)
-                    && (diffs.iter().any(|d| range.contains(*d))
-                        || line_styles_differ(&before.rows, &after.rows, range.start.row, range.end.row)
-                        || line_styles_differ(&before.cols, &after.cols, range.start.col, range.end.col))
-                {
-                    changed.push((si, anchor));
-                }
-            }
-        }
-        if updates.is_empty() {
-            continue;
-        }
-        let Some(sh) = wb.sheet_mut(si) else { continue };
-        for (c, r) in updates {
-            if let Some(cell) = sh.cells.get_mut(c) {
-                cell.value = gridcraft_core::Value::Number(r);
-                if !structural {
-                    changed.push((si, c));
-                }
-            }
-        }
-    }
-}
-
-/// Whether any row or column style in `lo..=hi` differs between two sheets' line maps.
-fn line_styles_differ(
-    before: &std::collections::BTreeMap<u32, gridcraft_model::LineInfo>,
-    after: &std::collections::BTreeMap<u32, gridcraft_model::LineInfo>,
-    lo: u32,
-    hi: u32,
-) -> bool {
-    let style = |m: &std::collections::BTreeMap<u32, gridcraft_model::LineInfo>, k: u32| m.get(&k).and_then(|l| l.style);
-    after.range(lo..=hi).any(|(k, l)| l.style != style(before, *k)) || before.range(lo..=hi).any(|(k, l)| l.style != style(after, *k))
-}
-
-/// Turning "Set precision as displayed" on rounds every number constant in the workbook to its
-/// format, permanently (Excel warns "Data will permanently lose accuracy"). Formulas are rounded
-/// by the recalculation that follows.
-pub(crate) fn round_all_constants_as_displayed(wb: &mut Workbook) {
-    let mut prec = gridcraft_calc::DisplayedPrecision::new();
-    for si in 0..wb.sheets.len() {
-        let Some(sh) = wb.sheets.get(si) else { continue };
-        let updates = displayed_updates(&mut prec, wb, si, sh.cells.iter().map(|(c, _)| c));
-        if updates.is_empty() {
-            continue;
-        }
-        let Some(sh) = wb.sheet_mut(si) else { continue };
-        for (c, r) in updates {
-            if let Some(cell) = sh.cells.get_mut(c) {
-                cell.value = gridcraft_core::Value::Number(r);
-            }
-        }
-    }
-}
-
-/// The constants among `cells` on sheet `si` whose value the option changes, with their rounded
-/// values. A locked constant on a protected sheet keeps its value: protection keeps its content,
-/// and rounding it by its format would change the content that the sheet protects.
-fn displayed_updates(
-    prec: &mut gridcraft_calc::DisplayedPrecision,
-    wb: &Workbook,
-    si: usize,
-    cells: impl Iterator<Item = CellRef>,
-) -> Vec<(CellRef, f64)> {
-    let Some(sh) = wb.sheet(si) else { return Vec::new() };
-    cells
-        .filter(|&c| !(sh.is_protected() && wb.styles.get(sh.style_id(c)).protection.locked))
-        .filter_map(|c| {
-            let cell = sh.cell(c)?;
-            match cell.value {
-                gridcraft_core::Value::Number(n) if cell.formula.is_none() => {
-                    let r = prec.round(wb, si, c, n);
-                    (r.to_bits() != n.to_bits()).then_some((c, r))
-                }
-                _ => None,
-            }
-        })
-        .collect()
-}
 /// The most cells a dry run's touch log keeps; a footprint whose log is full may be missing writes
 /// that kept a cell's value, so a shift is refused then.
 pub(crate) const TOUCH_LOG_LIMIT: usize = 1_000_000;

crates/engine/src/cmd/controls.rs

@@ -1,711 +0,0 @@
-//! Form controls (Insert › Controls): buttons that run a macro or a command, and sliders and spin
-//! buttons that hold a whole number from 0 to 30000 and write it to a linked cell.
-//!
-//! A slider or spin button's value lives on the control and in its linked cell. Setting it goes
-//! through `cell.set`, so the cell's dependents recalculate and Undo takes both back as one step;
-//! editing the linked cell moves the control (see [`sync_linked_values`]). Pressing a button runs
-//! its action through the macro policy with the document's trust, so a button from a file someone
-//! else made asks before it runs anything.
-
-use gridcraft_core::CellRef;
-use gridcraft_model::{
-    Anchor, AnchorMode, CONTROL_MAX, ControlAction, ControlKind, FormControl, MAX_MACRO_NAME, MacroInput, ObjKind, Sheet, Workbook,
-};
-use serde_json::{Value as Json, json};
-
-use super::{
-    CommandSpec, EngineError, PROTECTED, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, find_command,
-    has_doc, split_sheet, stash, str_param, u32_param,
-};
-use crate::macros::policy::{Policy, macro_policy};
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        cmd!(
-            "insert.button",
-            "Button",
-            ["Insert", "Controls"],
-            None,
-            "{at?: \"B2\" (or cell), dx?, dy?, width?, height?, text?, macro?: name, input?: \"selection\" | \"B2:D9\", output?: \"F2\", command?: id, params?: {..}} places a button; pressing it runs the macro or the command → {control: id}",
-            has_doc,
-            insert_button
-        ),
-        cmd!(
-            "insert.slider",
-            "Slider",
-            ["Insert", "Controls"],
-            None,
-            "{at?: \"B2\" (or cell), dx?, dy?, width?, height?, link?: \"$B$1\" | \"Sheet2!$B$1\", min?: 0, max?: 100, step?: 1, page?: 10, value?, horizontal?: true} whole numbers, 0 ≤ min < max ≤ 30000, 1 ≤ step ≤ max − min, page ≥ step → {control: id}",
-            has_doc,
-            |s, p| insert_number_control(s, p, ControlKind::Slider)
-        ),
-        cmd!(
-            "insert.spinButton",
-            "Spin Button",
-            ["Insert", "Controls"],
-            None,
-            "{at?: \"B2\" (or cell), dx?, dy?, width?, height?, link?: \"$B$1\", min?: 0, max?: 100, step?: 1, value?} whole numbers, 0 ≤ min < max ≤ 30000, 1 ≤ step ≤ max − min → {control: id}",
-            has_doc,
-            |s, p| insert_number_control(s, p, ControlKind::Spin)
-        ),
-        cmd!(
-            "control.format",
-            "Format Control",
-            [],
-            None,
-            "{id, text?, name?, link?: \"$B$1\" | \"\" (no link), min?, max?, step?, page?, value?, horizontal?, print?, locked?} → the control (as control.list)",
-            has_doc,
-            format
-        ),
-        cmd!(
-            "control.assign",
-            "Assign Action",
-            [],
-            None,
-            "{id, macro?: name, input?: \"selection\" | \"B2:D9\", output?: \"F2\" | command?: id, params?: {..} | clear?: true} sets what a button runs → the control",
-            has_doc,
-            assign
-        ),
-        cmd!(
-            "control.setValue",
-            "Change Control Value",
-            [],
-            None,
-            "{id, value} clamps the value to min..max, snaps it to the step, and writes it to the linked cell → {value}",
-            has_doc,
-            set_value
-        ),
-        cmd!(
-            "control.press",
-            "Press Button",
-            [],
-            None,
-            "{id, approve?: bool, onConflict?, overwrite?} runs a button's macro or command (through the macro policy, with the workbook's trust; a workbook from a file asks first) → what the macro or command returned",
-            has_doc,
-            press
-        ),
-        cmd!(query "control.list", "Form Controls", [], None, "{} → the active sheet's controls: [{id, kind, name, text, at, link?, value, min, max, step, page, horizontal, action?}]", has_doc, list),
-    ]
-}
-
-/// The longest caption or name a control takes.
-const MAX_TEXT: usize = 1_024;
-
-fn control_json(c: &FormControl) -> Json {
-    let mut o = json!({
-        "id": c.id,
-        "kind": match c.kind { ControlKind::Button => "button", ControlKind::Slider => "slider", ControlKind::Spin => "spinButton" },
-        "name": c.display_name(),
-        "at": c.anchor.cell.a1(),
-        "width": c.anchor.width,
-        "height": c.anchor.height,
-        "print": c.print,
-        "locked": c.locked,
-    });
-    if c.kind == ControlKind::Button {
-        o["text"] = json!(c.text);
-        if let Some(a) = &c.action {
-            o["action"] = serde_json::to_value(a).unwrap_or(Json::Null);
-        }
-    } else {
-        o["value"] = json!(c.value);
-        o["min"] = json!(c.min);
-        o["max"] = json!(c.max);
-        o["step"] = json!(c.step);
-        if c.kind == ControlKind::Slider {
-            o["page"] = json!(c.page);
-            o["horizontal"] = json!(c.horizontal);
-        }
-    }
-    if let Some(l) = &c.link {
-        o["link"] = json!(l);
-    }
-    o
-}
-
-fn list(s: &mut Session, _: &Json) -> Result<Json> {
-    let sh = s.doc()?.wb.active().ok_or(EngineError::NoDocument)?;
-    Ok(Json::Array(sh.controls.iter().map(control_json).collect()))
-}
-
-/// A whole number from 0 to 30000 named `key`, if given. Numbers in text (`"12"`) count; anything
-/// else is refused with a message that names the parameter.
-fn whole(cmd: &str, p: &Json, key: &str) -> Result<Option<u32>> {
-    let v = match p.get(key) {
-        None | Some(Json::Null) => return Ok(None),
-        Some(Json::Number(n)) => n.as_f64(),
-        Some(Json::String(t)) => t.trim().parse::<f64>().ok(),
-        Some(_) => None,
-    };
-    match v {
-        Some(x) if x.is_finite() && x.fract() == 0.0 && (0.0..=CONTROL_MAX as f64).contains(&x) => Ok(Some(x as u32)),
-        _ => Err(bad(cmd, format!("`{key}` must be a whole number from 0 to {CONTROL_MAX}"))),
-    }
-}
-
-fn text_param(cmd: &str, p: &Json, key: &str) -> Result<Option<String>> {
-    match p.get(key) {
-        None | Some(Json::Null) => Ok(None),
-        Some(Json::String(t)) if t.chars().count() <= MAX_TEXT => Ok(Some(t.clone())),
-        Some(Json::String(_)) => Err(bad(cmd, format!("`{key}` is longer than {MAX_TEXT} characters"))),
-        Some(_) => Err(bad(cmd, format!("`{key}` must be text"))),
-    }
-}
-
-/// The cell a link names, from the control's sheet `host`: `(sheet index, cell)`. `None` when it
-/// doesn't name one cell of an existing sheet (a link into a deleted sheet reads `#REF!`).
-pub fn link_target(wb: &Workbook, host: usize, link: &str) -> Option<(usize, CellRef)> {
-    let text = link.trim().trim_start_matches('=');
-    let (sheet, body) = split_sheet(text);
-    let si = match sheet {
-        Some(n) => wb.sheet_index(&n)?,
-        None => host,
-    };
-    wb.sheet(si)?;
-    Some((si, CellRef::parse(body.trim())?))
-}
-
-/// A link parameter in its stored form: `$B$2` on the host sheet, `'My Sheet'!$B$2` elsewhere.
-/// An empty text removes the link.
-fn link_param(cmd: &str, wb: &Workbook, host: usize, p: &Json) -> Result<Option<Option<String>>> {
-    let text = match p.get("link") {
-        None => return Ok(None),
-        Some(Json::Null) => return Ok(Some(None)),
-        Some(Json::String(t)) => t.trim(),
-        Some(_) => return Err(bad(cmd, "`link` must be a cell reference such as $B$1")),
-    };
-    if text.is_empty() {
-        return Ok(Some(None));
-    }
-    let (si, c) = link_target(wb, host, text)
-        .ok_or_else(|| bad(cmd, format!("`{text}` isn't a cell of this workbook; the link must be one cell, such as $B$1")))?;
-    let abs = format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row as u64 + 1);
-    Ok(Some(Some(if si == host {
-        abs
-    } else {
-        let name = wb.sheet(si).map(|sh| sh.name.clone()).unwrap_or_default();
-        format!("{}!{abs}", gridcraft_formula::quote_sheet(&name))
-    })))
-}
-
-/// The anchor of a new control: `at` or `cell` (default the active cell), with its size.
-fn new_anchor(s: &Session, p: &Json, size: (f32, f32)) -> Result<Anchor> {
-    let cell = match cell_param(s, p, "at")? {
-        Some(c) => c,
-        None => cell_param(s, p, "cell")?.unwrap_or(s.doc()?.selection.active),
-    };
-    let dim = |k: &str, v: f32| f64_param(p, k).filter(|x| x.is_finite()).map_or(v, |x| x.clamp(4.0, 10_000.0) as f32);
-    let off = |k: &str| f64_param(p, k).filter(|x| x.is_finite()).map_or(0.0, |x| x.clamp(-10_000.0, 10_000.0) as f32);
-    Ok(Anchor {
-        cell,
-        dx: off("dx"),
-        dy: off("dy"),
-        width: dim("width", size.0),
-        height: dim("height", size.1),
-        mode: anchor_mode_param(p).unwrap_or(AnchorMode::MoveOnly),
-    })
-}
-
-fn insert_button(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "insert.button";
-    let anchor = new_anchor(s, p, (96.0, 28.0))?;
-    let action = action_param(s, CMD, p)?;
-    let d = s.doc()?;
-    let id = d.wb.next_object_id();
-    let text = text_param(CMD, p, "text")?.unwrap_or_else(|| format!("Button {id}"));
-    let sheet = d.wb.active_sheet();
-    let control = FormControl { id, kind: ControlKind::Button, anchor, text, action, ..FormControl::default() };
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.controls.push(control);
-        Ok(json!({"control": id}))
-    })
-}
-
-fn insert_number_control(s: &mut Session, p: &Json, kind: ControlKind) -> Result<Json> {
-    let cmd = if kind == ControlKind::Slider { "insert.slider" } else { "insert.spinButton" };
-    let horizontal = bool_param(p, "horizontal").unwrap_or(true);
-    let size = match kind {
-        ControlKind::Slider if horizontal => (144.0, 18.0),
-        ControlKind::Slider => (18.0, 144.0),
-        _ => (18.0, 36.0),
-    };
-    let anchor = new_anchor(s, p, size)?;
-    let d = s.doc()?;
-    let sheet = d.wb.active_sheet();
-    let id = d.wb.next_object_id();
-    let mut c = FormControl { id, kind, anchor, horizontal, ..FormControl::default() };
-    numbers(cmd, p, &mut c)?;
-    if let Some(link) = link_param(cmd, &d.wb, sheet, p)? {
-        c.link = link;
-    }
-    let given = whole(cmd, p, "value")?;
-    // Without a value, a control starts at the number its linked cell holds (or its minimum).
-    let start = given.map(f64::from).or_else(|| linked_number(&d.wb, sheet, &c)).unwrap_or(c.min as f64);
-    c.value = c.snap(start);
-    let value = c.value;
-    let link = c.link.clone();
-    s.grouped(&format!("Insert {}", kind.label()), |s| {
-        edit(s, |cx| {
-            cx.sheet_mut(sheet)?.controls.push(c);
-            Ok(())
-        })?;
-        if given.is_some() {
-            write_link(s, sheet, link.as_deref(), value)?;
-        }
-        Ok(json!({"control": id}))
-    })
-}
-
-/// Applies `min`, `max`, `step`, `page` and `value` from `p` to `c` and checks the result.
-fn numbers(cmd: &str, p: &Json, c: &mut FormControl) -> Result<()> {
-    for (key, slot) in [("min", &mut c.min), ("max", &mut c.max), ("step", &mut c.step), ("page", &mut c.page)] {
-        if let Some(v) = whole(cmd, p, key)? {
-            *slot = v;
-        }
-    }
-    // A new slider's page follows a larger step unless it was given.
-    if p.get("page").is_none() && c.page < c.step {
-        c.page = c.step;
-    }
-    c.check_numbers().map_err(|e| bad(cmd, e))
-}
-
-/// The number the control's linked cell holds, if it holds one.
-fn linked_number(wb: &Workbook, host: usize, c: &FormControl) -> Option<f64> {
-    let (si, cell) = link_target(wb, host, c.link.as_deref()?)?;
-    wb.sheet(si)?.cell(cell)?.value.as_f64()
-}
-
-/// Writes `value` to the linked cell through `cell.set` (nothing without a link, or when the cell
-/// already shows `value`, formula or not: Format Control's OK sends the value back every time, and
-/// a write that changes nothing must not turn a formula into a constant or fail on a locked cell
-/// of a protected sheet; a real change replaces a formula with the constant, as in Excel).
-fn write_link(s: &mut Session, host: usize, link: Option<&str>, value: u32) -> Result<()> {
-    let Some(link) = link else { return Ok(()) };
-    let Some((si, cell)) = link_target(&s.doc()?.wb, host, link) else { return Ok(()) };
-    let holds = s.doc()?.wb.sheet(si).and_then(|sh| sh.cell(cell)).and_then(|c| c.value.as_f64());
-    if holds == Some(value as f64) {
-        return Ok(());
-    }
-    s.execute("cell.set", json!({"sheet": si, "cell": cell.a1(), "input": value.to_string()}))?;
-    Ok(())
-}
-
-/// The control `id` names on the active sheet: (sheet, its index in `controls`, a copy).
-fn find(s: &Session, cmd: &str, p: &Json) -> Result<(usize, usize, FormControl)> {
-    let id = u32_param(p, "id").ok_or_else(|| bad(cmd, "missing `id` (a control id from control.list)"))?;
-    let d = s.doc()?;
-    let sheet = d.wb.active_sheet();
-    let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?;
-    let i = sh.controls.iter().position(|c| c.id == id).ok_or_else(|| bad(cmd, format!("there is no control {id} on this sheet")))?;
-    let c = sh.controls.get(i).cloned().ok_or_else(|| bad(cmd, "no such control"))?;
-    Ok((sheet, i, c))
-}
-
-/// Drawing objects on a protected sheet can't be changed while they are locked.
-/// For the object commands (`object.move`, `object.delete`, `object.setAnchorMode`, `arrange.*`,
-/// `arrange.align`): refuses to change form controls `ids` on `sheet` when one is locked and the
-/// sheet is protected, as `control.format` and `control.assign` do. Other kinds pass.
-pub(crate) fn check_objects_unlocked(s: &Session, sheet: usize, kind: ObjKind, ids: &[u32]) -> Result<()> {
-    if kind != ObjKind::Control {
-        return Ok(());
-    }
-    let Some(sh) = s.doc()?.wb.sheet(sheet) else { return Ok(()) };
-    if sh.is_protected() && sh.controls.iter().any(|c| c.locked && ids.contains(&c.id)) {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
-    Ok(())
-}
-
-fn check_unlocked(s: &Session, sheet: usize, c: &FormControl) -> Result<()> {
-    if c.locked && s.doc()?.wb.sheet(sheet).is_some_and(Sheet::is_protected) {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
-    Ok(())
-}
-
-fn format(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "control.format";
-    let (sheet, i, mut c) = find(s, CMD, p)?;
-    check_unlocked(s, sheet, &c)?;
-    if let Some(t) = text_param(CMD, p, "text")? {
-        c.text = t;
-    }
-    if let Some(n) = text_param(CMD, p, "name")? {
-        c.name = n.trim().to_string();
-    }
-    for (key, slot) in [("print", &mut c.print), ("locked", &mut c.locked), ("horizontal", &mut c.horizontal)] {
-        if let Some(v) = bool_param(p, key) {
-            *slot = v;
-        }
-    }
-    let mut given = None;
-    if c.kind != ControlKind::Button {
-        for (key, slot) in [("min", &mut c.min), ("max", &mut c.max), ("step", &mut c.step), ("page", &mut c.page)] {
-            if let Some(v) = whole(CMD, p, key)? {
-                *slot = v;
-            }
-        }
-        c.check_numbers().map_err(|e| bad(CMD, e))?;
-        given = whole(CMD, p, "value")?;
-    }
-    if let Some(link) = link_param(CMD, &s.doc()?.wb, sheet, p)? {
-        c.link = link;
-    }
-    // New bounds pull the value in; a given value is snapped to them.
-    c.value = c.snap(given.map_or(c.value as f64, f64::from));
-    let number = c.kind != ControlKind::Button;
-    let write = number && (given.is_some() || p.get("min").is_some() || p.get("max").is_some() || p.get("step").is_some());
-    let (value, link) = (c.value, c.link.clone());
-    s.grouped("Format Control", |s| {
-        edit(s, |cx| {
-            if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) {
-                *slot = c;
-            }
-            Ok(())
-        })?;
-        if write {
-            write_link(s, sheet, link.as_deref(), value)?;
-        }
-        Ok(())
-    })?;
-    // The reply is the control as committed: a new link to a cell holding another number has
-    // moved its value there.
-    let (_, _, c) = find(s, CMD, p)?;
-    Ok(control_json(&c))
-}
-
-/// Commands a button never runs, beyond the macro policy's lists: a button has no way to show
-/// what its command would open, so a web page is refused when the action is assigned or comes in
-/// from a file. A command that turns out to open a page or a dialog when it runs is refused
-/// then, by [`press`].
-const BUTTON_DENIED: &[(&str, &str)] = &[("link.open", "buttons don't open web pages")];
-
-/// The macro policy for a button's command, with the button's own refusals first.
-fn button_policy(id: &str, params: &Json, trust: crate::Trust) -> Policy {
-    match BUTTON_DENIED.iter().find(|(d, _)| *d == id) {
-        Some((_, why)) => Policy::Deny((*why).into()),
-        None => macro_policy(id, params, trust),
-    }
-}
-
-/// Drops the UI requests a button's command queued from `queued` on, keeping messages for the
-/// person, and says why the press is refused when one would open a dialog or a web page, which
-/// buttons don't do (`name` is the button's). A cell edit the command asked for is dropped too.
-pub(crate) fn take_requests(s: &mut Session, queued: usize, name: &str) -> Option<String> {
-    use crate::UiRequest;
-    let mut blocked = None;
-    let asked: Vec<UiRequest> = s.ui_requests.drain(queued.min(s.ui_requests.len())..).collect();
-    for q in asked {
-        match q {
-            UiRequest::Dialog(d, _) => blocked = Some(format!("'{name}' would open the {d} dialog; give its command the parameters it needs.")),
-            UiRequest::OpenUrl(_) => blocked = Some(format!("'{name}' would open a web page, which buttons don't do.")),
-            UiRequest::EditCell(_) | UiRequest::InsertName(_) => {}
-            m @ UiRequest::Message(_) => s.ui_requests.push(m),
-        }
-    }
-    blocked
-}
-
-/// The stored name of the workbook's macro `name` when it exists and declares no inputs: a fixed
-/// input range would make every press fail (`macro.run` refuses inputs it doesn't take), so such
-/// an assignment is refused when it is made and dropped to the selection when a file brings one
-/// in. A macro the workbook doesn't have (yet) is not checked: the assignment is kept as given.
-fn takes_no_inputs(wb: &Workbook, name: &str) -> Option<String> {
-    crate::macros::find(wb, name).and_then(|i| wb.macros.get(i)).filter(|m| m.inputs.is_empty()).map(|m| m.name.clone())
-}
-
-/// A button action from `macro` (with `input` and `output`) or `command` (with `params`).
-fn action_param(s: &Session, cmd: &str, p: &Json) -> Result<Option<ControlAction>> {
-    if let Some(name) = str_param(p, "macro").map(str::trim).filter(|n| !n.is_empty()) {
-        if name.chars().count() > MAX_MACRO_NAME {
-            return Err(bad(cmd, "`macro` is not a macro name"));
-        }
-        let input = match str_param(p, "input").map(str::trim) {
-            None | Some("") => MacroInput::Selection,
-            Some(t) if t.eq_ignore_ascii_case("selection") => MacroInput::Selection,
-            Some(t) => {
-                let (_, body) = split_sheet(t);
-                if gridcraft_core::RangeRef::parse(body).is_none() {
-                    return Err(bad(cmd, format!("`input` must be \"selection\" or a range such as B2:D9, not `{t}`")));
-                }
-                if let Some(stored) = takes_no_inputs(&s.doc()?.wb, name) {
-                    return Err(bad(cmd, format!("macro '{stored}' takes no inputs, so `input` must be \"selection\"")));
-                }
-                MacroInput::Fixed(t.to_string())
-            }
-        };
-        let output = str_param(p, "output").map(str::trim).filter(|o| !o.is_empty()).map(str::to_string);
-        if let Some(o) = &output
-            && gridcraft_core::RangeRef::parse(split_sheet(o).1).is_none()
-        {
-            return Err(bad(cmd, format!("`output` must be a cell such as F2, not `{o}`")));
-        }
-        return Ok(Some(ControlAction::Macro { name: name.to_string(), input, output }));
-    }
-    if let Some(id) = str_param(p, "command").map(str::trim).filter(|n| !n.is_empty()) {
-        if find_command(id).is_none() {
-            return Err(bad(cmd, format!("there is no command `{id}`")));
-        }
-        let params = p.get("params").cloned().unwrap_or_else(|| json!({}));
-        if !params.is_object() {
-            return Err(bad(cmd, "`params` must be an object"));
-        }
-        let trust = s.doc()?.trust;
-        if let Policy::Deny(why) = button_policy(id, &params, trust) {
-            return Err(EngineError::Other(format!("A button can't run {id}: {why}.")));
-        }
-        return Ok(Some(ControlAction::Command { id: id.to_string(), params }));
-    }
-    Ok(None)
-}
-
-fn assign(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "control.assign";
-    let (sheet, i, mut c) = find(s, CMD, p)?;
-    check_unlocked(s, sheet, &c)?;
-    if c.kind != ControlKind::Button {
-        return Err(bad(CMD, "only buttons run actions; a slider or spin button writes its value to its linked cell"));
-    }
-    let action = action_param(s, CMD, p)?;
-    if action.is_none() && bool_param(p, "clear") != Some(true) {
-        return Err(bad(CMD, "pass `macro` or `command` (or `clear: true` to remove the action)"));
-    }
-    c.action = action;
-    let out = control_json(&c);
-    edit(s, |cx| {
-        if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) {
-            *slot = c;
-        }
-        Ok(out)
-    })
-}
-
-fn set_value(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "control.setValue";
-    let (sheet, i, c) = find(s, CMD, p)?;
-    if c.kind == ControlKind::Button {
-        return Err(bad(CMD, "a button has no value; use control.press"));
-    }
-    let v = match p.get("value") {
-        Some(Json::Number(n)) => n.as_f64(),
-        Some(Json::String(t)) => t.trim().parse::<f64>().ok(),
-        _ => None,
-    }
-    .filter(|v| v.is_finite())
-    .ok_or_else(|| bad(CMD, "`value` must be a number"))?;
-    let value = c.snap(v);
-    let label = format!("Change {}", c.kind.label());
-    s.grouped(&label, |s| {
-        if c.value != value {
-            edit(s, |cx| {
-                if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) {
-                    slot.value = value;
-                }
-                Ok(())
-            })?;
-        }
-        write_link(s, sheet, c.link.as_deref(), value)?;
-        Ok(json!({"value": value}))
-    })
-}
-
-fn press(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "control.press";
-    let (_, _, c) = find(s, CMD, p)?;
-    if c.kind != ControlKind::Button {
-        return Err(bad(CMD, "only buttons can be pressed; use control.setValue for a slider or spin button"));
-    }
-    let name = c.display_name();
-    match c.action {
-        None => Err(EngineError::Other(format!("'{name}' has no action. Right-click it and choose Assign Action."))),
-        Some(ControlAction::Macro { name: mac, input, output }) => {
-            let mut params = json!({"name": mac});
-            if let MacroInput::Fixed(r) = input {
-                params["inputs"] = json!(r);
-            }
-            if let Some(o) = output {
-                params["output"] = json!(o);
-            }
-            for key in ["approve", "onConflict", "overwrite", "timeLimit"] {
-                if let Some(v) = p.get(key) {
-                    params[key] = v.clone();
-                }
-            }
-            // The macro runner gates every step with the document's trust.
-            crate::macros::run::run(s, &mac, &params)
-        }
-        Some(ControlAction::Command { id, params }) => {
-            let d = s.doc()?;
-            let (doc, trust) = (d.uid, d.trust);
-            let policy = button_policy(&id, &params, trust);
-            let file_command = matches!(policy, Policy::NeedsPermission(_));
-            let why = match policy {
-                Policy::Allow => None,
-                Policy::Ask(why) | Policy::NeedsPermission(why) => Some(why),
-                Policy::Deny(why) => return Err(EngineError::Other(format!("'{name}' can't run {id}: {why}."))),
-            };
-            if let Some(why) = why {
-                let key = (doc, approval_key(&id, &params));
-                if !s.macro_approvals.contains(&key) {
-                    if bool_param(p, "approve") != Some(true) {
-                        return Err(EngineError::Approve(format!("Run {id} from '{name}'? It {why}{}.", path_note(&params))));
-                    }
-                    s.macro_approvals.insert(key);
-                }
-            }
-            // As a macro step: only an approved file command reaches the file system, so a
-            // command that reads or writes a file under another parameter name can't.
-            let _sandbox = (!file_command).then(crate::io::ScriptSandbox::enter);
-            s.grouped(&name, |s| {
-                let queued = s.ui_requests.len();
-                let r = s.execute(&id, params.clone());
-                // As a macro step: a command that would open a dialog or a web page is refused
-                // and its group rolled back; messages for the person stay queued.
-                let blocked = take_requests(s, queued, &name);
-                let r = r?;
-                match blocked {
-                    Some(why) => Err(EngineError::Other(why)),
-                    None => Ok(r),
-                }
-            })
-        }
-    }
-}
-
-/// The file a button's command names in its `path`, as ` (path)` for its approval question, so
-/// the person sees what it reads or writes before saying yes. Empty without a `path`; a long one
-/// is shortened in the middle.
-fn path_note(params: &Json) -> String {
-    let text = match params.get("path") {
-        None | Some(Json::Null) => return String::new(),
-        Some(Json::String(t)) => t.clone(),
-        Some(other) => other.to_string(),
-    };
-    let text: String = text.chars().map(|c| if c.is_control() { ' ' } else { c }).collect();
-    let n = text.chars().count();
-    let shown = if n > 200 {
-        let head: String = text.chars().take(100).collect();
-        let tail: String = text.chars().skip(n - 99).collect();
-        format!("{head}…{tail}")
-    } else {
-        text
-    };
-    format!(" ({shown})")
-}
-
-/// The approval key of a button's command: its id and parameters, with a prefix that keeps it
-/// apart from a macro's fingerprint (canonical JSON, which starts with `{`).
-fn approval_key(id: &str, params: &Json) -> String {
-    format!("control-command\u{0}{id}\u{0}{params}")
-}
-
-/// After an edit: each slider and spin button whose linked cell holds a number takes that number
-/// (clamped and snapped), so editing the cell moves the control. Sheets without such a control
-/// are left untouched.
-pub(crate) fn sync_linked_values(wb: &mut Workbook) {
-    for si in 0..wb.sheets.len() {
-        let updates: Vec<(usize, u32)> = match wb.sheet(si) {
-            Some(sh) if sh.controls.iter().any(|c| c.link.is_some()) => sh
-                .controls
-                .iter()
-                .enumerate()
-                .filter(|(_, c)| c.kind != ControlKind::Button)
-                .filter_map(|(i, c)| linked_number(wb, si, c).map(|n| (i, c.snap(n))).filter(|(_, v)| *v != c.value))
-                .collect(),
-            _ => continue,
-        };
-        if updates.is_empty() {
-            continue;
-        }
-        if let Some(sh) = wb.sheet_mut(si) {
-            for (i, v) in updates {
-                if let Some(c) = sh.controls.get_mut(i) {
-                    c.value = v;
-                }
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------- xlsx
-
-/// The hidden-data key of the button actions xlsx has no place for.
-pub(crate) const ACTIONS_KEY: &str = "control_actions";
-
-/// A button's action that xlsx carries itself: a macro on the selection (`macro="[0]!Name"`).
-fn plain(a: &ControlAction) -> bool {
-    matches!(a, ControlAction::Macro { input: MacroInput::Selection, output: None, .. })
-}
-
-/// A copy of `wb` for xlsx with the button actions xlsx can't express (commands, fixed inputs,
-/// output cells) in a hidden name, keyed by sheet name and the control's place on the sheet, with
-/// the button's name and anchor cell to check it is still the same button when the file comes
-/// back. `None` when there is nothing to store.
-pub(crate) fn with_action_names(wb: &Workbook) -> Result<Option<Workbook>> {
-    let mut items = Vec::new();
-    for sh in &wb.sheets {
-        for (i, c) in sh.controls.iter().enumerate() {
-            if let Some(a) = c.action.as_ref().filter(|a| !plain(a)) {
-                items.push(json!({"sheet": sh.name, "index": i, "name": c.display_name(), "at": c.anchor.cell.a1(), "action": a}));
-            }
-        }
-    }
-    let stale = stash::get(wb, ACTIONS_KEY).is_some();
-    if items.is_empty() && !stale {
-        return Ok(None);
-    }
-    let mut out = wb.clone();
-    stash::remove(&mut out, ACTIONS_KEY);
-    if !items.is_empty() {
-        stash::set_json(&mut out, ACTIONS_KEY, &Json::Array(items))?;
-    }
-    Ok(Some(out))
-}
-
-/// After a file is opened: gives buttons back the actions kept in the hidden name, and removes
-/// it. Entries that don't parse, or don't match a button, are dropped: an entry must carry the
-/// button's name and anchor cell, the button at the stored place must have that name and anchor
-/// cell (another application may have added, removed or reordered controls), and it must not
-/// have been given another macro since (a stored macro action comes back only on a button that
-/// still runs that macro, a stored command only on one the file gives no macro). A stored fixed
-/// input for a macro that takes no inputs becomes the selection (see [`takes_no_inputs`]).
-pub(crate) fn load_action_names(wb: &mut Workbook) {
-    let Some(items) = stash::get_json(wb, ACTIONS_KEY) else { return };
-    stash::remove(wb, ACTIONS_KEY);
-    for item in items.as_array().into_iter().flatten().take(100_000) {
-        let (Some(sheet), Some(index)) = (item.get("sheet").and_then(Json::as_str), item.get("index").and_then(Json::as_u64)) else { continue };
-        let Ok(action) = serde_json::from_value::<ControlAction>(item.get("action").cloned().unwrap_or(Json::Null)) else { continue };
-        let valid = match &action {
-            ControlAction::Macro { name, .. } => !name.trim().is_empty() && name.chars().count() <= MAX_MACRO_NAME,
-            ControlAction::Command { id, params } => !id.is_empty() && id.len() <= 200 && params.is_object(),
-        };
-        let Some(si) = wb.sheet_index(sheet) else { continue };
-        let Ok(index) = usize::try_from(index) else { continue };
-        let text = |k: &str| item.get(k).and_then(Json::as_str);
-        let same = |c: &FormControl| {
-            c.kind == ControlKind::Button
-                && text("name").is_some_and(|n| n == c.display_name())
-                && text("at").is_some_and(|a| a == c.anchor.cell.a1())
-                && match (&c.action, &action) {
-                    (None, ControlAction::Command { .. }) => true,
-                    (Some(ControlAction::Macro { name: now, .. }), ControlAction::Macro { name: kept, .. }) => now.eq_ignore_ascii_case(kept),
-                    _ => false,
-                }
-        };
-        if !valid || !wb.sheet(si).is_some_and(|sh| sh.controls.get(index).is_some_and(same)) {
-            continue;
-        }
-        let action = match action {
-            // The macro takes no inputs now: the stored range would fail every press, so the
-            // button runs the macro on the selection, as the file itself assigns it.
-            ControlAction::Macro { name, input: MacroInput::Fixed(_), output } if takes_no_inputs(wb, &name).is_some() => {
-                ControlAction::Macro { name, input: MacroInput::Selection, output }
-            }
-            other => other,
-        };
-        if let Some(c) = wb.sheet_mut(si).and_then(|sh| sh.controls.get_mut(index)) {
-            c.action = Some(action);
-        }
-    }
-}

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

@@ -18,71 +18,21 @@ fn op_param(s: Option<&str>) -> CfOperator {
     }
 }
 
-/// Removes a set of cuts from one validation range in a row sweep, updating the result once
-/// instead of fragmenting it again for every cut.
-fn subtract_ranges(r: RangeRef, cuts: &[RangeRef]) -> Vec<RangeRef> {
-    let mut events = std::collections::BTreeMap::<u64, Vec<((u32, u32), bool)>>::new();
-    for cut in cuts {
-        let Some(i) = r.intersection(cut) else { continue };
-        let columns = (i.start.col, i.end.col);
-        events.entry(u64::from(i.start.row)).or_default().push((columns, true));
-        events.entry(u64::from(i.end.row) + 1).or_default().push((columns, false));
+/// `r` minus `cut`, as up to four non-overlapping rectangles.
+fn subtract_range(r: RangeRef, cut: &RangeRef) -> Vec<RangeRef> {
+    let Some(i) = r.intersection(cut) else { return vec![r] };
+    let mut out = Vec::new();
+    if i.start.row > r.start.row {
+        out.push(RangeRef::new(r.start, CellRef::new(i.start.row - 1, r.end.col)));
     }
-    if events.is_empty() {
-        return vec![r];
+    if i.end.row < r.end.row {
+        out.push(RangeRef::new(CellRef::new(i.end.row + 1, r.start.col), r.end));
     }
-    events.entry(u64::from(r.end.row) + 1).or_default();
-
-    let mut active = std::collections::BTreeMap::<(u32, u32), usize>::new();
-    let mut out: Vec<RangeRef> = Vec::new();
-    let mut last_by_columns = std::collections::BTreeMap::<(u32, u32), usize>::new();
-    let mut previous_row = u64::from(r.start.row);
-    for (row, changes) in events {
-        if previous_row < row {
-            let start_row = previous_row as u32;
-            let end_row = (row - 1).min(u64::from(r.end.row)) as u32;
-            let mut covered = Vec::<(u32, u32)>::new();
-            for &(start, end) in active.keys() {
-                match covered.last_mut() {
-                    Some(last) if start <= last.1.saturating_add(1) => last.1 = last.1.max(end),
-                    _ => covered.push((start, end)),
-                }
-            }
-            let mut next_col = u64::from(r.start.col);
-            let mut remaining = Vec::new();
-            for (start, end) in covered {
-                if next_col < u64::from(start) {
-                    remaining.push((next_col as u32, start - 1));
-                }
-                next_col = u64::from(end) + 1;
-            }
-            if next_col <= u64::from(r.end.col) {
-                remaining.push((next_col as u32, r.end.col));
-            }
-            for (start_col, end_col) in remaining {
-                let columns = (start_col, end_col);
-                if let Some(&index) = last_by_columns.get(&columns)
-                    && out[index].end.row.saturating_add(1) == start_row
-                {
-                    out[index].end.row = end_row;
-                } else {
-                    let index = out.len();
-                    out.push(RangeRef::new(CellRef::new(start_row, start_col), CellRef::new(end_row, end_col)));
-                    last_by_columns.insert(columns, index);
-                }
-            }
-        }
-        for (columns, add) in changes {
-            if add {
-                *active.entry(columns).or_default() += 1;
-            } else if let Some(count) = active.get_mut(&columns) {
-                *count -= 1;
-                if *count == 0 {
-                    active.remove(&columns);
-                }
-            }
-        }
-        previous_row = row;
+    if i.start.col > r.start.col {
+        out.push(RangeRef::new(CellRef::new(i.start.row, r.start.col), CellRef::new(i.end.row, i.start.col - 1)));
+    }
+    if i.end.col < r.end.col {
+        out.push(RangeRef::new(CellRef::new(i.start.row, i.end.col + 1), CellRef::new(i.end.row, r.end.col)));
     }
     out
 }
@@ -93,7 +43,9 @@ fn subtract_ranges(r: RangeRef, cuts: &[RangeRef]) -> Vec<RangeRef> {
 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);
-        dv.ranges = dv.ranges.iter().flat_map(|r| subtract_ranges(*r, cuts)).collect();
+        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));

crates/engine/src/cmd/edit.rs

@@ -239,12 +239,7 @@ fn redo(s: &mut Session, p: &Json) -> Result<Json> {
 
 /// The rows of `range` an applied filter hides (rows hidden by hand are not among them).
 fn filtered_rows(sh: &gridcraft_model::Sheet, range: RangeRef) -> std::collections::BTreeSet<u32> {
-    let spans = sh.filter_row_spans();
-    if spans.is_empty() {
-        return Default::default();
-    }
-    let filtered = |row: u32| spans.iter().any(|&(first, last)| row >= first && row <= last);
-    sh.rows.range(range.start.row..=range.end.row).filter(|(r, info)| info.hidden && filtered(**r)).map(|(r, _)| *r).collect()
+    sh.rows.range(range.start.row..=range.end.row).filter(|(r, info)| info.hidden && sh.is_row_filtered(**r)).map(|(r, _)| *r).collect()
 }
 
 /// The Clear commands (Delete is Clear Contents). As in Excel, the rows an applied filter hides

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

@@ -328,11 +328,7 @@ pub(super) fn range_fill(s: &mut Session, p: &Json) -> Result<Json> {
             if r.count() > 2_000_000 {
                 return Err(bad("range.fill", "range too large"));
             }
-            let skip = cx.wb.sheet(sheet).map(|sh| super::filtered_rows(sh, *r)).unwrap_or_default();
             for at in r.iter() {
-                if skip.contains(&at.row) {
-                    continue;
-                }
                 let style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
                 let base = match by_style.get(&style) {
                     Some(c) => c.clone(),

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

@@ -1,8 +1,8 @@
 use super::cell::input_to_cell;
 use super::paste_special::paste_special;
 use super::{
-    Cell, CellRef, 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, bad, bool_param, cell_param_on, edit, json, ok, str_param, target_ranges,
+    target_sheet,
 };
 
 // ---------------------------------------------------------------- clipboard
@@ -15,7 +15,7 @@ fn copy_impl(s: &mut Session, p: &Json, cut: bool) -> Result<Json> {
         return Err(multiple());
     }
     // The selection as made (untrimmed), for Insert Copied Cells.
-    let mut selected = ranges.first().copied().unwrap_or_default();
+    let selected = ranges.first().copied().unwrap_or_default();
     let d = s.doc()?;
     let Some(sh) = d.wb.sheet(sheet) else { return Err(EngineError::NoDocument) };
     let trim = |range: RangeRef| {
@@ -31,27 +31,7 @@ fn copy_impl(s: &mut Session, p: &Json, cut: bool) -> Result<Json> {
         let (wb, block) = slide_together(&d.wb, sheet, &areas).ok_or_else(multiple)?;
         (std::sync::Arc::new(wb), block, areas)
     } else {
-        let range = trim(ranges.first().copied().unwrap_or_default());
-        // A copied range with rows a filter hides takes only the rows showing: they are copied
-        // like a multi-area selection stacked top to bottom (formulas as values), as in Excel.
-        // A cut still takes every row.
-        let hidden = if cut { Default::default() } else { super::filtered_rows(sh, range) };
-        let visible = if hidden.is_empty() { Vec::new() } else { visible_row_runs(range, &hidden) };
-        let any_visible = !visible.is_empty();
-        let packed = match visible.as_slice() {
-            [] => (d.wb.clone(), range, Vec::new()),
-            [only] => (d.wb.clone(), *only, Vec::new()),
-            _ => {
-                let (wb, block) = slide_together(&d.wb, sheet, &visible).ok_or_else(multiple)?;
-                (std::sync::Arc::new(wb), block, visible)
-            }
-        };
-        // Whole rows copied with some hidden by a filter come as the block of rows showing, so
-        // Insert Copied Cells makes room for those rows, not for the hidden ones too.
-        if !hidden.is_empty() && any_visible && selected.is_full_rows() {
-            selected = RangeRef::rows(packed.1.start.row, packed.1.end.row);
-        }
-        packed
+        (d.wb.clone(), trim(ranges.first().copied().unwrap_or_default()), Vec::new())
     };
     let text = crate::display::range_text(&wb, sheet, range);
     // The HTML rendering is for the host clipboard (UI); it can reach 4 MB, so agents and
@@ -66,56 +46,6 @@ fn copy_impl(s: &mut Session, p: &Json, cut: bool) -> Result<Json> {
     Ok(result)
 }
 
-/// The runs of consecutive rows of `range` not in `hidden`, as ranges of `range`'s columns.
-fn visible_row_runs(range: RangeRef, hidden: &std::collections::BTreeSet<u32>) -> Vec<RangeRef> {
-    let mut runs = Vec::new();
-    let mut start = None;
-    for row in range.start.row..=range.end.row {
-        match (hidden.contains(&row), start) {
-            (false, None) => start = Some(row),
-            (true, Some(first)) => {
-                runs.push(RangeRef::new(CellRef::new(first, range.start.col), CellRef::new(row - 1, range.end.col)));
-                start = None;
-            }
-            _ => {}
-        }
-    }
-    if let Some(first) = start {
-        runs.push(RangeRef::new(CellRef::new(first, range.start.col), CellRef::new(range.end.row, range.end.col)));
-    }
-    runs
-}
-
-/// The validation rules of `src` cut into the areas of a packed block: one rule per area a rule
-/// touches, over that area's part moved by the area's shift. `sorted` areas run in order.
-fn pack_validations(src: &gridcraft_model::Sheet, sorted: &[RangeRef], shifts: &[(i64, i64)], across: bool) -> Vec<gridcraft_model::Validation> {
-    let key = |c: CellRef| if across { c.col } else { c.row };
-    let mut packed_rules = Vec::new();
-    for dv in &src.validations {
-        let Some(from) = dv.ranges.first().map(|r| r.start) else { continue };
-        // The areas each of the rule's ranges touches lie side by side in the sorted list.
-        let end_key = |a: &RangeRef| if across { a.end.col } else { a.end.row };
-        let mut by_area: std::collections::BTreeMap<usize, Vec<RangeRef>> = Default::default();
-        for r in &dv.ranges {
-            let first = sorted.partition_point(|a| end_key(a) < key(r.start));
-            for (i, a) in sorted.iter().enumerate().skip(first).take_while(|(_, a)| key(a.start) <= end_key(r)) {
-                let (dr, dc) = shifts[i];
-                let moved = r.intersection(a).and_then(|x| Some(RangeRef::new(x.start.offset(dr, dc)?, x.end.offset(dr, dc)?)));
-                by_area.entry(i).or_default().extend(moved);
-            }
-        }
-        for ranges in by_area.into_values() {
-            let Some(to) = ranges.first().map(|r| r.start) else { continue };
-            let mut rule = dv.clone();
-            rule.f1 = super::super::data::move_rule_formula(&dv.f1, from, to);
-            rule.f2 = dv.f2.as_ref().map(|f| super::super::data::move_rule_formula(f, from, to));
-            rule.ranges = ranges;
-            packed_rules.push(rule);
-        }
-    }
-    packed_rules
-}
-
 /// Excel copies a multi-area selection only when the areas line up: all cover the same rows (they
 /// slide together side by side, left to right) or all cover the same columns (stacked, top to
 /// bottom), without overlapping. Returns a copy of the workbook whose sheet holds the areas packed
@@ -150,35 +80,17 @@ fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRe
     dst.spill.retain(|c, _| !block.contains(*c));
     dst.spill_ranges.retain(|c, _| !block.contains(*c));
     dst.comments.retain(|c, _| !block.contains(*c));
-    dst.hyperlinks.retain(|c, _| !block.contains(*c));
-    super::super::data::remove_validation_cells(&mut dst.validations, &[block]);
     dst.merges.retain(|m| !m.intersects(&block));
     if across {
         dst.cols.retain(|c, _| !(block.start.col..=block.end.col).contains(c));
     } else {
         dst.rows.retain(|r, _| !(block.start.row..=block.end.row).contains(r));
     }
-    // Where each area lands: the shift of its cells, and its first row or column in the block.
-    let key = |c: CellRef| if across { c.col } else { c.row };
     let mut next = if across { anchor.col } else { anchor.row };
-    let mut shifts: Vec<(i64, i64)> = Vec::with_capacity(sorted.len());
     for a in &sorted {
-        let to = i64::from(next);
-        shifts.push(if across { (0, to - i64::from(a.start.col)) } else { (to - i64::from(a.start.row), 0) });
-        next = next.saturating_add(if across { a.width() } else { a.height() });
-    }
-    // The areas never overlap and run in order, so the area holding a cell is found by search:
-    // each map below is read once, whatever the number of areas.
-    let area_of = |c: CellRef| -> Option<usize> {
-        let i = sorted.partition_point(|a| key(a.start) <= key(c)).checked_sub(1)?;
-        sorted.get(i)?.contains(c).then_some(i)
-    };
-    let moved = |c: CellRef| -> Option<CellRef> {
-        let (dr, dc) = shifts[area_of(c)?];
-        c.offset(dr, dc)
-    };
-    for (a, &(dr, dc)) in sorted.iter().zip(&shifts) {
-        for (c, _) in src.cells.iter_range(*a) {
+        let (dr, dc) = if across { (0, i64::from(next) - i64::from(a.start.col)) } else { (i64::from(next) - i64::from(a.start.row), 0) };
+        let cells = src.cells.iter_range(*a).map(|(c, _)| c).chain(src.spill.keys().copied().filter(|c| a.contains(*c)));
+        for c in cells {
             let Some(to) = c.offset(dr, dc) else { continue };
             let style = src.cell(c).map(|x| x.style).unwrap_or_default();
             dst.set_cell(to, Cell { value: src.value(c), formula: None, style, py: None });
@@ -186,38 +98,17 @@ fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRe
                 dst.cell_pictures.insert(to, picture.clone());
             }
         }
-    }
-    for c in src.spill.keys().copied() {
-        let Some(to) = moved(c) else { continue };
-        let style = src.cell(c).map(|x| x.style).unwrap_or_default();
-        dst.set_cell(to, Cell { value: src.value(c), formula: None, style, py: None });
-        if let Some(picture) = src.cell_pictures.get(&c) {
-            dst.cell_pictures.insert(to, picture.clone());
+        for (c, comment) in src.comments.iter().filter(|(c, _)| a.contains(**c)) {
+            if let Some(to) = c.offset(dr, dc) {
+                dst.comments.insert(to, comment.clone());
+            }
         }
-    }
-    // Links and validation rules follow their cells too, so a row the filter hides leaves its own
-    // behind.
-    for (c, link) in &src.hyperlinks {
-        if let Some(to) = moved(*c) {
-            dst.hyperlinks.insert(to, link.clone());
+        for m in src.merges.iter().filter(|m| a.contains_range(m)) {
+            if let (Some(s), Some(e)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
+                dst.merges.push(RangeRef::new(s, e));
+            }
         }
-    }
-    let packed_rules = pack_validations(src, &sorted, &shifts, across);
-    for (c, comment) in &src.comments {
-        if let Some(to) = moved(*c) {
-            dst.comments.insert(to, comment.clone());
-        }
-    }
-    for m in &src.merges {
-        let Some(i) = area_of(m.start).filter(|&i| sorted[i].contains_range(m)) else { continue };
-        let (dr, dc) = shifts[i];
-        if let (Some(s), Some(e)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
-            dst.merges.push(RangeRef::new(s, e));
-        }
-    }
-    // Column widths (side by side) or row heights and hidden rows (stacked) follow their cells.
-    let mut next = if across { anchor.col } else { anchor.row };
-    for a in &sorted {
+        // Column widths (side by side) or row heights and hidden rows (stacked) follow their cells.
         if across {
             for (c, info) in src.cols.range(a.start.col..=a.end.col) {
                 dst.cols.insert(next.saturating_add(c.saturating_sub(a.start.col)), *info);
@@ -229,7 +120,6 @@ fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRe
         }
         next = next.saturating_add(if across { a.width() } else { a.height() });
     }
-    dst.validations.extend(packed_rules);
     Some((out, block))
 }
 

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

@@ -31,9 +31,8 @@ pub(super) fn fill_dir(s: &mut Session, p: &Json, dr: i64, dc: i64) -> Result<Js
     } else {
         RangeRef::new(CellRef::new(r.start.row, r.end.col), r.end)
     };
-    let skip = s.doc()?.wb.sheet(sheet).map(|sh| super::filtered_rows(sh, r)).unwrap_or_default();
     edit(s, |cx| {
-        crate::fill::fill_except(cx, sheet, src, r, crate::fill::FillMode::Copy, &skip)?;
+        crate::fill::fill(cx, sheet, src, r, crate::fill::FillMode::Copy)?;
         Ok(Json::Null)
     })
 }

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

@@ -4,7 +4,74 @@ use super::{
     target_sheet,
 };
 
-#[allow(clippy::cognitive_complexity)] // The command applies the selected paste mode in one atomic edit.
+fn tiled_cells(rows: u32, cols: u32, tiles_r: u32, tiles_c: u32) -> impl Iterator<Item = (u32, u32, u32, u32)> + Clone {
+    (0..tiles_r).flat_map(move |tr| (0..tiles_c).flat_map(move |tc| (0..rows).flat_map(move |r| (0..cols).map(move |c| (tr, tc, r, c)))))
+}
+
+fn apply_operation(op: &str, old: &Cell, new: &mut Cell) {
+    let operand = new.value.clone();
+    if let (Ok(x), Ok(y)) = (old.value.to_number(), operand.to_number())
+        && (old.value.is_number() || old.value.is_empty() || old.value.is_text())
+        && (operand.is_number() || operand.is_empty())
+    {
+        new.value = match op {
+            "add" => Value::number(x + y),
+            "subtract" => Value::number(x - y),
+            "multiply" => Value::number(x * y),
+            "divide" if y == 0.0 => Value::Error(gridcraft_core::CellError::Div0),
+            "divide" => Value::number(x / y),
+            _ => operand.clone(),
+        };
+    } else if (old.value.is_text() || old.value.is_error()) && (operand.is_number() || operand.is_empty()) {
+        new.value = old.value.clone();
+    }
+    if let Some(formula) = &old.formula
+        && let Ok(y) = operand.to_number()
+        && (operand.is_number() || operand.is_empty())
+        && let Some(symbol) = operation_symbol(op)
+    {
+        let text = format!("=({}){symbol}{}", formula.text, gridcraft_core::number_to_text(y));
+        new.formula = Some(std::sync::Arc::new(Formula::new(&text)));
+        new.value = Value::Empty;
+    }
+}
+
+fn operation_symbol(op: &str) -> Option<char> {
+    match op {
+        "add" => Some('+'),
+        "subtract" => Some('-'),
+        "multiply" => Some('*'),
+        "divide" => Some('/'),
+        _ => None,
+    }
+}
+
+fn copy_merges(
+    cx: &mut crate::cmd::Ctx,
+    dest_sheet: usize,
+    src_sheet: &gridcraft_model::Sheet,
+    src: RangeRef,
+    at: CellRef,
+    what: What,
+    transpose: bool,
+) -> Result<()> {
+    if !matches!(what, What::All | What::Formats) || transpose {
+        return Ok(());
+    }
+    let merges: Vec<RangeRef> = src_sheet.merges.iter().filter(|merge| src.contains_range(merge)).copied().collect();
+    for merge in merges {
+        let row_offset = at.row as i64 - src.start.row as i64;
+        let col_offset = at.col as i64 - src.start.col as i64;
+        if let (Some(start), Some(end)) = (merge.start.offset(row_offset, col_offset), merge.end.offset(row_offset, col_offset)) {
+            let moved = RangeRef::new(start, end);
+            let sheet = cx.sheet_mut(dest_sheet)?;
+            sheet.merges.retain(|existing| !existing.intersects(&moved));
+            sheet.merges.push(moved);
+        }
+    }
+    Ok(())
+}
+
 pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
     let Some(clip) = s.clipboard.clone() else { return Err(EngineError::Other("Nothing to paste.".into())) };
     let what = match str_param(p, "what").unwrap_or("all") {
@@ -30,11 +97,7 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
     let dest_sheet = target_sheet(s, p)?;
     let sel = s.doc()?.selection.current();
     let at = cell_param_on(s, p, "at", dest_sheet)?.unwrap_or(sel.start);
-    // Whole columns or rows paste whole (the copy keeps only their used part as its text), so
-    // what the destination columns hold further down is replaced too, as in Excel. The cells are
-    // visited sparsely below, so this costs what the columns hold, not 1,048,576 rows.
-    let whole = clip.areas.is_empty() && (clip.selected.is_full_cols() || clip.selected.is_full_rows()) && clip.selected.contains_range(&clip.range);
-    let src = if whole { clip.selected } else { clip.range };
+    let src = clip.range;
     let (h, w) = if transpose { (src.width(), src.height()) } else { (src.height(), src.width()) };
     // Tile the copy over a larger destination that is a multiple of its size.
     let tile = sel.height() % h == 0
@@ -45,31 +108,17 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
         && !sel.is_full_rows()
         && sel.count() <= 4_000_000;
     let (tiles_r, tiles_c) = if tile { (sel.height() / h, sel.width() / w) } else { (1, 1) };
-    // A single cell or row repeated down a filtered selection skips the rows the filter hides; a
-    // taller block is pasted straight down, hidden rows included, as in Excel.
-    let skip_rows = match s.doc()?.wb.sheet(dest_sheet) {
-        Some(sh) if tile && h == 1 => super::filtered_rows(sh, sel),
-        _ => Default::default(),
-    };
-    // Excel refuses a paste that would run off the sheet (whole columns pasted below row 1, whole
-    // rows right of column A, a whole column transposed) instead of pasting part of it.
-    if at.offset(i64::from(tiles_r * h) - 1, i64::from(tiles_c * w) - 1).is_none() {
-        return Err(EngineError::Other("The copied cells don't fit here: paste them where the whole copied area fits on the sheet.".into()));
-    }
-    // Paste Link writes a formula into every cell, blank ones included, so it is the one paste
-    // whose work grows with the area rather than with what the source holds.
-    let link_src = clip.range;
-    if link && link_src.count().saturating_mul(u64::from(tiles_r) * u64::from(tiles_c)) > MAX_PASTE_LINK_CELLS {
-        return Err(EngineError::Other("Too many cells to paste as links at once.".into()));
-    }
     let same_doc = s.doc()?.uid == clip.doc_uid;
     let cut_move = clip.cut && same_doc && what == What::All;
     let src_wb = clip.wb.clone();
     let Some(src_sheet) = src_wb.sheet(clip.sheet) else { return Err(EngineError::Other("The copied sheet no longer exists.".into())) };
     let src_sheet_name = src_sheet.name.clone();
+    if cut_move && at.offset((tiles_r * h).saturating_sub(1) as i64, (tiles_c * w).saturating_sub(1) as i64).is_none() {
+        // Check the whole footprint before the source is emptied, so a move that overflows the grid loses nothing.
+        return Err(EngineError::Other("The cut area doesn't fit at this position; nothing was moved.".into()));
+    }
     edit(s, |cx| {
         // Styles from another workbook must be re-interned.
-        let dest_name = cx.wb.sheet(dest_sheet).map(|sh| sh.name.clone()).unwrap_or_default();
         let mut style_map = std::collections::HashMap::new();
         let mut map_style = |id: StyleId, wb: &mut gridcraft_model::Workbook| -> StyleId {
             if same_doc {
@@ -77,7 +126,7 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
             }
             *style_map.entry(id).or_insert_with(|| wb.styles.intern(src_wb.styles.get(id).clone()))
         };
-        let mut moved_formulas = std::collections::BTreeMap::new();
+        let mut moved_formulas = Vec::new();
         let mut moved_pictures = std::collections::BTreeMap::new();
         if cut_move {
             // Remove the source first (contents and formats), and fix references to it.
@@ -94,284 +143,190 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
             for (c, _) in &taken {
                 cx.touch(clip.sheet, *c);
             }
-            moved_formulas = taken.into_iter().collect();
+            moved_formulas = taken;
         }
-        // The cells of the copied block that hold something (or that a link reads), as offsets
-        // inside it. Blank source cells matter only where the destination holds something.
-        let source_offsets: std::collections::BTreeSet<(u32, u32)> = if link {
-            (0..link_src.height()).flat_map(|r| (0..link_src.width()).map(move |c| (r, c))).collect()
-        } else {
-            let offset = |c: CellRef| (c.row - src.start.row, c.col - src.start.col);
-            let mut held: std::collections::BTreeSet<(u32, u32)> = src_sheet.cells.iter_range(src).map(|(c, _)| offset(c)).collect();
-            let side =
-                src_sheet.spill.keys().chain(src_sheet.cell_pictures.keys()).chain(src_sheet.comments.keys()).chain(src_sheet.hyperlinks.keys());
-            held.extend(side.chain(moved_formulas.keys()).chain(moved_pictures.keys()).filter(|c| src.contains(**c)).map(|c| offset(*c)));
-            held
-        };
-        let skip_cells = matches!(what, What::Validation | What::ColumnWidths);
-        // A blank source cell clears (or reformats) a destination cell that holds something, so
-        // those cells join the visit. One scan of the whole pasted area sorts them by tile.
-        let mut dest_held: std::collections::BTreeMap<(u32, u32), Vec<(u32, u32)>> = Default::default();
-        if !link && !skip_cells {
-            let pasted = RangeRef::new(at, at.offset_clamped(i64::from(tiles_r * h) - 1, i64::from(tiles_c * w) - 1));
-            let held =
-                cx.wb.sheet(dest_sheet).into_iter().flat_map(|sh| {
-                    sh.cells.iter_range(pasted).map(|(c, _)| c).chain(sh.cell_pictures.keys().copied().filter(|c| pasted.contains(*c)))
-                });
-            for d in held.collect::<Vec<_>>() {
-                let (dr, dc) = (d.row - at.row, d.col - at.col);
-                let local = (dr % h, dc % w);
-                dest_held.entry((dr / h, dc / w)).or_default().push(if transpose { (local.1, local.0) } else { local });
+        let dest_name = cx.wb.sheet(dest_sheet).map(|sh| sh.name.clone()).unwrap_or_default();
+        for (tr, tc, r, c) in tiled_cells(src.height(), src.width(), tiles_r, tiles_c) {
+            let sc = CellRef::new(src.start.row + r, src.start.col + c);
+            let (dr, dc) = if transpose { (c, r) } else { (r, c) };
+            let Some(dest) = at.offset((tr * h + dr) as i64, (tc * w + dc) as i64) else { continue };
+            let src_cell = if cut_move { moved_formulas.iter().find(|(k, _)| *k == sc).map(|(_, v)| v.clone()) } else { src_sheet.cell(sc).cloned() };
+            let src_val = src_sheet.value(sc);
+            let src_picture = if cut_move { moved_pictures.get(&sc) } else { src_sheet.cell_pictures.get(&sc) }.cloned();
+            if skip_blanks && src_picture.is_none() && src_val.is_empty() && src_cell.as_ref().is_none_or(|x| x.formula.is_none() && x.py.is_none()) {
+                continue;
             }
-        }
-        let no_cells = std::collections::BTreeSet::new();
-        for tr in 0..tiles_r {
-            for tc in 0..tiles_c {
-                let merged;
-                let offsets = match dest_held.get(&(tr, tc)) {
-                    Some(extra) => {
-                        merged = source_offsets.iter().chain(extra).copied().collect::<std::collections::BTreeSet<_>>();
-                        &merged
-                    }
-                    None if skip_cells => &no_cells,
-                    None => &source_offsets,
-                };
-                for &(r, c) in offsets {
-                    let sc = CellRef::new(src.start.row + r, src.start.col + c);
-                    let (dr, dc) = if transpose { (c, r) } else { (r, c) };
-                    let Some(dest) = at.offset((tr * h + dr) as i64, (tc * w + dc) as i64) else { continue };
-                    if skip_rows.contains(&dest.row) {
-                        continue;
-                    }
-                    let src_cell = if cut_move { moved_formulas.get(&sc).cloned() } else { src_sheet.cell(sc).cloned() };
-                    let src_val = src_sheet.value(sc);
-                    let src_picture = if cut_move { moved_pictures.get(&sc) } else { src_sheet.cell_pictures.get(&sc) }.cloned();
-                    if skip_blanks
-                        && src_picture.is_none()
-                        && src_val.is_empty()
-                        && src_cell.as_ref().is_none_or(|x| x.formula.is_none() && x.py.is_none())
-                    {
-                        continue;
-                    }
-                    let old = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell(dest)).cloned().unwrap_or_default();
-                    let old_picture = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell_pictures.get(&dest)).cloned();
-                    let mut new_picture = old_picture.clone();
-                    let mut new = old.clone();
-                    let shift = |cell: &Cell| -> Option<std::sync::Arc<Formula>> {
-                        let f = cell.formula.as_ref()?;
-                        let e = f.expr()?;
-                        if cut_move {
-                            // A moved formula still reads cells on its original sheet. Qualify
-                            // those references before the workbook-wide move adjustment below.
-                            let e = if dest_sheet != clip.sheet {
-                                e.map(&mut |x| match x {
-                                    gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
-                                        r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
-                                        gridcraft_formula::Expr::Ref(r)
-                                    }
-                                    other => other,
-                                })
-                            } else {
-                                e
-                            };
-                            let mut moved = Formula::from_expr(e);
-                            // The array range moves with its formula.
-                            let (dr, dc) = (dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
-                            moved.array = f.array.and_then(|a| Some(RangeRef::new(a.start.offset(dr, dc)?, a.end.offset(dr, dc)?)));
-                            moved.dynamic = f.dynamic;
-                            return Some(std::sync::Arc::new(moved));
-                        }
-                        let moved = gridcraft_formula::adjust::shift_relative(e, dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
-                        Some(std::sync::Arc::new(Formula { dynamic: f.dynamic, ..Formula::from_expr(moved) }))
-                    };
-                    let moved_py = |cell: &Cell| -> Result<Option<std::sync::Arc<gridcraft_model::PyCode>>> {
-                        let Some(py) = cell.py.clone() else { return Ok(None) };
-                        if !cut_move || dest_sheet == clip.sheet {
-                            return Ok(Some(py));
-                        }
-                        let qualified = gridcraft_model::python::rewrite_xl(&py.code, |reference| {
-                            let e = gridcraft_formula::parse(reference).ok()?.map(&mut |x| match x {
-                                gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
-                                    r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
-                                    gridcraft_formula::Expr::Ref(r)
-                                }
-                                other => other,
-                            });
-                            Some(gridcraft_formula::print(&e))
-                        });
-                        Ok(Some(match qualified {
-                            Some(code) => {
-                                let moved = gridcraft_model::PyCode { code, ..(*py).clone() };
-                                check_python_fits(&moved, &dest_name, dest)?;
-                                std::sync::Arc::new(moved)
+            let old = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell(dest)).cloned().unwrap_or_default();
+            let old_picture = cx.wb.sheet(dest_sheet).and_then(|sh| sh.cell_pictures.get(&dest)).cloned();
+            let mut new_picture = old_picture.clone();
+            let mut new = old.clone();
+            let shift = |cell: &Cell| -> Option<std::sync::Arc<Formula>> {
+                let f = cell.formula.as_ref()?;
+                let e = f.expr()?;
+                if cut_move {
+                    // A moved formula still reads cells on its original sheet. Qualify
+                    // those references before the workbook-wide move adjustment below.
+                    let e = if dest_sheet != clip.sheet {
+                        e.map(&mut |x| match x {
+                            gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
+                                r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
+                                gridcraft_formula::Expr::Ref(r)
                             }
-                            None => py,
-                        }))
-                    };
-                    if link {
-                        let sheet_prefix = if dest_sheet == clip.sheet && same_doc {
-                            String::new()
-                        } else {
-                            format!("{}!", gridcraft_formula::quote_sheet(&src_sheet_name))
-                        };
-                        new.formula = Some(std::sync::Arc::new(Formula::new(&format!("={sheet_prefix}{}", sc.a1()))));
-                        new.value = Value::Empty;
-                        new.py = None;
-                        new_picture = None;
+                            other => other,
+                        })
                     } else {
-                        let sc_cell = src_cell.clone().unwrap_or_default();
-                        match what {
-                            What::All | What::AllExceptBorders => {
-                                new_picture = src_picture.clone();
-                                new.formula = shift(&sc_cell);
-                                new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
-                                new.py = moved_py(&sc_cell)?;
-                                let st = map_style(sc_cell.style, &mut cx.wb);
-                                new.style = if what == What::AllExceptBorders {
-                                    let borders = cx.wb.styles.get(old.style).borders;
-                                    cx.wb.styles.derive(st, |s| s.borders = borders)
-                                } else {
-                                    st
-                                };
-                            }
-                            What::Formulas | What::FormulasAndNumberFormats => {
-                                new_picture = src_picture.clone();
-                                new.formula = shift(&sc_cell);
-                                new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
-                                new.py = moved_py(&sc_cell)?;
-                                if what == What::FormulasAndNumberFormats {
-                                    let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
-                                    new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
-                                }
-                            }
-                            What::Values | What::ValuesAndNumberFormats => {
-                                new_picture = src_picture.clone();
-                                new.formula = None;
-                                new.py = None;
-                                new.value = src_val.clone();
-                                if what == What::ValuesAndNumberFormats {
-                                    let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
-                                    new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
-                                }
-                            }
-                            What::Formats => new.style = map_style(sc_cell.style, &mut cx.wb),
-                            What::Comments | What::Validation | What::ColumnWidths => {}
-                        }
-                        // Operations combine numbers with what is already there.
-                        if op != "none"
-                            && matches!(what, What::All | What::Values | What::ValuesAndNumberFormats | What::Formulas)
-                            && new.formula.is_none()
-                            && new.py.is_none()
-                        {
-                            if old_picture.is_some() || new_picture.is_some() {
-                                new_picture = None;
-                                new.value = Value::Error(gridcraft_core::CellError::Value);
-                            }
-                            let a = old.value.clone();
-                            let b = new.value.clone();
-                            // Numbers stored as text take part (multiplying by 1 turns them into
-                            // numbers); other text and errors stay as they are.
-                            if let (Ok(x), Ok(y)) = (a.to_number(), b.to_number())
-                                && (a.is_number() || a.is_empty() || a.is_text())
-                                && (b.is_number() || b.is_empty())
-                            {
-                                new.value = match op.as_str() {
-                                    "add" => Value::number(x + y),
-                                    "subtract" => Value::number(x - y),
-                                    "multiply" => Value::number(x * y),
-                                    "divide" => {
-                                        if y == 0.0 {
-                                            Value::Error(gridcraft_core::CellError::Div0)
-                                        } else {
-                                            Value::number(x / y)
-                                        }
-                                    }
-                                    _ => b.clone(),
-                                };
-                            } else if (a.is_text() || a.is_error()) && (b.is_number() || b.is_empty()) {
-                                new.value = a;
-                            }
-                            // A formula already there is kept and combined with the pasted number.
-                            if let Some(f) = &old.formula
-                                && let Ok(y) = b.to_number()
-                                && (b.is_number() || b.is_empty())
-                                && let Some(sym) = match op.as_str() {
-                                    "add" => Some('+'),
-                                    "subtract" => Some('-'),
-                                    "multiply" => Some('*'),
-                                    "divide" => Some('/'),
-                                    _ => None,
-                                }
-                            {
-                                let text = format!("=({}){sym}{}", f.text, gridcraft_core::number_to_text(y));
-                                new.formula = Some(std::sync::Arc::new(Formula::new(&text)));
-                                new.value = Value::Empty;
-                            }
-                        }
-                    }
-                    match what {
-                        What::Comments => {
-                            if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
-                                cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
-                            }
-                        }
-                        What::All => {
-                            if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
-                                cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
-                            }
-                            if let Some(h) = src_sheet.hyperlinks.get(&sc).cloned() {
-                                cx.sheet_mut(dest_sheet)?.hyperlinks.insert(dest, h);
-                            }
-                            cx.sheet_mut(dest_sheet)?.set_cell(dest, new);
-                        }
-                        _ => cx.sheet_mut(dest_sheet)?.set_cell(dest, new),
-                    }
-                    if let Some(picture) = new_picture {
-                        cx.sheet_mut(dest_sheet)?.cell_pictures.insert(dest, picture);
-                    }
-                    cx.touch(dest_sheet, dest);
+                        e
+                    };
+                    let mut moved = Formula::from_expr(e);
+                    // The array range moves with its formula.
+                    let (dr, dc) = (dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
+                    moved.array = f.array.and_then(|a| Some(RangeRef::new(a.start.offset(dr, dc)?, a.end.offset(dr, dc)?)));
+                    moved.dynamic = f.dynamic;
+                    return Some(std::sync::Arc::new(moved));
                 }
-            }
-        }
-        let pasted = RangeRef::new(at, at.offset_clamped(i64::from(tiles_r * h) - 1, i64::from(tiles_c * w) - 1));
-        if !link && matches!(what, What::All | What::AllExceptBorders | What::Validation) {
-            paste_validations(cx, src_sheet, src, dest_sheet, pasted, PasteMode { transpose, skip_blanks, skip_rows: &skip_rows })?;
-        }
-        if what == What::ColumnWidths {
-            // Each pasted column takes the width of the column copied to it (transposed, the
-            // copied rows land in columns and all take the last copied column's width).
-            let cols = cx.sheet_mut(dest_sheet)?;
-            for dc in 0..pasted.width() {
-                let info = if transpose {
-                    (0..src.width()).rev().find_map(|c| src_sheet.cols.get(&(src.start.col + c)).copied())
+                let moved = gridcraft_formula::adjust::shift_relative(e, dest.row as i64 - sc.row as i64, dest.col as i64 - sc.col as i64);
+                Some(std::sync::Arc::new(Formula { dynamic: f.dynamic, ..Formula::from_expr(moved) }))
+            };
+            // A Python cell's code travels with it. Cut to another sheet, it keeps reading the
+            // cells its `xl()` references named on its original sheet, as a moved formula does:
+            // they are qualified with that sheet before the workbook-wide move adjustment below.
+            let moved_py = |cell: &Cell| -> Result<Option<std::sync::Arc<gridcraft_model::PyCode>>> {
+                let Some(py) = cell.py.clone() else { return Ok(None) };
+                if !cut_move || dest_sheet == clip.sheet {
+                    return Ok(Some(py));
+                }
+                let qualified = gridcraft_model::python::rewrite_xl(&py.code, |reference| {
+                    let e = gridcraft_formula::parse(reference).ok()?.map(&mut |x| match x {
+                        gridcraft_formula::Expr::Ref(mut r) if r.sheet == gridcraft_formula::SheetSel::Current => {
+                            r.sheet = gridcraft_formula::SheetSel::Named(src_sheet_name.clone());
+                            gridcraft_formula::Expr::Ref(r)
+                        }
+                        other => other,
+                    });
+                    Some(gridcraft_formula::print(&e))
+                });
+                Ok(Some(match qualified {
+                    Some(code) => {
+                        let moved = gridcraft_model::PyCode { code, ..(*py).clone() };
+                        check_python_fits(&moved, &dest_name, dest)?;
+                        std::sync::Arc::new(moved)
+                    }
+                    None => py,
+                }))
+            };
+            if link {
+                let sheet_prefix = if dest_sheet == clip.sheet && same_doc {
+                    String::new()
                 } else {
-                    src_sheet.cols.get(&(src.start.col + dc % w)).copied()
+                    format!("{}!", gridcraft_formula::quote_sheet(&src_sheet_name))
                 };
-                if let Some(info) = info {
-                    cols.cols.insert(pasted.start.col + dc, info);
+                new.formula = Some(std::sync::Arc::new(Formula::new(&format!("={sheet_prefix}{}", sc.a1()))));
+                new.value = Value::Empty;
+                new.py = None;
+                new_picture = None;
+            } else {
+                let sc_cell = src_cell.clone().unwrap_or_default();
+                match what {
+                    What::All | What::AllExceptBorders => {
+                        new_picture = src_picture.clone();
+                        new.formula = shift(&sc_cell);
+                        new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                        new.py = moved_py(&sc_cell)?;
+                        let st = map_style(sc_cell.style, &mut cx.wb);
+                        new.style = if what == What::AllExceptBorders {
+                            let borders = cx.wb.styles.get(old.style).borders;
+                            cx.wb.styles.derive(st, |s| s.borders = borders)
+                        } else {
+                            st
+                        };
+                    }
+                    What::Formulas | What::FormulasAndNumberFormats => {
+                        new_picture = src_picture.clone();
+                        new.formula = shift(&sc_cell);
+                        new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                        new.py = moved_py(&sc_cell)?;
+                        if what == What::FormulasAndNumberFormats {
+                            let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
+                            new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
+                        }
+                    }
+                    What::Values | What::ValuesAndNumberFormats => {
+                        new_picture = src_picture.clone();
+                        new.formula = None;
+                        new.py = None;
+                        new.value = src_val.clone();
+                        if what == What::ValuesAndNumberFormats {
+                            let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
+                            new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
+                        }
+                    }
+                    What::Formats => new.style = map_style(sc_cell.style, &mut cx.wb),
+                    What::Comments | What::Validation | What::ColumnWidths => {}
+                }
+                // Operations combine numbers with what is already there.
+                if op != "none"
+                    && matches!(what, What::All | What::Values | What::ValuesAndNumberFormats | What::Formulas)
+                    && new.formula.is_none()
+                    && new.py.is_none()
+                {
+                    if old_picture.is_some() || new_picture.is_some() {
+                        new_picture = None;
+                        new.value = Value::Error(gridcraft_core::CellError::Value);
+                    }
+                    // Numbers stored as text participate; other text and errors stay as they are.
+                    apply_operation(&op, &old, &mut new);
                 }
             }
+            // The copied cell's validation rule replaces whatever rule the destination had.
+            if !link && matches!(what, What::All | What::AllExceptBorders | What::Validation) {
+                let rule = src_sheet.validations.iter().find(|dv| dv.ranges.iter().any(|r| r.contains(sc))).cloned();
+                let sh = cx.sheet_mut(dest_sheet)?;
+                crate::cmd::data::remove_validation_cells(&mut sh.validations, &[RangeRef::new(dest, dest)]);
+                if let Some(mut dv) = rule {
+                    // Relative references move with the rule, as pasted formulas do.
+                    let first = RangeRef::top_left(&dv.ranges).unwrap_or(sc);
+                    dv.f1 = crate::cmd::data::move_rule_formula(&dv.f1, first, dest);
+                    dv.f2 = dv.f2.map(|f| crate::cmd::data::move_rule_formula(&f, first, dest));
+                    dv.ranges = vec![RangeRef::new(dest, dest)];
+                    sh.validations.push(dv);
+                }
+            }
+            match what {
+                What::Comments => {
+                    if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
+                        cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
+                    }
+                }
+                What::ColumnWidths => {
+                    if let Some(info) = src_sheet.cols.get(&sc.col).copied() {
+                        cx.sheet_mut(dest_sheet)?.cols.insert(dest.col, info);
+                    }
+                }
+                What::All => {
+                    if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
+                        cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
+                    }
+                    if let Some(h) = src_sheet.hyperlinks.get(&sc).cloned() {
+                        cx.sheet_mut(dest_sheet)?.hyperlinks.insert(dest, h);
+                    }
+                    cx.sheet_mut(dest_sheet)?.set_cell(dest, new);
+                }
+                _ => cx.sheet_mut(dest_sheet)?.set_cell(dest, new),
+            }
+            if let Some(picture) = new_picture {
+                cx.sheet_mut(dest_sheet)?.cell_pictures.insert(dest, picture);
+            }
+            cx.touch(dest_sheet, dest);
         }
         // Merged areas inside the copied block travel with it.
-        if matches!(what, What::All | What::Formats) && !transpose {
-            let merges: Vec<RangeRef> = src_sheet.merges.iter().filter(|m| src.contains_range(m)).copied().collect();
-            for m in merges {
-                let dr = at.row as i64 - src.start.row as i64;
-                let dc = at.col as i64 - src.start.col as i64;
-                if let (Some(a), Some(b)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
-                    let nm = RangeRef::new(a, b);
-                    let sh = cx.sheet_mut(dest_sheet)?;
-                    sh.merges.retain(|x| !x.intersects(&nm));
-                    sh.merges.push(nm);
-                }
-            }
-        }
+        copy_merges(cx, dest_sheet, src_sheet, src, at, what, transpose)?;
         if cut_move {
             // References elsewhere to the moved block now point to its new place.
+            let dest_name = cx.wb.sheet(dest_sheet).map(|s| s.name.clone()).unwrap_or_default();
             let e = if dest_sheet == clip.sheet {
                 gridcraft_formula::adjust::Edit::Move { from: src, to_row: at.row, to_col: at.col }
             } else {
-                gridcraft_formula::adjust::Edit::MoveToSheet { from: src, to_sheet: dest_name.clone(), to_row: at.row, to_col: at.col }
+                gridcraft_formula::adjust::Edit::MoveToSheet { from: src, to_sheet: dest_name, to_row: at.row, to_col: at.col }
             };
             rewrite_all_formulas(&mut cx.wb, &src_sheet_name, &e)?;
             cx.structural = true;
@@ -396,161 +351,6 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result<Json> {
     Ok(json!({"pasted": s.doc()?.selection.a1()}))
 }
 
-/// Most cells one Paste Link writes (it writes a formula into every cell of the copied area,
-/// blank ones included).
-const MAX_PASTE_LINK_CELLS: u64 = 1_048_576;
-/// Most validation ranges one paste adds (a rule covering part of a small block tiled over a huge
-/// selection makes one range per tile).
-const MAX_PASTE_VALIDATION_RANGES: usize = 100_000;
-
-/// How a validation paste lays the rules out: transposed or not, keeping the destination's rule under
-/// blank source cells, and leaving the rows a filter hides as they are.
-#[derive(Clone, Copy)]
-struct PasteMode<'a> {
-    transpose: bool,
-    skip_blanks: bool,
-    skip_rows: &'a std::collections::BTreeSet<u32>,
-}
-
-/// `range` less the rows in `skip`: the runs of rows between them, as ranges of its columns.
-fn without_rows(range: RangeRef, skip: &std::collections::BTreeSet<u32>) -> Vec<RangeRef> {
-    let mut out = Vec::new();
-    let mut next = range.start.row;
-    for &row in skip.range(range.start.row..=range.end.row) {
-        if row > next {
-            out.push(RangeRef::new(CellRef::new(next, range.start.col), CellRef::new(row - 1, range.end.col)));
-        }
-        next = row + 1;
-    }
-    if next <= range.end.row {
-        out.push(RangeRef::new(CellRef::new(next, range.start.col), CellRef::new(range.end.row, range.end.col)));
-    }
-    out
-}
-
-/// Pasting validation works on ranges, as Excel stores it: the pasted rectangle is cut out of the
-/// destination's rules (cells whose source had no rule end up with none), then each source rule
-/// that covers part of the copied block `src` comes along as one rule over the translated parts.
-/// `size` is one tile's (height, width) at the destination; `pasted` is all the tiles together.
-fn paste_validations(
-    cx: &mut crate::cmd::Ctx<'_>,
-    src_sheet: &gridcraft_model::Sheet,
-    src: RangeRef,
-    dest_sheet: usize,
-    pasted: RangeRef,
-    mode: PasteMode<'_>,
-) -> Result<()> {
-    let PasteMode { transpose, skip_blanks, skip_rows } = mode;
-    let (h, w) = if transpose { (src.width(), src.height()) } else { (src.height(), src.width()) };
-    let (tiles_r, tiles_c) = (pasted.height() / h.max(1), pasted.width() / w.max(1));
-    let mut rules = Vec::new();
-    // Under Skip Blanks the destination keeps its rule below a blank source cell that has none, so
-    // only the destination of cells that hold something (and of the rules) is cleared. Nothing is
-    // collected when no destination rule is under the paste.
-    let mut cleared: Vec<RangeRef> = Vec::new();
-    let dest_rules =
-        cx.wb.sheet(dest_sheet).is_some_and(|sh| sh.validations.iter().any(|dv| dv.ranges.iter().any(|r| r.intersection(&pasted).is_some())));
-    if skip_blanks && dest_rules {
-        let mut cells = Vec::new();
-        for (sc, cell) in src_sheet.cells.iter_range(src) {
-            if cell.formula.is_none() && cell.py.is_none() && src_sheet.value(sc).is_empty() {
-                continue;
-            }
-            let (r, c) = (sc.row - src.start.row, sc.col - src.start.col);
-            let (r, c) = if transpose { (c, r) } else { (r, c) };
-            for tr in 0..tiles_r {
-                for tc in 0..tiles_c {
-                    if let Some(d) = pasted.start.offset(i64::from(tr * h + r), i64::from(tc * w + c))
-                        && !skip_rows.contains(&d.row)
-                    {
-                        cells.push((d.row, d.col));
-                    }
-                }
-            }
-        }
-        // Coalesce populated cells into horizontal runs, then join identical runs in adjacent
-        // rows. The range limit applies to the cuts, not the number of populated cells.
-        cells.sort_unstable();
-        let mut runs: Vec<RangeRef> = Vec::new();
-        let mut i = 0;
-        while i < cells.len() {
-            let (row, start_col) = cells[i];
-            let mut end_col = start_col;
-            i += 1;
-            while i < cells.len() && cells[i].0 == row && cells[i].1 <= end_col.saturating_add(1) {
-                end_col = end_col.max(cells[i].1);
-                i += 1;
-            }
-            runs.push(RangeRef::new(CellRef::new(row, start_col), CellRef::new(row, end_col)));
-        }
-        let mut last_run_by_columns = std::collections::BTreeMap::<(u32, u32), usize>::new();
-        for run in runs {
-            let columns = (run.start.col, run.end.col);
-            if let Some(&index) = last_run_by_columns.get(&columns)
-                && cleared[index].end.row.saturating_add(1) == run.start.row
-            {
-                cleared[index].end.row = run.end.row;
-            } else {
-                let index = cleared.len();
-                cleared.push(run);
-                last_run_by_columns.insert(columns, index);
-            }
-        }
-    }
-    let mut total = 0usize;
-    for dv in &src_sheet.validations {
-        let parts: Vec<RangeRef> = dv.ranges.iter().filter_map(|r| r.intersection(&src)).collect();
-        let Some(first) = dv.ranges.first().map(|r| r.start) else { continue };
-        if parts.is_empty() {
-            continue;
-        }
-        let mut ranges = Vec::new();
-        if parts.contains(&src) {
-            ranges.push(pasted);
-        } else {
-            total = total.saturating_add(parts.len().saturating_mul(tiles_r as usize).saturating_mul(tiles_c as usize));
-            if total > MAX_PASTE_VALIDATION_RANGES {
-                return Err(EngineError::Other("Too many separate validation areas to paste at once.".into()));
-            }
-            for tr in 0..tiles_r {
-                for tc in 0..tiles_c {
-                    let Some(origin) = pasted.start.offset(i64::from(tr * h), i64::from(tc * w)) else { continue };
-                    for p in &parts {
-                        let (r0, c0) = (p.start.row - src.start.row, p.start.col - src.start.col);
-                        let (r1, c1) = (p.end.row - src.start.row, p.end.col - src.start.col);
-                        let ((r0, c0), (r1, c1)) = if transpose { ((c0, r0), (c1, r1)) } else { ((r0, c0), (r1, c1)) };
-                        let Some(a) = origin.offset(i64::from(r0), i64::from(c0)) else { continue };
-                        let b = origin.offset_clamped(i64::from(r1), i64::from(c1));
-                        ranges.push(RangeRef::new(a, b));
-                    }
-                }
-            }
-        }
-        // The rows a filter hides keep what they have.
-        let ranges: Vec<RangeRef> = ranges.into_iter().flat_map(|r| without_rows(r, skip_rows)).collect();
-        let Some(anchor) = ranges.first().map(|r| r.start) else { continue };
-        let mut rule = dv.clone();
-        // Relative references move with the rule, as pasted formulas do: they are written for the
-        // rule's first cell.
-        rule.f1 = super::super::data::move_rule_formula(&dv.f1, first, anchor);
-        rule.f2 = dv.f2.as_ref().map(|f| super::super::data::move_rule_formula(f, first, anchor));
-        rule.ranges = ranges;
-        rules.push(rule);
-    }
-    if cleared.len() > MAX_PASTE_VALIDATION_RANGES {
-        return Err(EngineError::Other("Too many separate validation areas to paste at once.".into()));
-    }
-    let sh = cx.sheet_mut(dest_sheet)?;
-    if skip_blanks {
-        cleared.extend(rules.iter().flat_map(|r| r.ranges.iter().copied()));
-        super::super::data::remove_validation_cells(&mut sh.validations, &cleared);
-    } else {
-        super::super::data::remove_validation_cells(&mut sh.validations, &without_rows(pasted, skip_rows));
-    }
-    sh.validations.extend(rules);
-    Ok(())
-}
-
 /// Applies a reference adjustment to every cell formula and defined name in the workbook.
 pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &str, e: &gridcraft_formula::adjust::Edit) -> Result<()> {
     use gridcraft_formula::adjust::Edit;
@@ -567,19 +367,19 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &
         let on_target = moves_arrays && host.eq_ignore_ascii_case(target);
         let Some(sheet) = wb.sheet_mut(si) else { continue };
         for (c, f) in keys {
-            // Borrows the tree and copies and prints only the formulas the edit changes. A formula
-            // the edit leaves alone keeps its stored text, even if that text is not canonical.
-            let Some(new) = f.with_expr(|x| gridcraft_formula::adjust::adjust_if_changed(x, &host, target, e)) else { continue };
+            let Some(expr) = f.expr() else { continue };
+            let new = gridcraft_formula::adjust::adjust(expr, &host, target, e);
+            let text = gridcraft_formula::print(&new);
             let array = match f.array {
                 Some(a) if on_target => crate::cmd::sheet::map_range(a, e),
                 a => a,
             };
-            let nf = match new {
-                Some(new) => Formula { array, dynamic: f.dynamic, ..Formula::from_expr(new) },
-                None if array != f.array => Formula { array, ..(*f).clone() },
-                None => continue,
-            };
-            if let Some(cell) = sheet.cells.get_mut(c) {
+            if (text != f.text || array != f.array)
+                && let Some(cell) = sheet.cells.get_mut(c)
+            {
+                let mut nf = Formula::from_expr(new);
+                nf.array = array;
+                nf.dynamic = f.dynamic;
                 cell.formula = Some(std::sync::Arc::new(nf));
             }
         }
@@ -596,15 +396,14 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &
 }
 
 /// Runs `f` over every reference a floating object holds (a chart's series values, categories,
-/// name and bubble sizes, and the source block it was made from, and a form control's linked
-/// cell). Every edit that moves
+/// name and bubble sizes, and the source block it was made from). Every edit that moves
 /// references calls it: inserting and deleting lines and cells and cut-moves (through
 /// [`rewrite_all_formulas`]), and renaming and deleting sheets. `f` maps a reference held by an
 /// object on the sheet named `host` to its new form; text that does not parse is kept. A source
 /// block that no longer exists is dropped.
 pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn(&str, gridcraft_formula::Expr) -> gridcraft_formula::Expr) {
     for si in 0..wb.sheets.len() {
-        let Some(host) = wb.sheets.get(si).filter(|s| !s.charts.is_empty() || !s.controls.is_empty()).map(|s| s.name.clone()) else { continue };
+        let Some(host) = wb.sheets.get(si).filter(|s| !s.charts.is_empty()).map(|s| s.name.clone()) else { continue };
         let Some(sh) = wb.sheet_mut(si) else { continue };
         let fix = |text: &str| -> String {
             match gridcraft_formula::parse(text) {
@@ -621,9 +420,6 @@ pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn(
                 se.bubble_sizes = se.bubble_sizes.as_deref().map(fix);
             }
         }
-        for c in sh.controls.iter_mut() {
-            c.link = c.link.as_deref().map(fix);
-        }
     }
 }
 

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

@@ -66,14 +66,7 @@ pub(super) fn selection_move(s: &mut Session, p: &Json) -> Result<Json> {
     // Extension moves the far corner, not the active cell.
     let from = if extend { sel.moving_end() } else { sel.active };
     // Skip hidden rows/columns and step over merged areas.
-    let mut to = if jmp && extend && (dr == 0) != (dc == 0) {
-        // Excel: Ctrl+Shift+arrow searches the active cell's column (or row) from the moving
-        // edge, so a header row selected with Ctrl+Shift+Right extends down to the end of the
-        // active column's data.
-        let probe = if dr != 0 { CellRef::new(from.row, sel.active.col) } else { CellRef::new(sel.active.row, from.col) };
-        let edge = jump(sheet, probe, dr.signum(), dc.signum());
-        if dr != 0 { CellRef::new(edge.row, from.col) } else { CellRef::new(from.row, edge.col) }
-    } else if jmp {
+    let mut to = if jmp {
         jump(sheet, from, dr.signum(), dc.signum())
     } else {
         let mut t = from.offset_clamped(dr, dc);

crates/engine/src/cmd/extra.rs

@@ -97,7 +97,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Bring Forward",
             ["Page Layout", "Arrange"],
             None,
-            "{kind: chart|image|shape|slicer|equation|control, id, toFront?: bool}",
+            "{kind: chart|image|shape|slicer|equation, id, toFront?: bool}",
             has_doc,
             |s, p| arrange(s, p, true)
         ),
@@ -106,7 +106,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Send Backward",
             ["Page Layout", "Arrange"],
             None,
-            "{kind: chart|image|shape|slicer|equation|control, id, toBack?: bool}",
+            "{kind: chart|image|shape|slicer|equation, id, toBack?: bool}",
             has_doc,
             |s, p| arrange(s, p, false)
         ),
@@ -116,7 +116,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Align",
             ["Page Layout", "Arrange"],
             None,
-            "{kind: chart|image|shape|slicer|equation|control, ids: [..], align: left|center|right|top|middle|bottom}",
+            "{kind: chart|image|shape|slicer|equation, ids: [..], align: left|center|right|top|middle|bottom}",
             has_doc,
             align
         ),

crates/engine/src/cmd/extra/objects.rs

@@ -57,7 +57,6 @@ pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json>
     let kind = kind_param(p, "arrange")?;
     let extreme = bool_param(p, "toFront").or(bool_param(p, "toBack")).unwrap_or(false);
     let si = s.doc()?.wb.active_sheet();
-    crate::cmd::controls::check_objects_unlocked(s, si, kind, &[id])?;
     fn reorder<T>(v: &mut Vec<T>, i: usize, forward: bool, extreme: bool) {
         if i >= v.len() {
             return;
@@ -82,7 +81,6 @@ pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json>
             ObjKind::Shape | ObjKind::Equation => {
                 sh.shapes.iter().position(|c| c.id == id && shape_is(kind, c)).map(|i| reorder(&mut sh.shapes, i, forward, extreme))
             }
-            ObjKind::Control => sh.controls.iter().position(|c| c.id == id).map(|i| reorder(&mut sh.controls, i, forward, extreme)),
         };
         found.ok_or_else(|| bad("arrange", "no such object"))?;
         Ok(Json::Null)
@@ -108,12 +106,6 @@ pub(super) fn selection_pane(s: &mut Session, _: &Json) -> Result<Json> {
         let name = if c.caption.is_empty() { &c.column } else { &c.caption };
         v.push(json!({"kind": "slicer", "id": c.id, "name": name, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
     }
-    // Form controls paint above everything else.
-    for c in &sh.controls {
-        v.push(
-            json!({"kind": "control", "id": c.id, "name": c.display_name(), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}),
-        );
-    }
     Ok(Json::Array(v))
 }
 
@@ -123,7 +115,6 @@ fn anchors_of(sh: &mut Sheet, kind: ObjKind) -> Vec<(u32, &mut Anchor)> {
         ObjKind::Chart => sh.charts.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
         ObjKind::Image => sh.images.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
         ObjKind::Slicer => sh.slicers.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
-        ObjKind::Control => sh.controls.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
         ObjKind::Shape | ObjKind::Equation => sh.shapes.iter_mut().filter(|c| shape_is(kind, c)).map(|c| (c.id, &mut c.anchor)).collect(),
     }
 }
@@ -142,7 +133,6 @@ pub(super) fn align(s: &mut Session, p: &Json) -> Result<Json> {
     };
     let how = str_param(p, "align").unwrap_or("left").to_string();
     let si = s.doc()?.wb.active_sheet();
-    crate::cmd::controls::check_objects_unlocked(s, si, kind, &ids)?;
     edit(s, |cx| {
         let sheet = cx.sheet_mut(si)?;
         let geo: Vec<(u32, f64, f64, f32, f32)> = {

crates/engine/src/cmd/file.rs

@@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Options",
             ["File"],
             None,
-            "{} → {calculation: {mode, iterative, maxIterations, maxChange, precisionAsDisplayed}} for the active workbook (the interface opens File › Options; change settings with their own commands, e.g. formulas.calculationOptions, view.theme, app.language.set)",
+            "{} → {calculation: {mode, iterative, maxIterations, maxChange}} for the active workbook (the interface opens File › Options; change settings with their own commands, e.g. formulas.calculationOptions, view.theme, app.language.set)",
             always,
             options
         ),
@@ -230,7 +230,7 @@ fn options(s: &mut Session, _: &Json) -> Result<Json> {
             gridcraft_model::CalcMode::AutomaticExceptTables => "automaticExceptTables",
             gridcraft_model::CalcMode::Manual => "manual",
         };
-        json!({"mode": mode, "iterative": c.iterative, "maxIterations": c.max_iterations, "maxChange": c.max_change, "precisionAsDisplayed": c.precision_as_displayed})
+        json!({"mode": mode, "iterative": c.iterative, "maxIterations": c.max_iterations, "maxChange": c.max_change})
     });
     Ok(json!({"calculation": calculation}))
 }

crates/engine/src/cmd/forecast.rs

@@ -427,8 +427,6 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result<Json> {
             data_table: None,
             gridlines: true,
             style: 1,
-            hole_size: 75,
-            first_slice_angle: 0,
             x_title: None,
             y_title: None,
             source: None,

crates/engine/src/cmd/formulas.rs

@@ -101,7 +101,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Calculation Options",
             ["Formulas", "Calculation"],
             None,
-            "{mode?: automatic|automaticExceptTables|manual, iterative?: bool (Enable iterative calculation), maxIterations?: 1–32767 (100), maxChange?: number (0.001), precisionAsDisplayed?: bool (Set precision as displayed: numbers are stored as their format shows them; turning it on rounds every number constant permanently)} → the settings. File › Options › Formulas › Calculation options; stored in the workbook.",
+            "{mode?: automatic|automaticExceptTables|manual, iterative?: bool (Enable iterative calculation), maxIterations?: 1–32767 (100), maxChange?: number (0.001)} → the settings. File › Options › Formulas › Calculation options; stored in the workbook.",
             has_doc,
             calc_options
         ),
@@ -179,7 +179,10 @@ fn guessed_range(sh: &gridcraft_model::sheet::Sheet, at: CellRef) -> Option<Rang
     let mut range = None;
     if at.row > 0 && (numeric(CellRef::new(at.row - 1, at.col)) || at.col == 0 || !numeric(CellRef::new(at.row, at.col - 1))) {
         let mut top = at.row - 1;
-        while top > 0 && numeric(CellRef::new(top - 1, at.col)) {
+        while top > 0
+            && (numeric(CellRef::new(top - 1, at.col))
+                || sh.value(CellRef::new(top - 1, at.col)).is_empty() && top > 1 && numeric(CellRef::new(top - 2, at.col)))
+        {
             top -= 1;
         }
         if numeric(CellRef::new(at.row - 1, at.col)) {
@@ -951,30 +954,14 @@ fn calc_options(s: &mut Session, p: &Json) -> Result<Json> {
         if let Some(v) = f64_param(p, "maxChange") {
             cx.wb.calc.set_max_change(v);
         }
-        let precision = bool_param(p, "precisionAsDisplayed");
-        if let Some(v) = precision {
-            cx.wb.calc.precision_as_displayed = v;
-            if v && !before.precision_as_displayed {
-                crate::cmd::round_all_constants_as_displayed(&mut cx.wb);
-            }
-        }
         let c = &cx.wb.calc;
         // Switching to automatic, or changing how circular references are calculated outside
         // manual mode, recalculates the workbook.
         let iteration_changed = (c.iterative, c.max_iterations, c.max_change) != (before.iterative, before.max_iterations, before.max_change);
-        // Switching precision as displayed recalculates the workbook, in manual mode too, so the
-        // values change as soon as it is switched on or off.
-        let precision_changed = c.precision_as_displayed != before.precision_as_displayed;
-        if mode == Some(CalcMode::Automatic) || (iteration_changed && c.mode != CalcMode::Manual) || precision_changed {
+        if mode == Some(CalcMode::Automatic) || (iteration_changed && c.mode != CalcMode::Manual) {
             cx.structural = true;
         }
-        Ok(json!({
-            "mode": format!("{:?}", c.mode),
-            "iterative": c.iterative,
-            "maxIterations": c.max_iterations,
-            "maxChange": c.max_change,
-            "precisionAsDisplayed": c.precision_as_displayed,
-        }))
+        Ok(json!({"mode": format!("{:?}", c.mode), "iterative": c.iterative, "maxIterations": c.max_iterations, "maxChange": c.max_change}))
     })
 }
 

crates/engine/src/cmd/insert.rs

@@ -99,7 +99,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Chart Properties",
             ["Chart Design"],
             None,
-            "{chart?: id, type?, subtype?, title?, legend?: none|bottom|top|left|right, dataLabels?, gridlines?, dataTable?: bool, dataTableKeys?: bool, dataTableHorizontalBorder?: bool, dataTableVerticalBorder?: bool, dataTableOutline?: bool (data tables: column/bar/line/area and compatible combo charts), quartiles?: exclusive|inclusive, style?, holeSize?, firstSliceAngle?, xTitle?, yTitle?, at?, width?, height?, dx?, dy?}",
+            "{chart?: id, type?, subtype?, title?, legend?: none|bottom|top|left|right, dataLabels?, gridlines?, dataTable?: bool, dataTableKeys?: bool, dataTableHorizontalBorder?: bool, dataTableVerticalBorder?: bool, dataTableOutline?: bool (data tables: column/bar/line/area and compatible combo charts), quartiles?: exclusive|inclusive, style?, xTitle?, yTitle?, at?, width?, height?, dx?, dy?}",
             has_doc,
             chart_set
         ),
@@ -146,13 +146,13 @@ pub fn specs() -> Vec<CommandSpec> {
             &with(p, "kind", json!("textBox"))
         )),
         cmd!("shape.setText", "Edit Text Box", [], None, "{id: textBox id, text: string}", has_doc, shape_set_text),
-        cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape|slicer|equation|control, id}", has_doc, delete_object),
+        cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape|slicer|equation, id}", has_doc, delete_object),
         cmd!(
             "object.move",
             "Move Object",
             [],
             None,
-            "{kind: chart|image|shape|slicer|equation|control, id, at?: \"C3\", dx?, dy?, width?, height? (each at most 10,000 points, or the object's current size when a file made it larger)}",
+            "{kind: chart|image|shape|slicer|equation, id, at?: \"C3\", dx?, dy?, width?, height? (each at most 10,000 points, or the object's current size when a file made it larger)}",
             has_doc,
             move_object
         ),
@@ -161,7 +161,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Object Properties",
             [],
             None,
-            "{kind: chart|image|shape|slicer|equation|control, id, mode: moveAndSize|moveOnly|absolute}",
+            "{kind: chart|image|shape|slicer|equation, id, mode: moveAndSize|moveOnly|absolute}",
             has_doc,
             set_anchor_mode
         ),
@@ -850,8 +850,6 @@ pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> {
         data_table: None,
         gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
         style: 1,
-        hole_size: 75,
-        first_slice_angle: 0,
         x_title: None,
         y_title: None,
         source: (areas.len() == 1).then(|| format!("{}!{}", gridcraft_formula::quote_sheet(&sh.name), bounds.a1())),
@@ -928,12 +926,6 @@ fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
         if let Some(v) = u32_param(p, "style") {
             c.style = v.clamp(1, 16);
         }
-        if let Some(v) = u32_param(p, "holeSize") {
-            c.hole_size = v.clamp(10, 90) as u8;
-        }
-        if let Some(v) = u32_param(p, "firstSliceAngle") {
-            c.first_slice_angle = (v % 360) as u16;
-        }
         if let Some(t) = p.get("xTitle") {
             c.x_title = t.as_str().map(str::to_string);
         }
@@ -1243,16 +1235,13 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
 /// objects are errors, so a stale id never succeeds silently.
 fn object_param(s: &Session, p: &Json, cmd: &str) -> Result<(usize, ObjRef)> {
     let id = u32_param(p, "id").ok_or_else(|| bad(cmd, "missing `id`"))?;
-    let kind =
-        str_param(p, "kind").and_then(ObjKind::parse).ok_or_else(|| bad(cmd, "kind must be chart, image, shape, slicer, equation or control"))?;
+    let kind = str_param(p, "kind").and_then(ObjKind::parse).ok_or_else(|| bad(cmd, "kind must be chart, image, shape, slicer or equation"))?;
     let d = s.doc()?;
     let sheet = d.wb.active_sheet();
     let o = ObjRef::new(kind, id);
     if !d.wb.sheet(sheet).is_some_and(|sh| sh.has_object(o)) {
         return Err(bad(cmd, "no such object"));
     }
-    // A locked form control on a protected sheet stays as it is.
-    super::controls::check_objects_unlocked(s, sheet, kind, &[id])?;
     Ok((sheet, o))
 }
 

crates/engine/src/cmd/macros.rs

@@ -28,7 +28,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Run Macro",
             [],
             None,
-            "{name, inputs?: {Input: \"B2:D9\"} | \"B2:D9\", output?: \"F2\" (instead of the macro's output anchor), onConflict?: ask|fail|overwrite|shiftDown|shiftRight, overwrite?: bool, approve?: bool, timeLimit?: seconds} runs as one undo step; any error rolls it all back → {macro, ran, inputs, stopped?, shifted?}",
+            "{name, inputs?: {Input: \"B2:D9\"} | \"B2:D9\", onConflict?: ask|fail|overwrite|shiftDown|shiftRight, overwrite?: bool, approve?: bool, timeLimit?: seconds} runs as one undo step; any error rolls it all back → {macro, ran, inputs, stopped?, shifted?}",
             has_doc,
             run
         ),
@@ -37,7 +37,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Check Macro",
             [],
             None,
-            "{name, inputs?, output?: \"F2\" (as macro.run), onConflict?, overwrite?, timeLimit?: seconds} validates the inputs and dry-runs the macro on the workbook (then puts everything back) → {ok (macro.run with these parameters would go ahead without a question), errors?, needsApproval?, onConflict, inputs, output?, conflicts, footprint}",
+            "{name, inputs?, onConflict?, overwrite?, timeLimit?: seconds} validates the inputs and dry-runs the macro on the workbook (then puts everything back) → {ok (macro.run with these parameters would go ahead without a question), errors?, needsApproval?, onConflict, inputs, output?, conflicts, footprint}",
             has_doc,
             check
         ),
@@ -55,7 +55,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Step Into",
             [],
             None,
-            "{action: start|step|continue|runTo|stop|state, name, inputs?, output?, overwrite?, approve?, timeLimit?: seconds per action (start, as macro.run), step: path (runTo), keep?: bool (stop), breakpoints?: [\"3\", \"2.1\"] (steps of the macro), breakpointsOnly?: bool (the list replaces the steps' own breakpoints)} debugs a macro one step at a time; stop keeps the changes as one undo step or rolls them back. Runs on its own, never as a step of a script or macro. Until it finishes or stops, its workbook runs only macro.debug, queries, selection and sheet changes, Go To, Find, Copy, zoom, Switch Window, Close and Stop Action (other workbooks stay editable) → {state: paused|finished|stopped|failed, current: {step, kind, command?, params?, iteration?}, lastParams, executed, changed (at most 500), changedCells, atBreakpoint?, shifted?, wroteFiles?, message?, error?}",
+            "{action: start|step|continue|runTo|stop|state, name, inputs?, onConflict?, overwrite?, approve?, timeLimit?: seconds per action (start, as macro.run), step: path (runTo), keep?: bool (stop), breakpoints?: [\"3\", \"2.1\"] (steps of the macro), breakpointsOnly?: bool (the list replaces the steps' own breakpoints)} debugs a macro one step at a time; stop keeps the changes as one undo step or rolls them back. Runs on its own, never as a step of a script or macro. Until it finishes or stops, its workbook runs only macro.debug, queries, selection and sheet changes, Go To, Find, Copy, zoom, Switch Window, Close and Stop Action (other workbooks stay editable) → {state: paused|finished|stopped|failed, current: {step, kind, command?, params?, iteration?}, lastParams, executed, changed (at most 500), changedCells, atBreakpoint?, shifted?, wroteFiles?, message?, error?}",
             has_doc,
             |s, p| crate::macros::debug::debug(s, p)
         ),
@@ -170,21 +170,7 @@ fn rename(s: &mut Session, p: &Json) -> Result<Json> {
         renamed.name = to.clone();
         // The whole check, size included: a longer name can take a macro past what a file holds.
         crate::macros::check(&renamed).map_err(EngineError::Other)?;
-        let from = std::mem::replace(m, renamed).name;
-        // Buttons that run the macro follow the new name.
-        let runs = |c: &gridcraft_model::FormControl| matches!(&c.action, Some(gridcraft_model::ControlAction::Macro { name, .. }) if name.eq_ignore_ascii_case(&from));
-        for si in 0..cx.wb.sheets.len() {
-            if !cx.wb.sheet(si).is_some_and(|sh| sh.controls.iter().any(runs)) {
-                continue;
-            }
-            for c in cx.sheet_mut(si)?.controls.iter_mut() {
-                if let Some(gridcraft_model::ControlAction::Macro { name, .. }) = &mut c.action
-                    && name.eq_ignore_ascii_case(&from)
-                {
-                    *name = to.clone();
-                }
-            }
-        }
+        *m = renamed;
         Ok(())
     })?;
     Ok(json!({"name": to}))

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

@@ -67,8 +67,6 @@ pub(super) fn insert_pivot_chart(s: &mut Session, p: &Json) -> Result<Json> {
         data_labels: false,
         data_table: None,
         gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
-        hole_size: 75,
-        first_slice_angle: 0,
         style: 1,
         x_title: None,
         y_title: None,

crates/engine/src/cmd/sheet/tabs.rs

@@ -55,12 +55,11 @@ pub(super) fn delete_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 cx.wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
             let Some(sh) = cx.wb.sheet_mut(si) else { continue };
             for (c, f) in keys {
-                // Only formulas whose tree changes are rewritten; the others keep their text.
-                let changed = f.with_expr(|e| Some(gridcraft_formula::adjust::delete_sheet(e.clone(), &name, &order)).filter(|ne| ne != e));
-                if let Some(Some(ne)) = changed
-                    && let Some(cell) = sh.cells.get_mut(c)
-                {
-                    cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
+                if let Some(e) = f.expr() {
+                    let ne = gridcraft_formula::adjust::delete_sheet(e, &name, &order);
+                    if let Some(cell) = sh.cells.get_mut(c) {
+                        cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
+                    }
                 }
             }
         }
@@ -110,12 +109,14 @@ pub(super) fn rename_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                 cx.wb.sheets.get(si).map(|s| s.cells.iter().filter_map(|(c, x)| x.formula.clone().map(|f| (c, f))).collect()).unwrap_or_default();
             let Some(sh) = cx.wb.sheet_mut(si) else { continue };
             for (c, f) in keys {
-                // Compares trees, so unchanged formulas are not printed; they keep their text.
-                let changed = f.with_expr(|e| Some(gridcraft_formula::adjust::rename_sheet(e.clone(), &old, &name)).filter(|ne| ne != e));
-                if let Some(Some(ne)) = changed
-                    && let Some(cell) = sh.cells.get_mut(c)
-                {
-                    cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
+                if let Some(e) = f.expr() {
+                    let ne = gridcraft_formula::adjust::rename_sheet(e, &old, &name);
+                    let text = gridcraft_formula::print(&ne);
+                    if text != f.text
+                        && let Some(cell) = sh.cells.get_mut(c)
+                    {
+                        cell.formula = Some(Arc::new(gridcraft_model::Formula::from_expr(ne)));
+                    }
                 }
             }
             for ch in sh.charts.iter_mut() {
@@ -169,7 +170,7 @@ pub(super) fn move_sheet(s: &mut Session, p: &Json) -> Result<Json> {
             // Object ids are unique across the workbook (selection and the `{kind, id}` commands
             // rely on it), so the copied objects get fresh ones (free ones, even when a file used
             // the largest id).
-            let count = sh.charts.len() + sh.images.len() + sh.shapes.len() + sh.slicers.len() + sh.controls.len();
+            let count = sh.charts.len() + sh.images.len() + sh.shapes.len() + sh.slicers.len();
             let ids = cx.wb.free_object_ids(count);
             if ids.len() < count {
                 return Err(bad("sheet.move", "no free object ids are left for the copied objects"));
@@ -180,7 +181,6 @@ pub(super) fn move_sheet(s: &mut Session, p: &Json) -> Result<Json> {
             sh.images.iter_mut().for_each(|o| o.id = fresh());
             sh.shapes.iter_mut().for_each(|o| o.id = fresh());
             sh.slicers.iter_mut().for_each(|o| o.id = fresh());
-            sh.controls.iter_mut().for_each(|o| o.id = fresh());
             let at = to.min(n);
             // The copy gets its own copies of the sheet's names, referring to the copy.
             let copies: Vec<gridcraft_model::DefinedName> = cx

crates/engine/src/cmd/solver/model.rs

@@ -1,5 +1,3 @@
-use gridcraft_core::split_areas;
-
 use super::{
     CMD, CellRef, DEFAULT_EVALS, DefinedName, EngineError, Json, MAX_CONSTRAINTS, MAX_EVALS, MAX_POPULATION, MAX_VARS, MIN_POPULATION, RangeRef,
     Result, Session, Workbook, bad, bool_param, f64_param, json, split_sheet, str_param,
@@ -140,8 +138,7 @@ pub(super) struct Model {
 fn cells_of(wb: &Workbook, t: &str, default_sheet: usize, cap: usize) -> Result<(usize, Vec<CellRef>)> {
     let mut sheet = None;
     let mut out = Vec::new();
-    // A comma inside a quoted sheet name (`'Sales, West'!$A$1`) does not end the area.
-    for part in split_areas(t).into_iter().map(str::trim).filter(|x| !x.is_empty()) {
+    for part in t.split(',').map(str::trim).filter(|x| !x.is_empty()) {
         let (sh, body) = split_sheet(part);
         let si = match sh {
             Some(n) => wb.sheet_index(&n).ok_or_else(|| bad(CMD, format!("no sheet named `{n}`")))?,
@@ -166,30 +163,14 @@ fn num_text(t: &str) -> Option<f64> {
     gridcraft_core::parse::parse_number_text(t.trim()).filter(|v| v.is_finite())
 }
 
-/// `t` split at the first `pat` outside quoted sheet names: `'A<=B'!$C$1 <= 5` splits at the
-/// second `<=`. A doubled quote inside a name (`'O''Brien<=1'!A1`) toggles the quoted state
-/// twice, as in [`split_areas`], so it doesn't end the name.
-fn split_unquoted<'a>(t: &'a str, pat: &str) -> Option<(&'a str, &'a str)> {
-    let mut quoted = false;
-    for (i, c) in t.char_indices() {
-        if c == '\'' {
-            quoted = !quoted;
-        } else if !quoted && t.get(i..).is_some_and(|rest| rest.starts_with(pat)) {
-            return Some((t.get(..i)?, t.get(i.saturating_add(pat.len())..)?));
-        }
-    }
-    None
-}
-
-/// Splits `"B5 <= 10"` / `"B2 int"` into (lhs, relation, rhs). A relation's characters inside
-/// a quoted sheet name (`'A<=B'!$C$1 <= 5`) are part of the name.
+/// Splits `"B5 <= 10"` / `"B2 int"` into (lhs, relation, rhs).
 fn split_constraint(t: &str) -> Option<(String, Rel, String)> {
     for op in ["<=", ">=", "=<", "=>", "≤", "≥", "=="] {
-        if let Some((a, b)) = split_unquoted(t, op) {
+        if let Some((a, b)) = t.split_once(op) {
             return Some((a.trim().into(), Rel::parse(op)?, b.trim().into()));
         }
     }
-    if let Some((a, b)) = split_unquoted(t, "=") {
+    if let Some((a, b)) = t.split_once('=') {
         return Some((a.trim().into(), Rel::Eq, b.trim().into()));
     }
     let lower = t.trim().to_ascii_lowercase();
@@ -356,8 +337,8 @@ pub fn sensitivity_applies(p: &Json) -> bool {
 /// `"B2:B4,D1"` as absolute references, each qualified by `sheet_name` when given.
 fn abs_text(sheet_name: Option<&str>, cells: &str) -> String {
     let q = sheet_name.map(|n| format!("{}!", crate::pivot::quote_sheet(n))).unwrap_or_default();
-    split_areas(cells)
-        .into_iter()
+    cells
+        .split(',')
         .map(str::trim)
         .filter(|x| !x.is_empty())
         .filter_map(|part| {
@@ -465,7 +446,7 @@ pub fn saved_model(wb: &Workbook, sheet: usize) -> Option<Json> {
     let named = |n: &str, scope: Option<usize>| wb.names.iter().find(|d| d.name.eq_ignore_ascii_case(n) && d.scope == scope);
     let scope = if named("solver_opt", Some(sheet)).is_some() { Some(sheet) } else { None };
     let get = |n: &str| named(n, scope).map(|d| d.formula.trim().trim_start_matches('=').to_string());
-    let local = |t: String| local_refs(&t);
+    let local = |t: String| -> String { t.split(',').map(|p| split_sheet(p.trim()).1.replace('$', "")).collect::<Vec<_>>().join(",") };
     let objective = local(get("solver_opt")?);
     if objective.trim_matches('"').trim().is_empty() {
         return None;
@@ -574,8 +555,7 @@ pub(super) fn model_params(wb: &Workbook, m: &Model) -> Json {
 
 /// The cells Save Model writes, top to bottom, as formula text.
 pub(super) fn model_formulas(m: &Model) -> Result<Vec<String>> {
-    // A comma inside a quoted sheet name (`'Sales, West'!$A$1`) doesn't start another area.
-    let one_area = |t: &str| split_areas(t).into_iter().filter(|a| !a.trim().is_empty()).count() <= 1;
+    let one_area = |t: &str| !t.contains(',');
     let mut rows = Vec::with_capacity(m.cons.len() + 3);
     let obj = abs_text(None, &m.objective.a1());
     rows.push(match m.goal {
@@ -585,8 +565,7 @@ pub(super) fn model_formulas(m: &Model) -> Result<Vec<String>> {
     });
     rows.push(format!("=COUNT({})", abs_text(None, &m.vars_text)));
     for c in &m.cons {
-        // A number on the right side (`1,000`) is no range, whatever its separators.
-        if !one_area(&c.lhs_text) || (matches!(c.rhs, Rhs::Cells(_)) && !one_area(&c.rhs_text)) {
+        if !one_area(&c.lhs_text) || !one_area(&c.rhs_text) {
             return Err(EngineError::Other("Save Model needs each side of a constraint to be one range.".into()));
         }
         let lhs = abs_text(None, &c.lhs_text);
@@ -629,7 +608,7 @@ fn call_args(t: &str, name: &str) -> Option<String> {
 
 /// References without sheet names or `$`.
 fn local_refs(t: &str) -> String {
-    split_areas(t).into_iter().map(|p| split_sheet(p.trim()).1.replace('$', "")).collect::<Vec<_>>().join(",")
+    t.split(',').map(|p| split_sheet(p.trim()).1.replace('$', "")).collect::<Vec<_>>().join(",")
 }
 
 fn not_a_model() -> EngineError {
@@ -691,13 +670,13 @@ fn read_options_row(model: &mut Json, list: &str) -> Result<()> {
 /// One constraint row of Save Model (`AND(relation)`) as a `data.solver` constraint.
 fn read_constraint_row(t: String) -> Result<String> {
     let t = call_args(&t, "AND").unwrap_or(t);
-    if let Some((x, y)) = split_unquoted(&t, "=INT(").or_else(|| split_unquoted(&t, "=int(")) {
+    if let Some((x, y)) = t.split_once("=INT(").or_else(|| t.split_once("=int(")) {
         if y.strip_suffix(')') != Some(x) {
             return Err(not_a_model());
         }
         return Ok(format!("{} int", local_refs(x)));
     }
-    if let Some(x) = t.strip_prefix('(').and_then(|x| x.strip_suffix("=1)")).and_then(|x| split_unquoted(x, "=0)+(")).filter(|(a, b)| a == b) {
+    if let Some(x) = t.strip_prefix('(').and_then(|x| x.strip_suffix("=1)")).and_then(|x| x.split_once("=0)+(")).filter(|(a, b)| a == b) {
         return Ok(format!("{} bin", local_refs(x.0)));
     }
     let (l, rel, r) = split_constraint(&t).ok_or_else(not_a_model)?;
@@ -719,7 +698,7 @@ pub(super) fn parse_model_formulas(rows: &[String]) -> Result<Json> {
     } else if let Some(o) = call_args(&first, "MIN") {
         ("min", o, 0.0)
     } else {
-        let (o, v) = split_unquoted(&first, "=").ok_or_else(not_a_model)?;
+        let (o, v) = first.split_once('=').ok_or_else(not_a_model)?;
         ("value", o.to_string(), num_text(v).ok_or_else(not_a_model)?)
     };
     let variables = call_args(&body(rows.get(1).ok_or_else(not_a_model)?), "COUNT").ok_or_else(not_a_model)?;

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

@@ -1819,133 +1819,3 @@ fn hostile_models_are_refused_without_panicking() {
     let r = s.execute("data.solver", json!({"objective": "D1", "variables": "A1", "maxEvaluations": 1e300})).unwrap();
     assert_ne!(r["status"], "converged");
 }
-
-#[test]
-fn a_comma_inside_a_quoted_sheet_name_does_not_split_a_reference() {
-    // Wyndor Glass on sheets whose names hold a comma (and, for the second, a doubled quote),
-    // solved from Sheet1 with references that carry those names.
-    for (name, quoted) in [("Sales, West", "'Sales, West'"), ("O'Brien, Jr", "'O''Brien, Jr'")] {
-        let mut s = s();
-        s.execute("home.insertSheet", json!({"name": name, "before": 1})).unwrap();
-        s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=3*A1+5*A2"), ("B2", "=2*A2"), ("B3", "=3*A1+2*A2")]);
-        s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-        let r = s
-            .execute(
-                "data.solver",
-                json!({
-                    "objective": format!("{quoted}!$B$1"),
-                    "goal": "max",
-                    "variables": format!("{quoted}!$A$1,{quoted}!$A$2"),
-                    "constraints": [format!("{quoted}!$A$1 <= 4"), format!("{quoted}!$B$2 <= 12"), format!("{quoted}!$B$3 <= 18")],
-                    "method": "simplex",
-                }),
-            )
-            .unwrap_or_else(|e| panic!("{name}: {e}"));
-        assert_eq!(r["status"], "optimal", "{name}: {r}");
-        let sheet = &s.doc().unwrap().wb.sheets[1];
-        let v = |a: &str| sheet.value(CellRef::parse(a).unwrap()).as_f64().unwrap_or(f64::NAN);
-        assert!((v("A1") - 2.0).abs() < 1e-9 && (v("A2") - 6.0).abs() < 1e-9, "{name}");
-        assert!((v("B1") - 36.0).abs() < 1e-9, "{name}");
-        // The saved model keeps both variable cells, and loads back as the same model.
-        let model = super::saved_model(&s.doc().unwrap().wb, 1).unwrap_or_else(|| panic!("{name}: no saved model"));
-        assert_eq!(model["objective"], "B1", "{name}: {model}");
-        assert_eq!(model["variables"], "A1,A2", "{name}: {model}");
-        assert_eq!(model["constraints"][0], "A1 <= 4", "{name}: {model}");
-    }
-}
-
-#[test]
-fn a_relation_inside_a_quoted_sheet_name_does_not_split_a_constraint() {
-    // Wyndor Glass with a third, binary variable (Z = 37 at 2, 6, 1) on sheets whose names hold
-    // a relation, solved from Sheet1 with references that carry those names, under every
-    // relation. One name holds a doubled quote as well, and two the text that marks an integer
-    // or a binary constraint in a model written on cells.
-    for name in ["A<=B", "A>=B", "A=B", "Q1=<Q2", "x≤y", "O'Brien<=1", "n=INT(1", "n=0)+(1"] {
-        let q = gridcraft_core::quote_sheet(name);
-        let mut s = s();
-        s.execute("home.insertSheet", json!({"name": name, "before": 1})).unwrap();
-        s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("A3", "0"), ("B1", "=3*A1+5*A2+A3"), ("B2", "=2*A2"), ("B3", "=3*A1+2*A2")]);
-        s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-        let constraints = [
-            format!("{q}!$A$1 <= 4"),
-            format!("{q}!$B$2 <= 12"),
-            format!("{q}!$B$3 <= 18"),
-            format!("{q}!$A$1 >= 1"),
-            format!("{q}!$A$1 = 2"),
-            format!("{q}!$A$1:$A$2 int"),
-            format!("{q}!$A$3 bin"),
-        ];
-        let model = json!({"objective": format!("{q}!$B$1"), "goal": "max", "variables": format!("{q}!$A$1:$A$3"), "constraints": constraints, "method": "simplex"});
-        let r = s.execute("data.solver", model).unwrap_or_else(|e| panic!("{name}: {e}"));
-        assert_eq!(r["status"], "optimal", "{name}: {r}");
-        assert!((at(&s, name, "B1").as_f64().unwrap_or(f64::NAN) - 37.0).abs() < 1e-9, "{name}");
-        // The saved model holds every constraint whole, and solves again from its sheet.
-        let saved = super::saved_model(&s.doc().unwrap().wb, 1).unwrap_or_else(|| panic!("{name}: no saved model"));
-        assert_eq!(saved["constraints"], json!(["A1 <= 4", "B2 <= 12", "B3 <= 18", "A1 >= 1", "A1 = 2", "A1:A2 int", "A3 bin"]), "{name}: {saved}");
-        s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("A3", "0")]);
-        let r = s.execute("data.solver", json!({"saved": true})).unwrap_or_else(|e| panic!("{name}: {e}"));
-        assert_eq!(r["status"], "optimal", "{name}: {r}");
-        assert!((n(&s, "B1") - 37.0).abs() < 1e-9, "{name}");
-        // An integer constraint is still one, so no Sensitivity report is offered.
-        let p = json!({"method": "simplex", "constraints": [format!("{q}!$A$1 int")]});
-        assert!(!super::sensitivity_applies(&p), "{name}");
-        // A model written on cells with references that carry the name loads whole, a Value Of
-        // goal included.
-        let rows = [
-            format!("=MAX({q}!$B$1)"),
-            format!("=COUNT({q}!$A$1:$A$3)"),
-            format!("=AND({q}!$B$3<=18)"),
-            format!("=AND({q}!$A$1:$A$2=INT({q}!$A$1:$A$2))"),
-            format!("=AND(({q}!$A$3=0)+({q}!$A$3=1))"),
-            "={2,1,100,0.075,0,1,0.0001,50,20000,0}".to_string(),
-        ];
-        for (k, f) in rows.iter().enumerate() {
-            set(&mut s, &[(&format!("H{}", k + 1), f)]);
-        }
-        let m = s.execute("data.solverLoadModel", json!({"from": "H1"})).unwrap_or_else(|e| panic!("{name}: {e}"))["model"].clone();
-        assert_eq!(m["objective"], "B1", "{name}: {m}");
-        assert_eq!(m["constraints"], json!(["B3 <= 18", "A1:A2 int", "A3 bin"]), "{name}: {m}");
-        set(&mut s, &[("J1", &format!("={q}!$B$1=37")), ("J2", &format!("=COUNT({q}!$A$1:$A$3)")), ("J3", &rows[5])]);
-        let m = s.execute("data.solverLoadModel", json!({"from": "J1"})).unwrap_or_else(|e| panic!("{name}: {e}"))["model"].clone();
-        assert_eq!((m["objective"].as_str(), m["goal"].as_str(), m["value"].as_f64()), (Some("B1"), Some("value"), Some(37.0)), "{name}: {m}");
-    }
-}
-
-#[test]
-fn save_model_counts_areas_outside_quoted_sheet_names() {
-    // Wyndor Glass on a sheet whose name holds a comma (and, for the second, a doubled quote),
-    // saved on cells with references that carry the name.
-    for name in ["Sales, West", "O'Brien, Jr"] {
-        let q = gridcraft_core::quote_sheet(name);
-        let mut s = s();
-        s.execute("home.insertSheet", json!({"name": name, "before": 1})).unwrap();
-        s.execute("sheet.activate", json!({"sheet": 1})).unwrap();
-        set(&mut s, &[("A1", "0"), ("A2", "0"), ("B1", "=3*A1+5*A2"), ("B2", "=2*A2"), ("B3", "=3*A1+2*A2"), ("C3", "18")]);
-        let constraints = [
-            format!("{q}!$A$1 <= 4"),
-            format!("{q}!$B$2 <= 12"),
-            format!("{q}!$B$3 <= {q}!$C$3"),
-            format!("{q}!$A$1:$A$2 int"),
-            // A number with a thousands separator is one value, not two areas.
-            format!("{q}!$B$1 <= 1,000"),
-        ];
-        let model = json!({"objective": format!("{q}!$B$1"), "variables": format!("{q}!$A$1:$A$2"), "constraints": constraints, "method": "simplex"});
-        let out = s.execute("data.solverSaveModel", json!({"to": "H1", "model": model})).unwrap_or_else(|e| panic!("{name}: {e}"));
-        assert_eq!(out["range"], "H1:H8", "{name}: {out}");
-        let rows: Vec<String> = (3..=7).map(|r| formula(&s, &format!("H{r}"))).collect();
-        assert_eq!(rows, ["AND($A$1<=4)", "AND($B$2<=12)", "AND($B$3<=$C$3)", "AND($A$1:$A$2=INT($A$1:$A$2))", "AND($B$1<=1000)"], "{name}");
-        // The model loads back from the cells and solves.
-        let loaded = s.execute("data.solverLoadModel", json!({"from": "H1"})).unwrap_or_else(|e| panic!("{name}: {e}"));
-        assert_eq!(loaded["model"]["constraints"], json!(["A1 <= 4", "B2 <= 12", "B3 <= C3", "A1:A2 int", "B1 <= 1000"]), "{name}: {loaded}");
-        let r = s.execute("data.solver", json!({"saved": true})).unwrap_or_else(|e| panic!("{name}: {e}"));
-        assert_eq!(r["status"], "optimal", "{name}: {r}");
-        assert!((n(&s, "B1") - 36.0).abs() < 1e-9, "{name}");
-        // A side of two areas, each carrying the name, is still refused.
-        let two = json!({"objective": format!("{q}!$B$1"), "variables": format!("{q}!$A$1:$A$2"), "constraints": [format!("{q}!$A$1:$A$2 <= {q}!$C$1,{q}!$C$2")]});
-        let e = s.execute("data.solverSaveModel", json!({"to": "J1", "model": two})).unwrap_err().to_string();
-        assert!(e.contains("one range"), "{name}: {e}");
-    }
-}

crates/engine/src/fill.rs

@@ -87,18 +87,6 @@ pub fn holds_source_in_corner(src: RangeRef, target: RangeRef) -> bool {
 
 /// Fills `target` (which contains `src` at one edge) from the pattern in `src`.
 pub fn fill(cx: &mut Ctx, sheet: usize, src: RangeRef, target: RangeRef, mode: FillMode) -> Result<()> {
-    fill_except(cx, sheet, src, target, mode, &std::collections::BTreeSet::new())
-}
-
-/// [`fill`], leaving the rows in `skip_rows` untouched (Fill Down over a filtered range).
-pub fn fill_except(
-    cx: &mut Ctx,
-    sheet: usize,
-    src: RangeRef,
-    target: RangeRef,
-    mode: FillMode,
-    skip_rows: &std::collections::BTreeSet<u32>,
-) -> Result<()> {
     let custom = cx.wb.custom_lists.clone();
     let Some(sh) = cx.wb.sheet(sheet) else { return Ok(()) };
     // Direction: down/up if target extends rows, else right/left.
@@ -131,7 +119,7 @@ pub fn fill_except(
                 (c, sh.cell(c).cloned())
             })
             .collect();
-        let mut targets: Vec<CellRef> = if vertical {
+        let targets: Vec<CellRef> = if vertical {
             let rows: Vec<u32> =
                 if forward { (src.end.row + 1..=target.end.row).collect() } else { (target.start.row..src.start.row).rev().collect() };
             rows.into_iter().map(|r| CellRef::new(r, lane)).collect()
@@ -140,7 +128,6 @@ pub fn fill_except(
                 if forward { (src.end.col + 1..=target.end.col).collect() } else { (target.start.col..src.start.col).rev().collect() };
             cols.into_iter().map(|c| CellRef::new(lane, c)).collect()
         };
-        targets.retain(|t| !skip_rows.contains(&t.row));
         let fmt = |c: &(CellRef, Option<Cell>)| cx.wb.styles.get(c.1.as_ref().map(|c| c.style).unwrap_or_default()).num_fmt.as_str();
         let pattern = if mode.extends_series() || mode == FillMode::Alternate {
             let first_fmt = src_cells.first().map(fmt).unwrap_or_default();

crates/engine/src/io.rs

@@ -123,13 +123,12 @@ fn decrypt_message(name: &str, e: gridcraft_xlsx::DecryptError) -> String {
     }
 }
 
-/// Parses bytes that aren't encrypted, then takes the workbook's macros, and the button actions
-/// xlsx has no place for, out of their hidden names, and adopts the Python cells they hold (see
-/// [`adopt_python`]) within the limits of [`enforce_python_limits`].
+/// Parses bytes that aren't encrypted, then takes the workbook's macros out of their hidden names
+/// and adopts the Python cells they hold (see [`adopt_python`]) within the limits of
+/// [`enforce_python_limits`].
 fn open_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook, Vec<String>)> {
     let (mut wb, mut warnings) = read_plain(name, bytes, csv_as_text)?;
     warnings.extend(crate::macros::load(&mut wb));
-    crate::cmd::controls::load_action_names(&mut wb);
     warnings.extend(adopt_python(&mut wb));
     warnings.extend(enforce_python_limits(&mut wb));
     Ok((wb, warnings))
@@ -494,13 +493,9 @@ pub fn save_bytes_as(wb: &Workbook, path: &str, kind: FileKind) -> Result<Vec<u8
     match kind {
         // The extension picks the package kind; only the macro-enabled kinds (.xlsm, .xltm) carry
         // the VBA project, so any other name saves without it, as Excel does.
-        // Macros, and button actions xlsx has no place for, travel in hidden names.
+        // Macros travel in hidden names.
         FileKind::Xlsx => {
             let named = crate::macros::with_names(wb)?;
-            let named = match crate::cmd::controls::with_action_names(named.as_ref().unwrap_or(wb))? {
-                Some(w) => Some(w),
-                None => named,
-            };
             let book = std::path::Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or_default();
             gridcraft_xlsx::write_xlsx_named(named.as_ref().unwrap_or(wb), gridcraft_xlsx::XlsxKind::from_path(path), book)
                 .map_err(|e| EngineError::Other(e.to_string()))

crates/engine/src/macros/policy.rs

@@ -38,7 +38,6 @@ const DENIED: &[(&str, &str)] = &[
     ("view.newWindow", "macros don't open, hide or show windows"),
     ("view.hideWindow", "macros don't open, hide or show windows"),
     ("view.unhideWindow", "macros don't open, hide or show windows"),
-    ("control.press", "macros don't press form controls"),
 ];
 
 /// Commands under a denied prefix that only change the workbook.
@@ -113,7 +112,6 @@ mod tests {
             "view.newWindow",
             "view.hideWindow",
             "view.unhideWindow",
-            "control.press",
         ] {
             assert!(matches!(macro_policy(id, &none, Trust::Local), Policy::Deny(_)), "{id}");
             assert!(matches!(macro_policy(id, &path, Trust::FromFile), Policy::Deny(_)), "{id}");

crates/engine/src/macros/run.rs

@@ -23,7 +23,7 @@ use std::sync::Arc;
 
 use gridcraft_core::{CellRef, RangeRef, Value};
 use gridcraft_formula::adjust::Edit;
-use gridcraft_model::{Cell, CompareOp, InputKind, MAX_MACRO_REF, Macro, OnConflict, RepeatOf, Sheet, Step, StepKind, Workbook};
+use gridcraft_model::{Cell, CompareOp, InputKind, Macro, OnConflict, RepeatOf, Sheet, Step, StepKind, Workbook};
 use serde::Serialize;
 use serde_json::{Value as Json, json};
 
@@ -539,8 +539,7 @@ impl Guard {
             }
             objects += deleted(&ss.charts, &ps.charts, &sa.charts, |o| o.id)
                 + deleted(&ss.images, &ps.images, &sa.images, |o| o.id)
-                + deleted(&ss.shapes, &ps.shapes, &sa.shapes, |o| o.id)
-                + deleted(&ss.controls, &ps.controls, &sa.controls, |o| o.id);
+                + deleted(&ss.shapes, &ps.shapes, &sa.shapes, |o| o.id);
         }
         if objects > 0 {
             parts.push(format!("{objects} object{}", if objects == 1 { "" } else { "s" }));
@@ -1286,12 +1285,7 @@ fn objects(b: &Sheet, a: &Sheet) -> (usize, usize, usize) {
         let changed = b.iter().filter(|x| a.iter().any(|y| id(y) == id(x) && y != *x)).count();
         (added, changed, removed)
     }
-    let parts = [
-        count(&b.charts, &a.charts, |o| o.id),
-        count(&b.images, &a.images, |o| o.id),
-        count(&b.shapes, &a.shapes, |o| o.id),
-        count(&b.controls, &a.controls, |o| o.id),
-    ];
+    let parts = [count(&b.charts, &a.charts, |o| o.id), count(&b.images, &a.images, |o| o.id), count(&b.shapes, &a.shapes, |o| o.id)];
     parts.iter().fold((0, 0, 0), |t, p| (t.0 + p.0, t.1 + p.1, t.2 + p.2))
 }
 
@@ -1399,7 +1393,6 @@ pub fn begin(s: &mut Session, name: &str, p: &Json) -> Result<Begun> {
     check_params(p, &m)?;
     let asks = gate(&m, trust)?;
     approve(s, &m, doc, &asks, p.get("approve").and_then(Json::as_bool).unwrap_or(false))?;
-    let m = with_output(m, p);
     let prepared = prepare(s, &m, p.get("inputs"))?;
     let rule = conflict_rule(p, &m)?;
     let time_limit_ms = time_limit(p);
@@ -1500,21 +1493,9 @@ pub fn run(s: &mut Session, name: &str, p: &Json) -> Result<Json> {
     })
 }
 
-/// `m` with the run's `output` (a form button that sends the output elsewhere) in place of its own
-/// output anchor, after the policy and the approval, which go by the macro as it is stored. The
-/// anchor is resolved and checked by [`prepare`] like the macro's own, and the footprint, the
-/// conflict rule and the per-step guard all work on the cells it names.
-fn with_output(mut m: Macro, p: &Json) -> Macro {
-    if let Some(o) = p.get("output").and_then(Json::as_str).map(str::trim).filter(|o| !o.is_empty()) {
-        m.output.anchor = Some(o.to_string());
-    }
-    m
-}
-
 /// Refuses run parameters that would otherwise be ignored: an input the macro doesn't have, an
-/// input given as something other than reference text, `onConflict`, `overwrite`, `approve` or
-/// `timeLimit` of the wrong kind, and an `output` that isn't reference text of at most
-/// `MAX_MACRO_REF` characters (`null` counts as not given).
+/// input given as something other than reference text, and `onConflict`, `overwrite`, `approve`
+/// or `timeLimit` of the wrong kind (`null` counts as not given).
 pub fn check_params(p: &Json, m: &Macro) -> Result<()> {
     let refuse = |msg: String| Err(EngineError::Other(format!("Macro '{}': {msg}", m.name)));
     let names = || m.inputs.iter().map(|i| i.name.clone()).collect::<Vec<_>>().join(", ");
@@ -1547,12 +1528,6 @@ pub fn check_params(p: &Json, m: &Macro) -> Result<()> {
             return refuse(format!("`{k}` must be true or false."));
         }
     }
-    if let Some(o) = given("output") {
-        let ok = o.as_str().map(str::trim).is_some_and(|t| !t.is_empty() && t.chars().count() <= MAX_MACRO_REF && !t.chars().any(char::is_control));
-        if !ok {
-            return refuse(format!("`output` must be reference text of at most {MAX_MACRO_REF} characters, such as \"F2\" or \"Sheet2!F2\"."));
-        }
-    }
     if given("timeLimit").is_some_and(|v| !v.as_f64().is_some_and(|t| t > 0.0)) {
         return refuse("`timeLimit` must be a number of seconds above 0.".into());
     }
@@ -1629,7 +1604,7 @@ pub fn check(s: &mut Session, name: &str, p: &Json) -> Result<Json> {
         // Nothing from an unapproved macro runs, not even in a dry run.
         out["needsApproval"] = json!(asks);
     }
-    let prepared = match prepare(s, &with_output(m, p), p.get("inputs")) {
+    let prepared = match prepare(s, &m, p.get("inputs")) {
         Ok(pr) => pr,
         Err(e) => return refused(out, e.to_string()),
     };

crates/engine/src/tests.rs

@@ -2067,19 +2067,6 @@ fn formula_at(s: &Session, a: &str) -> Option<String> {
     s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse(a).unwrap()).and_then(|c| c.formula.as_ref().map(|f| f.text.clone()))
 }
 
-#[test]
-fn autosum_of_a_single_cell_stops_at_a_blank_cell() {
-    // #3291: a blank row between two blocks of numbers ended the guess one block too late, so the
-    // second total summed the first block (and its total) as well.
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "B4", "values": [[1], [2], [3]]})).unwrap();
-    s.execute("cell.set", json!({"cell": "B7", "input": "=SUM(B4:B6)"})).unwrap();
-    s.execute("range.setValues", json!({"range": "B9", "values": [[10], [20]]})).unwrap();
-    s.execute("selection.set", json!({"cell": "B11"})).unwrap();
-    s.execute("formulas.autoSum", json!({})).unwrap();
-    assert_eq!(v(&s, "B11"), Value::Number(30.0));
-}
-
 #[test]
 fn autosum_over_a_row_totals_it_to_the_right() {
     // As in Excel: a row selected and AutoSum puts one total to its right, not a one-cell total
@@ -3143,7 +3130,7 @@ fn calculation_options_enable_iterative_calculation() {
     assert!(!s.doc().unwrap().calc.circular.is_empty());
     // Switching it on recalculates the loop.
     let r = s.execute("formulas.calculationOptions", json!({"iterative": true})).unwrap();
-    assert_eq!(r, json!({"mode": "Automatic", "iterative": true, "maxIterations": 100, "maxChange": 0.001, "precisionAsDisplayed": false}));
+    assert_eq!(r, json!({"mode": "Automatic", "iterative": true, "maxIterations": 100, "maxChange": 0.001}));
     near(&s, "A1", 10.0);
     near(&s, "A2", 10.0);
     assert!(s.doc().unwrap().calc.circular.is_empty());
@@ -3250,21 +3237,6 @@ fn every_chart_kind_survives_xlsx() {
     }
 }
 
-#[test]
-fn chart_set_doughnut_hole_and_angle() {
-    let mut s = s();
-    chart_data(&mut s);
-    s.execute("insert.chart", json!({"type": "doughnut", "range": "A1:B7"})).unwrap();
-    s.execute("chart.set", json!({"holeSize": 5, "firstSliceAngle": 400})).unwrap();
-    s.execute("chart.set", json!({"holeSize": 200})).unwrap();
-    let c = s.doc().unwrap().wb.active().unwrap().charts[0].clone();
-    assert_eq!((c.hole_size, c.first_slice_angle), (90, 40));
-    s.execute("chart.set", json!({"holeSize": 25, "firstSliceAngle": 180})).unwrap();
-    reopen(&mut s);
-    let c = &s.doc().unwrap().wb.active().unwrap().charts[0];
-    assert_eq!((c.kind, c.hole_size, c.first_slice_angle), (gridcraft_model::ChartKind::Doughnut, 25, 180));
-}
-
 #[test]
 fn scatter_of_two_columns_is_one_series_with_the_first_as_x() {
     let mut s = s();
@@ -4183,25 +4155,6 @@ fn a_cut_moves_the_sources_notes_hyperlinks_and_merges() {
     assert!(v(&s, "A1").is_empty() && v(&s, "B1").is_empty());
 }
 
-/// A cell that holds only a hyperlink (its content cleared) is still part of the block: a
-/// cut must carry the link to the destination instead of dropping it with the source.
-#[test]
-fn a_cut_carries_a_link_only_cell() {
-    let mut s = s();
-    s.execute("insert.link", json!({"cell": "A1", "target": "https://example.com"})).unwrap();
-    let a1 = CellRef::parse("A1").unwrap();
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    sh.remove_cell(a1);
-    assert!(sh.cell(a1).is_none(), "A1 holds only the link");
-    s.execute("edit.cut", json!({"range": "A1:B1"})).unwrap();
-    s.execute("edit.paste", json!({"at": "D1"})).unwrap();
-
-    let d = s.doc().unwrap();
-    let sh = d.wb.active().unwrap();
-    assert!(!sh.hyperlinks.contains_key(&CellRef::parse("A1").unwrap()), "the link left the source");
-    assert!(sh.hyperlinks.contains_key(&CellRef::parse("D1").unwrap()), "the link arrived at the destination");
-}
-
 /// Page Layout ▸ Print Titles: naming one axis must not clear the other. `print_titles` read
 /// both `rows` and `cols` into `Option`s and assigned both unconditionally, so
 /// `{"rows":"2:2"}` silently dropped the repeated columns from every printed page.
@@ -4823,420 +4776,6 @@ fn paste_special_validation_moves_relative_references() {
     assert!(ok(&mut s, "C3", "20"));
 }
 
-/// "Set precision as displayed" (formulas.calculationOptions `precisionAsDisplayed`). Behaviour
-/// observed in Excel through COM with synthetic values: turning it on rounds existing constants
-/// and formulas to their formats; constants typed or reformatted while it is on are rounded at
-/// once (permanently: a wider format later doesn't bring digits back); General keeps full
-/// precision; turning it off restores formulas on recalculation, not constants.
-#[test]
-fn precision_as_displayed_option() {
-    let mut s = s();
-    let num = |s: &Session, a: &str| v(s, a).as_f64().unwrap_or(f64::NAN);
-    s.execute("cell.set", json!({"cell": "A1", "input": "1.23456"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A2", "input": "=A1*100"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A3", "input": "=7/3"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A4", "input": "0.333333333333333"})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "A1", "code": "0.00"})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "A3", "code": "0"})).unwrap();
-    assert_eq!((num(&s, "A1"), num(&s, "A3")), (1.23456, 7.0 / 3.0));
-    let r = s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    assert_eq!(r["precisionAsDisplayed"], true);
-    assert_eq!((num(&s, "A1"), num(&s, "A2"), num(&s, "A3"), num(&s, "A4")), (1.23, 123.0, 2.0, 0.333333333333333));
-    let r = s.execute("file.options", json!({})).unwrap();
-    assert_eq!(r["calculation"]["precisionAsDisplayed"], true);
-    // Typed while on: rounded to the cell's format, and dependents read the rounded value.
-    s.execute("cell.set", json!({"cell": "A1", "input": "4.56789"})).unwrap();
-    assert_eq!((num(&s, "A1"), num(&s, "A2")), (4.57, 457.0));
-    s.execute("range.setValues", json!({"range": "A1", "values": [[5.43219]]})).unwrap();
-    assert_eq!(num(&s, "A1"), 5.43);
-    // Reformatting while on rounds a constant and a formula at once.
-    s.execute("cell.set", json!({"cell": "B1", "input": "1.23456"})).unwrap();
-    s.execute("cell.set", json!({"cell": "B2", "input": "=1.23456"})).unwrap();
-    s.execute("cell.set", json!({"cell": "B3", "input": "=B1*100"})).unwrap();
-    assert_eq!(num(&s, "B1"), 1.23456);
-    s.execute("home.numberFormat", json!({"range": "B1:B2", "code": "0.0"})).unwrap();
-    assert_eq!((num(&s, "B1"), num(&s, "B2"), num(&s, "B3")), (1.2, 1.2, 120.0));
-    // The constant's digits are gone for good; the formula is rounded again from its result.
-    s.execute("home.numberFormat", json!({"range": "B1:B2", "code": "0.0000"})).unwrap();
-    assert_eq!((num(&s, "B1"), num(&s, "B2")), (1.2, 1.2346));
-    // Undo brings the unrounded constant back.
-    s.execute("edit.undo", json!({})).unwrap();
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(num(&s, "B1"), 1.23456);
-    // Saved with the workbook, and applied on recalculation after reopening.
-    reopen(&mut s);
-    assert!(s.doc().unwrap().wb.calc.precision_as_displayed);
-    assert_eq!(num(&s, "A3"), 2.0);
-    // Off: formulas get their full precision back, constants stay rounded.
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": false})).unwrap();
-    assert_eq!((num(&s, "A1"), num(&s, "A3")), (5.43, 7.0 / 3.0));
-}
-
-/// Reformatting a cell a dynamic array spills into rounds that element as displayed: the cell
-/// holds no stored value (the spill lives in `Sheet::spill`), so the edit changes only its
-/// style, and the anchor must be recalculated for the element to be rounded.
-#[test]
-fn precision_as_displayed_rounds_a_reformatted_spill_cell() {
-    let mut s = s();
-    let num = |s: &Session, a: &str| v(s, a).as_f64().unwrap_or(f64::NAN);
-    s.execute("cell.set", json!({"cell": "F1", "input": "=SEQUENCE(3,1,0.123,0.111)"})).unwrap();
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    s.execute("cell.set", json!({"cell": "G1", "input": "=SUM(F1:F3)"})).unwrap();
-    let (f2, f3) = (0.123 + 0.111, 0.123 + 0.111 * 2.0);
-    assert_eq!((num(&s, "F1"), num(&s, "F2"), num(&s, "F3")), (0.123, f2, f3));
-    // Formatting a spill destination (the anchor is not in the edit) rounds just that element.
-    s.execute("home.numberFormat", json!({"range": "F2", "code": "0.0"})).unwrap();
-    assert_eq!((num(&s, "F1"), num(&s, "F2"), num(&s, "F3")), (0.123, 0.2, f3));
-    assert_eq!(num(&s, "G1"), 0.123 + 0.2 + f3);
-    // A range covering anchor and spill, and a whole column, round every element.
-    s.execute("home.numberFormat", json!({"range": "F:F", "code": "0.00"})).unwrap();
-    assert_eq!((num(&s, "F1"), num(&s, "F2"), num(&s, "F3")), (0.12, 0.23, 0.35));
-    assert_eq!(num(&s, "G1"), 0.12 + 0.23 + 0.35);
-    // Formatting a cell that no spill covers changes nothing.
-    s.execute("home.numberFormat", json!({"range": "F4", "code": "0.0"})).unwrap();
-    assert_eq!(num(&s, "F3"), 0.35);
-}
-#[test]
-fn precision_as_displayed_enable_undoes_in_one_step() {
-    let mut s = s();
-    let num = |s: &Session, a: &str| v(s, a).as_f64().unwrap_or(f64::NAN);
-    s.execute("cell.set", json!({"cell": "A1", "input": "1.23456"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A2", "input": "=A1*100"})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "A1", "code": "0.00"})).unwrap();
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    assert_eq!((num(&s, "A1"), num(&s, "A2")), (1.23, 123.0));
-    // One undo brings back the constants and the flag together.
-    s.execute("edit.undo", json!({})).unwrap();
-    assert!(!s.doc().unwrap().wb.calc.precision_as_displayed);
-    assert_eq!((num(&s, "A1"), num(&s, "A2")), (1.23456, 1.23456 * 100.0));
-}
-
-#[test]
-fn precision_as_displayed_applies_in_manual_mode() {
-    let mut s = s();
-    let num = |s: &Session, a: &str| v(s, a).as_f64().unwrap_or(f64::NAN);
-    s.execute("cell.set", json!({"cell": "A1", "input": "1.23456"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A2", "input": "=A1*100"})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "A1", "code": "0.00"})).unwrap();
-    s.execute("formulas.calculationOptions", json!({"mode": "manual"})).unwrap();
-    // Turning it on rounds the values at once, without a calculation.
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    assert_eq!((num(&s, "A1"), num(&s, "A2")), (1.23, 123.0));
-    // Turning it off recalculates at once too: the formula reads the rounded constant.
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": false})).unwrap();
-    assert_eq!((num(&s, "A1"), num(&s, "A2")), (1.23, 1.23 * 100.0));
-}
-
-#[test]
-fn precision_as_displayed_on_a_protected_sheet_keeps_locked_constants() {
-    let mut s = s();
-    let num = |s: &Session, a: &str| v(s, a).as_f64().unwrap_or(f64::NAN);
-    s.execute("cell.set", json!({"cell": "A1", "input": "1.23456"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A2", "input": "=A1*100"})).unwrap();
-    s.execute("cell.set", json!({"cell": "B1", "input": "1.23456"})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "A1:B1", "code": "0.00"})).unwrap();
-    s.execute("home.lockCell", json!({"range": "B1", "on": false})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    // Turning the option on is not refused: the locked constant keeps its digits, the unlocked
-    // one is rounded.
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    assert!(s.doc().unwrap().wb.calc.precision_as_displayed);
-    assert_eq!((num(&s, "A1"), num(&s, "B1"), num(&s, "A2")), (1.23456, 1.23, 1.23456 * 100.0));
-    // Reformatting a locked constant, on a sheet that allows formatting, keeps its digits too.
-    s.execute("review.unprotectSheet", json!({})).unwrap();
-    s.execute("review.protectSheet", json!({"formatCells": true})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "A1", "code": "0.0"})).unwrap();
-    assert_eq!(num(&s, "A1"), 1.23456);
-}
-
-#[test]
-fn precision_as_displayed_rounds_a_legacy_array_by_each_cell() {
-    let mut s = s();
-    let num = |s: &Session, a: &str| v(s, a).as_f64().unwrap_or(f64::NAN);
-    s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2]]})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "B1", "code": "0.00"})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "B2", "code": "0.0"})).unwrap();
-    s.execute("selection.set", json!({"range": "B1:B2"})).unwrap();
-    s.execute("cell.set", json!({"input": "=A1:A2/3", "array": true})).unwrap();
-    assert_eq!((num(&s, "B1"), num(&s, "B2")), (1.0 / 3.0, 2.0 / 3.0));
-    // Each element takes the format of the cell it lands in.
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    assert_eq!((num(&s, "B1"), num(&s, "B2")), (0.33, 0.7));
-}
-
-#[test]
-fn precision_as_displayed_rounds_numbers_written_to_a_new_sheet() {
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2], [4], [7], [3], [5]]})).unwrap();
-    // Histogram output on a new sheet, with the option off, keeps full precision.
-    s.execute("data.analysisToolPak", json!({"tool": "histogram", "range": "Sheet1!A1:A6", "cumulative": true, "newSheet": "Raw"})).unwrap();
-    let raw: Vec<(CellRef, f64)> = {
-        let d = s.doc().unwrap();
-        let sh = d.wb.sheet(d.wb.sheet_index("Raw").unwrap()).unwrap();
-        sh.cells
-            .iter()
-            .filter_map(|(c, cell)| match cell.value {
-                Value::Number(n) if cell.formula.is_none() => Some((c, n)),
-                _ => None,
-            })
-            .collect()
-    };
-    s.execute("formulas.calculationOptions", json!({"precisionAsDisplayed": true})).unwrap();
-    s.execute("data.analysisToolPak", json!({"tool": "histogram", "range": "Sheet1!A1:A6", "cumulative": true, "newSheet": "Rounded"})).unwrap();
-    let d = s.doc().unwrap();
-    let si = d.wb.sheet_index("Rounded").unwrap();
-    let sh = d.wb.sheet(si).unwrap();
-    let mut prec = gridcraft_calc::DisplayedPrecision::new();
-    let mut rounded = 0;
-    for (c, n) in &raw {
-        let want = prec.round(&d.wb, si, *c, *n);
-        assert_eq!(sh.value(*c), Value::Number(want), "{c:?}");
-        rounded += usize::from(want != *n);
-    }
-    // Cumulative shares of six values are sixths, which the percent format rounds.
-    assert!(rounded > 0, "the histogram's formatted cells should be rounded");
-}
-
-/// #1101: repeating one cell or row down a filtered selection (paste, Ctrl+Enter, Fill Down) skips
-/// the rows the filter hides, as in Excel. A taller pasted block goes straight down, and rows
-/// hidden by hand are written, also as in Excel (each case measured in Excel for Microsoft 365).
-#[test]
-fn fills_and_single_row_pastes_skip_filtered_rows() {
-    let fresh = s;
-    let filtered = || {
-        let mut s = fresh();
-        let mut rows = vec![json!(["Val", "Tag"])];
-        for i in 2..=11 {
-            rows.push(json!([format!("v{i}"), if [3, 5, 7, 9].contains(&i) { "hide" } else { "keep" }]));
-        }
-        s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-        s.execute("range.setValues", json!({"range": "E1", "values": [["X", "W"], ["Y", ""]]})).unwrap();
-        s.execute("selection.set", json!({"range": "A1:B1"})).unwrap();
-        s.execute("data.filter", json!({})).unwrap();
-        assert_eq!(s.execute("data.filterBy", json!({"column": "B", "values": ["keep"]})).unwrap()["hiddenRows"], 4);
-        s
-    };
-    let col = |s: &Session, c: &str| -> Vec<Value> { (2..=11).map(|r| v(s, &format!("{c}{r}"))).collect() };
-    let skipped =
-        |x: &str| -> Vec<Value> { (2..=11).map(|r| Value::from(if [3, 5, 7, 9].contains(&r) { format!("v{r}") } else { x.to_string() })).collect() };
-
-    // One cell pasted over the filtered rows.
-    let mut s = filtered();
-    s.execute("edit.copy", json!({"range": "E1"})).unwrap();
-    s.execute("selection.set", json!({"range": "A2:A11"})).unwrap();
-    s.execute("edit.paste", json!({})).unwrap();
-    assert_eq!(col(&s, "A"), skipped("X"));
-
-    // One row (two cells) pasted over the filtered rows.
-    let mut s = filtered();
-    s.execute("edit.copy", json!({"range": "E1:F1"})).unwrap();
-    s.execute("selection.set", json!({"range": "A2:B11"})).unwrap();
-    s.execute("edit.paste", json!({})).unwrap();
-    assert_eq!(col(&s, "A"), skipped("X"));
-    assert_eq!(v(&s, "B3"), Value::from("hide"));
-    assert_eq!(v(&s, "B4"), Value::from("W"));
-
-    // A two-row block is pasted straight down, hidden rows included.
-    let mut s = filtered();
-    s.execute("edit.copy", json!({"range": "E1:E2"})).unwrap();
-    s.execute("selection.set", json!({"range": "A2:A11"})).unwrap();
-    s.execute("edit.paste", json!({})).unwrap();
-    assert_eq!(col(&s, "A"), ["X", "Y", "X", "Y", "X", "Y", "X", "Y", "X", "Y"].map(Value::from));
-
-    // Ctrl+Enter.
-    let mut s = filtered();
-    s.execute("selection.set", json!({"range": "A2:A11"})).unwrap();
-    s.execute("range.fill", json!({"input": "Z"})).unwrap();
-    assert_eq!(col(&s, "A"), skipped("Z"));
-
-    // Fill Down, and a formula filled down still adjusts to the row it lands in.
-    let mut s = filtered();
-    s.execute("edit.fillDown", json!({"range": "A2:A11"})).unwrap();
-    assert_eq!(col(&s, "A"), skipped("v2"));
-    s.execute("cell.set", json!({"cell": "C2", "input": "=ROW()"})).unwrap();
-    s.execute("edit.fillDown", json!({"range": "C2:C11"})).unwrap();
-    assert_eq!(v(&s, "C4"), Value::Number(4.0));
-    assert!(v(&s, "C3").is_empty());
-
-    // Fill Up and Fill Right skip them too.
-    let mut s = filtered();
-    s.execute("edit.fillUp", json!({"range": "A2:A11"})).unwrap();
-    assert_eq!(col(&s, "A"), skipped("v11"));
-    let mut s = filtered();
-    s.execute("range.setValues", json!({"range": "C2", "values": [["c2"], ["c3"], ["c4"]]})).unwrap();
-    s.execute("edit.fillRight", json!({"range": "A2:C4"})).unwrap();
-    assert_eq!([v(&s, "C2"), v(&s, "C3"), v(&s, "C4")], [Value::from("v2"), Value::from("c3"), Value::from("v4")]);
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(v(&s, "C4"), Value::from("c4"));
-
-    // Copying the filtered range takes only the rows showing, formulas as their values; a cut
-    // still moves every row.
-    let mut s = filtered();
-    s.execute("cell.set", json!({"cell": "C2", "input": "=ROW()"})).unwrap();
-    s.execute("edit.fillDown", json!({"range": "C2:C11"})).unwrap();
-    let r = s.execute("edit.copy", json!({"range": "A1:C11"})).unwrap();
-    assert_eq!(
-        r["text"],
-        "Val	Tag	
-v2	keep	2
-v4	keep	4
-v6	keep	6
-v8	keep	8
-v10	keep	10
-v11	keep	11
-"
-    );
-    s.execute("edit.paste", json!({"at": "H20"})).unwrap();
-    let pasted: Vec<Value> = (20..=27).map(|r| v(&s, &format!("H{r}"))).collect();
-    assert_eq!(pasted, ["Val", "v2", "v4", "v6", "v8", "v10", "v11"].map(Value::from).into_iter().chain([Value::Empty]).collect::<Vec<_>>());
-    assert_eq!(v(&s, "J22"), Value::Number(4.0));
-    assert!(s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse("J22").unwrap()).unwrap().formula.is_none());
-    let mut s = filtered();
-    s.execute("edit.cut", json!({"range": "A1:B11"})).unwrap();
-    s.execute("edit.paste", json!({"at": "H20"})).unwrap();
-    assert_eq!(v(&s, "H22"), Value::from("v3"));
-
-    // Rows hidden by hand (no filter) are written, as in Excel.
-    let mut s = fresh();
-    s.execute("range.setValues", json!({"range": "A1", "values": [["a"], ["b"], ["c"]]})).unwrap();
-    s.execute("home.hideRows", json!({"rows": "2:2"})).unwrap();
-    s.execute("selection.set", json!({"range": "A1:A3"})).unwrap();
-    s.execute("range.fill", json!({"input": "Z"})).unwrap();
-    assert_eq!(v(&s, "A2"), Value::from("Z"));
-}
-
-/// A table of ten rows (A1:B11) with a link on every value cell, four of its rows hidden by a
-/// filter (3, 5, 7, 9), and a spare corner at E1 to copy from.
-fn filtered_rows_with_links() -> Session {
-    let mut s = s();
-    let mut rows = vec![json!(["Val", "Tag"])];
-    for i in 2..=11 {
-        rows.push(json!([format!("v{i}"), if [3, 5, 7, 9].contains(&i) { "hide" } else { "keep" }]));
-    }
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    s.execute("range.setValues", json!({"range": "E1", "values": [["X"]]})).unwrap();
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    for r in 2..=11u32 {
-        sh.hyperlinks
-            .insert(CellRef::new(r - 1, 0), gridcraft_model::Hyperlink { target: format!("https://example.com/{r}"), tooltip: None, external: true });
-    }
-    s.execute("selection.set", json!({"range": "A1:B1"})).unwrap();
-    s.execute("data.filter", json!({})).unwrap();
-    s.execute("data.filterBy", json!({"column": "B", "values": ["keep"]})).unwrap();
-    s
-}
-
-fn cell_link_target(s: &Session, cell: &str) -> Option<String> {
-    s.doc().unwrap().wb.active().unwrap().hyperlinks.get(&CellRef::parse(cell).unwrap()).map(|h| h.target.clone())
-}
-
-fn cell_validation(s: &Session, cell: &str) -> Option<String> {
-    let c = CellRef::parse(cell).unwrap();
-    s.doc().unwrap().wb.active().unwrap().validations.iter().find(|d| d.ranges.iter().any(|r| r.contains(c))).map(|d| d.f1.clone())
-}
-
-/// Copying a filtered range packs the rows showing into one block; their links and validation
-/// rules travel with them, and those of the hidden rows are left behind.
-#[test]
-fn filtered_copy_pastes_links_and_validation_of_the_rows_showing_only() {
-    let mut s = filtered_rows_with_links();
-    for (cell, source) in [("A3", "\"hidden\""), ("A4", "\"showing\""), ("A9", "\"hidden too\"")] {
-        s.execute("data.validation", json!({"range": cell, "type": "list", "formula1": source})).unwrap();
-    }
-    s.execute("edit.copy", json!({"range": "A1:B11"})).unwrap();
-    s.execute("edit.paste", json!({"at": "H20"})).unwrap();
-    let links: Vec<Option<String>> = (20..=26).map(|r| cell_link_target(&s, &format!("H{r}"))).collect();
-    let expected: Vec<Option<String>> =
-        [None, Some(2u32), Some(4), Some(6), Some(8), Some(10), Some(11)].iter().map(|n| n.map(|n| format!("https://example.com/{n}"))).collect();
-    assert_eq!(links, expected);
-    let rules: Vec<Option<String>> = (20..=26).map(|r| cell_validation(&s, &format!("H{r}"))).collect();
-    assert_eq!(rules, [None, None, Some("\"showing\"".to_string()), None, None, None, None]);
-    // The source keeps its own links and rules where they were.
-    assert_eq!(cell_link_target(&s, "A3").as_deref(), Some("https://example.com/3"));
-    assert_eq!(cell_validation(&s, "A3").as_deref(), Some("\"hidden\""));
-}
-
-/// One cell pasted over a filtered column leaves the rules of the rows the filter hides alone, and
-/// does not give them the copied rule, with or without Skip Blanks.
-#[test]
-fn single_row_paste_over_filtered_rows_leaves_their_validation_alone() {
-    for skip_blanks in [false, true] {
-        let mut s = filtered_rows_with_links();
-        s.execute("data.validation", json!({"range": "E1", "type": "list", "formula1": "\"copied\""})).unwrap();
-        s.execute("data.validation", json!({"range": "A2:A5", "type": "list", "formula1": "\"old\""})).unwrap();
-        s.execute("edit.copy", json!({"range": "E1"})).unwrap();
-        s.execute("selection.set", json!({"range": "A2:A11"})).unwrap();
-        s.execute("edit.pasteSpecial", json!({"what": "all", "skipBlanks": skip_blanks})).unwrap();
-        let rules: Vec<Option<String>> = (2..=11).map(|r| cell_validation(&s, &format!("A{r}"))).collect();
-        let showing = Some("\"copied\"".to_string());
-        let old = Some("\"old\"".to_string());
-        assert_eq!(
-            rules,
-            [showing.clone(), old.clone(), showing.clone(), old, showing.clone(), None, showing.clone(), None, showing.clone(), showing],
-            "skip blanks: {skip_blanks}"
-        );
-    }
-}
-
-/// Insert Copied Cells after a filtered copy of whole rows makes room for the rows copied, not for
-/// the rows that were selected.
-#[test]
-fn insert_copied_cells_after_a_filtered_row_copy_inserts_only_the_rows_showing() {
-    let mut s = filtered_rows_with_links();
-    s.execute("cell.set", json!({"cell": "A30", "input": "below"})).unwrap();
-    s.execute("edit.copy", json!({"range": "1:11"})).unwrap();
-    s.execute("selection.set", json!({"range": "A20"})).unwrap();
-    s.execute("home.insertCopiedCells", json!({})).unwrap();
-    // Seven rows were copied (the header and six rows showing).
-    assert_eq!(v(&s, "A37"), Value::from("below"));
-    assert_eq!(v(&s, "A20"), Value::from("Val"));
-    assert_eq!(v(&s, "A26"), Value::from("v11"));
-    assert_eq!(v(&s, "A27"), Value::Empty);
-}
-
-/// Copying a filtered range with many separate runs of rows showing moves each row's note, link and
-/// merge with it, and leaves the hidden rows' behind.
-#[test]
-fn filtered_copy_with_many_runs_moves_notes_and_merges_with_their_rows() {
-    let mut s = s();
-    let mut rows = vec![json!(["Val", "Tag"])];
-    for i in 2..=2001 {
-        rows.push(json!([format!("v{i}"), if i % 2 == 1 { "hide" } else { "keep" }]));
-    }
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    for r in 2..=2001u32 {
-        let note = gridcraft_model::Comment {
-            author: "a".into(),
-            text: format!("note {r}"),
-            replies: vec![],
-            threaded: false,
-            resolved: false,
-            visible: false,
-            dates: vec![],
-            note_box: None,
-        };
-        sh.comments.insert(CellRef::new(r - 1, 0), note);
-    }
-    sh.merges.push(gridcraft_core::RangeRef::new(CellRef::new(3, 1), CellRef::new(3, 2)));
-    sh.merges.push(gridcraft_core::RangeRef::new(CellRef::new(2, 1), CellRef::new(2, 2)));
-    s.execute("selection.set", json!({"range": "A1:B1"})).unwrap();
-    s.execute("data.filter", json!({})).unwrap();
-    s.execute("data.filterBy", json!({"column": "B", "values": ["keep"]})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:C2001"})).unwrap();
-    s.execute("edit.paste", json!({"at": "H1"})).unwrap();
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    let note = |row: u32| sh.comments.get(&CellRef::new(row - 1, 7)).map(|c| c.text.clone());
-    assert_eq!(note(1), None);
-    assert_eq!(note(2).as_deref(), Some("note 2"));
-    assert_eq!(note(3).as_deref(), Some("note 4"));
-    assert_eq!(note(1001).as_deref(), Some("note 2000"));
-    assert_eq!(sh.comments.keys().filter(|c| c.col == 7).count(), 1000);
-    // Only the merge on a row showing (row 4) came along, packed to the row it landed in (row 3).
-    assert!(sh.merges.contains(&gridcraft_core::RangeRef::new(CellRef::new(2, 8), CellRef::new(2, 9))));
-    assert_eq!(sh.merges.iter().filter(|m| m.start.col >= 7).count(), 1);
-}
-
 #[test]
 fn editing_quote_prefixed_text_keeps_it_text() {
     let mut s = s();
@@ -5286,243 +4825,6 @@ fn csv_as_text_keeps_identifier_columns_as_written() {
     assert_eq!(crate::io::base64_decode(saved["base64"].as_str().unwrap()).unwrap(), csv.replace('\n', "\r\n").as_bytes());
 }
 
-fn validation_areas(s: &Session) -> Vec<String> {
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    let mut out: Vec<String> = sh.validations.iter().map(|dv| dv.ranges.iter().map(|r| r.a1()).collect::<Vec<_>>().join(" ")).collect();
-    out.sort();
-    out
-}
-
-/// ft-3ir.10.16: pasting whole columns walked every one of their 1,048,576 rows and added one
-/// single-cell validation rule per pasted cell, re-cutting every rule each time (the fuzz run
-/// aborted on a 34 GB allocation). Validation now pastes as ranges and only cells that hold
-/// something are visited.
-#[test]
-fn whole_column_paste_with_validation_works_on_ranges() {
-    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;
-    s.execute("cell.set", json!({"cell": "C1", "input": "1"})).unwrap();
-    s.execute("cell.set", json!({"cell": "D1048576", "input": "2"})).unwrap();
-    s.execute("cell.set", json!({"cell": "F100", "input": "old"})).unwrap();
-    s.execute("data.validation", json!({"range": "C:C", "type": "whole", "operator": "greater", "formula1": "0"})).unwrap();
-    s.execute("data.validation", json!({"range": "F:H", "type": "list", "formula1": "\"a,b\""})).unwrap();
-    s.execute("edit.copy", json!({"range": "C:D"})).unwrap();
-    s.execute("edit.paste", json!({"at": "F1"})).unwrap();
-    assert_eq!(v(&s, "F1"), Value::Number(1.0));
-    assert_eq!(v(&s, "G1048576"), Value::Number(2.0));
-    assert_eq!(v(&s, "F100"), Value::Empty, "the whole column is replaced, below the copied text too");
-    // One rule per copied rule, over whole columns; G (D had no rule) has none; H keeps the list.
-    assert_eq!(validation_areas(&s), ["C:C", "F:F", "H:H"]);
-    assert!(!ok(&mut s, "F500", "-1"));
-    assert!(ok(&mut s, "G500", "anything"));
-    assert!(!ok(&mut s, "H500", "c"));
-    assert_eq!(s.doc().unwrap().selection.a1(), "F:G");
-    // Undo gives the list back over F:H.
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(validation_areas(&s), ["C:C", "F:H"]);
-    assert_eq!(v(&s, "F100"), Value::Text("old".into()));
-}
-
-/// Paste Link of whole columns links the cells the columns hold, wherever they start.
-#[test]
-fn paste_link_of_whole_columns_links_the_used_rows() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "C5", "input": "1"})).unwrap();
-    s.execute("cell.set", json!({"cell": "C6", "input": "2"})).unwrap();
-    s.execute("edit.copy", json!({"range": "C:C"})).unwrap();
-    s.execute("edit.pasteSpecial", json!({"what": "all", "link": true, "at": "F1"})).unwrap();
-    assert_eq!(v(&s, "F1"), Value::Number(0.0), "a link to a blank cell reads 0");
-    assert_eq!(v(&s, "F5"), Value::Number(1.0));
-    assert_eq!(v(&s, "F6"), Value::Number(2.0));
-    assert_eq!(s.execute("cell.get", json!({"cell": "F5"})).unwrap()["input"], json!("=C5"));
-}
-
-/// A transposed paste clears the destination cells that line up with blank source cells.
-#[test]
-fn transposed_paste_clears_destination_cells_under_blank_source_cells() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "1"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A2", "input": "3"})).unwrap();
-    s.execute("cell.set", json!({"cell": "B2", "input": "4"})).unwrap();
-    s.execute("cell.set", json!({"cell": "E2", "input": "old"})).unwrap();
-    s.execute("cell.set", json!({"cell": "F1", "input": "older"})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:B2"})).unwrap();
-    s.execute("edit.pasteSpecial", json!({"what": "all", "transpose": true, "at": "E1"})).unwrap();
-    assert_eq!(v(&s, "E1"), Value::Number(1.0));
-    assert_eq!(v(&s, "E2"), Value::Empty, "B1 was blank");
-    assert_eq!(v(&s, "F1"), Value::Number(3.0));
-    assert_eq!(v(&s, "F2"), Value::Number(4.0));
-}
-
-/// A copy tiled over a larger selection clears the non-blank destination cells under its blanks,
-/// in every tile.
-#[test]
-fn tiled_paste_clears_destination_cells_under_blank_source_cells() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "1"})).unwrap();
-    s.execute("cell.set", json!({"cell": "C2", "input": "x"})).unwrap();
-    s.execute("cell.set", json!({"cell": "C4", "input": "y"})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:A2"})).unwrap();
-    s.execute("selection.set", json!({"range": "C1:C4"})).unwrap();
-    s.execute("edit.paste", json!({})).unwrap();
-    assert_eq!(v(&s, "C1"), Value::Number(1.0));
-    assert_eq!(v(&s, "C2"), Value::Empty);
-    assert_eq!(v(&s, "C3"), Value::Number(1.0));
-    assert_eq!(v(&s, "C4"), Value::Empty);
-}
-
-/// Excel refuses a paste that would run off the sheet rather than pasting part of it: whole
-/// columns below row 1, whole rows right of column A, a whole column transposed, or a block at
-/// the last row or column.
-#[test]
-fn paste_that_does_not_fit_on_the_sheet_is_refused() {
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "C1", "values": [[1, 2], [3, 4]]})).unwrap();
-    s.execute("cell.set", json!({"cell": "A15", "input": "x"})).unwrap();
-    let before = s.doc().unwrap().wb.clone();
-    s.execute("edit.copy", json!({"range": "C:D"})).unwrap();
-    assert!(s.execute("edit.paste", json!({"at": "B8"})).is_err());
-    assert!(s.execute("edit.pasteSpecial", json!({"what": "all", "transpose": true, "at": "A1"})).is_err());
-    s.execute("edit.copy", json!({"range": "15:15"})).unwrap();
-    assert!(s.execute("edit.paste", json!({"at": "AN17"})).is_err());
-    s.execute("edit.copy", json!({"range": "C1:D2"})).unwrap();
-    assert!(s.execute("edit.paste", json!({"at": "XFD1"})).is_err());
-    assert!(s.execute("edit.paste", json!({"at": "A1048576"})).is_err());
-    s.execute("edit.cut", json!({"range": "C1:D2"})).unwrap();
-    assert!(s.execute("edit.paste", json!({"at": "XFD1"})).is_err());
-    let after = s.doc().unwrap().wb.clone();
-    assert_eq!(after.active().unwrap().cells.len(), before.active().unwrap().cells.len());
-    assert_eq!(v(&s, "C1"), Value::Number(1.0));
-    // Whole rows still paste at column A, whole columns at row 1.
-    s.execute("edit.copy", json!({"range": "15:15"})).unwrap();
-    s.execute("edit.paste", json!({"at": "A20"})).unwrap();
-    assert_eq!(v(&s, "A20"), Value::Text("x".into()));
-}
-
-/// Paste visits only cells that hold something on either side: a blank copied cell still clears
-/// (or reformats) a destination cell that holds something, and blank onto blank stays blank, even
-/// with an operation (Excel leaves it empty rather than writing 0).
-#[test]
-fn paste_blank_cells_clear_destination_and_blank_onto_blank_stays_blank() {
-    let mut s = s();
-    let has_cell = |s: &Session, a: &str| s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse(a).unwrap()).is_some();
-    s.execute("cell.set", json!({"cell": "A1", "input": "5"})).unwrap();
-    s.execute("cell.set", json!({"cell": "D2", "input": "7"})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:A3"})).unwrap();
-    s.execute("edit.pasteSpecial", json!({"what": "values", "operation": "add", "at": "D1"})).unwrap();
-    assert_eq!(v(&s, "D1"), Value::Number(5.0));
-    assert_eq!(v(&s, "D2"), Value::Number(7.0));
-    assert!(!has_cell(&s, "D3"), "blank + blank stays blank");
-    s.execute("cell.set", json!({"cell": "F2", "input": "old"})).unwrap();
-    s.execute("edit.paste", json!({"at": "F1"})).unwrap();
-    assert_eq!(v(&s, "F1"), Value::Number(5.0));
-    assert!(!has_cell(&s, "F2"), "a blank copied cell clears the destination");
-    s.execute("home.bold", json!({"range": "H2"})).unwrap();
-    assert!(has_cell(&s, "H2"));
-    s.execute("edit.pasteSpecial", json!({"what": "formats", "at": "H1"})).unwrap();
-    assert!(!has_cell(&s, "H2"), "a blank copied cell's format replaces the bold");
-}
-
-/// Validation pastes over the whole pasted area (a blank copied cell's rule included, as Excel
-/// does), and cuts only the pasted cells out of a rule the block lands inside.
-#[test]
-fn paste_validation_covers_the_pasted_area_as_ranges() {
-    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;
-    s.execute("cell.set", json!({"cell": "A1", "input": "5"})).unwrap();
-    s.execute("cell.set", json!({"cell": "A3", "input": "6"})).unwrap();
-    s.execute("data.validation", json!({"range": "A1:A3", "type": "whole", "operator": "greater", "formula1": "0"})).unwrap();
-    s.execute("data.validation", json!({"range": "D1:D3", "type": "list", "formula1": "\"x,y\""})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:A3"})).unwrap();
-    s.execute("edit.pasteSpecial", json!({"what": "all", "skipBlanks": true, "at": "D1"})).unwrap();
-    assert!(!ok(&mut s, "D2", "-1"), "the blank copied cell's rule is pasted too");
-    assert!(ok(&mut s, "D2", "3"));
-    assert_eq!(validation_areas(&s), ["A1:A3", "D1:D3"]);
-
-    // A block with a rule on its middle cells pasted inside a bigger list rule.
-    let mut s = self::s();
-    s.execute("data.validation", json!({"range": "A2:A3", "type": "whole", "operator": "greater", "formula1": "0"})).unwrap();
-    s.execute("data.validation", json!({"range": "C1:E10", "type": "list", "formula1": "\"p,q\""})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:A4"})).unwrap();
-    s.execute("edit.paste", json!({"at": "D4"})).unwrap();
-    assert_eq!(validation_areas(&s), ["A2:A3", "C1:E3 C4:C7 E4:E7 C8:E10", "D5:D6"]);
-    assert!(ok(&mut s, "D4", "anything"));
-    assert!(!ok(&mut s, "D5", "-1"));
-    assert!(!ok(&mut s, "D3", "z"));
-
-    // One copied cell tiled over a selection is one rule over the selection.
-    s.execute("edit.copy", json!({"range": "A2"})).unwrap();
-    s.execute("selection.set", json!({"range": "G1:G4"})).unwrap();
-    s.execute("edit.paste", json!({})).unwrap();
-    assert!(validation_areas(&s).contains(&"G1:G4".to_string()));
-}
-
-/// Paste Special > Validation, checked against Excel 16.0: A1 has a list rule, A2 is blank with a
-/// whole-number rule, A3 is blank with no rule, over C1:C3 that hold a decimal rule. With Skip
-/// Blanks a blank source cell that has a rule still pastes it, and one without keeps the
-/// destination's rule; without it the destination's rule is cleared.
-#[test]
-fn paste_validation_skip_blanks_keeps_rules_under_blank_cells_without_one() {
-    let ok = |s: &mut Session, cell: &str, input: &str| s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == true;
-    for skip in [true, false] {
-        let mut s = s();
-        s.execute("data.validation", json!({"range": "A1", "type": "list", "formula1": "\"x,y\""})).unwrap();
-        s.execute("data.validation", json!({"range": "A2", "type": "whole", "operator": "greater", "formula1": "0"})).unwrap();
-        s.execute("data.validation", json!({"range": "C1:C3", "type": "decimal", "operator": "greater", "formula1": "0"})).unwrap();
-        s.execute("edit.copy", json!({"range": "A1:A3"})).unwrap();
-        s.execute("edit.pasteSpecial", json!({"what": "validation", "skipBlanks": skip, "at": "C1"})).unwrap();
-        assert!(!ok(&mut s, "C1", "z"), "C1 gets A1's list rule (skip {skip})");
-        assert!(!ok(&mut s, "C2", "1.5"), "C2 gets A2's whole-number rule (skip {skip})");
-        assert_eq!(ok(&mut s, "C3", "-1"), !skip, "C3 keeps its decimal rule only when blanks are skipped");
-    }
-}
-
-/// A big populated Skip Blanks validation paste is not refused for its cell count: only
-/// validation areas are limited, and with no rule under the paste nothing is cleared.
-#[test]
-fn paste_validation_skip_blanks_large_populated_paste() {
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "A1:A100002", "values": (0..100_002).map(|i| vec![i]).collect::<Vec<_>>()})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:A100002"})).unwrap();
-    s.execute("edit.pasteSpecial", json!({"what": "validation", "skipBlanks": true, "at": "C1"})).unwrap();
-    assert!(validation_areas(&s).is_empty());
-
-    // A destination rule is cleared under every populated source cell. Count the resulting
-    // coalesced ranges, not the 100,002 cells that were considered for clearing.
-    let mut s = self::s();
-    s.execute("range.setValues", json!({"range": "A1:A100002", "values": (0..100_002).map(|i| vec![i]).collect::<Vec<_>>()})).unwrap();
-    s.execute("data.validation", json!({"range": "C1:C100002", "type": "list", "formula1": "\"x,y\""})).unwrap();
-    s.execute("edit.copy", json!({"range": "A1:A100002"})).unwrap();
-    s.execute("edit.pasteSpecial", json!({"what": "validation", "skipBlanks": true, "at": "C1"})).unwrap();
-    assert!(validation_areas(&s).is_empty());
-}
-
-/// A whole-column copy of a filtered range takes only the rows showing, also when they form one
-/// block (the hidden rows are all at the end) and the selection covers the whole column.
-#[test]
-fn whole_column_copy_of_a_filtered_range_leaves_the_hidden_rows_out() {
-    for hidden_tail in [false, true] {
-        let mut s = s();
-        let mut rows = vec![json!(["Val", "Tag"])];
-        for i in 2..=11 {
-            let hide = if hidden_tail { i >= 8 } else { [3, 5, 7, 9].contains(&i) };
-            rows.push(json!([format!("v{i}"), if hide { "hide" } else { "keep" }]));
-        }
-        s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-        s.execute("selection.set", json!({"range": "A1:B1"})).unwrap();
-        s.execute("data.filter", json!({})).unwrap();
-        s.execute("data.filterBy", json!({"column": "B", "values": ["keep"]})).unwrap();
-        s.execute("cell.set", json!({"cell": "H30", "input": "old"})).unwrap();
-        s.execute("edit.copy", json!({"range": "A:B"})).unwrap();
-        s.execute("edit.paste", json!({"at": "H1"})).unwrap();
-        let col: Vec<Value> = (1..=11).map(|r| v(&s, &format!("H{r}"))).collect();
-        let want: Vec<&str> =
-            if hidden_tail { vec!["Val", "v2", "v3", "v4", "v5", "v6", "v7"] } else { vec!["Val", "v2", "v4", "v6", "v8", "v10", "v11"] };
-        let want: Vec<Value> = want.into_iter().map(Value::from).chain(std::iter::repeat(Value::Empty)).take(11).collect();
-        assert_eq!(col, want, "hidden rows stay out of a whole-column copy (hidden tail: {hidden_tail})");
-    }
-}
-
 /// Open a workbook by path, and `CELL("filename")` names the file it came from, as Excel does;
 /// Save As makes the new file the one it names. The sheet-name formula of #1489 depends on it.
 #[test]
@@ -6112,7 +5414,6 @@ fn a_script_cannot_switch_windows() {
     assert_eq!(v(&s, "A1"), Value::number(2.0));
 }
 
-mod controls;
 mod equation;
 mod macros;
 mod objects;

crates/engine/src/tests/controls.rs

@@ -1,847 +0,0 @@
-//! Form controls: buttons, sliders and spin buttons (insert, format, assign, setValue, press).
-
-use gridcraft_core::Value;
-use gridcraft_model::{ControlAction, ControlKind, FormControl, MacroInput};
-use serde_json::{Value as Json, json};
-
-use super::{s, v};
-use crate::{EngineError, Session, Trust};
-
-fn id(r: &Json) -> u64 {
-    r["control"].as_u64().unwrap()
-}
-
-fn control(s: &Session, id: u64) -> FormControl {
-    s.doc().unwrap().wb.active().unwrap().controls.iter().find(|c| c.id as u64 == id).cloned().unwrap()
-}
-
-fn undo_len(s: &Session) -> usize {
-    s.doc().unwrap().undo.len()
-}
-
-fn err(r: crate::Result<Json>) -> String {
-    r.unwrap_err().to_string()
-}
-
-#[test]
-fn numbers_are_whole_and_each_rule_has_its_own_error() {
-    let mut s = s();
-    let ok = s.execute("insert.slider", json!({"at": "D2", "min": 10, "max": 50, "step": 5, "page": 10})).unwrap();
-    let c = control(&s, id(&ok));
-    assert_eq!((c.kind, c.min, c.max, c.step, c.page, c.value), (ControlKind::Slider, 10, 50, 5, 10, 10));
-    for (p, needle) in [
-        (json!({"min": 2.5}), "`min` must be a whole number from 0 to 30000"),
-        (json!({"min": -1}), "`min` must be a whole number"),
-        (json!({"max": 30001}), "`max` must be a whole number from 0 to 30000"),
-        (json!({"step": "two"}), "`step` must be a whole number"),
-        (json!({"max": 1e300}), "`max` must be a whole number"),
-        (json!({"min": 50, "max": 50}), "Maximum value (50) must be greater than Minimum value (50)"),
-        (json!({"min": 60, "max": 50}), "must be greater than Minimum"),
-        (json!({"step": 0}), "Incremental change must be at least 1"),
-        (json!({"min": 0, "max": 10, "step": 11}), "Incremental change (11) can be at most Maximum minus Minimum (10)"),
-        (json!({"step": 5, "page": 2}), "Page change (2) must be at least the incremental change (5)"),
-        (json!({"link": "not a cell"}), "isn't a cell of this workbook"),
-        (json!({"link": "Nowhere!A1"}), "isn't a cell of this workbook"),
-        (json!({"link": "A1:B2"}), "isn't a cell"),
-    ] {
-        let e = err(s.execute("insert.slider", p.clone()));
-        assert!(e.contains(needle), "{p}: {e}");
-    }
-    // A spin button has no page change, so a page below the step is fine.
-    s.execute("insert.spinButton", json!({"step": 5, "page": 2})).unwrap();
-    // Numbers in text are numbers.
-    let n = id(&s.execute("insert.spinButton", json!({"min": "3", "max": "9"})).unwrap());
-    let c = control(&s, n);
-    assert_eq!((c.min, c.max, c.value), (3, 9, 3));
-    // A larger step pulls a slider's default page up with it.
-    let n = id(&s.execute("insert.slider", json!({"max": 1000, "step": 50})).unwrap());
-    let c = control(&s, n);
-    assert_eq!(c.page, 50);
-    // The model checks the same rules.
-    let bad = FormControl { kind: ControlKind::Spin, min: 0, max: 30_001, ..Default::default() };
-    assert!(bad.check_numbers().is_err());
-    assert!(FormControl { kind: ControlKind::Button, max: 0, ..Default::default() }.check_numbers().is_ok());
-}
-
-#[test]
-fn set_value_clamps_snaps_and_writes_the_link_as_one_undo_step() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "C1", "input": "=B1*2"})).unwrap();
-    let c = id(&s.execute("insert.slider", json!({"link": "B1", "min": 10, "max": 100, "step": 5})).unwrap());
-    assert_eq!(control(&s, c).link.as_deref(), Some("$B$1"));
-    let before = undo_len(&s);
-    for (given, want) in [(37.0, 35.0), (38.0, 40.0), (-5.0, 10.0), (1e9, 100.0), (99.0, 100.0), (12.4, 10.0)] {
-        let r = s.execute("control.setValue", json!({"id": c, "value": given})).unwrap();
-        assert_eq!(r["value"], json!(want as u32), "{given}");
-        assert_eq!(v(&s, "B1"), Value::Number(want), "{given}");
-        assert_eq!(v(&s, "C1"), Value::Number(want * 2.0), "dependents recalculate");
-        assert_eq!(control(&s, c).value, want as u32);
-    }
-    assert_eq!(undo_len(&s), before + 5, "one undo step per change (99 snaps to the 100 it holds)");
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(v(&s, "B1"), Value::Number(100.0));
-    assert_eq!(control(&s, c).value, 100);
-    // Setting the value it already has adds no step.
-    let n = undo_len(&s);
-    s.execute("control.setValue", json!({"id": c, "value": 100})).unwrap();
-    assert_eq!(undo_len(&s), n);
-    for p in [json!({"id": c}), json!({"id": c, "value": "x"}), json!({"id": 999, "value": 1}), json!({"value": 1})] {
-        assert!(s.execute("control.setValue", p).is_err());
-    }
-    // A button has no value.
-    let b = id(&s.execute("insert.button", json!({})).unwrap());
-    assert!(err(s.execute("control.setValue", json!({"id": b, "value": 1}))).contains("control.press"));
-}
-
-#[test]
-fn editing_the_linked_cell_moves_the_control() {
-    let mut s = s();
-    let c = id(&s.execute("insert.spinButton", json!({"link": "$B$2", "max": 20, "step": 2})).unwrap());
-    s.execute("cell.set", json!({"cell": "B2", "input": "7"})).unwrap();
-    assert_eq!(control(&s, c).value, 8, "snapped to the step");
-    s.execute("cell.set", json!({"cell": "B2", "input": "500"})).unwrap();
-    assert_eq!(control(&s, c).value, 20, "clamped");
-    s.execute("cell.set", json!({"cell": "B2", "input": "text"})).unwrap();
-    assert_eq!(control(&s, c).value, 20, "text leaves it where it was");
-    // A new control starts at what its cell holds.
-    s.execute("cell.set", json!({"cell": "D4", "input": "12"})).unwrap();
-    let d = id(&s.execute("insert.slider", json!({"link": "D4", "max": 20})).unwrap());
-    assert_eq!(control(&s, d).value, 12);
-    // A linked cell on another sheet.
-    s.execute("home.insertSheet", json!({"name": "Data Sheet"})).unwrap();
-    s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-    let e = id(&s.execute("insert.slider", json!({"link": "'Data Sheet'!a1", "value": 30})).unwrap());
-    assert_eq!(control(&s, e).link.as_deref(), Some("'Data Sheet'!$A$1"));
-    let wb = &s.doc().unwrap().wb;
-    let other = wb.sheet(wb.sheet_index("Data Sheet").unwrap()).unwrap();
-    assert_eq!(other.cell(gridcraft_core::CellRef::new(0, 0)).unwrap().value, Value::Number(30.0));
-}
-
-#[test]
-fn format_replies_with_the_value_a_new_link_gives() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "C5", "input": "30"})).unwrap();
-    let c = id(&s.execute("insert.slider", json!({"link": "B1", "max": 100, "value": 10})).unwrap());
-    // Relinked to a cell that holds another number, the control takes that number, and the reply
-    // says so, as control.list does.
-    let r = s.execute("control.format", json!({"id": c, "link": "C5"})).unwrap();
-    assert_eq!(control(&s, c).value, 30);
-    assert_eq!(r["value"], json!(30), "{r}");
-    assert_eq!(r["link"], json!("$C$5"), "{r}");
-    // A given value is written to the new link and replied as given.
-    let r = s.execute("control.format", json!({"id": c, "link": "D6", "value": 44})).unwrap();
-    assert_eq!((r["value"].clone(), v(&s, "D6")), (json!(44), Value::Number(44.0)));
-}
-
-#[test]
-fn links_follow_inserted_rows() {
-    let mut s = s();
-    let c = id(&s.execute("insert.slider", json!({"at": "E2", "link": "B3", "value": 40})).unwrap());
-    s.execute("selection.set", json!({"range": "1:1"})).unwrap();
-    s.execute("home.insertRows", json!({})).unwrap();
-    let ctl = control(&s, c);
-    assert_eq!(ctl.link.as_deref(), Some("$B$4"));
-    assert_eq!(ctl.anchor.cell.a1(), "E3");
-    assert_eq!(v(&s, "B4"), Value::Number(40.0));
-    s.execute("control.setValue", json!({"id": c, "value": 41})).unwrap();
-    assert_eq!(v(&s, "B4"), Value::Number(41.0));
-}
-
-#[test]
-fn format_and_assign() {
-    let mut s = s();
-    let c = id(&s.execute("insert.slider", json!({"link": "B1", "max": 100, "value": 80})).unwrap());
-    let r = s.execute("control.format", json!({"id": c, "max": 50, "name": "Rate", "horizontal": false})).unwrap();
-    assert_eq!(
-        (r["max"].clone(), r["value"].clone(), r["name"].clone(), r["horizontal"].clone()),
-        (json!(50), json!(50), json!("Rate"), json!(false))
-    );
-    assert_eq!(v(&s, "B1"), Value::Number(50.0), "the new maximum pulls the linked value in");
-    assert!(err(s.execute("control.format", json!({"id": c, "min": 50}))).contains("greater than Minimum"));
-    assert_eq!(control(&s, c).min, 0, "a refused change leaves the control as it was");
-    s.execute("control.format", json!({"id": c, "link": ""})).unwrap();
-    assert_eq!(control(&s, c).link, None);
-    s.execute("control.format", json!({"id": c, "value": 25})).unwrap();
-    assert_eq!(v(&s, "B1"), Value::Number(50.0), "without a link nothing is written");
-    // Buttons: text and action.
-    // A fixed input needs a macro that takes one.
-    s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "x"}}], "inputs": [{"name": "Input", "kind": "range"}]})).unwrap();
-    let b = id(&s.execute("insert.button", json!({"text": "Go", "macro": "Fill", "input": "C2:D4", "output": "F2"})).unwrap());
-    let action = control(&s, b).action;
-    assert_eq!(action, Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Fixed("C2:D4".into()), output: Some("F2".into()) }));
-    s.execute("control.assign", json!({"id": b, "command": "home.bold", "params": {"range": "A1"}})).unwrap();
-    assert!(matches!(control(&s, b).action, Some(ControlAction::Command { ref id, .. }) if id == "home.bold"));
-    assert!(err(s.execute("control.assign", json!({"id": b, "command": "file.saveAs"}))).contains("can't run file.saveAs"));
-    assert!(err(s.execute("control.assign", json!({"id": b, "command": "control.press", "params": {"id": b}}))).contains("can't run control.press"));
-    assert!(err(s.execute("control.assign", json!({"id": b, "command": "no.such"}))).contains("no command"));
-    assert!(err(s.execute("control.assign", json!({"id": b, "macro": "Fill", "input": "nonsense!!"}))).contains("`input`"));
-    assert!(err(s.execute("control.assign", json!({"id": b}))).contains("clear"));
-    assert!(err(s.execute("control.assign", json!({"id": c, "macro": "Fill"}))).contains("only buttons"));
-    s.execute("control.assign", json!({"id": b, "clear": true})).unwrap();
-    assert_eq!(control(&s, b).action, None);
-    // Renaming the macro keeps the button pointing at it.
-    s.execute("control.assign", json!({"id": b, "macro": "fill"})).unwrap();
-    s.execute("macro.rename", json!({"name": "Fill", "to": "Fill Block"})).unwrap();
-    assert!(matches!(control(&s, b).action, Some(ControlAction::Macro { ref name, .. }) if name == "Fill Block"));
-    let list = s.execute("control.list", json!({})).unwrap();
-    assert_eq!(list.as_array().map(Vec::len), Some(2));
-    assert_eq!(list[1]["text"], json!("Go"));
-}
-
-#[test]
-fn pressing_a_button_runs_its_macro_as_one_undo_step() {
-    let mut s = s();
-    s.execute(
-        "macro.save",
-        json!({"name": "Mark", "inputs": [{"name": "Input", "kind": "range"}], "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "done"}}], "output": {"onConflict": "overwrite"}}),
-    )
-    .unwrap();
-    let b = id(&s.execute("insert.button", json!({"macro": "Mark"})).unwrap());
-    s.execute("selection.set", json!({"range": "C3:D4"})).unwrap();
-    let before = undo_len(&s);
-    let r = s.execute("control.press", json!({"id": b})).unwrap();
-    assert_eq!(r["macro"], json!("Mark"));
-    assert_eq!(v(&s, "C3"), Value::text("done"));
-    assert_eq!(undo_len(&s), before + 1);
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(v(&s, "C3"), Value::Empty);
-    // A fixed input ignores the selection.
-    s.execute("control.assign", json!({"id": b, "macro": "Mark", "input": "F6:G7"})).unwrap();
-    s.execute("control.press", json!({"id": b})).unwrap();
-    assert_eq!((v(&s, "F6"), v(&s, "C3")), (Value::text("done"), Value::Empty));
-    // No action, a missing macro, not a button.
-    let empty = id(&s.execute("insert.button", json!({"text": "Nothing"})).unwrap());
-    assert!(err(s.execute("control.press", json!({"id": empty}))).contains("has no action"));
-    s.execute("control.assign", json!({"id": empty, "macro": "Gone"})).unwrap();
-    assert!(err(s.execute("control.press", json!({"id": empty}))).contains("no macro called"));
-    let spin = id(&s.execute("insert.spinButton", json!({})).unwrap());
-    assert!(err(s.execute("control.press", json!({"id": spin}))).contains("only buttons"));
-}
-
-#[test]
-fn a_command_button_goes_through_the_policy_with_the_documents_trust() {
-    let mut s = s();
-    let b = id(&s.execute("insert.button", json!({"command": "cell.set", "params": {"cell": "A1", "input": "7"}})).unwrap());
-    // A workbook made here runs it straight away, as one undo step.
-    let before = undo_len(&s);
-    s.execute("control.press", json!({"id": b})).unwrap();
-    assert_eq!(v(&s, "A1"), Value::Number(7.0));
-    assert_eq!(undo_len(&s), before + 1);
-    s.execute("edit.undo", json!({})).unwrap();
-    // From a file: it asks first, once.
-    s.doc_mut().unwrap().trust = Trust::FromFile;
-    match s.execute("control.press", json!({"id": b})) {
-        Err(EngineError::Approve(q)) => assert!(q.contains("came with a workbook you opened"), "{q}"),
-        other => panic!("expected a question, got {other:?}"),
-    }
-    assert_eq!(v(&s, "A1"), Value::Empty, "nothing ran");
-    s.execute("control.press", json!({"id": b, "approve": true})).unwrap();
-    assert_eq!(v(&s, "A1"), Value::Number(7.0));
-    s.execute("cell.set", json!({"cell": "A1", "input": ""})).unwrap();
-    s.execute("control.press", json!({"id": b})).unwrap();
-    assert_eq!(v(&s, "A1"), Value::Number(7.0), "approved for the session");
-    // A command that reads a file always asks.
-    s.doc_mut().unwrap().trust = Trust::Local;
-    let f = id(&s.execute("insert.button", json!({"command": "data.fromTextCsv", "params": {"path": "/nonexistent/x.csv"}})).unwrap());
-    assert!(matches!(s.execute("control.press", json!({"id": f})), Err(EngineError::Approve(q)) if q.contains("reads a file")));
-    // A denied command that a file brought in never runs.
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    if let Some(c) = sh.controls.iter_mut().find(|c| c.id as u64 == f) {
-        c.action = Some(ControlAction::Command { id: "file.saveAs".into(), params: json!({"path": "/tmp/x.xlsx"}) });
-    }
-    assert!(err(s.execute("control.press", json!({"id": f, "approve": true}))).contains("can't run file.saveAs"));
-    // A macro button in a file's workbook asks too (the runner's gate).
-    s.execute(
-        "macro.save",
-        json!({"name": "M", "steps": [{"command": "cell.set", "params": {"cell": "B1", "input": "1"}}], "output": {"onConflict": "overwrite"}}),
-    )
-    .unwrap();
-    let m = id(&s.execute("insert.button", json!({"macro": "M"})).unwrap());
-    s.doc_mut().unwrap().trust = Trust::FromFile;
-    assert!(matches!(s.execute("control.press", json!({"id": m})), Err(EngineError::Approve(_))));
-    s.execute("control.press", json!({"id": m, "approve": true})).unwrap();
-    assert_eq!(v(&s, "B1"), Value::Number(1.0));
-}
-
-#[test]
-fn a_file_commands_approval_question_names_the_file() {
-    let mut s = s();
-    let b = id(&s.execute("insert.button", json!({"command": "file.exportCsv", "params": {"path": "/tmp/reports/q3 totals.csv"}})).unwrap());
-    match s.execute("control.press", json!({"id": b})) {
-        Err(EngineError::Approve(q)) => assert!(q.contains("writes a file (/tmp/reports/q3 totals.csv)"), "{q}"),
-        other => panic!("expected a question, got {other:?}"),
-    }
-    // A long path is shortened in the middle, and line breaks can't hide part of it.
-    let long = format!("/tmp/{}\n{}.csv", "a".repeat(300), "b".repeat(300));
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    if let Some(c) = sh.controls.iter_mut().find(|c| c.id as u64 == b) {
-        c.action = Some(ControlAction::Command { id: "file.exportCsv".into(), params: json!({"path": long}) });
-    }
-    match s.execute("control.press", json!({"id": b})) {
-        Err(EngineError::Approve(q)) => {
-            assert!(q.contains("(/tmp/aaa") && q.contains("…") && q.contains("bbb.csv)") && !q.contains('\n') && q.len() < 600, "{q}")
-        }
-        other => panic!("expected a question, got {other:?}"),
-    }
-    // Without a path the question is unchanged.
-    let plain = id(&s.execute("insert.button", json!({"command": "cell.set", "params": {"cell": "A1", "input": "1"}})).unwrap());
-    s.doc_mut().unwrap().trust = Trust::FromFile;
-    match s.execute("control.press", json!({"id": plain})) {
-        Err(EngineError::Approve(q)) => assert!(q.ends_with("came with a workbook you opened."), "{q}"),
-        other => panic!("expected a question, got {other:?}"),
-    }
-}
-
-#[test]
-fn hostile_params_are_refused() {
-    let mut s = s();
-    let c = id(&s.execute("insert.slider", json!({"width": 1e30, "height": -5, "at": "XFD1048576"})).unwrap());
-    let a = control(&s, c).anchor;
-    assert_eq!((a.width, a.height), (10_000.0, 4.0));
-    let long = "x".repeat(2_000);
-    assert!(s.execute("insert.button", json!({"text": long})).is_err());
-    assert!(s.execute("insert.button", json!({"text": 5})).is_err());
-    assert!(s.execute("insert.button", json!({"command": "cell.set", "params": [1]})).is_err());
-    assert!(s.execute("control.format", json!({"id": c, "link": 5})).is_err());
-    assert!(s.execute("control.format", json!({"id": c, "value": f64::MAX})).is_err());
-    assert!(s.execute("control.setValue", json!({"id": c, "value": f64::MIN})).is_ok());
-    assert_eq!(control(&s, c).value, 0);
-    // Snapping keeps the maximum reachable when the step doesn't divide the range.
-    let odd = FormControl { kind: ControlKind::Spin, min: 0, max: 10, step: 3, ..Default::default() };
-    assert_eq!((odd.snap(9.4), odd.snap(9.6), odd.snap(f64::NAN)), (9, 10, 0));
-}
-
-fn link(s: &Session, sheet_i: usize, id: u64) -> String {
-    let sh = s.doc().unwrap().wb.sheet(sheet_i).unwrap();
-    sh.controls.iter().find(|c| c.id as u64 == id).and_then(|c| c.link.clone()).unwrap_or_default()
-}
-
-#[test]
-fn links_follow_inserts_deletes_renames_and_cut_moves() {
-    let mut s = s();
-    s.execute("home.insertSheet", json!({"name": "Data"})).unwrap();
-    // A control on Data pointing back at Sheet1.
-    let back = id(&s.execute("insert.spinButton", json!({"at": "C3", "link": "Sheet1!$B$2"})).unwrap());
-    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-    let local = id(&s.execute("insert.slider", json!({"at": "E2", "link": "$B$2"})).unwrap());
-    let remote = id(&s.execute("insert.spinButton", json!({"at": "E6", "link": "Data!$A$1"})).unwrap());
-
-    s.execute("home.insertRows", json!({"rows": "1:1"})).unwrap();
-    s.execute("home.insertColumns", json!({"cols": "A:A"})).unwrap();
-    assert_eq!(link(&s, 0, local), "$C$3");
-    assert_eq!(link(&s, 1, back), "Sheet1!$C$3");
-    assert_eq!(link(&s, 0, remote), "Data!$A$1", "edits on Sheet1 leave links into Data alone");
-
-    s.execute("cell.set", json!({"cell": "C3", "input": "7"})).unwrap();
-    s.execute("edit.cut", json!({"range": "C3"})).unwrap();
-    s.execute("edit.paste", json!({"at": "G9"})).unwrap();
-    assert_eq!(link(&s, 0, local), "$G$9", "a cut-move takes the link with the cell");
-    assert_eq!(link(&s, 1, back), "Sheet1!$G$9");
-
-    s.execute("sheet.rename", json!({"sheet": 1, "name": "Inputs"})).unwrap();
-    assert_eq!(link(&s, 0, remote), "Inputs!$A$1");
-    s.execute("home.deleteRows", json!({"rows": "9:9"})).unwrap();
-    assert!(link(&s, 0, local).contains("#REF!"), "{}", link(&s, 0, local));
-    s.execute("home.deleteSheet", json!({"sheet": 1})).unwrap();
-    assert!(link(&s, 0, remote).contains("#REF!"), "{}", link(&s, 0, remote));
-    // A link to a deleted cell writes nothing.
-    s.execute("control.setValue", json!({"id": local, "value": 5})).unwrap();
-    for _ in 0..3 {
-        s.execute("edit.undo", json!({})).unwrap();
-    }
-    assert_eq!((link(&s, 0, local), link(&s, 0, remote)), ("$G$9".to_string(), "Inputs!$A$1".to_string()));
-}
-
-#[test]
-fn the_object_commands_leave_a_locked_control_on_a_protected_sheet_alone() {
-    let mut s = s();
-    let locked = id(&s.execute("insert.slider", json!({"at": "D2", "link": "B1"})).unwrap());
-    let other = id(&s.execute("insert.spinButton", json!({"at": "D8"})).unwrap());
-    let free = id(&s.execute("insert.button", json!({"at": "D12"})).unwrap());
-    s.execute("control.format", json!({"id": free, "locked": false})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    let before = s.doc().unwrap().wb.clone();
-    for (cmd, p) in [
-        ("object.move", json!({"kind": "control", "id": locked, "at": "H9"})),
-        ("object.delete", json!({"kind": "control", "id": locked})),
-        ("object.setAnchorMode", json!({"kind": "control", "id": locked, "mode": "absolute"})),
-        ("arrange.bringForward", json!({"kind": "control", "id": locked, "toFront": true})),
-        ("arrange.sendBackward", json!({"kind": "control", "id": locked})),
-        ("arrange.align", json!({"kind": "control", "ids": [locked, other], "align": "left"})),
-    ] {
-        assert!(err(s.execute(cmd, p)).contains("protected"), "{cmd}");
-    }
-    assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before), "nothing changed");
-    // An unlocked control still moves, as in Excel.
-    s.execute("object.move", json!({"kind": "control", "id": free, "at": "H12"})).unwrap();
-    assert_eq!(control(&s, free).anchor.cell.a1(), "H12");
-}
-
-#[test]
-fn a_locked_control_on_a_protected_sheet_cannot_be_changed() {
-    let mut s = s();
-    let c = id(&s.execute("insert.slider", json!({"link": "B1"})).unwrap());
-    let b = id(&s.execute("insert.button", json!({})).unwrap());
-    s.execute("review.protectSheet", json!({})).unwrap();
-    assert!(err(s.execute("control.format", json!({"id": c, "max": 50}))).contains("protected"));
-    assert!(err(s.execute("control.assign", json!({"id": b, "command": "home.bold"}))).contains("protected"));
-}
-
-fn reopen(s: &mut Session) {
-    let r = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap();
-    let b64 = r["base64"].as_str().unwrap().to_string();
-    s.execute("file.open", json!({"name": "x.xlsx", "base64": b64})).unwrap();
-}
-
-#[test]
-fn a_kept_button_action_comes_back_only_on_the_same_button() {
-    use crate::cmd::controls::{load_action_names, with_action_names};
-    let mut s = s();
-    s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}]})).unwrap();
-    s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap();
-    s.execute("insert.button", json!({"at": "D6", "text": "Other"})).unwrap();
-    s.execute("insert.button", json!({"at": "D9", "text": "Fixed", "macro": "Mark", "input": "F1:G2"})).unwrap();
-    let wb = (*s.doc().unwrap().wb).clone();
-    let stored = with_action_names(&wb).unwrap().unwrap();
-    let actions = |wb: &gridcraft_model::Workbook| wb.sheet(0).unwrap().controls.iter().map(|c| c.action.clone()).collect::<Vec<_>>();
-    let kept = |wb: &gridcraft_model::Workbook| {
-        let mut wb = wb.clone();
-        for c in &mut wb.sheet_mut(0).unwrap().controls {
-            // As xlsx carries them: a macro on the selection, or nothing for a command.
-            c.action = match c.action.take() {
-                Some(ControlAction::Macro { name, .. }) => Some(ControlAction::Macro { name, input: MacroInput::Selection, output: None }),
-                _ => None,
-            };
-        }
-        wb
-    };
-    // The same buttons in the same places get their actions back.
-    let mut same = kept(&stored);
-    load_action_names(&mut same);
-    assert_eq!(actions(&same), actions(&wb));
-    // Another application removed the first button: the command must not move to "Other".
-    let mut shifted = kept(&stored);
-    shifted.sheet_mut(0).unwrap().controls.remove(0);
-    load_action_names(&mut shifted);
-    assert_eq!(shifted.sheets[0].controls[0].action, None, "the command stays with the removed button");
-    // A button given another macro there keeps it; a command doesn't replace a macro either.
-    let mut reassigned = kept(&stored);
-    for i in [0, 2] {
-        reassigned.sheet_mut(0).unwrap().controls[i].action =
-            Some(ControlAction::Macro { name: "Other".into(), input: MacroInput::Selection, output: None });
-    }
-    load_action_names(&mut reassigned);
-    for i in [0, 2] {
-        assert!(
-            matches!(&reassigned.sheets[0].controls[i].action, Some(ControlAction::Macro { name, input: MacroInput::Selection, .. }) if name == "Other"),
-            "{i}"
-        );
-    }
-    // Another application cleared the macro of "Fixed": the stored action (with its fixed input)
-    // does not bring the assignment back. The command on a button given no macro still does.
-    let mut cleared = kept(&stored);
-    cleared.sheet_mut(0).unwrap().controls[2].action = None;
-    load_action_names(&mut cleared);
-    assert_eq!(cleared.sheets[0].controls[2].action, None, "the removed assignment stays removed");
-    assert_eq!(cleared.sheets[0].controls[0].action, actions(&wb)[0], "the command comes back");
-}
-
-/// An entry of the hidden name must carry the button's name and anchor cell (the writer always
-/// stores both): a hand-edited entry without either, or with something else there, is dropped
-/// like an unparsable one, so it cannot pin its action onto whatever button sits at that index.
-#[test]
-fn a_kept_action_without_the_buttons_name_or_anchor_is_dropped() {
-    use crate::cmd::controls::{ACTIONS_KEY, load_action_names, with_action_names};
-    use crate::cmd::stash;
-    let mut s = s();
-    s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap();
-    let stored = with_action_names(&s.doc().unwrap().wb).unwrap().unwrap();
-    let items = stash::get_json(&stored, ACTIONS_KEY).unwrap();
-    assert!(items[0]["name"].is_string() && items[0]["at"].is_string(), "the writer stores both keys: {items}");
-    // As the file brings a command button back: with no action.
-    let kept = |items: &Json| {
-        let mut wb = stored.clone();
-        wb.sheet_mut(0).unwrap().controls[0].action = None;
-        stash::remove(&mut wb, ACTIONS_KEY);
-        stash::set_json(&mut wb, ACTIONS_KEY, items).unwrap();
-        load_action_names(&mut wb);
-        assert!(stash::get(&wb, ACTIONS_KEY).is_none(), "the hidden name is removed");
-        wb.sheets[0].controls[0].action.clone()
-    };
-    let edited = |key: &str, value: Option<Json>| {
-        let mut items = items.clone();
-        let entry = items[0].as_object_mut().unwrap();
-        match value {
-            Some(v) => entry.insert(key.to_string(), v),
-            None => entry.remove(key),
-        };
-        items
-    };
-    assert_eq!(kept(&edited("name", None)), None, "no `name`");
-    assert_eq!(kept(&edited("at", None)), None, "no `at`");
-    assert_eq!(kept(&edited("name", Some(json!(1)))), None, "`name` is not text");
-    assert_eq!(kept(&edited("at", Some(Json::Null))), None, "`at` is null");
-    assert!(matches!(kept(&items), Some(ControlAction::Command { .. })), "the writer's own entry still comes back");
-}
-
-/// A fixed input range for a macro that declares no inputs would fail every press (`macro.run`
-/// refuses inputs the macro doesn't take), so the assignment is refused when it is made, naming
-/// the macro; a macro the workbook doesn't have yet is not checked, and a macro with an input
-/// takes the range. A file that brings such a stored input in gets the macro on the selection.
-#[test]
-fn a_fixed_input_for_a_macro_without_inputs_is_refused_when_assigned() {
-    use crate::cmd::controls::{load_action_names, with_action_names};
-    let mut s = s();
-    s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "x"}}]})).unwrap();
-    s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}]})).unwrap();
-    let want = "macro 'Fill' takes no inputs";
-    assert!(err(s.execute("insert.button", json!({"at": "B2", "macro": "Fill", "input": "C2:D4"}))).contains(want));
-    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 0, "no button was placed");
-    let b = id(&s.execute("insert.button", json!({"at": "B2", "macro": "Fill", "output": "F2"})).unwrap());
-    let e = err(s.execute("control.assign", json!({"id": b, "macro": "fill", "input": "C2:D4"})));
-    assert!(e.contains(want), "any letter case: {e}");
-    assert_eq!(control(&s, b).action, Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Selection, output: Some("F2".into()) }));
-    s.execute("control.assign", json!({"id": b, "macro": "Mark", "input": "C2:D4"})).unwrap();
-    s.execute("control.assign", json!({"id": b, "macro": "Later", "input": "C2:D4"})).unwrap();
-    assert_eq!(control(&s, b).action, Some(ControlAction::Macro { name: "Later".into(), input: MacroInput::Fixed("C2:D4".into()), output: None }));
-    // A file's stored fixed input for Fill (another version assigned it) comes back as the selection.
-    s.execute("control.assign", json!({"id": b, "macro": "Fill", "output": "F2"})).unwrap();
-    let mut wb = (*s.doc().unwrap().wb).clone();
-    wb.sheet_mut(0).unwrap().controls[0].action =
-        Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Fixed("C2:D4".into()), output: Some("F2".into()) });
-    let mut stored = with_action_names(&wb).unwrap().unwrap();
-    load_action_names(&mut stored);
-    assert_eq!(
-        stored.sheets[0].controls[0].action,
-        Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Selection, output: Some("F2".into()) })
-    );
-}
-
-/// The saved xlsx bytes of `s`'s workbook.
-fn saved_xlsx(s: &mut Session) -> Vec<u8> {
-    let r = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap();
-    crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap()
-}
-
-/// `bytes` with `edit` applied to the text of every part, as another application that rewrote
-/// those parts would leave the file.
-fn edit_parts(bytes: &[u8], mut edit: impl FnMut(&str, String) -> String) -> Vec<u8> {
-    use std::io::{Cursor, Read, Write};
-    let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
-    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
-    for i in 0..zip.len() {
-        let mut part = zip.by_index(i).unwrap();
-        let name = part.name().to_string();
-        let mut data = Vec::new();
-        part.read_to_end(&mut data).unwrap();
-        let data = match String::from_utf8(data) {
-            Ok(text) => edit(&name, text).into_bytes(),
-            Err(e) => e.into_bytes(),
-        };
-        out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
-        out.write_all(&data).unwrap();
-    }
-    out.finish().unwrap().into_inner()
-}
-
-/// Opens `bytes` as `name`, checks the hidden name of the button actions is taken back out, and
-/// lists the controls.
-fn open_and_list(s: &mut Session, name: &str, bytes: &[u8]) -> Json {
-    s.execute("file.open", json!({"name": name, "base64": crate::io::base64_encode(bytes)})).unwrap();
-    assert!(s.doc().unwrap().wb.names.iter().all(|n| !n.name.contains("control_actions")), "{name}: the hidden name is taken back out");
-    s.execute("control.list", json!({})).unwrap()
-}
-
-/// The macro reference xlsx writes for a button that runs `Mark`.
-const MARK: &str = "[0]!Mark";
-
-/// Another application removed a button's macro assignment and kept the button with its name and
-/// place: the hidden name's copy of the action (with the fixed input and the output cell) does not
-/// bring the assignment back. The same file, unedited, reopens with the whole action.
-#[test]
-fn a_macro_assignment_removed_in_another_application_stays_removed() {
-    let mut s = s();
-    s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}], "output": {"onConflict": "overwrite"}})).unwrap();
-    s.execute("insert.button", json!({"at": "D2", "text": "Run", "macro": "Mark", "input": "F1:G2", "output": "H1"})).unwrap();
-    let before = s.execute("control.list", json!({})).unwrap()[0].clone();
-    let full = ControlAction::Macro { name: "Mark".into(), input: MacroInput::Fixed("F1:G2".into()), output: Some("H1".into()) };
-    assert_eq!(before["action"], serde_json::to_value(&full).unwrap());
-    let bytes = saved_xlsx(&mut s);
-    // xlsx assigns the macro in the sheet's `<controlPr macro>` and in the VML shape's
-    // `<x:FmlaMacro>` (the parts the reader takes it from); clearing the assignment drops both.
-    let (attr, fmla) = (format!(" macro=\"{MARK}\""), format!("<x:FmlaMacro>{MARK}</x:FmlaMacro>"));
-    let mut edited = Vec::new();
-    let cleared = edit_parts(&bytes, |name, text| {
-        if text.contains(&attr) || text.contains(&fmla) {
-            edited.push(name.to_string());
-        }
-        text.replace(&attr, "").replace(&fmla, "")
-    });
-    edited.sort();
-    assert_eq!(edited, ["xl/drawings/vmlDrawing1.vml", "xl/worksheets/sheet1.xml"]);
-    let list = open_and_list(&mut s, "cleared.xlsx", &cleared);
-    assert_eq!(list.as_array().unwrap().len(), 1);
-    for key in ["kind", "name", "at", "text"] {
-        assert_eq!(list[0][key], before[key], "{key}: the same button");
-    }
-    assert_eq!(list[0].get("action"), None, "the removed assignment stays removed");
-    // Unedited, the file still assigns the macro, and the action comes back whole.
-    let list = open_and_list(&mut s, "kept.xlsx", &bytes);
-    assert_eq!(list[0]["action"], before["action"]);
-}
-
-/// Another application assigned a macro to a button that ran a command (kept in the hidden name):
-/// the file's macro wins, as it does when a macro button is given another macro.
-#[test]
-fn a_macro_assigned_in_another_application_replaces_a_stored_command() {
-    let mut s = s();
-    s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "m"}}]})).unwrap();
-    s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap();
-    let bytes = saved_xlsx(&mut s);
-    let (pr, data) = ("<controlPr", "<x:ClientData ObjectType=\"Button\">");
-    let mut edited = Vec::new();
-    let assigned = edit_parts(&bytes, |name, text| {
-        if text.contains(pr) || text.contains(data) {
-            edited.push(name.to_string());
-        }
-        text.replace(pr, &format!("<controlPr macro=\"{MARK}\"")).replace(data, &format!("{data}<x:FmlaMacro>{MARK}</x:FmlaMacro>"))
-    });
-    edited.sort();
-    assert_eq!(edited, ["xl/drawings/vmlDrawing1.vml", "xl/worksheets/sheet1.xml"]);
-    let list = open_and_list(&mut s, "assigned.xlsx", &assigned);
-    let plain = ControlAction::Macro { name: "Mark".into(), input: MacroInput::Selection, output: None };
-    assert_eq!(list[0]["action"], serde_json::to_value(&plain).unwrap(), "the file's macro, not the stored command");
-}
-
-#[test]
-fn every_kind_and_action_survives_xlsx() {
-    let mut s = s();
-    s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}], "output": {"onConflict": "overwrite"}})).unwrap();
-    s.execute("insert.slider", json!({"at": "D2", "link": "B1", "min": 10, "max": 200, "step": 10, "page": 50, "value": 70})).unwrap();
-    s.execute("insert.spinButton", json!({"at": "D6", "link": "B2", "max": 9, "value": 4})).unwrap();
-    s.execute("insert.button", json!({"at": "D9", "text": "Plain", "macro": "Mark"})).unwrap();
-    s.execute("insert.button", json!({"at": "D11", "text": "Fixed", "macro": "Mark", "input": "F1:G2", "output": "H1"})).unwrap();
-    s.execute("insert.button", json!({"at": "D13", "text": "Command", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap();
-    s.execute("review.newNote", json!({"cell": "A1", "text": "a note"})).unwrap();
-    let before: Vec<Json> = s
-        .execute("control.list", json!({}))
-        .unwrap()
-        .as_array()
-        .unwrap()
-        .iter()
-        .map(|c| {
-            let mut c = c.clone();
-            c.as_object_mut().unwrap().remove("id");
-            c
-        })
-        .collect();
-    reopen(&mut s);
-    let after: Vec<Json> = s
-        .execute("control.list", json!({}))
-        .unwrap()
-        .as_array()
-        .unwrap()
-        .iter()
-        .map(|c| {
-            let mut c = c.clone();
-            c.as_object_mut().unwrap().remove("id");
-            c
-        })
-        .collect();
-    assert_eq!(before.len(), after.len());
-    for (b, a) in before.iter().zip(&after) {
-        for key in ["kind", "name", "at", "text", "link", "value", "min", "max", "step", "page", "horizontal", "action", "print", "locked"] {
-            assert_eq!(b.get(key), a.get(key), "{key}: {b} vs {a}");
-        }
-    }
-    assert!(s.doc().unwrap().wb.names.iter().all(|n| !n.name.contains("control_actions")), "the hidden name is taken back out");
-    assert_eq!(s.doc().unwrap().trust, Trust::FromFile);
-    // A workbook from a file: its command button asks before it runs.
-    let cmd = after.iter().position(|c| c["text"] == json!("Command")).unwrap();
-    let id = s.execute("control.list", json!({})).unwrap()[cmd]["id"].as_u64().unwrap();
-    assert!(matches!(s.execute("control.press", json!({"id": id})), Err(EngineError::Approve(_))));
-    s.execute("control.press", json!({"id": id, "approve": true})).unwrap();
-    assert_eq!(v(&s, "A9"), Value::text("cmd"));
-    // The linked cells still move the controls.
-    s.execute("cell.set", json!({"cell": "B1", "input": "120"})).unwrap();
-    assert_eq!(s.execute("control.list", json!({})).unwrap()[0]["value"], json!(120));
-}
-
-/// A button's command goes through the macro policy when it is assigned and again when it is
-/// pressed, so a file whose hidden name carries a denied command (written by another application,
-/// or edited by hand) can't use a button as a way around the policy.
-#[test]
-fn a_denied_command_is_refused_when_assigned_and_when_a_file_brings_it_in() {
-    let dir = std::env::temp_dir().join(format!("gridcraft-control-deny-{}", std::process::id()));
-    let leak = dir.join("leak.xlsx").to_string_lossy().to_string();
-    let denied = [
-        ("link.open", json!({"url": "https://example.com/?d=secret"})),
-        ("file.saveAs", json!({"path": leak})),
-        ("file.save", json!({})),
-        ("file.open", json!({"path": leak})),
-        ("app.commands", json!({})),
-        ("macro.run", json!({"name": "Mark"})),
-        ("automate.runScript", json!({"name": "Leak", "trusted": true})),
-        ("control.press", json!({"id": 1})),
-    ];
-    let mut s = s();
-    s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "m"}}]})).unwrap();
-    // Neither Insert › Button nor Assign Action takes one.
-    let b = id(&s.execute("insert.button", json!({"at": "B2", "text": "Run"})).unwrap());
-    for (cmd, params) in &denied {
-        let want = format!("can't run {cmd}");
-        assert!(err(s.execute("insert.button", json!({"at": "B9", "command": cmd, "params": params}))).contains(&want), "{cmd}");
-        assert!(err(s.execute("control.assign", json!({"id": b, "command": cmd, "params": params}))).contains(&want), "{cmd}");
-        assert_eq!(control(&s, b).action, None, "{cmd}");
-    }
-    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 1, "no button was placed");
-    // A file can still carry them: one button per command, given its action as a file would.
-    for i in 1..denied.len() {
-        s.execute("insert.button", json!({"at": format!("B{}", 2 + 3 * i), "text": format!("Run {i}")})).unwrap();
-    }
-    let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap();
-    for (c, (cmd, params)) in sh.controls.iter_mut().zip(&denied) {
-        c.action = Some(ControlAction::Command { id: (*cmd).to_string(), params: params.clone() });
-    }
-    reopen(&mut s);
-    assert_eq!(s.doc().unwrap().trust, Trust::FromFile);
-    let list = s.execute("control.list", json!({})).unwrap();
-    for (i, (cmd, params)) in denied.iter().enumerate() {
-        // The action came back through the hidden name, so the check at press time is what holds.
-        assert_eq!(list[i]["action"], json!({"type": "command", "id": cmd, "params": params}), "{cmd}");
-        let pressed = list[i]["id"].as_u64().unwrap();
-        let before = undo_len(&s);
-        assert!(err(s.execute("control.press", json!({"id": pressed, "approve": true}))).contains(&format!("can't run {cmd}")), "{cmd}");
-        assert_eq!(undo_len(&s), before, "{cmd}: nothing ran");
-    }
-    assert!(!std::path::Path::new(&leak).exists());
-    assert_eq!(v(&s, "A1"), Value::Empty, "the macro never ran");
-    assert!(!s.ui_requests.iter().any(|r| matches!(r, crate::UiRequest::OpenUrl(_))), "no page was opened: {:?}", s.ui_requests);
-}
-
-/// A command the policy allows may still turn out to open a dialog or a web page when it runs
-/// (a command given no parameters opens its dialog): the press is refused with the reason, as a
-/// macro step is, and the request is dropped, so nothing opens. Messages for the person pass.
-#[test]
-fn a_button_command_that_would_open_a_dialog_or_a_page_is_refused_after_it_runs() {
-    use crate::UiRequest;
-    use crate::cmd::controls::take_requests;
-    let mut s = s();
-    let b = id(&s.execute("insert.button", json!({"at": "B2", "text": "Link", "command": "insert.link", "params": {}})).unwrap());
-    let before = undo_len(&s);
-    let name = control(&s, b).display_name();
-    assert_eq!(
-        err(s.execute("control.press", json!({"id": b}))),
-        format!("'{name}' would open the insertLink dialog; give its command the parameters it needs.")
-    );
-    assert!(!s.ui_requests.iter().any(|r| matches!(r, UiRequest::Dialog(..))), "{:?}", s.ui_requests);
-    assert_eq!(undo_len(&s), before, "nothing stays done");
-    // The filter itself, with every kind of request a command can queue: the page is refused,
-    // the cell edit is dropped, the message stays, and requests queued before are left alone.
-    s.ui_requests.push(UiRequest::Message("earlier".into()));
-    let queued = s.ui_requests.len();
-    s.ui_requests.extend([UiRequest::EditCell(None), UiRequest::Message("saved".into()), UiRequest::OpenUrl("https://example.com/".into())]);
-    assert_eq!(take_requests(&mut s, queued, "Go").as_deref(), Some("'Go' would open a web page, which buttons don't do."));
-    assert_eq!(s.ui_requests, vec![UiRequest::Message("earlier".into()), UiRequest::Message("saved".into())]);
-    assert_eq!(take_requests(&mut s, 5, "Go"), None, "a mark past the queue's end drops nothing");
-    assert_eq!(s.ui_requests.len(), 2);
-}
-
-/// A linked cell that holds a formula: a write of the value the formula already shows is skipped,
-/// so Format Control's OK (which sends the value back every time) keeps the formula, also on a
-/// protected sheet with the cell locked; a changed value replaces the formula with the constant.
-#[test]
-fn a_formula_in_the_linked_cell_survives_a_write_of_the_value_it_shows() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "10"})).unwrap();
-    s.execute("cell.set", json!({"cell": "B1", "input": "=A1*2"})).unwrap();
-    let formula =
-        |s: &Session| s.doc().unwrap().wb.sheet(0).unwrap().cell(gridcraft_core::CellRef::parse("B1").unwrap()).is_some_and(|c| c.formula.is_some());
-    assert!(formula(&s));
-    // Inserting with the value the formula shows (10 * 2 = 20) writes nothing.
-    let c = id(&s.execute("insert.slider", json!({"at": "D2", "link": "B1", "value": 20})).unwrap());
-    assert!(formula(&s), "the formula stays");
-    assert_eq!(v(&s, "B1"), Value::Number(20.0));
-    // The dialog's OK: every number sent back, the value unchanged, a new name.
-    s.execute("control.format", json!({"id": c, "name": "Speed", "value": 20, "min": 0, "max": 100, "step": 1, "page": 10, "locked": false}))
-        .unwrap();
-    assert!(formula(&s), "a rename keeps the formula");
-    // Editing A1 moves the control through the formula (15 * 2 = 30); OK with that value keeps it.
-    s.execute("cell.set", json!({"cell": "A1", "input": "15"})).unwrap();
-    assert_eq!(control(&s, c).value, 30);
-    s.execute("control.format", json!({"id": c, "value": 30, "min": 0, "max": 100, "step": 1})).unwrap();
-    assert!(formula(&s));
-    // On a protected sheet with B1 locked, the same OK is not refused.
-    s.execute("review.protectSheet", json!({})).unwrap();
-    s.execute("control.format", json!({"id": c, "name": "Rate", "value": 30, "min": 0, "max": 100, "step": 1})).unwrap();
-    assert_eq!(control(&s, c).name, "Rate");
-    assert!(formula(&s));
-    s.execute("review.unprotectSheet", json!({})).unwrap();
-    // A changed value writes the constant over the formula.
-    s.execute("control.format", json!({"id": c, "value": 40, "min": 0, "max": 100, "step": 1})).unwrap();
-    assert!(!formula(&s), "the formula is replaced");
-    assert_eq!(v(&s, "B1"), Value::Number(40.0));
-}
-
-/// Using a slider or spin button writes its linked cell through `cell.set`, so the cell's
-/// protection governs it: a locked cell on a protected sheet refuses the change, and the control
-/// keeps its value (the control's change and the cell write are one group, rolled back together).
-/// A control's own Locked flag keeps it from being moved or edited, not from being used, as in
-/// Excel, so an unlocked linked cell takes the value on a protected sheet.
-#[test]
-fn a_locked_linked_cell_on_a_protected_sheet_refuses_the_change_and_the_control_keeps_its_value() {
-    let mut s = s();
-    let c = id(&s.execute("insert.slider", json!({"at": "D2", "link": "B1", "value": 40})).unwrap());
-    s.execute("control.format", json!({"id": c, "locked": false})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    let before = undo_len(&s);
-    assert!(err(s.execute("control.setValue", json!({"id": c, "value": 60}))).contains("protected"));
-    assert_eq!((control(&s, c).value, v(&s, "B1")), (40, Value::Number(40.0)), "nothing is half-applied");
-    assert_eq!(undo_len(&s), before, "no undo step is left behind");
-    // Format Control: a new maximum that would pull the value into the cell is refused whole.
-    assert!(err(s.execute("control.format", json!({"id": c, "max": 30}))).contains("protected"));
-    assert_eq!((control(&s, c).max, control(&s, c).value), (100, 40));
-    // Inserting a control with a value for a locked cell is refused and leaves no control behind.
-    assert!(err(s.execute("insert.spinButton", json!({"at": "D8", "link": "B2", "value": 5}))).contains("protected"));
-    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 1);
-    // The value the cell already holds writes nothing, so nothing is refused.
-    s.execute("control.setValue", json!({"id": c, "value": 40})).unwrap();
-    assert_eq!(undo_len(&s), before);
-    // An unlocked linked cell takes the value on the protected sheet.
-    s.execute("review.unprotectSheet", json!({})).unwrap();
-    s.execute("home.lockCell", json!({"range": "B1", "on": false})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    s.execute("control.setValue", json!({"id": c, "value": 60})).unwrap();
-    assert_eq!((control(&s, c).value, v(&s, "B1")), (60, Value::Number(60.0)));
-}
-
-/// A link to a cell on another sheet obeys that sheet's protection, not the control's sheet's.
-#[test]
-fn a_link_to_another_sheet_obeys_that_sheets_protection() {
-    let mut s = s();
-    s.execute("home.insertSheet", json!({"name": "Data"})).unwrap();
-    s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap();
-    let c = id(&s.execute("insert.slider", json!({"at": "D2", "link": "Data!B1", "value": 10})).unwrap());
-    assert_eq!(control(&s, c).link.as_deref(), Some("Data!$B$1"));
-    let data = |s: &Session| {
-        let wb = &s.doc().unwrap().wb;
-        wb.sheet(wb.sheet_index("Data").unwrap()).unwrap().value(gridcraft_core::CellRef::new(0, 1))
-    };
-    assert_eq!(data(&s), Value::Number(10.0));
-    s.execute("review.protectSheet", json!({"sheet": "Data"})).unwrap();
-    let before = undo_len(&s);
-    assert!(err(s.execute("control.setValue", json!({"id": c, "value": 20}))).contains("protected"));
-    assert_eq!((control(&s, c).value, data(&s)), (10, Value::Number(10.0)));
-    assert_eq!(undo_len(&s), before);
-    assert!(err(s.execute("insert.spinButton", json!({"at": "D8", "link": "Data!B2", "value": 5}))).contains("protected"));
-    assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 1);
-    // Protecting the control's own sheet instead leaves the write to the other sheet alone.
-    s.execute("review.unprotectSheet", json!({"sheet": "Data"})).unwrap();
-    s.execute("review.protectSheet", json!({})).unwrap();
-    s.execute("control.setValue", json!({"id": c, "value": 20})).unwrap();
-    assert_eq!((control(&s, c).value, data(&s)), (20, Value::Number(20.0)));
-    // A link to a sheet the workbook doesn't have is refused with a clear message.
-    s.execute("review.unprotectSheet", json!({})).unwrap();
-    assert!(err(s.execute("control.format", json!({"id": c, "link": "Nowhere!B1"}))).contains("isn't a cell of this workbook"));
-    assert_eq!(control(&s, c).link.as_deref(), Some("Data!$B$1"));
-}

crates/engine/src/tests/macros.rs

@@ -2434,83 +2434,3 @@ fn a_shortcut_taken_while_recording_is_reported_when_it_is_left_off() {
     assert!(r.get("shortcutDropped").is_none(), "{r}");
     assert_eq!(s.execute("macro.get", json!({"name": "Keep"})).unwrap()["shortcut"], "Ctrl+Shift+Q");
 }
-
-/// `output` (a form button's output cell) moves where the macro writes: the footprint, the
-/// conflict rule and `macro.check` protect the data at the cells it names, as at the macro's own
-/// anchor, and a value that names no cell is refused before anything runs.
-#[test]
-fn an_output_override_is_checked_and_protected_like_the_macros_own_anchor() {
-    let mut s = s();
-    s.execute("home.insertSheet", json!({"name": "Other"})).unwrap();
-    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-    put(
-        &mut s,
-        json!({"name": "Placed", "output": {"anchor": "D1"}, "steps": [
-            {"command": "cell.set", "params": {"cell": "Output", "input": "out"}}
-        ]}),
-    );
-    set(&mut s, "F1", "keep me");
-    let start = s.doc().unwrap().wb.clone();
-    // Writing over F1 asks (programmatic runs fail) and changes nothing, as it would at D1.
-    let r = s.execute("macro.run", json!({"name": "Placed", "output": "F1"}));
-    let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") };
-    assert!(q.contains("(F1 on Sheet1)"), "{q}");
-    let err = s.execute("macro.run", json!({"name": "Placed", "output": "F1", "onConflict": "fail"})).unwrap_err().to_string();
-    assert!(err.contains("Nothing was changed"), "{err}");
-    assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &start));
-    // macro.check reports the override and its conflict.
-    let c = s.execute("macro.check", json!({"name": "Placed", "output": "F1"})).unwrap();
-    assert_eq!((&c["ok"], &c["output"], &c["conflicts"]), (&json!(false), &json!("F1"), &json!(1)), "{c}");
-    // On another sheet too.
-    s.execute("cell.set", json!({"cell": "Other!B2", "input": "theirs"})).unwrap();
-    let r = s.execute("macro.run", json!({"name": "Placed", "output": "Other!B2"}));
-    assert!(matches!(&r, Err(EngineError::Confirm(q)) if q.contains("(B2 on Other)")), "{r:?}");
-    // The stored anchor holding data doesn't matter when the output goes elsewhere.
-    set(&mut s, "D1", "stored anchor's data");
-    s.execute("macro.run", json!({"name": "Placed", "output": "H1"})).unwrap();
-    assert_eq!((v(&s, "H1").display(), v(&s, "D1").display()), ("out".to_string(), "stored anchor's data".to_string()));
-    // Hostile values are refused before anything runs.
-    let before = s.doc().unwrap().wb.clone();
-    for (bad, needle) in [
-        (json!(5), "`output` must be reference text"),
-        (json!({"cell": "F1"}), "`output` must be reference text"),
-        (json!(" "), "`output` must be reference text"),
-        (json!("x".repeat(1_025)), "`output` must be reference text"),
-        (json!("F1\nF2"), "`output` must be reference text"),
-        (json!("NoSuchSheet!A1"), "output anchor"),
-        (json!("XFE1"), "output anchor"),
-        (json!("A1048577"), "output anchor"),
-        (json!("not a cell!!"), "output anchor"),
-    ] {
-        let err = s.execute("macro.run", json!({"name": "Placed", "output": bad, "onConflict": "overwrite"})).unwrap_err().to_string();
-        assert!(err.contains(needle), "{bad}: {err}");
-        let c = s.execute("macro.check", json!({"name": "Placed", "output": bad})).unwrap();
-        assert!(c["errors"].to_string().contains(needle), "{bad}: {c}");
-    }
-    assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &before));
-}
-
-/// After a partial footprint (Solver can't be previewed), a later step that deletes a form
-/// control is caught by the check of each step, as one that deletes a chart or a picture is.
-#[test]
-fn a_step_that_deletes_a_form_control_after_a_partial_footprint_is_caught() {
-    let mut s = s();
-    set(&mut s, "A1", "1");
-    set(&mut s, "C1", "=A1");
-    let control = s.execute("insert.spinButton", json!({"at": "E2"})).unwrap()["control"].as_u64().unwrap();
-    let solver = json!({"command": "data.solver", "params": {"objective": "C1", "variables": "A1", "constraints": ["A1 <= 5"], "method": "simplex", "saveModel": false}});
-    let delete = json!({"command": "object.delete", "params": {"kind": "control", "id": control}});
-    put(&mut s, json!({"name": "Drop", "inputs": [{"name": "Input"}], "steps": [solver, delete]}));
-    let start = s.doc().unwrap().wb.clone();
-    for rule in ["fail", "ask"] {
-        let r = s.execute("macro.run", json!({"name": "Drop", "inputs": "A1", "onConflict": rule}));
-        let e = match (rule, r) {
-            ("fail", Err(EngineError::Other(e))) | ("ask", Err(EngineError::Confirm(e))) => e,
-            (_, r) => panic!("{rule}: {r:?}"),
-        };
-        assert!(e.contains("Step 2 (object.delete): It would write over data (1 object)"), "{e}");
-        assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &start), "{rule}: rolled back");
-    }
-    s.execute("macro.run", json!({"name": "Drop", "inputs": "A1", "overwrite": true})).unwrap();
-    assert!(s.doc().unwrap().wb.active().unwrap().controls.is_empty());
-}

crates/engine/src/tests/objects.rs

@@ -20,8 +20,8 @@ fn id_of(v: &serde_json::Value, key: &str) -> u32 {
 }
 
 /// A table with one object of each kind on the first sheet: a chart, a picture, a shape, a
-/// slicer, an equation and a form control, in `ObjKind::ALL` order.
-fn every_kind(s: &mut Session) -> [ObjRef; 6] {
+/// slicer and an equation, in `ObjKind::ALL` order.
+fn every_kind(s: &mut Session) -> [ObjRef; 5] {
     s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Qty"], ["East", 3], ["West", 5], ["East", 2], ["North", 8]]})).unwrap();
     s.execute("insert.table", json!({"range": "A1:B5", "name": "Sales"})).unwrap();
     let chart = id_of(&s.execute("insert.chart", json!({"range": "B1:B5", "type": "column", "at": "D2"})).unwrap(), "chart");
@@ -30,14 +30,12 @@ fn every_kind(s: &mut Session) -> [ObjRef; 6] {
     s.execute("selection.set", json!({"cell": "A2"})).unwrap();
     let slicer = id_of(&s.execute("insert.slicer", json!({"column": "Region", "at": "L2"})).unwrap(), "slicer");
     let equation = id_of(&s.execute("insert.equation", json!({"latex": "x^2", "cell": "L18"})).unwrap(), "equation");
-    let control = id_of(&s.execute("insert.slider", json!({"at": "P18", "link": "$B$7"})).unwrap(), "control");
     [
         ObjRef::new(ObjKind::Chart, chart),
         ObjRef::new(ObjKind::Image, image),
         ObjRef::new(ObjKind::Shape, shape),
         ObjRef::new(ObjKind::Slicer, slicer),
         ObjRef::new(ObjKind::Equation, equation),
-        ObjRef::new(ObjKind::Control, control),
     ]
 }
 
@@ -70,9 +68,9 @@ fn every_kind_is_found_moved_and_deleted_by_kind_and_id() {
             assert!(sheet(&s, 0).has_object(*later), "deleting {o:?} leaves {later:?}");
         }
     }
-    // One undo step per delete brings the control, deleted last, back.
+    // One undo step per delete brings the equation back.
     s.execute("edit.undo", json!({})).unwrap();
-    assert!(sheet(&s, 0).has_object(objs[5]));
+    assert!(sheet(&s, 0).has_object(objs[4]));
 }
 
 #[test]
@@ -86,11 +84,9 @@ fn selection_pane_lists_and_stacks_slicers() {
     for k in ObjKind::ALL {
         assert!(kinds.contains(&k.name()), "{k:?} listed in {kinds:?}");
     }
-    assert_eq!(kinds.last(), Some(&"control"), "form controls stack on top");
-    assert_eq!(kinds.get(kinds.len() - 2), Some(&"slicer"), "slicers stack above charts, pictures and shapes");
+    assert_eq!(kinds.last(), Some(&"slicer"), "slicers stack on top");
     let names: Vec<&str> = items.iter().map(|o| o["name"].as_str().unwrap()).collect();
     assert!(names.contains(&"Region") && names.contains(&"Qty"), "{names:?}");
-    assert!(names.contains(&format!("Slider {}", objs[5].id).as_str()), "{names:?}");
     assert_eq!(sheet(&s, 0).slicers.first().map(|c| c.id), Some(objs[3].id));
     s.execute("arrange.sendBackward", json!({"kind": "slicer", "id": second, "toBack": true})).unwrap();
     assert_eq!(sheet(&s, 0).slicers.first().map(|c| c.id), Some(second));
@@ -126,17 +122,17 @@ fn cell_of(s: &Session, o: ObjRef) -> String {
 fn every_kind_follows_row_and_column_edits_and_sorts() {
     let mut s = s();
     let objs = every_kind(&mut s);
-    // Anchors: chart D2, picture D18, shape H18, slicer L2, equation L18, slider P18.
+    // Anchors: chart D2, picture D18, shape H18, slicer L2, equation L18.
     s.execute("object.setAnchorMode", json!({"kind": "shape", "id": objs[2].id, "mode": "absolute"})).unwrap();
     let cells = |s: &Session| objs.map(|o| cell_of(s, o));
-    assert_eq!(cells(&s), ["D2", "D18", "H18", "L2", "L18", "P18"]);
+    assert_eq!(cells(&s), ["D2", "D18", "H18", "L2", "L18"]);
     s.execute("home.insertRows", json!({"rows": "10:11"})).unwrap();
-    assert_eq!(cells(&s), ["D2", "D20", "H18", "L2", "L20", "P20"], "rows inserted above move the objects below them; an absolute shape stays");
+    assert_eq!(cells(&s), ["D2", "D20", "H18", "L2", "L20"], "rows inserted above move the objects below them; an absolute shape stays");
     s.execute("home.insertColumns", json!({"cols": "C:C"})).unwrap();
-    assert_eq!(cells(&s), ["E2", "E20", "H18", "M2", "M20", "Q20"]);
+    assert_eq!(cells(&s), ["E2", "E20", "H18", "M2", "M20"]);
     s.execute("home.deleteColumns", json!({"cols": "C:C"})).unwrap();
     s.execute("home.deleteRows", json!({"rows": "10:11"})).unwrap();
-    assert_eq!(cells(&s), ["D2", "D18", "H18", "L2", "L18", "P18"]);
+    assert_eq!(cells(&s), ["D2", "D18", "H18", "L2", "L18"]);
     // Sorting moves a picture anchored inside the sorted block with its row.
     s.execute("range.setValues", json!({"range": "T1", "values": [["k"], [3], [1], [2]]})).unwrap();
     let pic = ObjRef::new(ObjKind::Image, super::add_image(&mut s, "T2", AnchorMode::MoveAndSize));
@@ -265,7 +261,6 @@ fn a_copied_sheet_gives_its_objects_fresh_ids() {
             .chain(sh.images.iter().map(|c| c.id))
             .chain(sh.shapes.iter().map(|c| c.id))
             .chain(sh.slicers.iter().map(|c| c.id))
-            .chain(sh.controls.iter().map(|c| c.id))
             .collect()
     };
     let mut ids: Vec<u32> = wb.sheets.iter().flat_map(|sh| ids_of(sh)).collect();
@@ -319,26 +314,6 @@ fn object_ids_stay_unique_when_a_file_used_the_largest_id() {
     assert_eq!(ids.len(), 6, "every shape id is distinct across both sheets");
 }
 
-/// A copied sheet's form controls take free ids like its other objects: a file's control can
-/// carry the largest id, and the ids the copy asks for count the controls.
-#[test]
-fn a_copied_sheets_form_controls_take_free_ids_too() {
-    let mut s = s();
-    let slider = id_of(&s.execute("insert.slider", json!({"at": "B2", "link": "$A$1"})).unwrap(), "control");
-    s.execute("insert.button", json!({"at": "B6"})).unwrap();
-    s.execute("insert.shape", json!({"kind": "rectangle", "at": "D2"})).unwrap();
-    // The file's slider carries the largest id (set on the model, as a loaded file would).
-    std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().controls.iter_mut().find(|o| o.id == slider).unwrap().id = u32::MAX;
-    s.execute("sheet.move", json!({"sheet": 0, "to": 1, "copy": true})).unwrap();
-    let wb = &s.doc().unwrap().wb;
-    let mut ids: Vec<u32> = wb.sheets.iter().flat_map(|sh| sh.controls.iter().map(|o| o.id).chain(sh.shapes.iter().map(|o| o.id))).collect();
-    assert_eq!(ids.len(), 6);
-    ids.sort_unstable();
-    ids.dedup();
-    assert_eq!(ids.len(), 6, "every control and shape id is distinct across both sheets: {ids:?}");
-    assert_eq!(ids.iter().filter(|&&i| i == u32::MAX).count(), 1, "only the file's slider keeps the largest id");
-}
-
 /// A file's anchors are not held to the 10,000 points `object.move` gives a new size. A picture
 /// a file made 12,000 wide keeps that width when it is moved, shrinks by what a resize asks
 /// (11,990 stays 11,990, no jump to 10,000) and never grows further; a dimension the file kept

crates/engine/tests/it/ctrl_shift_arrow_active_line.rs

@@ -1,56 +0,0 @@
-//! Ctrl/Cmd+Shift+arrow searches the active cell's column (or row) from the moving edge (#3484).
-
-use gridcraft_engine::Session;
-use serde_json::json;
-
-fn table() -> Session {
-    // Headers in A2:K2, a key column in A3:A13, nothing else filled.
-    let mut s = Session::new();
-    s.new_workbook();
-    let header: Vec<i64> = (1..=11).collect();
-    s.execute("range.setValues", json!({"range": "A2:K2", "values": [header]})).unwrap();
-    let keys: Vec<Vec<i64>> = (1..=11).map(|i| vec![i]).collect();
-    s.execute("range.setValues", json!({"range": "A3:A13", "values": keys})).unwrap();
-    s
-}
-
-fn ctrl_shift(s: &mut Session, dr: i64, dc: i64) -> String {
-    s.execute("selection.move", json!({"dr": dr, "dc": dc, "extend": true, "jump": true})).unwrap();
-    s.doc().unwrap().selection.a1()
-}
-
-#[test]
-fn ctrl_shift_down_after_ctrl_shift_right_follows_the_active_column() {
-    let mut s = table();
-    s.execute("selection.set", json!({"cell": "A2"})).unwrap();
-    assert_eq!(ctrl_shift(&mut s, 0, 1), "A2:K2");
-    assert_eq!(ctrl_shift(&mut s, 1, 0), "A2:K13", "column A's data ends on row 13; column K's ends on row 2");
-    // From the end of column A's data the next press runs to the sheet's last row.
-    assert_eq!(ctrl_shift(&mut s, 1, 0), "A2:K1048576");
-}
-
-#[test]
-fn ctrl_shift_right_after_ctrl_shift_down_follows_the_active_row() {
-    let mut s = table();
-    s.execute("selection.set", json!({"cell": "A2"})).unwrap();
-    assert_eq!(ctrl_shift(&mut s, 1, 0), "A2:A13");
-    assert_eq!(ctrl_shift(&mut s, 0, 1), "A2:K13", "row 2's data ends in column K; row 13's ends in column A");
-}
-
-#[test]
-fn ctrl_shift_down_after_ctrl_shift_left_follows_the_active_column() {
-    // The active cell is on the right: column K, empty below the header, decides, not column A.
-    let mut s = table();
-    s.execute("selection.set", json!({"cell": "K2"})).unwrap();
-    assert_eq!(ctrl_shift(&mut s, 0, -1), "A2:K2");
-    assert_eq!(ctrl_shift(&mut s, 1, 0), "A2:K1048576");
-}
-
-#[test]
-fn ctrl_shift_right_after_ctrl_shift_up_follows_the_active_row() {
-    // The active cell is at the bottom: row 13, empty right of the key, decides, not row 2.
-    let mut s = table();
-    s.execute("selection.set", json!({"cell": "A13"})).unwrap();
-    assert_eq!(ctrl_shift(&mut s, -1, 0), "A2:A13");
-    assert_eq!(ctrl_shift(&mut s, 0, 1), "2:13", "row 13's data ends in column A, so the rows extend to the last column");
-}

crates/engine/tests/it/main.rs

@@ -7,7 +7,6 @@ mod chart_workbook_names;
 mod command_sequence_fuzz;
 mod cross_sheet_cut;
 mod csv_export_budget;
-mod ctrl_shift_arrow_active_line;
 mod custom_filter_blanks;
 mod custom_view_freeze;
 mod dynamicmetadata;
@@ -29,7 +28,6 @@ mod sheet_copy_spill;
 mod sheet_name_quoting;
 mod sparse_clear_invalidation;
 mod stored_list_shape;
-mod structural_edit_rewrite;
 mod table_resize_overlap;
 mod table_total_row_last_row;
 mod trace_error;

crates/engine/tests/it/structural_edit_rewrite.rs

@@ -1,84 +0,0 @@
-//! Structural edits (insert and delete of lines, sheet rename and delete) rewrite only the formulas
-//! whose tree they change. A formula they leave alone keeps its stored text and its flags.
-
-use std::sync::Arc;
-
-use gridcraft_core::{CellRef, RangeRef};
-use gridcraft_engine::Session;
-use gridcraft_model::{Cell, Formula};
-use serde_json::{Value as Json, json};
-
-fn run(s: &mut Session, command: &str, params: Json) {
-    s.execute(command, params).unwrap();
-}
-
-fn workbook() -> Session {
-    let mut s = Session::new();
-    s.new_workbook();
-    run(&mut s, "home.insertSheet", json!({"name": "Other"}));
-    run(&mut s, "home.insertSheet", json!({"name": "Spare"}));
-    run(&mut s, "sheet.activate", json!({"sheet": "Sheet1"}));
-    s
-}
-
-fn formula(s: &Session, sheet: &str, cell: &str) -> Arc<Formula> {
-    let wb = &s.doc().unwrap().wb;
-    wb.sheet(wb.sheet_index(sheet).unwrap()).unwrap().cell(CellRef::parse(cell).unwrap()).unwrap().formula.clone().unwrap()
-}
-
-/// Stores a formula with this exact text and no cached tree, as a JSON workbook loads it.
-fn put_raw(s: &mut Session, cell: &str, text: &str) {
-    let wb = Arc::make_mut(&mut s.doc_mut().unwrap().wb);
-    let i = wb.sheet_index("Sheet1").unwrap();
-    let f = Formula { text: text.to_string(), expr: None, array: None, dynamic: false };
-    wb.sheet_mut(i).unwrap().cells.set(CellRef::parse(cell).unwrap(), Cell::formula(f));
-}
-
-#[test]
-fn an_edit_that_leaves_a_formula_alone_keeps_its_stored_text() {
-    // The rewrite compares trees, not printed text, so a stored non-canonical text is not
-    // re-printed by an edit that does not change the formula. An edit that changes it prints it.
-    let mut s = workbook();
-    put_raw(&mut s, "C1", "sum(a1,  Other!b2)");
-    run(&mut s, "home.insertRows", json!({"rows": "5:5"}));
-    run(&mut s, "home.insertColumns", json!({"cols": "F:F"}));
-    run(&mut s, "sheet.rename", json!({"sheet": "Spare", "name": "Spare2"}));
-    run(&mut s, "home.deleteSheet", json!({"sheet": "Spare2"}));
-    assert_eq!(formula(&s, "Sheet1", "C1").text, "sum(a1,  Other!b2)");
-
-    run(&mut s, "home.insertRows", json!({"rows": "1:1"}));
-    assert_eq!(formula(&s, "Sheet1", "C2").text, "SUM(A2,Other!B2)");
-}
-
-#[test]
-fn renaming_a_referenced_sheet_rewrites_the_formula() {
-    let mut s = workbook();
-    put_raw(&mut s, "C1", "sum(a1,  Other!b2)");
-    run(&mut s, "sheet.rename", json!({"sheet": "Other", "name": "Data"}));
-    assert_eq!(formula(&s, "Sheet1", "C1").text, "SUM(A1,Data!B2)");
-    run(&mut s, "home.deleteSheet", json!({"sheet": "Data"}));
-    assert_eq!(formula(&s, "Sheet1", "C1").text, "SUM(A1,#REF!)");
-}
-
-#[test]
-fn inserting_rows_above_a_legacy_array_moves_its_range_when_the_formula_is_unchanged() {
-    let mut s = workbook();
-    run(&mut s, "range.setValues", json!({"range": "B1", "values": [[1], [2]]}));
-    run(&mut s, "selection.set", json!({"range": "C5:C6"}));
-    run(&mut s, "cell.set", json!({"cell": "C5", "input": "=B1:B2*2", "array": true}));
-    assert_eq!(formula(&s, "Sheet1", "C5").array, Some(RangeRef::parse("C5:C6").unwrap()));
-    run(&mut s, "home.insertRows", json!({"rows": "3:3"}));
-    let f = formula(&s, "Sheet1", "C6");
-    assert_eq!(f.text, "B1:B2*2");
-    assert_eq!(f.array, Some(RangeRef::parse("C6:C7").unwrap()));
-}
-
-#[test]
-fn deleting_an_unrelated_sheet_keeps_legacy_arrays() {
-    let mut s = workbook();
-    run(&mut s, "range.setValues", json!({"range": "B1", "values": [[1], [2]]}));
-    run(&mut s, "selection.set", json!({"range": "C1:C2"}));
-    run(&mut s, "cell.set", json!({"cell": "C1", "input": "=B1:B2*2", "array": true}));
-    run(&mut s, "home.deleteSheet", json!({"sheet": "Spare"}));
-    assert_eq!(formula(&s, "Sheet1", "C1").array, Some(RangeRef::parse("C1:C2").unwrap()));
-}

crates/formula/src/adjust.rs

@@ -8,7 +8,7 @@ use crate::ast::{Anchor, Expr, RefKind, Reference, SheetSel, clamp_anchor};
 /// Copy/fill: relative parts move by `(dr, dc)`. References pushed off the sheet become `#REF!`.
 pub fn shift_relative(e: Expr, dr: i64, dc: i64) -> Expr {
     e.map(&mut |x| match x {
-        Expr::Ref(r) => match shift_ref(r, dr, dc) {
+        Expr::Ref(r) => match shift_ref(&r, dr, dc) {
             Some(r) => Expr::Ref(r),
             None => Expr::Error(CellError::Ref),
         },
@@ -60,14 +60,14 @@ fn shift_line(v: u32, abs: bool, d: i64, max: u32) -> Option<u32> {
     if (0..max as i64).contains(&n) { Some(n as u32) } else { None }
 }
 
-fn shift_ref(r: Reference, dr: i64, dc: i64) -> Option<Reference> {
+fn shift_ref(r: &Reference, dr: i64, dc: i64) -> Option<Reference> {
     let kind = match &r.kind {
         RefKind::Cell(a) => RefKind::Cell(shift_anchor(a, dr, dc)?),
         RefKind::Range(a, b) => RefKind::Range(shift_anchor(a, dr, dc)?, shift_anchor(b, dr, dc)?),
         RefKind::Rows(r0, a0, r1, a1) => RefKind::Rows(shift_line(*r0, *a0, dr, MAX_ROWS)?, *a0, shift_line(*r1, *a1, dr, MAX_ROWS)?, *a1),
         RefKind::Cols(c0, a0, c1, a1) => RefKind::Cols(shift_line(*c0, *a0, dc, MAX_COLS)?, *a0, shift_line(*c1, *a1, dc, MAX_COLS)?, *a1),
     };
-    Some(Reference { sheet: r.sheet, kind })
+    Some(Reference { sheet: r.sheet.clone(), kind })
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -95,54 +95,27 @@ pub enum Edit {
     MoveToSheet { from: RangeRef, to_sheet: String, to_row: u32, to_col: u32 },
 }
 
-/// Whether `r`, in a formula living on sheet `host`, points into sheet `target`.
-fn on_target(r: &Reference, host: &str, target: &str) -> bool {
-    match &r.sheet {
-        SheetSel::Current => host.eq_ignore_ascii_case(target),
-        SheetSel::Named(n) => n.eq_ignore_ascii_case(target),
-        SheetSel::Span(..) => false,
-    }
-}
-
-/// Whether [`adjust`] would change `r`. It runs the same [`adjust_ref`] on a copy without the
-/// sheet name, so no name is copied: the adjustment reads only the position, and the sheet a cut
-/// to another sheet assigns is compared afterwards.
-fn ref_changes(r: &Reference, edit: &Edit) -> bool {
-    let probe = Reference { sheet: SheetSel::Current, kind: r.kind.clone() };
-    match adjust_ref(probe, edit) {
-        None => true,
-        Some(p) => p.kind != r.kind || (p.sheet != SheetSel::Current && p.sheet != r.sheet),
-    }
-}
-
-/// Whether [`adjust`] would change the formula `e` at all, without copying or rebuilding it.
-fn changes(e: &Expr, host: &str, target: &str, edit: &Edit) -> bool {
-    let mut changed = false;
-    e.walk(&mut |x| {
-        if !changed && let Expr::Ref(r) = x {
-            changed = on_target(r, host, target) && ref_changes(r, edit);
-        }
-    });
-    changed
-}
-
 /// Adjusts a formula living on sheet `host` after `edit` on sheet `target`.
 pub fn adjust(e: Expr, host: &str, target: &str, edit: &Edit) -> Expr {
     e.map(&mut |x| match x {
-        Expr::Ref(r) if on_target(&r, host, target) => match adjust_ref(r, edit) {
-            Some(r) => Expr::Ref(r),
-            None => Expr::Error(CellError::Ref),
-        },
+        Expr::Ref(r) => {
+            let on_target = match &r.sheet {
+                SheetSel::Current => host.eq_ignore_ascii_case(target),
+                SheetSel::Named(n) => n.eq_ignore_ascii_case(target),
+                SheetSel::Span(..) => false,
+            };
+            if !on_target {
+                return Expr::Ref(r);
+            }
+            match adjust_ref(&r, edit) {
+                Some(r) => Expr::Ref(r),
+                None => Expr::Error(CellError::Ref),
+            }
+        }
         other => other,
     })
 }
 
-/// [`adjust`] for a borrowed formula: `None` when the edit leaves it exactly as it is, so a
-/// caller can skip unaffected formulas without copying, rebuilding or printing them.
-pub fn adjust_if_changed(e: &Expr, host: &str, target: &str, edit: &Edit) -> Option<Expr> {
-    changes(e, host, target, edit).then(|| adjust(e.clone(), host, target, edit))
-}
-
 /// New position of an index after an insert (`None` never) or delete (`None` = deleted).
 fn map_index(v: u32, at: u32, count: u32, insert: bool, max: u32) -> Option<u32> {
     if insert {
@@ -195,7 +168,7 @@ fn map_span(lo: u32, hi: u32, at: u32, count: u32, insert: bool, max: u32) -> Op
     }
 }
 
-fn adjust_ref(r: Reference, edit: &Edit) -> Option<Reference> {
+fn adjust_ref(r: &Reference, edit: &Edit) -> Option<Reference> {
     match edit {
         Edit::Insert { axis, at, count } | Edit::Delete { axis, at, count } => {
             let insert = matches!(edit, Edit::Insert { .. });
@@ -220,7 +193,7 @@ fn adjust_ref(r: Reference, edit: &Edit) -> Option<Reference> {
                 }
                 (k, _) => k.clone(),
             };
-            Some(Reference { sheet: r.sheet, kind })
+            Some(Reference { sheet: r.sheet.clone(), kind })
         }
         Edit::InsertCells { axis, range } | Edit::DeleteCells { axis, range } => {
             // Like inserting/deleting lines, for references that lie within the shifted
@@ -231,7 +204,7 @@ fn adjust_ref(r: Reference, edit: &Edit) -> Option<Reference> {
                 Axis::Cols => (range.start.row <= span.start.row && span.end.row <= range.end.row, range.start.col, range.width()),
             };
             if !inside {
-                return Some(r);
+                return Some(r.clone());
             }
             let axis = *axis;
             let lines = if matches!(edit, Edit::InsertCells { .. }) { Edit::Insert { axis, at, count } } else { Edit::Delete { axis, at, count } };
@@ -242,7 +215,7 @@ fn adjust_ref(r: Reference, edit: &Edit) -> Option<Reference> {
             let dc = *to_col as i64 - from.start.col as i64;
             let range = r.range();
             if !from.contains_range(&range) {
-                return Some(r);
+                return Some(r.clone());
             }
             let mv = |a: &Anchor| -> Option<Anchor> {
                 let (row, col) = clamp_anchor(a.row as i64 + dr, a.col as i64 + dc)?;
@@ -260,11 +233,11 @@ fn adjust_ref(r: Reference, edit: &Edit) -> Option<Reference> {
                     RefKind::Cols(shift_line(*a, false, dc, MAX_COLS)?, *aa, shift_line(*b, false, dc, MAX_COLS)?, *ba)
                 }
             };
-            Some(Reference { sheet: r.sheet, kind })
+            Some(Reference { sheet: r.sheet.clone(), kind })
         }
         Edit::MoveToSheet { from, to_sheet, to_row, to_col } => {
             if !from.contains_range(&r.range()) {
-                return Some(r);
+                return Some(r.clone());
             }
             let mut moved = adjust_ref(r, &Edit::Move { from: *from, to_row: *to_row, to_col: *to_col })?;
             moved.sheet = SheetSel::Named(to_sheet.clone());

crates/formula/tests/it/adjust_oracle.rs

@@ -1,494 +0,0 @@
-//! `adjust`, `adjust_if_changed` and `shift_relative` against a verbatim copy of the previous
-//! implementation, which cloned and rebuilt every formula. The rewrite must give the same tree
-//! (and so the same text) for every formula and edit, and `adjust_if_changed` must say
-//! "unchanged" exactly when the old code returned the formula as it was.
-
-use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef};
-use gridcraft_formula::adjust::{Axis, Edit, adjust, adjust_if_changed, shift_relative};
-use gridcraft_formula::{Expr, parse, print};
-
-/// The implementation before the borrowed check, kept as the test oracle.
-mod old {
-    use gridcraft_core::{CellError, MAX_COLS, MAX_ROWS};
-    use gridcraft_formula::adjust::{Axis, Edit};
-    use gridcraft_formula::{Anchor, Expr, RefKind, Reference, SheetSel};
-
-    fn clamp_anchor(row: i64, col: i64) -> Option<(u32, u32)> {
-        if (0..MAX_ROWS as i64).contains(&row) && (0..MAX_COLS as i64).contains(&col) { Some((row as u32, col as u32)) } else { None }
-    }
-
-    pub fn shift_relative(e: Expr, dr: i64, dc: i64) -> Expr {
-        e.map(&mut |x| match x {
-            Expr::Ref(r) => match shift_ref(&r, dr, dc) {
-                Some(r) => Expr::Ref(r),
-                None => Expr::Error(CellError::Ref),
-            },
-            other => other,
-        })
-    }
-
-    fn shift_anchor(a: &Anchor, dr: i64, dc: i64) -> Option<Anchor> {
-        let row = if a.row_abs { a.row as i64 } else { a.row as i64 + dr };
-        let col = if a.col_abs { a.col as i64 } else { a.col as i64 + dc };
-        let (row, col) = clamp_anchor(row, col)?;
-        Some(Anchor { row, col, ..*a })
-    }
-
-    fn shift_line(v: u32, abs: bool, d: i64, max: u32) -> Option<u32> {
-        if abs {
-            return Some(v);
-        }
-        let n = v as i64 + d;
-        if (0..max as i64).contains(&n) { Some(n as u32) } else { None }
-    }
-
-    fn shift_ref(r: &Reference, dr: i64, dc: i64) -> Option<Reference> {
-        let kind = match &r.kind {
-            RefKind::Cell(a) => RefKind::Cell(shift_anchor(a, dr, dc)?),
-            RefKind::Range(a, b) => RefKind::Range(shift_anchor(a, dr, dc)?, shift_anchor(b, dr, dc)?),
-            RefKind::Rows(r0, a0, r1, a1) => RefKind::Rows(shift_line(*r0, *a0, dr, MAX_ROWS)?, *a0, shift_line(*r1, *a1, dr, MAX_ROWS)?, *a1),
-            RefKind::Cols(c0, a0, c1, a1) => RefKind::Cols(shift_line(*c0, *a0, dc, MAX_COLS)?, *a0, shift_line(*c1, *a1, dc, MAX_COLS)?, *a1),
-        };
-        Some(Reference { sheet: r.sheet.clone(), kind })
-    }
-
-    pub fn adjust(e: Expr, host: &str, target: &str, edit: &Edit) -> Expr {
-        e.map(&mut |x| match x {
-            Expr::Ref(r) => {
-                let on_target = match &r.sheet {
-                    SheetSel::Current => host.eq_ignore_ascii_case(target),
-                    SheetSel::Named(n) => n.eq_ignore_ascii_case(target),
-                    SheetSel::Span(..) => false,
-                };
-                if !on_target {
-                    return Expr::Ref(r);
-                }
-                match adjust_ref(&r, edit) {
-                    Some(r) => Expr::Ref(r),
-                    None => Expr::Error(CellError::Ref),
-                }
-            }
-            other => other,
-        })
-    }
-
-    fn map_index(v: u32, at: u32, count: u32, insert: bool, max: u32) -> Option<u32> {
-        if insert {
-            if v >= at {
-                let n = v as u64 + count as u64;
-                if n >= max as u64 { None } else { Some(n as u32) }
-            } else {
-                Some(v)
-            }
-        } else if v < at {
-            Some(v)
-        } else if v >= at.saturating_add(count) {
-            Some(v - count)
-        } else {
-            None
-        }
-    }
-
-    fn map_span(lo: u32, hi: u32, at: u32, count: u32, insert: bool, max: u32) -> Option<(u32, u32)> {
-        if insert {
-            let lo2 = if lo >= at { lo as u64 + count as u64 } else { lo as u64 };
-            let hi2 = if hi >= at { hi as u64 + count as u64 } else { hi as u64 };
-            let hi2 = hi2.min(max as u64 - 1);
-            if lo2 > hi2 {
-                return None;
-            }
-            Some((lo2 as u32, hi2 as u32))
-        } else {
-            let end = at.saturating_add(count);
-            if lo >= at && hi < end {
-                return None;
-            }
-            let lo2 = if lo < at {
-                lo
-            } else if lo >= end {
-                lo - count
-            } else {
-                at
-            };
-            let hi2 = if hi < at {
-                hi
-            } else if hi >= end {
-                hi - count
-            } else {
-                at.saturating_sub(1)
-            };
-            Some((lo2, hi2.max(lo2)))
-        }
-    }
-
-    fn adjust_ref(r: &Reference, edit: &Edit) -> Option<Reference> {
-        match edit {
-            Edit::Insert { axis, at, count } | Edit::Delete { axis, at, count } => {
-                let insert = matches!(edit, Edit::Insert { .. });
-                let kind = match (&r.kind, axis) {
-                    (RefKind::Cell(a), Axis::Rows) => RefKind::Cell(Anchor { row: map_index(a.row, *at, *count, insert, MAX_ROWS)?, ..*a }),
-                    (RefKind::Cell(a), Axis::Cols) => RefKind::Cell(Anchor { col: map_index(a.col, *at, *count, insert, MAX_COLS)?, ..*a }),
-                    (RefKind::Range(a, b), Axis::Rows) => {
-                        let (lo, hi) = map_span(a.row.min(b.row), a.row.max(b.row), *at, *count, insert, MAX_ROWS)?;
-                        RefKind::Range(Anchor { row: lo, ..*a }, Anchor { row: hi, ..*b })
-                    }
-                    (RefKind::Range(a, b), Axis::Cols) => {
-                        let (lo, hi) = map_span(a.col.min(b.col), a.col.max(b.col), *at, *count, insert, MAX_COLS)?;
-                        RefKind::Range(Anchor { col: lo, ..*a }, Anchor { col: hi, ..*b })
-                    }
-                    (RefKind::Rows(r0, a0, r1, a1), Axis::Rows) => {
-                        let (lo, hi) = map_span(*r0.min(r1), *r0.max(r1), *at, *count, insert, MAX_ROWS)?;
-                        RefKind::Rows(lo, *a0, hi, *a1)
-                    }
-                    (RefKind::Cols(c0, a0, c1, a1), Axis::Cols) => {
-                        let (lo, hi) = map_span(*c0.min(c1), *c0.max(c1), *at, *count, insert, MAX_COLS)?;
-                        RefKind::Cols(lo, *a0, hi, *a1)
-                    }
-                    (k, _) => k.clone(),
-                };
-                Some(Reference { sheet: r.sheet.clone(), kind })
-            }
-            Edit::InsertCells { axis, range } | Edit::DeleteCells { axis, range } => {
-                let span = r.range();
-                let (inside, at, count) = match axis {
-                    Axis::Rows => (range.start.col <= span.start.col && span.end.col <= range.end.col, range.start.row, range.height()),
-                    Axis::Cols => (range.start.row <= span.start.row && span.end.row <= range.end.row, range.start.col, range.width()),
-                };
-                if !inside {
-                    return Some(r.clone());
-                }
-                let axis = *axis;
-                let lines =
-                    if matches!(edit, Edit::InsertCells { .. }) { Edit::Insert { axis, at, count } } else { Edit::Delete { axis, at, count } };
-                adjust_ref(r, &lines)
-            }
-            Edit::Move { from, to_row, to_col } => {
-                let dr = *to_row as i64 - from.start.row as i64;
-                let dc = *to_col as i64 - from.start.col as i64;
-                let range = r.range();
-                if !from.contains_range(&range) {
-                    return Some(r.clone());
-                }
-                let mv = |a: &Anchor| -> Option<Anchor> {
-                    let (row, col) = clamp_anchor(a.row as i64 + dr, a.col as i64 + dc)?;
-                    Some(Anchor { row, col, ..*a })
-                };
-                let kind = match &r.kind {
-                    RefKind::Cell(a) => RefKind::Cell(mv(a)?),
-                    RefKind::Range(a, b) => RefKind::Range(mv(a)?, mv(b)?),
-                    RefKind::Rows(a, aa, b, ba) => {
-                        let dr = *to_row as i64 - from.start.row as i64;
-                        RefKind::Rows(shift_line(*a, false, dr, MAX_ROWS)?, *aa, shift_line(*b, false, dr, MAX_ROWS)?, *ba)
-                    }
-                    RefKind::Cols(a, aa, b, ba) => {
-                        let dc = *to_col as i64 - from.start.col as i64;
-                        RefKind::Cols(shift_line(*a, false, dc, MAX_COLS)?, *aa, shift_line(*b, false, dc, MAX_COLS)?, *ba)
-                    }
-                };
-                Some(Reference { sheet: r.sheet.clone(), kind })
-            }
-            Edit::MoveToSheet { from, to_sheet, to_row, to_col } => {
-                if !from.contains_range(&r.range()) {
-                    return Some(r.clone());
-                }
-                let mut moved = adjust_ref(r, &Edit::Move { from: *from, to_row: *to_row, to_col: *to_col })?;
-                moved.sheet = SheetSel::Named(to_sheet.clone());
-                Some(moved)
-            }
-        }
-    }
-}
-
-/// Formulas with every reference shape the adjustment distinguishes.
-const FORMULAS: &[&str] = &[
-    "A1",
-    "B2+C3*D4",
-    "$B$2+B$2+$B2",
-    "SUM(A1:A10)+SUM(B2:C3)+SUM($B$2:$C$3)",
-    "SUM(C3:B2)",
-    "SUM(A:A)+SUM($B:$C)+SUM(2:2)+SUM($3:$5)",
-    "SUM(A1:.A7)+SUM(B:.B)+ROWS(2.:.6)+SUM(A1.:B1)",
-    "S!B2+s!C3+'S'!A1:B9",
-    "Other!B2+Other!A:A+Other!2:3",
-    "'My Sheet'!B2+'my sheet'!C3:D4",
-    "Dest!B2+S!B2",
-    "SUM(S:Other!B2)+SUM(Other:S!A1:C3)",
-    "XFD1048576+XFD1+A1048576+SUM(XFC1048575:XFD1048576)",
-    "SUM(1048576:1048576)+SUM(XFD:XFD)",
-    "VLOOKUP($B2,Lookup!$A$1:$D$500,3,FALSE)",
-    "IF(AND(C2>0,D2<100),C2*1.07,IF(E2=\"x\",\"yes\",\"no\"))",
-    "Table1[@Qty]*Table1[@Price]+SUM(Table1[[#Data],[Qty]])",
-    "SUMPRODUCT(A2:C2,{1,2,3})",
-    "LET(x,A2*2,y,B2+x,x*y)",
-    "LAMBDA(x,x+B2)(C3)",
-    "IFERROR(INDEX(Lookup!$A:$A,MATCH(F2,Lookup!$B:$B,0)),\"\")",
-    "-B2%+(C3)^2&\"a\"",
-    "A1#+S!B2#",
-    "S!MyName+MyName+#REF!+S!#REF!",
-    "COUNTIFS(Data!$A:$A,A2,Data!$C:$C,\">=\"&$G$2)",
-    "1+2",
-    "\"text\"",
-    "B2:C3 B3:D4",
-    "(B2:C3,E5)",
-    "INDIRECT(\"B2\")+OFFSET(B2,1,1)",
-    // From the parser edge cases (prefixes and LET parameter names).
-    "LET(_xlpm.TRUE,1,_xlpm.TRUE+1)",
-    "LET(_xlpm.A1,1,_xlpm.A1)",
-    "LAMBDA(_xlpm.x,_xlpm.x+1)(2)",
-    "_xlfn.LET(_xlpm.R1C1,1,_xlpm.R1C1*2)",
-    "LET(_xlpm.FALSE,2,_xlpm.FALSE)",
-    "_xlpm.SUM(1)",
-    "LET(_xlpm.x_1,1,_xlpm.x_1)",
-    "_xlfn.ANCHORARRAY(A1)+_xlfn.SINGLE(B1:B3)",
-    "SUM(_xlfn._TRO_ALL(A1:E10))",
-];
-
-fn col(c: u32) -> String {
-    gridcraft_core::addr::col_to_letters(c)
-}
-
-/// The realistic mix the structural-edit benchmark uses, row-dependent.
-fn mix(i: usize, r: u32) -> String {
-    let r1 = r + 1;
-    match i % 12 {
-        0 => format!("SUM(A{r1}:A{})", r1 + 9),
-        1 => format!("VLOOKUP($B{r1},Lookup!$A$1:$D$500,3,FALSE)"),
-        2 => format!("IF(AND(C{r1}>0,D{r1}<100),C{r1}*1.07,IF(E{r1}=\"x\",\"yes\",\"no\"))"),
-        3 => format!("'My Sheet'!B{r1}+Data!C{r1}*2-1"),
-        4 => "Table1[@Qty]*Table1[@Price]".to_string(),
-        5 => format!("SUMPRODUCT(A{r1}:C{r1},{{1,2,3}})+SUM(Table1[[#Data],[Qty]])"),
-        6 => format!("\"Lorem ipsum\"&A{r1}&\" units\""),
-        7 => format!("IFERROR(INDEX(Lookup!$A:$A,MATCH(F{r1},Lookup!$B:$B,0)),\"\")"),
-        8 => (0..20).map(|k| format!("{}{r1}", col(k))).collect::<Vec<_>>().join("+"),
-        9 => format!("LET(x,A{r1}*2,y,B{r1}+x,x*y)"),
-        10 => format!("ROUND(AVERAGE(B{r1}:F{r1})*(1+$H$1)^2,2)"),
-        _ => format!("COUNTIFS(Data!$A:$A,A{r1},Data!$C:$C,\">=\"&$G$2)"),
-    }
-}
-
-fn range(r0: u32, c0: u32, r1: u32, c1: u32) -> RangeRef {
-    RangeRef::new(CellRef::new(r0, c0), CellRef::new(r1, c1))
-}
-
-/// Every edit kind, at the sheet's start, middle and edges, with counts that run past the end.
-fn edits() -> Vec<Edit> {
-    let mut v = Vec::new();
-    for axis in [Axis::Rows, Axis::Cols] {
-        let max = if axis == Axis::Rows { MAX_ROWS } else { MAX_COLS };
-        for at in [0, 1, 2, 3, 9, max - 2, max - 1] {
-            for count in [0, 1, 2, 5, max - 1, max, u32::MAX] {
-                v.push(Edit::Insert { axis, at, count });
-                v.push(Edit::Delete { axis, at, count });
-            }
-        }
-        for r in [
-            range(1, 1, 2, 2),
-            range(0, 0, 0, 0),
-            range(1, 0, 1, MAX_COLS - 1),
-            range(0, 1, MAX_ROWS - 1, 1),
-            range(MAX_ROWS - 2, MAX_COLS - 2, MAX_ROWS - 1, MAX_COLS - 1),
-        ] {
-            v.push(Edit::InsertCells { axis, range: r });
-            v.push(Edit::DeleteCells { axis, range: r });
-        }
-    }
-    let blocks = [
-        range(1, 1, 2, 2),
-        range(0, 0, 0, 0),
-        range(0, 0, MAX_ROWS - 1, MAX_COLS - 1),
-        range(0, 0, MAX_ROWS - 1, 2),
-        range(1, 0, 4, MAX_COLS - 1),
-        range(0, 0, 20, 10),
-    ];
-    let targets = [(9, 3), (0, 0), (1, 1), (MAX_ROWS - 1, MAX_COLS - 1), (MAX_ROWS - 2, 0)];
-    for from in blocks {
-        for (to_row, to_col) in targets {
-            v.push(Edit::Move { from, to_row, to_col });
-            for to_sheet in ["Dest", "S", "s", "Other"] {
-                v.push(Edit::MoveToSheet { from, to_sheet: to_sheet.to_string(), to_row, to_col });
-            }
-        }
-    }
-    v
-}
-
-/// Compares the new and the old adjustment of `src` for every host and edit; returns the
-/// number of (formula, host, edit) cases checked, or 0 when `src` does not parse.
-fn check(src: &str, edits: &[Edit]) -> usize {
-    let Ok(e) = parse(src) else { return 0 };
-    let mut n = 0;
-    for host in ["S", "s", "Other", "My Sheet"] {
-        for edit in edits {
-            let want = old::adjust(e.clone(), host, "S", edit);
-            let got = adjust(e.clone(), host, "S", edit);
-            assert!(got == want, "{src} on {host} after {edit:?}: {} vs {}", print(&got), print(&want));
-            assert_eq!(print(&got), print(&want), "{src} on {host} after {edit:?}");
-            match adjust_if_changed(&e, host, "S", edit) {
-                None => assert!(want == e, "{src} on {host} after {edit:?}: reported unchanged, old gives {}", print(&want)),
-                Some(x) => {
-                    assert!(want != e, "{src} on {host} after {edit:?}: reported changed but the old code keeps it");
-                    assert!(x == want, "{src} on {host} after {edit:?}: {} vs {}", print(&x), print(&want));
-                }
-            }
-            n += 1;
-        }
-    }
-    for (dr, dc) in [(0, 0), (1, 0), (0, 1), (-1, -1), (5, 3), (-3, 2), (MAX_ROWS as i64, 0), (0, -(MAX_COLS as i64)), (1_048_575, 16_383)] {
-        let want = old::shift_relative(e.clone(), dr, dc);
-        let got = shift_relative(e.clone(), dr, dc);
-        assert!(got == want, "{src} shifted by ({dr}, {dc}): {} vs {}", print(&got), print(&want));
-    }
-    n
-}
-
-#[test]
-fn adjust_matches_the_previous_implementation_for_every_edit_kind() {
-    let edits = edits();
-    let mut cases = 0;
-    for src in FORMULAS {
-        let n = check(src, &edits);
-        assert!(n > 0, "{src} does not parse");
-        cases += n;
-    }
-    for i in 0..48 {
-        // Rows 1-2 and 1,048,565-1,048,566 of the mix (its longest range reaches 9 rows further
-        // down, to the last row): near both edges of the sheet.
-        let row = if i < 24 { (i / 12) as u32 } else { MAX_ROWS - 12 + (i / 12 - 2) as u32 };
-        let src = mix(i, row);
-        let n = check(&src, &edits);
-        assert!(n > 0, "{src} does not parse");
-        cases += n;
-    }
-    assert!(cases > 100_000, "{cases}");
-}
-
-/// A small deterministic generator: a failing case is reproduced by rerunning the test, and
-/// its message names the case's index in the stream.
-struct Rng(u64);
-
-impl Rng {
-    fn next(&mut self) -> u64 {
-        self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
-        self.0 >> 33
-    }
-    fn below(&mut self, n: u64) -> u64 {
-        self.next() % n
-    }
-    fn line(&mut self, max: u32) -> u32 {
-        match self.below(3) {
-            0 => self.below(12) as u32,
-            1 => max - 1 - self.below(12) as u32,
-            _ => self.below(max as u64) as u32,
-        }
-    }
-}
-
-fn random_ref(rng: &mut Rng) -> String {
-    let sheet = ["", "", "S!", "s!", "Other!", "'My Sheet'!", "S:Other!"][rng.below(7) as usize];
-    let dollar = |rng: &mut Rng| if rng.below(3) == 0 { "$" } else { "" };
-    let cell = |rng: &mut Rng| format!("{}{}{}{}", dollar(rng), col(rng.line(MAX_COLS)), dollar(rng), rng.line(MAX_ROWS) + 1);
-    let body = match rng.below(4) {
-        0 => cell(rng),
-        1 => format!("{}:{}", cell(rng), cell(rng)),
-        2 => {
-            let (a, b) = (rng.line(MAX_ROWS) + 1, rng.line(MAX_ROWS) + 1);
-            format!("{}{a}:{}{b}", dollar(rng), dollar(rng))
-        }
-        _ => {
-            let (a, b) = (rng.line(MAX_COLS), rng.line(MAX_COLS));
-            format!("{}{}:{}{}", dollar(rng), col(a), dollar(rng), col(b))
-        }
-    };
-    format!("{sheet}{body}")
-}
-
-fn random_edit(rng: &mut Rng) -> Edit {
-    let axis = if rng.below(2) == 0 { Axis::Rows } else { Axis::Cols };
-    let max = if axis == Axis::Rows { MAX_ROWS } else { MAX_COLS };
-    let block = |rng: &mut Rng| {
-        let (r0, r1) = (rng.line(MAX_ROWS), rng.line(MAX_ROWS));
-        let (c0, c1) = (rng.line(MAX_COLS), rng.line(MAX_COLS));
-        range(r0.min(r1), c0.min(c1), r0.max(r1), c0.max(c1))
-    };
-    let count = if rng.below(8) == 0 { rng.below(u32::MAX as u64) as u32 } else { rng.below(20) as u32 };
-    match rng.below(7) {
-        0 => Edit::Insert { axis, at: rng.line(max), count },
-        1 => Edit::Delete { axis, at: rng.line(max), count },
-        2 => Edit::InsertCells { axis, range: block(rng) },
-        3 => Edit::DeleteCells { axis, range: block(rng) },
-        4 => Edit::Move { from: block(rng), to_row: rng.line(MAX_ROWS), to_col: rng.line(MAX_COLS) },
-        _ => Edit::MoveToSheet {
-            from: block(rng),
-            to_sheet: ["Dest", "S", "other"][rng.below(3) as usize].to_string(),
-            to_row: rng.line(MAX_ROWS),
-            to_col: rng.line(MAX_COLS),
-        },
-    }
-}
-
-/// Random references near the sheet's edges and random edits: "unchanged" is reported exactly
-/// when the previous implementation leaves the formula as it was, and a reported change is the
-/// old result.
-#[test]
-fn adjust_if_changed_reports_unchanged_exactly_when_nothing_moves() {
-    let mut rng = Rng(0x5eed);
-    let (mut unchanged, mut changed) = (0, 0);
-    for case in 0..20_000 {
-        let refs: Vec<String> = (0..1 + rng.below(4)).map(|_| random_ref(&mut rng)).collect();
-        let src = format!("SUM({})", refs.join(","));
-        let Ok(e) = parse(&src) else { panic!("case {case}: {src} does not parse") };
-        let edit = random_edit(&mut rng);
-        let host = ["S", "Other"][rng.below(2) as usize];
-        let want = old::adjust(e.clone(), host, "S", &edit);
-        assert!(adjust(e.clone(), host, "S", &edit) == want, "case {case}: {src} on {host} after {edit:?}");
-        match adjust_if_changed(&e, host, "S", &edit) {
-            None => {
-                assert!(want == e, "case {case}: {src} on {host} after {edit:?}: reported unchanged, old gives {}", print(&want));
-                unchanged += 1;
-            }
-            Some(x) => {
-                assert!(want != e && x == want, "case {case}: {src} on {host} after {edit:?}");
-                changed += 1;
-            }
-        }
-    }
-    // Both outcomes are exercised in quantity.
-    assert!(unchanged > 2_000 && changed > 2_000, "unchanged {unchanged}, changed {changed}");
-}
-
-/// The whole formula corpus (one formula per line, with or without `=`) when
-/// `GRIDCRAFT_ADJUST_CORPUS` names a file: `cargo test -p gridcraft-formula --test it -- --ignored adjust_corpus`.
-#[test]
-#[ignore = "needs GRIDCRAFT_ADJUST_CORPUS"]
-fn adjust_corpus_matches_the_previous_implementation() {
-    let Ok(path) = std::env::var("GRIDCRAFT_ADJUST_CORPUS") else { return };
-    let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("{path}: {e}"));
-    let edits = edits();
-    let (mut parsed, mut skipped, mut cases) = (0, 0, 0);
-    for line in text.lines().filter(|l| !l.trim().is_empty()) {
-        match check(line, &edits) {
-            0 => skipped += 1,
-            n => {
-                parsed += 1;
-                cases += n;
-            }
-        }
-    }
-    eprintln!("corpus: {parsed} formulas parsed, {skipped} skipped (do not parse), {cases} cases");
-}
-
-#[test]
-fn unaffected_formula_is_returned_as_is() {
-    let e: Expr = parse("Other!B2+SUM(A1:A3)").unwrap();
-    let ins = Edit::Insert { axis: Axis::Rows, at: 5, count: 1 };
-    // Row 6 inserted: A1:A3 lies above it and Other!B2 is not on S, so nothing moves, whichever
-    // sheet the formula lives on (on Other, A1:A3 is on Other too).
-    assert!(adjust_if_changed(&e, "S", "S", &ins).is_none());
-    assert!(adjust_if_changed(&e, "Other", "S", &ins).is_none());
-    // Row 1 inserted: A1:A3 on S moves, Other!B2 does not.
-    let top = Edit::Insert { axis: Axis::Rows, at: 0, count: 1 };
-    assert_eq!(adjust_if_changed(&e, "S", "S", &top).map(|x| print(&x)).as_deref(), Some("Other!B2+SUM(A2:A4)"));
-    // A cut that moves a block onto the same place still qualifies its references with the sheet.
-    let same_place = Edit::MoveToSheet { from: range(0, 0, 2, 0), to_sheet: "S".into(), to_row: 0, to_col: 0 };
-    assert_eq!(adjust_if_changed(&e, "S", "S", &same_place).map(|x| print(&x)).as_deref(), Some("Other!B2+SUM(S!A1:A3)"));
-}

crates/formula/tests/it/main.rs

@@ -1,5 +1,4 @@
 //! The crate's integration tests, one module per file, built as one test binary.
 
-mod adjust_oracle;
 mod printer_roundtrip;
 mod spanish_input;

crates/functions/src/special.rs

@@ -88,17 +88,11 @@ pub(crate) fn reg_gamma_p(a: f64, x: f64) -> f64 {
     if x.is_infinite() {
         return 1.0;
     }
-    if x < a + 1.0 { gamma_series(a, x, front_of(a, x)) } else { 1.0 - gamma_cf(a, x, front_of(a, x)) }
+    if x < a + 1.0 { gamma_series(a, x) } else { 1.0 - gamma_cf(a, x) }
 }
 
 /// Regularised upper incomplete gamma Q(a, x) = 1 − P(a, x).
 pub(crate) fn reg_gamma_q(a: f64, x: f64) -> f64 {
-    let front = if a > 0.0 && x > 0.0 && x.is_finite() { (-x + a * x.ln() - ln_gamma(a)).exp() } else { 0.0 };
-    reg_gamma_q_front(a, x, front)
-}
-
-/// Q(a, x) given the prefactor `e^-x x^a / Γ(a)` (the Poisson mass at a - 1, times x).
-pub(crate) fn reg_gamma_q_front(a: f64, x: f64, front: f64) -> f64 {
     if a.is_nan() || a <= 0.0 || x.is_nan() || x < 0.0 || !a.is_finite() {
         return f64::NAN;
     }
@@ -108,15 +102,10 @@ pub(crate) fn reg_gamma_q_front(a: f64, x: f64, front: f64) -> f64 {
     if x.is_infinite() {
         return 0.0;
     }
-    if x < a + 1.0 { 1.0 - gamma_series(a, x, front) } else { gamma_cf(a, x, front) }
+    if x < a + 1.0 { 1.0 - gamma_series(a, x) } else { gamma_cf(a, x) }
 }
 
-/// `e^-x x^a / Γ(a)`.
-fn front_of(a: f64, x: f64) -> f64 {
-    (-x + a * x.ln() - ln_gamma(a)).exp()
-}
-
-fn gamma_series(a: f64, x: f64, front: f64) -> f64 {
+fn gamma_series(a: f64, x: f64) -> f64 {
     let mut ap = a;
     let mut sum = 1.0 / a;
     let mut del = sum;
@@ -128,10 +117,10 @@ fn gamma_series(a: f64, x: f64, front: f64) -> f64 {
             break;
         }
     }
-    sum * front
+    sum * (-x + a * x.ln() - ln_gamma(a)).exp()
 }
 
-fn gamma_cf(a: f64, x: f64, front: f64) -> f64 {
+fn gamma_cf(a: f64, x: f64) -> f64 {
     let tiny = 1e-300;
     let mut b = x + 1.0 - a;
     let mut c = 1.0 / tiny;
@@ -155,7 +144,7 @@ fn gamma_cf(a: f64, x: f64, front: f64) -> f64 {
             break;
         }
     }
-    front * h
+    (-x + a * x.ln() - ln_gamma(a)).exp() * h
 }
 
 /// Error function.
@@ -198,17 +187,6 @@ pub(crate) fn erfc(x: f64) -> f64 {
 
 /// Regularised incomplete beta I_x(a, b).
 pub(crate) fn reg_inc_beta(x: f64, a: f64, b: f64) -> f64 {
-    if x > 0.0 && x < 1.0 && a > 0.0 && b > 0.0 {
-        let ln_bt = -ln_beta(a, b) + a * x.ln() + b * (1.0 - x).ln();
-        return reg_inc_beta_front(x, a, b, ln_bt.exp());
-    }
-    reg_inc_beta_front(x, a, b, 0.0)
-}
-
-/// I_x(a, b) given the prefactor `bt = x^a (1-x)^b / B(a, b)` (symmetric in the two sides). A
-/// caller that knows `bt` more accurately than the log-gamma route gives (the binomial mass, for
-/// instance) passes it here.
-pub(crate) fn reg_inc_beta_front(x: f64, a: f64, b: f64, bt: f64) -> f64 {
     if a.is_nan() || a <= 0.0 || b.is_nan() || b <= 0.0 || !(0.0..=1.0).contains(&x) {
         return f64::NAN;
     }
@@ -218,6 +196,8 @@ pub(crate) fn reg_inc_beta_front(x: f64, a: f64, b: f64, bt: f64) -> f64 {
     if x == 1.0 {
         return 1.0;
     }
+    let ln_bt = -ln_beta(a, b) + a * x.ln() + b * (1.0 - x).ln();
+    let bt = ln_bt.exp();
     if x < (a + 1.0) / (a + b + 2.0) { bt * beta_cf(a, b, x) / a } else { 1.0 - bt * beta_cf(b, a, 1.0 - x) / b }
 }
 

crates/functions/src/stat.rs

@@ -3,10 +3,7 @@
 
 use gridcraft_core::{CellError, Value};
 
-use crate::special::{
-    erf, gamma, invert, ln_beta, ln_gamma, norm_cdf, norm_inv, norm_pdf, reg_gamma_p, reg_gamma_q, reg_gamma_q_front, reg_inc_beta,
-    reg_inc_beta_front,
-};
+use crate::special::{erf, gamma, invert, ln_beta, ln_gamma, norm_cdf, norm_inv, norm_pdf, reg_gamma_p, reg_gamma_q, reg_inc_beta};
 use crate::util::{A, R, S, arg, array_numbers, array_val, as_array, boolean, has, num, num_val, numbers, numbers_a, opt_num};
 use crate::{Arg, Ctx, FnSpec, VAR};
 

crates/functions/src/stat/descriptive.rs

@@ -33,40 +33,19 @@ pub(super) fn var_p(x: &[f64]) -> R<f64> {
     Ok(devsq(x) / x.len() as f64)
 }
 
-pub(super) fn sorted(mut v: Vec<f64>) -> Vec<f64> {
+fn sorted(mut v: Vec<f64>) -> Vec<f64> {
     v.sort_by(f64::total_cmp);
     v
 }
 
-/// Sorts `v` if it is already monotone in `total_cmp` order (a descending slice is reversed) and
-/// says whether it did. At most two passes, each stopping at the first out-of-order pair, so
-/// unordered data costs next to nothing. Needed because the std sort recognises ascending and
-/// descending runs in O(n) with a small constant; selection is O(n) too but measured 1.2-1.8x
-/// slower on such input.
-fn sorted_if_monotone(v: &mut [f64]) -> bool {
-    if v.is_sorted_by(|a, b| a.total_cmp(b).is_le()) {
-        return true;
-    }
-    if v.is_sorted_by(|a, b| a.total_cmp(b).is_ge()) {
-        v.reverse();
-        return true;
-    }
-    false
-}
-
 pub(super) fn median(v: Vec<f64>) -> R<f64> {
     if v.is_empty() {
         return Err(CellError::Num);
     }
-    let mut v = v;
-    let n = v.len();
-    if sorted_if_monotone(&mut v) {
-        let hi = v.get(n / 2).copied().unwrap_or(0.0);
-        return if n % 2 == 1 { Ok(hi) } else { Ok(v.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) };
-    }
-    let (lower, hi, _) = v.select_nth_unstable_by(n / 2, f64::total_cmp);
-    let hi = *hi;
-    if n % 2 == 1 { Ok(hi) } else { Ok(lower.iter().copied().max_by(f64::total_cmp).unwrap_or(0.0).midpoint(hi)) }
+    let s = sorted(v);
+    let n = s.len();
+    let hi = s.get(n / 2).copied().unwrap_or(0.0);
+    if n % 2 == 1 { Ok(hi) } else { Ok(s.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) }
 }
 
 /// Values occurring at least twice, ordered by first occurrence, with their (equal, maximal) count.
@@ -147,54 +126,34 @@ pub(super) fn max_of(v: &[f64]) -> f64 {
 }
 
 /// k-th largest (k is rounded up like Excel).
-pub(super) fn kth(v: Vec<f64>, k: f64, largest: bool) -> R<f64> {
+fn kth(v: Vec<f64>, k: f64, largest: bool) -> R<f64> {
     let k = k.ceil();
     if k.is_nan() || k < 1.0 || k > v.len() as f64 {
         return Err(CellError::Num);
     }
-    let mut v = v;
+    let s = sorted(v);
     let k = k as usize;
-    let idx = if largest { v.len() - k } else { k - 1 };
-    // Selection instead of a full sort (monotone input is read directly); same total order, so the
-    // same bit pattern as `sorted(v)[idx]`.
-    if sorted_if_monotone(&mut v) {
-        return v.get(idx).copied().ok_or(CellError::Num);
-    }
-    Ok(*v.select_nth_unstable_by(idx, f64::total_cmp).1)
+    let idx = if largest { s.len() - k } else { k - 1 };
+    s.get(idx).copied().ok_or(CellError::Num)
 }
 
-/// Value at fractional rank `pos` of the sorted data, linearly interpolated, found by selection.
-fn interp(mut v: Vec<f64>, pos: f64) -> R<f64> {
+fn interp(s: &[f64], pos: f64) -> R<f64> {
     let i = pos.floor();
     let frac = pos - i;
     let i = i as usize;
-    if i >= v.len() {
-        return Err(CellError::Num);
+    let lo = *s.get(i).ok_or(CellError::Num)?;
+    match s.get(i + 1) {
+        Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)),
+        _ => Ok(lo),
     }
-    if sorted_if_monotone(&mut v) {
-        let lo = v.get(i).copied().ok_or(CellError::Num)?;
-        return match v.get(i + 1) {
-            Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)),
-            _ => Ok(lo),
-        };
-    }
-    let (_, lo, upper) = v.select_nth_unstable_by(i, f64::total_cmp);
-    let lo = *lo;
-    // The next order statistic is the minimum of the upper partition.
-    if frac > 0.0
-        && let Some(hi) = upper.iter().copied().min_by(f64::total_cmp)
-    {
-        return Ok(lo + frac * (hi - lo));
-    }
-    Ok(lo)
 }
 
 pub(super) fn percentile_inc(v: Vec<f64>, k: f64) -> R<f64> {
     if v.is_empty() || !(0.0..=1.0).contains(&k) {
         return Err(CellError::Num);
     }
-    let pos = k * (v.len() - 1) as f64;
-    interp(v, pos)
+    let s = sorted(v);
+    interp(&s, k * (s.len() - 1) as f64)
 }
 
 pub(super) fn percentile_exc(v: Vec<f64>, k: f64) -> R<f64> {
@@ -206,7 +165,8 @@ pub(super) fn percentile_exc(v: Vec<f64>, k: f64) -> R<f64> {
     if pos < 1.0 || pos > n {
         return Err(CellError::Num);
     }
-    interp(v, pos - 1.0)
+    let s = sorted(v);
+    interp(&s, pos - 1.0)
 }
 
 pub(super) fn quartile_inc(v: Vec<f64>, q: f64) -> R<f64> {

crates/functions/src/stat/distributions.rs

@@ -1,7 +1,7 @@
 use super::descriptive::{arg_nums, arg_pairs, mean, var_s};
 use super::{
     Arg, C, CellError, R, Value, arg, as_array, boolean, erf, gamma, has, invert, ln_beta, ln_gamma, norm_cdf, norm_inv, norm_pdf, num, num_val,
-    reg_gamma_p, reg_gamma_q, reg_gamma_q_front, reg_inc_beta, reg_inc_beta_front,
+    reg_gamma_p, reg_gamma_q, reg_inc_beta,
 };
 
 // ---------------------------------------------------------------------------------------------
@@ -93,97 +93,6 @@ fn f_pdf(x: f64, d1: f64, d2: f64) -> f64 {
 
 const MAX_BINOM_TRIALS: f64 = 2_147_483_646.0;
 
-/// Stirling-series error `ln n! - ((n + 1/2) ln n - n + ln(2π)/2)` for integer `n >= 1`: exact
-/// table (computed with 60-digit Decimal arithmetic) up to 30, then the series, whose first
-/// omitted term is below 1e-19 there.
-fn stirlerr(n: f64) -> f64 {
-    const TABLE: [f64; 31] = [
-        0.0,
-        0.08106146679532726,
-        0.0413406959554093,
-        0.02767792568499834,
-        0.020790672103765093,
-        0.016644691189821193,
-        0.013876128823070748,
-        0.01189670994589177,
-        0.010411265261972096,
-        0.009255462182712733,
-        0.00833056343336287,
-        0.007573675487951841,
-        0.00694284010720953,
-        0.006408994188004207,
-        0.0059513701127588475,
-        0.005554733551962801,
-        0.0052076559196096404,
-        0.004901395948434738,
-        0.004629153749334028,
-        0.004385560249232324,
-        0.004166319691996922,
-        0.00396795421864086,
-        0.0037876180684444346,
-        0.0036229602246830948,
-        0.003472021382978767,
-        0.003333155636728093,
-        0.003204970228055038,
-        0.0030862786826087773,
-        0.002976063983550409,
-        0.0028734493623524663,
-        0.0027776749297526936,
-    ];
-    if n <= 30.0 {
-        return TABLE.get(n as usize).copied().unwrap_or(0.0);
-    }
-    let r = 1.0 / n;
-    let r2 = r * r;
-    r * (1.0 / 12.0 - r2 * (1.0 / 360.0 - r2 * (1.0 / 1260.0 - r2 * (1.0 / 1680.0 - r2 * (1.0 / 1188.0)))))
-}
-
-/// `x ln(x/np) + np - x` without the cancellation of the direct formula when `x` is near `np`
-/// (Loader, 2000).
-fn bd0(x: f64, np: f64) -> f64 {
-    if (x - np).abs() < 0.1 * (x + np) {
-        let v = (x - np) / (x + np);
-        let mut s = (x - np) * v;
-        if s.abs() < f64::MIN_POSITIVE {
-            return s;
-        }
-        let mut ej = 2.0 * x * v;
-        let v2 = v * v;
-        for j in 1..1000 {
-            ej *= v2;
-            let s1 = s + ej / f64::from(2 * j + 1);
-            if s1 == s {
-                return s1;
-            }
-            s = s1;
-        }
-    }
-    x * (x / np).ln() + np - x
-}
-
-/// `(1 - p)^e` with the rounding error of `1 - p` (it is not exact for `p < 1/2`) folded back in,
-/// which `e` would otherwise multiply.
-fn pow_one_minus(p: f64, e: f64) -> f64 {
-    let hi = 1.0 - p;
-    let lo = (1.0 - hi) - p;
-    let r = hi.powf(e) * (e * (lo / hi).ln_1p()).exp();
-    // An exponent so large that the two factors under- and overflow: the plain form is enough.
-    if r.is_nan() { (e * (-p).ln_1p()).exp() } else { r }
-}
-
-/// `C(n, k)` for a small `k` as a product of `k` ratios.
-fn choose_small(n: f64, k: f64) -> f64 {
-    let mut c = 1.0;
-    let mut j = 0.0;
-    while j < k {
-        c *= (n - j) / (j + 1.0);
-        j += 1.0;
-    }
-    c
-}
-
-/// Binomial mass at integer `k`, `0 <= k <= n`, by Loader's saddle-point formula: no log-gamma
-/// of large numbers, so the relative error stays near 1e-15 for any `n`.
 fn binom_pmf(k: f64, n: f64, p: f64) -> f64 {
     if k < 0.0 || k > n {
         return 0.0;
@@ -194,67 +103,7 @@ fn binom_pmf(k: f64, n: f64, p: f64) -> f64 {
     if p == 1.0 {
         return if k == n { 1.0 } else { 0.0 };
     }
-    if k == 0.0 {
-        return if n == 0.0 { 1.0 } else { pow_one_minus(p, n) };
-    }
-    if k == n {
-        return p.powf(n);
-    }
-    // A few successes or a few failures: the product form has no large cancelling terms.
-    // (Not for astronomically large n, or when either power underflows: the
-    // saddle-point form below handles those through logs.)
-    if n < 1e30 && p.powf(k) > 1e-280 {
-        if k < 16.0 {
-            let rest = pow_one_minus(p, n - k);
-            if rest >= f64::MIN_POSITIVE {
-                return choose_small(n, k) * p.powi(k as i32) * rest;
-            }
-        }
-        if n - k < 16.0 {
-            return choose_small(n, n - k) * p.powf(k) * pow_one_minus(p, n - k);
-        }
-    }
-    let q = 1.0 - p;
-    let lc = stirlerr(n) - stirlerr(k) - stirlerr(n - k) - bd0(k, n * p) - bd0(n - k, n * q);
-    let lf = std::f64::consts::TAU.ln() + k.ln() + (-k / n).ln_1p();
-    (lc - 0.5 * lf).exp()
-}
-
-/// Sum of the binomial masses 0..=k for `n <= 10_000`: starts at the term nearest the mode
-/// (accurate by the formula above) and walks away from it by the ratio of neighbouring masses,
-/// one multiply per term, stopping once the terms no longer matter. Above the mode it sums the
-/// upper tail instead and subtracts it from 1.
-fn binom_cdf_sum(k: f64, n: f64, p: f64) -> f64 {
-    let q = 1.0 - p;
-    if p == 0.0 {
-        return 1.0;
-    }
-    if p == 1.0 {
-        return 0.0;
-    }
-    if k <= n * p {
-        // mass(i - 1) = mass(i) * i / (n - i + 1) * q / p
-        let mut t = binom_pmf(k, n, p);
-        let mut s = t;
-        let mut i = k;
-        while i >= 1.0 && t > s * 1e-18 {
-            t *= i / (n - i + 1.0) * (q / p);
-            s += t;
-            i -= 1.0;
-        }
-        s.min(1.0)
-    } else {
-        // mass(i + 1) = mass(i) * (n - i) / (i + 1) * p / q
-        let mut t = binom_pmf(k + 1.0, n, p);
-        let mut s = t;
-        let mut i = k + 1.0;
-        while i < n && t > s * 1e-18 {
-            t *= (n - i) / (i + 1.0) * (p / q);
-            s += t;
-            i += 1.0;
-        }
-        (1.0 - s).max(0.0)
-    }
+    (ln_comb(n, k) + k * p.ln() + (n - k) * (1.0 - p).ln()).exp()
 }
 
 fn binom_cdf(k: f64, n: f64, p: f64) -> f64 {
@@ -265,7 +114,13 @@ fn binom_cdf(k: f64, n: f64, p: f64) -> f64 {
         return 1.0;
     }
     if n <= 10_000.0 {
-        return binom_cdf_sum(k, n, p);
+        let mut s = 0.0;
+        let mut i = 0.0;
+        while i <= k {
+            s += binom_pmf(i, n, p);
+            i += 1.0;
+        }
+        return s.min(1.0);
     }
     if p == 0.0 {
         return 1.0;
@@ -273,19 +128,14 @@ fn binom_cdf(k: f64, n: f64, p: f64) -> f64 {
     if p == 1.0 {
         return 0.0;
     }
-    // I_(1-p)(n-k, k+1) has prefactor (n-k) p mass(k).
-    reg_inc_beta_front(1.0 - p, n - k, k + 1.0, (n - k) * p * binom_pmf(k, n, p))
+    reg_inc_beta(1.0 - p, n - k, k + 1.0)
 }
 
-/// Poisson mass at integer `x >= 0` by Loader's formula.
 fn poisson_pmf(x: f64, m: f64) -> f64 {
     if m == 0.0 {
         return if x == 0.0 { 1.0 } else { 0.0 };
     }
-    if x == 0.0 {
-        return (-m).exp();
-    }
-    (-stirlerr(x) - bd0(x, m)).exp() / (std::f64::consts::TAU * x).sqrt()
+    (-m + x * m.ln() - ln_gamma(x + 1.0)).exp()
 }
 
 fn poisson_cdf(x: f64, m: f64) -> f64 {
@@ -293,31 +143,15 @@ fn poisson_cdf(x: f64, m: f64) -> f64 {
         return 1.0;
     }
     if x <= 1000.0 {
-        if x <= m {
-            // mass(i - 1) = mass(i) * i / m, downwards from x while the terms matter
-            let mut t = poisson_pmf(x, m);
-            let mut s = t;
-            let mut i = x;
-            while i >= 1.0 && t > s * 1e-18 {
-                t *= i / m;
-                s += t;
-                i -= 1.0;
-            }
-            return s.min(1.0);
-        }
-        // Above the mean: 1 minus the upper tail, mass(i + 1) = mass(i) * m / (i + 1).
-        let mut t = poisson_pmf(x + 1.0, m);
-        let mut s = t;
-        let mut i = x + 1.0;
-        while t > s * 1e-18 {
-            t *= m / (i + 1.0);
-            s += t;
+        let mut s = 0.0;
+        let mut i = 0.0;
+        while i <= x {
+            s += poisson_pmf(i, m);
             i += 1.0;
         }
-        return (1.0 - s).max(0.0);
+        return s.min(1.0);
     }
-    // Q(x+1, m) has prefactor m mass(x).
-    reg_gamma_q_front(x + 1.0, m, m * poisson_pmf(x, m))
+    reg_gamma_q(x + 1.0, m)
 }
 
 pub(super) fn norm_dist(a: &[Arg], _: C) -> R<Value> {

crates/functions/src/stat/tests.rs

@@ -1,6 +1,4 @@
-use super::descriptive::{kth, median, percentile_exc, percentile_inc, sorted};
 use super::{MAX_REGRESSORS, aggregate_values, aggregate_values_k, check_regression_size};
-use crate::util::R;
 use crate::util::testutil::*;
 use gridcraft_core::{CellError, Value};
 
@@ -202,126 +200,6 @@ fn min_max_order() {
     close(ev("RANK.AVG", vec![n(3.5), r2, n(1.0)]), 3.5);
 }
 
-// Reference implementations: the previous full-sort versions, as the oracle for the selection ones.
-fn old_interp(s: &[f64], pos: f64) -> R<f64> {
-    let i = pos.floor();
-    let frac = pos - i;
-    let i = i as usize;
-    let lo = *s.get(i).ok_or(CellError::Num)?;
-    match s.get(i + 1) {
-        Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)),
-        _ => Ok(lo),
-    }
-}
-
-fn old_median(v: Vec<f64>) -> R<f64> {
-    if v.is_empty() {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    let n = s.len();
-    let hi = s.get(n / 2).copied().unwrap_or(0.0);
-    if n % 2 == 1 { Ok(hi) } else { Ok(s.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) }
-}
-
-fn old_kth(v: Vec<f64>, k: f64, largest: bool) -> R<f64> {
-    let k = k.ceil();
-    if k.is_nan() || k < 1.0 || k > v.len() as f64 {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    let k = k as usize;
-    let idx = if largest { s.len() - k } else { k - 1 };
-    s.get(idx).copied().ok_or(CellError::Num)
-}
-
-fn old_percentile_inc(v: Vec<f64>, k: f64) -> R<f64> {
-    if v.is_empty() || !(0.0..=1.0).contains(&k) {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    old_interp(&s, k * (s.len() - 1) as f64)
-}
-
-fn old_percentile_exc(v: Vec<f64>, k: f64) -> R<f64> {
-    let n = v.len() as f64;
-    if v.is_empty() || !(k > 0.0 && k < 1.0) {
-        return Err(CellError::Num);
-    }
-    let pos = k * (n + 1.0);
-    if pos < 1.0 || pos > n {
-        return Err(CellError::Num);
-    }
-    let s = sorted(v);
-    old_interp(&s, pos - 1.0)
-}
-
-/// Same Ok bit pattern or same error.
-fn same(a: R<f64>, b: R<f64>) -> bool {
-    match (a, b) {
-        (Ok(x), Ok(y)) => x.to_bits() == y.to_bits(),
-        (Err(x), Err(y)) => x == y,
-        _ => false,
-    }
-}
-
-#[test]
-fn selection_matches_full_sort_bit_for_bit() {
-    let mut state = 0x9E37_79B9_7F4A_7C15_u64;
-    let mut next = move || {
-        state ^= state << 13;
-        state ^= state >> 7;
-        state ^= state << 17;
-        state
-    };
-    let specials = [0.0, -0.0, f64::INFINITY, f64::NEG_INFINITY, f64::NAN, -f64::NAN, f64::MAX, f64::MIN_POSITIVE, 1.0, -1.0];
-    for len in (0..=40).chain([63, 64, 65, 100, 257, 1000, 4096]) {
-        for round in 0..24 {
-            let mut v: Vec<f64> = (0..len)
-                .map(|_| match (round % 4, next() % 8) {
-                    // Few distinct values: many ties.
-                    (0, r) => (r % 3) as f64,
-                    // Specials, including both zeros and NaNs.
-                    (1, r) => specials[(next() as usize).wrapping_add(r as usize) % specials.len()],
-                    // Wide random range.
-                    (2, _) => (next() as i64 as f64) / 1e3,
-                    // Integers with some specials mixed in.
-                    (_, 0) => specials[next() as usize % specials.len()],
-                    _ => (next() % 50) as f64,
-                })
-                .collect();
-            // Rounds 12..24 repeat the data as already ascending, already descending and nearly
-            // ascending (ends swapped): the monotone shortcut and its fallback to selection.
-            match round / 4 {
-                3 => v.sort_by(f64::total_cmp),
-                4 => {
-                    v.sort_by(f64::total_cmp);
-                    v.reverse();
-                }
-                5 => {
-                    v.sort_by(f64::total_cmp);
-                    if let Some(last) = v.len().checked_sub(1) {
-                        v.swap(0, last);
-                    }
-                }
-                _ => {}
-            }
-            assert!(same(median(v.clone()), old_median(v.clone())), "median len={len} round={round}");
-            let ks = [-1.0, 0.0, 0.2, 1.0, 1.5, 2.0, len as f64 / 2.0, len as f64 - 0.5, len as f64, len as f64 + 1.0, f64::NAN];
-            for &k in &ks {
-                for largest in [true, false] {
-                    assert!(same(kth(v.clone(), k, largest), old_kth(v.clone(), k, largest)), "kth len={len} k={k}");
-                }
-            }
-            let ps = [-0.1, 0.0, 0.01, 0.1, 0.25, 0.3, 0.5, 0.75, 0.9, 0.99, 1.0, 1.1, f64::NAN, (next() % 1001) as f64 / 1000.0];
-            for &p in &ps {
-                assert!(same(percentile_inc(v.clone(), p), old_percentile_inc(v.clone(), p)), "pinc len={len} p={p}");
-                assert!(same(percentile_exc(v.clone(), p), old_percentile_exc(v.clone(), p)), "pexc len={len} p={p}");
-            }
-        }
-    }
-}
-
 #[test]
 fn percentiles() {
     close(ev("PERCENTILE.INC", vec![c(&[1.0, 3.0, 2.0, 4.0]), n(0.3)]), 1.9);
@@ -740,248 +618,6 @@ fn aggregate_helper() {
     is_err(aggregate_values_k(14, &vals, &nv(10.0)), CellError::Num);
 }
 
-// B1: BINOM.DIST and POISSON.DIST went through ln_gamma differences (relative error 1.1e-13 at
-// n = 100, 1.5e-11 at n = 10,000). Reference values: 70-digit Decimal arithmetic on the exact
-// double `p` (mass by the neighbour-ratio recurrence from q^n, cdf as the running sum), rounded
-// once to f64. Columns: k, n, p, mass, cdf.
-#[rustfmt::skip]
-const BINOM_REF: &[(f64, f64, f64, f64, f64)] = &[
-    (0.0, 10.0, 0.5, 0.0009765625, 0.0009765625),
-    (1.0, 10.0, 0.5, 0.009765625, 0.0107421875),
-    (3.0, 10.0, 0.5, 0.1171875, 0.171875),
-    (5.0, 10.0, 0.5, 0.24609375, 0.623046875),
-    (7.0, 10.0, 0.5, 0.1171875, 0.9453125),
-    (9.0, 10.0, 0.5, 0.009765625, 0.9990234375),
-    (0.0, 10.0, 0.3, 0.028247524900000005, 0.028247524900000005),
-    (1.0, 10.0, 0.3, 0.12106082100000001, 0.14930834590000003),
-    (2.0, 10.0, 0.3, 0.23347444050000002, 0.3827827864),
-    (3.0, 10.0, 0.3, 0.266827932, 0.6496107184000001),
-    (4.0, 10.0, 0.3, 0.200120949, 0.8497316674000001),
-    (5.0, 10.0, 0.3, 0.10291934519999998, 0.9526510126),
-    (7.0, 10.0, 0.3, 0.009001691999999999, 0.9984096136),
-    (9.0, 10.0, 0.3, 0.00013778099999999996, 0.9999940951),
-    (0.0, 10.0, 0.999, 1.0000000000000088e-30, 1.0000000000000088e-30),
-    (1.0, 10.0, 0.999, 9.99000000000008e-27, 9.99100000000008e-27),
-    (5.0, 10.0, 0.999, 2.507425174812609e-13, 2.50951798425701e-13),
-    (9.0, 10.0, 0.999, 0.00991035916125875, 0.009955119790251798),
-    (0.0, 100.0, 0.5, 7.888609052210118e-31, 7.888609052210118e-31),
-    (1.0, 100.0, 0.5, 7.888609052210118e-29, 7.967495142732219e-29),
-    (35.0, 100.0, 0.5, 0.0008638556657416528, 0.0017588208614850792),
-    (45.0, 100.0, 0.5, 0.048474296626430755, 0.18410080866334813),
-    (50.0, 100.0, 0.5, 0.07958923738717877, 0.5397946186935894),
-    (55.0, 100.0, 0.5, 0.048474296626430755, 0.8643734879630827),
-    (65.0, 100.0, 0.5, 0.0008638556657416528, 0.9991050348042566),
-    (99.0, 100.0, 0.5, 7.888609052210118e-29, 1.0),
-    (0.0, 100.0, 0.01, 0.3660323412732295, 0.3660323412732295),
-    (1.0, 100.0, 0.01, 0.3697296376497268, 0.7357619789229563),
-    (2.0, 100.0, 0.01, 0.1848648188248634, 0.9206267977478196),
-    (4.0, 100.0, 0.01, 0.014941714856895142, 0.9965676784122455),
-    (50.0, 100.0, 0.01, 6.103987557173001e-72, 1.0),
-    (99.0, 100.0, 0.01, 9.900000000000021e-197, 1.0),
-    (0.0, 100.0, 0.7, 5.15377520732019e-53, 5.15377520732019e-53),
-    (1.0, 100.0, 0.7, 1.2025475483747105e-50, 1.207701323582031e-50),
-    (50.0, 100.0, 0.7, 1.302622713144541e-05, 2.2060913327166086e-05),
-    (56.0, 100.0, 0.7, 0.001028871216633018, 0.0021146172813184595),
-    (65.0, 100.0, 0.7, 0.04677968235272982, 0.16285828837178737),
-    (70.0, 100.0, 0.7, 0.08678386475342809, 0.5376602639846381),
-    (75.0, 100.0, 0.7, 0.04955992276217012, 0.8864298182958186),
-    (84.0, 100.0, 0.7, 0.0005638655029474704, 0.9995950004580563),
-    (99.0, 100.0, 0.7, 1.3862042184106021e-14, 0.9999999999999997),
-    (0.0, 1000.0, 0.5, 9.332636185032189e-302, 9.332636185032189e-302),
-    (1.0, 1000.0, 0.5, 9.332636185032189e-299, 9.341968821217221e-299),
-    (453.0, 1000.0, 0.5, 0.00030353498700958767, 0.00162629990658169),
-    (484.0, 1000.0, 0.5, 0.015123665829158384, 0.1634683412157977),
-    (500.0, 1000.0, 0.5, 0.0252250181783608, 0.5126125090891804),
-    (516.0, 1000.0, 0.5, 0.015123665829158384, 0.8516553246133607),
-    (547.0, 1000.0, 0.5, 0.00030353498700958767, 0.9986772350804279),
-    (999.0, 1000.0, 0.5, 9.332636185032189e-299, 1.0),
-    (0.0, 1000.0, 0.3, 1.2532566399657381e-155, 1.2532566399657381e-155),
-    (1.0, 1000.0, 0.3, 5.371099885567449e-153, 5.383632451967106e-153),
-    (257.0, 1000.0, 0.3, 0.00030959977077928017, 0.0014835731103312242),
-    (286.0, 1000.0, 0.3, 0.0174263984921581, 0.1759288949498673),
-    (300.0, 1000.0, 0.3, 0.027521003821268385, 0.5155935198141203),
-    (314.0, 1000.0, 0.3, 0.017109129819617666, 0.8414952343056957),
-    (343.0, 1000.0, 0.3, 0.00036310112605077133, 0.9985016810663147),
-    (500.0, 1000.0, 0.3, 3.4791609391626546e-40, 1.0),
-    (999.0, 1000.0, 0.3, 0.0, 1.0),
-    (0.0, 1000.0, 0.001, 0.36769542477096406, 0.36769542477096406),
-    (1.0, 1000.0, 0.001, 0.36806348825922325, 0.7357589130301873),
-    (2.0, 1000.0, 0.001, 0.18403174412961162, 0.9197906571597989),
-    (4.0, 1000.0, 0.001, 0.01528995542083862, 0.9963631219704782),
-    (500.0, 1000.0, 0.001, 0.0, 1.0),
-    (999.0, 1000.0, 0.001, 0.0, 1.0),
-    (0.0, 10000.0, 0.5, 0.0, 0.0),
-    (1.0, 10000.0, 0.5, 0.0, 0.0),
-    (4850.0, 10000.0, 0.5, 8.861480551702583e-05, 0.0013939837588563594),
-    (4950.0, 10000.0, 0.5, 0.004839495142316416, 0.161087099897656),
-    (5000.0, 10000.0, 0.5, 0.007978646139382154, 0.5039893230696911),
-    (5050.0, 10000.0, 0.5, 0.004839495142316416, 0.8437523952446604),
-    (5150.0, 10000.0, 0.5, 8.861480551702583e-05, 0.9986946310466607),
-    (9999.0, 10000.0, 0.5, 0.0, 1.0),
-    (0.0, 10000.0, 0.3, 0.0, 0.0),
-    (1.0, 10000.0, 0.3, 0.0, 0.0),
-    (2863.0, 10000.0, 0.3, 9.71726742023389e-05, 0.0013927715709303387),
-    (2954.0, 10000.0, 0.3, 0.0052756073908582085, 0.16038574844431697),
-    (3000.0, 10000.0, 0.3, 0.008705361365067056, 0.504932983819298),
-    (3046.0, 10000.0, 0.3, 0.005244996814931252, 0.8448693061622872),
-    (3137.0, 10000.0, 0.3, 0.00010232641238302388, 0.9986013755801396),
-    (5000.0, 10000.0, 0.3, 0.0, 1.0),
-    (9999.0, 10000.0, 0.3, 0.0, 1.0),
-    (0.0, 10000.0, 0.0001, 0.3678610464329299, 0.3678610464329299),
-    (1.0, 10000.0, 0.0001, 0.3678978362165516, 0.7357588826494815),
-    (2.0, 10000.0, 0.0001, 0.1839489181082758, 0.9197078007577573),
-    (4.0, 10000.0, 0.0001, 0.015324477632794846, 0.996342452182816),
-    (5000.0, 10000.0, 0.0001, 0.0, 1.0),
-    (9999.0, 10000.0, 0.0001, 0.0, 1.0),
-    (0.0, 10000.0, 0.999, 0.0, 0.0),
-    (1.0, 10000.0, 0.999, 0.0, 0.0),
-    (5000.0, 10000.0, 0.999, 0.0, 0.0),
-    (9981.0, 10000.0, 0.999, 0.0037205945263045544, 0.007158161342006954),
-    (9987.0, 10000.0, 0.999, 0.07292252318084555, 0.20834867055478343),
-    (9990.0, 10000.0, 0.999, 0.12517263665023892, 0.5421328760209826),
-    (9993.0, 10000.0, 0.999, 0.09007019224850273, 0.8699847268232276),
-    (9999.0, 10000.0, 0.999, 0.00045218564541589875, 0.9999548266540229),
-    (0.0, 100000.0, 0.5, 0.0, 0.0),
-    (1.0, 100000.0, 0.5, 0.0, 0.0),
-    (49526.0, 100000.0, 0.5, 2.821098952769392e-05, 0.00137358872189177),
-    (49842.0, 100000.0, 0.5, 0.0015314620321580088, 0.15959653953914368),
-    (50000.0, 100000.0, 0.5, 0.00252312621419674, 0.5012615631070984),
-    (50158.0, 100000.0, 0.5, 0.0015314620321580088, 0.8419349224930143),
-    (50474.0, 100000.0, 0.5, 2.821098952769392e-05, 0.9986546222676359),
-    (99999.0, 100000.0, 0.5, 0.0, 1.0),
-    (0.0, 100000.0, 0.3, 0.0, 0.0),
-    (1.0, 100000.0, 0.3, 0.0, 0.0),
-    (29565.0, 100000.0, 0.3, 3.016598258904529e-05, 0.0013408650955754554),
-    (29855.0, 100000.0, 0.3, 0.0016703029966719045, 0.15934769308464344),
-    (30000.0, 100000.0, 0.3, 0.002752954648397428, 0.5015600059172672),
-    (30145.0, 100000.0, 0.3, 0.0016672321665529399, 0.8423208126454166),
-    (30435.0, 100000.0, 0.3, 3.067097885268188e-05, 0.9986570625478413),
-    (50000.0, 100000.0, 0.3, 0.0, 1.0),
-    (99999.0, 100000.0, 0.3, 0.0, 1.0),
-    (0.0, 100000.0, 0.99, 0.0, 0.0),
-    (1.0, 100000.0, 0.99, 0.0, 0.0),
-    (50000.0, 100000.0, 0.99, 0.0, 0.0),
-    (98906.0, 100000.0, 0.99, 0.00015962501729101418, 0.001680685850467731),
-    (98969.0, 100000.0, 0.99, 0.007723834924565287, 0.1660975153530963),
-    (99000.0, 100000.0, 0.99, 0.012678161323544589, 0.5042686879721229),
-    (99031.0, 100000.0, 0.99, 0.007885853372194001, 0.8416321140066325),
-    (99094.0, 100000.0, 0.99, 0.00013276363518518057, 0.9988439452168577),
-    (99999.0, 100000.0, 0.99, 0.0, 1.0),
-    // Small k where (1 - p)^(n - k) underflows although the mass is a normal number.
-    (10.0, 1100.0, 0.5, 5.050689010687844e-308, 5.097367491037505e-308),
-    (14.0, 1100.0, 0.5, 2.9513324041838846e-300, 2.989803284040754e-300),
-    (15.0, 1100.0, 0.5, 2.1367646606291324e-298, 2.16666269346954e-298),
-    (16.0, 1100.0, 0.5, 1.4489935354891303e-296, 1.4706601624238258e-296),
-    (20.0, 1100.0, 0.5, 1.711087104904223e-289, 1.7433098849775326e-289),
-    (25.0, 1100.0, 0.5, 3.906996229178926e-281, 3.999839082741416e-281),
-];
-
-// Columns: x, mean, mass, cdf. The last block has x > 1000, which takes the incomplete-gamma branch.
-#[rustfmt::skip]
-const POISSON_REF: &[(f64, f64, f64, f64)] = &[
-    (0.0, 0.5, 0.6065306597126334, 0.6065306597126334),
-    (1.0, 0.5, 0.3032653298563167, 0.9097959895689501),
-    (3.0, 0.5, 0.012636055410679864, 0.9982483774437092),
-    (0.0, 5.0, 0.006737946999085467, 0.006737946999085467),
-    (2.0, 5.0, 0.08422433748856833, 0.12465201948308115),
-    (5.0, 5.0, 0.1754673697678507, 0.6159606548330632),
-    (10.0, 5.0, 0.018132788707821874, 0.986304731401617),
-    (25.0, 5.0, 1.294589320478486e-10, 0.9999999999695003),
-    (70.0, 100.0, 0.00031056089812001654, 0.0009714440282773882),
-    (100.0, 100.0, 0.039860996809147134, 0.5265621985299984),
-    (130.0, 100.0, 0.000575252683815463, 0.9982931596294985),
-    (900.0, 1000.0, 7.516954352125952e-05, 0.0006977673277963068),
-    (1000.0, 1000.0, 0.012614611348721499, 0.508409367168506),
-    (1100.0, 1000.0, 9.498944242299507e-05, 0.9991323590365564),
-    (1050.0, 1000.0, 0.003599490404803648, 0.9439711616363267),
-    (1200.0, 1000.0, 7.992642848843571e-11, 0.9999999996115061),
-    (1500.0, 2000.0, 1.878037542328086e-32, 7.468034373687017e-32),
-    (2000.0, 2000.0, 0.00892024889598624, 0.5059467004517837),
-    (2100.0, 2000.0, 0.0007442234118916615, 0.9872092799080792),
-    (2300.0, 2000.0, 4.011826753210622e-12, 0.999999999973895),
-    (4800.0, 5000.0, 9.987733294132511e-05, 0.002269403878343364),
-    (5000.0, 5000.0, 0.005641801804664022, 0.5037611677708467),
-];
-
-fn rel_err(got: Value, want: f64) -> f64 {
-    // An error or a non-finite result is the worst possible miss, not a skipped one.
-    let Some(g) = got.as_f64().filter(|g| g.is_finite()) else { return f64::INFINITY };
-    if want == 0.0 { g.abs() } else { ((g - want) / want).abs() }
-}
-
-/// Error bound the grid below must meet: 1e-13, plus 2e-16 per unit of |ln value| for far-tail
-/// results (an exp of a sum of large logs cannot do better in double precision). Measured: at
-/// most 9e-14 on the grid (the n = 100,000 cumulative cases), 2e-14 for n <= 10,000 away from the
-/// far tails, 2e-15 on the Excel-sized central cases. The log-gamma code was off by 1.5e-11.
-fn allowed(want: f64) -> f64 {
-    // A reference that underflows to 0 must come back as (almost) 0, not as any finite value.
-    if want == 0.0 {
-        return 1e-300;
-    }
-    1e-13 + 2e-16 * want.abs().ln().abs()
-}
-
-#[test]
-fn binom_and_poisson_match_exact_decimal_references() {
-    // Worst error relative to the allowance (above 1 is a failure) and plain worst error.
-    let (mut worst, mut worst_plain) = (0.0f64, 0.0f64);
-    let mut check = |what: &str, got: Value, want: f64| {
-        let e = rel_err(got, want);
-        let ratio = e / allowed(want);
-        if ratio > 1.0 {
-            println!("{what}: error {e:e}, allowed {:e}", allowed(want));
-        }
-        worst = worst.max(ratio);
-        if want > 1e-3 {
-            worst_plain = worst_plain.max(e);
-        }
-    };
-    for &(k, nn, p, pmf, cdf) in BINOM_REF {
-        check(&format!("BINOM.DIST({k},{nn},{p},FALSE)"), ev("BINOM.DIST", vec![n(k), n(nn), n(p), b(false)]), pmf);
-        check(&format!("BINOM.DIST({k},{nn},{p},TRUE)"), ev("BINOM.DIST", vec![n(k), n(nn), n(p), b(true)]), cdf);
-    }
-    for &(x, m, pmf, cdf) in POISSON_REF {
-        check(&format!("POISSON.DIST({x},{m},FALSE)"), ev("POISSON.DIST", vec![n(x), n(m), b(false)]), pmf);
-        check(&format!("POISSON.DIST({x},{m},TRUE)"), ev("POISSON.DIST", vec![n(x), n(m), b(true)]), cdf);
-    }
-    println!("worst error / allowance {worst:.3}; worst relative error where the result is above 1e-3: {worst_plain:e}");
-    assert!(worst <= 1.0);
-    assert!(worst_plain < 1e-13);
-}
-
-#[test]
-fn binom_and_poisson_edge_cases() {
-    for cum in [false, true] {
-        let pm = |k: f64, nn: f64, p: f64| ev("BINOM.DIST", vec![n(k), n(nn), n(p), b(cum)]);
-        // p = 0 and p = 1
-        close(pm(0.0, 50.0, 0.0), 1.0);
-        close(pm(3.0, 50.0, 1.0), 0.0);
-        close(pm(50.0, 50.0, 1.0), 1.0);
-        // n = 0
-        close(pm(0.0, 0.0, 0.3), 1.0);
-        // k = n is certain when cumulative and p^n otherwise
-        close(pm(20.0, 20.0, 0.5), if cum { 1.0 } else { 0.5f64.powi(20) });
-        close_tol(pm(10_000.0, 10_000.0, 0.999), if cum { 1.0 } else { 0.999f64.powi(10_000) }, 1e-12);
-        // k = 0 is q^n
-        close_tol(pm(0.0, 1000.0, 0.001), 0.999f64.powi(1000), 1e-12);
-        close_tol(pm(0.0, 100_000.0, 0.00001), (1.0f64 - 1e-5).powi(100_000), 1e-9);
-    }
-    close(ev("POISSON.DIST", vec![n(0.0), n(0.0), b(false)]), 1.0);
-    close(ev("POISSON.DIST", vec![n(4.0), n(0.0), b(false)]), 0.0);
-    close(ev("POISSON.DIST", vec![n(4.0), n(0.0), b(true)]), 1.0);
-    close_tol(ev("POISSON.DIST", vec![n(0.0), n(3.0), b(true)]), (-3.0f64).exp(), 1e-15);
-    // Fractions truncate as before.
-    close(ev("BINOM.DIST", vec![n(6.9), n(10.9), n(0.5), b(false)]), 0.205078125);
-    // The 10,000 trial switch of the method no longer shows: neighbours agree to 1e-14.
-    let lo = ev("BINOM.DIST", vec![n(5000.0), n(10_000.0), n(0.5), b(true)]).as_f64().unwrap();
-    let hi = ev("BINOM.DIST", vec![n(5000.0), n(10_001.0), n(0.5), b(true)]).as_f64().unwrap();
-    let pmf = ev("BINOM.DIST", vec![n(5000.0), n(10_000.0), n(0.5), b(false)]).as_f64().unwrap();
-    // cdf(5000; 10,001) = cdf(5000; 10,000) - p * mass(5000; 10,000) by the recurrence on n
-    assert!(((hi - (lo - 0.5 * pmf)) / hi).abs() < 1e-13, "{lo} {hi}");
-    // Inverse stays consistent: the smallest k with cdf >= alpha.
-    close(ev("BINOM.INV", vec![n(10_000.0), n(0.5), n(0.5)]), 5000.0);
-}
-
 /// 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

crates/math/src/lib.rs

@@ -3,7 +3,7 @@
 //! without calling RaTeX again.
 //!
 //! RaTeX is young (0.1.x), so it only ever runs inside this crate's entry points ([`layout`],
-//! [`to_omml`], [`check`]). Each one caps its input (4 KB, nesting 32, no macro definitions, at most [`MAX_CELLS`] matrix cells) and runs under
+//! [`to_omml`], [`check`]). Each one caps its input (4 KB, nesting 32) and runs under
 //! `catch_unwind`, so a stray panic becomes a [`MathError`]. See the RaTeX gate in
 //! `docs/decisions.md` and `tests/gate.rs`.
 //!
@@ -33,9 +33,6 @@ pub const MAX_DEPTH: usize = 32;
 pub const MAX_EM: f32 = 10_000.0;
 /// Most items one equation may produce.
 pub const MAX_ITEMS: usize = 50_000;
-/// Most matrix cells one equation may have, counting the empty cells that pad a short row to the
-/// width of the widest one. A ragged matrix costs rows times the widest row, not what is typed.
-pub const MAX_CELLS: usize = 2_500;
 
 /// The error for a source over [`MAX_SOURCE_BYTES`]. It is one shared value so that a cache can
 /// answer for such a source by its length alone, without reading it.
@@ -226,61 +223,20 @@ fn parse(latex: &str) -> Result<Vec<ratex_parser::ParseNode>, MathError> {
     })
 }
 
-/// Control words that define or rebind macros. User macros have no use in an equation, and
-/// RaTeX caps only how many expansions run, not how large they grow, so a self-referencing
-/// definition whose argument doubles on every call keeps the expander busy without bound. They are
-/// refused before RaTeX sees the source.
-const MACRO_DEFINERS: &[&str] =
-    &["def", "gdef", "edef", "xdef", "let", "futurelet", "global", "long", "newcommand", "renewcommand", "providecommand"];
-
-/// One open `\begin…\end` environment, counted from the source text.
-struct Grid {
-    /// Rows ended so far (by `\\`, `\cr` or `\newline`).
-    rows: usize,
-    /// Cells in the current row.
-    cells: usize,
-    /// Cells in the widest row so far.
-    widest: usize,
-}
-
-impl Grid {
-    fn new() -> Grid {
-        Grid { rows: 0, cells: 1, widest: 0 }
-    }
-    fn end_row(&mut self) {
-        self.widest = self.widest.max(self.cells);
-        self.rows += 1;
-        self.cells = 1;
-    }
-    /// The padded grid RaTeX lays out and `to_omml` writes: every row as wide as the widest.
-    fn padded_cells(&self) -> usize {
-        (self.rows + 1).saturating_mul(self.widest.max(self.cells))
-    }
-}
-
-/// The size, nesting, macro and matrix caps, checked before RaTeX sees the source.
+/// The size and nesting caps, checked before RaTeX sees the source.
 fn check_caps(latex: &str) -> Result<(), MathError> {
     if latex.len() > MAX_SOURCE_BYTES {
         return Err(SOURCE_TOO_LONG.clone());
     }
-    // `%` starts a comment, except inside the address of `\href` and `\url`, where RaTeX reads it
-    // as a character. Which one it is decides what the rest of the line means, so the two are not
-    // allowed together.
-    if latex.contains('%') && (latex.contains("\\href") || latex.contains("\\url")) {
-        return Err(MathError::new("A % can't be combined with a link in an equation.", latex.find('%').map(|i| i..i + 1)));
-    }
     let mut depth = 0usize;
-    let mut grids: Vec<Grid> = Vec::new();
-    let mut cells_total = 0usize;
     let mut chars = latex.char_indices().peekable();
     while let Some((i, c)) = chars.next() {
         let open = match c {
             '\\' => {
-                // A control word (letters and `@`, as RaTeX's lexer reads it), or an escaped
-                // character (`\{` is not a group).
+                // A control word, or an escaped character (`\{` is not a group).
                 let mut word = String::new();
                 while let Some(&(_, n)) = chars.peek() {
-                    if n.is_ascii_alphabetic() || n == '@' {
+                    if n.is_ascii_alphabetic() {
                         word.push(n);
                         chars.next();
                     } else {
@@ -288,70 +244,15 @@ fn check_caps(latex: &str) -> Result<(), MathError> {
                     }
                 }
                 if word.is_empty() {
-                    if let Some((_, n)) = chars.next()
-                        && n == '\\'
-                        && let Some(g) = grids.last_mut()
-                    {
-                        g.end_row();
-                    }
+                    chars.next();
                     continue;
                 }
-                if MACRO_DEFINERS.contains(&word.as_str()) {
-                    return Err(MathError::new("Macro definitions are not supported in equations.", Some(i..i + 1 + word.len())));
-                }
                 match word.as_str() {
-                    "verb" => {
-                        // Verbatim text runs to the next copy of its delimiter, whatever it
-                        // holds: no group, comment, row or definition starts inside it.
-                        if chars.peek().is_some_and(|&(_, n)| n == '*') {
-                            chars.next();
-                        }
-                        if let Some((_, delim)) = chars.next() {
-                            for (_, n) in chars.by_ref() {
-                                if n == delim {
-                                    break;
-                                }
-                            }
-                        }
-                        None
-                    }
-                    // RaTeX reads `\newline` as `\\`, so it ends a row like `\cr` does.
-                    "cr" | "newline" => {
-                        if let Some(g) = grids.last_mut() {
-                            g.end_row();
-                        }
-                        None
-                    }
-                    "begin" => {
-                        if let Some(n) = alignat_columns(latex.get(i + 6..).unwrap_or_default())
-                            && n > MAX_ALIGNAT_PAIRS
-                        {
-                            return Err(too_many_cells(i..i + 6));
-                        }
-                        grids.push(Grid::new());
-                        Some(true)
-                    }
-                    "end" => {
-                        if let Some(g) = grids.pop() {
-                            cells_total = cells_total.saturating_add(g.padded_cells());
-                            if cells_total > MAX_CELLS {
-                                return Err(too_many_cells(i..i + 1 + word.len()));
-                            }
-                        }
-                        Some(false)
-                    }
-                    "left" => Some(true),
-                    "right" => Some(false),
+                    "left" | "begin" => Some(true),
+                    "right" | "end" => Some(false),
                     _ => None,
                 }
             }
-            '&' | '@' => {
-                // `@` makes an arrow cell and an empty cell beside it in a `CD` diagram.
-                if let Some(g) = grids.last_mut() {
-                    g.cells += if c == '@' { 2 } else { 1 };
-                }
-                None
-            }
             '%' => {
                 // A comment runs to the end of the line.
                 for (_, n) in chars.by_ref() {
@@ -376,72 +277,9 @@ fn check_caps(latex: &str) -> Result<(), MathError> {
             None => {}
         }
     }
-    // An environment left open is a syntax error for the parser to report, but it still counts.
-    for g in grids {
-        cells_total = cells_total.saturating_add(g.padded_cells());
-    }
-    if cells_total > MAX_CELLS {
-        return Err(too_many_cells(latex.len()..latex.len()));
-    }
     Ok(())
 }
 
-/// Most column pairs `\begin{alignedat}{N}` may ask for. RaTeX allocates 2N column specs before
-/// it lays anything out.
-const MAX_ALIGNAT_PAIRS: usize = 50;
-
-/// N of `{alignat}{N}`, `{alignat*}{N}` or `{alignedat}{N}` at the start of `rest` (just after
-/// `\begin`). `usize::MAX` when the count is present but is not a plain digit string RaTeX reads
-/// the same way (too long, or hidden by a comment, inner spaces or a macro): refused, not skipped.
-/// An environment name that is computed (contains `\` or `{`) is refused the same way.
-///
-/// RaTeX reads the environment name and the count through its lexer, which drops comments and
-/// spaces, so they are dropped here too before the two groups are compared.
-fn alignat_columns(rest: &str) -> Option<usize> {
-    // Enough for the longest name and any count that fits `usize`; a longer count is refused.
-    const WINDOW: usize = 64;
-    let mut kept = String::new();
-    let mut chars = rest.chars();
-    while kept.len() < WINDOW {
-        match chars.next() {
-            None => break,
-            Some('%') => {
-                for n in chars.by_ref() {
-                    if n == '\n' {
-                        break;
-                    }
-                }
-            }
-            Some(c) if c.is_whitespace() => {}
-            Some(c) => kept.push(c),
-        }
-    }
-    let group = kept.strip_prefix('{')?;
-    // A name that does not close inside the window cannot be read, so it is refused.
-    let Some((name, after)) = group.split_once('}') else {
-        return Some(usize::MAX);
-    };
-    // A computed name (`align\@char{97}t` reads as `alignat`) cannot be resolved here: refused
-    // too. Every real environment name is letters, optionally with a trailing `*`.
-    if name.contains(['\\', '{']) {
-        return Some(usize::MAX);
-    }
-    if !matches!(name, "alignat" | "alignat*" | "alignedat") {
-        return None;
-    }
-    let Some(digits) = after.strip_prefix('{').and_then(|a| a.split_once('}')).map(|(d, _)| d) else {
-        return Some(usize::MAX);
-    };
-    if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
-        return Some(usize::MAX);
-    }
-    Some(digits.parse().unwrap_or(usize::MAX))
-}
-
-fn too_many_cells(span: Range<usize>) -> MathError {
-    MathError::new(format!("An equation can have at most {MAX_CELLS} matrix cells (rows times the widest row)."), Some(span))
-}
-
 fn color(c: &Color) -> Option<[u8; 3]> {
     let q = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
     let rgb = [q(c.r), q(c.g), q(c.b)];
@@ -671,116 +509,6 @@ mod tests {
         }
     }
 
-    /// Runs `f` on its own thread and fails if it has not returned within `secs` seconds.
-    fn within<T: Send + 'static>(secs: u64, f: impl FnOnce() -> T + Send + 'static) -> T {
-        let (tx, rx) = std::sync::mpsc::channel();
-        std::thread::Builder::new()
-            .stack_size(2 << 20)
-            .spawn(move || {
-                let _ = tx.send(f());
-            })
-            .unwrap();
-        match rx.recv_timeout(std::time::Duration::from_secs(secs)) {
-            Ok(v) => v,
-            Err(std::sync::mpsc::RecvTimeoutError::Timeout) => panic!("did not return within {secs} s"),
-            Err(e) => panic!("the worker thread died: {e}"),
-        }
-    }
-
-    #[test]
-    fn macro_definitions_are_refused_before_the_expander_runs() {
-        let defs = [
-            "\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "\\gdef\\a#1{\\a{#1#1#1#1}}\\a{x}",
-            "\\edef\\a#1{\\a{#1#1}}\\a{x}",
-            "\\xdef\\a#1{{#1}{#1}}\\a{x}",
-            "\\newcommand{\\a}[1]{\\a{#1#1}}\\a{x}",
-            "\\renewcommand{\\a}[1]{\\a{#1#1}}\\a{x}",
-            "\\providecommand{\\a}[1]{\\a{#1#1}}\\a{x}",
-            "\\let\\a\\frac \\a{1}{2}",
-            "\\futurelet\\a\\frac \\a{1}{2}",
-            "\\global\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "\\long\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "{\\def\\a#1{\\a{#1#1}}}\\a{x}",
-        ];
-        for src in defs {
-            // `check_caps` alone, so this cannot hang even if the refusal regresses.
-            let e = check_caps(src).unwrap_err();
-            assert!(e.message.contains("Macro definitions"), "{src}: {e}");
-            assert_eq!(e.span.as_ref().map(|r| &src[r.clone()]).map(|w| w.starts_with('\\')), Some(true));
-            let s = src.to_string();
-            let (c, l, o) = within(10, move || (check(&s).is_err(), layout(&s).is_err(), to_omml(&s, 11.0, None).is_err()));
-            assert!(c && l && o, "{src}");
-        }
-        // Names that merely start with a definer, escaped backslashes and comments are not macros.
-        for ok in ["\\default", "\\letter", "\\\\def", "x % \\def\\a\n+1", "\\longrightarrow"] {
-            assert!(check_caps(ok).is_ok(), "{ok}");
-        }
-        assert!(layout("\\longrightarrow x").is_ok());
-        // Text the lexer reads differently from a plain scan must not hide a definition: a
-        // verbatim `%` is no comment, a `%` in a link address is no comment, `@` joins a word.
-        for src in [
-            "\\verb|%|\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "\\verb\\x\\\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "%\\verb|\n\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "\\href{a%b}{x}\\def\\a#1{\\a{#1#1}}\\a{x}",
-            "\\url{a%}\\def\\a#1{\\a{#1#1}}\\a{x}",
-        ] {
-            assert!(check_caps(src).is_err(), "{src}");
-        }
-        assert!(check_caps("\\verb|\\def| x").is_ok(), "verbatim text is not a definition");
-        assert!(check_caps("\\def@x").is_ok(), "`\\def@x` is one unknown word to the lexer");
-    }
-
-    #[test]
-    fn ragged_matrices_are_capped_by_their_padded_size() {
-        let ragged = format!("\\begin{{matrix}}{}{}\\end{{matrix}}", "a\\\\".repeat(650), "a&".repeat(999) + "a");
-        assert!(ragged.len() < MAX_SOURCE_BYTES);
-        let e = check_caps(&ragged).unwrap_err();
-        assert!(e.message.contains("matrix cells"), "{e}");
-        let r = ragged.clone();
-        let (l, o) = within(10, move || (layout(&r).unwrap_err(), to_omml(&r, 11.0, None).unwrap_err()));
-        assert!(l.message.contains("matrix cells") && o.message.contains("matrix cells"));
-        // Without the environment words there is no grid to count; the parser rejects it.
-        // Ordinary and wide-but-regular matrices still work, and so does a trailing `\\`.
-        let wide = format!("\\begin{{pmatrix}}{}\\end{{pmatrix}}", vec!["a&".repeat(39) + "a"; 40].join("\\\\"));
-        assert!(wide.len() < MAX_SOURCE_BYTES);
-        assert!(layout(&wide).is_ok());
-        assert!(to_omml(&wide, 11.0, None).is_ok());
-        assert!(layout("\\begin{pmatrix} a & b \\\\ c & d \\\\ \\end{pmatrix}").is_ok());
-        // Diagram arrows and `alignedat` column counts size a grid without any `&`.
-        let cd = format!("\\begin{{CD}}{}{}\\end{{CD}}", "A\\\\".repeat(900), "@>>>".repeat(300));
-        assert!(cd.len() < MAX_SOURCE_BYTES);
-        assert!(check_caps(&cd).is_err_and(|e| e.message.contains("matrix cells")));
-        let r = "\\begin{alignedat}{99999999}a\\end{alignedat}";
-        assert!(check_caps(r).is_err_and(|e| e.message.contains("matrix cells")));
-        assert!(check_caps("\\begin{alignedat}{2}a&b&c&d\\end{alignedat}").is_ok());
-        // A comment, inner spaces or a macro in the count do not hide it from the cap.
-        for hidden in [
-            "\\begin{alignedat}%\n{99999999}a\\end{alignedat}",
-            "\\begin %c\n {alignedat}{99999999}a\\end{alignedat}",
-            "\\begin{alignedat}{9 9}a\\end{alignedat}",
-            "\\begin{alignedat}{9%x\n9}a\\end{alignedat}",
-            "\\begin{align%x\nedat}{99}a\\end{alignedat}",
-            "\\begin{alignedat}{9\\relax9}a\\end{alignedat}",
-        ] {
-            assert!(check_caps(hidden).is_err_and(|e| e.message.contains("matrix cells")), "{hidden}");
-        }
-        // A computed environment name reads as `alignat` to the parser, so it is capped too.
-        for name in ["align\\@char{97}t", "alignedat\\relax", "al\\@char{105}gnat*"] {
-            let over = format!("\\begin{{{name}}}{{51}}a\\end{{alignat}}");
-            assert!(check_caps(&over).is_err_and(|e| e.message.contains("matrix cells")), "{over}");
-        }
-        let long = format!("\\begin{{{}}}{{51}}a\\end{{alignat}}", "a".repeat(80));
-        assert!(check_caps(&long).is_err_and(|e| e.message.contains("matrix cells")));
-        assert!(check_caps("\\begin{alignat}{50}a\\end{alignat}").is_ok());
-        assert!(check_caps("\\begin{alignedat} {2} % two pairs\na&b&c&d\\end{alignedat}").is_ok());
-        assert!(layout("\\begin{CD}A @>f>> B \\\\ @VVV @VVV \\\\ C @>>> D\\end{CD}").is_ok());
-        assert!(check_caps("\\operatorname{curl} 50\\%").is_ok());
-        let two = format!("{0}{0}", "\\begin{matrix}a&b\\\\c&d\\end{matrix}");
-        assert!(check_caps(&two).is_ok());
-    }
-
     #[test]
     fn an_injected_panic_is_an_error_not_a_crash() {
         INJECT_PANIC.with(|p| p.set(true));
@@ -802,20 +530,4 @@ mod tests {
         let l = layout("").unwrap();
         assert!(l.items.is_empty());
     }
-
-    #[test]
-    fn newline_rows_count_toward_the_matrix_cap() {
-        // RaTeX reads `\newline` as `\\`, so it ends a row like `\cr` does.
-        for brk in ["\\newline ", "\\cr ", "\\\\"] {
-            let src = format!("\\begin{{matrix}}{}{}\\end{{matrix}}", format!("a{brk}").repeat(250), "a&".repeat(700) + "a");
-            assert!(src.len() < MAX_SOURCE_BYTES);
-            let e = check_caps(&src).unwrap_err();
-            assert!(e.message.contains("matrix cells"), "{brk}: {e}");
-            let s = src.clone();
-            let (l, o) = within(10, move || (layout(&s).unwrap_err(), to_omml(&s, 11.0, None).unwrap_err()));
-            assert!(l.message.contains("matrix cells") && o.message.contains("matrix cells"), "{brk}");
-        }
-        assert!(check_caps("\\begin{matrix}a&b\\newline c&d\\end{matrix}").is_ok());
-        assert!(layout("\\begin{matrix}a&b\\newline c&d\\end{matrix}").is_ok());
-    }
 }

crates/math/src/omml.rs

@@ -406,9 +406,6 @@ impl Writer {
             }
             ParseNode::Array { body, is_cd: None | Some(false), .. } => {
                 let cols = body.iter().map(Vec::len).max().unwrap_or(0).max(1);
-                if body.len().saturating_mul(cols) > crate::MAX_CELLS {
-                    return Err(MathError::new(format!("An equation can have at most {} matrix cells.", crate::MAX_CELLS), None));
-                }
                 self.out.push_str(&format!(
                     "<m:m><m:mPr><m:mcs><m:mc><m:mcPr><m:count m:val=\"{cols}\"/><m:mcJc m:val=\"center\"/></m:mcPr></m:mc></m:mcs></m:mPr>"
                 ));

crates/model/src/cell.rs

@@ -11,7 +11,6 @@ use crate::style::StyleId;
 
 /// A parsed formula. `text` is the canonical formula text without the leading `=`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(from = "SavedFormula")]
 pub struct Formula {
     pub text: String,
     #[serde(skip)]
@@ -40,43 +39,14 @@ impl Formula {
     pub fn from_expr(e: Expr) -> Formula {
         Formula { text: gridcraft_formula::print(&e), expr: Some(Arc::new(e)), array: None, dynamic: false }
     }
-    /// The parsed expression, re-parsing when no tree is cached.
+    /// The parsed expression, re-parsing after deserialization.
     pub fn expr(&self) -> Option<Expr> {
         self.expr.as_deref().cloned().or_else(|| gridcraft_formula::parse(&self.text).ok())
     }
-    /// The parsed expression without copying it (re-parses when no tree is cached).
+    /// The parsed expression without copying it (re-parses after deserialization).
     pub fn expr_arc(&self) -> Option<Arc<Expr>> {
         self.expr.clone().or_else(|| gridcraft_formula::parse(&self.text).ok().map(Arc::new))
     }
-    /// Runs `f` on the parsed expression, borrowing the cached tree or, when none is cached,
-    /// a freshly parsed one that is dropped afterwards. Unlike [`expr`](Self::expr) it never copies
-    /// the tree, and unlike [`expr_arc`](Self::expr_arc) it needs no reference count or `Arc`
-    /// allocation. `None` when the text does not parse.
-    pub fn with_expr<R>(&self, f: impl FnOnce(&Expr) -> R) -> Option<R> {
-        match &self.expr {
-            Some(e) => Some(f(e)),
-            None => gridcraft_formula::parse(&self.text).ok().map(|e| f(&e)),
-        }
-    }
-}
-
-/// A formula as a saved workbook holds it: the tree is not saved. Reading one parses its text
-/// once and caches the tree, so a workbook opened from JSON does not parse every formula again on
-/// each recalculation. The text is kept as saved, and text that doesn't parse caches nothing, as
-/// [`Formula::new`] does.
-#[derive(Deserialize)]
-struct SavedFormula {
-    text: String,
-    array: Option<RangeRef>,
-    #[serde(default)]
-    dynamic: bool,
-}
-
-impl From<SavedFormula> for Formula {
-    fn from(f: SavedFormula) -> Formula {
-        let expr = gridcraft_formula::parse(&f.text).ok().map(Arc::new);
-        Formula { text: f.text, expr, array: f.array, dynamic: f.dynamic }
-    }
 }
 
 /// A static picture stored as cell content, independent of floating drawing anchors.
@@ -151,59 +121,3 @@ impl Cell {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gridcraft_core::CellRef;
-
-    #[test]
-    fn formulas_read_from_json_keep_their_text_and_cache_the_tree() -> Result<(), serde_json::Error> {
-        let mut array = Formula::new("=A1:B2*2");
-        array.array = Some(RangeRef::new(CellRef::new(0, 2), CellRef::new(1, 3)));
-        array.dynamic = true;
-        for f in [Formula::new("=SUM(A1:A3)+'My Sheet'!B2"), Formula::new("=LET(x,A1*2,x+1)"), array] {
-            let back: Formula = serde_json::from_str(&serde_json::to_string(&f)?)?;
-            assert!(back.expr.is_some(), "{}: the tree is cached after reading", f.text);
-            assert_eq!(back, f);
-        }
-        // Saved text is kept as written, even when the canonical print differs, and its tree is
-        // the one the text parses to.
-        let back: Formula = serde_json::from_str(r#"{"text": "sum( a1 , 2 )", "array": null}"#)?;
-        assert_eq!(back.text, "sum( a1 , 2 )");
-        assert!(!back.dynamic);
-        assert_eq!(back.expr.as_deref(), gridcraft_formula::parse("sum( a1 , 2 )").ok().as_ref());
-        assert!(back.expr.is_some());
-        // Text that doesn't parse caches nothing, as `Formula::new` does.
-        let bad = Formula::new("=SUM(");
-        let back: Formula = serde_json::from_str(&serde_json::to_string(&bad)?)?;
-        assert_eq!(back, bad);
-        assert!(back.expr.is_none());
-        Ok(())
-    }
-
-    #[test]
-    fn a_workbook_read_from_json_has_every_formula_tree() -> Result<(), Box<dyn std::error::Error>> {
-        let mut wb = crate::Workbook::new();
-        let mut array = Formula::new("=A1:A3*2");
-        array.array = Some(RangeRef::new(CellRef::new(0, 3), CellRef::new(2, 3)));
-        let sheet = wb.sheet_mut(0).ok_or("no sheet")?;
-        sheet.cells.set(CellRef::new(0, 0), Cell::value(Value::Number(1.0)));
-        sheet.cells.set(CellRef::new(0, 1), Cell::formula(Formula::new("=SUM(A1:A3)")));
-        sheet.cells.set(CellRef::new(1, 1), Cell::formula(Formula::new("=IF(A1>0,\"yes\",\"no\")")));
-        sheet.cells.set(CellRef::new(2, 1), Cell::formula(Formula::new("=SUM(")));
-        sheet.cells.set(CellRef::new(0, 3), Cell::formula(array));
-        let json = serde_json::to_string(&wb)?;
-        let back: crate::Workbook = serde_json::from_str(&json)?;
-        let (before, after) = (wb.sheet(0).ok_or("no sheet")?, back.sheet(0).ok_or("no sheet")?);
-        let mut formulas = 0;
-        for (c, cell) in before.cells.iter() {
-            let (Some(f), Some(read)) = (&cell.formula, after.cell(c).and_then(|cell| cell.formula.as_ref())) else { continue };
-            assert_eq!(read, f, "{c:?}: text, tree and flags as saved");
-            assert_eq!(read.expr.is_some(), gridcraft_formula::parse(&f.text).is_ok(), "{c:?}: every formula that parses has its tree");
-            formulas += 1;
-        }
-        assert_eq!(formulas, 4);
-        Ok(())
-    }
-}

crates/model/src/features.rs

@@ -540,12 +540,6 @@ impl Trendline {
     }
 }
 
-/// Charts saved before `hole_size` existed were drawn with a 50% hole. New charts and charts read
-/// from XLSX set 75 explicitly (Excel's default), so only a missing JSON field keeps the old look.
-fn default_hole_size() -> u8 {
-    50
-}
-
 /// A chart's data table (`c:dTable`), independent of the chart legend.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(default)]
@@ -575,13 +569,6 @@ pub struct Chart {
     pub data_table: Option<ChartDataTable>,
     pub gridlines: bool,
     pub style: u32,
-    /// Doughnut hole size as a percentage of the plot radius (Excel's 10–90 range). New charts and
-    /// XLSX imports use Excel's 75; a document saved before this field existed reads as 50.
-    #[serde(default = "default_hole_size")]
-    pub hole_size: u8,
-    /// Pie/doughnut first slice angle in degrees clockwise from 12 o'clock (0–359).
-    #[serde(default)]
-    pub first_slice_angle: u16,
     pub x_title: Option<String>,
     pub y_title: Option<String>,
     /// Source range when created from a selection (for Switch Row/Column).
@@ -753,171 +740,6 @@ impl EquationCache {
     }
 }
 
-/// What a form control on the sheet is.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum ControlKind {
-    #[default]
-    Button,
-    Slider,
-    Spin,
-}
-
-impl ControlKind {
-    /// The kind's name in the window: Button, Slider, Spin Button.
-    pub fn label(self) -> &'static str {
-        match self {
-            ControlKind::Button => "Button",
-            ControlKind::Slider => "Slider",
-            ControlKind::Spin => "Spin Button",
-        }
-    }
-}
-
-/// The largest value a slider or spin button takes (Excel's scroll bar limit). Values are whole
-/// numbers from 0 to this.
-pub const CONTROL_MAX: u32 = 30_000;
-
-/// What a button runs when it is pressed.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "camelCase")]
-pub enum ControlAction {
-    /// Runs a macro of the workbook on `input`, optionally sending its output to `output`.
-    Macro {
-        name: String,
-        #[serde(default)]
-        input: MacroInput,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        output: Option<String>,
-    },
-    /// Runs one GridCraft command with fixed parameters.
-    Command {
-        id: String,
-        #[serde(default)]
-        params: serde_json::Value,
-    },
-}
-
-/// The range a button's macro runs on.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum MacroInput {
-    /// The selection when the button is pressed.
-    #[default]
-    Selection,
-    /// Always this range (`B2:D9` or `Data!B2:D9`).
-    Fixed(String),
-}
-
-/// A form control (button, slider, spin button) floating over the sheet.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct FormControl {
-    pub id: u32,
-    pub kind: ControlKind,
-    pub anchor: Anchor,
-    /// The name shown in the Selection Pane (`Button 3`); empty means the kind and id.
-    pub name: String,
-    /// The caption of a button.
-    pub text: String,
-    /// The linked cell as reference text: `$B$2` on the control's own sheet, or `Sheet2!$B$2`.
-    /// Structural edits rewrite it like a formula reference.
-    pub link: Option<String>,
-    /// The current value of a slider or spin button (the linked cell holds it too).
-    pub value: u32,
-    pub min: u32,
-    pub max: u32,
-    /// Incremental change: one arrow click or arrow key.
-    pub step: u32,
-    /// Page change (sliders): a click on the track, or Page Up / Page Down.
-    pub page: u32,
-    /// A slider lies horizontally (false: vertically).
-    pub horizontal: bool,
-    /// What a button runs.
-    pub action: Option<ControlAction>,
-    /// Printed with the sheet.
-    pub print: bool,
-    /// Locked when the sheet is protected.
-    pub locked: bool,
-}
-
-impl Default for FormControl {
-    fn default() -> Self {
-        FormControl {
-            id: 0,
-            kind: ControlKind::default(),
-            anchor: Anchor::default(),
-            name: String::new(),
-            text: String::new(),
-            link: None,
-            value: 0,
-            min: 0,
-            max: 100,
-            step: 1,
-            page: 10,
-            horizontal: true,
-            action: None,
-            print: true,
-            locked: true,
-        }
-    }
-}
-
-impl FormControl {
-    /// The name shown for the control: its own, else `Button 3`, `Slider 4`, `Spin Button 5`.
-    pub fn display_name(&self) -> String {
-        if self.name.trim().is_empty() { format!("{} {}", self.kind.label(), self.id) } else { self.name.clone() }
-    }
-
-    /// Checks the numbers of a slider or spin button: 0 ≤ min < max ≤ 30000, 1 ≤ step ≤ max − min,
-    /// and (sliders) page ≥ step. Each rule has its own message.
-    pub fn check_numbers(&self) -> Result<(), String> {
-        if self.kind == ControlKind::Button {
-            return Ok(());
-        }
-        if self.max > CONTROL_MAX {
-            return Err(format!("Maximum value can be at most {CONTROL_MAX}."));
-        }
-        if self.min > CONTROL_MAX {
-            return Err(format!("Minimum value must be a whole number from 0 to {CONTROL_MAX}."));
-        }
-        if self.min >= self.max {
-            return Err(format!("Maximum value ({}) must be greater than Minimum value ({}).", self.max, self.min));
-        }
-        if self.step < 1 {
-            return Err("Incremental change must be at least 1.".into());
-        }
-        let span = self.max - self.min;
-        if self.step > span {
-            return Err(format!("Incremental change ({}) can be at most Maximum minus Minimum ({span}).", self.step));
-        }
-        if self.kind == ControlKind::Slider {
-            if self.page < self.step {
-                return Err(format!("Page change ({}) must be at least the incremental change ({}).", self.page, self.step));
-            }
-            if self.page > CONTROL_MAX {
-                return Err(format!("Page change can be at most {CONTROL_MAX}."));
-            }
-        }
-        Ok(())
-    }
-
-    /// `v` clamped to min..max and snapped to the nearest step from min (max stays reachable).
-    pub fn snap(&self, v: f64) -> u32 {
-        let (min, max) = (self.min.min(CONTROL_MAX), self.max.min(CONTROL_MAX).max(self.min.min(CONTROL_MAX)));
-        if !v.is_finite() || v <= min as f64 {
-            return min;
-        }
-        if v >= max as f64 {
-            return max;
-        }
-        let step = self.step.max(1) as f64;
-        let snapped = (min as f64 + ((v - min as f64) / step).round() * step).clamp(min as f64, max as f64);
-        // When the step doesn't divide the range, the maximum is a stop of its own.
-        if (max as f64 - v).abs() < (snapped - v).abs() { max } else { snapped as u32 }
-    }
-}
-
 /// The kinds of floating object a sheet holds. Commands name an object by kind and
 /// workbook-unique id (`{kind: "chart", id}`); [`ObjKind::name`] is that parameter's spelling.
 /// Equations are stored as shapes ([`ShapeKind::Equation`]) but select, open and delete as their
@@ -930,11 +752,10 @@ pub enum ObjKind {
     Shape,
     Slicer,
     Equation,
-    Control,
 }
 
 impl ObjKind {
-    pub const ALL: [ObjKind; 6] = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer, ObjKind::Equation, ObjKind::Control];
+    pub const ALL: [ObjKind; 5] = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer, ObjKind::Equation];
 
     /// The name used in command parameters.
     pub fn name(self) -> &'static str {
@@ -944,7 +765,6 @@ impl ObjKind {
             ObjKind::Shape => "shape",
             ObjKind::Slicer => "slicer",
             ObjKind::Equation => "equation",
-            ObjKind::Control => "control",
         }
     }
 
@@ -1101,39 +921,6 @@ mod trendline_forecast_tests {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn chart_without_hole_size_keeps_the_legacy_hole() {
-        let chart = Chart {
-            id: 1,
-            kind: ChartKind::Doughnut,
-            anchor: Anchor::default(),
-            title: None,
-            series: vec![],
-            legend: LegendPos::Right,
-            data_labels: false,
-            data_table: None,
-            gridlines: false,
-            style: 1,
-            hole_size: 75,
-            first_slice_angle: 0,
-            x_title: None,
-            y_title: None,
-            source: None,
-            by_rows: false,
-            pivot: None,
-        };
-        let mut json = serde_json::to_value(&chart).expect("serialize chart");
-        json.as_object_mut().expect("chart object").remove("hole_size");
-        let legacy: Chart = serde_json::from_value(json).expect("deserialize legacy chart");
-        assert_eq!(legacy.hole_size, 50, "documents saved before hole_size existed keep the old 50% hole");
-        assert_eq!(chart.hole_size, 75, "new charts keep Excel's 75% default");
-    }
-}
-
 #[cfg(test)]
 mod equation_cache_tests {
     use super::{EquationCache, source_key};

crates/model/src/sheet.rs

@@ -9,8 +9,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::cell::{Cell, CellPicture};
 use crate::features::{
-    Anchor, AutoFilter, Chart, Comment, CondFormat, FormControl, Hyperlink, Image, LineInfo, ObjKind, ObjRef, PivotTable, PrintSettings, Shape,
-    ShapeKind, SheetProtection, Slicer, Sparkline, Table, Validation,
+    Anchor, AutoFilter, Chart, Comment, CondFormat, Hyperlink, Image, LineInfo, ObjKind, ObjRef, PivotTable, PrintSettings, Shape, ShapeKind,
+    SheetProtection, Slicer, Sparkline, Table, Validation,
 };
 use crate::store::CellStore;
 use crate::style::{Color, StyleId};
@@ -147,10 +147,6 @@ pub struct Sheet {
     /// On-sheet slicer widgets (filter a table column by clicking value tiles).
     #[serde(default)]
     pub slicers: Vec<Slicer>,
-    /// Form controls (buttons, sliders, spin buttons). They paint above every other object and
-    /// take clicks first.
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub controls: Vec<FormControl>,
     /// PivotTables whose output lives on this sheet.
     #[serde(default)]
     pub pivots: Vec<PivotTable>,
@@ -223,7 +219,6 @@ impl Sheet {
             shapes: vec![],
             sparklines: vec![],
             slicers: vec![],
-            controls: vec![],
             pivots: vec![],
             protection: None,
             edit_ranges: vec![],
@@ -290,8 +285,6 @@ impl Sheet {
             if s.kind == ShapeKind::Equation { ObjKind::Equation } else { ObjKind::Shape }
         } else if self.slicers.iter().any(|o| o.id == id) {
             ObjKind::Slicer
-        } else if self.controls.iter().any(|o| o.id == id) {
-            ObjKind::Control
         } else {
             return None;
         };
@@ -312,7 +305,6 @@ impl Sheet {
             ObjKind::Shape => self.shapes.iter().find(|c| c.id == o.id).map(|c| c.anchor),
             ObjKind::Slicer => self.slicers.iter().find(|c| c.id == o.id).map(|c| c.anchor),
             ObjKind::Equation => self.shapes.iter().find(|c| c.id == o.id && c.kind == ShapeKind::Equation).map(|c| c.anchor),
-            ObjKind::Control => self.controls.iter().find(|c| c.id == o.id).map(|c| c.anchor),
         }
     }
 
@@ -323,7 +315,6 @@ impl Sheet {
             ObjKind::Shape => self.shapes.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor),
             ObjKind::Slicer => self.slicers.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor),
             ObjKind::Equation => self.shapes.iter_mut().find(|c| c.id == o.id && c.kind == ShapeKind::Equation).map(|c| &mut c.anchor),
-            ObjKind::Control => self.controls.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor),
         }
     }
 
@@ -340,13 +331,12 @@ impl Sheet {
             ObjKind::Shape => take(&mut self.shapes, |c| c.id == o.id),
             ObjKind::Slicer => take(&mut self.slicers, |c| c.id == o.id),
             ObjKind::Equation => take(&mut self.shapes, |c| c.id == o.id && c.kind == ShapeKind::Equation),
-            ObjKind::Control => take(&mut self.controls, |c| c.id == o.id),
         }
     }
 
-    /// Every floating object's anchor in a fixed order (charts, images, shapes, slicers, controls)
-    /// that [`Sheet::object_anchors_mut`] repeats, so a pass can compute new anchors from the old
-    /// ones and write them back in step.
+    /// Every floating object's anchor in a fixed order (charts, images, shapes, slicers) that
+    /// [`Sheet::object_anchors_mut`] repeats, so a pass can compute new anchors from the old ones
+    /// and write them back in step.
     pub fn object_anchors(&self) -> impl Iterator<Item = &Anchor> {
         self.charts
             .iter()
@@ -354,7 +344,6 @@ impl Sheet {
             .chain(self.images.iter().map(|o| &o.anchor))
             .chain(self.shapes.iter().map(|o| &o.anchor))
             .chain(self.slicers.iter().map(|o| &o.anchor))
-            .chain(self.controls.iter().map(|o| &o.anchor))
     }
 
     pub fn object_anchors_mut(&mut self) -> impl Iterator<Item = &mut Anchor> {
@@ -364,7 +353,6 @@ impl Sheet {
             .chain(self.images.iter_mut().map(|o| &mut o.anchor))
             .chain(self.shapes.iter_mut().map(|o| &mut o.anchor))
             .chain(self.slicers.iter_mut().map(|o| &mut o.anchor))
-            .chain(self.controls.iter_mut().map(|o| &mut o.anchor))
     }
     /// Displayed value of a cell: its own value, or a spilled value.
     pub fn value(&self, c: CellRef) -> Value {
@@ -491,14 +479,12 @@ impl Sheet {
     /// sheet AutoFilter while it has criteria, or a hidden data row of a filtered table.
     /// Other hidden rows were hidden by hand.
     pub fn is_row_filtered(&self, row: u32) -> bool {
-        self.is_row_hidden(row) && self.filter_row_spans().iter().any(|&(first, last)| row >= first && row <= last)
-    }
-    /// The row spans (first, last) an applied filter can hide: the data rows of the sheet
-    /// AutoFilter while it has criteria, and of each filtered table.
-    pub fn filter_row_spans(&self) -> Vec<(u32, u32)> {
-        let sheet = self.autofilter.as_ref().filter(|af| !af.criteria.is_empty()).map(|af| (af.range.start.row.saturating_add(1), af.range.end.row));
-        let tables = self.tables.iter().filter(|t| !t.filter.is_empty()).filter_map(|t| t.data_range()).map(|r| (r.start.row, r.end.row));
-        sheet.into_iter().chain(tables).collect()
+        if !self.is_row_hidden(row) {
+            return false;
+        }
+        let in_sheet_filter =
+            self.autofilter.as_ref().is_some_and(|af| !af.criteria.is_empty() && row > af.range.start.row && row <= af.range.end.row);
+        in_sheet_filter || self.tables.iter().any(|t| !t.filter.is_empty() && t.data_range().is_some_and(|r| row >= r.start.row && row <= r.end.row))
     }
     pub fn is_col_hidden(&self, col: u32) -> bool {
         self.cols.get(&col).is_some_and(|r| r.hidden)
@@ -833,8 +819,6 @@ mod tests {
                 data_table: None,
                 gridlines: false,
                 style: 0,
-                hole_size: 75,
-                first_slice_angle: 0,
                 x_title: None,
                 y_title: None,
                 source: None,
@@ -855,7 +839,6 @@ mod tests {
             ObjKind::Slicer => {
                 s.slicers.push(Slicer { id, table: String::new(), column: String::new(), caption: String::new(), anchor, selected: None, columns: 1 })
             }
-            ObjKind::Control => s.controls.push(FormControl { id, anchor, ..Default::default() }),
         }
     }
 
@@ -877,15 +860,13 @@ mod tests {
             (ObjKind::Slicer, 1),
             (ObjKind::Image, 4),
             (ObjKind::Equation, 6),
-            (ObjKind::Control, 13),
             (ObjKind::Shape, 12),
             (ObjKind::Equation, 8),
-            (ObjKind::Control, 15),
         ];
         for &(kind, id) in &inserted {
             push_object(&mut s, kind, id, Anchor { cell: CellRef::new(id, 0), ..Default::default() });
         }
-        let per_kind = s.charts.len() + s.images.len() + s.shapes.len() + s.slicers.len() + s.controls.len();
+        let per_kind = s.charts.len() + s.images.len() + s.shapes.len() + s.slicers.len();
         assert_eq!(per_kind, inserted.len());
         assert_eq!(s.object_anchors().count(), per_kind, "object_anchors visits every collection");
         assert_eq!(s.object_anchors_mut().count(), per_kind, "object_anchors_mut visits every collection");
@@ -896,10 +877,10 @@ mod tests {
         }
         let marks: Vec<f32> = s.object_anchors().map(|a| a.dx).collect();
         assert_eq!(marks, (0..per_kind).map(|i| i as f32).collect::<Vec<f32>>());
-        // The sequence is the documented one (charts, images, shapes, slicers, controls, each in
-        // insertion order; equations are shapes) and every object appears in it once.
+        // The sequence is the documented one (charts, images, shapes, slicers, each in insertion
+        // order; equations are shapes) and every object appears in it once.
         let collection = |k: ObjKind| if k == ObjKind::Equation { ObjKind::Shape } else { k };
-        let documented: Vec<u32> = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer, ObjKind::Control]
+        let documented: Vec<u32> = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer]
             .iter()
             .flat_map(|&k| inserted.iter().filter(move |(kind, _)| collection(*kind) == k).map(|&(_, id)| id))
             .collect();

crates/model/src/store.rs

@@ -4,8 +4,6 @@
 //! copies only the band pointers; editing a cell copies just its band.
 
 use std::collections::BTreeMap;
-use std::collections::btree_map::Entry;
-use std::ops::RangeInclusive;
 use std::sync::Arc;
 
 use gridcraft_core::{CellRef, RangeRef};
@@ -268,187 +266,64 @@ impl CellStore {
         }
         bytes
     }
-    /// Removes every cell in `r` and returns them, row-major.
+    /// Removes every cell in `r` and returns them.
     pub fn take_range(&mut self, r: RangeRef) -> Vec<(CellRef, Cell)> {
-        if r.end.col < gridcraft_core::MAX_COLS - 1 {
-            // A block with columns to its right: cutting it out of each row map measured slower
-            // than removing its cells one by one (#3575).
-            let keys: Vec<CellRef> = self.iter_range(r).map(|(c, _)| c).collect();
-            return keys.into_iter().filter_map(|c| self.remove(c).map(|cell| (c, cell))).collect();
-        }
-        let rows = self.take_rows(r.start.row..=r.end.row, r.start.col..=r.end.col);
-        rows.into_iter().flat_map(|(row, cols)| cols.into_iter().map(move |(col, cell)| (CellRef::new(row, col), cell))).collect()
+        let keys: Vec<CellRef> = self.iter_range(r).map(|(c, _)| c).collect();
+        keys.into_iter().filter_map(|c| self.remove(c).map(|cell| (c, cell))).collect()
     }
     /// Rows strictly greater than or equal to `from` moved by `delta` (positive = down). Rows that
     /// would land before `from`... callers delete the vacated block first.
     pub fn shift_rows(&mut self, from: u32, delta: i64) {
-        let moved = self.take_rows(from..=u32::MAX, 0..=u32::MAX);
-        self.put_rows(moved.into_iter().filter_map(|(row, cols)| Some((shifted(row, delta, gridcraft_core::MAX_ROWS)?, cols))));
+        let moved: Vec<(CellRef, Cell)> = {
+            let keys: Vec<CellRef> = self.iter().filter(|(c, _)| c.row >= from).map(|(c, _)| c).collect();
+            keys.into_iter().filter_map(|c| self.remove(c).map(|cell| (c, cell))).collect()
+        };
+        for (c, cell) in moved {
+            let nr = c.row as i64 + delta;
+            if (0..gridcraft_core::MAX_ROWS as i64).contains(&nr) {
+                self.set(CellRef::new(nr as u32, c.col), cell);
+            }
+        }
     }
     pub fn shift_cols(&mut self, from: u32, delta: i64) {
-        let moved = self.take_rows(0..=u32::MAX, from..=u32::MAX);
-        self.put_rows(moved.into_iter().map(|(row, cols)| (row, shift_keys(cols, delta))));
+        let keys: Vec<CellRef> = self.iter().filter(|(c, _)| c.col >= from).map(|(c, _)| c).collect();
+        let moved: Vec<(CellRef, Cell)> = keys.into_iter().filter_map(|c| self.remove(c).map(|cell| (c, cell))).collect();
+        for (c, cell) in moved {
+            let nc = c.col as i64 + delta;
+            if (0..gridcraft_core::MAX_COLS as i64).contains(&nc) {
+                self.set(CellRef::new(c.row, nc as u32), cell);
+            }
+        }
     }
     /// Shifts cells within rows `r0..=r1` and columns `>= from` horizontally (Insert/Delete Cells
     /// with shift right/left).
     pub fn shift_cols_in_rows(&mut self, r0: u32, r1: u32, from: u32, delta: i64) {
-        let r = RangeRef::new(CellRef::new(r0, from), CellRef::new(r1, gridcraft_core::MAX_COLS - 1));
-        let moved = self.take_rows(r.start.row..=r.end.row, r.start.col..=r.end.col);
-        self.put_rows(moved.into_iter().map(|(row, cols)| (row, shift_keys(cols, delta))));
+        let range = RangeRef::new(CellRef::new(r0, from), CellRef::new(r1, gridcraft_core::MAX_COLS - 1));
+        let moved = self.take_range(range);
+        for (c, cell) in moved {
+            let nc = c.col as i64 + delta;
+            if (0..gridcraft_core::MAX_COLS as i64).contains(&nc) {
+                self.set(CellRef::new(c.row, nc as u32), cell);
+            }
+        }
     }
     /// Shifts cells within columns `c0..=c1` and rows `>= from` vertically.
     pub fn shift_rows_in_cols(&mut self, c0: u32, c1: u32, from: u32, delta: i64) {
-        // Cell by cell: the moved cells sit between columns that stay, so moving row maps
-        // measured no faster here (#3575).
         let range = RangeRef::new(CellRef::new(from, c0), CellRef::new(gridcraft_core::MAX_ROWS - 1, c1));
-        for (c, cell) in self.take_range(range) {
-            if let Some(nr) = shifted(c.row, delta, gridcraft_core::MAX_ROWS) {
-                self.set(CellRef::new(nr, c.col), cell);
+        let moved = self.take_range(range);
+        for (c, cell) in moved {
+            let nr = c.row as i64 + delta;
+            if (0..gridcraft_core::MAX_ROWS as i64).contains(&nr) {
+                self.set(CellRef::new(nr as u32, c.col), cell);
             }
         }
     }
-    /// Removes the cells in `rows` x `cols` and returns them grouped by row, in row order. Moves
-    /// whole column maps (or the split-off part of one) instead of removing cell by cell, and only
-    /// copies bands that hold a cell in the block, so snapshots keep sharing the others.
-    fn take_rows(&mut self, rows: RangeInclusive<u32>, cols: RangeInclusive<u32>) -> Vec<(u32, BTreeMap<u32, Cell>)> {
-        let (r0, r1, c0, c1) = (*rows.start(), *rows.end(), *cols.start(), *cols.end());
-        let mut out = Vec::new();
-        if r0 > r1 || c0 > c1 {
-            return out;
-        }
-        let whole_rows = c0 == 0 && c1 == u32::MAX;
-        let keys: Vec<u32> = self
-            .bands
-            .range(r0 / BAND..=r1 / BAND)
-            .filter(|(_, band)| band.rows.range(r0..=r1).any(|(_, row)| row.range(c0..=c1).next().is_some()))
-            .map(|(k, _)| *k)
-            .collect();
-        for key in keys {
-            let Some(band) = self.bands.get_mut(&key) else { continue };
-            let inside = |row: Option<&u32>| row.is_some_and(|r| (r0..=r1).contains(r));
-            if whole_rows && inside(band.rows.keys().next()) && inside(band.rows.keys().next_back()) {
-                // The whole band moves: no splitting.
-                let Some(band) = self.bands.remove(&key) else { continue };
-                for (row, taken) in Arc::unwrap_or_clone(band).rows {
-                    self.len -= taken.len();
-                    out.push((row, taken));
-                }
-                continue;
-            }
-            let band = Arc::make_mut(band);
-            let mut block = band.rows.split_off(&r0);
-            let mut tail = match r1.checked_add(1) {
-                Some(next) => block.split_off(&next),
-                None => BTreeMap::new(),
-            };
-            for (row, mut kept) in block {
-                let taken = if whole_rows {
-                    std::mem::take(&mut kept)
-                } else if c1.checked_add(1).is_none_or(|next| kept.range(next..).next().is_none()) {
-                    // Nothing right of the block: one split.
-                    kept.split_off(&c0)
-                } else {
-                    let mut taken = BTreeMap::new();
-                    for (col, cell) in kept.extract_if(c0..=c1, |_, _| true) {
-                        taken.insert(col, cell);
-                    }
-                    taken
-                };
-                if !kept.is_empty() {
-                    band.rows.insert(row, kept);
-                }
-                if !taken.is_empty() {
-                    self.len -= taken.len();
-                    out.push((row, taken));
-                }
-            }
-            band.rows.append(&mut tail);
-            if band.rows.is_empty() {
-                self.bands.remove(&key);
-            }
-        }
-        out
-    }
-    /// Stores rows of cells (each row at most once) the way `set` stores each cell: a cell
-    /// replaces what is there, and a blank cell clears its destination instead of being stored.
-    /// A row with nothing stored yet takes the whole map. Rows in order share one band lookup.
-    fn put_rows(&mut self, rows: impl Iterator<Item = (u32, BTreeMap<u32, Cell>)>) {
-        let mut rows = rows.peekable();
-        let mut group = Vec::new();
-        while let Some((first, cols)) = rows.next() {
-            let key = first / BAND;
-            group.clear();
-            group.push((first, cols));
-            while let Some(next) = rows.next_if(|(row, _)| row / BAND == key) {
-                group.push(next);
-            }
-            // Leave the band shared when only blank cells land on empty positions.
-            let existing = self.bands.get(&key);
-            let writes = group.iter().any(|(row, cols)| {
-                let dest = existing.and_then(|band| band.rows.get(row));
-                cols.iter().any(|(col, cell)| !cell.is_blank() || dest.is_some_and(|d| d.contains_key(col)))
-            });
-            if !writes {
-                continue;
-            }
-            let band = Arc::make_mut(self.bands.entry(key).or_default());
-            for (row, mut cols) in group.drain(..) {
-                match band.rows.entry(row) {
-                    Entry::Vacant(slot) => {
-                        if cols.values().any(Cell::is_blank) {
-                            cols.retain(|_, cell| !cell.is_blank());
-                        }
-                        if !cols.is_empty() {
-                            self.len += cols.len();
-                            slot.insert(cols);
-                        }
-                    }
-                    Entry::Occupied(mut slot) => {
-                        let dest = slot.get_mut();
-                        for (col, cell) in cols {
-                            if cell.is_blank() {
-                                if dest.remove(&col).is_some() {
-                                    self.len -= 1;
-                                }
-                            } else if dest.insert(col, cell).is_none() {
-                                self.len += 1;
-                            }
-                        }
-                        if dest.is_empty() {
-                            slot.remove();
-                        }
-                    }
-                }
-            }
-            if band.rows.is_empty() {
-                self.bands.remove(&key);
-            }
-        }
-    }
-}
-
-/// `at + delta` when it lies in `0..limit`.
-fn shifted(at: u32, delta: i64, limit: u32) -> Option<u32> {
-    let to = (at as i64).checked_add(delta)?;
-    if (0..limit as i64).contains(&to) { Some(to as u32) } else { None }
-}
-
-/// The cells of one row with their columns moved by `delta`; cells that would leave the sheet are
-/// dropped.
-fn shift_keys(cols: BTreeMap<u32, Cell>, delta: i64) -> BTreeMap<u32, Cell> {
-    let mut out = BTreeMap::new();
-    for (col, cell) in cols {
-        if let Some(c) = shifted(col, delta, gridcraft_core::MAX_COLS) {
-            out.insert(c, cell);
-        }
-    }
-    out
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gridcraft_core::{MAX_COLS, MAX_ROWS, Value};
+    use gridcraft_core::Value;
 
     fn c(r: u32, col: u32) -> CellRef {
         CellRef::new(r, col)
@@ -521,211 +396,4 @@ mod tests {
         s.shift_cols(0, 1);
         assert!(s.get(c(7, 1)).is_some());
     }
-
-    /// The per-cell algorithms the shifts used before they moved whole rows (#3575), kept as the
-    /// reference the structural versions must match cell for cell.
-    mod per_cell {
-        use super::*;
-
-        fn reset(s: &mut CellStore, moved: Vec<(CellRef, Cell)>, to: impl Fn(CellRef) -> Option<CellRef>) {
-            for (at, cell) in moved {
-                if let Some(at) = to(at) {
-                    s.set(at, cell);
-                }
-            }
-        }
-        fn row_by(delta: i64) -> impl Fn(CellRef) -> Option<CellRef> {
-            move |at| {
-                let r = at.row as i64 + delta;
-                (0..MAX_ROWS as i64).contains(&r).then(|| CellRef::new(r as u32, at.col))
-            }
-        }
-        fn col_by(delta: i64) -> impl Fn(CellRef) -> Option<CellRef> {
-            move |at| {
-                let c = at.col as i64 + delta;
-                (0..MAX_COLS as i64).contains(&c).then(|| CellRef::new(at.row, c as u32))
-            }
-        }
-        pub fn take_range(s: &mut CellStore, r: RangeRef) -> Vec<(CellRef, Cell)> {
-            let keys: Vec<CellRef> = s.iter_range(r).map(|(c, _)| c).collect();
-            keys.into_iter().filter_map(|c| s.remove(c).map(|cell| (c, cell))).collect()
-        }
-        pub fn shift_rows(s: &mut CellStore, from: u32, delta: i64) {
-            let keys: Vec<CellRef> = s.iter().filter(|(c, _)| c.row >= from).map(|(c, _)| c).collect();
-            let moved = keys.into_iter().filter_map(|c| s.remove(c).map(|cell| (c, cell))).collect();
-            reset(s, moved, row_by(delta));
-        }
-        pub fn shift_cols(s: &mut CellStore, from: u32, delta: i64) {
-            let keys: Vec<CellRef> = s.iter().filter(|(c, _)| c.col >= from).map(|(c, _)| c).collect();
-            let moved = keys.into_iter().filter_map(|c| s.remove(c).map(|cell| (c, cell))).collect();
-            reset(s, moved, col_by(delta));
-        }
-        pub fn shift_cols_in_rows(s: &mut CellStore, r0: u32, r1: u32, from: u32, delta: i64) {
-            let moved = take_range(s, RangeRef::new(CellRef::new(r0, from), CellRef::new(r1, MAX_COLS - 1)));
-            reset(s, moved, col_by(delta));
-        }
-        pub fn shift_rows_in_cols(s: &mut CellStore, c0: u32, c1: u32, from: u32, delta: i64) {
-            let moved = take_range(s, RangeRef::new(CellRef::new(from, c0), CellRef::new(MAX_ROWS - 1, c1)));
-            reset(s, moved, row_by(delta));
-        }
-    }
-
-    struct Lcg(u64);
-    impl Lcg {
-        fn below(&mut self, n: u64) -> u64 {
-            self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
-            (self.0 >> 33) % n.max(1)
-        }
-        fn pick<T: Copy>(&mut self, xs: &[T]) -> T {
-            xs[self.below(xs.len() as u64) as usize]
-        }
-    }
-
-    /// A position near a band edge, the sheet edge, or anywhere below `max`.
-    fn coord(rng: &mut Lcg, max: u32, edges: &[u32]) -> u32 {
-        match rng.below(3) {
-            0 => rng.pick(edges).min(max - 1),
-            1 => max - 1 - rng.below(70.min(max as u64)) as u32,
-            _ => rng.below(max as u64) as u32,
-        }
-    }
-
-    /// Random store with values, styled-only cells, a few cells off the grid, and blank cells left
-    /// behind by `get_mut` (which `set` never stores, but the old shifts dropped and let clear
-    /// their destination).
-    fn random_store(rng: &mut Lcg, max_r: u32, max_c: u32) -> CellStore {
-        let row_edges = [0, 1, 62, 63, 64, 65, 127, 128, 129, 191, 192, MAX_ROWS - 64, MAX_ROWS - 1];
-        let col_edges = [0, 1, 2, 63, 64, 65, MAX_COLS - 2, MAX_COLS - 1];
-        let mut s = CellStore::new();
-        for _ in 0..rng.below(300) {
-            let mut at = CellRef::new(coord(rng, max_r, &row_edges), coord(rng, max_c, &col_edges));
-            // Now and then a cell outside the grid (`set` does not check): the shifts must treat
-            // it as the old code did.
-            match rng.below(60) {
-                0 => at.row = MAX_ROWS + rng.below(3) as u32,
-                1 => at.col = MAX_COLS + rng.below(3) as u32,
-                _ => {}
-            }
-            let cell = match rng.below(5) {
-                0 => Cell { style: crate::style::StyleId(1 + rng.below(3) as u32), ..Cell::default() },
-                1 => Cell::value(Value::from("t")),
-                _ => Cell::value(Value::Number(rng.below(1000) as f64)),
-            };
-            s.set(at, cell);
-            if rng.below(8) == 0
-                && let Some(cell) = s.get_mut(at)
-            {
-                *cell = Cell::default();
-            }
-        }
-        s
-    }
-
-    fn assert_same(new: &CellStore, old: &CellStore, base: &CellStore, base_copy: &CellStore, what: &str) {
-        assert_eq!(new, old, "{what}");
-        assert_eq!(new.len(), new.iter().count(), "{what}: len");
-        assert!(new.iter().map(|(c, x)| (c, x.clone())).eq(old.iter().map(|(c, x)| (c, x.clone()))), "{what}: iteration");
-        assert!(new.bands.values().all(|b| !b.rows.is_empty() && b.rows.values().all(|r| !r.is_empty())), "{what}: empty band or row");
-        // Copy-on-write: every band the old code left shared with the snapshot stays shared.
-        for (k, b) in &base.bands {
-            if old.bands.get(k).is_some_and(|o| Arc::ptr_eq(o, b)) {
-                assert!(new.bands.get(k).is_some_and(|n| Arc::ptr_eq(n, b)), "{what}: band {k} copied");
-            }
-        }
-        assert_eq!(base, base_copy, "{what}: snapshot changed");
-    }
-
-    #[test]
-    fn structural_shifts_match_per_cell_shifts() {
-        let mut rng = Lcg(3575);
-        let deltas = [0i64, 1, -1, 2, -2, 63, -63, 64, -64, 65, -65, 128, -128, 1000, -1000, MAX_ROWS as i64, -(MAX_ROWS as i64)];
-        let row_edges = [0, 1, 63, 64, 65, 127, 128, MAX_ROWS - 1, MAX_ROWS];
-        let col_edges = [0, 1, 63, 64, 65, MAX_COLS - 1, MAX_COLS];
-        for trial in 0..3000 {
-            let max_r = [200, 5000, MAX_ROWS][trial % 3];
-            let max_c = [30, MAX_COLS][trial / 3 % 2];
-            let mut base = random_store(&mut rng, max_r, max_c);
-            for step in 0..4 {
-                let snapshot = base.clone();
-                let (mut new, mut old) = (base.clone(), base.clone());
-                let delta = if rng.below(2) == 0 { rng.pick(&deltas) } else { rng.below(301) as i64 - 150 };
-                let row = if rng.below(2) == 0 { rng.pick(&row_edges) } else { rng.below(max_r as u64 + 1) as u32 };
-                let col = if rng.below(2) == 0 { rng.pick(&col_edges) } else { rng.below(max_c as u64 + 1) as u32 };
-                let (row2, col2) = (rng.below(max_r as u64 + 1) as u32, rng.below(max_c as u64 + 1) as u32);
-                let op = rng.below(5);
-                match op {
-                    0 => {
-                        new.shift_rows(row, delta);
-                        per_cell::shift_rows(&mut old, row, delta);
-                    }
-                    1 => {
-                        new.shift_cols(col, delta);
-                        per_cell::shift_cols(&mut old, col, delta);
-                    }
-                    2 => {
-                        new.shift_cols_in_rows(row, row2, col, delta);
-                        per_cell::shift_cols_in_rows(&mut old, row, row2, col, delta);
-                    }
-                    3 => {
-                        new.shift_rows_in_cols(col, col2, row, delta);
-                        per_cell::shift_rows_in_cols(&mut old, col, col2, row, delta);
-                    }
-                    _ => {
-                        let r = RangeRef::new(CellRef::new(row, col), CellRef::new(row2, col2));
-                        assert_eq!(new.take_range(r), per_cell::take_range(&mut old, r), "trial {trial} step {step}: taken cells");
-                    }
-                }
-                let what = format!("trial {trial} step {step} op {op} row {row}..{row2} col {col}..{col2} delta {delta}");
-                assert_same(&new, &old, &base, &snapshot, &what);
-                base = new;
-            }
-        }
-    }
-
-    #[test]
-    fn off_grid_cells_right_of_a_block_stay_put() {
-        let mut s = CellStore::new();
-        for col in [0, 5, MAX_COLS - 1, MAX_COLS + 1] {
-            s.set(c(3, col), Cell::value((col as f64).into()));
-        }
-        let mut old = s.clone();
-        s.shift_cols_in_rows(3, 3, 0, 1);
-        per_cell::shift_cols_in_rows(&mut old, 3, 3, 0, 1);
-        assert_eq!(s, old);
-        assert_eq!(s.get(c(3, MAX_COLS + 1)).map(|x| x.value.clone()), Some(Value::Number((MAX_COLS + 1) as f64)));
-        let r = RangeRef::rows(3, 3);
-        assert_eq!(s.take_range(r), per_cell::take_range(&mut old, r));
-        assert_eq!(s, old);
-    }
-
-    #[test]
-    fn moved_blank_cell_clears_its_destination() {
-        let mut s = CellStore::new();
-        s.set(c(3, 0), Cell::value(1.0.into()));
-        s.set(c(5, 0), Cell::value(2.0.into()));
-        s.set(c(5, 1), Cell::value(3.0.into()));
-        if let Some(cell) = s.get_mut(c(5, 0)) {
-            *cell = Cell::default();
-        }
-        s.shift_rows(5, -2);
-        assert!(s.get(c(3, 0)).is_none());
-        assert_eq!(s.get(c(3, 1)).map(|x| x.value.clone()), Some(Value::Number(3.0)));
-        assert_eq!(s.len(), 1);
-    }
-
-    #[test]
-    fn shifting_keeps_untouched_bands_shared() {
-        let mut s = CellStore::new();
-        for r in 0..256 {
-            s.set(c(r, 0), Cell::value((r as f64).into()));
-        }
-        s.set(c(200, 5), Cell::value("x".into()));
-        let snap = s.clone();
-        s.shift_rows(130, 1);
-        assert!(Arc::ptr_eq(&s.bands[&0], &snap.bands[&0]));
-        assert!(Arc::ptr_eq(&s.bands[&1], &snap.bands[&1]));
-        s.shift_cols(5, 1);
-        assert!(Arc::ptr_eq(&s.bands[&0], &snap.bands[&0]));
-        assert_eq!(s.get(c(201, 6)).map(|x| x.value.clone()), Some(Value::from("x")));
-    }
 }

crates/model/src/workbook.rs

@@ -506,7 +506,7 @@ impl Workbook {
         }
     }
 
-    /// A free id for a new chart, picture, shape, table, slicer or form control: one more than the largest in
+    /// A free id for a new chart, picture, shape, table or slicer: one more than the largest in
     /// use, or, when that is `u32::MAX` (a file can carry any id), the lowest free one.
     pub fn next_object_id(&self) -> u32 {
         self.free_object_ids(1).first().copied().unwrap_or(u32::MAX)
@@ -527,7 +527,6 @@ impl Workbook {
                     .chain(s.shapes.iter().map(|o| o.id))
                     .chain(s.tables.iter().map(|o| o.id))
                     .chain(s.slicers.iter().map(|o| o.id))
-                    .chain(s.controls.iter().map(|o| o.id))
             })
             .collect();
         used.sort_unstable();
@@ -614,10 +613,6 @@ mod tests {
             sh.images.push(image(7));
         }
         assert_eq!(wb.next_object_id(), 8);
-        if let Some(sh) = wb.sheet_mut(0) {
-            sh.controls.push(crate::FormControl { id: 12, ..Default::default() });
-        }
-        assert_eq!(wb.next_object_id(), 13, "form controls take ids from the same sequence");
         if let Some(sh) = wb.sheet_mut(0) {
             sh.images.push(image(u32::MAX));
         }
@@ -636,19 +631,6 @@ mod tests {
         assert_eq!(wb.free_object_ids(3), vec![1, 2, u32::MAX], "the top first, then from 1");
     }
 
-    /// A form control's id is in use like any object's: the free ids skip it, also when it is the
-    /// largest id a file could carry.
-    #[test]
-    fn free_object_ids_skip_a_form_controls_id() {
-        let mut wb = Workbook::new();
-        if let Some(sh) = wb.sheet_mut(0) {
-            sh.controls.push(crate::FormControl { id: 3, ..Default::default() });
-            sh.controls.push(crate::FormControl { id: u32::MAX, ..Default::default() });
-        }
-        assert_eq!(wb.free_object_ids(4), vec![1, 2, 4, 5], "3 and the largest id are taken");
-        assert_eq!(wb.next_object_id(), 1);
-    }
-
     /// A file can use the largest id and the one below it: nothing is free above them, so the free
     /// ids are the lowest unused ones from 1 (0 is never an object's id), and a large request is
     /// served in time linear in the count and the ids in use.

crates/numfmt/src/lib.rs

@@ -323,60 +323,6 @@ impl NumberFormat {
         (Formatted { text: out.text, color: sec.color, fill: out.fill, numeric: true }, false)
     }
 
-    /// The number `n` as this format displays it: what Excel stores when "Set precision as
-    /// displayed" is on. Fixed decimals, percent, thousands scaling (`0.0,,`), scientific and
-    /// fraction sections round to what they show; the section is picked as for display, so
-    /// `0.00;(0.0)` keeps one decimal for negatives. Observed in Excel (COM,
-    /// `Workbook.PrecisionAsDisplayed`), these keep the full value: General, date and time
-    /// formats (`mm:ss.0` included), text formats and sections without digits (`"x"`, `;;;`).
-    /// The section is picked by [`NumberFormat::rounding_section`], which ignores conditions.
-    /// Never returns `-0`.
-    pub fn round_as_displayed(&self, n: f64) -> f64 {
-        if self.is_general() || !n.is_finite() {
-            return n;
-        }
-        let Some(sec) = self.rounding_section(n) else { return n };
-        if sec.kind != SecKind::Number {
-            return n;
-        }
-        let Some(m) = render::shown_value(sec, n) else { return n };
-        if m == 0.0 {
-            0.0
-        } else if n < 0.0 {
-            -m
-        } else {
-            m
-        }
-    }
-
-    /// The section whose digits "Set precision as displayed" rounds `n` by. Observed in Excel
-    /// (COM), this differs from the section that displays `n`:
-    /// - Conditions are ignored; the sign picks the section, the first for positives and the
-    ///   second for negatives. `[<1]0.00;0` shows 2.333 as `2` but stores 2.33, and stores -10/3
-    ///   as -3 although it shows `-3.00`. `[>1]0.0;0.000` stores 1/3 as 0.3.
-    /// - A format with a condition and a single number section keeps negatives at full value
-    ///   (`[<1]0.00`, `[>=-100]0.0`); with an `@` section added (`[<1]0.00;@`) negatives use the
-    ///   first section, as every format without a condition does.
-    /// - A completely empty section (no characters, not even a colour) passes to the next one:
-    ///   `0.0;;0.000` stores -2.333 as -2.333, `;0.0` stores 2.333 as 2.3, `;;0.0` too. A section
-    ///   with only a colour or a literal (`0.0;[Red];0.000`, `0.0;" "`) has no digits and keeps
-    ///   the full value.
-    ///
-    /// `None` keeps the full value.
-    fn rounding_section(&self, n: f64) -> Option<&Section> {
-        let secs = self.num_sections();
-        let conditional = secs.iter().any(|s| s.cond.is_some());
-        let slot = if n < 0.0 && secs.len() >= 2 {
-            1
-        } else if n < 0.0 && conditional && self.inner.text_section.is_none() {
-            return None;
-        } else {
-            0
-        };
-        let empty = |s: &Section| s.toks.is_empty() && s.color.is_none() && s.cond.is_none();
-        secs.get(slot..)?.iter().find(|s| !empty(s))
-    }
-
     fn format_text(&self, t: &str) -> Formatted {
         match self.inner.text_section.and_then(|i| self.inner.sections.get(i)) {
             Some(sec) => {

crates/numfmt/src/render.rs

@@ -230,31 +230,9 @@ fn digit_indices(toks: &[Tok], range: std::ops::Range<usize>) -> Vec<usize> {
     range.filter(|&i| matches!(toks.get(i), Some(Tok::Digit(_)))).collect()
 }
 
-/// Where a number section's placeholders are: the decimal point, the exponent, and the digit
-/// placeholders before the point (or exponent) and between the point and the exponent.
-struct NumberLayout {
-    point: Option<usize>,
-    exp: Option<usize>,
-    int_idx: Vec<usize>,
-    frac_idx: Vec<usize>,
-}
-
-fn number_layout(toks: &[Tok]) -> NumberLayout {
-    let n = toks.len();
-    let point = toks.iter().position(|t| matches!(t, Tok::Point));
-    let exp = toks.iter().position(|t| matches!(t, Tok::Exp { .. }));
-    let int_end = point.or(exp).unwrap_or(n);
-    let frac_end = exp.unwrap_or(n);
-    let int_idx = digit_indices(toks, 0..int_end);
-    let frac_idx = match point {
-        Some(p) => digit_indices(toks, p + 1..frac_end),
-        None => Vec::new(),
-    };
-    NumberLayout { point, exp, int_idx, frac_idx }
-}
-
-/// The number a section works on: each `%` multiplies by 100, each scaling comma divides by 1000.
-fn scaled(sec: &Section, mut x: f64) -> f64 {
+/// Renders a non-negative number through a number section.
+pub(crate) fn render_number(sec: &Section, v: f64) -> Out {
+    let mut x = v.abs();
     // Observed: `%` in a scientific section is only a literal (`#%e+#` shows 123456.789 as
     // `1%e+5`).
     if sec.percent > 0 && !sec.exp {
@@ -263,75 +241,6 @@ fn scaled(sec: &Section, mut x: f64) -> f64 {
     if sec.scale > 0 {
         x /= 1000f64.powi(sec.scale.min(110));
     }
-    x
-}
-
-/// Scientific notation of a non-negative `x` with `int_count` integer and `frac_count` fraction
-/// placeholders: the exponent (a multiple of the integer placeholder count, engineering style)
-/// and the mantissa's integer and fraction digits.
-fn scientific_parts(x: f64, int_count: usize, frac_count: usize) -> (i32, String, String) {
-    if x == 0.0 {
-        // Observed: zero shows `0` in every integer placeholder, `#` and `?` too
-        // (`#.#E+#` gives `0.E+0`, `####.####E+#` gives `0000.E+0`).
-        return (0, "0".repeat(int_count), "0".repeat(frac_count));
-    }
-    let step = int_count.max(1) as i32;
-    let (digits, xe) = decimal_digits(x);
-    let mut e = xe - xe.rem_euclid(step);
-    let (mut i, mut f) = fixed_from_digits(&digits, xe - e, frac_count);
-    if i.len() > step as usize {
-        e += step;
-        (i, f) = fixed_from_digits(&digits, xe - e, frac_count);
-    }
-    (e, i, f)
-}
-
-/// The number a number section shows for a non-negative `v`, as a value: what "Set precision as
-/// displayed" stores. `None` when the section shows no digits (`"x"`) or the result isn't finite.
-/// It uses the display's own rounding, so 1.005 with `0.00` gives 1.01, and 0.123456 with
-/// `0.00%` gives 0.1235 (the nearest double to the decimal shown).
-pub(crate) fn shown_value(sec: &Section, v: f64) -> Option<f64> {
-    if !sec.has_digits || !v.is_finite() {
-        return None;
-    }
-    let x = scaled(sec, v.abs());
-    if !x.is_finite() {
-        return None;
-    }
-    if x == 0.0 {
-        return Some(0.0);
-    }
-    // `%` and scaling are undone by moving the decimal point in the digits shown, so the result
-    // is the nearest double to that decimal rather than a product with its own rounding error.
-    let pct = if sec.exp { 0 } else { sec.percent.min(20) };
-    let shift = 3 * sec.scale.clamp(0, 110) - 2 * pct;
-    let shown = if sec.fraction {
-        let lay = fraction_layout(&sec.toks)?;
-        let (whole, num, den) = fraction_parts(&lay, x);
-        let den = den.max(1) as f64;
-        (whole * den + num) / den * 10f64.powi(shift)
-    } else {
-        let NumberLayout { exp, frac_idx, .. } = number_layout(&sec.toks);
-        let (e, int_s, frac_s) = match exp {
-            // Observed: the stored value keeps one digit plus the fraction digits, whatever the
-            // integer placeholders (`##0.0E+0` stores 123456.789 as 120000 though it shows
-            // `123.5E+3`; `###.00E+0` keeps three digits). A `%` in a scientific section stores a
-            // value that matches neither the display nor this rule: left as is.
-            Some(_) if sec.percent > 0 => return None,
-            Some(_) => scientific_parts(x, 1, frac_idx.len()),
-            None => {
-                let (i, f) = fixed(x, frac_idx.len());
-                (0, i, f)
-            }
-        };
-        format!("0{int_s}.{frac_s}0e{}", i64::from(e) + i64::from(shift)).parse::<f64>().ok()?
-    };
-    shown.is_finite().then_some(shown)
-}
-
-/// Renders a non-negative number through a number section.
-pub(crate) fn render_number(sec: &Section, v: f64) -> Out {
-    let mut x = scaled(sec, v.abs());
     if !x.is_finite() {
         x = f64::MAX;
     }
@@ -347,10 +256,32 @@ pub(crate) fn render_number(sec: &Section, v: f64) -> Out {
         lits = vec![None; n];
         render_fraction(sec, x, &mut pieces, &mut lits);
     } else {
-        let NumberLayout { point, exp, int_idx, frac_idx } = number_layout(toks);
+        let point = toks.iter().position(|t| matches!(t, Tok::Point));
+        let exp = toks.iter().position(|t| matches!(t, Tok::Exp { .. }));
+        let int_end = point.or(exp).unwrap_or(n);
+        let frac_end = exp.unwrap_or(n);
+        let int_idx = digit_indices(toks, 0..int_end);
+        let frac_idx = match point {
+            Some(p) => digit_indices(toks, p + 1..frac_end),
+            None => Vec::new(),
+        };
         let (int_s, frac_s) = if let Some(e_at) = exp {
             let exp_idx = digit_indices(toks, e_at + 1..n);
-            let (mut e, int_s, frac_s) = scientific_parts(x, int_idx.len(), frac_idx.len());
+            let step = int_idx.len().max(1) as i32;
+            let (mut e, int_s, frac_s) = if x == 0.0 {
+                // Observed: zero shows `0` in every integer placeholder, `#` and `?` too
+                // (`#.#E+#` gives `0.E+0`, `####.####E+#` gives `0000.E+0`).
+                (0i32, "0".repeat(int_idx.len()), "0".repeat(frac_idx.len()))
+            } else {
+                let (digits, xe) = decimal_digits(x);
+                let mut e = xe - xe.rem_euclid(step);
+                let (mut i, mut f) = fixed_from_digits(&digits, xe - e, frac_idx.len());
+                if i.len() > step as usize {
+                    e += step;
+                    (i, f) = fixed_from_digits(&digits, xe - e, frac_idx.len());
+                }
+                (e, i, f)
+            };
             // Exponent text.
             let (upper, plus) = match toks.get(e_at) {
                 Some(Tok::Exp { upper, plus }) => (*upper, *plus),
@@ -493,23 +424,19 @@ fn blank_range(toks: &[Tok], range: std::ops::Range<usize>, spaces: bool, pieces
     }
 }
 
-/// Where a fraction section's parts are (see [`render_fraction`]).
-struct FractionLayout {
-    slash: usize,
-    num_start: usize,
-    whole_idx: Vec<usize>,
-    num_idx: Vec<usize>,
-    sep_start: usize,
-    fixed_den: Option<u64>,
-    den_start: usize,
-    den_end: usize,
-    den_idx: Vec<usize>,
-}
-
-fn fraction_layout(toks: &[Tok]) -> Option<FractionLayout> {
+/// A fraction section is `[whole] [sep] num [lit] / [lit] den`: the numerator is the run of
+/// placeholders ending at the last one before the bar, the whole part is every placeholder
+/// before it (literals between them stay), `sep` the literals between the two parts.
+///
+/// Observed Excel behaviour: when the whole part shows no digit its separator disappears (or
+/// becomes spaces when the whole part or the numerator has a `?`); when the fraction is zero and
+/// the numerator has no `0` placeholder, the separator, numerator, bar and denominator disappear
+/// (or become spaces when any part has a `?`) and the whole part shows at least `0`.
+fn render_fraction(sec: &Section, x: f64, pieces: &mut [String], lits: &mut [Option<String>]) {
+    let toks = &sec.toks;
     let is_digit = |i: usize| matches!(toks.get(i), Some(Tok::Digit(_)));
-    let slash = toks.iter().position(|t| matches!(t, Tok::Slash))?;
-    let num_last = (0..slash).rev().find(|&i| is_digit(i))?;
+    let Some(slash) = toks.iter().position(|t| matches!(t, Tok::Slash)) else { return };
+    let Some(num_last) = (0..slash).rev().find(|&i| is_digit(i)) else { return };
     let mut num_start = num_last;
     while num_start > 0 && is_digit(num_start - 1) {
         num_start -= 1;
@@ -536,20 +463,16 @@ fn fraction_layout(toks: &[Tok]) -> Option<FractionLayout> {
         }
     }
     let den_idx = digit_indices(toks, den_start..den_end);
-    Some(FractionLayout { slash, num_start, whole_idx, num_idx, sep_start, fixed_den, den_start, den_end, den_idx })
-}
-
-/// The whole part, numerator and denominator a fraction section shows for a non-negative `x`.
-fn fraction_parts(lay: &FractionLayout, x: f64) -> (f64, f64, u64) {
-    let has_whole = !lay.whole_idx.is_empty();
+    let has_q = |idx: &[usize]| idx.iter().any(|&i| toks.get(i) == Some(&Tok::Digit('?')));
+    let has_whole = !whole_idx.is_empty();
     let (mut whole, f) = if has_whole { (x.floor(), x - x.floor()) } else { (0.0, x) };
     // Without a whole part the numerator carries the whole value and can pass u64::MAX, so it
     // stays an f64 (a float-to-u64 cast saturates).
-    let (mut num, den): (f64, u64) = match lay.fixed_den {
+    let (mut num, den): (f64, u64) = match fixed_den {
         Some(d) => ((f * d as f64).round(), d),
         None if f >= 1e15 => (f.round(), 1),
         None => {
-            let digits = lay.den_idx.len().clamp(1, 7) as u32;
+            let digits = den_idx.len().clamp(1, 7) as u32;
             let (n, d) = approximate(f, 10u64.pow(digits) - 1);
             (n as f64, d)
         }
@@ -560,24 +483,6 @@ fn fraction_parts(lay: &FractionLayout, x: f64) -> (f64, f64, u64) {
         whole += (n / den) as f64;
         num = (n % den) as f64;
     }
-    (whole, num, den)
-}
-
-/// A fraction section is `[whole] [sep] num [lit] / [lit] den`: the numerator is the run of
-/// placeholders ending at the last one before the bar, the whole part is every placeholder
-/// before it (literals between them stay), `sep` the literals between the two parts.
-///
-/// Observed Excel behaviour: when the whole part shows no digit its separator disappears (or
-/// becomes spaces when the whole part or the numerator has a `?`); when the fraction is zero and
-/// the numerator has no `0` placeholder, the separator, numerator, bar and denominator disappear
-/// (or become spaces when any part has a `?`) and the whole part shows at least `0`.
-fn render_fraction(sec: &Section, x: f64, pieces: &mut [String], lits: &mut [Option<String>]) {
-    let toks = &sec.toks;
-    let Some(lay) = fraction_layout(toks) else { return };
-    let (whole, num, den) = fraction_parts(&lay, x);
-    let FractionLayout { slash, num_start, whole_idx, num_idx, sep_start, fixed_den, den_start, den_end, den_idx } = lay;
-    let has_q = |idx: &[usize]| idx.iter().any(|&i| toks.get(i) == Some(&Tok::Digit('?')));
-    let has_whole = !whole_idx.is_empty();
     let whole_s = if whole >= 1.0 { fixed(whole, 0).0 } else { String::new() };
     let num_zero_ph = num_idx.iter().any(|&i| toks.get(i) == Some(&Tok::Digit('0')));
     if has_whole && num == 0.0 && !num_zero_ph {

crates/numfmt/src/tests.rs

@@ -901,120 +901,3 @@ fn closed_brackets_still_hold_their_semicolons() {
     assert_eq!(f("0\\[0", 5.0), "0[5");
     assert_eq!(f("\"[\"0;0", 5.0), "[5");
 }
-
-/// "Set precision as displayed": the value each format stores. Expected values observed in Excel
-/// (COM, `Workbook.PrecisionAsDisplayed = True`) with synthetic values.
-#[test]
-fn round_as_displayed_matches_excel() {
-    let r = |code: &str, n: f64| NumberFormat::parse(code).round_as_displayed(n);
-    let cases: &[(&str, f64, f64)] = &[
-        ("0", 527.91, 528.0),
-        ("0", 2.5, 3.0),
-        ("0", -2.5, -3.0),
-        ("0.00", 1.005, 1.01),
-        ("0.00", 1.23456, 1.23),
-        ("#.##", 1.23456, 1.23),
-        ("#.##", 1.2, 1.2),
-        ("?.??", 1.23456, 1.23),
-        ("0.0??", 1.23456, 1.235),
-        ("0%", 0.123456, 0.12),
-        ("0.0%", 0.123456, 0.123),
-        ("0.00%", 0.123456, 0.1235),
-        ("$#,##0.00", 1234.5678, 1234.57),
-        ("#,##0", 1234.5678, 1235.0),
-        ("0.0,,", 1234567.891, 1200000.0),
-        ("#,##0,", 1234567.891, 1235000.0),
-        ("0.0,", 1234567.891, 1234600.0),
-        ("# ?/?", 0.3333333, 1.0 / 3.0),
-        ("# ??/??", 0.3333333, 1.0 / 3.0),
-        ("# ?/8", 0.3, 0.25),
-        ("# ?/4", 2.71829, 2.75),
-        ("?/?", 0.123, 0.125),
-        ("0.00E+00", 123456.789, 123000.0),
-        ("##0.0E+0", 123456.789, 120000.0),
-        ("0.0E+0", 0.000123456, 0.00012),
-        ("##0.E+0", 98765.4, 100000.0),
-        ("###.00E+0", 98765.4, 98800.0),
-        ("000.0E+0", 0.0123456, 0.012),
-        ("0.00E+0\" u\"", 98765.4, 98800.0),
-        ("0.0%E+0", 12345.0, 12345.0),
-        ("0.00;(0.00)", -1.23456, -1.23),
-        ("0.00;(0.0)", -1.23456, -1.2),
-        ("0.0 \"kg\"", 1.23456, 1.2),
-        ("0.00;-0.00;\"zero\"", 0.001, 0.0),
-        ("0.00_);(0.00)", 1.23456, 1.23),
-        ("#,##0.0_);[Red](#,##0.0)", 2.345, 2.3),
-        // Kept at full precision.
-        ("General", 1.0 / 3.0, 1.0 / 3.0),
-        ("m/d/yyyy", 45000.75, 45000.75),
-        ("h:mm", 45000.123456, 45000.123456),
-        ("h:mm:ss", 45000.123456, 45000.123456),
-        ("[h]:mm", 1.2345678, 1.2345678),
-        ("mm:ss.0", 0.0001234567, 0.0001234567),
-        ("d", 45000.6, 45000.6),
-        ("@", 1.23456, 1.23456),
-        ("\"x\"", 1.23456, 1.23456),
-        (";;;", 1.23456, 1.23456),
-        // Conditions are ignored: the sign picks the section (first for positives, second for
-        // negatives), whatever section displays the number.
-        ("[<1]0.00;0", 1.0 / 3.0, 0.33),
-        ("[<1]0.00;0", 2.0 + 1.0 / 3.0, 2.33),
-        ("[<1]0.00;0", 12345.678, 12345.68),
-        ("[<1]0.00;0", -10.0 / 3.0, -3.0),
-        ("[<1]0.00;0", -1.0 / 3.0, 0.0),
-        ("[>1]0.0;0.000", 1.0 / 3.0, 0.3),
-        ("[>1]0.0;0.000", -10.0 / 3.0, -3.333),
-        ("[>=100]0;0.000", 2.0 + 1.0 / 3.0, 2.0),
-        ("[>=100]0;0.000", -200.0 - 1.0 / 3.0, -200.333),
-        ("[<0]0.0;0.000", -2.0 - 1.0 / 3.0, -2.333),
-        ("[>100]0;[<-100]0.0;0.000", -2.0 - 1.0 / 3.0, -2.3),
-        ("[<=-1]0.0;[>=1]0.000;0.00000", -2.0 - 1.0 / 3.0, -2.333),
-        ("0.0;[<-5]0.000", -2.0 - 1.0 / 3.0, -2.333),
-        ("[<1]0.00%;0", 2.0 + 1.0 / 3.0, 2.3333),
-        ("[<1]0.00;0.0,", -2345.6789, -2300.0),
-        ("[<1]0.0E+0;0", 1.0 / 3.0, 0.33),
-        ("[<1]# ?/?;0", 2.3, 16.0 / 7.0),
-        ("[<1]0.00;?/8", -2.0 - 1.0 / 3.0, -2.375),
-        ("[<1]0.00;0.0;0.000;@", -2.0 - 1.0 / 3.0, -2.3),
-        ("[<1]\"x\";0.0", 2.0 + 1.0 / 3.0, 2.0 + 1.0 / 3.0),
-        ("[<1]\"x\";0.0", -2.0 - 1.0 / 3.0, -2.3),
-        ("[<1]m/d/yyyy;0.0", 2.0 + 1.0 / 3.0, 2.0 + 1.0 / 3.0),
-        ("[<1]0.0;m/d/yyyy", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        // One section with a condition: negatives keep the full value, unless an `@` section
-        // follows (then the first section applies, as without a condition).
-        ("[<1]0.00", 2.0 + 1.0 / 3.0, 2.33),
-        ("[<1]0.00", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("[>=-100]0.0", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("[<1]0.00;@", -2.0 - 1.0 / 3.0, -2.33),
-        ("[<1]0.0%;@", -2.0 - 1.0 / 3.0, -2.333),
-        ("0.00;@", -2.0 - 1.0 / 3.0, -2.33),
-        // A completely empty section passes to the next; a colour or a literal doesn't.
-        ("0.0;;0.000", -2.0 - 1.0 / 3.0, -2.333),
-        ("[<1]0.0;;0.000", -2.0 - 1.0 / 3.0, -2.333),
-        ("[<1]0.0;;0.0%", -2.0 - 1.0 / 3.0, -2.333),
-        (";0.0", 2.0 + 1.0 / 3.0, 2.3),
-        (";;0.0", 2.0 + 1.0 / 3.0, 2.3),
-        (";;0.0", -2.0 - 1.0 / 3.0, -2.3),
-        ("0.0;;", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("0.0;;@", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("[<1]0.00;", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("0.0;[Red];0.000", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("[<1]0.0;\" \";0.000", -2.0 - 1.0 / 3.0, -2.0 - 1.0 / 3.0),
-        ("[<1];0.0;0.00", 2.0 + 1.0 / 3.0, 2.0 + 1.0 / 3.0),
-    ];
-    for &(code, n, want) in cases {
-        assert_eq!(r(code, n), want, "{code} with {n}");
-    }
-    // A negative that rounds to zero stores 0, not -0.
-    let z = r("0.00", -0.004);
-    assert!(z == 0.0 && z.is_sign_positive());
-    // Non-finite and extreme inputs come back unchanged or finite, never a panic.
-    assert!(r("0.00", f64::NAN).is_nan());
-    assert_eq!(r("0.00", f64::INFINITY), f64::INFINITY);
-    assert_eq!(r("0", 1e300 * 10.0), 1e301);
-    assert_eq!(r("0.0,,,,,,,,,,", 1.234e35), 1.234e35);
-    assert_eq!(r("0.000000000000000000000000000000", 1.0 / 3.0), 0.333333333333333);
-    assert_eq!(r("0%%%%%%%%%%%%%%%%%%%%%%%%", f64::MAX), f64::MAX);
-    assert_eq!(r("0", f64::MAX), f64::MAX);
-    assert_eq!(r("0.0E+0", f64::MIN_POSITIVE), 2.2e-308);
-}

crates/ui-egui/Cargo.toml

@@ -18,7 +18,6 @@ gridcraft-chart = { workspace = true }
 # this feature. The UI draws ✕, ◀, ↘ and 📋 as text; without these faces the strict kittest
 # harness (and a host with no symbol font) renders them as tofu.
 egui = { workspace = true, features = ["default_fonts", "monochrome_emoji_fonts"] }
-egui_extras = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }

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

@@ -302,7 +302,6 @@ impl SheetApp {
         // The requests belong to the window the command left active.
         self.follow_active_window();
         self.prune_selected_object();
-        self.prune_views();
         for req in self.session.take_ui_requests() {
             match req {
                 UiRequest::Dialog(name, params) => self.open_dialog(&name, params),
@@ -328,7 +327,7 @@ impl SheetApp {
     }
 
     /// Whether the active sheet of the active document is protected (drives the Protect/Unprotect
-    /// Sheet labels and actions). While a dialog with reference boxes is open, it is the dialog's
+    /// Sheet labels and actions). While a dialog's reference boxes have picked, it is the dialog's
     /// own sheet: Protect Sheet ends the pick and acts on that sheet, so the label says so too.
     pub fn active_sheet_protected(&self) -> bool {
         if let Some(protected) = self.dialog.as_ref().and_then(|d| d.home_sheet_protected(self)) {

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

@@ -7,8 +7,8 @@ impl SheetApp {
     }
 
     /// The active window and sheet: each window scrolls on its own.
-    fn scroll_key(&self) -> Option<(u64, u64)> {
-        Some((self.session.active_window()?, self.session.active()?.wb.active()?.uid.get()))
+    fn scroll_key(&self) -> Option<(u64, usize)> {
+        Some((self.session.active_window()?, self.session.active()?.wb.active_sheet()))
     }
 
     pub fn view(&self) -> SheetView {
@@ -41,10 +41,8 @@ impl SheetApp {
         let window = self.session.active_window();
         let Some(d) = self.session.active_mut() else { return };
         let mut tops = Vec::new();
-        for (si, sh) in d.wb.sheets.iter().enumerate() {
-            let Some(v) =
-                window.and_then(|w| self.views.get(&(w, sh.uid.get()))).filter(|_| sh.view == gridcraft_engine::model::SheetViewMode::Normal)
-            else {
+        for (&(w, si), v) in &self.views {
+            let Some(sh) = d.wb.sheets.get(si).filter(|sh| Some(w) == window && sh.view == gridcraft_engine::model::SheetViewMode::Normal) else {
                 continue;
             };
             let (fr, fc) = sh.freeze.unwrap_or((0, 0));
@@ -55,10 +53,4 @@ impl SheetApp {
         }
         d.store_view(&tops);
     }
-
-    /// Drops the scroll positions of windows that have closed: window ids are never reused.
-    pub(super) fn prune_views(&mut self) {
-        let session = &self.session;
-        self.views.retain(|&(w, _), _| session.window(w).is_some());
-    }
 }

crates/ui-egui/src/chartview.rs

@@ -1,5 +1,5 @@
 //! Floating objects on the sheet: charts (rendered by `gridcraft-chart` into primitives that
-//! we paint with egui), pictures, shapes, equations, slicers and form controls (`form_controls.rs`).
+//! we paint with egui), pictures, shapes, equations and slicers.
 
 use egui::epaint::{PathShape, PathStroke};
 use egui::{Align2, Color32, FontId, Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2};
@@ -381,18 +381,6 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo
         done(start, r);
     }
     paint_slicers(p, geo, wb, si, sh);
-    // Form controls sit above every other object.
-    let hover = p.ctx().input(|i| i.pointer.hover_pos()).map(|h| geo.mirror_pos(h)).filter(|h| geo.in_cells(*h));
-    for c in &sh.controls {
-        let r = anchor_rect(geo, sh, &c.anchor);
-        // A slider's value shows beside it while it is dragged.
-        if !r.expand(24.0).intersects(p.clip_rect()) {
-            continue;
-        }
-        let start = p.add(egui::Shape::Noop);
-        crate::form_controls::paint(p, r, c, geo.z, crate::form_controls::look(app, geo, c, r, hover));
-        done(start, r);
-    }
     // The selected object's frame and handles go over every object, and move with it on a
     // right-to-left sheet.
     if let Some(r) = app.selected_object.and_then(|o| object_rect(geo, sh, o))
@@ -535,19 +523,13 @@ pub fn selected_handle(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option
     crate::objects::handle_at(r, p).map(|h| (o, r, h))
 }
 
-/// The topmost object under `p` and its rect: form controls paint on top, so they are hit first,
-/// then slicers, charts, pictures and shapes (equations included), each from the top of its stack.
-/// Nothing is hit outside the cell area or while objects are hidden.
+/// The topmost object under `p` and its rect: slicers paint on top, so they are hit first, then
+/// charts, pictures and shapes (equations included), each from the top of its stack. Nothing is hit outside the cell
+/// area or while objects are hidden.
 pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Rect)> {
     if !geo.cells.contains(p) || app.session.active().is_some_and(|d| objects_hidden(&d.wb)) {
         return None;
     }
-    for c in sh.controls.iter().rev() {
-        let r = anchor_rect(geo, sh, &c.anchor);
-        if r.contains(p) {
-            return Some((ObjRef::new(ObjKind::Control, c.id), r));
-        }
-    }
     for sl in sh.slicers.iter().rev() {
         let r = anchor_rect(geo, sh, &sl.anchor);
         if r.contains(p) {
@@ -581,30 +563,3 @@ pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Re
 pub(crate) fn ink_color(line: Color32, width_pt: f32) -> Color32 {
     if width_pt > 8.0 { line.gamma_multiply(0.45) } else { line }
 }
-
-#[cfg(test)]
-mod tests {
-    use gridcraft_chart::Measure;
-
-    use super::*;
-
-    /// The production measure is not monotone for labels with a line break: egui lays the text out
-    /// line by line, so ending a prefix with `\n…` can be narrower than the shorter `iii…`. The
-    /// chart's label fitting must not assume otherwise (#1152).
-    #[test]
-    fn egui_measure_shrinks_when_a_prefix_ends_in_a_line_break() {
-        let ctx = egui::Context::default();
-        ctx.set_fonts(theme::pinned_font_definitions());
-        let mut checked = false;
-        // Fonts are ready from the second pass on.
-        for _ in 0..2 {
-            let mut out = ctx.run_ui(Default::default(), |ui| {
-                let m = EguiMeasure { painter: ui.painter(), z: 1.0 };
-                let (short, long) = (m.text_width("iii…", 11.0, false), m.text_width("iiii\n…", 11.0, false));
-                checked = long < short;
-            });
-            out.textures_delta.clear();
-        }
-        assert!(checked);
-    }
-}

crates/ui-egui/src/control_ui.rs

@@ -1,569 +0,0 @@
-//! Form controls in the window, apart from drawing them: placing a new control (draw it on the
-//! grid, or click for the default size), pressing a button and answering its questions, the
-//! control's context menu (Edit Text, Assign Action, Format Control, Delete), and the Assign
-//! Action and Format Control dialogs. Everything goes through the `insert.*` and `control.*`
-//! commands.
-
-use egui::{Pos2, Rect, Stroke, StrokeKind, Ui, vec2};
-use gridcraft_engine::core::CellRef;
-use gridcraft_engine::macros::policy::{Policy, macro_policy};
-use gridcraft_engine::model::{CONTROL_MAX, ControlAction, ControlKind, FormControl, MacroInput, ObjKind, ObjRef, Sheet};
-use serde_json::{Value as Json, json};
-
-use crate::SheetApp;
-use crate::dialogs::Dialog;
-use crate::grid::Geo;
-use crate::theme::Tokens;
-
-/// The control `id` on the active sheet.
-pub fn control(app: &SheetApp, id: u32) -> Option<FormControl> {
-    app.session.active()?.wb.active()?.controls.iter().find(|c| c.id == id).cloned()
-}
-
-/// Whether the control `id` on the active sheet is a button (its menu adds Edit Text and Assign
-/// Action).
-pub fn is_button(app: &SheetApp, id: u32) -> bool {
-    app.session.active().and_then(|d| d.wb.active()).is_some_and(|sh| sh.controls.iter().any(|c| c.id == id && c.kind == ControlKind::Button))
-}
-
-fn insert_id(kind: ControlKind) -> &'static str {
-    match kind {
-        ControlKind::Button => "insert.button",
-        ControlKind::Slider => "insert.slider",
-        ControlKind::Spin => "insert.spinButton",
-    }
-}
-
-/// The cell under a logical grid position and the offset into it, in sheet points.
-fn cell_point(geo: &Geo, sh: &Sheet, p: Pos2) -> (CellRef, f32, f32) {
-    let (col, row) = (geo.col_at(sh, p.x), geo.row_at(sh, p.y));
-    let dx = ((p.x - geo.x(sh, col)) / geo.z).max(0.0);
-    let dy = ((p.y - geo.y(sh, row)) / geo.z).max(0.0);
-    (CellRef::new(row, col), dx, dy)
-}
-
-/// Insert › Controls placement: while a kind is armed, a drag on the grid draws the control and a
-/// click places it at its default size. Escape disarms. True when it used the pointer.
-pub fn place(app: &mut SheetApp, ui: &Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet) -> bool {
-    let Some(kind) = app.grid.placing else {
-        app.grid.place_start = None;
-        return false;
-    };
-    let ctx = ui.ctx().clone();
-    if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
-        app.grid.placing = None;
-        app.grid.place_start = None;
-        return true;
-    }
-    let pointer = ctx.input(|i| i.pointer.clone());
-    // Logical positions (see `Geo::rtl`).
-    let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p));
-    if pos.is_some_and(|p| geo.in_cells(p)) {
-        ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
-    }
-    if pointer.primary_pressed()
-        && resp.contains_pointer()
-        && let Some(p) = pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos).filter(|p| geo.in_cells(*p))
-    {
-        app.grid.place_start = Some(p);
-    }
-    let Some(start) = app.grid.place_start else { return resp.contains_pointer() && pointer.any_down() };
-    let rect = Rect::from_two_pos(start, pos.unwrap_or(start));
-    if pointer.primary_down() {
-        let t = Tokens::get(&ctx);
-        ui.painter().rect_stroke(geo.mirror_rect(rect), 2.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Inside);
-        return true;
-    }
-    app.grid.place_start = None;
-    app.grid.placing = None;
-    let (cell, dx, dy) = cell_point(geo, sh, rect.min);
-    let mut params = json!({"at": cell.a1(), "dx": dx, "dy": dy});
-    // A drag sets the size (and a slider's orientation); a click keeps the default size.
-    if rect.width() >= 6.0 || rect.height() >= 6.0 {
-        params["width"] = json!((rect.width() / geo.z).max(8.0));
-        params["height"] = json!((rect.height() / geo.z).max(8.0));
-        if kind == ControlKind::Slider {
-            params["horizontal"] = json!(rect.width() >= rect.height());
-        }
-    }
-    match app.run(insert_id(kind), params) {
-        Ok(v) => {
-            if let Some(id) = v["control"].as_u64().and_then(|id| u32::try_from(id).ok()) {
-                app.selected_object = Some(ObjRef::new(ObjKind::Control, id));
-                // A new button asks what it should run, as Excel's Assign Macro does.
-                if kind == ControlKind::Button {
-                    app.open_dialog("assignAction", json!({"id": id}));
-                }
-            }
-        }
-        Err(e) => app.message = Some(("Insert Control".into(), crate::clean_error(&e))),
-    }
-    true
-}
-
-/// Opens a control's editor (double-click): a button's text, else Format Control.
-pub fn edit(app: &mut SheetApp, id: u32) {
-    match control(app, id).map(|c| c.kind) {
-        Some(ControlKind::Button) => app.open_dialog("formatControl", json!({"id": id, "textOnly": true})),
-        Some(_) => app.open_dialog("formatControl", json!({"id": id})),
-        None => {}
-    }
-}
-
-// ---------------------------------------------------------------- pressing a button
-
-/// The question in an `approve: …` error, if it is one.
-fn approve_text(e: &str) -> Option<String> {
-    let rest = e.split_once("approve: ")?.1;
-    Some(rest.split_once(" (run again with").map_or(rest, |(q, _)| q).to_string())
-}
-
-/// The question in a `confirm: …` error, if it is one.
-fn confirm_text(e: &str) -> Option<String> {
-    let rest = e.split_once("confirm: ")?.1;
-    Some(rest.split_once(" (run again with").map_or(rest, |(q, _)| q).to_string())
-}
-
-/// What a press of the button `params` names would run, as text: the workbook, the sheet, the
-/// button, its action, the content of the macro it runs, and the selection (a macro on the
-/// selection, or a command without a range, works there). `None` when the active sheet has no
-/// such button. A question is answered only while this is unchanged, so an answer never applies
-/// to an action other than the one it asked about.
-fn press_binding(app: &SheetApp, params: &Json) -> Option<String> {
-    let id = params.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok())?;
-    let d = app.session.active()?;
-    let sheet = d.wb.active_sheet();
-    let sh = d.wb.sheet(sheet)?;
-    let c = sh.controls.iter().find(|c| c.id == id && c.kind == ControlKind::Button)?;
-    let mac = match &c.action {
-        Some(ControlAction::Macro { name, .. }) => {
-            gridcraft_engine::macros::find(&d.wb, name).and_then(|i| d.wb.macros.get(i)).map(gridcraft_engine::macros::fingerprint)
-        }
-        _ => None,
-    };
-    Some(
-        json!({
-            "doc": d.uid,
-            "sheet": sheet,
-            "sheetName": sh.name,
-            "control": id,
-            "action": c.action,
-            "macro": mac,
-            "selection": d.selection,
-        })
-        .to_string(),
-    )
-}
-
-/// Presses a button (`control.press` with `params`). A question (approve the action, or make
-/// room for a macro's output) opens a prompt whose buttons press it again with the answer, bound
-/// to what the question was about (see [`press_binding`]); any other error shows in a message
-/// box.
-pub fn press(app: &mut SheetApp, params: Json) {
-    let bound = press_binding(app, &params);
-    let Err(e) = app.run("control.press", params.clone()) else { return };
-    let (text, choices) = if let Some(q) = approve_text(&e) {
-        (q, json!([["Run", {"approve": true}]]))
-    } else if let Some(q) = confirm_text(&e) {
-        let what = q.split_once(" Overwrite them").map_or(q.as_str(), |(a, _)| a).trim_end_matches(['.', ' ']).to_string();
-        (
-            format!("{what}. Overwrite them, or move the data out of the way?"),
-            json!([["Overwrite", {"onConflict": "overwrite"}], ["Shift Down", {"onConflict": "shiftDown"}], ["Shift Right", {"onConflict": "shiftRight"}]]),
-        )
-    } else {
-        app.message = Some(("Button".into(), crate::clean_error(&e)));
-        return;
-    };
-    app.open_dialog("controlQuestion", json!({"text": text, "params": params, "choices": choices, "bound": bound}));
-}
-
-pub fn open_question(params: &Json) -> Option<Dialog> {
-    let text = params.get("text").and_then(Json::as_str)?;
-    let v = json!({
-        "text": text,
-        "params": params.get("params").cloned().unwrap_or_else(|| json!({})),
-        "choices": params.get("choices").cloned().unwrap_or_else(|| json!([])),
-        "bound": params.get("bound").and_then(Json::as_str),
-    });
-    Some(Dialog::custom("controlQuestion", "Button", v))
-}
-
-/// The prompt [`press`] opens: the question, a button per answer, and Cancel.
-pub fn question_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &mut bool) {
-    ui.label(val(d, "text"));
-    ui.add_space(8.0);
-    let choices: Vec<(String, Json)> = d
-        .values
-        .get("choices")
-        .and_then(Json::as_array)
-        .map(|a| a.iter().filter_map(|c| Some((c.get(0)?.as_str()?.to_string(), c.get(1)?.clone()))).collect())
-        .unwrap_or_default();
-    let mut answer = None;
-    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-        if ui.button(" Cancel ").clicked() {
-            *open = false;
-        }
-        for (label, extra) in choices.iter().rev() {
-            if ui.button(format!(" {label} ")).clicked() {
-                answer = Some(extra.clone());
-            }
-        }
-    });
-    if let Some(extra) = answer {
-        *open = false;
-        let mut params = d.values.get("params").cloned().unwrap_or_else(|| json!({}));
-        // The answer is for the action the question named: if the workbook, the sheet, the
-        // button, its action, its macro or the selection changed meanwhile (an agent reassigned
-        // it), nothing runs, and the next press asks about what it runs now.
-        let asked = d.values.get("bound").and_then(Json::as_str);
-        let now = press_binding(app, &params);
-        if asked.is_none() || asked != now.as_deref() {
-            let why = if now.is_none() {
-                "The button is gone, so nothing ran."
-            } else {
-                "The button changed while the question was open, so nothing ran. Press it again to see what it runs now."
-            };
-            app.message = Some(("Button".into(), why.into()));
-            return;
-        }
-        if let (Some(p), Some(x)) = (params.as_object_mut(), extra.as_object()) {
-            for (k, v) in x {
-                p.insert(k.clone(), v.clone());
-            }
-        }
-        press(app, params);
-    }
-}
-
-// ---------------------------------------------------------------- Assign Action
-
-fn val(d: &Dialog, key: &str) -> String {
-    d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string()
-}
-
-/// The workbook's macros: (name, description).
-fn macros(app: &SheetApp) -> Vec<(String, String)> {
-    app.session.active().map(|d| d.wb.macros.iter().map(|m| (m.name.clone(), m.description.clone())).collect()).unwrap_or_default()
-}
-
-/// Assign Action: a macro (on the selection or a fixed range, with an optional output cell) or a
-/// command with its parameters.
-pub fn open_assign(app: &SheetApp, params: &Json) -> Option<Dialog> {
-    let id = params.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok())?;
-    let c = control(app, id)?;
-    let mut v =
-        json!({"id": id, "mode": "macro", "macro": "", "input": "selection", "range": "", "output": "", "command": "", "params": "{}", "search": ""});
-    match &c.action {
-        Some(ControlAction::Macro { name, input, output }) => {
-            v["macro"] = json!(name);
-            if let MacroInput::Fixed(r) = input {
-                v["input"] = json!("fixed");
-                v["range"] = json!(r);
-            }
-            v["output"] = json!(output.clone().unwrap_or_default());
-        }
-        Some(ControlAction::Command { id, params }) => {
-            v["mode"] = json!("command");
-            v["command"] = json!(id);
-            v["params"] = json!(serde_json::to_string_pretty(params).unwrap_or_else(|_| "{}".into()));
-        }
-        None => {
-            // A new button suggests the workbook's first macro.
-            v["macro"] = json!(macros(app).first().map(|m| m.0.clone()).unwrap_or_default());
-        }
-    }
-    Some(Dialog::custom("assignAction", &format!("Assign Action: {}", c.display_name()), v))
-}
-
-/// The `control.assign` params the dialog describes, or why it can't yet.
-pub fn assign_params(d: &Dialog) -> Result<Json, String> {
-    let id = d.values.get("id").cloned().unwrap_or(Json::Null);
-    if val(d, "mode") == "command" {
-        let command = val(d, "command");
-        if command.trim().is_empty() {
-            return Err("Choose a command.".into());
-        }
-        let text = val(d, "params");
-        let params: Json = if text.trim().is_empty() {
-            json!({})
-        } else {
-            serde_json::from_str(&text).map_err(|e| format!("The parameters aren't valid JSON: {e}"))?
-        };
-        if !params.is_object() {
-            return Err("The parameters must be a JSON object, such as {\"range\": \"A1:B2\"}.".into());
-        }
-        return Ok(json!({"id": id, "command": command.trim(), "params": params}));
-    }
-    let name = val(d, "macro");
-    if name.trim().is_empty() {
-        return Err("Type or choose a macro name.".into());
-    }
-    let input = if val(d, "input") == "fixed" { val(d, "range") } else { "selection".into() };
-    if input.trim().is_empty() {
-        return Err("Type the range the macro always runs on.".into());
-    }
-    Ok(json!({"id": id, "macro": name.trim(), "input": input.trim(), "output": val(d, "output").trim()}))
-}
-
-/// Commands a button may run whose id or label contains `search` (every one when it is empty):
-/// (id, label). File commands are left out: the ones a button may run only produce bytes.
-fn command_choices(search: &str) -> Vec<(&'static str, &'static str)> {
-    let q = search.trim().to_lowercase();
-    gridcraft_engine::command_specs()
-        .iter()
-        .filter(|c| c.journal && !c.id.starts_with("file."))
-        .filter(|c| !matches!(macro_policy(c.id, &json!({}), gridcraft_engine::Trust::Local), Policy::Deny(_)))
-        .filter(|c| q.is_empty() || c.id.to_lowercase().contains(&q) || c.label.to_lowercase().contains(&q))
-        .map(|c| (c.id, c.label))
-        .take(200)
-        .collect()
-}
-
-fn text_field(ui: &mut Ui, d: &mut Dialog, key: &str, width: f32) {
-    let mut s = val(d, key);
-    ui.add(egui::TextEdit::singleline(&mut s).desired_width(width).id_salt(("control_dialog", key.to_string())));
-    d.values.insert(key.into(), json!(s));
-}
-
-pub fn assign_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &mut bool) {
-    let t = Tokens::get(ui.ctx());
-    let mut mode = val(d, "mode");
-    ui.horizontal(|ui| {
-        ui.radio_value(&mut mode, "macro".to_string(), "Run a macro");
-        ui.radio_value(&mut mode, "command".to_string(), "Run a command");
-    });
-    d.values.insert("mode".into(), json!(mode));
-    ui.add_space(4.0);
-    if mode == "macro" {
-        let macros = macros(app);
-        let mut name = val(d, "macro");
-        ui.label("Macro name:");
-        ui.add(egui::TextEdit::singleline(&mut name).desired_width(f32::INFINITY).id_salt("assign_macro"));
-        egui::Frame::NONE.fill(t.input_bg).stroke(Stroke::new(1.0, t.input_border)).inner_margin(2.0).show(ui, |ui| {
-            ui.set_min_size(vec2(ui.available_width(), 110.0));
-            egui::ScrollArea::vertical().max_height(110.0).show(ui, |ui| {
-                if macros.is_empty() {
-                    ui.label(egui::RichText::new("This workbook has no macros yet.").italics().color(t.text_dim));
-                }
-                for (n, desc) in &macros {
-                    let r =
-                        ui.add(egui::Button::selectable(n.eq_ignore_ascii_case(name.trim()), n.as_str()).min_size(vec2(ui.available_width(), 20.0)));
-                    let r = if desc.is_empty() { r } else { r.on_hover_text(desc) };
-                    if r.clicked() {
-                        name = n.clone();
-                    }
-                }
-            });
-        });
-        d.values.insert("macro".into(), json!(name));
-        ui.add_space(4.0);
-        let mut input = val(d, "input");
-        ui.label("Run it on:");
-        ui.radio_value(&mut input, "selection".to_string(), "The selection when the button is pressed");
-        ui.horizontal(|ui| {
-            ui.radio_value(&mut input, "fixed".to_string(), "Always this range:");
-            if input == "fixed" {
-                text_field(ui, d, "range", 160.0);
-            }
-        });
-        d.values.insert("input".into(), json!(input));
-        ui.horizontal(|ui| {
-            ui.label("Output to (optional):");
-            text_field(ui, d, "output", 120.0);
-        });
-    } else {
-        let mut search = val(d, "search");
-        let command = val(d, "command");
-        ui.label("Command:");
-        ui.add(egui::TextEdit::singleline(&mut search).hint_text("Search commands").desired_width(f32::INFINITY).id_salt("assign_search"));
-        egui::Frame::NONE.fill(t.input_bg).stroke(Stroke::new(1.0, t.input_border)).inner_margin(2.0).show(ui, |ui| {
-            ui.set_min_size(vec2(ui.available_width(), 130.0));
-            egui::ScrollArea::vertical().max_height(130.0).show(ui, |ui| {
-                for (cid, label) in command_choices(&search) {
-                    let text = format!("{label}  ({cid})");
-                    if ui.add(egui::Button::selectable(cid == command, text).min_size(vec2(ui.available_width(), 20.0))).clicked() {
-                        d.values.insert("command".into(), json!(cid));
-                    }
-                }
-            });
-        });
-        d.values.insert("search".into(), json!(search));
-        let doc = gridcraft_engine::find_command(val(d, "command").trim()).map(|c| c.params).unwrap_or("");
-        if !doc.is_empty() {
-            ui.label(egui::RichText::new(doc).small().color(t.text_dim));
-        }
-        ui.label("Parameters (JSON):");
-        let mut params = val(d, "params");
-        ui.add(egui::TextEdit::multiline(&mut params).code_editor().desired_rows(3).desired_width(f32::INFINITY).id_salt("assign_params"));
-        d.values.insert("params".into(), json!(params));
-    }
-    let problem = assign_params(d).err();
-    if let Some(p) = &problem {
-        ui.label(egui::RichText::new(p).color(t.danger));
-    }
-    let (ok, cancel) = ok_cancel(ui, problem.is_none());
-    if cancel || (ok && assign(app, d)) {
-        *open = false;
-    }
-}
-
-/// OK (offered while `enabled`) and Cancel at the bottom right, as the other dialogs place them:
-/// (OK clicked, Cancel clicked).
-fn ok_cancel(ui: &mut Ui, enabled: bool) -> (bool, bool) {
-    let (mut ok, mut cancel) = (false, false);
-    ui.add_space(8.0);
-    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-        let t = Tokens::get(ui.ctx());
-        ok = ui.add_enabled(enabled, egui::Button::new(egui::RichText::new("   OK   ").color(t.on_accent)).fill(t.accent)).clicked();
-        cancel = ui.button(" Cancel ").clicked();
-    });
-    (ok, cancel)
-}
-
-/// Runs `control.assign` from the dialog. False (with the error shown) when it failed.
-fn assign(app: &mut SheetApp, d: &Dialog) -> bool {
-    let result = assign_params(d).and_then(|params| app.run("control.assign", params).map_err(|e| crate::clean_error(&e)));
-    match result {
-        Ok(_) => true,
-        Err(e) => {
-            app.message = Some(("Assign Action".into(), e));
-            false
-        }
-    }
-}
-
-// ---------------------------------------------------------------- Format Control
-
-/// Format Control: a slider's or spin button's cell link, value and limits (orientation and page
-/// change for sliders); a button's text. `textOnly` shows just the text (Edit Text).
-pub fn open_format(app: &SheetApp, params: &Json) -> Option<Dialog> {
-    let id = params.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok())?;
-    let c = control(app, id)?;
-    let text_only = params.get("textOnly").and_then(Json::as_bool) == Some(true) && c.kind == ControlKind::Button;
-    let v = json!({
-        "id": id,
-        "textOnly": text_only,
-        "text": c.text,
-        "name": c.name,
-        "value": c.value.to_string(),
-        "min": c.min.to_string(),
-        "max": c.max.to_string(),
-        "step": c.step.to_string(),
-        "page": c.page.to_string(),
-        "link": c.link.clone().unwrap_or_default(),
-        "horizontal": c.horizontal,
-        "print": c.print,
-        "locked": c.locked,
-    });
-    let title = if text_only { "Edit Text".to_string() } else { format!("Format Control: {}", c.display_name()) };
-    Some(Dialog::custom("formatControl", &title, v))
-}
-
-fn whole(text: &str) -> Option<u32> {
-    text.trim().parse::<u32>().ok().filter(|v| *v <= CONTROL_MAX)
-}
-
-/// The `control.format` params the dialog describes, or the first problem with them (the same
-/// rules the engine checks, so OK is only offered when it will work).
-pub fn format_params(app: &SheetApp, d: &Dialog) -> Result<Json, String> {
-    let id = d.values.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok()).ok_or("The control is gone.")?;
-    let c = control(app, id).ok_or("The control is gone.")?;
-    let flag = |k: &str| d.values.get(k).and_then(Json::as_bool).unwrap_or(false);
-    if d.values.get("textOnly").and_then(Json::as_bool) == Some(true) {
-        return Ok(json!({"id": id, "text": val(d, "text")}));
-    }
-    let mut out = json!({"id": id, "name": val(d, "name"), "print": flag("print"), "locked": flag("locked")});
-    if c.kind == ControlKind::Button {
-        out["text"] = json!(val(d, "text"));
-        return Ok(out);
-    }
-    let mut draft = c.clone();
-    for (key, label, slot) in [
-        ("min", "Minimum value", &mut draft.min),
-        ("max", "Maximum value", &mut draft.max),
-        ("step", "Incremental change", &mut draft.step),
-        ("page", "Page change", &mut draft.page),
-    ] {
-        if key == "page" && c.kind != ControlKind::Slider {
-            continue;
-        }
-        *slot = whole(&val(d, key)).ok_or_else(|| format!("{label} must be a whole number from 0 to {CONTROL_MAX}."))?;
-        out[key] = json!(*slot);
-    }
-    draft.check_numbers()?;
-    let value = whole(&val(d, "value")).ok_or_else(|| format!("Current value must be a whole number from 0 to {CONTROL_MAX}."))?;
-    if value < draft.min || value > draft.max {
-        return Err(format!("Current value must be between {} and {}.", draft.min, draft.max));
-    }
-    out["value"] = json!(value);
-    out["link"] = json!(val(d, "link").trim());
-    if c.kind == ControlKind::Slider {
-        out["horizontal"] = json!(flag("horizontal"));
-    }
-    Ok(out)
-}
-
-pub fn format_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &mut bool) {
-    let t = Tokens::get(ui.ctx());
-    let Some(c) = d.values.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok()).and_then(|id| control(app, id)) else {
-        *open = false;
-        return;
-    };
-    let text_only = d.values.get("textOnly").and_then(Json::as_bool) == Some(true);
-    if c.kind == ControlKind::Button {
-        let mut text = val(d, "text");
-        ui.label("Text:");
-        ui.add(egui::TextEdit::multiline(&mut text).desired_rows(2).desired_width(f32::INFINITY).id_salt("control_text"));
-        d.values.insert("text".into(), json!(text));
-    } else {
-        egui::Grid::new("format_control_grid").num_columns(2).spacing([12.0, 6.0]).show(ui, |ui| {
-            let mut fields = vec![("value", "Current value:"), ("min", "Minimum value:"), ("max", "Maximum value:"), ("step", "Incremental change:")];
-            if c.kind == ControlKind::Slider {
-                fields.push(("page", "Page change:"));
-            }
-            fields.push(("link", "Cell link:"));
-            for (key, label) in fields {
-                ui.label(label);
-                text_field(ui, d, key, if key == "link" { 160.0 } else { 90.0 });
-                ui.end_row();
-            }
-        });
-        if c.kind == ControlKind::Slider {
-            let mut h = d.values.get("horizontal").and_then(Json::as_bool).unwrap_or(true);
-            ui.horizontal(|ui| {
-                ui.label("Orientation:");
-                ui.radio_value(&mut h, true, "Horizontal");
-                ui.radio_value(&mut h, false, "Vertical");
-            });
-            d.values.insert("horizontal".into(), json!(h));
-        }
-    }
-    if !text_only {
-        ui.add_space(4.0);
-        ui.horizontal(|ui| {
-            ui.label("Name:");
-            let mut name = val(d, "name");
-            ui.add(egui::TextEdit::singleline(&mut name).hint_text(c.display_name()).desired_width(200.0).id_salt("control_name"));
-            d.values.insert("name".into(), json!(name));
-        });
-        for (key, label) in [("locked", "Locked (when the sheet is protected)"), ("print", "Print object")] {
-            let mut on = d.values.get(key).and_then(Json::as_bool).unwrap_or(true);
-            ui.checkbox(&mut on, label);
-            d.values.insert(key.into(), json!(on));
-        }
-    }
-    let params = format_params(app, d);
-    if let Err(p) = &params {
-        ui.label(egui::RichText::new(p).color(t.danger));
-    }
-    let (ok, cancel) = ok_cancel(ui, params.is_ok());
-    if cancel {
-        *open = false;
-    }
-    if ok && let Ok(p) = params {
-        match app.run("control.format", p) {
-            Ok(_) => *open = false,
-            Err(e) => app.message = Some(("Format Control".into(), crate::clean_error(&e))),
-        }
-    }
-}

crates/ui-egui/src/credits.rs

@@ -244,17 +244,12 @@ pub fn contributors_ui(ui: &mut egui::Ui) {
     let list = sorted(CONTRIBUTORS, v.names, v.key, v.ascending);
     ui.label(RichText::new(format!("{} contributors · {} commits", list.len(), group(TOTAL_COMMITS))).small().weak());
     ui.separator();
-    if list.is_empty() {
-        ui.label("No contributor data was built into this copy.");
-    } else if v.table {
-        // The table scrolls vertically itself, under a fixed header; it only scrolls sideways
-        // once its columns are dragged wider than the dialog.
-        ui.allocate_ui(egui::vec2(ui.available_width(), 340.0), |ui| {
-            ui.set_max_height(340.0);
-            egui::ScrollArea::horizontal().auto_shrink([false, false]).show(ui, |ui| table(ui, &list, &mut v));
-        });
-    } else {
-        egui::ScrollArea::vertical().auto_shrink([false, false]).max_height(340.0).show(ui, |ui| {
+    egui::ScrollArea::both().auto_shrink([false, false]).max_height(340.0).show(ui, |ui| {
+        if list.is_empty() {
+            ui.label("No contributor data was built into this copy.");
+        } else if v.table {
+            table(ui, &list, &mut v);
+        } else {
             ui.horizontal_wrapped(|ui| {
                 for (i, c) in list.iter().enumerate() {
                     if i > 0 {
@@ -263,153 +258,39 @@ pub fn contributors_ui(ui: &mut egui::Ui) {
                     ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary());
                 }
             });
-        });
-    }
+        }
+    });
     ui.data_mut(|d| d.insert_temp(id, v));
 }
 
-/// How the contributor table's spare width is shared out: all of it to Name.
-const CONTRIBUTOR_GROW: [f32; 10] = [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
-
-/// How the model table's spare width is shared out: to Company and Model, the text columns.
-const MODEL_GROW: [f32; 6] = [1.0, 2.0, 0.0, 0.0, 0.0, 0.0];
-
-/// The narrowest a column can be dragged.
-const MIN_COLUMN: f32 = 28.0;
-
-/// The width a column needs for its header and its widest cell.
-fn natural(ui: &egui::Ui, header: RichText, cells: impl Iterator<Item = String>) -> f32 {
-    let measure = |text: egui::WidgetText| text.into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, egui::TextStyle::Body).size().x;
-    let widest = cells.map(|c| measure(c.into())).fold(measure(header.into()), f32::max);
-    widest + 2.0 * ui.spacing().button_padding.x
-}
-
-/// Opening column widths: each column's natural width, with the spare room shared out by `grow`,
-/// so the columns fill `room` exactly. When there is too little room, only the growing columns
-/// give way, each in proportion to its width above [`MIN_COLUMN`], and none goes below that.
-fn fit_widths(natural: &[f32], grow: &[f32], room: f32) -> Vec<f32> {
-    let spare = room - natural.iter().sum::<f32>();
-    let weight = grow.iter().sum::<f32>();
-    let slack = |w: f32| (w - MIN_COLUMN).max(0.0);
-    let flexible: f32 = natural.iter().zip(grow).filter(|(_, g)| **g > 0.0).map(|(w, _)| slack(*w)).sum();
-    natural
-        .iter()
-        .zip(grow)
-        .map(|(w, g)| {
-            if *g > 0.0 && spare >= 0.0 {
-                w + spare * g / weight
-            } else if *g > 0.0 && flexible > 0.0 {
-                w - (-spare).min(flexible) * slack(*w) / flexible
-            } else {
-                *w
-            }
-        })
-        .collect()
-}
-
-/// A striped table whose columns open at [`fit_widths`], so it fills the width and nothing scrolls
-/// sideways. Every column, the last included, can be dragged wider or narrower at its right edge:
-/// only a table dragged wider than the window scrolls sideways. Text too long for its column is
-/// clipped. When a column's natural width or the window changes, the columns go back to a new fit,
-/// dropping any dragged widths.
-fn fitted_table<'a>(ui: &'a mut egui::Ui, id: &str, natural: &[f32], grow: &[f32]) -> egui_extras::TableBuilder<'a> {
-    // Every cell is followed by the item gap, and the vertical scrollbar keeps its margins.
-    let s = ui.spacing();
-    let gaps = s.item_spacing.x * natural.len() as f32;
-    let bar = s.scroll.bar_width + s.scroll.bar_inner_margin + s.scroll.bar_outer_margin;
-    let widths = fit_widths(natural, grow, (ui.available_width() - gaps - bar).max(0.0));
-    // The table keeps its own column widths, so a change in what they were fitted to has to clear
-    // them. A longer name can leave the fit itself unchanged, and scrolling can nudge the available
-    // width, so this compares the natural widths and the clip rect, which scrolling never moves.
-    let fit = egui::Id::unique(("credits_fit", id));
-    let measured = (natural.to_vec(), ui.clip_rect().width());
-    let refit = ui.data_mut(|d| d.get_temp::<(Vec<f32>, f32)>(fit)).as_ref() != Some(&measured);
-    ui.data_mut(|d| d.insert_temp(fit, measured));
-    let mut t =
-        egui_extras::TableBuilder::new(ui).id_salt(id).striped(true).resizable(true).auto_shrink([false, false]).max_scroll_height(f32::INFINITY);
-    if refit {
-        t.reset();
-    }
-    for w in widths {
-        t = t.column(egui_extras::Column::initial(w).at_least(MIN_COLUMN).clip(true));
-    }
-    t
-}
-
-/// Add a cell's widget right-aligned (counts, dates) or left-aligned (names), vertically centred.
-fn aligned<R>(ui: &mut egui::Ui, right: bool, add: impl FnOnce(&mut egui::Ui) -> R) -> R {
-    let layout = if right { egui::Layout::right_to_left(egui::Align::Center) } else { egui::Layout::left_to_right(egui::Align::Center) };
-    ui.with_layout(layout, add).inner
-}
-
-fn row_height(ui: &egui::Ui) -> f32 {
-    ui.text_style_height(&egui::TextStyle::Body) + 6.0
-}
-
-/// One contributor's table cells after the name, in `SortKey::ALL` order.
-fn cells(c: &Contributor) -> [String; 9] {
-    [
-        group(c.prs),
-        group(c.commits),
-        group(c.lines_added),
-        group(c.lines_deleted),
-        signed(c.lines_delta()),
-        group(c.binary_added),
-        group(c.binary_deleted),
-        day(c.first_commit).to_string(),
-        day(c.last_commit).to_string(),
-    ]
-}
-
-/// A contributor-table header. The sorted column is highlighted; its direction shows on the
-/// toolbar's sort-order button, so no arrow widens the column.
-fn header_text(k: SortKey) -> RichText {
-    RichText::new(k.label().1).strong()
-}
-
 fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) {
-    let h = row_height(ui);
-    let rows: Vec<[String; 9]> = list.iter().map(|c| cells(c)).collect();
-    let widths: Vec<f32> = SortKey::ALL
-        .iter()
-        .enumerate()
-        .map(|(i, &k)| match i.checked_sub(1) {
-            None => natural(ui, header_text(k), list.iter().map(|c| c.name(v.names))),
-            Some(col) => natural(ui, header_text(k), rows.iter().filter_map(|r| r.get(col).cloned())),
-        })
-        .collect();
-    fitted_table(ui, "credits_table", &widths, &CONTRIBUTOR_GROW)
-        .header(h + 4.0, |mut header| {
-            for k in SortKey::ALL {
-                header.col(|ui| {
-                    let r = aligned(ui, k != SortKey::Name, |ui| ui.selectable_label(v.key == k, header_text(k))).on_hover_text(k.label().0);
-
-                    if r.clicked() {
-                        if v.key == k {
-                            v.ascending = !v.ascending;
-                        } else {
-                            v.key = k;
-                            v.ascending = k.default_ascending();
-                        }
-                    }
-                });
+    egui::Grid::new("credits_table").striped(true).num_columns(SortKey::ALL.len()).show(ui, |ui| {
+        for k in SortKey::ALL {
+            let arrow = if v.key == k { if v.ascending { " ▲" } else { " ▼" } } else { "" };
+            if ui.button(RichText::new(format!("{}{arrow}", k.label().1)).strong()).on_hover_text(k.label().0).clicked() {
+                if v.key == k {
+                    v.ascending = !v.ascending;
+                } else {
+                    v.key = k;
+                    v.ascending = k.default_ascending();
+                }
             }
-        })
-        .body(|mut body| {
-            for (c, cells) in list.iter().zip(rows) {
-                body.row(h, |mut row| {
-                    row.col(|ui| {
-                        aligned(ui, false, |ui| ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)))
-                            .on_hover_text(c.summary());
-                    });
-                    for text in cells {
-                        row.col(|ui| {
-                            aligned(ui, true, |ui| ui.label(text));
-                        });
-                    }
-                });
-            }
-        });
+        }
+        ui.end_row();
+        for c in list {
+            ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary());
+            ui.label(group(c.prs));
+            ui.label(group(c.commits));
+            ui.label(group(c.lines_added));
+            ui.label(group(c.lines_deleted));
+            ui.label(signed(c.lines_delta()));
+            ui.label(group(c.binary_added));
+            ui.label(group(c.binary_deleted));
+            ui.label(day(c.first_commit));
+            ui.label(day(c.last_commit));
+            ui.end_row();
+        }
+    });
 }
 
 /// About ▸ Models: AI models credited in Co-Authored-By trailers.
@@ -419,50 +300,21 @@ pub fn models_ui(ui: &mut egui::Ui) {
         return;
     }
     let assisted: u64 = MODELS.iter().map(|m| m.commits).max().unwrap_or(0).max(1);
-    let h = row_height(ui);
-    let titles = ["Company", "Model", "Version", "Commits", "% of all commits", "Lines +/−"];
-    // Company, Model and Version read as text; the counts line up on the right.
-    let right = [false, false, false, true, true, true];
-    let rows: Vec<[String; 6]> = MODELS
-        .iter()
-        .map(|m| {
-            [
-                m.company.to_string(),
-                m.model.to_string(),
-                m.version.to_string(),
-                group(m.commits),
-                format!("{:.0}%", 100.0 * m.commits as f64 / TOTAL_COMMITS.max(assisted) as f64),
-                format!("+{} / −{}", group(m.lines_added), group(m.lines_deleted)),
-            ]
-        })
-        .collect();
-    let widths: Vec<f32> = titles
-        .iter()
-        .enumerate()
-        .map(|(i, title)| natural(ui, RichText::new(*title).strong(), rows.iter().filter_map(|r| r.get(i).cloned())))
-        .collect();
-    ui.allocate_ui(egui::vec2(ui.available_width(), 340.0), |ui| {
-        ui.set_max_height(340.0);
-        egui::ScrollArea::horizontal().id_salt("credits_models").auto_shrink([false, false]).show(ui, |ui| {
-            fitted_table(ui, "credits_models", &widths, &MODEL_GROW)
-                .header(h + 4.0, |mut header| {
-                    for (title, r) in titles.into_iter().zip(right) {
-                        header.col(|ui| {
-                            aligned(ui, r, |ui| ui.label(RichText::new(title).strong()));
-                        });
-                    }
-                })
-                .body(|mut body| {
-                    for cells in rows {
-                        body.row(h, |mut row| {
-                            for (text, r) in cells.into_iter().zip(right) {
-                                row.col(|ui| {
-                                    aligned(ui, r, |ui| ui.label(text));
-                                });
-                            }
-                        });
-                    }
-                });
+    egui::ScrollArea::both().auto_shrink([false, false]).max_height(340.0).show(ui, |ui| {
+        egui::Grid::new("credits_models").striped(true).num_columns(6).show(ui, |ui| {
+            for h in ["Company", "Model", "Version", "Commits", "% of all commits", "Lines +/−"] {
+                ui.label(RichText::new(h).strong());
+            }
+            ui.end_row();
+            for m in MODELS {
+                ui.label(m.company);
+                ui.label(m.model);
+                ui.label(m.version);
+                ui.label(group(m.commits));
+                ui.label(format!("{:.0}%", 100.0 * m.commits as f64 / TOTAL_COMMITS.max(assisted) as f64));
+                ui.label(format!("+{} / −{}", group(m.lines_added), group(m.lines_deleted)));
+                ui.end_row();
+            }
         });
     });
 }
@@ -543,131 +395,4 @@ mod tests {
         assert_eq!(day("2026-10-07T18:45:23Z"), "2026-10-07");
         assert_eq!(day(""), "—");
     }
-
-    #[test]
-    fn columns_fill_the_room_and_spare_width_goes_to_growing_columns() {
-        assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 0.0, 0.0], 300.0), [200.0, 40.0, 60.0]);
-        assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 2.0, 0.0], 230.0), [110.0, 60.0, 60.0]);
-        let w = fit_widths(&[123.0, 45.5, 67.25], &[1.0, 0.0, 2.0], 512.0);
-        assert!((w.iter().sum::<f32>() - 512.0).abs() < 0.01, "a fitted table neither scrolls nor leaves a gap: {w:?}");
-    }
-
-    #[test]
-    fn too_little_room_shrinks_only_growing_columns() {
-        assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 0.0, 0.0], 150.0), [50.0, 40.0, 60.0]);
-        assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 0.0, 0.0], 0.0), [MIN_COLUMN, 40.0, 60.0]);
-        assert_eq!(fit_widths(&[100.0, 40.0], &[0.0, 0.0], 50.0), [100.0, 40.0]);
-    }
-
-    #[test]
-    fn a_column_at_the_minimum_leaves_the_shortfall_to_the_others() {
-        let w = fit_widths(&[100.0, 300.0, 50.0], &[1.0, 1.0, 0.0], 140.0);
-        assert!((w.iter().sum::<f32>() - 140.0).abs() < 0.01, "the columns still fit the room: {w:?}");
-        assert!(w.iter().all(|c| *c >= MIN_COLUMN), "no column goes below the minimum: {w:?}");
-        assert_eq!(fit_widths(&[100.0, 300.0, 50.0], &[1.0, 1.0, 0.0], 0.0), [MIN_COLUMN, MIN_COLUMN, 50.0]);
-    }
-
-    const WINDOW: f32 = 640.5;
-    const NATURAL: [f32; 3] = [120.0, 80.0, 80.0];
-    const GROW: [f32; 3] = [1.0, 0.0, 0.0];
-
-    /// One frame of a table long enough to scroll; the rects of its header cells.
-    fn table_frame(ctx: &egui::Context, width: f32, natural: &[f32], events: Vec<egui::Event>) -> Vec<egui::Rect> {
-        scrolled_frame(ctx, width, natural, 0.0, events)
-    }
-
-    /// [`table_frame`], scrolled `offset` points sideways.
-    fn scrolled_frame(ctx: &egui::Context, width: f32, natural: &[f32], offset: f32, events: Vec<egui::Event>) -> Vec<egui::Rect> {
-        let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 300.0)));
-        let raw = egui::RawInput { screen_rect, events, ..Default::default() };
-        let mut cells = Vec::new();
-        let out = ctx.run_ui(raw, |ui| {
-            cells.clear();
-            egui::ScrollArea::horizontal().auto_shrink([false, false]).horizontal_scroll_offset(offset).show(ui, |ui| {
-                fitted_table(ui, "test", natural, &GROW)
-                    .header(20.0, |mut header| {
-                        for _ in natural {
-                            header.col(|ui| cells.push(ui.max_rect()));
-                        }
-                    })
-                    .body(|mut body| {
-                        for _ in 0..40 {
-                            body.row(20.0, |mut row| {
-                                for _ in natural {
-                                    row.col(|ui| {
-                                        ui.label("x");
-                                    });
-                                }
-                            });
-                        }
-                    });
-            });
-        });
-        out.drop_without_applying_deltas();
-        cells
-    }
-
-    /// A new context with the table open and settled, and the rects of its header cells.
-    fn opened_table() -> (egui::Context, Vec<egui::Rect>) {
-        let ctx = egui::Context::default();
-        table_frame(&ctx, WINDOW, &NATURAL, Vec::new());
-        let cells = table_frame(&ctx, WINDOW, &NATURAL, Vec::new());
-        (ctx, cells)
-    }
-
-    /// Drags a column's right edge, which runs midway through the gap after `cell`, then lets go.
-    fn drag_edge(ctx: &egui::Context, cell: egui::Rect, by: f32) {
-        use egui::{Event, Modifiers, PointerButton};
-        let start = egui::pos2(cell.right() + 4.0, cell.center().y);
-        let halfway = start + egui::vec2(by / 2.0, 0.0);
-        let end = start + egui::vec2(by, 0.0);
-        let moved = Event::PointerMoved;
-        let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
-        for event in [moved(start), button(start, true), moved(halfway), moved(end), button(end, false)] {
-            table_frame(ctx, WINDOW, &NATURAL, vec![event]);
-        }
-    }
-
-    #[test]
-    fn every_column_can_be_dragged_at_its_right_edge_and_stays_there() {
-        let (_, opened) = opened_table();
-        for (dragged, cell) in opened.iter().enumerate() {
-            let (ctx, _) = opened_table();
-            drag_edge(&ctx, *cell, -30.0);
-            table_frame(&ctx, WINDOW, &NATURAL, Vec::new());
-            let after = table_frame(&ctx, WINDOW, &NATURAL, Vec::new());
-            for (column, (was, now)) in opened.iter().zip(&after).enumerate() {
-                let want = if column == dragged { was.width() - 30.0 } else { was.width() };
-                assert!((now.width() - want).abs() < 1.0, "dragging column {dragged}: column {column} is {now:?}, was {was:?}");
-            }
-        }
-    }
-
-    #[test]
-    fn a_changed_fit_replaces_the_column_widths() {
-        let (ctx, opened) = opened_table();
-        drag_edge(&ctx, opened[0], -30.0);
-        let longer_name = table_frame(&ctx, WINDOW, &[200.0, 80.0, 80.0], Vec::new());
-        assert!((longer_name[0].width() - opened[0].width()).abs() < 1.0, "a longer name drops a dragged width: {longer_name:?}");
-        let wider = table_frame(&ctx, WINDOW, &[120.0, 200.0, 80.0], Vec::new());
-        let widths: Vec<f32> = wider.iter().map(|c| c.width().round()).collect();
-        assert!(widths.ends_with(&[200.0, 80.0]), "a longer cell widens its column: {widths:?}");
-        assert!(wider[2].right() < WINDOW, "the table still fits the window: {wider:?}");
-        let narrower = table_frame(&ctx, 400.0, &NATURAL, Vec::new());
-        assert!(narrower[2].right() < 400.0, "a narrower window refits the table: {narrower:?}");
-    }
-
-    #[test]
-    fn scrolling_sideways_keeps_dragged_widths() {
-        let (ctx, opened) = opened_table();
-        drag_edge(&ctx, opened[0], 100.0);
-        table_frame(&ctx, WINDOW, &NATURAL, Vec::new());
-        let dragged = table_frame(&ctx, WINDOW, &NATURAL, Vec::new());
-        assert!((dragged[0].width() - opened[0].width() - 100.0).abs() < 1.0, "the drag took: {dragged:?}");
-        for offset in [13.3, 27.77, 41.1, 0.6] {
-            scrolled_frame(&ctx, WINDOW, &NATURAL, offset, Vec::new());
-            let scrolled = scrolled_frame(&ctx, WINDOW, &NATURAL, offset, Vec::new());
-            assert!((scrolled[0].width() - dragged[0].width()).abs() < 1.0, "scrolled {offset}: {scrolled:?}");
-        }
-    }
 }

crates/ui-egui/src/dialogs.rs

@@ -157,31 +157,19 @@ impl Dialog {
         ref_edit::end_pick(app, self)
     }
 
-    /// Whether the dialog's own sheet is protected, for a dialog with reference boxes and while
+    /// Whether the dialog's own sheet is protected, once its reference boxes have picked and while
     /// that sheet exists (the sheet [`Self::end_pick`] shows again); `None` otherwise.
     pub(crate) fn home_sheet_protected(&self, app: &SheetApp) -> Option<bool> {
         ref_edit::home_sheet_protected(app, self)
     }
 
-    /// Whether the sheet a dialog with reference boxes was opened on was deleted while it was
-    /// open: OK is then refused with [`SHEET_DELETED`], since references without a sheet name
-    /// have nothing to refer to.
+    /// Whether the sheet the dialog was opened on was deleted while its reference boxes picked:
+    /// OK is then refused with [`SHEET_DELETED`], since references without a sheet name have
+    /// nothing to refer to.
     pub(crate) fn home_sheet_deleted(&mut self, app: &SheetApp) -> bool {
         ref_edit::home_sheet_deleted(app, self)
     }
 
-    /// A press on the grid that selects cells: the reference box being picked into takes the
-    /// selection on this frame even when it is unchanged (a click on the cell already selected).
-    pub(crate) fn note_selecting_press(&mut self) {
-        ref_edit::note_selecting_press(self);
-    }
-
-    /// Whether a reference box is the one grid selections fill: a click on the grid is then a
-    /// pick, and a second click on the same cell does not edit the cell.
-    pub(crate) fn ref_box_picks(&self) -> bool {
-        ref_edit::picks(self)
-    }
-
     /// Whether a click on the grid goes to a formula box of this dialog rather than the selection.
     pub fn picks_references(&self) -> bool {
         self.pick.is_some()
@@ -278,7 +266,7 @@ impl Dialog {
         let active = app.session.active().map(|d| d.selection.active.a1()).unwrap_or_default();
         let p = |k: &str| params.get(k).cloned().unwrap_or(Json::Null);
         use Field::*;
-        let mut d = match name {
+        let d = match name {
             "insertCells" => Dialog::form(
                 "insertCells",
                 "Insert",
@@ -1107,9 +1095,6 @@ impl Dialog {
                 dialog
             }
             "pickList" => Dialog::custom("pickList", "Pick From List", json!({})),
-            "assignAction" => return crate::control_ui::open_assign(app, &params),
-            "formatControl" => return crate::control_ui::open_format(app, &params),
-            "controlQuestion" => return crate::control_ui::open_question(&params),
             "saveCopy" => Dialog::custom("saveCopy", "Save a Copy", json!({"format": p("format")})),
             "saveChanges" => Dialog::custom("saveChanges", "Save Changes?", json!({"title": p("title"), "quit": p("quit")})),
             "start" => Dialog::custom("start", "GridCraft", json!({})),
@@ -1131,7 +1116,6 @@ impl Dialog {
             }
             _ => return None,
         };
-        ref_edit::record_home(app, &mut d);
         Some(d)
     }
 }

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

@@ -1,4 +1,4 @@
-use super::ref_edit::{RefLabel, SHEET_DELETED, current_area_ref, end_pick, home_sheet_deleted, ref_edit};
+use super::ref_edit::{RefLabel, SHEET_DELETED, end_pick, home_sheet_deleted, ref_edit};
 use super::show::{build_params, form_fields, ok_cancel};
 use super::{Dialog, Field, Json, Map, SheetApp, json, vec2};
 
@@ -261,9 +261,7 @@ pub(super) fn analysis_toolpak(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Di
         ok_cancel(ui, &mut ok, open);
         let pick = d.values.get("pick").and_then(Json::as_str).unwrap_or("").to_string();
         if (ok || chosen) && TOOLS.iter().any(|(id, _)| *id == pick) {
-            // The selection becomes the input range, with its sheet's name when another sheet
-            // than the dialog's own is shown.
-            let sel = current_area_ref(app, d);
+            let sel = app.session.active().map(|doc| doc.selection.current().a1()).unwrap_or_default();
             d.values = toolpak_defaults(&sel, &pick);
         }
         return;

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

@@ -218,11 +218,8 @@ pub(super) fn sort(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confir
             if columns.is_empty() {
                 ui.add(egui::TextEdit::singleline(&mut col).desired_width(50.0)).labelled_by(label.id);
             } else {
-                // The closed box shows the same "B: Revenue" label as the list, not the bare letter (#3446).
-                let shown =
-                    columns.iter().find(|(letter, _)| letter.eq_ignore_ascii_case(&col)).map_or_else(|| col.clone(), |(_, label)| label.clone());
                 craft_ui::ComboBox::from_id_salt(("sort_col", i))
-                    .selected_text(shown)
+                    .selected_text(col.clone())
                     .show_ui(ui, |ui| {
                         for (letter, label) in &columns {
                             ui.selectable_value(&mut col, letter.clone(), label.as_str());

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

@@ -1,12 +1,10 @@
 //! Reference boxes (Excel's RefEdit): text fields that take a range by selection on the grid, with
 //! a button that collapses the dialog to the box while the person selects.
 
-use gridcraft_engine::DocState;
-use gridcraft_engine::core::split_areas;
 use gridcraft_engine::model::{Sheet, SheetUid, Workbook};
 
 use super::data::abs;
-use super::{Dialog, Field, Icon, Json, SheetApp, json, theme, vec2};
+use super::{Dialog, Icon, Json, SheetApp, json, theme, vec2};
 
 /// What a dialog's reference boxes are doing: which one grid selections fill, and whether the
 /// dialog is collapsed to one of them.
@@ -20,17 +18,12 @@ pub(super) struct RefBoxes {
     /// The sheet shown when `seen` was taken: changing sheets only refreshes `seen`, since the
     /// other sheet's own selection is not a pick.
     seen_sheet: String,
-    /// The dialog's own sheet, from the moment the dialog opens until it closes, and the
-    /// selection to put back when it runs its command or closes.
+    /// The dialog's own sheet, from the first pick until the dialog closes, and the selection to
+    /// put back when it runs its command or closes.
     home: Option<Home>,
     /// The target took a selection from the grid and takes the keyboard back once the pointer
     /// is released, so typing still edits the box.
     refocus: bool,
-    /// A press on the grid selected this frame ([`note_selecting_press`]): the target takes the
-    /// selection even when it is the one it last saw, since clicking the cell already selected
-    /// is a pick too. Cleared when a box starts picking and once the frame's boxes are drawn, so
-    /// only a press made while the box picks counts.
-    pressed: bool,
     /// The target box was drawn this frame. A box the dialog stops showing (another view of the
     /// dialog, a hidden area, a constraint operator that takes no value) is no longer picked
     /// into, so a selection made meanwhile does not land in it once it is shown again (see
@@ -50,9 +43,9 @@ pub(super) struct RefBoxes {
     other_field: bool,
 }
 
-/// The dialog's own sheet: the sheet shown when the dialog opened ([`record_home`]), kept for as
-/// long as the dialog is open (a failed OK leaves it open, and a later OK still needs to know
-/// whether that sheet is there), and the selection on it to put back once picking ends.
+/// Where picking began: the dialog's own sheet, kept for as long as the dialog is open (a failed
+/// OK leaves it open, and a later OK still needs to know whether that sheet is there), and the
+/// selection to put back once.
 #[derive(Clone, Debug)]
 struct Home {
     /// The sheet's identity while the app runs ([`SheetUid`]): fresh for every sheet added,
@@ -61,59 +54,18 @@ struct Home {
     /// copy of it is never taken for it, and an undo that brings it back makes it the dialog's
     /// again.
     uid: SheetUid,
-    /// The ranges and active cell on the dialog's sheet from before picking began, taken when a
-    /// box starts picking (from the sheet's kept selection when another sheet is shown then), and
-    /// put back once when the dialog runs its command or closes.
+    /// The ranges and active cell from before picking began on the dialog's sheet, put back once
+    /// when the dialog runs its command or closes.
     selection: Option<(String, String)>,
 }
 
-/// Whether the dialog has reference boxes: Goal Seek, Solver, Data Analysis, and any form with a
-/// [`Field::Ref`].
-fn has_reference_boxes(d: &Dialog) -> bool {
-    matches!(d.name.as_str(), "goalSeek" | "solver" | "analysisToolPak") || d.fields.iter().any(|f| matches!(f, Field::Ref { .. }))
-}
-
-/// Records the sheet shown as the dialog's own when a dialog with reference boxes opens, from the
-/// ribbon or the control channel alike. A sheet shown later, before any box picks, is not the
-/// dialog's: references without a sheet name still mean the sheet the dialog was opened on,
-/// whose defaults (the active cell, the selection) the boxes start with.
-pub(super) fn record_home(app: &SheetApp, d: &mut Dialog) {
-    if !has_reference_boxes(d) {
-        return;
-    }
-    if let Some(sheet) = app.session.active().and_then(|doc| doc.wb.active()) {
-        d.refs.home = Some(Home { uid: sheet.uid, selection: None });
-    }
-}
-
-/// The selection on the dialog's own sheet as (ranges, active cell): the one shown while that
-/// sheet is active, else the one the sheet keeps for when it is shown again. `None` once the
-/// sheet is deleted.
-fn home_selection(doc: &DocState, home: &Home) -> Option<(String, String)> {
-    let i = doc.wb.sheets.iter().position(|s| s.uid.get() == home.uid.get())?;
-    let sel = if i == doc.wb.active_sheet() { &doc.selection } else { doc.sheet_selections.get(i)? };
-    let ranges: Vec<String> = sel.ranges.iter().map(|r| r.a1()).collect();
-    Some((ranges.join(","), sel.active.a1()))
-}
-
-/// The grid's current area (the one being selected) as a reference for a dialog of `d`'s: with
-/// the sheet name when it is on another sheet than the dialog's own, as a reference box writes it.
-pub(super) fn current_area_ref(app: &SheetApp, d: &Dialog) -> String {
-    let Some(doc) = app.session.active() else { return String::new() };
-    let area = doc.selection.current().a1();
-    match (doc.wb.active(), d.refs.home.as_ref()) {
-        (Some(sh), Some(home)) if home.uid.get() != sh.uid.get() => format!("{}!{area}", gridcraft_engine::formula::quote_sheet(&sh.name)),
-        _ => area,
-    }
-}
-
 /// The dialog's own sheet in `wb`, or `None` once it was deleted.
 fn home_sheet<'a>(wb: &'a Workbook, home: &Home) -> Option<&'a Sheet> {
     wb.sheets.iter().map(|s| &**s).find(|s| s.uid.get() == home.uid.get())
 }
 
-/// Whether the dialog's own sheet is protected, for a dialog with reference boxes and while that
-/// sheet exists: the sheet [`end_pick`] shows again. `None` otherwise.
+/// Whether the dialog's own sheet is protected, once its reference boxes have picked and while
+/// that sheet exists: the sheet [`end_pick`] shows again. `None` otherwise.
 pub(super) fn home_sheet_protected(app: &SheetApp, d: &Dialog) -> Option<bool> {
     let home = d.refs.home.as_ref()?;
     app.session.active().and_then(|doc| home_sheet(&doc.wb, home)).map(Sheet::is_protected)
@@ -123,9 +75,8 @@ pub(super) fn home_sheet_protected(app: &SheetApp, d: &Dialog) -> Option<bool> {
 pub(crate) const SHEET_DELETED: &str =
     "The sheet this dialog was opened on was deleted. Cancel, then open the dialog again on the sheet it should use.";
 
-/// Whether the sheet a dialog with reference boxes was opened on has been deleted while it was
-/// open: its references without a sheet name have nothing to refer to, so OK is refused with
-/// [`SHEET_DELETED`].
+/// Whether the sheet the dialog was opened on has been deleted while it picked: its references
+/// without a sheet name have nothing to refer to, so OK is refused with [`SHEET_DELETED`].
 pub(super) fn home_sheet_deleted(app: &SheetApp, d: &mut Dialog) -> bool {
     d.refs.home.as_ref().is_some_and(|h| app.session.active().is_none_or(|doc| home_sheet(&doc.wb, h).is_none()))
 }
@@ -265,8 +216,6 @@ pub(super) fn window_shown(ctx: &egui::Context, d: &mut Dialog, collapsed: bool,
         d.refs.rect = rect;
     }
     d.refs.was_collapsed = collapsed;
-    // A press the boxes did not take this frame (none was picking) is not kept for a later one.
-    d.refs.pressed = false;
     d.refs.other_field = d.refs.collapsed.as_deref().is_some_and(|key| other_field_focused(ctx, key));
     // The box compares the grid selection with the one it last saw only while it is drawn: a
     // hidden box would take a selection made meanwhile when it comes back.
@@ -278,33 +227,26 @@ pub(super) fn window_shown(ctx: &egui::Context, d: &mut Dialog, collapsed: bool,
     }
 }
 
-/// Records a press on the grid that selects (see [`RefBoxes::pressed`]).
-pub(super) fn note_selecting_press(d: &mut Dialog) {
-    d.refs.pressed = true;
-}
-
-/// Whether a reference box is being picked into (see [`Dialog::ref_box_picks`]).
-pub(super) fn picks(d: &Dialog) -> bool {
-    d.refs.target.is_some()
-}
-
-/// Makes the reference box `key` the one grid selections fill. The first pick (and the first
-/// after an OK that failed) remembers the selection on the dialog's own sheet, which is put back
-/// when the dialog runs its command or closes. A dialog opened without [`record_home`] takes the
-/// sheet shown at its first pick as its own.
+/// Makes the reference box `key` the one grid selections fill. The first pick remembers the
+/// sheet and selection, which are put back when the dialog runs its command or closes.
 pub(super) fn begin_pick(app: &SheetApp, d: &mut Dialog, key: &str) {
     if let Some(doc) = app.session.active()
         && let Some(sheet) = doc.wb.active()
     {
-        let home = d.refs.home.get_or_insert(Home { uid: sheet.uid, selection: None });
-        if home.selection.is_none() {
-            home.selection = home_selection(doc, home);
+        let ranges: Vec<String> = doc.selection.ranges.iter().map(|r| r.a1()).collect();
+        let selection = Some((ranges.join(","), doc.selection.active.a1()));
+        match d.refs.home.as_mut() {
+            None => d.refs.home = Some(Home { uid: sheet.uid, selection }),
+            // Picking again after a failed OK: the selection to put back is the one now on the
+            // dialog's sheet.
+            Some(home) if home.selection.is_none() && home.uid.get() == sheet.uid.get() => {
+                home.selection = selection;
+            }
+            Some(_) => {}
         }
     }
     d.refs.target = Some(key.to_string());
     d.refs.refocus = false;
-    // Focusing the box keeps its text: only a press after this one picks.
-    d.refs.pressed = false;
     d.refs.seen = selection_ref(app, d.refs.home.as_ref(), takes_several_areas(&d.name, key));
     d.refs.seen_sheet = active_sheet_name(app);
 }
@@ -363,17 +305,14 @@ pub(super) fn ref_edit(app: &SheetApp, ui: &mut egui::Ui, d: &mut Dialog, key: &
         } else if d.refs.target.as_deref() == Some(key) {
             let sel = selection_ref(app, d.refs.home.as_ref(), takes_several_areas(&d.name, key));
             let sheet = active_sheet_name(app);
-            let pressed = std::mem::take(&mut d.refs.pressed);
-            if sheet != d.refs.seen_sheet && !pressed {
+            if sheet != d.refs.seen_sheet {
                 // Another sheet was shown: its selection is where that sheet was left, not a pick.
                 d.refs.seen = sel;
                 d.refs.seen_sheet = sheet;
-            } else if pressed || sel != d.refs.seen {
-                // The person selected on the grid, even the cell already selected: the selection
-                // becomes the reference.
+            } else if sel != d.refs.seen {
+                // The person selected on the grid: the selection becomes the reference.
                 s = sel.clone();
                 d.refs.seen = sel;
-                d.refs.seen_sheet = sheet;
                 d.refs.refocus = true;
             }
             if d.refs.refocus && !ui.input(|i| i.pointer.any_down()) {
@@ -437,6 +376,27 @@ fn anchors(part: &str) -> Option<Anchors> {
     Some(Anchors { letters, digits, col_abs, row_abs })
 }
 
+/// The areas of a reference list, split at the commas between them. A comma inside a quoted
+/// sheet name (`'Sales, West'!A1`) is part of the name, and a doubled quote inside the quotes
+/// (`'O''Brien, Jr'!A1`) is an escaped quote, not the end of the name: a quote toggles the
+/// quoted state, so a doubled one toggles it twice.
+fn split_areas(reference: &str) -> Vec<&str> {
+    let mut areas = Vec::new();
+    let (mut start, mut quoted) = (0, false);
+    for (i, c) in reference.char_indices() {
+        match c {
+            '\'' => quoted = !quoted,
+            ',' if !quoted => {
+                areas.push(reference.get(start..i).unwrap_or_default());
+                start = i.saturating_add(1);
+            }
+            _ => {}
+        }
+    }
+    areas.push(reference.get(start..).unwrap_or_default());
+    areas
+}
+
 /// Excel's F4 in a reference box: `A1` → `$A$1` → `A$1` → `$A1` → `A1`, every part of every
 /// area moving together from the first part's anchors (`A1:B2,D4` → `$A$1:$B$2,$D$4`), sheet
 /// names kept; whole columns and rows have one anchor each (`A:A` → `$A:$A` → `A:A`). Text that
@@ -482,7 +442,16 @@ pub(crate) fn cycle_anchors(reference: &str) -> String {
 
 #[cfg(test)]
 mod tests {
-    use super::cycle_anchors;
+    use super::{cycle_anchors, split_areas};
+
+    #[test]
+    fn areas_split_only_at_commas_outside_quoted_sheet_names() {
+        assert_eq!(split_areas("B2:B4,D1"), ["B2:B4", "D1"]);
+        assert_eq!(split_areas("'Sales, West'!$A$1"), ["'Sales, West'!$A$1"]);
+        assert_eq!(split_areas("'O''Brien, Jr'!A1:B2,D4"), ["'O''Brien, Jr'!A1:B2", "D4"]);
+        assert_eq!(split_areas("'Q1, Q2'!A1,'Q3, Q4'!B2"), ["'Q1, Q2'!A1", "'Q3, Q4'!B2"]);
+        assert_eq!(split_areas(""), [""]);
+    }
 
     #[test]
     fn f4_keeps_a_comma_inside_a_quoted_sheet_name() {

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

@@ -148,13 +148,12 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
     let mut confirm = false;
     let width = match d.name.as_str() {
         "formatCells" => 560.0,
-        "about" => 820.0,
+        "about" => 660.0,
         "insertFunction" | "commandSearch" | "nameManager" | "manageRules" | "journal" | "agents" | "equation" => 520.0,
         "macros" => 480.0,
         "recommendedCharts" => 600.0,
         "analysisToolPak" => 420.0,
         "solver" => 460.0,
-        "assignAction" => 440.0,
         "zoom" => 220.0,
         "pasteSpecial" => 480.0,
         _ => 380.0,
@@ -204,9 +203,6 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) {
                 "solver" => solver(app, ui, &mut d, &mut confirm, &mut open),
                 "solverResults" => solver_results(app, ui, &mut d, &mut open),
                 "spelling" => spelling(app, ui, &mut d, &mut open),
-                "assignAction" => crate::control_ui::assign_dialog(app, ui, &mut d, &mut open),
-                "formatControl" => crate::control_ui::format_dialog(app, ui, &mut d, &mut open),
-                "controlQuestion" => crate::control_ui::question_dialog(app, ui, &mut d, &mut open),
                 "agents" => {
                     ui.label("GridCraft is fully drivable by agents. Every menu item, button and gesture is a command:");
                     ui.add_space(4.0);

crates/ui-egui/src/form_controls.rs

@@ -1,463 +0,0 @@
-//! Form controls on the sheet: drawing buttons, sliders and spin buttons, and working them with
-//! the pointer and the keyboard. A click operates a control; Ctrl or Cmd+click, or a right-click,
-//! selects it instead (to move, resize or format it). Values change through `control.setValue`,
-//! and a whole drag or a held arrow is one undo step.
-//!
-//! Positions are logical (see `Geo::rtl`): on a right-to-left sheet a control moves as a whole
-//! but is not mirrored, so a point inside it is reflected back with [`inner`] first.
-
-use egui::epaint::PathShape;
-use egui::{Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2};
-use gridcraft_engine::model::{ControlKind, FormControl, ObjKind, ObjRef, Sheet};
-use serde_json::json;
-
-use crate::SheetApp;
-use crate::grid::Geo;
-use crate::theme::{self, Tokens};
-
-/// How long an arrow or the track waits before it repeats, and then between repeats (seconds).
-const REPEAT_DELAY: f64 = 0.4;
-const REPEAT_EVERY: f64 = 0.06;
-
-/// The part of a control under the pointer.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Part {
-    Button,
-    /// A spin button's arrow that adds a step.
-    Up,
-    /// A spin button's arrow that takes a step away.
-    Down,
-    Thumb,
-    /// The track on the minimum's side of the thumb (a page down).
-    TrackBefore,
-    /// The track on the maximum's side of the thumb (a page up).
-    TrackAfter,
-}
-
-/// A control being worked with the pointer.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Gesture {
-    pub id: u32,
-    pub part: Part,
-    /// Thumb drags: where along the track the pointer grabbed the thumb, from its centre.
-    pub grab: f32,
-    /// The undo stack's length when the gesture began: everything it changes is one step.
-    pub undo_start: usize,
-    /// When a held arrow or track repeats next (egui time, seconds).
-    pub next_repeat: f64,
-}
-
-/// What a control looks like this frame.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct Look {
-    pub hover: Option<Part>,
-    pub pressed: Option<Part>,
-    pub focused: bool,
-    /// Show the value next to the thumb (while dragging).
-    pub show_value: bool,
-}
-
-fn fraction(c: &FormControl) -> f32 {
-    let span = c.max.saturating_sub(c.min).max(1) as f32;
-    (c.value.saturating_sub(c.min) as f32 / span).clamp(0.0, 1.0)
-}
-
-/// A slider's track and thumb in `r`. A horizontal slider has its minimum on the left; a vertical
-/// one has it at the top (as Excel's scroll bars do).
-pub fn slider_parts(r: Rect, c: &FormControl, z: f32) -> (Rect, Rect) {
-    let f = fraction(c);
-    if c.horizontal {
-        let knob = (r.height() - 4.0 * z).clamp(6.0 * z, 16.0 * z).min(r.width() / 2.0).max(1.0);
-        let track = Rect::from_center_size(r.center(), vec2((r.width() - knob).max(1.0), (4.0 * z).min(r.height())));
-        let x = track.left() + f * track.width();
-        (track, Rect::from_center_size(pos2(x, r.center().y), vec2(knob, (r.height() - 4.0 * z).max(4.0))))
-    } else {
-        let knob = (r.width() - 4.0 * z).clamp(6.0 * z, 16.0 * z).min(r.height() / 2.0).max(1.0);
-        let track = Rect::from_center_size(r.center(), vec2((4.0 * z).min(r.width()), (r.height() - knob).max(1.0)));
-        let y = track.top() + f * track.height();
-        (track, Rect::from_center_size(pos2(r.center().x, y), vec2((r.width() - 4.0 * z).max(4.0), knob)))
-    }
-}
-
-/// A spin button's halves: (the arrow that adds, the arrow that subtracts). Tall spin buttons
-/// stack them (up on top); wide ones put them side by side (up on the right).
-pub fn spin_parts(r: Rect) -> (Rect, Rect) {
-    if r.height() >= r.width() {
-        let (top, bottom) = r.split_top_bottom_at_fraction(0.5);
-        (top, bottom)
-    } else {
-        let (left, right) = r.split_left_right_at_fraction(0.5);
-        (right, left)
-    }
-}
-
-/// A logical point `p` inside control rect `r`, as the control is drawn: on a right-to-left
-/// sheet the control moves as a whole without mirroring, so `p` is reflected within `r`.
-pub fn inner(geo: &Geo, r: Rect, p: Pos2) -> Pos2 {
-    if geo.rtl { pos2(r.left() + r.right() - p.x, p.y) } else { p }
-}
-
-/// The part of control `c` (drawn in `r`) under `p`.
-pub fn part_at(r: Rect, c: &FormControl, z: f32, p: Pos2) -> Option<Part> {
-    if !r.contains(p) {
-        return None;
-    }
-    Some(match c.kind {
-        ControlKind::Button => Part::Button,
-        ControlKind::Spin => {
-            let (up, _) = spin_parts(r);
-            if up.contains(p) { Part::Up } else { Part::Down }
-        }
-        ControlKind::Slider => {
-            let (_, thumb) = slider_parts(r, c, z);
-            if thumb.expand(2.0).contains(p) {
-                Part::Thumb
-            } else {
-                let before = if c.horizontal { p.x < thumb.center().x } else { p.y < thumb.center().y };
-                if before { Part::TrackBefore } else { Part::TrackAfter }
-            }
-        }
-    })
-}
-
-/// The value a thumb dragged to `p` stands for (`grab`: the offset from the thumb's centre where
-/// it was grabbed).
-pub fn value_at(r: Rect, c: &FormControl, z: f32, p: Pos2, grab: f32) -> f64 {
-    let (track, _) = slider_parts(r, c, z);
-    let f = if c.horizontal { (p.x - grab - track.left()) / track.width().max(1.0) } else { (p.y - grab - track.top()) / track.height().max(1.0) };
-    c.min as f64 + f.clamp(0.0, 1.0) as f64 * c.max.saturating_sub(c.min) as f64
-}
-
-/// Paints control `c` in `r`, in the sheet's control colours.
-pub fn paint(p: &Painter, r: Rect, c: &FormControl, z: f32, look: Look) {
-    let t = Tokens::get(p.ctx());
-    let border = Stroke::new(1.0, t.sheet_control_border);
-    let bg = |part: Part| {
-        if look.pressed == Some(part) {
-            t.sheet_control_pressed
-        } else if look.hover == Some(part) {
-            t.sheet_control_hover
-        } else {
-            t.sheet_control_bg
-        }
-    };
-    let clip = p.with_clip_rect(r.expand(2.0 * z.max(1.0) + 3.0).intersect(p.clip_rect()));
-    match c.kind {
-        ControlKind::Button => {
-            let fill = bg(Part::Button);
-            clip.rect_filled(r, 3.0 * z, fill);
-            clip.rect_stroke(r, 3.0 * z, border, StrokeKind::Inside);
-            let shift = if look.pressed == Some(Part::Button) { vec2(0.0, 1.0) } else { vec2(0.0, 0.0) };
-            let g = clip.layout(c.text.clone(), theme::ui_font(12.0 * z), t.sheet_control_text, (r.width() - 8.0 * z).max(1.0));
-            clip.with_clip_rect(r.shrink(1.0).intersect(clip.clip_rect())).galley(r.center() - g.size() / 2.0 + shift, g, t.sheet_control_text);
-        }
-        ControlKind::Slider => {
-            clip.rect_filled(r, 2.0 * z, t.sheet_control_bg);
-            clip.rect_stroke(r, 2.0 * z, border, StrokeKind::Inside);
-            let (track, thumb) = slider_parts(r, c, z);
-            clip.rect_filled(track, 2.0 * z, t.sheet_track);
-            let filled = if c.horizontal {
-                Rect::from_min_max(track.min, pos2(thumb.center().x, track.max.y))
-            } else {
-                Rect::from_min_max(track.min, pos2(track.max.x, thumb.center().y))
-            };
-            clip.rect_filled(filled, 2.0 * z, t.sheet_fill);
-            let knob = if look.pressed == Some(Part::Thumb) || look.hover == Some(Part::Thumb) { t.sheet_control_text } else { t.sheet_thumb };
-            clip.rect_filled(thumb, 3.0 * z, knob);
-            clip.rect_stroke(thumb, 3.0 * z, Stroke::new(1.0, t.sheet_control_bg), StrokeKind::Inside);
-            if look.show_value {
-                let g = clip.layout_no_wrap(c.value.to_string(), theme::ui_font(11.0 * z), t.sheet_control_text);
-                let at = if c.horizontal {
-                    pos2(thumb.center().x - g.size().x / 2.0, r.top() - g.size().y - 4.0 * z)
-                } else {
-                    pos2(r.right() + 4.0 * z, thumb.center().y - g.size().y / 2.0)
-                };
-                let card = Rect::from_min_size(at, g.size()).expand(2.0 * z);
-                p.rect_filled(card, 2.0 * z, t.sheet_control_bg);
-                p.rect_stroke(card, 2.0 * z, border, StrokeKind::Inside);
-                p.galley(at, g, t.sheet_control_text);
-            }
-        }
-        ControlKind::Spin => {
-            let (up, down) = spin_parts(r);
-            let tall = r.height() >= r.width();
-            for (half, part) in [(up, Part::Up), (down, Part::Down)] {
-                clip.rect_filled(half, 2.0 * z, bg(part));
-                clip.rect_stroke(half, 2.0 * z, border, StrokeKind::Inside);
-                let s = (half.width().min(half.height()) * 0.28).max(1.5);
-                let m = half.center();
-                let tri = match (tall, part) {
-                    (true, Part::Up) => vec![pos2(m.x, m.y - s * 0.6), pos2(m.x - s, m.y + s * 0.5), pos2(m.x + s, m.y + s * 0.5)],
-                    (true, _) => vec![pos2(m.x, m.y + s * 0.6), pos2(m.x + s, m.y - s * 0.5), pos2(m.x - s, m.y - s * 0.5)],
-                    (false, Part::Up) => vec![pos2(m.x + s * 0.6, m.y), pos2(m.x - s * 0.5, m.y + s), pos2(m.x - s * 0.5, m.y - s)],
-                    (false, _) => vec![pos2(m.x - s * 0.6, m.y), pos2(m.x + s * 0.5, m.y - s), pos2(m.x + s * 0.5, m.y + s)],
-                };
-                clip.add(PathShape::convex_polygon(tri, t.sheet_control_text, Stroke::NONE));
-            }
-        }
-    }
-    if look.focused {
-        p.rect_stroke(r.expand(2.0), 3.0 * z, Stroke::new(2.0, t.sheet_focus), StrokeKind::Outside);
-    }
-}
-
-/// The control with `id` on `sh`.
-pub fn find(sh: &Sheet, id: u32) -> Option<&FormControl> {
-    sh.controls.iter().find(|c| c.id == id)
-}
-
-/// How control `c` looks this frame, from the gesture, the focus and the pointer (`hover`, a
-/// logical position).
-pub fn look(app: &SheetApp, geo: &Geo, c: &FormControl, r: Rect, hover: Option<Pos2>) -> Look {
-    let gesture = app.grid.control.as_ref().filter(|g| g.id == c.id);
-    let selected = app.selected_object == Some(ObjRef::new(ObjKind::Control, c.id));
-    let hover = if selected { None } else { hover.and_then(|p| part_at(r, c, geo.z, inner(geo, r, p))) };
-    let pressed = gesture.map(|g| g.part).filter(|part| *part == Part::Thumb || hover == Some(*part));
-    Look { hover, pressed, focused: app.grid.focused_control == Some(c.id) && !selected, show_value: gesture.is_some_and(|g| g.part == Part::Thumb) }
-}
-
-impl SheetApp {
-    /// Sets a slider or spin button's value; inside a gesture, keeps it one undo step.
-    fn control_set(&mut self, id: u32, value: f64) -> bool {
-        match self.session.run("control.setValue", json!({"id": id, "value": value})) {
-            Ok(_) => {
-                if let Some(start) = self.grid.control.as_ref().map(|g| g.undo_start)
-                    && let Some(d) = self.session.active_mut()
-                    && d.undo.len() > start + 1
-                {
-                    d.undo.truncate(start + 1);
-                }
-                true
-            }
-            Err(e) => {
-                self.grid.control = None;
-                self.message = Some(("Form Control".into(), crate::clean_error(&e)));
-                false
-            }
-        }
-    }
-
-    /// Moves a slider or spin button by `steps` steps (negative: toward the minimum), or by pages
-    /// when `page` is set.
-    pub fn control_nudge(&mut self, id: u32, steps: i64, page: bool) -> bool {
-        let Some(c) = self.session.active().and_then(|d| d.wb.active()).and_then(|sh| find(sh, id)).cloned() else { return false };
-        if c.kind == ControlKind::Button {
-            return false;
-        }
-        let by = if page && c.kind == ControlKind::Slider { c.page } else { c.step } as f64;
-        self.control_set(id, c.value as f64 + steps as f64 * by)
-    }
-
-    /// Runs a button's action. Questions (approve it, make room for a macro's output) become a
-    /// prompt.
-    pub fn press_button(&mut self, id: u32) {
-        crate::control_ui::press(self, json!({"id": id}));
-    }
-}
-
-/// Pointer handling for controls on the grid. Returns true when it used the pointer this frame
-/// (so the grid neither selects cells nor objects).
-pub fn interact(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Response, geo: &Geo, sh: &Sheet) -> bool {
-    let (pointer, mods, time) = ctx.input(|i| (i.pointer.clone(), i.modifiers, i.time));
-    let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p));
-    // A control that no longer exists loses its gesture and focus.
-    if let Some(id) = app.grid.focused_control
-        && find(sh, id).is_none()
-    {
-        app.grid.focused_control = None;
-    }
-    if let Some(g) = app.grid.control.clone() {
-        let Some(c) = find(sh, g.id).cloned() else {
-            app.grid.control = None;
-            return true;
-        };
-        let r = crate::chartview::anchor_rect(geo, sh, &c.anchor);
-        if pointer.primary_down() {
-            match g.part {
-                Part::Thumb => {
-                    if let Some(p) = pos {
-                        let v = c.snap(value_at(r, &c, geo.z, inner(geo, r, p), g.grab));
-                        if v != c.value {
-                            app.control_set(c.id, v as f64);
-                        }
-                    }
-                }
-                Part::Button => {}
-                part => {
-                    // Held arrows and track repeat while the pointer stays on them.
-                    let over = pos.and_then(|p| part_at(r, &c, geo.z, inner(geo, r, p))) == Some(part);
-                    if over && time >= g.next_repeat {
-                        step_part(app, &c, part);
-                        if let Some(gg) = app.grid.control.as_mut() {
-                            gg.next_repeat = time + REPEAT_EVERY;
-                        }
-                    }
-                    ctx.request_repaint_after(std::time::Duration::from_millis(30));
-                }
-            }
-            return true;
-        }
-        // Released: a button runs when the pointer is still on it.
-        app.grid.control = None;
-        if g.part == Part::Button && pos.is_some_and(|p| r.contains(p)) {
-            app.press_button(c.id);
-        }
-        resp.request_focus();
-        return true;
-    }
-    if !pointer.primary_pressed() || !resp.contains_pointer() {
-        // Any other press, on the grid (a right-click on a cell) or off it, moves the focus off
-        // the control, so a later Enter or Space doesn't work it.
-        if pointer.any_pressed() && app.grid.focused_control.is_some() {
-            app.grid.focused_control = None;
-        }
-        return false;
-    }
-    let Some(p) = pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) else { return false };
-    // The selected object's handles reach past its frame and win over a control beneath them.
-    if let Some(r) = app.selected_object.and_then(|o| crate::chartview::object_rect(geo, sh, o))
-        && crate::objects::handle_at(r, p).is_some()
-    {
-        return false;
-    }
-    let hit = crate::chartview::hit(app, geo, sh, p).filter(|(o, _)| o.kind == ObjKind::Control);
-    // Ctrl or Cmd+click selects; a selected control moves and resizes instead of working.
-    let Some((o, r)) = hit.filter(|(o, _)| !mods.command && !mods.ctrl && app.selected_object != Some(*o)) else {
-        app.grid.focused_control = None;
-        return false;
-    };
-    let Some(c) = find(sh, o.id).cloned() else { return false };
-    let p = inner(geo, r, p);
-    let Some(part) = part_at(r, &c, geo.z, p) else { return false };
-    app.selected_object = None;
-    app.grid.focused_control = Some(c.id);
-    let undo_start = app.session.active().map_or(0, |d| d.undo.len());
-    let grab = if part == Part::Thumb {
-        let (_, thumb) = slider_parts(r, &c, geo.z);
-        if c.horizontal { p.x - thumb.center().x } else { p.y - thumb.center().y }
-    } else {
-        0.0
-    };
-    app.grid.control = Some(Gesture { id: c.id, part, grab, undo_start, next_repeat: time + REPEAT_DELAY });
-    if !matches!(part, Part::Button | Part::Thumb) {
-        step_part(app, &c, part);
-    }
-    resp.request_focus();
-    true
-}
-
-/// One click on an arrow or the track.
-fn step_part(app: &mut SheetApp, c: &FormControl, part: Part) {
-    match part {
-        Part::Up => app.control_nudge(c.id, 1, false),
-        Part::Down => app.control_nudge(c.id, -1, false),
-        Part::TrackBefore => app.control_nudge(c.id, -1, true),
-        Part::TrackAfter => app.control_nudge(c.id, 1, true),
-        Part::Button | Part::Thumb => false,
-    };
-}
-
-/// Whether the focused control is a button. Space presses one, so the space it types must not
-/// start a cell edit; a slider or spin button doesn't take Space, and its space reaches the grid
-/// like any other character.
-pub fn focused_button(app: &SheetApp, sh: &Sheet) -> bool {
-    app.grid.focused_control.and_then(|id| find(sh, id)).is_some_and(|c| c.kind == ControlKind::Button)
-}
-
-/// The grid takes a key while a control is focused: a button gives the keyboard back, so a later
-/// Enter or Space doesn't press it again and Space starts a cell edit; a slider or spin button
-/// keeps it, as the control last worked, which the arrows still step.
-pub fn key_to_grid(app: &mut SheetApp, sh: &Sheet) {
-    if focused_button(app, sh) {
-        app.grid.focused_control = None;
-    }
-}
-
-/// Keys for the focused control: arrows move by a step, Page Up and Page Down by a page, Home and
-/// End to the ends; Space or Enter presses a button. True when the key was used. `repeat` is a key
-/// held down: it steps a slider or spin button again, but a button runs once per press.
-pub fn key(app: &mut SheetApp, sh: &Sheet, key: egui::Key, repeat: bool) -> bool {
-    use egui::Key;
-    let Some(c) = app.grid.focused_control.and_then(|id| find(sh, id)).cloned() else { return false };
-    if app.selected_object.is_some() {
-        return false;
-    }
-    match (c.kind, key) {
-        (_, Key::Escape) => {
-            app.grid.focused_control = None;
-            true
-        }
-        (ControlKind::Button, Key::Space | Key::Enter) => {
-            if !repeat {
-                app.press_button(c.id);
-            }
-            true
-        }
-        (ControlKind::Button, _) => false,
-        // A spin button's up arrow adds; a slider's minimum is at its left or top.
-        (ControlKind::Spin, Key::ArrowUp | Key::ArrowRight) | (ControlKind::Slider, Key::ArrowDown | Key::ArrowRight) => {
-            app.control_nudge(c.id, 1, false)
-        }
-        (ControlKind::Spin, Key::ArrowDown | Key::ArrowLeft) | (ControlKind::Slider, Key::ArrowUp | Key::ArrowLeft) => {
-            app.control_nudge(c.id, -1, false)
-        }
-        (ControlKind::Spin, Key::PageUp) | (ControlKind::Slider, Key::PageDown) => app.control_nudge(c.id, 1, true),
-        (ControlKind::Spin, Key::PageDown) | (ControlKind::Slider, Key::PageUp) => app.control_nudge(c.id, -1, true),
-        (_, Key::Home) => app.control_set(c.id, c.min as f64),
-        (_, Key::End) => app.control_set(c.id, c.max as f64),
-        _ => false,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn slider(value: u32, horizontal: bool) -> FormControl {
-        FormControl { kind: ControlKind::Slider, min: 0, max: 100, value, horizontal, ..Default::default() }
-    }
-
-    #[test]
-    fn the_thumb_sits_at_the_value_and_dragging_reads_it_back() {
-        let r = Rect::from_min_size(pos2(10.0, 10.0), vec2(200.0, 20.0));
-        for v in [0, 25, 50, 100] {
-            let c = slider(v, true);
-            let (_, thumb) = slider_parts(r, &c, 1.0);
-            assert!((value_at(r, &c, 1.0, thumb.center(), 0.0) - v as f64).abs() < 0.5, "{v}");
-            assert_eq!(part_at(r, &c, 1.0, thumb.center()), Some(Part::Thumb));
-        }
-        let c = slider(50, true);
-        assert_eq!(part_at(r, &c, 1.0, pos2(15.0, 20.0)), Some(Part::TrackBefore));
-        assert_eq!(part_at(r, &c, 1.0, pos2(205.0, 20.0)), Some(Part::TrackAfter));
-        assert_eq!(part_at(r, &c, 1.0, pos2(5.0, 20.0)), None);
-        // Past the ends clamps.
-        assert_eq!(value_at(r, &c, 1.0, pos2(-500.0, 20.0), 0.0), 0.0);
-        assert_eq!(value_at(r, &c, 1.0, pos2(900.0, 20.0), 0.0), 100.0);
-        // Vertical: the minimum is at the top.
-        let r = Rect::from_min_size(pos2(0.0, 0.0), vec2(20.0, 200.0));
-        let c = slider(0, false);
-        let (_, thumb) = slider_parts(r, &c, 1.0);
-        assert!(thumb.center().y < 20.0);
-        assert_eq!(part_at(r, &slider(50, false), 1.0, pos2(10.0, 190.0)), Some(Part::TrackAfter));
-    }
-
-    #[test]
-    fn spin_halves() {
-        let tall = Rect::from_min_size(pos2(0.0, 0.0), vec2(18.0, 36.0));
-        let c = FormControl { kind: ControlKind::Spin, ..Default::default() };
-        assert_eq!(part_at(tall, &c, 1.0, pos2(9.0, 5.0)), Some(Part::Up));
-        assert_eq!(part_at(tall, &c, 1.0, pos2(9.0, 30.0)), Some(Part::Down));
-        let wide = Rect::from_min_size(pos2(0.0, 0.0), vec2(40.0, 18.0));
-        assert_eq!(part_at(wide, &c, 1.0, pos2(35.0, 9.0)), Some(Part::Up));
-        assert_eq!(part_at(wide, &c, 1.0, pos2(5.0, 9.0)), Some(Part::Down));
-    }
-
-    #[test]
-    fn degenerate_ranges_do_not_divide_by_zero() {
-        let r = Rect::from_min_size(pos2(0.0, 0.0), vec2(1.0, 1.0));
-        let c = FormControl { kind: ControlKind::Slider, min: 5, max: 5, value: 5, ..Default::default() };
-        let (track, thumb) = slider_parts(r, &c, 1.0);
-        assert!(track.width().is_finite() && thumb.center().x.is_finite());
-        assert!(value_at(r, &c, 1.0, pos2(0.5, 0.5), 0.0).is_finite());
-    }
-}

crates/ui-egui/src/grid.rs

@@ -297,14 +297,6 @@ pub struct GridState {
     pub hf_start: bool,
     /// The grid geometry of the last frame (hit-testing for agents and tests).
     pub geo: Option<Geo>,
-    /// A form control being worked with the pointer.
-    pub control: Option<crate::form_controls::Gesture>,
-    /// The form control that takes the arrow keys (the one last worked).
-    pub focused_control: Option<u32>,
-    /// Insert › Controls: the kind a click or drag on the grid places, and where the drag began
-    /// (logical position).
-    pub placing: Option<gridcraft_engine::model::ControlKind>,
-    pub place_start: Option<Pos2>,
     /// The horizontal scrollbar's track in the sheet tab bar (hit-testing for tests).
     pub hscroll: Option<Rect>,
     /// The handle between the sheet tabs and the horizontal scrollbar (hit-testing for tests).

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

@@ -1,5 +1,3 @@
-use gridcraft_engine::model::ObjKind;
-
 use super::geo::Geo;
 use super::interact::{col_edge, freeze_handles, hidden_col_edge, hidden_row_edge, on_border, row_edge};
 use super::{CellRef, Color32, CursorIcon, Drag, Pos2, RangeRef, Rect, Sheet, SheetApp, Stroke, pos2, vec2};
@@ -23,9 +21,8 @@ pub(super) fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Resp
     {
         app.grid.hover_cell = in_cells.then(|| geo.cell_at(sh, p));
     }
-    // Draw tools and Insert › Controls placement own the cursor over cells, including while
-    // recording a stroke or drawing the control.
-    if (!app.session.draw_tool.is_empty() || app.grid.placing.is_some()) && in_cells {
+    // Draw tools own the cursor over cells, including while recording a stroke.
+    if !app.session.draw_tool.is_empty() && in_cells {
         ctx.set_cursor_icon(CursorIcon::Crosshair);
         return;
     }
@@ -82,15 +79,9 @@ fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, poin
     // The selected object's handles resize it; any object's body moves it.
     let idle = app.grid.drag == Drag::None && app.editor.is_none();
     let object_handle = if idle { crate::chartview::selected_handle(app, geo, sh, p).map(|(.., h)| h) } else { None };
-    let hit = if idle { crate::chartview::hit(app, geo, sh, p) } else { None };
-    // A form control works on click unless it is selected (or Ctrl or Cmd is held).
-    let mods = ctx.input(|i| i.modifiers);
-    let works = hit.is_some_and(|(o, _)| o.kind == ObjKind::Control && app.selected_object != Some(o) && !mods.command && !mods.ctrl);
-    let on_object = hit.is_some();
+    let on_object = idle && crate::chartview::hit(app, geo, sh, p).is_some();
     if let Some(h) = object_handle {
         ctx.set_cursor_icon(h.cursor(geo.rtl));
-    } else if works {
-        ctx.set_cursor_icon(CursorIcon::PointingHand);
     } else if on_object {
         ctx.set_cursor_icon(CursorIcon::Move);
     } else if near_col_edge || (in_row_header && row_edge(geo, sh, p.y).is_some()) {

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

@@ -64,15 +64,6 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
     let in_col_header = pos.is_some_and(|p| p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left());
     let in_row_header = pos.is_some_and(|p| p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top());
     let in_corner = pos.is_some_and(|p| p.x < geo.cells.left() && p.y < geo.cells.top() && p.x >= geo.head_left() && p.y >= geo.head_top());
-    // Insert › Controls places a control; a click works a form control (Ctrl or Cmd+click, or a
-    // right-click, selects it instead).
-    if app.editor.is_none() && crate::control_ui::place(app, ui, resp, geo, sh) {
-        return;
-    }
-    if app.editor.is_none() && app.session.draw_tool.is_empty() && crate::form_controls::interact(app, &ctx, resp, geo, sh) {
-        keyboard(app, &ctx, resp, geo, sh);
-        return;
-    }
     let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default();
     let cur_rect = geo.range_rect(sh, sel.current());
     let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0));
@@ -109,14 +100,10 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         return;
     }
     // A plain click on a slicer value tile toggles it (Ctrl/Cmd for multi-select); the clear
-    // button resets it. Runs before the generic object select/drag so tiles stay clickable, but
-    // only when the slicer is what the press lands on: a form control over a tile (Ctrl or
-    // Cmd+clicked, or clicked while selected, so `form_controls::interact` left the click) and a
-    // selected object's handle keep the generic path, which selects, moves or resizes them.
+    // button resets it. Runs before the generic object select/drag so tiles stay clickable.
     if primary_clicked
         && !resp.drag_started()
         && let Some(p) = pos
-        && object_under(app, geo, sh, p).is_some_and(|(o, _, handle)| o.kind == ObjKind::Slicer && handle.is_none())
         && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p)
     {
         app.selected_object = Some(ObjRef::new(ObjKind::Slicer, id));
@@ -139,10 +126,10 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         // The selected object's handles reach a little outside it, so they win over hit-testing.
         // Only they resize: a press anywhere on another object selects and moves it, as the
         // hover cursor shows.
-        let under = at.and_then(|p| object_under(app, geo, sh, p));
-        let handle = under.and_then(|(.., h)| h);
+        let on_handle = at.and_then(|p| crate::chartview::selected_handle(app, geo, sh, p));
+        let handle = on_handle.map(|(.., h)| h);
         if let Some(p) = at
-            && let Some((obj, _, _)) = under
+            && let Some((obj, _)) = on_handle.map(|(o, r, _)| (o, r)).or_else(|| crate::chartview::hit(app, geo, sh, p))
         {
             app.selected_object = Some(obj);
             if resp.double_clicked() && app.open_object(obj) != crate::objects::OpenAction::Select {
@@ -159,18 +146,14 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
         }
         app.selected_object = None;
     }
-    // A right-click on a chart, picture, shape, slicer or form control opens the object's menu, not
-    // the cell's under it; a right press that wobbles into a drag counts too (#2067). On a form
-    // control it selects the control without running it.
+    // A right-click on a chart, picture, shape or slicer opens the object's menu, not the cell's
+    // under it; a right press that wobbles into a drag counts too (#2067).
     let secondary_drag = resp.drag_started_by(egui::PointerButton::Secondary);
     if (resp.secondary_clicked() || secondary_drag)
         && let Some(p) = if secondary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos }
         && let Some((obj, _)) = crate::chartview::hit(app, geo, sh, p)
     {
         app.selected_object = Some(obj);
-        if obj.kind == ObjKind::Control {
-            app.grid.focused_control = None;
-        }
         app.grid.object_menu = Some((geo.mirror_pos(p), obj.kind.name(), obj.id));
         return;
     }
@@ -350,7 +333,6 @@ fn handle_column_header_press(app: &mut SheetApp, input: &InteractionInput<'_>,
             return;
         }
         let range = if mods.shift { RangeRef::cols(sel.anchor.col.min(c), sel.anchor.col.max(c)) } else { RangeRef::cols(c, c) };
-        note_selecting_press(app);
         select_ranges(app, range, mods.command, CellRef::new(geo.row_at(sh, geo.cells.top() + 1.0), c));
         app.grid.drag = Drag::Cols(if mods.shift { sel.anchor.col } else { c });
     }
@@ -371,7 +353,6 @@ fn handle_row_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, p:
             return;
         }
         let range = if mods.shift { RangeRef::rows(sel.anchor.row.min(r), sel.anchor.row.max(r)) } else { RangeRef::rows(r, r) };
-        note_selecting_press(app);
         select_ranges(app, range, mods.command, CellRef::new(r, geo.col_at(sh, geo.cells.left() + 1.0)));
         app.grid.drag = Drag::Rows(if mods.shift { sel.anchor.row } else { r });
     }
@@ -403,7 +384,6 @@ fn handle_press(app: &mut SheetApp, input: &InteractionInput<'_>) {
         return;
     }
     if in_corner {
-        note_selecting_press(app);
         let _ = app.session.run("selection.set", json!({"range": RangeRef::all().a1()}));
         return;
     }
@@ -489,16 +469,11 @@ fn handle_press(app: &mut SheetApp, input: &InteractionInput<'_>) {
         return;
     }
     let now = crate::now_ms();
-    // While a reference box picks, a click only picks: a second click on a cell does not edit it,
-    // and a link is not followed nor a checkbox toggled.
-    let ref_box_picks = app.dialog.as_ref().is_some_and(|d| d.ref_box_picks());
-    let acts = primary_clicked && !ref_box_picks;
-    if !ref_box_picks && handle_cell_double_click(app, input, c, now) {
+    if handle_cell_double_click(app, input, c, now) {
         return;
     }
     app.grid.last_click = Some((c, now));
     if mods.shift {
-        note_selecting_press(app);
         let _ = app.session.run("selection.set", json!({"range": RangeRef::new(sel.anchor, c).a1(), "active": sel.active.a1()}));
         if let Some(d) = app.session.active_mut() {
             d.selection.anchor = sel.anchor;
@@ -506,24 +481,22 @@ fn handle_press(app: &mut SheetApp, input: &InteractionInput<'_>) {
     } else if mods.command {
         // Ctrl+click (without Alt) on a hyperlink's text follows it instead of adding the cell to the selection.
         if let Some(h) = sh.hyperlinks.get(&c).cloned()
-            && acts
+            && primary_clicked
             && !mods.alt
             && p.x < geo.cell_rect(sh, c).left() + geo.cell_rect(sh, c).width() * 0.8
         {
             follow_link(app, &h.target);
         } else {
-            note_selecting_press(app);
             select_ranges(app, RangeRef::cell(c), true, c);
         }
     } else {
-        note_selecting_press(app);
         let _ = app.session.run("selection.set", json!({"cell": c.a1()}));
-        if acts && wb.styles.get(sh.style_id(c)).num_fmt.as_str() == "checkbox" {
+        if primary_clicked && wb.styles.get(sh.style_id(c)).num_fmt.as_str() == "checkbox" {
             let _ = app.run("cell.toggleCheckbox", json!({"cell": c.a1()}));
         }
         // A click on a hyperlink's text follows it (like Excel); elsewhere in the cell selects.
         if let Some(h) = sh.hyperlinks.get(&c).cloned()
-            && acts
+            && primary_clicked
             && !mods.any()
         {
             let r = geo.cell_rect(sh, c);
@@ -542,15 +515,6 @@ fn handle_press(app: &mut SheetApp, input: &InteractionInput<'_>) {
     }
 }
 
-/// Tells the open dialog that a press on the grid selects: the reference box being picked into
-/// takes the selection even when the press leaves it as it was (a click on the cell already
-/// selected), as a deliberate pick.
-fn note_selecting_press(app: &mut SheetApp) {
-    if let Some(d) = app.dialog.as_mut() {
-        d.note_selecting_press();
-    }
-}
-
 fn handle_cell_double_click(app: &mut SheetApp, input: &InteractionInput<'_>, c: CellRef, now: f64) -> bool {
     let (sh, mods) = (input.sheet, input.modifiers);
     if let Some((last, at)) = app.grid.last_click
@@ -580,15 +544,6 @@ fn handle_cell_double_click(app: &mut SheetApp, input: &InteractionInput<'_>, c:
     false
 }
 
-/// What a press at `p` lands on, for slicer tiles and the generic object handling alike, so the
-/// z-order decides once: the selected object's handle (handles reach a little past the frame and
-/// win over hit-testing), else the topmost object under `p` and its rect.
-fn object_under(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Rect, Option<crate::objects::Handle>)> {
-    crate::chartview::selected_handle(app, geo, sh, p)
-        .map(|(o, r, h)| (o, r, Some(h)))
-        .or_else(|| crate::chartview::hit(app, geo, sh, p).map(|(o, r)| (o, r, None)))
-}
-
 fn handle_context_menu_and_keyboard(app: &mut SheetApp, input: &InteractionInput<'_>) {
     let (geo, sh, sel, pos) = (input.geo, input.sheet, &input.selection, input.position);
     let resp = input.response;