fix(flatpak): allow reading launcher version pins

2026-11-07 10:59:46 -06:00 · 2026-10-30 18:42:21 -04:00 · 2026-10-30 18:41:21 -04:00
402 changed files with 2685 additions and 44001 deletions
@@ -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
@@ -12,7 +12,6 @@ on:

 permissions:
  contents: write
-  packages: write

 concurrency:
  group: release-${{ github.ref }}
@@ -42,4 +41,3 @@ jobs:
      AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
      AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
      AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
-      LINUX_SIGNING_KEY: ${{ secrets.LINUX_SIGNING_KEY }}
@@ -1,62 +1,14 @@
-<!-- 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).

+Standards and learnings shared across the crafting apps live in `../../craftrules` (checked out next to the craft apps, or `storytold/craftrules`). Read its `AGENTS.md` at the start of a session, follow its standards, and contribute reusable learnings back there. Never code: repos don't share code.
+
 ## 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.
@@ -68,7 +20,7 @@ Read [`ROADMAP.md`](ROADMAP.md) and [`docs/gaps.md`](docs/gaps.md). `plan/` is a
 - 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.**
+People trust GridCraft with their numbers; a crash loses their work. **This outranks feature work.** Standard: [`craftrules/standards/never-crash.md`](https://github.com/storytold/craftrules/blob/main/standards/never-crash.md).
 - **No panics in non-test code:** no `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!`; no `unsafe` (`unsafe_code = "forbid"`).
 - **Errors are `Result<T, E>`** through the crate's error type and `?`.
 - **Input-derived numbers are hostile** (files, formulas, commands, MCP/control params): validate indexes and ranges before access, use checked access when validity is not established, use checked/saturating arithmetic, and cap input-sized allocations (huge ranges, `REPT`, `SEQUENCE`, whole-column references).
@@ -79,12 +31,13 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr

 ## 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.
+- **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. Standard: craftrules `standards/fonts.md`.
+- **Test corpora** (real Excel-authored files) live in a separate corpus repo, fetched pinned and sha256-verified (craftrules `standards/test-corpora.md`). 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`.
+- **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,12 +46,12 @@ 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
-`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`.
+`ROADMAP.md` (committed) is the one-page summary: stage, headline numbers, dimensions, languages, progress log. It follows craftrules `standards/progress-docs.md` and 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`.

 ## Contributor credits (About window)

@@ -109,15 +62,16 @@ People trust GridCraft with their numbers; a crash loses their work. **This outr
  username has a `[people.<username>]` entry in `contributors/people.toml`. If not, ask them once
  whether they want to be credited by more than their username: a real name, a display name, and/or
  their public GitHub profile name (`sync_github_name = true`). If yes, add **only their own** entry
-  (copy the template at the top of the file)
+  (copy the template at the top of the file, or run
+  `python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "…" --sync-github-name`)
  and include it in their PR, committed as them. If no, change nothing: they are credited as
  `@username` anyway.
 - Never add, edit, guess or copy anyone else's entry or name (not from git config, commit authors or
  GitHub profiles). Never hand-edit `contributors.json`.
+- Maintainers refresh the stats with `python3 ../../craftrules/scripts/contributors.py .` (it also
+  re-verifies who wrote each `people.toml` entry; `--check` only verifies).

 ## 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.
-
-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.
@@ -12,15 +12,15 @@ Generated-in-code art is original and has no file to list: the UI icon set (`cra
 | `epaint_default_fonts::HACK_REGULAR` (dependency font input) | Source Foundry Authors (Hack; DejaVu and Bitstream Vera foundations) | [egui 6d518fc](https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts), [Hack](https://github.com/source-foundry/Hack) | MIT + Bitstream Vera License (full upstream texts in `NOTICE`) | Hack-Regular.ttf is egui's bundled monospace face and GridCraft's last-resort symbol fallback. Dependency asset unmodified here, no font file copied into this repository. |
 | `epaint_default_fonts::NOTO_EMOJI_REGULAR` (dependency font input) | The Noto Project Authors | [egui 6d518fc](https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts), [Noto Emoji](https://fonts.google.com/noto/specimen/Noto+Emoji) | SIL Open Font License 1.1 (full upstream text in `NOTICE`) | NotoEmoji-Regular.ttf is enabled by egui's `monochrome_emoji_fonts` feature and used as the monochrome emoji fallback. Dependency asset unmodified here, no font file copied into this repository. |
 | `epaint_default_fonts::UBUNTU_LIGHT` (dependency font input) | Canonical Ltd. and the Ubuntu Font Family authors | [egui 6d518fc](https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts), [Ubuntu font](https://design.ubuntu.com/font) | Ubuntu Font Licence 1.0 (full upstream text in `NOTICE`) | Ubuntu-Light.ttf is egui's default proportional face. Dependency asset unmodified here, no font file copied into this repository. |
-| `docs/brand/artcraft-logo.svg` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-logo.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/artcraft-logo-white.svg` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/artcraft-logo-white.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/artcraft-mark.svg` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/artcraft-mark.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/artcraft-mark-black.svg` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/artcraft-mark-black.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms | Trademark |
-| `docs/brand/LICENSE-brand.txt` | (licence text) | project | — | |
+| `docs/brand/artcraft-logo.svg` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `docs/brand/artcraft-logo.png` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/artcraft-logo-white.svg` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/artcraft-logo-white.png` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/artcraft-mark.svg` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/artcraft-mark.png` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/artcraft-mark-black.svg` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/artcraft-mark-black.png` | ArtCraft Team | craftrules `assets/brand/` | ArtCraft brand terms | Trademark |
+| `docs/brand/LICENSE-brand.txt` | (licence text) | craftrules | — | |
 | `assets/app-icon/gridcraft.svg` | GridCraft contributors | original (hand-written SVG; `packaging/icons.sh`) | MIT OR Apache-2.0 (`assets/app-icon/LICENSE.txt`) | PLACEHOLDER app icon (ledger page); replaced by the owner's creature art later |
 | `packaging/macos/dmg/background.svg` | @XusBadia | original (hand-written SVG, derived from the GridCraft app icon `assets/app-icon/gridcraft.svg`, referenced via `<image>`, not copied; text is outlined glyph paths; `packaging/macos/dmg/generate.py` renders it to `background.tiff`) | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | GridCraft macOS DMG window background for the Finder window; added 2026-10-08 |
 | `packaging/macos/dmg/background.tiff` | @XusBadia | Rendered from `packaging/macos/dmg/background.svg` by `packaging/macos/dmg/generate.py` | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | 1x + 2x HiDPI TIFF for the macOS DMG window; includes the app icon (see its row) and LittleCMS's built-in sRGB profile ("No copyright, use freely") |
@@ -46,5 +46,3 @@ Generated-in-code art is original and has no file to list: the UI icon set (`cra
 | `docs/images/pivot.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
 | `docs/images/format-chart.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
 | `docs/images/page-break.png` | GridCraft contributors | screenshot of GridCraft rendered offscreen (`crates/ui-egui/examples/snapshot.rs`) showing an original sample workbook | MIT OR Apache-2.0 | README screenshot; no third-party content |
-| Core 14 AFM metric numbers in `crates/pdf/src/symbol.rs` (Symbol: character codes and advance widths) and `crates/pdf/src/metrics.rs` (Helvetica, Times and Courier advance widths); no font file | Adobe Systems Incorporated | Adobe's Core 14 AFM font metrics files (`Symbol.afm` 001.008 and the Helvetica, Times and Courier AFMs) | Adobe's Core 14 metrics notice: the files may be used, copied and distributed for any purpose and without charge, provided the notice is kept (quoted in `crates/pdf/src/metrics.rs`) | Numbers only, typed in from the public metrics. PDF export embeds no font: Symbol and the Times faces are base-14 fonts every PDF reader supplies, and text outside WinAnsiEncoding is set in a predefined, non-embedded Adobe-GB1 CID font |
-| Unicode values of the Symbol encoding in `crates/pdf/src/symbol.rs` (the code-to-character map; numbers only, no file copied) | Unicode, Inc. | `symbol.txt`, "Adobe Symbol Encoding to Unicode", table version 1.0 (2011-07-12), at unicode.org/Public/MAPPINGS/VENDORS/ADOBE/ | Unicode, Inc.'s notice in the file: "Unicode, Inc. hereby grants the right to freely use the information supplied in this file in the creation of products supporting the Unicode Standard, and to make copies of this file in any form for internal or external distribution as long as this notice remains attached." The file is provided as-is, without warranties | Separate from Adobe's Core 14 notice (previous row), which covers the character codes and widths; the Unicode values come from this table |
@@ -1 +1,58 @@
-@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).
+
+Standards and learnings shared across the crafting apps live in `../../craftrules` (checked out next to the craft apps, or `storytold/craftrules`). Read its `AGENTS.md` at the start of a session, follow its standards, and contribute reusable learnings back there. Never code: repos don't share code.
+
+## 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.** Standard: [`craftrules/standards/never-crash.md`](https://github.com/storytold/craftrules/blob/main/standards/never-crash.md).
+- **No panics in non-test code:** no `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!`; no `unsafe` (`unsafe_code = "forbid"`).
+- **Errors are `Result<T, E>`** through the crate's error type and `?`.
+- **Input-derived numbers are hostile** (files, formulas, commands, MCP/control params): `get()` instead of indexing, checked/saturating arithmetic, cap input-sized allocations (huge ranges, `REPT`, `SEQUENCE`, whole-column references).
+- **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. Standard: craftrules `standards/fonts.md`.
+- **Test corpora** (real Excel-authored files) live in a separate corpus repo, fetched pinned and sha256-verified (craftrules `standards/test-corpora.md`). 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 follows craftrules `standards/progress-docs.md` and 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.
@@ -20,7 +20,7 @@ dependencies = [
 "accesskit",
 "accesskit_consumer",
 "atspi-common",
- "phf 0.14.0",
+ "phf",
 "serde",
 "zvariant",
 ]
@@ -225,12 +225,6 @@ dependencies = [
 "x11rb",
 ]

-[[package]]
-name = "arrayref"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
-
 [[package]]
 name = "arrayvec"
 version = "0.7.8"
@@ -474,30 +468,15 @@ version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"

-[[package]]
-name = "bit-set"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
-dependencies = [
- "bit-vec 0.8.0",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d"
 dependencies = [
- "bit-vec 0.9.1",
+ "bit-vec",
 ]

-[[package]]
-name = "bit-vec"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
-
 [[package]]
 name = "bit-vec"
 version = "0.9.1"
@@ -910,12 +889,12 @@ dependencies = [
 [[package]]
 name = "craft-fonts-build"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"

 [[package]]
 name = "craft-i18n"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
 "fixed_decimal",
 "icu_decimal",
@@ -938,10 +917,9 @@ dependencies = [
 [[package]]
 name = "craft-print"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
 "craft-winprint-gdi",
- "log",
 "miniz_oxide 0.9.1",
 "roxmltree",
 "tempfile",
@@ -952,7 +930,7 @@ dependencies = [
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
 "craft-fonts-build",
 "craft-i18n",
@@ -972,7 +950,7 @@ dependencies = [
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
+source = "git+https://github.com/storytold/craft-libs?rev=04aa1703b32d299e54f78fcde4182f2b393a9116#04aa1703b32d299e54f78fcde4182f2b393a9116"
 dependencies = [
 "chrono",
 "dunce",
@@ -995,19 +973,10 @@ dependencies = [
 "zip 9.1.0",
 ]

-[[package]]
-name = "craft-web-host"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=2e2312ddaf21bc3d85cd3395d0955c7d239306f6#2e2312ddaf21bc3d85cd3395d0955c7d239306f6"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "craft-window"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
 "egui",
 "objc2 0.6.5",
@@ -1355,19 +1324,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"
@@ -1435,26 +1391,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"
@@ -1558,17 +1494,6 @@ dependencies = [
 "pin-project-lite",
 ]

-[[package]]
-name = "fancy-regex"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e24cb5a94bcae1e5408b0effca5cd7172ea3c5755049c5f3af4cd283a165298"
-dependencies = [
- "bit-set 0.8.0",
- "regex-automata",
- "regex-syntax",
-]
-
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -2011,7 +1936,7 @@ dependencies = [

 [[package]]
 name = "gridcraft"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "arboard",
 "chrono",
@@ -2038,7 +1963,7 @@ dependencies = [

 [[package]]
 name = "gridcraft-calc"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-core",
 "gridcraft-formula",
@@ -2050,7 +1975,7 @@ dependencies = [

 [[package]]
 name = "gridcraft-chart"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-calc",
 "gridcraft-core",
@@ -2061,7 +1986,7 @@ dependencies = [

 [[package]]
 name = "gridcraft-cli"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-engine",
 "gridcraft-mcp",
@@ -2073,7 +1998,7 @@ dependencies = [

 [[package]]
 name = "gridcraft-core"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "chrono",
 "js-sys",
@@ -2084,14 +2009,13 @@ dependencies = [

 [[package]]
 name = "gridcraft-engine"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-calc",
 "gridcraft-chart",
 "gridcraft-core",
 "gridcraft-formula",
 "gridcraft-functions",
- "gridcraft-math",
 "gridcraft-model",
 "gridcraft-numfmt",
 "gridcraft-pdf",
@@ -2107,7 +2031,7 @@ dependencies = [

 [[package]]
 name = "gridcraft-formula"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-core",
 "serde",
@@ -2116,25 +2040,15 @@ dependencies = [

 [[package]]
 name = "gridcraft-functions"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-core",
 "regex",
 ]

-[[package]]
-name = "gridcraft-math"
-version = "0.17.0"
-dependencies = [
- "ratex-font",
- "ratex-layout",
- "ratex-parser",
- "ratex-types",
-]
-
 [[package]]
 name = "gridcraft-mcp"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-engine",
 "log",
@@ -2143,11 +2057,10 @@ dependencies = [

 [[package]]
 name = "gridcraft-model"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-core",
 "gridcraft-formula",
- "gridcraft-math",
 "serde",
 "serde_json",
 "sha2 0.11.1",
@@ -2156,24 +2069,23 @@ dependencies = [

 [[package]]
 name = "gridcraft-numfmt"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-core",
 ]

 [[package]]
 name = "gridcraft-pdf"
-version = "0.17.0"
+version = "0.13.0"

 [[package]]
 name = "gridcraft-ui-egui"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "craft-ui",
 "craft-update",
 "craft-window",
 "egui",
- "egui_extras",
 "egui_kittest",
 "epaint_default_fonts",
 "gridcraft-chart",
@@ -2193,9 +2105,8 @@ dependencies = [

 [[package]]
 name = "gridcraft-web"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
- "craft-web-host",
 "eframe",
 "egui",
 "gridcraft-engine",
@@ -2211,13 +2122,12 @@ dependencies = [

 [[package]]
 name = "gridcraft-xlsx"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "aes",
 "gridcraft-core",
 "gridcraft-formula",
 "gridcraft-functions",
- "gridcraft-math",
 "gridcraft-model",
 "quick-xml 0.41.0",
 "sha1 0.11.0",
@@ -3056,7 +2966,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130"
 dependencies = [
 "arrayvec",
- "bit-set 0.10.0",
+ "bit-set",
 "bitflags 2.13.2",
 "cfg-if",
 "cfg_aliases",
@@ -3632,37 +3542,17 @@ dependencies = [
 "indexmap",
 ]

-[[package]]
-name = "phf"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
-dependencies = [
- "phf_macros 0.11.3",
- "phf_shared 0.11.3",
-]
-
 [[package]]
 name = "phf"
 version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "010378780309880b08997fae13be7834dba947d36393bd372f2b1556deb2a2f6"
 dependencies = [
- "phf_macros 0.14.0",
- "phf_shared 0.14.0",
+ "phf_macros",
+ "phf_shared",
 "serde",
 ]

-[[package]]
-name = "phf_generator"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
-dependencies = [
- "phf_shared 0.11.3",
- "rand 0.8.8",
-]
-
 [[package]]
 name = "phf_generator"
 version = "0.14.0"
@@ -3670,20 +3560,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100"
 dependencies = [
 "fastrand",
- "phf_shared 0.14.0",
-]
-
-[[package]]
-name = "phf_macros"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
-dependencies = [
- "phf_generator 0.11.3",
- "phf_shared 0.11.3",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
+ "phf_shared",
 ]

 [[package]]
@@ -3692,22 +3569,13 @@ version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5fa8d0ca26d424d27630da600c6624696e7dec8bf7b3b492b383c5dc49e5e085"
 dependencies = [
- "phf_generator 0.14.0",
- "phf_shared 0.14.0",
+ "phf_generator",
+ "phf_shared",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]

-[[package]]
-name = "phf_shared"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
-dependencies = [
- "siphasher",
-]
-
 [[package]]
 name = "phf_shared"
 version = "0.14.0"
@@ -3983,7 +3851,7 @@ dependencies = [
 "bytes",
 "getrandom 0.4.3",
 "lru-slab",
- "rand 0.10.3",
+ "rand",
 "rand_pcg",
 "ring",
 "rustc-hash 2.1.3",
@@ -4031,15 +3899,6 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"

-[[package]]
-name = "rand"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
-dependencies = [
- "rand_core 0.6.4",
-]
-
 [[package]]
 name = "rand"
 version = "0.10.3"
@@ -4078,66 +3937,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08"

-[[package]]
-name = "ratex-font"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a7b73531dabe934a3e725ed5c90d18dacf43778b7a208381390943a9a8c24db"
-dependencies = [
- "phf 0.11.3",
- "ratex-types",
-]
-
-[[package]]
-name = "ratex-layout"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1792738e2e36683cd20de742296a5233759565efc8cd03831064a0ccfb1fe0f7"
-dependencies = [
- "ratex-font",
- "ratex-parser",
- "ratex-types",
- "serde_json",
-]
-
-[[package]]
-name = "ratex-lexer"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f704add86d7bf4c4ecc7767f45ab38a44f1bbfa4b49725b2ae53c32e83b8a61e"
-dependencies = [
- "ratex-types",
- "serde",
- "thiserror 1.0.69",
-]
-
-[[package]]
-name = "ratex-parser"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "079ec2e7ac6bc76137a6de093a173d1f901139a51318589ab9ce17139c21a6f0"
-dependencies = [
- "fancy-regex",
- "ratex-font",
- "ratex-lexer",
- "ratex-types",
- "regex",
- "regex-lite",
- "serde",
- "serde_json",
- "thiserror 1.0.69",
- "unicode-normalization",
-]
-
-[[package]]
-name = "ratex-types"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cf0be3d050525f0f7d37af55a443d7648c222ccc617639950e3de1f8e6f9900"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "raw-window-handle"
 version = "0.6.2"
@@ -4237,12 +4036,6 @@ dependencies = [
 "regex-syntax",
 ]

-[[package]]
-name = "regex-lite"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
-
 [[package]]
 name = "regex-syntax"
 version = "0.8.11"
@@ -4520,17 +4313,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

-[[package]]
-name = "sctk-adwaita"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec"
-dependencies = [
- "log",
- "smithay-client-toolkit 0.19.2",
- "tiny-skia",
-]
-
 [[package]]
 name = "security-framework"
 version = "3.7.0"
@@ -4834,7 +4616,7 @@ dependencies = [
 "const-oid",
 "der",
 "hex",
- "rand 0.10.3",
+ "rand",
 "reqwest",
 "rustls-pki-types",
 "rustls-webpki",
@@ -5063,12 +4845,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

-[[package]]
-name = "strict-num"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
-
 [[package]]
 name = "strum"
 version = "0.28.0"
@@ -5298,31 +5074,6 @@ dependencies = [
 "time-core",
 ]

-[[package]]
-name = "tiny-skia"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
-dependencies = [
- "arrayref",
- "arrayvec",
- "bytemuck",
- "cfg-if",
- "log",
- "tiny-skia-path",
-]
-
-[[package]]
-name = "tiny-skia-path"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
-dependencies = [
- "arrayref",
- "bytemuck",
- "strict-num",
-]
-
 [[package]]
 name = "tinystr"
 version = "0.8.4"
@@ -5594,15 +5345,6 @@ version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"

-[[package]]
-name = "unicode-normalization"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75cd3fb03d5288b3ba9a1ee103ac7e9cbb59f0b03d64f8ddfcc04dd42758a85d"
-dependencies = [
- "tinyvec",
-]
-
 [[package]]
 name = "unicode-properties"
 version = "0.1.4"
@@ -6043,8 +5785,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c018fce9b6270aa203c2fdd56f3cce996713534bd757e4ea58c8560b121f14"
 dependencies = [
 "arrayvec",
- "bit-set 0.10.0",
- "bit-vec 0.9.1",
+ "bit-set",
+ "bit-vec",
 "bitflags 2.13.2",
 "bytemuck",
 "cfg_aliases",
@@ -6116,7 +5858,7 @@ dependencies = [
 "android_system_properties",
 "arrayvec",
 "ash",
- "bit-set 0.10.0",
+ "bit-set",
 "bitflags 2.13.2",
 "block2 0.6.2",
 "bytemuck",
@@ -6442,7 +6184,6 @@ dependencies = [
 "raw-window-handle",
 "redox_syscall 0.4.1",
 "rustix 0.38.44",
- "sctk-adwaita",
 "smithay-client-toolkit 0.19.2",
 "smol_str",
 "tracing",
@@ -6662,7 +6403,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"

 [[package]]
 name = "xtask"
-version = "0.17.0"
+version = "0.13.0"
 dependencies = [
 "gridcraft-engine",
 "serde_json",
@@ -7011,6 +6752,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"
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/gridcraft", "apps/gridcraft-cli", "xtask"]

 [workspace.package]
-version = "0.17.0"
+version = "0.13.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -24,11 +24,10 @@ gridcraft-engine = { path = "crates/engine" }
 gridcraft-ui-egui = { path = "crates/ui-egui" }
 gridcraft-mcp = { path = "crates/mcp" }
 gridcraft-pdf = { path = "crates/pdf" }
-gridcraft-math = { path = "crates/math" }
 # Every craft-libs crate (craft-update and craft-window here, craft-ui in ui-egui, craft-print in
 # the app) comes from one storytold/craft-libs revision.
 # craft-update: app-specific pretend versions apply to startup and manual checks.
-craft-update = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", version = "=0.1.0", features = ["egui"] }
+craft-update = { git = "https://github.com/storytold/craft-libs", rev = "04aa1703b32d299e54f78fcde4182f2b393a9116", version = "=0.1.0", features = ["egui"] }

 # foundation
 thiserror = "2"
@@ -48,13 +47,6 @@ aes = { version = "0.9", default-features = false }
 sha1 = { version = "0.11", default-features = false }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }

-# equations: RaTeX (MIT) lays LaTeX out as positioned glyphs, rules and paths. Exact pins: it is
-# young (0.1.x), and the gate recorded in docs/decisions.md vetted this release.
-ratex-parser = "=0.1.14"
-ratex-layout = "=0.1.14"
-ratex-types = "=0.1.14"
-ratex-font = "=0.1.14"
-
 # ui
 egui = "0.37"
 egui_extras = { version = "0.37", default-features = false }
@@ -71,7 +63,7 @@ skrifa = { version = "0.44", default-features = false, features = ["std"] }
 epaint_default_fonts = "0.37"
 # One native window per workbook: the window list, Window menu titles and the immediate-viewport
 # driver. Same craft-libs revision as craft-update above.
-craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", default-features = false, features = ["egui"] }
+craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", default-features = false, features = ["egui"] }

 [workspace.lints.rust]
 unsafe_code = "forbid"
@@ -274,34 +274,3 @@ INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
 DEALINGS IN THE FONT SOFTWARE.
-
-Linux Wayland window decorations
-------------------------------
-sctk-adwaita 0.10.1 (https://github.com/PolyMeilex/sctk-adwaita,
-commit d5f343c45c04d4a026db57f76760819b7325db00) is used by winit on Linux
-for vector window controls. Its title-font features are disabled: no Cantarell
-font is embedded by this dependency and no font file is added to this repo.
-
-sctk-adwaita's MIT licence:
-
-MIT License
-
-Copyright (c) 2022 Bartłomiej Maryńczak
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
@@ -298,15 +298,7 @@ stand on its own.
 | <img src="https://raw.githubusercontent.com/storytold/pdfcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.pdfcraft.png" alt="" width="32" height="32"> | **PdfCraft** | Reading, organizing and protecting PDFs | [GitHub](https://github.com/storytold/pdfcraft) | [Website](https://getartcraft.com/apps/pdfcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/effectcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.effectcraft.png" alt="" width="32" height="32"> | **EffectCraft** | Motion graphics and visual effects | [GitHub](https://github.com/storytold/effectcraft) | [Website](https://getartcraft.com/apps/effectcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/designcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.designcraft.png" alt="" width="32" height="32"> | **DesignCraft** | Page layout and publishing | [GitHub](https://github.com/storytold/designcraft) | [Website](https://getartcraft.com/apps/designcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/figcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.figcraft.png" alt="" width="32" height="32"> | **FigCraft** | Interface design and prototyping | [GitHub](https://github.com/storytold/figcraft) | [Website](https://getartcraft.com/apps/figcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/wordcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.wordcraft.png" alt="" width="32" height="32"> | **WordCraft** | Word processing and documents | [GitHub](https://github.com/storytold/wordcraft) | [Website](https://getartcraft.com/apps/wordcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/soundcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.soundcraft.png" alt="" width="32" height="32"> | **SoundCraft** | Audio recording and editing | [GitHub](https://github.com/storytold/soundcraft) | [Website](https://getartcraft.com/apps/soundcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/deckcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.deckcraft.png" alt="" width="32" height="32"> | **DeckCraft** | Presentations and slide decks | [GitHub](https://github.com/storytold/deckcraft) | [Website](https://getartcraft.com/apps/deckcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/cadcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.cadcraft.png" alt="" width="32" height="32"> | **CADCraft** | Computer-aided design | [GitHub](https://github.com/storytold/cadcraft) | [Website](https://getartcraft.com/apps/cadcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/gridcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.gridcraft.png" alt="" width="32" height="32"> | **GridCraft** | Spreadsheets and data | [GitHub](https://github.com/storytold/gridcraft) | [Website](https://getartcraft.com/apps/gridcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/texturecraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.texturecraft.png" alt="" width="32" height="32"> | **TextureCraft** | 3D texture painting | [GitHub](https://github.com/storytold/texturecraft) | [Website](https://getartcraft.com/apps/texturecraft) |
-| <img src="https://raw.githubusercontent.com/storytold/craft-anything/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.craft-anything.png" alt="" width="32" height="32"> | **Craft Anything** | See how any software works, then build your own | [GitHub](https://github.com/storytold/craft-anything) | [Website](https://getartcraft.com/apps/craft-anything) |
-| <img src="https://raw.githubusercontent.com/tangency-labs/solidcraft/main/assets/icons/app/linux/exports/hicolor/64x64/apps/io.tangencylabs.solidcraft.png" alt="" width="32" height="32"> | **SolidCraft** | Parametric 3D CAD by Tangency Labs (community app) | [GitHub](https://github.com/tangency-labs/solidcraft) | |
+| <img src="https://raw.githubusercontent.com/storytold/gridcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.gridcraft.png" alt="" width="32" height="32"> | **GridCraft** | **Spreadsheets and data · you are here** | [GitHub](https://github.com/storytold/gridcraft) | [Website](https://getartcraft.com/apps/gridcraft) |

 And [**ArtCraft**](https://getartcraft.com/) itself, our AI image and video studio for artists who want real control.

@@ -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-10-11 · **Last updated:** 2026-10-25 · **Change:** minor (AutoSum over a selected row puts its total to the right, and fills a selection's empty last row and column; earlier: macro engine and `macro.*` commands; macro interface on the Automate tab) · **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 276 / 292 (94.5%), 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,19 +135,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in

 | Date | What landed |
 |---|---|
-| 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 |
-| 2026-11-02 | Equations: Insert › Equation (a split button with a gallery of examples) and an editor with quick-insert buttons, the error underlined at its position and a live preview; `insert.equation` and `equation.edit`; LaTeX laid out by RaTeX inside the new `gridcraft-math` crate, capped and panic-guarded, and cached on the shape so that painting never runs the layout engine; xlsx writes Office Math with a plain-text fallback and the source in `descr`, and reads Office Math back into LaTeX; PDF prints equations with the standard Symbol font and `[?]` for anything else |
-| 2026-11-02 | Solver writes a Sensitivity report: Simplex LP shadow prices, reduced costs and allowable ranges from the final tableau; GRG Nonlinear reduced gradients and Lagrange multipliers from difference gradients, at a Karush-Kuhn-Tucker point only; Solver Results offers it where it applies (no score change) |
-| 2026-11-02 | Floating objects: charts, pictures, shapes and slicers share one selection with a frame of eight resize handles (each moves only its own edges, also on right-to-left sheets); Delete or Backspace deletes the selected object and Escape drops the selection; slicers follow row and column edits and sorts like the other objects; chart series follow cut-moves and sheet renames and deletes; a copied sheet gives its objects fresh ids; `ui.inspect` reports `selectedObject` and `ui.object.select` selects any object (#190, #213) |
-| 2026-11-01 | Chart data tables are available from Chart Design › Add Chart Element and Format Chart Area. Tables follow live source values and number formats, keep blank cells blank, offer legend keys and border settings, and survive XLSX save/reopen; the shared renderer includes them in print and PDF. Readiness estimates unchanged. |
-| 2026-11-01 | XLSX keeps the first visible workbook window's active sheet and display settings together, falling back to the first view when all are hidden. Tab ratios are normalized to 0–1000 on import and export; invalid numeric text uses 600. Synthetic round trips cover isolated attributes, missing views, and active tabs after sheet deletion/reordering; firstSheet remains separate #2264 work (#3057). |
-| 2026-10-31 | Esc in File › Info, Print or Options first leaves the text field; the next Esc returns to the sheet (#3035) |
-| 2026-10-31 | CSV and text open detects each column's date order: a value that reads only day first (`31/05/2026`) makes the column day first, a value that reads only month first (`12/31/2026`) makes it month first, an all-ambiguous column keeps month first with a warning, and a column with both kinds stays text with a warning (#2765) |
-| 2026-10-31 | Recently Used lists the functions most recently entered in a formula from any source (ribbon, control channel, MCP, scripts), kept with the preferences and returned by `formulas.recentlyUsed`; the Insert Function dialog takes Excel's title and a working category list (Most Recently Used, All, each category) |
-| 2026-10-31 | Formulas › Function Library as a big Insert Function button, the AutoSum split button and three columns of labelled small buttons, each category book in its own colour; category menus end with Insert Function… on that category; More Functions cascades into the remaining categories; Home › Editing shares the AutoSum menu; the MR key tip opens Recently Used |
 | 2026-10-25 | AutoSum over a selection does what Excel does: a selected row gets one total to its right (in its last cell if that is empty), not a one-cell total under each cell; a block whose last column is empty gets each row's total there, one whose last row is empty each column's, and with both the corner gets the total of the block; otherwise totals go under each column as before |
 | 2026-10-24 | Macro interface ([macros.md](docs/macros.md#in-the-window)): an Automate › Macros group (Record Macro, which turns into Stop Recording, Use Relative References, Run Macro with recent macros); "Recording · N steps" with Stop in the status bar; a Record Macro dialog (checked name, free Ctrl+Shift shortcut, description); the Macros dialog lists macros beside Automate scripts and a VBA project, with Run, Step Into, Edit, Create, Delete and Options; Ctrl+Shift+letter macro shortcuts; questions that offer Run, Overwrite, Shift Down or Shift Right; a step editor with a breakpoint gutter, drag to reorder, a command picker, reference boxes that switch between relative tokens and absolute references, Inputs and Output tabs, a debug bar (Check, Run, Step, Continue, Run to Here, Stop with keep or undo) and grid overlays for inputs, writes, conflicts and the current step |
 | 2026-10-24 | Go To lists the named ranges of every sheet (`Sheet2!Name` for a name scoped to another sheet; hidden names, constants and formulas left out) and the references entered before, a double-click goes to an entry, and the Reference box takes several names or references separated by commas (`Price, Type`, `B14:C22,F19:G30`) |
@@ -177,11 +164,9 @@ 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) |
-| 2026-10-14 | `.xls` (Excel 97-2003) files open with their formatting: fonts, solid and pattern fills, borders (with diagonals), alignment (rotation, indent, wrap, shrink), locked and hidden cells, the workbook's custom colour palette, its Normal font and its user-defined cell styles |
 | 2026-10-14 | XLSX: formulas opened with dynamic-array metadata (`cm`) keep it on save, with `xl/metadata.xml`. Before, a formula returning one value lost it (11 of 40 corpus files that have the part lost it entirely), and Excel recalculated some of them with implicit intersection (`SUMPRODUCT(IFERROR(...))` changed value) |
 | 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 |
@@ -248,7 +233,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 | 2026-10-11 | PivotCharts (`insert.pivotChart`): charts bound to a PivotTable's report, following refreshes and layout changes (#311) |
 | 2026-10-11 | FORECAST.ETS, FORECAST.ETS.CONFINT, FORECAST.ETS.SEASONALITY, FORECAST.ETS.STAT: AAA exponential smoothing forecasts (#314) |
 | 2026-10-11 | File tab Backstage view (Home, New, Open, Info, Save As, Print preview, Export, Options) and `file.options` (#174) |
-| 2026-10-10 | Ribbon translated into Japanese, Chinese, Korean, Brazilian Portuguese and Russian with system-language default (#31, #104, #82); CJK/Thai/Hebrew font fallback (#38); clear messages for encrypted and `.xls` files (#17); smooth line charts (#62). Progress docs restructured; full re-measure (this page). Initial ribbon key tips (#43), in-place text box editing (#84), copy as HTML table (#36). ODS and XLSB data import (#100, #101); recalc linear in the number of range formulas (#66); RISC-V Linux build; Flatpak repository on Pages; web cell-commit trap fixed |
+| 2026-10-10 | Ribbon translated into Japanese, Chinese, Korean, Brazilian Portuguese and Russian with system-language default (#31, #104, #82); CJK/Thai/Hebrew font fallback (#38); clear messages for encrypted and `.xls` files (#17); smooth line charts (#62). Progress docs restructured to the craftrules standard; full re-measure (this page). Initial ribbon key tips (#43), in-place text box editing (#84), copy as HTML table (#36). ODS and XLSB data import (#100, #101); recalc linear in the number of range formulas (#66); RISC-V Linux build; Flatpak repository on Pages; web cell-commit trap fixed |
 | 2026-10-09 | Community fixes: spill range operator `A1#`, sheet-scoped names, protection refuses locked-cell edits, Insert/Delete Cells adjust references, `DATE(1900,2,29)`, SUMIF sizing, `ROUND` at 15 digits, `_xlpm.` LAMBDA parameters in XLSX, vertical scrollbar, system appearance, border previews; v0.4.0 |
 | 2026-10-08 | v0.2.0 and v0.3.0 releases; Flatpak, AppImage zsync, branded DMG; desktop log file; DirectX 12 default on Windows |
 | 2026-10-07 | About window with contributor and model credits; macOS release runner |
@@ -259,18 +244,6 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in

 | Date | Change | Summary |
 |---|---|---|
-| 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 |
-| 2026-11-02 | minor | Progress log: equations (Insert › Equation, the editor, gridcraft-math) |
-| 2026-11-02 | minor | What-if and analysis: Solver Sensitivity report for Simplex LP and GRG Nonlinear (no score change) |
-| 2026-11-02 | minor | Progress log: one selection and eight resize handles for every floating object |
-| 2026-11-01 | minor | Chart data tables are available from Chart Design › Add Chart Element and Format Chart Area. Tables follow live source values and number formats, keep blank cells blank, offer legend keys and border settings, and survive XLSX save/reopen; the shared renderer includes them in print and PDF. Readiness estimates unchanged. |
-| 2026-11-01 | trivial | Workbook views: selected window settings stay together, tab ratios are bounded, and regressions cover isolated settings and sheet edits; readiness estimates unchanged (#3057) |
-| 2026-10-31 | minor | File-page text fields keep the view open when Esc cancels an edit (#3035) |
-| 2026-10-31 | minor | Progress log: Recently Used and Insert Function categories |
-| 2026-10-31 | minor | Progress log: Function Library |
 | 2026-10-25 | minor | Progress log: AutoSum over a selected row, and a selection's empty last row and column |
 | 2026-10-24 | minor | Macro interface on the Automate tab; progress log row |
 | 2026-10-24 | minor | Macro engine and `macro.*` commands; catalog 275 / 291 → 276 / 292 (View › Macros › Record Macro); progress log row |
@@ -289,8 +262,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 |
 | 2026-10-14 | minor | XLSX dynamic-array `cm` metadata kept on save; progress log row |
@@ -325,5 +296,5 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in
 | 2026-10-10 | minor | Readiness-by-audience table with hours to ~95% per audience; full number unchanged (additive weighted sum) |
 | 2026-10-10 | minor | Added Mainstream practitioner (~50%) and Essentials user (~63%); languages updated for the 10-10 merges (ribbon in ja, zh, ko, pt-BR, ru); localization 5%→10%; full number re-checked (51.6, unchanged) |
 | 2026-10-10 | minor | Checked against the alpha gate (six core workflows pass): stays alpha |
-| 2026-10-10 | major | Re-measured against Excel for Mac 16.113.4: stage alpha, breadth ~75%, ready ~50%, ~160–240 h to beta, ~700–1,100 h to full parity; progress docs restructured; detail moved to `docs/` |
+| 2026-10-10 | major | Re-measured against Excel for Mac 16.113.4: stage alpha, breadth ~75%, ready ~50%, ~160–240 h to beta, ~700–1,100 h to full parity; restructured to the progress-docs standard; detail moved to `docs/` |
 | 2026-10-07 | major | First estimates: catalog 89%, functions ~93%, depth ~65%, ~35 h to alpha, ~215 h to full parity |
@@ -31,41 +31,20 @@ fn is_volatile(e: &Expr, volatile_names: &HashSet<String>) -> bool {
 }

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

-/// Decompressed bytes that comparing one package's relationship kinds may read in total: the
-/// relationship parts themselves and the targets whose content is checked.
-const RELATIONSHIP_BUDGET: u64 = 512 * 1024 * 1024;
-
 /// Relationship kinds (lower case) whose absence after a save isn't a loss: the calculation chain is
 /// a cache Excel rebuilds, and GridCraft never writes it.
 pub(super) const REBUILT_KINDS: [&str; 1] = ["calcchain"];
@@ -121,30 +117,6 @@ fn read_zip_part(zip: &mut Zip<'_>, name: &str) -> Result<Vec<u8>, String> {
    Ok(buf)
 }

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

-#[test]
-fn volatile_names_propagate_through_a_long_chain_in_one_walk() {
-    // Chain0 uses Chain1, Chain1 uses Chain2, ... and only the last is volatile: listed in this order, a rescan
-    // until nothing changes marked one name per pass (quadratic). Every name in the chain is
-    // volatile; a name off the chain is not.
-    const LEN: usize = 5_000;
-    let mut wb = book(&[("A1", "=1", n(1.0))]);
-    let name =
-        |name: String, formula: String| gridcraft_engine::model::DefinedName { name, scope: None, formula, comment: String::new(), hidden: false };
-    for i in 0..LEN {
-        let formula = if i + 1 == LEN { "NOW()".to_string() } else { format!("Chain{}+1", i + 1) };
-        wb.names.push(name(format!("Chain{i}"), formula));
-    }
-    wb.names.push(name("Plain".into(), "Chain0*0+Other".into()));
-    wb.names.push(name("Other".into(), "1".into()));
-    let set = volatile_names(&wb);
-    assert!((0..LEN).all(|i| set.contains(&format!("CHAIN{i}"))));
-    assert!(set.contains("PLAIN"));
-    assert!(!set.contains("OTHER"));
-    assert_eq!(set.len(), LEN + 1);
-}
-
 #[test]
 fn round_trip_of_a_simple_book_is_clean() {
    let mut wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("A2", "x", Value::text("x"))]);
@@ -16,8 +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.
-craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "2e2312ddaf21bc3d85cd3395d0955c7d239306f6", version = "0.1.0" }
 egui = { workspace = true }
 log = { workspace = true }
 serde_json = { workspace = true }
@@ -28,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"] }
@@ -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
+    }
 }
@@ -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");
-    }
-}
@@ -10,19 +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.
-//! `?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(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;
@@ -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}));
@@ -196,7 +193,7 @@ fn services(inbox: Inbox, ctx: egui::Context) -> Services {
            let ctx = ctx.clone();
            wasm_bindgen_futures::spawn_local(async move {
                let Some(file) = rfd::AsyncFileDialog::new()
-                    .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "slk", "json"])
+                    .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"])
                    .pick_file()
                    .await
                else {
@@ -24,26 +24,22 @@ chrono = { workspace = true }
 # Icon + VERSIONINFO for gridcraft.exe; build.rs only uses it when the target is Windows.
 winresource = "0.1"

-[target.'cfg(all(unix, not(any(target_os = "macos", target_os = "linux"))))'.dependencies]
+[target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
 winit = { version = "0.30", default-features = false, features = ["x11"] }

-[target.'cfg(target_os = "linux")'.dependencies]
-# Retain X11 fallback; draw Wayland client-side controls without bundled title fonts.
-winit = { version = "0.30", default-features = false, features = ["x11", "wayland-csd-adwaita-notitle"] }
-
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Same craft-libs revision as the workspace's craft-update and craft-window (see the root
 # Cargo.toml).
-craft-print = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7" }
+craft-print = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
 craft-update = { workspace = true }
 rfd = { workspace = true }
-arboard = { workspace = true, features = ["image-data"] }
+arboard = { workspace = true }
 gridcraft-mcp = { workspace = true }
 # The control channel's token (OS random numbers); already in the tree.
 getrandom = "0.4"

 [target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]
-arboard = { workspace = true, features = ["image-data", "wayland-data-control"] }
+arboard = { workspace = true, features = ["wayland-data-control"] }

 [target.'cfg(target_os = "windows")'.dependencies]
 # Blocks on the start-up DirectX 12 adapter probe (`graphics.rs`); already in the tree via eframe.
@@ -56,10 +52,6 @@ muda = { version = "0.21", default-features = false }
 # by PdfCraft and PhotoCraft) registers the handler (Objective-C interop needs unsafe, which our
 # workspace forbids) behind a safe API. Pinned exactly: review the diff before bumping.
 fmv-macos-events = "=0.1.0"
-# apple_events.rs brings the app forward for a Dock quit's question. Already in Cargo.lock (muda,
-# winit); pinned exactly to the same versions.
-objc2 = "=0.6.5"
-objc2-app-kit = { version = "=0.3.2", default-features = false, features = ["std", "NSApplication", "NSResponder", "NSWindow"] }

 # tests/mac_menu_appkit.rs: reads AppKit's menu bar back. Already in Cargo.lock (muda, winit);
 # pinned exactly to the same versions.
@@ -11,8 +11,6 @@

 use fmv_macos_events::{Event, Inbox, Registration};
 use gridcraft_ui_egui::SheetApp;
-use objc2::MainThreadMarker;
-use objc2_app_kit::{NSApplication, NSRequestUserAttentionType};

 /// Keeps the Apple-event handlers registered; hold it until the event loop returns.
 pub struct AppleEvents {
@@ -46,32 +44,7 @@ pub fn poll(inbox: &Inbox, app: &mut SheetApp, ctx: &egui::Context) {
                }
            }
            // Quit from the Dock or the system: each unsaved workbook is asked about in its window.
-            Event::Quit => {
-                app.request_quit(ctx);
-                if app.dialog.is_some() {
-                    bring_app_forward();
-                }
-            }
+            Event::Quit => app.request_quit(ctx),
        }
    }
 }
-
-/// A Dock quit reaches GridCraft behind other apps, hidden or minimized, and its question has to
-/// be seen. egui's Focus goes through winit, which skips a minimized window or a hidden app, and
-/// macOS may refuse an activation it didn't expect, so ask AppKit directly and bounce the Dock
-/// icon until the user switches over.
-fn bring_app_forward() {
-    let Some(mtm) = MainThreadMarker::new() else { return };
-    let ns_app = NSApplication::sharedApplication(mtm);
-    ns_app.unhide(None);
-    for window in ns_app.windows().to_vec() {
-        if window.isMiniaturized() {
-            window.deminiaturize(None);
-        }
-    }
-    #[allow(deprecated)] // `activate` needs macOS 14; this works on every supported version.
-    ns_app.activateIgnoringOtherApps(true);
-    if !ns_app.isActive() {
-        ns_app.requestUserAttention(NSRequestUserAttentionType::CriticalRequest);
-    }
-}
@@ -1,5 +1,4 @@
-//! Graphics instance configuration, applied before wgpu can initialize any driver: Windows
-//! backends and the DirectX 12 shader compiler, and the Intel Mac indirect-validation skip.
+//! Windows graphics instance configuration, applied before wgpu can initialize any driver.
 //!
 //! Vulkan is never initialized unless `WGPU_BACKEND` asks for it: enumerating Vulkan adapters
 //! crashes inside Intel's `igvk64.dll` on some UHD Graphics drivers (#120), and that access
@@ -9,38 +8,12 @@
 //! whichever `dxcompiler.dll` the DLL search path happens to find (#339, #354): see
 //! [`dx12_compiler`].

-// On macOS only the indirect-validation items are used outside tests; on Windows the other way
-// round, so those two carry their own `allow`.
-#![cfg_attr(target_os = "macos", allow(dead_code))]
-
 use eframe::{
    NativeOptions,
    egui_wgpu::WgpuSetup,
-    wgpu::{Backends, DeviceType, Dx12Compiler, InstanceFlags},
+    wgpu::{Backends, DeviceType, Dx12Compiler},
 };

-/// wgpu compiles its indirect-call validation compute shaders inside `request_device`. On Intel
-/// Macs (Iris 5100 in a Mac mini 2014) Metal's compiler aborts on them ("Compiler encountered an
-/// internal error"), the device is lost and eframe exits before the window opens. GridCraft issues
-/// no indirect draws or dispatches, so Intel Macs skip them; every other GPU keeps wgpu's default.
-/// Same as WordCraft (storytold/wordcraft#2652) and PhotoCraft (storytold/PhotoCraft#3171).
-#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
-pub fn skips_indirect_validation(macos: bool, intel: bool) -> bool {
-    macos && intel
-}
-
-/// Leaves wgpu's indirect-call validation out of the instance eframe creates when `skip`.
-/// `WGPU_VALIDATION_INDIRECT_CALL=1` still turns it back on.
-#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
-pub fn configure_indirect_validation(options: &mut NativeOptions, skip: bool) {
-    if !skip {
-        return;
-    }
-    if let WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup {
-        create.instance_descriptor.flags = create.instance_descriptor.flags.difference(InstanceFlags::VALIDATION_INDIRECT_CALL).with_env();
-    }
-}
-
 /// What the start-up probe learned about one DirectX 12 adapter.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Dx12Adapter {
@@ -168,55 +141,6 @@ fn probe_dx12(options: &NativeOptions) -> Vec<Dx12Adapter> {
 mod tests {
    use super::*;

-    fn instance_flags(options: &NativeOptions) -> InstanceFlags {
-        let WgpuSetup::CreateNew(create) = &options.wgpu_options.wgpu_setup else {
-            panic!("default native options must create a wgpu instance");
-        };
-        create.instance_descriptor.flags
-    }
-
-    #[test]
-    fn intel_macs_skip_the_indirect_validation_shaders() {
-        // Metal's Intel compiler aborted on them, losing the device before the window opened.
-        assert!(skips_indirect_validation(true, true));
-        // Apple silicon, Windows and Linux keep wgpu's validation.
-        for (macos, intel) in [(true, false), (false, true), (false, false)] {
-            assert!(!skips_indirect_validation(macos, intel), "macos={macos} intel={intel}");
-        }
-        let mut options = NativeOptions::default();
-        let before = instance_flags(&options);
-        configure_indirect_validation(&mut options, false);
-        assert_eq!(instance_flags(&options), before, "flags untouched when not skipping");
-        if std::env::var_os("WGPU_VALIDATION_INDIRECT_CALL").is_none() {
-            configure_indirect_validation(&mut options, true);
-            assert!(!instance_flags(&options).contains(InstanceFlags::VALIDATION_INDIRECT_CALL));
-        }
-    }
-
-    /// `WGPU_VALIDATION_INDIRECT_CALL=1` turns the validation back on even when it is skipped.
-    /// Tests can't set environment variables (`set_var` is unsafe, and unsafe code is forbidden),
-    /// so this runs itself again as a child process with the variable set.
-    #[test]
-    fn the_environment_turns_indirect_validation_back_on() {
-        const NAME: &str = "graphics::tests::the_environment_turns_indirect_validation_back_on";
-        if std::env::var_os("GRIDCRAFT_INDIRECT_VALIDATION_CHILD").is_some() {
-            let mut options = NativeOptions::default();
-            configure_indirect_validation(&mut options, true);
-            assert!(instance_flags(&options).contains(InstanceFlags::VALIDATION_INDIRECT_CALL));
-            return;
-        }
-        let exe = std::env::current_exe().unwrap();
-        let out = std::process::Command::new(exe)
-            .args(["--exact", NAME, "--test-threads=1"])
-            .env("GRIDCRAFT_INDIRECT_VALIDATION_CHILD", "1")
-            .env("WGPU_VALIDATION_INDIRECT_CALL", "1")
-            .output()
-            .unwrap();
-        let stdout = String::from_utf8_lossy(&out.stdout);
-        // `--exact` matching nothing would pass too, so the child must report this one test.
-        assert!(out.status.success() && stdout.contains("1 passed"), "child test failed:\n{stdout}{}", String::from_utf8_lossy(&out.stderr));
-    }
-
    fn configured_backends(backends: Backends) -> Backends {
        let mut options = NativeOptions::default();
        configure_backends(&mut options, backends);
@@ -12,7 +12,7 @@
 #[cfg(target_os = "macos")]
 mod apple_events;
 mod control_server;
-#[cfg(any(target_os = "windows", target_os = "macos", test))]
+#[cfg(any(target_os = "windows", test))]
 mod graphics;
 mod logging;
 #[cfg(target_os = "macos")]
@@ -154,7 +154,7 @@ fn read_clipboard<T>(
 fn services() -> Services {
    // Keep the owner alive: X11/Wayland serve clipboard data from this handle.
    let clipboard: Rc<RefCell<Option<arboard::Clipboard>>> = Rc::default();
-    let (html_clipboard, text_clipboard, image_clipboard) = (clipboard.clone(), clipboard.clone(), clipboard.clone());
+    let (html_clipboard, text_clipboard) = (clipboard.clone(), clipboard.clone());
    Services {
        copy_html: Some(Box::new(move |html, text| {
            let mut clipboard = clipboard.borrow_mut();
@@ -165,13 +165,9 @@ fn services() -> Services {
        })),
        paste_html: Some(Box::new(move || read_clipboard(&html_clipboard, |clipboard| clipboard.get().html()))),
        paste_text: Some(Box::new(move || read_clipboard(&text_clipboard, |clipboard| clipboard.get_text()))),
-        paste_image: Some(Box::new(move || {
-            let image = read_clipboard(&image_clipboard, |clipboard| clipboard.get_image())?;
-            image::RgbaImage::from_raw(u32::try_from(image.width).ok()?, u32::try_from(image.height).ok()?, image.bytes.into_owned())
-        })),
        pick_open: Some(Box::new(|| {
            rfd::FileDialog::new()
-                .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "slk", "json"])
+                .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"])
                .add_filter("Excel Workbook", &["xlsx", "xlsm"])
                .add_filter("Excel 97-2003 Workbook (import)", &["xls"])
                .add_filter("Excel Binary Workbook (data import)", &["xlsb"])
@@ -345,11 +341,8 @@ fn main() -> eframe::Result<()> {
    }
    let window_builder = viewport.clone();
    let options = eframe::NativeOptions { viewport, ..Default::default() };
-    #[cfg(unix)]
+    #[cfg(all(unix, not(target_os = "macos")))]
    let mut options = options;
-    // Intel Macs: Metal's compiler aborts on wgpu's indirect-validation shaders (see graphics.rs).
-    #[cfg(target_os = "macos")]
-    graphics::configure_indirect_validation(&mut options, graphics::skips_indirect_validation(true, cfg!(target_arch = "x86_64")));
    // winit has no file drag-and-drop on Wayland (only on X11), so dropping files from the file
    // manager showed a "no" cursor. Run through XWayland when it's there; GRIDCRAFT_WAYLAND=1
    // keeps the native Wayland backend.
@@ -1,7 +1,7 @@
 # GridCraft app icon (PLACEHOLDER)

 **This icon is temporary.** Every Crafting App's icon is an engraved creature portrait that the
-product owner makes; GridCraft's hasn't been made yet.
+product owner makes (craftrules `standards/icon-design.md`); GridCraft's hasn't been made yet.
 Until it is, this placeholder stands in: a simple ledger page with a header row, a row-number
 column, a selected cell with its fill handle and a double rule under a total, on a full-bleed
 GridCraft-green tile. It is original geometry written by hand for this repository, deliberately
@@ -1,7 +1,7 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
  <!-- GridCraft PLACEHOLDER icon: a ledger page with a selected cell, on GridCraft green.
       Original work; temporary until the owner's engraved creature portrait replaces it
-       Palette: ink #0b0b0c, paper #efe9dc,
+       (craftrules standards/icon-design.md). Palette: ink #0b0b0c, paper #efe9dc,
       app colour #1f9d55 (proposed). -->
  <defs>
    <clipPath id="tile"><rect width="512" height="512" rx="112"/></clipPath>
@@ -1,7 +1,7 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
  <!-- GridCraft PLACEHOLDER icon: a ledger page with a selected cell, on GridCraft green.
       Original work; temporary until the owner's engraved creature portrait replaces it
-       Palette: ink #0b0b0c, paper #efe9dc,
+       (craftrules standards/icon-design.md). Palette: ink #0b0b0c, paper #efe9dc,
       app colour #1f9d55 (proposed). -->
  <defs>
    <clipPath id="tile"><rect width="512" height="512" rx="112"/></clipPath>
@@ -1,10 +1,13 @@
-# Contributor names for the About window.
+# Contributor names for the About window (craftrules standards/contributors.md).
 #
 # Everyone who contributes is credited by GitHub username automatically. Anything more is up to
 # you: add YOUR OWN entry below, in your own PR (commit it yourself). Never add someone else; a
 # maintainer may add a person only when that person asked, recording where in consent_source.
 #
-# Copy this block, replacing your-github-username (every field is optional):
+# Easiest: python3 ../../craftrules/scripts/contributors.py --add-me . \
+#            [--real-name "Ada Lovelace"] [--display-name "Ada"] [--sync-github-name]
+#
+# Or copy this block, replacing your-github-username (every field is optional):
 #
 #   [people.your-github-username]
 #   real_name = "Your Name"        # shown when the viewer picks "Real name"
@@ -106,6 +109,3 @@ sync_github_name = true

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

-/// [`zip2`] that stops at the first cell `f` refuses (`None`), before the rest is built: the
-/// result grows as cells are made rather than being reserved for the whole broadcast up front.
-fn try_zip2(a: &Value, b: &Value, mut f: impl FnMut(&Value, &Value) -> Option<Value>) -> Option<Value> {
-    Some(match (a, b) {
-        (Value::Array(x), Value::Array(y)) => {
-            let rows = broadcast_dim(x.rows, y.rows);
-            let cols = broadcast_dim(x.cols, y.cols);
-            if broadcast_len(rows, cols).is_none() {
-                return Some(Value::Error(CellError::Num));
-            }
-            let mut data = Vec::new();
-            for r in 0..rows {
-                for c in 0..cols {
-                    data.push(f(&x.get_broadcast(r, c), &y.get_broadcast(r, c))?);
-                }
-            }
-            Value::from(Array { rows, cols, data })
-        }
-        (Value::Array(x), s) => Value::from(Array { rows: x.rows, cols: x.cols, data: x.data.iter().map(|v| f(v, s)).collect::<Option<_>>()? }),
-        (s, Value::Array(y)) => Value::from(Array { rows: y.rows, cols: y.cols, data: y.data.iter().map(|v| f(s, v)).collect::<Option<_>>()? }),
-        (x, y) => f(x, y)?,
-    })
-}
-
 /// Cell count of a `rows`×`cols` broadcast result, or `None` when it would exceed [`MAX_CELLS`].
 /// Each operand passes its own size cap, but their broadcast product can be far larger
 /// (`SEQUENCE(1048576)*SEQUENCE(1,16384)` is 17 billion cells), so it is checked before allocating.
-/// The product is formed in `u64`: on wasm32 `usize` is 32 bits, where a `usize` product above
-/// `u32::MAX` would wrap (2^32 cells → 0) and slip past the cap.
 pub(super) fn broadcast_len(rows: usize, cols: usize) -> Option<usize> {
-    let cells = u64::try_from(rows).ok()?.checked_mul(u64::try_from(cols).ok()?)?;
-    if cells > MAX_CELLS {
-        return None;
-    }
-    usize::try_from(cells).ok()
+    rows.checked_mul(cols).filter(|&n| n as u64 <= MAX_CELLS)
 }

 fn broadcast_dim(a: usize, b: usize) -> usize {
@@ -154,41 +124,15 @@ pub(super) fn zip3(c: &Array, t: &Value, f: &Value, g: impl Fn(&Value, &Value, &
 /// can't nest, so the whole helper gives `#CALC!`, as in Excel.
 pub(super) fn single(v: Value) -> Option<Value> {
    match v {
-        Value::Array(a) if a.data.len() > 1 => None,
+        Value::Array(a) if a.rows * a.cols > 1 => None,
        v => Some(v.scalar()),
    }
 }

-/// Text bytes that one `&` over arrays may produce in all. Each piece is capped on its own, but a
-/// compact formula can broadcast a long text across millions of cells
-/// (`SEQUENCE(4000,4000)&REPT("x",30000)` is 480 GB): past this the whole result is `#NUM!`, the
-/// error for a result too large to hold, before the rest is built.
-pub(super) const MAX_CONCAT_ARRAY_BYTES: usize = 512 * 1024 * 1024;
-
 pub fn binary_values(op: BinOp, x: &Value, y: &Value, sys: gridcraft_core::DateSystem) -> Value {
-    if op == BinOp::Concat && (matches!(x, Value::Array(_)) || matches!(y, Value::Array(_))) {
-        return concat_arrays(x, y, sys, MAX_CONCAT_ARRAY_BYTES);
-    }
    zip2(x, y, |a, b| binary_scalar(op, a, b, sys))
 }

-/// `x & y` with at least one array operand, giving `#NUM!` once the texts built so far pass `budget`
-/// bytes.
-fn concat_arrays(x: &Value, y: &Value, sys: gridcraft_core::DateSystem, budget: usize) -> Value {
-    let mut used = 0usize;
-    try_zip2(x, y, |a, b| {
-        let v = binary_scalar(BinOp::Concat, a, b, sys);
-        if let Value::Text(t) = &v {
-            used = used.saturating_add(t.len());
-            if used > budget {
-                return None;
-            }
-        }
-        Some(v)
-    })
-    .unwrap_or(Value::Error(CellError::Num))
-}
-
 fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSystem) -> Value {
    if let Value::Error(e) = a {
        return Value::Error(*e);
@@ -234,52 +178,3 @@ fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSyste
        BinOp::Range | BinOp::Union | BinOp::Intersect => Value::Error(CellError::Value),
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{Array, BinOp, CellError, MAX_CELLS, Value, broadcast_len, concat_arrays, try_zip2};
-
-    /// The broadcast stops at the first refused cell: nothing after it is visited.
-    #[test]
-    fn a_refused_cell_stops_the_broadcast() {
-        let col = Value::from(Array::column((0..4_000).map(|i| Value::number(i as f64)).collect()));
-        let row = Value::from(Array { rows: 1, cols: 4_000, data: (0..4_000).map(|i| Value::number(i as f64)).collect() });
-        let mut calls = 0;
-        let r = try_zip2(&col, &row, |a, _| {
-            calls += 1;
-            (calls <= 10).then(|| a.clone())
-        });
-        assert_eq!((r, calls), (None, 11));
-    }
-
-    #[test]
-    fn concatenating_arrays_stops_at_the_byte_budget() {
-        let sys = gridcraft_core::DateSystem::default();
-        let col = Value::from(Array::column((0..100).map(|i| Value::number(i as f64)).collect()));
-        let long = Value::text("x".repeat(100));
-        // 100 cells of 101 or 102 bytes each: about 10 KB in all.
-        let r = concat_arrays(&col, &long, sys, 20_000);
-        assert!(matches!(&r, Value::Array(a) if a.data.len() == 100), "{r:?}");
-        assert_eq!(concat_arrays(&col, &long, sys, 5_000), Value::Error(CellError::Num));
-        assert_eq!(concat_arrays(&long, &col, sys, 5_000), Value::Error(CellError::Num));
-        // Through the operator, a small result is unaffected.
-        let r = super::binary_values(BinOp::Concat, &col, &Value::text("a"), sys);
-        assert!(matches!(&r, Value::Array(a) if a.data.first() == Some(&Value::text("0a"))), "{r:?}");
-    }
-
-    #[test]
-    fn broadcast_len_caps_at_max_cells() {
-        assert_eq!(broadcast_len(4_000, 4_000), Some(MAX_CELLS as usize));
-        assert_eq!(broadcast_len(4_000, 4_001), None);
-        assert_eq!(broadcast_len(1, MAX_CELLS as usize), Some(MAX_CELLS as usize));
-    }
-
-    /// `65_536 * 65_536` is 2^32. Multiplied as `usize` on wasm32 it wraps to 0, which a
-    /// `> MAX_CELLS` test would let through; the guard must reject the true product.
-    #[test]
-    fn broadcast_len_rejects_a_product_that_wraps_to_zero_on_32_bits() {
-        assert_eq!(65_536u32.wrapping_mul(65_536), 0);
-        assert_eq!(broadcast_len(65_536, 65_536), None);
-        assert_eq!(broadcast_len(1_048_576, 16_384), None);
-    }
-}
@@ -4,12 +4,10 @@
 #![forbid(unsafe_code)]

 pub mod eval;
-mod precision;
 pub mod recalc;
 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)]
@@ -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,
-        }
-    }
-}
@@ -24,7 +24,7 @@ mod pass_host;
 #[cfg(test)]
 use graph::Intervals;
 pub use graph::{FxHasher, Graph, Key};
-use graph::{HashMap, HashSet, Node, Taken};
+use graph::{HashMap, HashSet, Node};
 use pass_host::{PassHost, spills_as_before};

 /// Calculation state kept beside a workbook.
@@ -135,10 +135,6 @@ impl Calc {
                    if cell.value == Value::Error(CellError::Circ) {
                        circ.push((si, c));
                    }
-                } else if cell.py.is_some() {
-                    // A Python cell lays out its kept result, so it is calculated like a formula
-                    // that reads nothing: its spill is blocked and unblocked like a formula's.
-                    self.graph.insert((si, c), Node { areas: Vec::new(), dynamic: false });
                }
            }
        }
@@ -210,29 +206,11 @@ impl Calc {
        let mut cleared: Vec<(usize, RangeRef)> = Vec::new();
        for &k in changed {
            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 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.
-                None if python => {
-                    self.graph.insert(k, Node { areas: Vec::new(), dynamic: false });
-                    // New code has no result yet: the spill the cell had (its old result's, or a
-                    // formula's) goes, and what read it is recalculated, as for a formula
-                    // replaced by a constant.
-                    if !spills
-                        && let Some(sh) = wb.sheet_mut(k.0)
-                        && let Some(r) = sh.spill_ranges.remove(&k.1)
-                    {
-                        sh.clear_spill(r);
-                        cleared.push((k.0, r));
-                    }
-                }
                None => {
                    self.graph.remove(k);
                    // A formula replaced by a constant (or cleared) takes its spilled values with it.
@@ -292,16 +270,17 @@ impl Calc {
                }
            }
        }
-        // Spill areas of changed anchors also change. They stay rectangles: one seed per spilled
-        // cell listed the formulas reading the area once per cell.
-        let mut areas: Vec<(usize, RangeRef)> = cleared;
+        // Spill areas of changed anchors also change.
        for &k in changed {
            if let Some(r) = wb.sheet(k.0).and_then(|s| s.spill_ranges.get(&k.1)) {
-                areas.push((k.0, *r));
+                seeds.extend(r.iter().map(|c| (k.0, c)));
            }
        }
+        for (si, r) in &cleared {
+            seeds.extend(r.iter().map(|c| (*si, c)));
+        }
        let t0 = prof_now();
-        let dirty = self.dirty_closure(wb, &seeds, &areas);
+        let dirty = self.dirty_closure(wb, &seeds);
        let t1 = prof_now();
        let n = dirty.len();
        self.run(wb, dirty, false);
@@ -310,39 +289,16 @@ impl Calc {
        }
    }

-    /// The formulas to recalculate after `seeds` and every cell of `areas` changed: the seeds
-    /// that are formulas, and everything that reads them, directly or through other formulas.
-    fn dirty_closure(&self, wb: &Workbook, seeds: &[Key], areas: &[(usize, RangeRef)]) -> Vec<Key> {
+    fn dirty_closure(&self, _wb: &Workbook, seeds: &[Key]) -> Vec<Key> {
        let mut seen: HashSet<Key> = HashSet::default();
        let mut queue: VecDeque<Key> = VecDeque::new();
-        // Each range-index entry is listed once in the whole walk: many changed cells under one
-        // broad reference (or many formulas inside one) would otherwise list every formula reading
-        // it once per cell, which squared the work.
-        let mut taken = Taken::default();
-        let mut deps = Vec::new();
        for k in seeds {
            if self.graph.nodes.contains_key(k) && seen.insert(*k) {
                queue.push_back(*k);
            }
-            deps.clear();
-            self.graph.dependents_untaken(k.0, k.1, &mut taken, &mut deps);
-            for d in deps.drain(..) {
-                if seen.insert(d) {
-                    queue.push_back(d);
-                }
-            }
-        }
-        for &(si, r) in areas {
-            if let Some(sh) = wb.sheet(si) {
-                for (c, _) in sh.cells.iter_range(r) {
-                    if self.graph.nodes.contains_key(&(si, c)) && seen.insert((si, c)) {
-                        queue.push_back((si, c));
-                    }
-                }
-            }
-            deps.clear();
-            self.graph.dependents_of_range(si, r, &mut deps);
-            for d in deps.drain(..) {
+            let mut deps = Vec::new();
+            self.graph.dependents(k.0, k.1, &mut deps);
+            for d in deps {
                if seen.insert(d) {
                    queue.push_back(d);
                }
@@ -353,9 +309,10 @@ impl Calc {
                queue.push_back(*k);
            }
        }
+        let mut deps = Vec::new();
        while let Some(k) = queue.pop_front() {
            deps.clear();
-            self.graph.dependents_untaken(k.0, k.1, &mut taken, &mut deps);
+            self.graph.dependents(k.0, k.1, &mut deps);
            for d in deps.drain(..) {
                if seen.insert(d) {
                    queue.push_back(d);
@@ -381,15 +338,11 @@ impl Calc {
                    exprs.insert(*k, e);
                }
            }
-            let python: HashMap<Key, Value> = dirty
-                .iter()
-                .filter_map(|k| wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.py.as_ref()).and_then(|p| p.result_value()).map(|v| (*k, v)))
-                .collect();
            let now = self.now();
            let mut rng = self.rng;
            let tp = prof_now();
            let (results, spills, cycles) = {
-                let mut host = PassHost::new(wb, &exprs, &mut rng, now).with_python(python);
+                let mut host = PassHost::new(wb, &exprs, &mut rng, now);
                host.iterate = wb.calc.iterative;
                for k in &dirty {
                    host.calculate(*k);
@@ -432,7 +385,7 @@ impl Calc {
            if spill_changes.is_empty() {
                break;
            }
-            dirty = self.dirty_closure(wb, &spill_changes, &[]);
+            dirty = self.dirty_closure(wb, &spill_changes);
        }
        // Loops among formulas the run did not evaluate stay listed while they are still formulas.
        // Iterative calculation reports none.
@@ -594,48 +547,6 @@ pub(crate) mod tests {
        v
    }

-    /// 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>) {
-        let n = 1_000usize;
-        let data: Vec<Value> = (0..n * n).map(|i| Value::Number(i as f64)).collect();
-        let array = gridcraft_core::Array::new(n, n, data.clone()).unwrap();
-        let mut wb = Workbook::new();
-        let sh = wb.sheet_mut(0).unwrap();
-        let anchor = CellRef::new(0, 0);
-        let py = gridcraft_model::PyCode::new("big");
-        sh.set_cell(anchor, Cell { value: Value::Number(0.0), py: Some(std::sync::Arc::new(py)), ..Cell::default() });
-        let area = RangeRef::new(anchor, CellRef::new(n as u32 - 1, n as u32 - 1));
-        sh.spill_ranges.insert(anchor, area);
-        for (i, c) in area.iter().enumerate().skip(1) {
-            sh.spill.insert(c, data[i].clone());
-        }
-        let mut python = HashMap::default();
-        python.insert((0, anchor), Value::Array(std::sync::Arc::new(array)));
-        (wb, python)
-    }
-
-    #[test]
-    fn a_read_beside_a_large_spill_walks_none_of_it() {
-        let (wb, python) = big_python_spill();
-        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, CellRef::new(0, 0)), Value::Number(0.0));
-        // Beside the spill (column ALM, the 1,001st), over the rows it covers.
-        let beside = RangeRef::parse("ALM1:ALM1000").unwrap();
-        host.spill_visits = 0;
-        assert!(host.range_values(0, beside).iter().all(Value::is_empty));
-        assert!(host.visit_range(0, beside, &mut |_| true), "a disjoint read takes the fast path");
-        assert_eq!(host.spill_visits, 0, "nothing of the spill is walked");
-        // A read inside it still sees the spilled values, walking only the cells it reads.
-        let inside = RangeRef::parse("B2:C3").unwrap();
-        host.spill_visits = 0;
-        assert_eq!(host.range_values(0, inside), [1_001.0, 1_002.0, 2_001.0, 2_002.0].map(Value::Number).to_vec());
-        assert!(host.spill_visits <= 8, "{}", host.spill_visits);
-        assert!(!host.visit_range(0, inside, &mut |_| true), "an overlapping read leaves the block to range_values");
-    }
-
    #[test]
    fn intervals_match_a_linear_scan() {
        let mut iv: Intervals<u32> = Intervals::default();
@@ -712,149 +623,6 @@ pub(crate) mod tests {
        assert!(visited < 64, "visited {visited} nodes for no match");
    }

-    #[test]
-    fn untaken_queries_list_each_interval_once_in_all() {
-        // 1,000 ranges over every row of 5,000: point queries at every row used to list all 1,000
-        // each time (5 million matches); sharing `taken`, each range is listed once in all.
-        let n = 5_000u32;
-        let mut iv: Intervals<u32> = Intervals::default();
-        for t in 0..1_000 {
-            iv.insert(0, n, t);
-        }
-        for r in 0..n {
-            iv.insert(r, r, 10_000 + r);
-        }
-        iv.settle();
-        let mut taken = Vec::new();
-        let mut listed = Vec::new();
-        for row in 0..=n + 3 {
-            iv.query_untaken(row, row, &mut taken, &mut |t| {
-                listed.push(*t);
-                true
-            });
-        }
-        listed.sort_unstable();
-        let want: Vec<u32> = (0..1_000).chain(10_000..10_000 + n).collect();
-        assert_eq!(listed, want);
-        // An entry the caller declines is offered again.
-        let mut taken = Vec::new();
-        let mut offered = 0;
-        for _ in 0..3 {
-            iv.query_untaken(7, 7, &mut taken, &mut |t| {
-                if *t == 10_007 {
-                    offered += 1;
-                }
-                *t != 10_007
-            });
-        }
-        assert_eq!(offered, 3);
-    }
-
-    #[test]
-    fn dirty_closure_matches_a_walk_of_every_cell() {
-        // Random formulas over single cells, narrow ranges and wide (over 64 columns) ranges, some
-        // removed or left unsettled: the closure equals the one found by listing every dependent
-        // of every changed cell, area cells included, as before `taken` and areas existed.
-        use super::{HashSet, Node};
-        use crate::eval::Area;
-        use std::collections::VecDeque;
-        let mut s = 0x2545_F491_4F6C_DD1D;
-        for case in 0..40 {
-            let mut wb = Workbook::new();
-            let mut calc = Calc::new();
-            let pick = |s: &mut u64, n: u64| (rng(s) % n) as u32;
-            let mut keys: Vec<Key> = Vec::new();
-            for _ in 0..300 {
-                let k = (0, CellRef::new(pick(&mut s, 120), pick(&mut s, 150)));
-                let mut areas = Vec::new();
-                for _ in 0..1 + pick(&mut s, 3) {
-                    let start = CellRef::new(pick(&mut s, 120), pick(&mut s, 150));
-                    let end = match pick(&mut s, 3) {
-                        0 => start,
-                        1 => CellRef::new(start.row + pick(&mut s, 40), start.col + pick(&mut s, 5)),
-                        _ => CellRef::new(start.row + pick(&mut s, 20), start.col + 65 + pick(&mut s, 30)),
-                    };
-                    areas.push(Area { sheet: 0, range: RangeRef::new(start, end) });
-                }
-                if let Some(sh) = wb.sheet_mut(0) {
-                    sh.cells.set(k.1, Cell::formula(Formula::new("=1")));
-                }
-                calc.graph.insert(k, Node { areas, dynamic: false });
-                keys.push(k);
-                if rng(&mut s).is_multiple_of(7) {
-                    calc.graph.settle();
-                }
-            }
-            for _ in 0..30 {
-                let k = keys[(rng(&mut s) % keys.len() as u64) as usize];
-                calc.graph.remove(k);
-                if let Some(sh) = wb.sheet_mut(0) {
-                    sh.cells.remove(k.1);
-                }
-            }
-            if case % 2 == 0 {
-                calc.graph.settle();
-            }
-            let seeds: Vec<Key> = (0..1 + pick(&mut s, 25)).map(|_| (0, CellRef::new(pick(&mut s, 140), pick(&mut s, 220)))).collect();
-            let areas: Vec<(usize, RangeRef)> = (0..pick(&mut s, 3))
-                .map(|_| {
-                    let start = CellRef::new(pick(&mut s, 120), pick(&mut s, 150));
-                    (0, RangeRef::new(start, CellRef::new(start.row + pick(&mut s, 30), start.col + pick(&mut s, 80))))
-                })
-                .collect();
-            let got: HashSet<Key> = calc.dirty_closure(&wb, &seeds, &areas).into_iter().collect();
-            // The walk before: every area cell is a seed, and every cell lists all its dependents.
-            let mut all = seeds.clone();
-            for (si, r) in &areas {
-                all.extend(r.iter().map(|c| (*si, c)));
-            }
-            let mut want: HashSet<Key> = HashSet::default();
-            let mut queue: VecDeque<Key> = VecDeque::new();
-            let mut deps = Vec::new();
-            for k in &all {
-                if calc.graph.nodes.contains_key(k) && want.insert(*k) {
-                    queue.push_back(*k);
-                }
-                deps.clear();
-                calc.graph.dependents(k.0, k.1, &mut deps);
-                queue.extend(deps.iter().copied().filter(|d| want.insert(*d)));
-            }
-            while let Some(k) = queue.pop_front() {
-                deps.clear();
-                calc.graph.dependents(k.0, k.1, &mut deps);
-                queue.extend(deps.iter().copied().filter(|d| want.insert(*d)));
-            }
-            assert_eq!(got, want, "case {case}");
-        }
-    }
-
-    #[test]
-    fn clearing_a_spill_recalculates_formulas_reading_it_once_each() {
-        // 300 formulas read the area an anchor spills into; clearing the anchor changes all of it
-        // and every one of them is recalculated (they were listed once per spilled cell).
-        let mut wb = Workbook::new();
-        let mut calc = Calc::new();
-        let set = |wb: &mut Workbook, calc: &mut Calc, at: CellRef, input: &str| {
-            if let Some(sh) = wb.sheet_mut(0) {
-                if input.is_empty() {
-                    sh.cells.remove(at);
-                } else {
-                    sh.cells.set(at, Cell::formula(Formula::new(input)));
-                }
-            }
-            calc.cells_changed(wb, &[(0, at)]);
-        };
-        set(&mut wb, &mut calc, CellRef::new(0, 0), "=SEQUENCE(2000)");
-        for r in 0..300 {
-            set(&mut wb, &mut calc, CellRef::new(r, 2), "=COUNT(A1:A2000)");
-        }
-        assert_eq!(wb.sheet(0).map(|s| s.value(CellRef::new(299, 2))), Some(Value::Number(2000.0)));
-        set(&mut wb, &mut calc, CellRef::new(0, 0), "");
-        for r in 0..300 {
-            assert_eq!(wb.sheet(0).map(|s| s.value(CellRef::new(r, 2))), Some(Value::Number(0.0)), "row {r}");
-        }
-    }
-
    /// `rows` rows of six numbers (E:J) and `=SUM(E{r}:J{r})` in K.
    fn sum_rows(rows: u32) -> Workbook {
        let mut wb = Workbook::new();
@@ -151,54 +151,6 @@ impl<T: Copy + Ord> Intervals<T> {
        self.walk(1, 0, self.max_end.len() / 2, p, a, f)
    }

-    /// [`Intervals::query`] that skips entries an earlier call with the same `taken` already
-    /// took (and whole subtrees of them), so that a series of queries lists each interval once in
-    /// all. `f` answers whether it took the entry; one it declines is offered again later.
-    /// `taken` belongs to this index as it is now; start it empty. Pending insertions (a few at
-    /// most after [`Intervals::settle`]) are offered every time.
-    pub(super) fn query_untaken(&self, a: u32, b: u32, taken: &mut Vec<bool>, f: &mut dyn FnMut(&T) -> bool) {
-        for it in &self.pending {
-            if it.0 <= b && it.1 >= a {
-                f(&it.2);
-            }
-        }
-        let p = self.items.partition_point(|it| it.0 <= b);
-        if p == 0 {
-            return;
-        }
-        if taken.len() != self.max_end.len() {
-            *taken = vec![false; self.max_end.len()];
-        }
-        self.walk_untaken(1, 0, self.max_end.len() / 2, p, a, taken, f);
-    }
-
-    /// Returns whether everything under `node` has now been reported (or is dead).
-    #[allow(clippy::too_many_arguments)]
-    fn walk_untaken(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, taken: &mut [bool], f: &mut dyn FnMut(&T) -> bool) -> bool {
-        if taken.get(node).copied().unwrap_or(true) {
-            return true;
-        }
-        if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) {
-            return false;
-        }
-        let done = if hi - lo <= 1 {
-            match (self.items.get(lo), self.dead.get(lo)) {
-                (Some(it), Some(false)) if it.1 >= a => f(&it.2),
-                (Some(_), Some(true)) => true,
-                _ => false,
-            }
-        } else {
-            let mid = lo + (hi - lo) / 2;
-            let left = self.walk_untaken(2 * node, lo, mid, p, a, taken, f);
-            let right = self.walk_untaken(2 * node + 1, mid, hi, p, a, taken, f);
-            left && right
-        };
-        if done && let Some(slot) = taken.get_mut(node) {
-            *slot = true;
-        }
-        done
-    }
-
    fn walk(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, f: &mut dyn FnMut(&T)) -> usize {
        if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) {
            return 1;
@@ -216,13 +168,6 @@ impl<T: Copy + Ord> Intervals<T> {
    }
 }

-/// Range-index entries one dependency walk has already listed (see [`Graph::dependents_untaken`]).
-#[derive(Default)]
-pub(super) struct Taken {
-    cols: HashMap<(usize, u32), Vec<bool>>,
-    wide: HashMap<usize, Vec<bool>>,
-}
-
 #[derive(Clone, Debug, Default)]
 pub struct Graph {
    pub(super) nodes: HashMap<Key, Node>,
@@ -357,32 +302,6 @@ impl Graph {
        }
    }

-    /// [`Graph::dependents`] leaving out the formulas whose range reads an earlier call with the
-    /// same `taken` already listed. A walk over many changed cells that a few broad ranges cover
-    /// then lists those formulas once, instead of once per cell (which squared the work). The
-    /// graph must not change while `taken` is in use.
-    pub(super) fn dependents_untaken(&self, sheet: usize, c: CellRef, taken: &mut Taken, out: &mut Vec<Key>) {
-        if let Some(v) = self.cell_deps.get(&(sheet, c)) {
-            out.extend(v.iter().copied());
-        }
-        if let Some(v) = self.col_deps.get(&(sheet, c.col)) {
-            v.query_untaken(c.row, c.row, taken.cols.entry((sheet, c.col)).or_default(), &mut |k| {
-                out.push(*k);
-                true
-            });
-        }
-        if let Some(v) = self.wide_deps.get(&sheet) {
-            // A wide entry is taken once it covers the cell's column too.
-            v.query_untaken(c.row, c.row, taken.wide.entry(sheet).or_default(), &mut |(c0, c1, k)| {
-                let hit = *c0 <= c.col && c.col <= *c1;
-                if hit {
-                    out.push(*k);
-                }
-                hit
-            });
-        }
-    }
-
    /// Formulas that read any cell of `range` (a formula can be listed more than once).
    pub fn dependents_of_range(&self, sheet: usize, range: RangeRef, out: &mut Vec<Key>) {
        if range.count() <= 4096 {
@@ -45,10 +45,6 @@ pub(super) struct PassHost<'a> {
    /// Suspensions so far (tests check that a wide read at the limit needs one, not one per cell).
    #[cfg(test)]
    pub(super) suspensions: usize,
-    /// Spilled values looked at by range reads (tests check that a read outside a large spill
-    /// looks at none of it).
-    #[cfg(test)]
-    pub(super) spill_visits: usize,
    /// The formulas in `cycles`.
    cycle_seen: HashSet<Key>,
    /// Iterative calculation: a circular reference reads the cell's previous value instead of
@@ -64,17 +60,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,
-    /// 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.
-    python: HashMap<Key, Value>,
 }

 impl<'a> PassHost<'a> {
@@ -98,8 +87,6 @@ impl<'a> PassHost<'a> {
            also: Vec::new(),
            #[cfg(test)]
            suspensions: 0,
-            #[cfg(test)]
-            spill_visits: 0,
            cycle_seen: HashSet::default(),
            iterate: false,
            prev: HashMap::default(),
@@ -107,20 +94,10 @@ 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,
-            python: HashMap::default(),
        }
    }
-
-    /// Adds the dirty Python cells of the pass and their kept results: like the formulas, they
-    /// are pending until laid out, so every read path calculates them before reading them.
-    pub(super) fn with_python(mut self, python: HashMap<Key, Value>) -> Self {
-        self.pending.extend(python.keys().copied());
-        self.python = python;
-        self
-    }
 }

 /// Whether an array result at `k` can't spill: it is in a table, or its area runs off the sheet,
@@ -134,10 +111,7 @@ fn spill_blocked(host: &PassHost<'_>, (sheet, anchor): Key, a: &Array) -> bool {
    let own = sh.spill_ranges.get(&anchor);
    let spilled_over = |c: CellRef| {
        !own.is_some_and(|o| o.contains(c))
-            && sh.spill_ranges.iter().any(|(o, r)| {
-                // A formula or Python cell recalculated in this pass lays its array out again.
-                *o != anchor && r.contains(c) && !host.exprs.contains_key(&(sheet, *o)) && !host.python.contains_key(&(sheet, *o))
-            })
+            && sh.spill_ranges.iter().any(|(o, r)| *o != anchor && r.contains(c) && !host.exprs.contains_key(&(sheet, *o)))
    };
    end.row >= gridcraft_core::MAX_ROWS
        || end.col >= gridcraft_core::MAX_COLS
@@ -161,42 +135,6 @@ 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.
-/// Returns how many values were looked at.
-fn stored_spill_in<'s>(sheet: &'s gridcraft_model::Sheet, range: RangeRef, f: &mut dyn FnMut(CellRef, &'s Value) -> bool) -> usize {
-    let mut seen = 0usize;
-    if sheet.spill.is_empty() {
-        return 0;
-    }
-    if (range.height() as usize) < sheet.spill.len() {
-        for row in range.start.row..=range.end.row {
-            for (c, v) in sheet.spill.range(CellRef::new(row, range.start.col)..=CellRef::new(row, range.end.col)) {
-                seen += 1;
-                if !f(*c, v) {
-                    return seen;
-                }
-            }
-        }
-    } else {
-        for (c, v) in sheet.spill.range(range.start..=range.end) {
-            seen += 1;
-            if range.contains(*c) && !f(*c, v) {
-                return seen;
-            }
-        }
-    }
-    seen
-}
-
 impl PassHost<'_> {
    /// Calculates `k` (and the formulas it reads) with bounded stack: when [`Self::compute`] would
    /// go deeper than [`MAX_NESTED`], it suspends what is in progress, the formula it needed is
@@ -250,9 +188,6 @@ impl PassHost<'_> {
            }
            return v;
        }
-        if let Some(result) = self.python.get(&k).cloned() {
-            return self.python_result(k, result);
-        }
        let Some(expr) = self.exprs.get(&k) else {
            return self.wb.sheet(k.0).map(|s| s.value(k.1)).unwrap_or_default();
        };
@@ -348,23 +283,6 @@ 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
@@ -373,10 +291,6 @@ impl PassHost<'_> {
                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.
@@ -391,36 +305,6 @@ impl PassHost<'_> {
        v
    }

-    /// A Python cell's kept result as its value: an array spills from the cell unless it is
-    /// blocked, malformed or larger than [`gridcraft_model::python::MAX_RESULT_CELLS`] (only a
-    /// crafted file holds one), which shows `#SPILL!`.
-    fn python_result(&mut self, k: Key, result: Value) -> Value {
-        self.pending.remove(&k);
-        let v = match result {
-            Value::Array(a) => {
-                let sane = a.rows >= 1
-                    && 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.spills.insert(k, a.clone());
-                    a.data.first().cloned().unwrap_or_default()
-                } else {
-                    Value::Error(CellError::Spill)
-                }
-            }
-            v => v,
-        };
-        let v = match self.spills.get(&k) {
-            Some(a) if spill_blocked(self, k, a) => {
-                self.spills.remove(&k);
-                Value::Error(CellError::Spill)
-            }
-            _ => v,
-        };
-        self.results.insert(k, v.clone());
-        v
-    }
-
    /// A formula's previous value for iterative calculation: from the last iteration, else the
    /// value it shows. Blank, and the `#CIRC!` of a loop calculated with iteration off, are 0.
    fn previous(&self, k: Key) -> Value {
@@ -561,29 +445,26 @@ impl Host for PassHost<'_> {
        let (h, w) = (range.height() as usize, range.width() as usize);
        let mut out = vec![Value::Empty; h * w];
        let Some(sh) = self.wb.sheet(sheet) else { return out };
-        // Sparse walk: only stored cells; formula and Python cells that are (or were) dirty go
-        // through `compute`, constants are copied straight from the store.
+        // Sparse walk: only stored cells; formula cells that are (or were) dirty go through
+        // `compute`, constants are copied straight from the store.
        let mut formulas: Vec<(usize, CellRef)> = Vec::new();
        for (c, cell) in sh.cells.iter_range(range) {
            let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
-            if cell.formula.is_some() || cell.py.is_some() {
+            if cell.formula.is_some() {
                formulas.push((i, c));
            } else if let Some(slot) = out.get_mut(i) {
                *slot = cell.value.clone();
            }
        }
-        let _seen = stored_spill_in(sh, range, &mut |c, v| {
-            let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
-            if let Some(slot) = out.get_mut(i)
-                && slot.is_empty()
-            {
-                *slot = v.clone();
+        for (c, v) in sh.spill.range(range.start..=range.end) {
+            if range.contains(*c) {
+                let i = (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize;
+                if let Some(slot) = out.get_mut(i)
+                    && slot.is_empty()
+                {
+                    *slot = v.clone();
+                }
            }
-            true
-        });
-        #[cfg(test)]
-        {
-            self.spill_visits += _seen;
        }
        for (i, c) in formulas {
            let v = self.cell_value(sheet, c);
@@ -592,31 +473,26 @@ impl Host for PassHost<'_> {
            }
        }
        if !self.spills.is_empty() {
-            // 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 new: Vec<(usize, Value)> = self
+                .spills
+                .iter()
+                .filter(|(a, _)| a.0 == sheet)
+                .flat_map(|(a, arr)| {
+                    let mut v = Vec::new();
+                    for r in 0..arr.rows {
+                        for cc in 0..arr.cols {
+                            let c = CellRef::new(a.1.row.saturating_add(r as u32), a.1.col.saturating_add(cc as u32));
+                            if c != a.1 && range.contains(c) {
+                                v.push((
+                                    (c.row - range.start.row) as usize * w + (c.col - range.start.col) as usize,
+                                    arr.get(r, cc).cloned().unwrap_or_default(),
+                                ));
+                            }
                        }
-                        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();
-            }
+                    v
+                })
+                .collect();
            // Iterating: an array spilled by a formula that read a previous value.
            if self.iterate
                && self.spills.iter().any(|(a, arr)| {
@@ -640,31 +516,21 @@ impl Host for PassHost<'_> {
    fn visit_range(&mut self, sheet: usize, range: RangeRef, f: &mut dyn FnMut(&Value) -> bool) -> bool {
        let wb = self.wb;
        let Some(sh) = wb.sheet(sheet) else { return false };
-        // Formula and Python cells first, in row-major order like `range_values`: reading one
-        // calculates it (a Python cell lays out its result) and the pass remembers the value, so
-        // the walk below gets the same value again without this method holding any.
+        // Formula cells first, in row-major order like `range_values`: reading one calculates it
+        // and the pass remembers the value, so the walk below gets the same value again without
+        // this method holding any.
        for (c, cell) in sh.cells.iter_range(range) {
-            if cell.formula.is_some() || cell.py.is_some() {
+            if cell.formula.is_some() {
                let _ = self.cell_value(sheet, c);
            }
        }
        // Spilled values sit between the stored cells (and the formulas just calculated may have
        // produced some): leave such blocks to `range_values`.
-        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;
-            false
-        });
-        #[cfg(test)]
-        {
-            self.spill_visits += _seen;
-        }
-        if arrays || stored {
+        if self.spills.keys().any(|a| a.0 == sheet) || sh.spill.range(range.start..=range.end).any(|(c, _)| range.contains(*c)) {
            return false;
        }
        for (c, cell) in sh.cells.iter_range(range) {
-            let go = if cell.formula.is_some() || cell.py.is_some() { f(&self.cell_value(sheet, c)) } else { f(&cell.value) };
+            let go = if cell.formula.is_some() { f(&self.cell_value(sheet, c)) } else { f(&cell.value) };
            if !go {
                break;
            }
@@ -1251,25 +1251,6 @@ fn array_broadcast_result_is_capped() {
    assert_eq!(t.num("C3"), 5.0);
 }

-/// MAP refuses a result past `MAX_CELLS` by its checked product, before allocating it (the
-/// 2^32-cell wrap that a 32-bit `usize` product would turn into 0 is pinned in
-/// `broadcast_len_rejects_a_product_that_wraps_to_zero_on_32_bits`; `SEQUENCE` tops out at
-/// 16384 columns, so the widest product it can build is 16384 squared).
-#[test]
-fn map_caps_its_result_size() {
-    let mut t = T::new();
-    for (at, formula) in
-        [("A1", "=MAP(SEQUENCE(4001),SEQUENCE(1,4000),LAMBDA(a,b,a))"), ("A2", "=MAP(SEQUENCE(16384),SEQUENCE(1,16384),LAMBDA(a,b,a))")]
-    {
-        t.set(at, formula);
-        assert_eq!(t.get(at), Value::Error(CellError::Num), "{formula}");
-    }
-    // Within the cap the broadcast shape is unchanged.
-    t.set("A3", "=ROWS(MAP(SEQUENCE(3),SEQUENCE(1,2),LAMBDA(a,b,a+b)))");
-    t.set("A4", "=COLUMNS(MAP(SEQUENCE(3),SEQUENCE(1,2),LAMBDA(a,b,a+b)))");
-    assert_eq!((t.num("A3"), t.num("A4")), (3.0, 2.0));
-}
-
 #[test]
 fn text_function() {
    let mut t = T::new();
@@ -1922,72 +1903,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
@@ -2378,63 +2293,3 @@ fn loan_schedule_residue_keeps_excels_sign() {
    }
    assert_eq!(t.get("P7"), Value::Text("".into()));
 }
-
-/// 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) {
-    use gridcraft_model::python::{PyCode, PyOutput};
-    let output = PyOutput { value: result, type_name: "list".into(), preview: String::new(), convertible: true };
-    let py = PyCode { output: Some(output), ..PyCode::new("[5, 6]") };
-    let cell = Cell { value: cached, formula: None, style: gridcraft_model::StyleId::default(), py: Some(std::sync::Arc::new(py)) };
-    t.wb.sheet_mut(0).unwrap().cells.set(c(at), cell);
-    (0, c(at))
-}
-
-fn column(values: &[f64]) -> Value {
-    let data = values.iter().map(|v| Value::Number(*v)).collect();
-    Value::Array(std::sync::Arc::new(gridcraft_core::Array::new(values.len(), 1, data).unwrap()))
-}
-
-#[test]
-fn formulas_read_a_dirty_python_cell_after_it_is_laid_out() {
-    // B1's result can't spill (B2 holds a value), so it is #SPILL!. A1, A2 and A3 come before
-    // it in the pass; each must lay it out first rather than read its old value, 1.
-    let build = |t: &mut T| {
-        t.set("B2", "10");
-        t.set("B3", "100");
-        t.set("A1", "=B1");
-        t.set("A2", "=MAX(B1:B3)");
-        t.set("A3", "=SUM(B1:B3)");
-        t.set("A4", "=COUNTA(B1:B3)");
-        t.set("A5", "=SUMPRODUCT(--ISERROR(B1:B3))");
-    };
-    let check = |t: &T, how: &str| {
-        assert_eq!(t.get("B1"), Value::Error(CellError::Spill), "{how}");
-        assert_eq!(t.get("A1"), Value::Error(CellError::Spill), "{how}: a reference");
-        assert_eq!(t.get("A2"), Value::Error(CellError::Spill), "{how}: a range read");
-        assert_eq!(t.get("A3"), Value::Error(CellError::Spill), "{how}: a range walked cell by cell");
-        assert_eq!(t.num("A4"), 3.0, "{how}");
-        assert_eq!(t.num("A5"), 1.0, "{how}: the error is seen in the range");
-    };
-
-    // A full recalculation.
-    let mut t = T::new();
-    build(&mut t);
-    plant_python(&mut t, "B1", Value::Number(1.0), column(&[5.0, 6.0]));
-    t.calc.recalc_all(&mut t.wb);
-    check(&t, "full");
-
-    // An incremental one: B1 becomes a Python cell after its readers.
-    let mut t = T::new();
-    t.set("B1", "1");
-    build(&mut t);
-    assert_eq!((t.num("A1"), t.num("A3")), (1.0, 111.0));
-    let k = plant_python(&mut t, "B1", Value::Number(1.0), column(&[5.0, 6.0]));
-    t.calc.cells_changed(&mut t.wb, &[k]);
-    check(&t, "incremental");
-
-    // Unblocked, the readers see the new array.
-    t.set("B2", "");
-    assert_eq!((t.num("B1"), t.num("B2")), (5.0, 6.0));
-    assert_eq!((t.num("A1"), t.num("A2"), t.num("A3")), (5.0, 100.0, 111.0));
-}
@@ -14,12 +14,11 @@ mod frame;
 mod kinds;
 mod legend;
 mod lines;
-mod table;
 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;
@@ -44,11 +43,6 @@ 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;
-/// 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>,
@@ -158,7 +152,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),
@@ -1,6 +1,6 @@
 use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range};
 use super::legend::{cat_label, plot_kind};
-use super::lines::{decimate_area, draw_markers, draw_runs};
+use super::lines::{decimate, draw_markers, draw_runs};
 use super::trend::{draw_trend_labels, draw_trendlines, max_backward, max_forward, max_forward_slots, supports_trendline};
 use super::{
    Chart, ChartData, ChartKind, Ctx, Fmt, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_LINE_PTS, MAX_MARKERS, Prim, Scale, SeriesData, TEXT,
@@ -96,11 +96,8 @@ fn series_spans(data: &ChartData, fams: &[Fam], sec: &[bool], ncat: usize) -> Ve
        } else {
            None
        };
-        // A series without values has no spans: 255 empty series over 20,000 categories would
-        // otherwise fill ~5 million entries.
-        let n = if s.values.is_empty() { 0 } else { ncat };
-        let mut row = Vec::with_capacity(n);
-        for j in 0..n {
+        let mut row = Vec::with_capacity(ncat);
+        for j in 0..ncat {
            let v = s.values.get(j).copied().flatten();
            let span = match (si.and_then(|p| stacks.get_mut(p)), fam) {
                (Some((_, pos, neg)), Fam::ColStack | Fam::Col100) => v.and_then(|v| {
@@ -211,9 +208,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
    // Outer levels padded to the slots (forecast slots stay in the last group).
    let outer: Vec<Vec<String>> =
        data.category_levels.iter().map(|l| (0..ncat_slots).map(|j| l.get(j).cloned().unwrap_or_default()).collect()).collect();
-    let (area, table) = super::table::reserve(ctx, chart, data, area, ncat_slots);
-    let category_axis = super::table::category_axis(&table, &labels, &outer);
-    let plot = frame(ctx, area, category_axis, &y1, y2.as_ref(), horizontal, chart.gridlines);
+    let plot = frame(ctx, area, CatAxis::Labels(&labels, &outer), &y1, y2.as_ref(), horizontal, chart.gridlines);
    if !plot.ok() {
        return;
    }
@@ -271,7 +266,10 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
                            base = vec![[b[0] - cw * 0.3, b[1]], [b[0] + cw * 0.3, b[1]]];
                        }
                    }
-                    let poly = decimate_area(top, base, MAX_LINE_PTS * 2);
+                    let top = decimate(top, MAX_LINE_PTS * 2);
+                    let base = decimate(base, MAX_LINE_PTS * 2);
+                    let mut poly = top;
+                    poly.extend(base.into_iter().rev());
                    if poly.len() >= 3 {
                        ctx.out.push(Prim::Polygon { pts: poly, fill: s.color, stroke: None });
                    }
@@ -357,7 +355,6 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx
        draw_trendlines(ctx, s, &pts, &frac, &px, &mut trend_labels, (0.5, ncat_slots as f64 + 0.5));
    }
    draw_trend_labels(ctx, plot, &trend_labels);
-    super::table::draw(ctx, chart, data, plot, table.as_ref());
 }

 // ---------------------------------------------------------------- scatter & bubble
@@ -453,18 +450,3 @@ pub(super) fn scatter(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
    }
    draw_trend_labels(ctx, plot, &trend_labels);
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn empty_series_get_no_span_entries() {
-        let empty = SeriesData::default();
-        let full = SeriesData { values: vec![Some(1.0); 3], ..SeriesData::default() };
-        let data = ChartData { series: vec![empty.clone(), full, empty], ..ChartData::default() };
-        let fams = [Fam::Col; 3];
-        let spans = series_spans(&data, &fams, &[false; 3], MAX_CATS);
-        assert_eq!(spans.iter().map(Vec::len).collect::<Vec<_>>(), [0, MAX_CATS, 0]);
-    }
-}
@@ -74,14 +74,12 @@ pub(super) enum CatAxis<'a> {
    /// Category labels and, for a multi-level axis, the outer levels (nearest the labels first;
    /// one entry per category, non-empty where a group starts).
    Labels(&'a [String], &'a [Vec<String>]),
-    /// A data table supplies the labels below a vertical chart. Its stub must clear the plot.
-    Table(&'a [String], f32),
    Numeric(Scale, &'a Fmt),
 }

 /// Groups of an outer category level: `(first, end)` index pairs, a group starting at every
 /// non-empty entry (and at the first category).
-pub(super) fn level_groups(level: &[String], n: usize) -> Vec<(usize, usize)> {
+fn level_groups(level: &[String], n: usize) -> Vec<(usize, usize)> {
    let mut starts: Vec<usize> = (0..n).filter(|&j| j == 0 || level.get(j).is_some_and(|t| !t.is_empty())).collect();
    starts.push(n);
    starts.windows(2).filter_map(|w| Some((*w.first()?, *w.get(1)?))).collect()
@@ -103,13 +101,9 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
    let ls = LABEL_SIZE;
    let lh = ls * 1.4;
    let ylabels = y.labels();
-    let stub = match &cat {
-        CatAxis::Table(_, width) => *width,
-        _ => 0.0,
-    };
    let maxw = |ctx: &Ctx, l: &[(f64, String)]| l.iter().map(|(_, t)| ctx.tw(t, ls)).fold(0.0f32, f32::max);
    if !horizontal {
-        let left = (maxw(ctx, &ylabels) + 6.0).min(area.w * 0.4).max(stub);
+        let left = (maxw(ctx, &ylabels) + 6.0).min(area.w * 0.4);
        let y2labels = y2.map(ValAxis::labels);
        let right = match (&y2labels, &cat) {
            (Some(l), _) => (maxw(ctx, l) + 6.0).min(area.w * 0.3),
@@ -118,7 +112,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
        };
        let levels = match &cat {
            CatAxis::Labels(_, o) => o.len() as f32,
-            CatAxis::Numeric(..) | CatAxis::Table(..) => 0.0,
+            CatAxis::Numeric(..) => 0.0,
        };
        let plot = Bx { x: area.x + left, y: area.y + lh * 0.5, w: area.w - left - right, h: area.h - lh * 1.5 - 4.0 - lh * levels };
        if !plot.ok() {
@@ -141,7 +135,6 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
        let y0 = plot.bottom() - y.scale.frac(zero) * plot.h;
        ctx.hline(plot.x, plot.right(), y0, AXIS, 0.75);
        match cat {
-            CatAxis::Table(..) => {}
            CatAxis::Labels(l, outer) => {
                let n = l.len().max(1);
                let cw = plot.w / n as f32;
@@ -188,7 +181,6 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
    } else {
        let (labels, outer): (Vec<String>, &[Vec<String>]) = match cat {
            CatAxis::Labels(l, o) => (l.to_vec(), o),
-            CatAxis::Table(l, _) => (l.to_vec(), &[]),
            CatAxis::Numeric(..) => (vec![], &[]),
        };
        let lw = (labels.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max) + 6.0).min(area.w * 0.35);
@@ -197,8 +189,7 @@ pub(super) fn frame(ctx: &mut Ctx, area: Bx, cat: CatAxis, y: &ValAxis, y2: Opti
            outer.iter().map(|l| (l.iter().take(2000).map(|t| ctx.tw(t, ls)).fold(0.0f32, f32::max) + 6.0).min(area.w * 0.15)).collect();
        let levels_w: f32 = level_w.iter().sum();
        let right = ylabels.last().map(|(_, t)| ctx.tw(t, ls) / 2.0).unwrap_or(0.0).min(area.w * 0.2) + 2.0;
-        let left = (lw + levels_w).max(stub);
-        let plot = Bx { x: area.x + left, y: area.y + 2.0, w: area.w - left - right, h: area.h - lh - 6.0 };
+        let plot = Bx { x: area.x + lw + levels_w, y: area.y + 2.0, w: area.w - lw - levels_w - right, h: area.h - lh - 6.0 };
        if !plot.ok() {
            return plot;
        }
@@ -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,89 +201,14 @@ 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 sum, smallest and largest area.
-fn worst(s: f64, mn: f64, mx: f64, side: f64) -> f64 {
+fn worst(row: &[f64], side: f64) -> f64 {
+    let s: f64 = row.iter().sum();
    if s <= 0.0 || side <= 0.0 {
        return f64::INFINITY;
    }
+    let (mn, mx) = row.iter().fold((f64::INFINITY, 0.0f64), |(a, b), v| (a.min(*v), b.max(*v)));
    let s2 = s * s;
    let w2 = side * side;
    (w2 * mx / s2).max(s2 / (w2 * mn))
@@ -361,8 +225,6 @@ fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
    let mut out = Vec::with_capacity(items.len());
    let mut rem = r;
    let mut row: Vec<(usize, f64)> = Vec::new();
-    // The row's sum, smallest and largest area, kept as items join so each step is O(1).
-    let (mut sum, mut mn, mut mx) = (0.0f64, f64::INFINITY, 0.0f64);
    let mut i = 0;
    let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| {
        let s: f64 = row.iter().map(|x| x.1).sum();
@@ -394,14 +256,15 @@ fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> {
    while let Some(&(j, v)) = items.get(i) {
        let a = v * scale;
        let side = rem.w.min(rem.h) as f64;
-        if row.is_empty() || worst(sum + a, mn.min(a), mx.max(a), side) <= worst(sum, mn, mx, side) {
+        let cur: Vec<f64> = row.iter().map(|x| x.1).collect();
+        let mut with = cur.clone();
+        with.push(a);
+        if row.is_empty() || worst(&with, side) <= worst(&cur, side) {
            row.push((j, a));
-            (sum, mn, mx) = (sum + a, mn.min(a), mx.max(a));
            i += 1;
        } else {
            layout(&row, &mut rem, &mut out);
            row.clear();
-            (sum, mn, mx) = (0.0, f64::INFINITY, 0.0);
        }
    }
    if !row.is_empty() {
@@ -416,7 +279,6 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
        s.values.iter().take(MAX_MARKERS).enumerate().filter_map(|(j, v)| v.filter(|v| *v > 0.0).map(|v| (j, v))).collect();
    items.sort_by(|a, b| b.1.total_cmp(&a.1));
    let f = Fmt::new(&s.number_format);
-    let value_of: std::collections::HashMap<usize, f64> = items.iter().copied().collect();
    for (j, b) in squarify(&items, area) {
        let fill = point_color(data, j);
        ctx.rect(b.x, b.y, b.w, b.h, fill, Some((WHITE, 1.5)));
@@ -424,7 +286,7 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx)
            let name = ctx.fit(&cat_label(data, j), LABEL_SIZE, b.w - 8.0);
            ctx.text(b.x + 4.0, b.y + 4.0, &name, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top));
            if chart.data_labels && b.h > LABEL_SIZE * 3.2 {
-                let v = value_of.get(&j).copied().unwrap_or(0.0);
+                let v = items.iter().find(|x| x.0 == j).map(|x| x.1).unwrap_or(0.0);
                let t = ctx.fit(&f.format(v, None), LABEL_SIZE, b.w - 8.0);
                ctx.text(b.x + 4.0, b.y + 4.0 + LABEL_SIZE * 1.4, &t, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top));
            }
@@ -42,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()
@@ -87,7 +85,7 @@ fn swatch_w(sw: Swatch, s: f32) -> f32 {
    if sw == Swatch::Box { s } else { s * 2.0 }
 }

-pub(super) fn draw_swatch(ctx: &mut Ctx, sw: Swatch, x: f32, yc: f32, s: f32, color: Rgba) {
+fn draw_swatch(ctx: &mut Ctx, sw: Swatch, x: f32, yc: f32, s: f32, color: Rgba) {
    match sw {
        Swatch::Box => ctx.rect(x, yc - s / 2.0, s, s, color, None),
        Swatch::Line => ctx.hline(x, x + 2.0 * s, yc, color, 2.0),
@@ -54,86 +54,6 @@ pub(super) fn decimate(pts: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> {
    out
 }

-/// Decimates the top and baseline of an area chart together at the same horizontal indices so
-/// `area_mesh`'s paired vertical-strip topology (`pts[i]` ↔ `pts[2n - 1 - i]`) is preserved.
-pub(super) fn decimate_area(top: Vec<[f32; 2]>, base: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> {
-    let n = top.len().min(base.len());
-    if n == 0 {
-        return Vec::new();
-    }
-    if n <= max {
-        let mut poly = top;
-        poly.truncate(n);
-        poly.extend(base.into_iter().take(n).rev());
-        return poly;
-    }
-    let mut cols: Vec<[usize; 6]> = Vec::new();
-    let mut keep = Vec::with_capacity(max * 2);
-    let mut i = 0;
-    while i < n {
-        let col = top[i][0].floor();
-        let (start, mut t_mn, mut t_mx, mut b_mn, mut b_mx) = (i, i, i, i, i);
-        let mut k = i + 1;
-        while k < n && top[k][0].floor() == col {
-            if top[k][1] < top[t_mn][1] {
-                t_mn = k;
-            }
-            if top[k][1] > top[t_mx][1] {
-                t_mx = k;
-            }
-            if base[k][1] < base[b_mn][1] {
-                b_mn = k;
-            }
-            if base[k][1] > base[b_mx][1] {
-                b_mx = k;
-            }
-            k += 1;
-        }
-        let entry = [start, t_mn, t_mx, b_mn, b_mx, k - 1];
-        cols.push(entry);
-        let mut idx = entry;
-        idx.sort_unstable();
-        let mut last = usize::MAX;
-        for ix in idx {
-            if ix != last {
-                keep.push(ix);
-                last = ix;
-            }
-        }
-        i = k;
-    }
-    if keep.len() > max * 4 {
-        let max_groups = (max * 4 / 6).max(1);
-        let group_size = cols.len().div_ceil(max_groups);
-        keep.clear();
-        for ch in cols.chunks(group_size) {
-            let start = ch[0][0];
-            let end = ch.last().map_or(start, |c| c[5]);
-            let t_mn = ch.iter().map(|c| c[1]).min_by(|&a, &b| top[a][1].total_cmp(&top[b][1])).unwrap_or(start);
-            let t_mx = ch.iter().map(|c| c[2]).max_by(|&a, &b| top[a][1].total_cmp(&top[b][1])).unwrap_or(start);
-            let b_mn = ch.iter().map(|c| c[3]).min_by(|&a, &b| base[a][1].total_cmp(&base[b][1])).unwrap_or(start);
-            let b_mx = ch.iter().map(|c| c[4]).max_by(|&a, &b| base[a][1].total_cmp(&base[b][1])).unwrap_or(start);
-            let mut idx = [start, t_mn, t_mx, b_mn, b_mx, end];
-            idx.sort_unstable();
-            let mut last = usize::MAX;
-            for ix in idx {
-                if ix != last {
-                    keep.push(ix);
-                    last = ix;
-                }
-            }
-        }
-    }
-    let mut poly = Vec::with_capacity(keep.len() * 2);
-    for &ix in &keep {
-        poly.push(top[ix]);
-    }
-    for &ix in keep.iter().rev() {
-        poly.push(base[ix]);
-    }
-    poly
-}
-
 /// Draws a polyline split at gaps (`None`), decimated when long. With `smooth` (the plot box),
 /// each run is interpolated with a Catmull-Rom spline so the line curves through the data points.
 pub(super) fn draw_runs(ctx: &mut Ctx, pts: &[Option<[f32; 2]>], color: Rgba, width: f32, smooth: Option<Bx>) {
@@ -235,57 +155,4 @@ mod smooth_tests {
        assert!(out.len() > 5);
        assert!(out.iter().all(|p| (0.0..=300.0).contains(&p[0]) && (10.0..=110.0).contains(&p[1])));
    }
-
-    #[test]
-    fn decimate_area_preserves_paired_vertical_strips() {
-        let top: Vec<[f32; 2]> = (0..1000).map(|i| [i as f32 * 0.25, ((i * 37) % 100) as f32]).collect();
-        let base: Vec<[f32; 2]> = (0..1000).map(|i| [i as f32 * 0.25, 100.0]).collect();
-        let poly = decimate_area(top, base, 64);
-        assert_eq!(poly.len() % 2, 0);
-        let half = poly.len() / 2;
-        for i in 0..half {
-            assert_eq!(poly[i][0], poly[poly.len() - 1 - i][0]);
-            assert_eq!(poly[poly.len() - 1 - i][1], 100.0);
-        }
-    }
-
-    #[test]
-    fn decimate_area_preserves_extrema_across_3000_columns() {
-        // 3,000 occupied pixel columns with 6 points per column (18,000 points total),
-        // where each column has distinct top and baseline extrema so the initial per-column
-        // index list exceeds `MAX_LINE_PTS * 2 * 4` (6,400).
-        let max = MAX_LINE_PTS * 2;
-        let mut top = Vec::with_capacity(18_000);
-        let mut base = Vec::with_capacity(18_000);
-        for col in 0..3_000 {
-            let y_top = [50.0, 20.0, 80.0, 50.0, 50.0, 50.0];
-            let y_base = [150.0, 150.0, 150.0, 120.0, 180.0, 150.0];
-            for s in 0..6 {
-                let x = col as f32 + s as f32 * 0.1;
-                top.push([x, y_top[s]]);
-                base.push([x, y_base[s]]);
-            }
-        }
-        // Plant sharp spikes on both top and baseline in interior columns.
-        top[777 * 6 + 1][1] = 1.0;
-        top[1999 * 6 + 2][1] = 99.0;
-        base[1234 * 6 + 3][1] = 101.0;
-        base[2501 * 6 + 4][1] = 199.0;
-
-        let poly = decimate_area(top, base, max);
-        assert_eq!(poly.len() % 2, 0);
-        let half = poly.len() / 2;
-        assert!(half <= max * 4, "retained {half} paired vertices, limit is {}", max * 4);
-        for i in 0..half {
-            assert_eq!(poly[i][0], poly[poly.len() - 1 - i][0]);
-        }
-        let top_kept = &poly[..half];
-        let base_kept = &poly[half..];
-        assert_eq!(top_kept.first().map(|p| p[0]), Some(0.0));
-        assert_eq!(top_kept.last().map(|p| p[0]), Some(2999.5));
-        assert!(top_kept.iter().any(|p| p[1] == 1.0), "top min spike preserved");
-        assert!(top_kept.iter().any(|p| p[1] == 99.0), "top max spike preserved");
-        assert!(base_kept.iter().any(|p| p[1] == 101.0), "base min spike preserved");
-        assert!(base_kept.iter().any(|p| p[1] == 199.0), "base max spike preserved");
-    }
 }
@@ -1,107 +0,0 @@
-//! The chart data table uses the same primitives as the plot, including in print/PDF output.
-
-use super::frame::{Bx, CatAxis, level_groups};
-use super::legend::{Swatch, cat_label, draw_swatch, plot_kind};
-use super::{AXIS, Chart, ChartData, ChartKind, Ctx, Fmt, HAlign, LABEL_SIZE, TEXT, VAlign};
-
-pub(super) struct Layout {
-    top: f32,
-    row_height: f32,
-    headers: usize,
-    stub: f32,
-    columns: usize,
-}
-
-pub(super) fn category_axis<'a>(layout: &Option<Layout>, labels: &'a [String], outer: &'a [Vec<String>]) -> CatAxis<'a> {
-    match layout {
-        Some(t) => CatAxis::Table(labels, t.stub),
-        None => CatAxis::Labels(labels, outer),
-    }
-}
-
-/// Reserve at most half the available height. A table that cannot fit is explicitly labelled
-/// instead of dropping rows or allocating a series × point-sized matrix.
-pub(super) fn reserve(ctx: &mut Ctx, chart: &Chart, data: &ChartData, mut area: Bx, columns: usize) -> (Bx, Option<Layout>) {
-    if chart.data_table.is_none() || !chart.supports_data_table() {
-        return (area, None);
-    }
-    let headers = data.category_levels.len() + 1;
-    let rows = headers + data.series.len();
-    let row_height = LABEL_SIZE * 1.4 + 4.0;
-    let height = row_height * rows as f32;
-    let key_width = if chart.data_table.as_ref().is_some_and(|t| t.show_keys) { 22.0 } else { 0.0 };
-    let names = data.series.iter().take(32).map(|s| ctx.tw(&s.name, LABEL_SIZE)).fold(0.0f32, f32::max);
-    let stub = (names + key_width + 10.0).clamp(24.0, (area.w * 0.3).max(24.0));
-    if columns == 0 || columns > 128 || data.series.len() > 32 || height > area.h * 0.5 || (area.w * 0.6) / (columns as f32) < 18.0 {
-        let message = ctx.fit("Data table needs more space", LABEL_SIZE, area.w);
-        ctx.text(area.cx(), area.bottom(), &message, LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Bottom));
-        area.h -= row_height;
-        return (area, None);
-    }
-    area.h -= height;
-    (area, Some(Layout { top: area.bottom(), row_height, headers, stub, columns }))
-}
-
-pub(super) fn draw(ctx: &mut Ctx, chart: &Chart, data: &ChartData, plot: Bx, layout: Option<&Layout>) {
-    let Some(layout) = layout else { return };
-    let Some(settings) = &chart.data_table else { return };
-    let x0 = plot.x - layout.stub;
-    let top = layout.top;
-    let rows = layout.headers + data.series.len();
-    let bottom = top + layout.row_height * rows as f32;
-    let cw = plot.w / layout.columns as f32;
-    // Outermost category level first, then the individual categories.
-    for (i, level) in data.category_levels.iter().rev().enumerate() {
-        for (first, end) in level_groups(level, layout.columns) {
-            let text = level.get(first).map(String::as_str).unwrap_or("");
-            let text = ctx.fit(text, LABEL_SIZE, (end - first) as f32 * cw - 4.0);
-            let x = plot.x + (first + end) as f32 * cw / 2.0;
-            ctx.text(x, top + (i as f32 + 0.5) * layout.row_height, &text, LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Middle));
-        }
-    }
-    let header_y = top + (layout.headers as f32 - 0.5) * layout.row_height;
-    let n = data.categories.len().max(data.series.iter().map(|s| s.values.len()).max().unwrap_or(0));
-    for j in 0..layout.columns {
-        let text = if j < n { cat_label(data, j) } else { String::new() };
-        let text = ctx.fit(&text, LABEL_SIZE, cw - 4.0);
-        ctx.text(plot.x + (j as f32 + 0.5) * cw, header_y, &text, LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Middle));
-    }
-    for (i, series) in data.series.iter().enumerate() {
-        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) {
-                ChartKind::Line | ChartKind::LineStacked => Swatch::Line,
-                ChartKind::LineMarkers => Swatch::LineMarker,
-                _ => Swatch::Box,
-            };
-            draw_swatch(ctx, swatch, x0 + 4.0, y, 7.0, series.color);
-        }
-        let name = ctx.fit(&series.name, LABEL_SIZE, plot.x - name_x - 4.0);
-        ctx.text(name_x, y, &name, LABEL_SIZE, TEXT, (HAlign::Left, VAlign::Middle));
-        let fmt = Fmt::new(&series.number_format);
-        for j in 0..layout.columns {
-            let value = series.values.get(j).copied().flatten().map(|v| fmt.format(v, None)).unwrap_or_default();
-            let text = ctx.fit(&value, LABEL_SIZE, cw - 4.0);
-            ctx.text(plot.x + (j as f32 + 0.5) * cw, y, &text, LABEL_SIZE, TEXT, (HAlign::Center, VAlign::Middle));
-        }
-    }
-    if settings.horizontal_border {
-        for row in 1..rows {
-            ctx.hline(x0, plot.right(), top + row as f32 * layout.row_height, AXIS, 0.75);
-        }
-    }
-    if settings.vertical_border {
-        ctx.vline(plot.x, top, bottom, AXIS, 0.75);
-        // The outer headers span groups; category dividers begin at the innermost header.
-        for j in 1..layout.columns {
-            ctx.vline(plot.x + j as f32 * cw, top + (layout.headers - 1) as f32 * layout.row_height, bottom, AXIS, 0.75);
-        }
-    }
-    if settings.outline {
-        ctx.hline(x0, plot.right(), top, AXIS, 0.75);
-        ctx.hline(x0, plot.right(), bottom, AXIS, 0.75);
-        ctx.vline(x0, top, bottom, AXIS, 0.75);
-        ctx.vline(plot.right(), top, bottom, AXIS, 0.75);
-    }
-}
@@ -179,10 +179,9 @@ fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str) -> (
 /// Whether `t` names a defined name seen from `sheet` (`Name`, or `Sheet1!Name` looked up on
 /// that sheet), the way the evaluator looks names up.
 fn is_defined_name(wb: &Workbook, sheet: usize, t: &str) -> bool {
-    // `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012).
-    match gridcraft_core::split_sheet(t) {
-        (Some(s), bare) => wb.sheet_index(&s).is_some_and(|i| wb.name(bare, i).is_some()),
-        (None, _) => wb.name(t, sheet).is_some(),
+    match t.split_once('!') {
+        Some((s, bare)) => wb.sheet_index(s.trim_matches('\'')).is_some_and(|i| wb.name(bare, i).is_some()),
+        None => wb.name(t, sheet).is_some(),
    }
 }

@@ -5,8 +5,6 @@ use gridcraft_model::{Anchor, Chart, ChartKind, Color, LegendPos, Series, Sparkl

 use crate::*;

-mod data_table;
-
 const ALL_KINDS: [ChartKind; 26] = [
    ChartKind::ColumnClustered,
    ChartKind::ColumnStacked,
@@ -45,11 +43,8 @@ fn chart(kind: ChartKind) -> Chart {
        series: vec![],
        legend: LegendPos::Bottom,
        data_labels: true,
-        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,
@@ -151,317 +146,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);
@@ -774,11 +458,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);
 }
@@ -1575,75 +1255,3 @@ fn box_whisker_draws_each_series_quartile_method() {
    // The boxes span 3.5 and 2.5 data units on the same value axis.
    assert!((heights[0] / heights[1] - 1.4).abs() < 0.001);
 }
-
-#[test]
-fn a_series_named_by_a_name_on_a_sheet_with_an_apostrophe_resolves() {
-    // #2012: `'Bob''s'!Title` kept the doubled quote, so the sheet wasn't found and the series
-    // was named by the literal text.
-    let mut wb = Workbook::new();
-    {
-        let s = wb.sheet_mut(0).unwrap();
-        s.name = "Bob's".into();
-        s.set_value(CellRef::new(0, 0), Value::from("Takings"));
-        s.set_value(CellRef::new(1, 0), Value::Number(4.0));
-        s.set_value(CellRef::new(2, 0), Value::Number(9.0));
-    }
-    wb.names.push(gridcraft_model::DefinedName {
-        name: "Title".into(),
-        scope: Some(0),
-        formula: "'Bob''s'!$A$1".into(),
-        comment: String::new(),
-        hidden: false,
-    });
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.series = vec![Series {
-        name: Some("'Bob''s'!Title".into()),
-        categories: None,
-        values: "'Bob''s'!$A$2:$A$3".into(),
-        bubble_sizes: None,
-        color: None,
-        secondary: false,
-        kind: None,
-        quartiles: Default::default(),
-        smooth: false,
-        trendlines: Vec::new(),
-    }];
-    let d = resolve(&wb, 0, &c);
-    assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings"));
-}
-
-#[test]
-fn a_series_named_by_a_name_on_a_sheet_with_a_bang_resolves() {
-    // `'a!b'!Title`: the sheet name holds a `!`, so the evaluator must split the parsed name at
-    // the last one, not the first.
-    let mut wb = Workbook::new();
-    {
-        let s = wb.sheet_mut(0).unwrap();
-        s.name = "a!b".into();
-        s.set_value(CellRef::new(0, 0), Value::from("Takings"));
-        s.set_value(CellRef::new(1, 0), Value::Number(4.0));
-        s.set_value(CellRef::new(2, 0), Value::Number(9.0));
-    }
-    wb.names.push(gridcraft_model::DefinedName {
-        name: "Title".into(),
-        scope: Some(0),
-        formula: "'a!b'!$A$1".into(),
-        comment: String::new(),
-        hidden: false,
-    });
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.series = vec![Series {
-        name: Some("'a!b'!Title".into()),
-        categories: None,
-        values: "'a!b'!$A$2:$A$3".into(),
-        bubble_sizes: None,
-        color: None,
-        secondary: false,
-        kind: None,
-        quartiles: Default::default(),
-        smooth: false,
-        trendlines: Vec::new(),
-    }];
-    let d = resolve(&wb, 0, &c);
-    assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings"));
-}
@@ -1,121 +0,0 @@
-use super::*;
-use gridcraft_model::ChartDataTable;
-
-#[test]
-fn tables_draw_source_values_for_every_supported_chart_kind() {
-    for kind in ALL_KINDS {
-        let mut c = chart(kind);
-        c.legend = LegendPos::None;
-        c.data_labels = false;
-        c.data_table = Some(ChartDataTable::default());
-        let supported = c.supports_data_table();
-        let d = sample(kind);
-        let prims = render(&c, &d, 900.0, 500.0, &ApproxMeasure);
-        assert_sane(&prims, 900.0, 500.0);
-        let labels = texts(&prims);
-        // Source amounts, including on 100% stacked charts, not shares or running totals.
-        if supported {
-            for value in ["$12,000", "-$4,000", "$38,000", "$61,870"] {
-                assert!(labels.contains(&value), "{kind:?}: missing {value}");
-            }
-        } else {
-            c.data_table = None;
-            assert_eq!(prims, render(&c, &d, 900.0, 500.0, &ApproxMeasure));
-        }
-    }
-}
-
-#[test]
-fn table_columns_align_with_plot_and_keep_missing_values_blank() {
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.title = Some(String::new());
-    c.x_title = None;
-    c.y_title = None;
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    c.data_table = Some(ChartDataTable::default());
-    let color = [1, 2, 3, 255];
-    let mut s = series("Rate", &[0.25, 0.0, 0.75], color, c.kind);
-    s.values[1] = None;
-    s.number_format = "0.0%".into();
-    let d = ChartData { categories: ["Jan", "Feb", "Mar"].map(String::from).to_vec(), series: vec![s], ..Default::default() };
-    let p = render(&c, &d, 600.0, 400.0, &ApproxMeasure);
-    let at = |text: &str| -> (f32, f32) {
-        p.iter()
-            .find_map(|p| match p {
-                Prim::Text { text: t, x, y, .. } if t == text => Some((*x, *y)),
-                _ => None,
-            })
-            .unwrap()
-    };
-    let (x1, y1) = at("25.0%");
-    let (x3, y3) = at("75.0%");
-    let header_y = at("Jan").1;
-    assert!(y1 > header_y && (y1 - y3).abs() < 0.01);
-    assert_eq!(at("Jan").0, x1);
-    assert_eq!(at("Mar").0, x3);
-    assert_eq!(texts(&p).iter().filter(|t| **t == "Jan").count(), 1, "the table replaces category-axis labels");
-    let centers: Vec<f32> = p
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Rect { x, y, w, fill: Some(f), .. } if *f == color && *y < header_y => Some(x + w / 2.0),
-            _ => None,
-        })
-        .collect();
-    assert_eq!(centers.len(), 2);
-    assert!((centers[0] - x1).abs() < 0.01 && (centers[1] - x3).abs() < 0.01);
-    let cells: Vec<&str> = p
-        .iter()
-        .filter_map(|p| match p {
-            Prim::Text { y, text, .. } if (*y - y1).abs() < 0.01 => Some(text.as_str()),
-            _ => None,
-        })
-        .collect();
-    assert_eq!(cells, ["Rate", "25.0%", "75.0%"], "blank cells are not zeroes");
-    assert!(
-        p.iter().any(|p| matches!(p, Prim::Rect { y, fill: Some(f), .. } if *f == color && *y > header_y)),
-        "legend key independent of hidden chart legend"
-    );
-    c.data_table = Some(ChartDataTable { show_keys: false, ..Default::default() });
-    let off = render(&c, &d, 600.0, 400.0, &ApproxMeasure);
-    assert!(!off.iter().any(|p| matches!(p, Prim::Rect { y, fill: Some(f), .. } if *f == color && *y > header_y)));
-}
-
-#[test]
-fn table_borders_are_independent_and_multilevel_headers_are_kept() {
-    let mut c = chart(ChartKind::Line);
-    c.legend = LegendPos::None;
-    c.data_labels = false;
-    let mut d = sample(c.kind);
-    d.category_levels = vec![vec!["2025".into(), "".into(), "".into(), "2026".into(), "".into(), "".into()]];
-    for (h, v, outline, want) in [(false, false, false, 0), (true, false, false, 4), (false, true, false, 6), (false, false, true, 4)] {
-        c.data_table = Some(ChartDataTable { horizontal_border: h, vertical_border: v, outline, show_keys: false });
-        let p = render(&c, &d, 900.0, 600.0, &ApproxMeasure);
-        let year_y = p
-            .iter()
-            .find_map(|p| match p {
-                Prim::Text { text, y, .. } if text == "2025" => Some(*y),
-                _ => None,
-            })
-            .unwrap();
-        assert!(texts(&p).contains(&"2026"));
-        let lines = p.iter().filter(|p| matches!(p, Prim::Line { pts, .. } if pts.iter().all(|p| p[1] > year_y - 9.0))).count();
-        assert_eq!(lines, want, "{h} {v} {outline}");
-        assert_sane(&p, 900.0, 600.0);
-    }
-}
-
-#[test]
-fn dense_and_tiny_tables_are_bounded_and_explicit() {
-    let mut c = chart(ChartKind::ColumnClustered);
-    c.data_table = Some(ChartDataTable::default());
-    let mut d = sample(c.kind);
-    d.categories = (0..20_000).map(|i| i.to_string()).collect();
-    let p = render(&c, &d, 600.0, 400.0, &ApproxMeasure);
-    assert!(texts(&p).contains(&"Data table needs more space"));
-    assert_sane(&p, 600.0, 400.0);
-    d.categories.clear();
-    for (w, h) in [(1.0, 1.0), (10.0, 10.0), (40.0, 35.0), (200.0, 100.0)] {
-        assert_sane(&render(&c, &d, w, h, &ApproxMeasure), w, h);
-    }
-}
@@ -188,12 +188,6 @@ impl RangeRef {
            end: CellRef::new(self.end.row.max(o.end.row), self.end.col.max(o.end.col)),
        }
    }
-    /// The top-left cell of a list of areas: the lowest row and the lowest column across all of
-    /// them, whatever order they are listed in. Excel writes the relative formulas of a
-    /// multi-area validation or conditional format for this cell. `None` for no areas.
-    pub fn top_left(ranges: &[RangeRef]) -> Option<CellRef> {
-        ranges.iter().copied().reduce(|a, b| a.union(&b)).map(|r| r.start)
-    }
    /// Row-major iterator over the cells. Callers must bound huge ranges themselves.
    pub fn iter(&self) -> impl Iterator<Item = CellRef> + '_ {
        let (r0, r1, c0, c1) = (self.start.row, self.end.row, self.start.col, self.end.col);
@@ -296,40 +290,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());
@@ -343,16 +307,6 @@ mod tests {
        Ok(())
    }

-    #[test]
-    fn top_left_spans_every_area_in_any_order() {
-        let areas: Vec<RangeRef> = ["H62:H68", "H26:H27", "H93:H95"].iter().filter_map(|a| RangeRef::parse(a)).collect();
-        assert_eq!(RangeRef::top_left(&areas), CellRef::parse("H26"));
-        // Lowest row and lowest column, even when they come from different areas.
-        let areas: Vec<RangeRef> = ["C5:D6", "E2", "B9"].iter().filter_map(|a| RangeRef::parse(a)).collect();
-        assert_eq!(RangeRef::top_left(&areas), CellRef::parse("B2"));
-        assert_eq!(RangeRef::top_left(&[]), None);
-    }
-
    #[test]
    fn sheet_quoting_follows_excel() {
        for quoted in [
@@ -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};
@@ -21,18 +21,10 @@ pub enum CellError {
    Calc,
    /// Circular reference that could not be resolved (shown as 0 by Excel; we keep it explicit).
    Circ,
-    /// A Python cell's code raised an error, or Python stopped.
-    Python,
-    /// A Python cell is waiting to run.
-    Busy,
-    /// A Python cell ran longer than the time limit.
-    Timeout,
-    /// Python can't run here: the workbook's content isn't enabled, or this build has no Python.
-    Blocked,
 }

 impl CellError {
-    pub const ALL: [CellError; 14] = [
+    pub const ALL: [CellError; 10] = [
        CellError::Null,
        CellError::Div0,
        CellError::Value,
@@ -43,10 +35,6 @@ impl CellError {
        CellError::GettingData,
        CellError::Spill,
        CellError::Calc,
-        CellError::Python,
-        CellError::Busy,
-        CellError::Timeout,
-        CellError::Blocked,
    ];
    pub fn as_str(&self) -> &'static str {
        match self {
@@ -61,16 +49,9 @@ impl CellError {
            CellError::Spill => "#SPILL!",
            CellError::Calc => "#CALC!",
            CellError::Circ => "#CIRC!",
-            CellError::Python => "#PYTHON!",
-            CellError::Busy => "#BUSY!",
-            CellError::Timeout => "#TIMEOUT!",
-            CellError::Blocked => "#BLOCKED!",
        }
    }
-    /// `ERROR.TYPE` number. Microsoft documents 1 to 8; 9 (#SPILL!), 11 (#BLOCKED!) and 14 (#CALC!)
-    /// are the numbers Excel returns. Microsoft documents no number for #PYTHON!, #BUSY! or
-    /// #TIMEOUT!: 19, 20 and 21 are GridCraft's own choice, after the numbers Excel is known to use,
-    /// and may change if Excel's numbers become known.
+    /// `ERROR.TYPE` number.
    pub fn code(&self) -> u32 {
        match self {
            CellError::Null => 1,
@@ -84,10 +65,6 @@ impl CellError {
            CellError::Spill => 9,
            CellError::Calc => 14,
            CellError::Circ => 15,
-            CellError::Blocked => 11,
-            CellError::Python => 19,
-            CellError::Busy => 20,
-            CellError::Timeout => 21,
        }
    }
    pub fn parse(s: &str) -> Option<CellError> {
@@ -23,7 +23,6 @@ log = { workspace = true }
 gridcraft-xlsx = { workspace = true }
 gridcraft-chart = { workspace = true }
 gridcraft-pdf = { workspace = true }
-gridcraft-math = { workspace = true }
 image = { workspace = true }

 [dev-dependencies]
@@ -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"),
@@ -244,7 +244,7 @@ impl CfCache {
        let v = sh.value(c);
        let no_stats = RuleStats::default();
        for (idx, cf) in rules {
-            let first = RangeRef::top_left(&cf.ranges).unwrap_or(c);
+            let first = cf.ranges.first().map(|r| r.start).unwrap_or(c);
            let st: &RuleStats = match stats_need(&cf.rule) {
                Some(need) => &*self.stats.entry(idx).or_insert_with(|| RuleStats::build(sh, &cf.ranges, need)),
                None => &no_stats,
@@ -17,13 +17,11 @@ const MAX_ROW_SPAN: usize = gridcraft_core::MAX_ROWS as usize;
 /// table is ignored: the HTML only refines cells of the tab-separated text, which stays the source.
 const MAX_HTML_CELLS: usize = 1_000_000;

-/// One table cell: its visible text, the number the source recorded for it, if any, and whether
-/// it is a header cell (`<th>`).
+/// One table cell: its visible text and the number the source recorded for it, if any.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub(crate) struct HtmlCell {
    pub text: String,
    pub num: Option<f64>,
-    pub header: bool,
 }

 /// The cells of the first table in `html`, row by row, read no further than `max_rows` rows of
@@ -90,7 +88,7 @@ pub(crate) fn table_cells(html: &str, max_rows: usize, max_cols: usize) -> Vec<V
                let num = attr(attrs, "x:num").or_else(|| attr(attrs, "sdval")).and_then(|v| v.trim().parse::<f64>().ok()).filter(|n| n.is_finite());
                let colspan = span(attrs, "colspan", MAX_SPAN);
                let rowspan = span(attrs, "rowspan", MAX_ROW_SPAN);
-                cell = Some(OpenCell { cell: HtmlCell { text: String::new(), num, header: name == "th" }, colspan, rowspan });
+                cell = Some(OpenCell { cell: HtmlCell { text: String::new(), num }, colspan, rowspan });
            }
            ("td" | "th", true) | ("tr", true) => grid.finish(&mut cell),
            ("br", _) => {
@@ -378,18 +376,18 @@ mod tests {
            <tr><td colspan=2 x:num="2.5">2.50 &amp; up</td><td>x</td></tr><!--EndFragment--></table></body></html>"#;
        let rows = table_cells(excel, 2, 3);
        assert_eq!(rows.len(), 2);
-        assert_eq!(rows[0][0], HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0), ..HtmlCell::default() });
-        assert_eq!(rows[0][1], HtmlCell { text: "Name".into(), num: None, ..HtmlCell::default() });
+        assert_eq!(rows[0][0], HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0) });
+        assert_eq!(rows[0][1], HtmlCell { text: "Name".into(), num: None });
        assert_eq!(rows[1].len(), 3, "colspan keeps the next cell in its column");
        assert_eq!(rows[1][0].text, "2.50 & up");
        assert_eq!(rows[1][2].text, "x");

        let calc = r#"<table cellspacing="0" border="0"><colgroup width="85"></colgroup><tr>
            <td height="17" align="right" sdval="10000" sdnum="1033;0;[$Rp-421]#,##0.00"><font face="Liberation Sans">Rp10,000.00</font></td></tr></table>"#;
-        assert_eq!(table_cells(calc, 1, 1), vec![vec![HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0), ..HtmlCell::default() }]]);
+        assert_eq!(table_cells(calc, 1, 1), vec![vec![HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0) }]]);

        let quoted_gt = r#"<table><tr><td style='mso-number-format:"\[>=1000\]0"' x:num="1500">1500</td></tr></table>"#;
-        assert_eq!(table_cells(quoted_gt, 1, 1), vec![vec![HtmlCell { text: "1500".into(), num: Some(1500.0), ..HtmlCell::default() }]]);
+        assert_eq!(table_cells(quoted_gt, 1, 1), vec![vec![HtmlCell { text: "1500".into(), num: Some(1500.0) }]]);
    }

    #[test]
@@ -436,7 +434,7 @@ mod tests {
        assert!(cells <= MAX_HTML_CELLS, "{cells} cells");
        assert!(rows.iter().all(|r| r.len() <= MAX_SPAN));
        assert_eq!(rows[0].len(), MAX_SPAN, "the first span fills the sheet's width");
-        assert_eq!(rows[0][0], HtmlCell { text: "1".into(), num: Some(1.0), ..HtmlCell::default() });
+        assert_eq!(rows[0][0], HtmlCell { text: "1".into(), num: Some(1.0) });

        // Bounded by the pasted text's shape, the same markup yields just that shape.
        let rows = table_cells(&html, 3, 2);
@@ -2,11 +2,9 @@
 //! `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;
-pub mod equation;
 pub mod extra;
 pub mod file;
 pub mod forecast;
@@ -17,7 +15,6 @@ pub mod inspect;
 pub mod macros;
 pub mod pivot;
 pub mod print;
-pub mod python;
 pub mod review;
 pub mod sheet;
 pub mod slicer;
@@ -43,11 +40,7 @@ pub struct CommandSpec {
    pub label: &'static str,
    /// Ribbon/menu placement, e.g. `["Home", "Font"]`. Empty = not in menus.
    pub menu: &'static [&'static str],
-    /// Portable notation: `Cmd` is ⌘ on macOS and Ctrl elsewhere.
    pub shortcut: Option<&'static str>,
-    /// macOS override when its key differs. Equal to `shortcut` marks a Mac-only shortcut
-    /// (Align Left/Center): other platforms show none. See [`CommandInfo::shortcut_for_platform`].
-    pub shortcut_mac: Option<&'static str>,
    pub params: &'static str,
    pub enabled: Enabled,
    pub run: Run,
@@ -61,32 +54,12 @@ pub struct CommandInfo {
    pub label: &'static str,
    pub menu: Vec<&'static str>,
    pub shortcut: Option<&'static str>,
-    pub shortcut_mac: Option<&'static str>,
    pub params: &'static str,
    pub enabled: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disabled_reason: Option<String>,
 }

-impl CommandInfo {
-    /// Format the portable shortcut notation for the runtime operating system.
-    pub fn shortcut_for_platform(&self, mac: bool) -> Option<String> {
-        let keys = if mac {
-            self.shortcut_mac.or(self.shortcut)
-        } else if self.shortcut_mac.is_some() && self.shortcut_mac == self.shortcut {
-            // An identical Mac override marks a Mac-only display shortcut.
-            // The portable field remains unchanged for legacy CLI consumers.
-            None
-        } else {
-            self.shortcut
-        }?;
-        if mac {
-            return Some(keys.to_owned());
-        }
-        Some(keys.split('+').map(|part| if part == "Cmd" { "Ctrl" } else { part }).collect::<Vec<_>>().join("+"))
-    }
-}
-
 impl CommandSpec {
    pub fn info(&self, s: &Session) -> CommandInfo {
        let e = (self.enabled)(s);
@@ -95,7 +68,6 @@ impl CommandSpec {
            label: self.label,
            menu: self.menu.to_vec(),
            shortcut: self.shortcut,
-            shortcut_mac: self.shortcut_mac,
            params: self.params,
            enabled: e.is_ok(),
            disabled_reason: e.err(),
@@ -146,13 +118,13 @@ pub fn has_clipboard(s: &Session) -> std::result::Result<(), String> {

 macro_rules! cmd {
    ($id:literal, $label:literal, [$($m:literal),*], $sc:expr, $params:literal, $en:expr, $run:expr) => {
-        $crate::cmd::CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc, shortcut_mac: None, params: $params, enabled: $en, run: $run, journal: true, undoable: true }
+        $crate::cmd::CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc, params: $params, enabled: $en, run: $run, journal: true, undoable: true }
    };
    (query $id:literal, $label:literal, [$($m:literal),*], $sc:expr, $params:literal, $en:expr, $run:expr) => {
-        $crate::cmd::CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc, shortcut_mac: None, params: $params, enabled: $en, run: $run, journal: false, undoable: false }
+        $crate::cmd::CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc, params: $params, enabled: $en, run: $run, journal: false, undoable: false }
    };
    (noundo $id:literal, $label:literal, [$($m:literal),*], $sc:expr, $params:literal, $en:expr, $run:expr) => {
-        $crate::cmd::CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc, shortcut_mac: None, params: $params, enabled: $en, run: $run, journal: true, undoable: false }
+        $crate::cmd::CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc, params: $params, enabled: $en, run: $run, journal: true, undoable: false }
    };
 }
 pub(crate) use cmd;
@@ -166,8 +138,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());
        v.extend(review::specs());
@@ -179,7 +149,6 @@ pub fn command_specs() -> &'static [CommandSpec] {
        v.extend(spelling::specs());
        v.extend(solver::specs());
        v.extend(pivot::specs());
-        v.extend(python::specs());
        v.extend(slicer::specs());
        v.extend(whatif::specs());
        v.extend(forecast::specs());
@@ -211,7 +180,6 @@ pub fn register_test_command(id: &'static str, run: Run) {
        label: id,
        menu: &[],
        shortcut: None,
-        shortcut_mac: None,
        params: "",
        enabled: |_| Ok(()),
        run,
@@ -229,7 +197,6 @@ pub(crate) fn register_undoable_test_command(id: &'static str, run: Run) {
        label: id,
        menu: &[],
        shortcut: None,
-        shortcut_mac: None,
        params: "",
        enabled: |_| Ok(()),
        run,
@@ -406,19 +373,13 @@ 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;
-    // 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();
+    let Ctx { mut wb, changed, structural, mut fit_rows, protection_checked, edits, .. } = ctx;
    if !protection_checked {
        check_protection(&d.wb, &wb, &d.unlocked_ranges)?;
    }
    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 +401,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 +417,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;
@@ -576,11 +425,8 @@ pub(crate) const TOUCH_LOG_LIMIT: usize = 1_000_000;
 pub(crate) const PROTECTED: &str = "The cell or chart you're trying to change is on a protected sheet.";

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

-/// Two cells hold the same value, formula or Python code (formats aside; a Python cell's result
-/// is not something the person edits).
+/// Two cells hold the same value or formula (formats aside).
 fn same_content(a: Option<&gridcraft_model::Cell>, b: Option<&gridcraft_model::Cell>) -> bool {
-    let empty = |c: Option<&gridcraft_model::Cell>| c.is_none_or(|c| !c.has_content());
+    let empty = |c: Option<&gridcraft_model::Cell>| c.is_none_or(|c| c.formula.is_none() && c.value.is_empty());
    match (a, b) {
        (Some(a), Some(b)) => match (&a.formula, &b.formula) {
            (Some(x), Some(y)) => x.text == y.text && x.array == y.array,
-            (None, None) => match (&a.py, &b.py) {
-                (Some(x), Some(y)) => x.code == y.code && x.object == y.object,
-                (None, None) => a.value == b.value,
-                _ => false,
-            },
+            (None, None) => a.value == b.value,
            _ => false,
        },
        _ => empty(a) && empty(b),
@@ -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);
-        }
-    }
-}
@@ -99,30 +99,18 @@ pub fn specs() -> Vec<CommandSpec> {
        ),
        cmd!(query "data.validate", "Check Value Against Validation", [], None, "{cell?, input} → {ok, message?}", has_doc, validate_cmd),
        cmd!(noundo "data.circleInvalid", "Circle Invalid Data", ["Data", "Data Tools", "Data Validation"], None, "{} → invalid cells", has_doc, circle_invalid),
-        CommandSpec {
-            shortcut_mac: Some("Cmd+Shift+K"),
-            ..cmd!(
-                "data.group",
-                "Group",
-                ["Data", "Outline"],
-                Some("Alt+Shift+Right"),
-                "{rows?: \"2:5\" | cols?: \"B:C\" | by?: rows|cols (the selection's rows or columns; a block of cells groups rows by default), sheet?}",
-                has_doc,
-                |s, p| group(s, p, true)
-            )
-        },
-        CommandSpec {
-            shortcut_mac: Some("Cmd+Shift+J"),
-            ..cmd!(
-                "data.ungroup",
-                "Ungroup",
-                ["Data", "Outline"],
-                Some("Alt+Shift+Left"),
-                "{rows? | cols? | by?: rows|cols, sheet?}",
-                has_doc,
-                |s, p| { group(s, p, false) }
-            )
-        },
+        cmd!(
+            "data.group",
+            "Group",
+            ["Data", "Outline"],
+            Some("Alt+Shift+Right"),
+            "{rows?: \"2:5\" | cols?: \"B:C\" | by?: rows|cols (the selection's rows or columns; a block of cells groups rows by default), sheet?}",
+            has_doc,
+            |s, p| group(s, p, true)
+        ),
+        cmd!("data.ungroup", "Ungroup", ["Data", "Outline"], Some("Alt+Shift+Left"), "{rows? | cols? | by?: rows|cols, sheet?}", has_doc, |s, p| {
+            group(s, p, false)
+        }),
        cmd!(
            "data.hideDetail",
            "Hide Detail",
@@ -270,7 +270,6 @@ pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) {

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

 pub(super) fn reapply(s: &mut Session, _: &Json) -> Result<Json> {
    let sheet = s.doc()?.wb.active_sheet();
-    crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?;
    edit(s, |cx| {
        apply_filter(&mut cx.wb, sheet);
        cx.structural = true;
@@ -21,15 +21,6 @@ fn outline_lines(s: &Session, p: &Json) -> Result<(bool, u32, u32)> {
    }
 }

-/// Outline commands change line visibility and grouping: a protected sheet must allow formatting that axis.
-fn refuse_unless_outline_allowed(s: &Session, sheet: usize, rows: bool) -> Result<()> {
-    if rows {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting rows", |p| p.format_rows)
-    } else {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting columns", |p| p.format_columns)
-    }
-}
-
 pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
    let si = target_sheet(s, p)?;
    // The selection belongs to the active sheet, so another sheet needs its lines.
@@ -37,7 +28,6 @@ pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
        return Err(bad(if on { "data.group" } else { "data.ungroup" }, "missing `rows` or `cols`: the selection is on the active sheet"));
    }
    let (rows, a, b) = outline_lines(s, p)?;
-    refuse_unless_outline_allowed(s, si, rows)?;
    edit(s, |cx| {
        let sh = cx.sheet_mut(si)?;
        let before = outline::summary_before(sh, rows);
@@ -68,7 +58,6 @@ pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result<Json> {
 /// + button, saved to XLSX); showing keeps inner groups that were collapsed on their own collapsed.
 pub(super) fn detail(s: &mut Session, p: &Json, hide: bool) -> Result<Json> {
    let (rows, a, b) = outline_lines(s, p)?;
-    refuse_unless_outline_allowed(s, s.doc()?.wb.active_sheet(), rows)?;
    let want = p.get("level").and_then(Json::as_u64).map(|l| l.min(outline::MAX_LEVEL as u64) as u8);
    edit(s, |cx| {
        let si = cx.sheet_index();
@@ -134,12 +123,6 @@ pub(super) fn show_levels(s: &mut Session, p: &Json) -> Result<Json> {
            msg: "give `rows` or `cols`: the outline level to show (1 = top-level summaries only)".into(),
        });
    }
-    let active = s.doc()?.wb.active_sheet();
-    for (n, is_rows) in [(rows, true), (cols, false)] {
-        if n.is_some() {
-            refuse_unless_outline_allowed(s, active, is_rows)?;
-        }
-    }
    edit(s, |cx| {
        let si = cx.sheet_index();
        let sh = cx.sheet_mut(si)?;
@@ -195,7 +195,8 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec<S
        // The object's own geometry (its top-left anchor cell, offset and size) is read from the
        // pre-sort `sh`; a two-cell object's bottom-right cell is derived from its size here so it
        // can be re-fitted to the lines it spans after the sort.
-        let objs: Vec<Anchor> = sh.object_anchors().copied().collect();
+        let objs: Vec<Anchor> =
+            sh.images.iter().map(|o| o.anchor).chain(sh.charts.iter().map(|o| o.anchor)).chain(sh.shapes.iter().map(|o| o.anchor)).collect();
        let descs: Vec<(u32, u32, f32, f32)> = objs
            .iter()
            .map(|a| {
@@ -241,22 +242,33 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec<S
                }
            }
        }
-        // Re-anchor floating objects now that the row heights are final. `objs` was collected in
-        // `object_anchors` order, which `object_anchors_mut` repeats.
+        // Re-anchor floating objects now that the row heights are final. `objs` was collected as
+        // images ++ charts ++ shapes, so the same index maps straight onto each vec.
        // Only objects anchored inside the sorted block move: within its lines on the sort axis
        // and within its span on the other axis (a picture beside the block stays put).
        let (b0, b1) = if by_cols { (body.start.col, body.end.col) } else { (body.start.row, body.end.row) };
        let (o0, o1) = if by_cols { (body.start.row, body.end.row) } else { (body.start.col, body.end.col) };
-        let new_anchors: Vec<Anchor> = objs
-            .into_iter()
-            .zip(descs)
-            .map(|(a, desc)| {
-                let other = if by_cols { a.cell.row } else { a.cell.col };
-                if other < o0 || other > o1 { a } else { sorted_anchor(shm, a, desc, by_cols, b0, b1, &dst_of) }
-            })
-            .collect();
-        for (a, n) in shm.object_anchors_mut().zip(new_anchors) {
-            *a = n;
+        let ni = shm.images.len();
+        let nch = shm.charts.len();
+        for (i, (a, desc)) in objs.into_iter().zip(descs).enumerate() {
+            let other = if by_cols { a.cell.row } else { a.cell.col };
+            if other < o0 || other > o1 {
+                continue;
+            }
+            let na = sorted_anchor(shm, a, desc, by_cols, b0, b1, &dst_of);
+            if na != a {
+                if i < ni {
+                    if let Some(o) = shm.images.get_mut(i) {
+                        o.anchor = na;
+                    }
+                } else if i < ni + nch {
+                    if let Some(o) = shm.charts.get_mut(i - ni) {
+                        o.anchor = na;
+                    }
+                } else if let Some(o) = shm.shapes.get_mut(i - ni - nch) {
+                    o.anchor = na;
+                }
+            }
        }
        for (c, _) in moved {
            cx.changed.push((sheet, c));
@@ -272,9 +284,7 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec<S
 /// line index on the moving axis and is the identity outside `b0..=b1`. `sh` is the post-sort
 /// grid (row heights already reordered), so re-fitting uses the heights the object lands on.
 /// Objects pinned absolutely ("Don't move or size with cells") never move; "move but don't size"
-/// keeps its size; "move and size" is re-fitted when its whole extent stays inside the body, and
-/// keeps its size when the sort turns its lines around (its bottom line now sorts before its top
-/// line), since the lines then enclose nothing to stretch it between.
+/// keeps its size; "move and size" is re-fitted when its whole extent stays inside the body.
 fn sorted_anchor(sh: &Sheet, a: Anchor, bottom: (u32, u32, f32, f32), by_cols: bool, b0: u32, b1: u32, dst_of: &[u32]) -> Anchor {
    if a.mode == AnchorMode::Absolute {
        return a;
@@ -292,10 +302,7 @@ fn sorted_anchor(sh: &Sheet, a: Anchor, bottom: (u32, u32, f32, f32), by_cols: b
        let y1 = sh.row_top(nr) + a.dy as f64;
        let x2 = sh.col_left(nbc) + tdx as f64;
        let y2 = sh.row_top(nbr) + tdy as f64;
-        // An extent that is not positive means the sort put the bottom-right line before the
-        // top-left one on that axis: the object keeps its old size there.
-        let fit = |extent: f64, old: f32| if extent > 0.0 { extent as f32 } else { old.max(0.0) };
-        Anchor { cell: CellRef::new(nr, nc), dx: a.dx, dy: a.dy, width: fit(x2 - x1, a.width), height: fit(y2 - y1, a.height), mode: a.mode }
+        Anchor { cell: CellRef::new(nr, nc), dx: a.dx, dy: a.dy, width: (x2 - x1).max(0.0) as f32, height: (y2 - y1).max(0.0) as f32, mode: a.mode }
    } else {
        Anchor { cell: CellRef::new(nr, nc), ..a }
    }
@@ -480,45 +480,6 @@ fn a_list_typed_without_quotes_is_saved_as_a_quoted_list() {
    assert_eq!(sheet_xml(&reopened), xml, "a second save writes the same rules");
 }

-#[test]
-fn a_relative_list_source_is_read_from_the_cell_being_checked() {
-    // As in Excel, `=$B1:$B2` on A3:A4,A1:A2 is written for A1 (the top-left cell of all the
-    // areas) and lists B4:B5 at A4. It used to list B1:B2 in every cell.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "B1:B5", "values": [["a"], ["b"], ["c"], ["d"], ["e"]]})).unwrap();
-    s.execute("data.validation", json!({"range": "A3:A4,A1:A2", "type": "list", "formula1": "=$B1:$B2"})).unwrap();
-    let wb = s.doc().unwrap().wb.clone();
-    let dv = wb.active().unwrap().validations[0].clone();
-    for (cell, items) in [("A1", ["a", "b"]), ("A2", ["b", "c"]), ("A3", ["c", "d"]), ("A4", ["d", "e"])] {
-        let at = CellRef::parse(cell).unwrap();
-        assert_eq!(list_items(&wb, 0, at, &dv), items, "{cell}");
-        for v in ["a", "b", "c", "d", "e"] {
-            assert_eq!(check_validation(&wb, 0, at, v).is_none(), items.contains(&v), "{cell} with {v}");
-        }
-    }
-}
-
-#[test]
-fn a_list_source_that_takes_in_the_cell_does_not_list_the_value_being_typed() {
-    // `=$A1:$A2` on A2:A3 is A1:A2 at A2 and A2:A3 at A3. The list is the one before the entry, as
-    // in Excel; a new value used to land in its own source and pass.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:A2", "values": [["x"], ["y"]]})).unwrap();
-    s.execute("data.validation", json!({"range": "A2:A3", "type": "list", "formula1": "=$A1:$A2"})).unwrap();
-    let wb = &s.doc().unwrap().wb;
-    for (cell, accepted, refused) in [("A2", &["x", "y"][..], &["new"][..]), ("A3", &["y"], &["x", "new"])] {
-        let at = CellRef::parse(cell).unwrap();
-        for v in accepted {
-            assert!(check_validation(wb, 0, at, v).is_none(), "{cell} refuses {v}");
-        }
-        for v in refused {
-            assert!(check_validation(wb, 0, at, v).is_some(), "{cell} accepts {v}");
-        }
-    }
-}
-
 #[test]
 fn a_rule_with_an_unknown_type_operator_or_error_style_is_refused() {
    // A typo used to give a rule that validates nothing (`type="none"`) or the wrong check,
@@ -146,16 +146,7 @@ pub(super) fn text_to_columns(s: &mut Session, p: &Json) -> Result<Json> {
            }
        }
        for (c, t) in out {
-            let cell = match crate::cmd::edit::input_to_cell(&t, sheet, c, &mut cx.wb) {
-                Ok(cell) => cell,
-                // `=PY(…)` doesn't make a Python cell (that takes python.set): the piece is kept
-                // as text rather than lost.
-                Err(_) if gridcraft_model::python::is_py_formula(&t) => {
-                    let style = cx.wb.sheet(sheet).map(|sh| sh.style_id(c)).unwrap_or_default();
-                    Some(Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style, py: None })
-                }
-                Err(_) => None,
-            };
+            let cell = crate::cmd::edit::input_to_cell(&t, sheet, c, &mut cx.wb).unwrap_or(None);
            let shm = cx.sheet_mut(sheet)?;
            match cell {
                Some(x) => shm.set_cell(c, x),
@@ -18,85 +18,30 @@ 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
 }

 /// Removes the cells of `cuts` from every validation, keeping the rest of each rule's ranges.
-/// When the rule's top-left cell goes, its relative formulas are rewritten for the new top-left
-/// cell, so the cells left keep checking the same cells.
 pub(in super::super) fn remove_validation_cells(validations: &mut Vec<Validation>, cuts: &[RangeRef]) {
    for dv in validations.iter_mut() {
-        let before = RangeRef::top_left(&dv.ranges);
-        dv.ranges = dv.ranges.iter().flat_map(|r| subtract_ranges(*r, cuts)).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));
+        for cut in cuts {
+            dv.ranges = dv.ranges.iter().flat_map(|r| subtract_range(*r, cut)).collect();
        }
    }
    validations.retain(|d| !d.ranges.is_empty());
@@ -200,10 +145,8 @@ fn list_source(f: &str) -> String {
    format!("\"{}\"", t.replace('"', "\"\""))
 }

-/// List entries of a list validation (literal or from a range) for the cell `at`. A relative
-/// source is written for the rule's top-left cell and read from `at`, as in Excel (`=$B1:$B3` on
-/// A1:A9 lists B5:B7 at A5).
-pub fn list_items(wb: &Workbook, sheet: usize, at: CellRef, dv: &Validation) -> Vec<String> {
+/// List entries of a list validation (literal or from a range).
+pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec<String> {
    let f = dv.f1.trim();
    if is_literal_list(f) {
        // A quoted list is a string literal: `""` inside stands for one `"`.
@@ -213,8 +156,8 @@ pub fn list_items(wb: &Workbook, sheet: usize, at: CellRef, dv: &Validation) ->
        };
        return items.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect();
    }
-    let first = RangeRef::top_left(&dv.ranges).unwrap_or(at);
-    match gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at)) {
+    let at = dv.ranges.first().map(|r| r.start).unwrap_or_default();
+    match gridcraft_calc::evaluate(wb, sheet, at, f) {
        Value::Array(a) => a.data.iter().filter(|v| !v.is_empty()).map(Value::display).collect(),
        v if !v.is_empty() && !v.is_error() => vec![v.display()],
        _ => vec![],
@@ -232,10 +175,9 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) -
        return None;
    }
    let v = gridcraft_core::parse::parse_input(input, wb.date_system).value;
-    // The formulas are written for the top-left cell of all the areas and see the value being entered,
+    // The formulas are written for the first cell of the range and see the value being entered,
    // as in Excel (a custom `=A1>10` on A1:A9 checks A5's new value at A5).
-    let first = RangeRef::top_left(&dv.ranges).unwrap_or(at);
-    let original = wb;
+    let first = dv.ranges.first().map(|r| r.start).unwrap_or(at);
    let entered;
    let wb = if sh.value(at) == v {
        wb
@@ -251,9 +193,7 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) -
    let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at));
    let num = |f: &str| eval(f).to_number().ok();
    let ok = match dv.kind {
-        // The list is the one the dropdown showed before the entry, as in Excel: a source that takes
-        // in the cell itself (`=$A1:$A2` on A2:A3 is A2:A3 at A3) doesn't list the value being typed.
-        ValidationKind::List => list_items(original, sheet, at, dv).iter().any(|x| x.eq_ignore_ascii_case(input)),
+        ValidationKind::List => list_items(wb, sheet, dv).iter().any(|x| x.eq_ignore_ascii_case(input)),
        ValidationKind::Custom => eval(&dv.f1).to_bool().unwrap_or(false),
        ValidationKind::TextLength => {
            let n = input.chars().count() as f64;
@@ -80,7 +80,6 @@ fn stroke(s: &mut Session, p: &Json) -> Result<Json> {
    let text = pts.iter().map(|q| format!("{:.1},{:.1}", q[0] - minx, q[1] - miny)).collect::<Vec<_>>().join(";");
    let id = d.wb.next_object_id();
    let shape = Shape {
-        math: Default::default(),
        id,
        kind: ShapeKind::Ink,
        anchor: Anchor {
@@ -20,10 +20,10 @@ mod paste_special;
 mod selection;

 use cell::{cell_set, range_fill, range_set_values};
-pub(crate) use cell::{check_arg_counts, input_to_cell, is_formula_input, json_to_input, parse_typed_formula};
+pub(crate) use cell::{check_arg_counts, input_to_cell, json_to_input, parse_typed_formula};
 #[cfg(test)]
 pub(crate) use clipboard::parse_tsv;
-use clipboard::{clear_clipboard, copy, cut, paste, range_move};
+use clipboard::{clear_clipboard, copy, cut, paste};
 use fill::{auto_fill, fill_dir, fill_series, flash_fill};
 #[cfg(test)]
 use find::replace_ci;
@@ -35,8 +35,8 @@ use go_to::go_to_special;
 #[cfg(test)]
 use go_to::{GO_TO_MAX_AREAS, GO_TO_RECENT, reference_parts};
 use paste_special::paste_special;
-pub(crate) use paste_special::{rewrite_all_formulas, rewrite_cell_links, rewrite_python_refs};
-use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_next_corner, selection_set};
+pub(crate) use paste_special::rewrite_all_formulas;
+use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_set};

 pub fn specs() -> Vec<CommandSpec> {
    vec![
@@ -46,7 +46,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Set Values",
            [],
            None,
-            "{range?: \"A1\", values: [[...]] (rows of numbers/strings/bools/null; strings starting with = are formulas), parse?: bool (default true: a string goes through typed input, so \"05.04.2026\" becomes a date and \"2.500\" a number, by en-US rules; false stores every other string as the text it is, so a dd.mm.yyyy date or a thousands separator survives, a leading ' is kept and an empty string clears the cell)} → {cells, convertedCount, converted: [{cell, input, stored}] (up to 20 of the strings typed input read as a number, date, time, boolean or error, so a script can notice)}",
+            "{range?: \"A1\", values: [[...]] (rows of numbers/strings/bools/null; strings starting with = are formulas), parse?: bool (default true: a string goes through typed input, so \"05.04.2026\" becomes a date and \"2.500\" a number, by en-US rules; false stores every other string as the text it is, so a dd.mm.yyyy date or a thousands separator survives)}",
            has_doc,
            range_set_values
        ),
@@ -62,15 +62,6 @@ pub fn specs() -> Vec<CommandSpec> {
        cmd!(noundo "selection.set", "Select", [], None, "{range: \"A1:B2,D4\" | cell, active?: \"A1\", sheet?}", has_doc, selection_set),
        cmd!(noundo "selection.move", "Move Selection", [], None, "{dr, dc, extend?: bool, jump?: bool (Ctrl+arrow), page?: bool}", has_doc, selection_move),
        cmd!(noundo "selection.next", "Next Cell in Selection", [], None, "{forward?: true, byRow?: false} (Enter/Tab inside a selection)", has_doc, selection_next),
-        cmd!(
-            noundo "selection.nextCorner",
-            "Next Corner of Selection",
-            [],
-            Some("Ctrl+."),
-            "{} (the active cell moves clockwise to the next corner of the selected area, which stays selected)",
-            has_doc,
-            selection_next_corner
-        ),
        cmd!(noundo "edit.selectAll", "Select All", ["Edit"], Some("Cmd+A"), "{} (current region first, then the whole sheet)", has_doc, select_all),
        cmd!(noundo "selection.currentRegion", "Select Current Region", [], Some("Ctrl+Shift+8"), "{}", has_doc, select_region),
        cmd!(noundo "selection.row", "Select Entire Row", [], Some("Shift+Space"), "{}", has_doc, select_row),
@@ -91,26 +82,14 @@ pub fn specs() -> Vec<CommandSpec> {
            paste
        ),
        cmd!(
-            "range.move",
-            "Drag and Drop",
-            [],
-            None,
-            "{range?, to: \"C3\", overwrite?: bool} (drag the selection's border: a cut and paste that asks before replacing data unless overwrite)",
-            has_doc,
-            range_move
+            "edit.pasteSpecial",
+            "Paste Special…",
+            ["Home", "Clipboard"],
+            Some("Ctrl+Cmd+V"),
+            "{what: all|formulas|values|formats|comments|validation|allExceptBorders|columnWidths|formulasAndNumberFormats|valuesAndNumberFormats, operation?: none|add|subtract|multiply|divide, skipBlanks?, transpose?, link?}",
+            has_clipboard,
+            paste_special
        ),
-        CommandSpec {
-            shortcut_mac: Some("Ctrl+Cmd+V"),
-            ..cmd!(
-                "edit.pasteSpecial",
-                "Paste Special…",
-                ["Home", "Clipboard"],
-                Some("Ctrl+Alt+V"),
-                "{what: all|formulas|values|formats|comments|validation|allExceptBorders|columnWidths|formulasAndNumberFormats|valuesAndNumberFormats, operation?: none|add|subtract|multiply|divide, skipBlanks?, transpose?, link?}",
-                has_clipboard,
-                paste_special
-            )
-        },
        cmd!(noundo "edit.clearClipboard", "Cancel Copy", [], Some("Escape"), "{}", has_doc, clear_clipboard),
        cmd!("edit.clearAll", "Clear All", ["Home", "Editing", "Clear"], None, "{range?}", has_doc, |s, p| clear(s, p, "all")),
        cmd!("edit.clearFormats", "Clear Formats", ["Home", "Editing", "Clear"], None, "{range?}", has_doc, |s, p| clear(s, p, "formats")),
@@ -144,13 +123,13 @@ pub fn specs() -> Vec<CommandSpec> {
            fill_series
        ),
        cmd!("edit.flashFill", "Flash Fill", ["Home", "Editing", "Fill"], Some("Ctrl+E"), "{range?}", has_doc, flash_fill),
-        cmd!(noundo "edit.find", "Find…", ["Home", "Editing", "Find & Select"], Some("Cmd+F"), "{what, matchCase?, wholeCell?, lookIn?: formulas|values, byColumns?, all?: bool, within?: sheet|workbook|selection} (selection: only the selected cells; Find Next keeps them selected and moves the active cell)", has_doc, find),
+        cmd!(noundo "edit.find", "Find…", ["Home", "Editing", "Find & Select"], Some("Cmd+F"), "{what, matchCase?, wholeCell?, lookIn?: formulas|values, byColumns?, all?: bool, within?: sheet|workbook}", has_doc, find),
        cmd!(
            "edit.replace",
            "Replace…",
            ["Home", "Editing", "Find & Select"],
            Some("Ctrl+H"),
-            "{what, with, matchCase?, wholeCell?, all?: true, within?: sheet|workbook|selection} → {replaced, skipped?} (in a Python cell the code is edited; skipped counts Python cells whose code would no longer fit)",
+            "{what, with, matchCase?, wholeCell?, all?: true, within?: sheet|workbook}",
            has_doc,
            replace
        ),
@@ -204,8 +183,6 @@ fn undo(s: &mut Session, p: &Json) -> Result<Json> {
        label = e.label.clone();
        d.wb = e.wb;
        d.selection = e.selection;
-        // Step by step: a rename and a new sheet undone together match up only one step apart.
-        super::extra::keep_view_modes(d, &cur_wb);
        crate::push_history(&mut d.redo, label.clone(), cur_wb, &d.wb, cur_selection);
    }
    super::extra::keep_watch_list(&now, &mut d.wb);
@@ -226,7 +203,6 @@ fn redo(s: &mut Session, p: &Json) -> Result<Json> {
        label = e.label.clone();
        d.wb = e.wb;
        d.selection = e.selection;
-        super::extra::keep_view_modes(d, &cur_wb);
        crate::push_history(&mut d.undo, label.clone(), cur_wb, &d.wb, cur_selection);
    }
    super::extra::keep_watch_list(&now, &mut d.wb);
@@ -262,36 +238,21 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
            })
        })
    };
-    // Notes and links aren't cell contents, so the cell comparison that guards a protected sheet
-    // doesn't see them go: a locked cell's are refused here, stored cell or not.
-    if matches!(what, "all" | "comments" | "hyperlinks") {
-        let d = s.doc()?;
-        if let Some(sh) = d.wb.sheet(sheet).filter(|sh| sh.is_protected()) {
-            for &whole in &ranges {
-                let skip = filtered_rows(sh, whole);
-                let notes = matches!(what, "all" | "comments").then(|| sh.comments.keys()).into_iter().flatten();
-                let links = matches!(what, "all" | "hyperlinks").then(|| sh.hyperlinks.keys()).into_iter().flatten();
-                for &c in notes.chain(links).filter(|c| whole.contains(**c) && !skip.contains(&c.row)) {
-                    if d.wb.styles.get(sh.style_id(c)).protection.locked
-                        && let Some(m) = locked_cell_error(sh, c, &d.unlocked_ranges)
-                    {
-                        return Err(EngineError::Other(m));
-                    }
-                }
-            }
-        }
-    }
    edit(s, |cx| {
-        for &whole in &ranges {
-            // Cells are only stored inside the used range. Notes and links are kept apart from
-            // them, so they are cleared over the whole range: one from a file can sit on a cell
-            // with nothing stored in it.
-            let used = cx.wb.sheet(sheet).and_then(|sh| sh.used_range()).and_then(|u| whole.intersection(&u));
-            let skip = cx.wb.sheet(sheet).map(|sh| filtered_rows(sh, whole)).unwrap_or_default();
-            let cells: Vec<(CellRef, Cell)> = match (cx.wb.sheet(sheet), used) {
-                (Some(sh), Some(r)) => sh.cells.iter_range(r).filter(|(c, _)| !skip.contains(&c.row)).map(|(c, x)| (c, x.clone())).collect(),
-                _ => Vec::new(),
+        for r in &ranges {
+            let r = match cx.wb.sheet(sheet).and_then(|sh| sh.used_range()) {
+                Some(u) => match r.intersection(&u) {
+                    Some(x) => x,
+                    None => continue,
+                },
+                None => continue,
            };
+            let skip = cx.wb.sheet(sheet).map(|sh| filtered_rows(sh, r)).unwrap_or_default();
+            let cells: Vec<(CellRef, Cell)> = cx
+                .wb
+                .sheet(sheet)
+                .map(|sh| sh.cells.iter_range(r).filter(|(c, _)| !skip.contains(&c.row)).map(|(c, x)| (c, x.clone())).collect())
+                .unwrap_or_default();
            // Report every stored cell we touch, even beyond a million coordinates in a sparse
            // selection. Removed formula anchors must also reach calc so their spills disappear.
            cx.changed.extend(cells.iter().map(|(c, _)| (sheet, *c)));
@@ -300,7 +261,6 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
                for (_, cell) in cells.iter_mut() {
                    let checkbox = cx.wb.styles.get(cell.style).num_fmt.as_str() == "checkbox";
                    cell.formula = None;
-                    cell.py = None;
                    if checkbox && uncheck_only {
                        cell.value = Value::Bool(false);
                    } else {
@@ -311,18 +271,6 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
                    }
                }
            }
-            let cleared = |c: CellRef| whole.contains(c) && !skip.contains(&c.row);
-            // A removed note or link changes its cell even with nothing stored there.
-            let metadata: Vec<CellRef> = cx
-                .wb
-                .sheet(sheet)
-                .map(|sh| {
-                    let notes = matches!(what, "all" | "comments").then(|| sh.comments.keys()).into_iter().flatten();
-                    let links = matches!(what, "all" | "hyperlinks").then(|| sh.hyperlinks.keys()).into_iter().flatten();
-                    notes.chain(links).copied().filter(|c| cleared(*c)).collect()
-                })
-                .unwrap_or_default();
-            cx.changed.extend(metadata.into_iter().map(|c| (sheet, c)));
            let sh = cx.sheet_mut(sheet)?;
            for (c, mut cell) in cells {
                match what {
@@ -339,15 +287,14 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result<Json> {
                    _ => {}
                }
            }
+            let cleared = |c: CellRef| r.contains(c) && !skip.contains(&c.row);
            if matches!(what, "all" | "comments") {
                sh.comments.retain(|c, _| !cleared(*c));
            }
            if matches!(what, "all" | "hyperlinks") {
                sh.hyperlinks.retain(|c, _| !cleared(*c));
            }
-            if let Some(r) = used
-                && matches!(what, "all" | "formats")
-            {
+            if matches!(what, "all" | "formats") {
                let mut unmerged = false;
                sh.merges.retain(|m| {
                    let keep = !r.contains_range(m) || skip.range(m.start.row..=m.end.row).next().is_some();
@@ -5,36 +5,24 @@ use super::{

 // ---------------------------------------------------------------- entry

-/// Typing `=PY(` doesn't make a Python cell; this says what does.
-pub(crate) const PY_FORMULA: &str = "Python cells are made with the python.set command (the code as `code`), not by typing =PY(…).";
-
-/// Whether typing `input` into a cell enters a formula: `=…`, or `+…`/`-…` followed by a name or
-/// a parenthesis (not a number), as Excel takes `+SUM(1)`.
-pub(crate) fn is_formula_input(input: &str) -> bool {
-    input.starts_with('=')
-        || (input.len() > 1
-            && (input.starts_with('+') || input.starts_with('-'))
-            && gridcraft_core::parse::parse_number_text(input).is_none()
-            && input.chars().nth(1).is_some_and(|c| c.is_ascii_alphabetic() || c == '('))
-}
-
 /// What typing `input` into a cell produces (constant or formula, plus an automatic number
 /// format). Inherits the destination's cell, row or column style, including its number
 /// format, before parsing. Errors when the formula can't be parsed.
 pub(crate) fn input_to_cell(input: &str, sheet: usize, at: CellRef, wb: &mut gridcraft_model::Workbook) -> Result<Option<Cell>> {
    let style = wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
    if input.is_empty() {
-        let c = Cell { value: Value::Empty, formula: None, style, py: None };
+        let c = Cell { value: Value::Empty, formula: None, style };
        return Ok(if c.is_blank() { None } else { Some(c) });
    }
    let fmt_is_text = wb.styles.get(style).num_fmt.as_str() == "@";
    if fmt_is_text {
-        return Ok(Some(Cell { value: Value::text(input), formula: None, style, py: None }));
-    }
-    let is_formula = is_formula_input(input);
-    if is_formula && gridcraft_model::python::is_py_formula(input) {
-        return Err(EngineError::Other(PY_FORMULA.into()));
+        return Ok(Some(Cell { value: Value::text(input), formula: None, style }));
    }
+    let is_formula = input.starts_with('=')
+        || (input.len() > 1
+            && (input.starts_with('+') || input.starts_with('-'))
+            && gridcraft_core::parse::parse_number_text(input).is_none()
+            && input.chars().nth(1).is_some_and(|c| c.is_ascii_alphabetic() || c == '('));
    if is_formula {
        let body = input.strip_prefix('=').unwrap_or(input);
        let expr = wb.name_call_case(parse_typed_formula(body)?);
@@ -86,7 +74,7 @@ pub(crate) fn input_to_cell(input: &str, sheet: usize, at: CellRef, wb: &mut gri
    if input.contains('\n') && !wb.styles.get(style).align.wrap {
        style = wb.styles.derive(style, |s| s.align.wrap = true);
    }
-    Ok(Some(Cell { value: parsed.value, formula: None, style, py: None }))
+    Ok(Some(Cell { value: parsed.value, formula: None, style }))
 }

 /// Parses a formula as it is typed (without the `=`). Excel closes missing parentheses for you,
@@ -154,7 +142,7 @@ pub(super) fn cell_set(s: &mut Session, p: &Json) -> Result<Json> {
            let sh = cx.sheet_mut(sheet)?;
            // The array takes the whole range: other cells in it lose their contents.
            for c in range.iter().skip(1).take(1_000_000) {
-                if let Some(old) = sh.cells.get(c).filter(|x| x.has_content()) {
+                if let Some(old) = sh.cells.get(c).filter(|x| !x.value.is_empty() || x.formula.is_some()) {
                    let style = old.style;
                    sh.set_cell(c, Cell { style, ..Cell::default() });
                }
@@ -195,22 +183,6 @@ pub(crate) fn json_to_input(v: &Json) -> String {
    }
 }

-/// How many converted strings `range.setValues` reports back, and how much of each input and
-/// stored text: the report is a diagnostic, so a big write must not put a second copy of its data
-/// in the result.
-const MAX_REPORTED_CONVERSIONS: usize = 20;
-const MAX_REPORTED_CHARS: usize = 32;
-
-/// `text` cut to [`MAX_REPORTED_CHARS`] characters for the conversion report, with `…` when it was
-/// cut. Counting characters keeps a multi-byte input whole.
-fn clipped(text: &str) -> String {
-    let mut out: String = text.chars().take(MAX_REPORTED_CHARS).collect();
-    if out.len() < text.len() {
-        out.push('…');
-    }
-    out
-}
-
 pub(super) fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
    let sheet = target_sheet(s, p)?;
    let start = target_range(s, p)?.start;
@@ -228,10 +200,6 @@ pub(super) fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
        return Err(bad("range.setValues", "too many rows"));
    }
    let mut count = 0;
-    // The strings typed input read as something other than the text given, for the result: a
-    // caller can notice a "05.04.2026" that became a date without reading the file back (#2255).
-    let mut converted: Vec<(CellRef, String)> = Vec::new();
-    let mut converted_count = 0;
    edit(s, |cx| {
        for (ri, row) in rows.iter().enumerate() {
            let cols: Vec<&Json> = match row.as_array() {
@@ -246,47 +214,23 @@ pub(super) fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
                        value: Value::number(n.as_f64().unwrap_or(0.0)),
                        formula: None,
                        style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(),
-                        py: None,
-                    }),
-                    Json::Bool(b) => Some(Cell {
-                        value: Value::Bool(*b),
-                        formula: None,
-                        style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default(),
-                        py: None,
                    }),
+                    Json::Bool(b) => {
+                        Some(Cell { value: Value::Bool(*b), formula: None, style: cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default() })
+                    }
                    // Text as given: no date or number reading, and a leading `'` is part of the
                    // text rather than the marker that makes it text. A formula is still a
                    // formula, which is what the ticket asks for and what `=` means in a cell.
                    Json::String(text) if !parse && !text.starts_with('=') => {
-                        if text.is_empty() {
-                            // An empty string clears the cell, as `null` and the default path do:
-                            // an empty text cell is not blank, and a script clearing cells with
-                            // `""` would leave cells `COUNTA` counts. The cell keeps its formatting.
-                            input_to_cell("", sheet, at, &mut cx.wb)?
-                        } else {
-                            let mut style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
-                            // Line breaks still turn on Wrap Text, as typed input does.
-                            if text.contains('\n') && !cx.wb.styles.get(style).align.wrap {
-                                style = cx.wb.styles.derive(style, |s| s.align.wrap = true);
-                            }
-                            Some(Cell { value: Value::Text(text.as_str().into()), formula: None, style, py: None })
+                        let mut style = cx.wb.sheet(sheet).map(|sh| sh.style_id(at)).unwrap_or_default();
+                        // Line breaks still turn on Wrap Text, as typed input does.
+                        if text.contains('\n') && !cx.wb.styles.get(style).align.wrap {
+                            style = cx.wb.styles.derive(style, |s| s.align.wrap = true);
                        }
+                        Some(Cell { value: Value::Text(text.as_str().into()), formula: None, style })
                    }
                    _ => input_to_cell(&input, sheet, at, &mut cx.wb)?,
                };
-                // A string that became a formula was written as one (`=`), which is deliberate;
-                // only a number (dates and times included), boolean or error is a reading of the
-                // string and worth reporting.
-                if let Some(c) = &cell
-                    && matches!(v, Json::String(_))
-                    && c.formula.is_none()
-                    && matches!(c.value, Value::Number(_) | Value::Bool(_) | Value::Error(_))
-                {
-                    converted_count += 1;
-                    if converted.len() < MAX_REPORTED_CONVERSIONS {
-                        converted.push((at, input.clone()));
-                    }
-                }
                let sh = cx.sheet_mut(sheet)?;
                match cell {
                    Some(c) => sh.set_cell(at, c),
@@ -301,17 +245,7 @@ pub(super) fn range_set_values(s: &mut Session, p: &Json) -> Result<Json> {
        }
        Ok(())
    })?;
-    let d = s.doc()?;
-    let reported: Vec<Json> =
-        d.wb.sheet(sheet)
-            .map(|sh| {
-                converted
-                .iter()
-                .map(|(at, input)| json!({"cell": at.a1(), "input": clipped(input), "stored": clipped(&crate::display::cell_text(&d.wb, sh, *at))}))
-                .collect()
-            })
-            .unwrap_or_default();
-    Ok(json!({"cells": count, "convertedCount": converted_count, "converted": reported}))
+    Ok(json!({"cells": count}))
 }

 pub(super) fn range_fill(s: &mut Session, p: &Json) -> Result<Json> {
@@ -1,8 +1,7 @@
 use super::cell::input_to_cell;
 use super::paste_special::paste_special;
 use super::{
-    Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, bad, bool_param, cell_param_on, edit, json, ok, str_param, target_ranges,
-    target_sheet,
+    Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, cell_param_on, edit, json, ok, str_param, target_ranges, target_sheet,
 };

 // ---------------------------------------------------------------- clipboard
@@ -93,7 +92,7 @@ fn slide_together(wb: &gridcraft_model::Workbook, sheet: usize, areas: &[RangeRe
        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 });
+            dst.set_cell(to, Cell { value: src.value(c), formula: None, style });
            if let Some(picture) = src.cell_pictures.get(&c) {
                dst.cell_pictures.insert(to, picture.clone());
            }
@@ -164,40 +163,6 @@ pub(super) fn paste(s: &mut Session, p: &Json) -> Result<Json> {
    paste_special(s, &json!({"what": "all", "at": p.get("at").cloned().unwrap_or(Json::Null)}))
 }

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

@@ -122,9 +114,7 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
    let whole = bool_param(p, "wholeCell").unwrap_or(false);
    let all = bool_param(p, "all").unwrap_or(true);
    let workbook = str_param(p, "within") == Some("workbook");
-    let selection = (str_param(p, "within") == Some("selection")).then(|| s.doc().map(|d| d.selection.clone())).transpose()?;
    let active = s.doc()?.selection.active;
-    let mut skipped = 0usize;
    let n = edit(s, |cx| {
        let sheets: Vec<usize> = if workbook { (0..cx.wb.sheets.len()).collect() } else { vec![cx.wb.active_sheet()] };
        let mut n = 0;
@@ -132,7 +122,7 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
            let cells: Vec<(CellRef, String)> =
                cx.wb.sheet(si).map(|sh| sh.cells.iter().map(|(c, _)| (c, sh.input_text(c))).collect()).unwrap_or_default();
            for (c, text) in cells {
-                if (!all && c != active) || selection.as_ref().is_some_and(|sel| !sel.contains(c)) {
+                if !all && c != active {
                    continue;
                }
                if !matches(&text, &what, case, whole) {
@@ -145,30 +135,6 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
                } else {
                    replace_ci(&text, &what, &with)
                };
-                // A Python cell's text is its code: the replacement edits the code and the cell
-                // stays a Python cell. Code that would no longer fit in a PY formula is left as it was.
-                let old_py = cx.wb.sheet(si).and_then(|sh| sh.cell(c)).and_then(|x| x.py.clone());
-                if let Some(old) = old_py {
-                    let py = gridcraft_model::PyCode { object: old.object, ..gridcraft_model::PyCode::new(&new) };
-                    if py.code == old.code {
-                        continue;
-                    }
-                    if !py.fits() {
-                        skipped += 1;
-                        continue;
-                    }
-                    // Its old spill is left to the recalculation, which removes it and
-                    // recalculates what read it.
-                    let sh = cx.sheet_mut(si)?;
-                    let style = sh.style_id(c);
-                    sh.set_cell(
-                        c,
-                        Cell { value: Value::Error(gridcraft_core::CellError::Blocked), formula: None, style, py: Some(std::sync::Arc::new(py)) },
-                    );
-                    cx.touch(si, c);
-                    n += 1;
-                    continue;
-                }
                let cell = input_to_cell(&new, si, c, &mut cx.wb).unwrap_or_else(|_| Some(Cell::value(Value::text(new.as_str()))));
                let sh = cx.sheet_mut(si)?;
                match cell {
@@ -183,9 +149,6 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result<Json> {
        }
        Ok(n)
    })?;
-    if skipped > 0 {
-        return Ok(json!({"replaced": n, "skipped": skipped}));
-    }
    Ok(json!({"replaced": n}))
 }

@@ -174,8 +174,8 @@ pub(super) fn go_to_special(s: &mut Session, p: &Json) -> Result<Json> {
        let v = sheet.value(c);
        let ok = match kind {
            "blanks" => v.is_empty(),
-            "constants" => cell.is_some_and(|x| x.formula.is_none() && x.py.is_none() && !x.value.is_empty()),
-            "formulas" => cell.is_some_and(|x| x.formula.is_some() || x.py.is_some()),
+            "constants" => cell.is_some_and(|x| x.formula.is_none() && !x.value.is_empty()),
+            "formulas" => cell.is_some_and(|x| x.formula.is_some()),
            "comments" | "notes" => sheet.comments.contains_key(&c),
            "errors" => v.is_error(),
            "numbers" => v.is_number(),
@@ -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,25 +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) };
-    // 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 {
@@ -71,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.
@@ -88,283 +143,156 @@ 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 });
+        for (tr, tc, r, c) in tiled_cells(src.height(), src.width(), tiles_r, tiles_c) {
+            let sc = CellRef::new(src.start.row + r, src.start.col + c);
+            let (dr, dc) = if transpose { (c, r) } else { (r, c) };
+            let Some(dest) = at.offset((tr * h + dr) as i64, (tc * w + dc) as i64) else { continue };
+            let src_cell = if cut_move { moved_formulas.iter().find(|(k, _)| *k == sc).map(|(_, v)| v.clone()) } else { src_sheet.cell(sc).cloned() };
+            let src_val = src_sheet.value(sc);
+            let src_picture = if cut_move { moved_pictures.get(&sc) } else { src_sheet.cell_pictures.get(&sc) }.cloned();
+            if skip_blanks && src_picture.is_none() && src_val.is_empty() && src_cell.as_ref().is_none_or(|x| x.formula.is_none()) {
+                continue;
            }
-        }
-        let 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 };
-                    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, transpose, skip_blanks)?;
-        }
-        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) }))
+            };
+            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_picture = None;
+            } else {
+                let sc_cell = src_cell.clone().unwrap_or_default();
+                match what {
+                    What::All | What::AllExceptBorders => {
+                        new_picture = src_picture.clone();
+                        new.formula = shift(&sc_cell);
+                        new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                        let st = map_style(sc_cell.style, &mut cx.wb);
+                        new.style = if what == What::AllExceptBorders {
+                            let borders = cx.wb.styles.get(old.style).borders;
+                            cx.wb.styles.derive(st, |s| s.borders = borders)
+                        } else {
+                            st
+                        };
+                    }
+                    What::Formulas | What::FormulasAndNumberFormats => {
+                        new_picture = src_picture.clone();
+                        new.formula = shift(&sc_cell);
+                        new.value = if new.formula.is_some() { Value::Empty } else { sc_cell.value.clone() };
+                        if what == What::FormulasAndNumberFormats {
+                            let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
+                            new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
+                        }
+                    }
+                    What::Values | What::ValuesAndNumberFormats => {
+                        new_picture = src_picture.clone();
+                        new.formula = None;
+                        new.value = src_val.clone();
+                        if what == What::ValuesAndNumberFormats {
+                            let nf = src_wb.styles.get(sc_cell.style).num_fmt.clone();
+                            new.style = cx.wb.styles.derive(old.style, |s| s.num_fmt = nf);
+                        }
+                    }
+                    What::Formats => new.style = map_style(sc_cell.style, &mut cx.wb),
+                    What::Comments | What::Validation | What::ColumnWidths => {}
+                }
+                // Operations combine numbers with what is already there.
+                if op != "none" && matches!(what, What::All | What::Values | What::ValuesAndNumberFormats | What::Formulas) && new.formula.is_none() {
+                    if old_picture.is_some() || new_picture.is_some() {
+                        new_picture = None;
+                        new.value = Value::Error(gridcraft_core::CellError::Value);
+                    }
+                    // Numbers stored as text participate; other text and errors stay as they are.
+                    apply_operation(&op, &old, &mut new);
                }
            }
+            // The copied cell's validation rule replaces whatever rule the destination had.
+            if !link && matches!(what, What::All | What::AllExceptBorders | What::Validation) {
+                let rule = src_sheet.validations.iter().find(|dv| dv.ranges.iter().any(|r| r.contains(sc))).cloned();
+                let sh = cx.sheet_mut(dest_sheet)?;
+                crate::cmd::data::remove_validation_cells(&mut sh.validations, &[RangeRef::new(dest, dest)]);
+                if let Some(mut dv) = rule {
+                    // Relative references move with the rule, as pasted formulas do.
+                    let first = dv.ranges.first().map_or(sc, |r| r.start);
+                    dv.f1 = crate::cmd::data::move_rule_formula(&dv.f1, first, dest);
+                    dv.f2 = dv.f2.map(|f| crate::cmd::data::move_rule_formula(&f, first, dest));
+                    dv.ranges = vec![RangeRef::new(dest, dest)];
+                    sh.validations.push(dv);
+                }
+            }
+            match what {
+                What::Comments => {
+                    if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
+                        cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
+                    }
+                }
+                What::ColumnWidths => {
+                    if let Some(info) = src_sheet.cols.get(&sc.col).copied() {
+                        cx.sheet_mut(dest_sheet)?.cols.insert(dest.col, info);
+                    }
+                }
+                What::All => {
+                    if let Some(cm) = src_sheet.comments.get(&sc).cloned() {
+                        cx.sheet_mut(dest_sheet)?.comments.insert(dest, cm);
+                    }
+                    if let Some(h) = src_sheet.hyperlinks.get(&sc).cloned() {
+                        cx.sheet_mut(dest_sheet)?.hyperlinks.insert(dest, h);
+                    }
+                    cx.sheet_mut(dest_sheet)?.set_cell(dest, new);
+                }
+                _ => cx.sheet_mut(dest_sheet)?.set_cell(dest, new),
+            }
+            if let Some(picture) = new_picture {
+                cx.sheet_mut(dest_sheet)?.cell_pictures.insert(dest, picture);
+            }
+            cx.touch(dest_sheet, dest);
        }
        // Merged areas inside the copied block travel with it.
-        if matches!(what, What::All | What::Formats) && !transpose {
-            let merges: Vec<RangeRef> = src_sheet.merges.iter().filter(|m| src.contains_range(m)).copied().collect();
-            for m in merges {
-                let dr = at.row as i64 - src.start.row as i64;
-                let dc = at.col as i64 - src.start.col as i64;
-                if let (Some(a), Some(b)) = (m.start.offset(dr, dc), m.end.offset(dr, dc)) {
-                    let nm = RangeRef::new(a, b);
-                    let sh = cx.sheet_mut(dest_sheet)?;
-                    sh.merges.retain(|x| !x.intersects(&nm));
-                    sh.merges.push(nm);
-                }
-            }
-        }
+        copy_merges(cx, dest_sheet, src_sheet, src, at, what, transpose)?;
        if cut_move {
            // References elsewhere to the moved block now point to its new place.
+            let dest_name = cx.wb.sheet(dest_sheet).map(|s| s.name.clone()).unwrap_or_default();
            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)?;
+            rewrite_all_formulas(&mut cx.wb, &src_sheet_name, &e);
            cx.structural = true;
        }
        let end = at.offset_clamped((tiles_r * h) as i64 - 1, (tiles_c * w) as i64 - 1);
@@ -387,134 +315,8 @@ 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;
-
-/// 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,
-    transpose: bool,
-    skip_blanks: bool,
-) -> Result<()> {
-    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)) {
-                        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));
-                    }
-                }
-            }
-        }
-        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, &[pasted]);
-    }
-    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<()> {
+pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &str, e: &gridcraft_formula::adjust::Edit) {
    use gridcraft_formula::adjust::Edit;
    // Rows and columns inserted or deleted on the target sheet move its legacy array ranges too
    // (a cut moves its arrays itself).
@@ -553,113 +355,4 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: &
            n.formula = gridcraft_formula::print(&new);
        }
    }
-    rewrite_cell_links(wb, |host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e));
-    rewrite_python_refs(wb, &|host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e))
-}
-
-/// 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
-/// 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(sh) = wb.sheet_mut(si) else { continue };
-        let fix = |text: &str| -> String {
-            match gridcraft_formula::parse(text) {
-                Ok(expr) => gridcraft_formula::print(&f(&host, expr)),
-                Err(_) => text.to_string(),
-            }
-        };
-        for ch in sh.charts.iter_mut() {
-            ch.source = ch.source.as_deref().map(fix).filter(|s| !s.contains("#REF!"));
-            for se in ch.series.iter_mut() {
-                se.values = fix(&se.values);
-                se.categories = se.categories.as_deref().map(fix);
-                se.name = se.name.as_deref().map(fix);
-                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);
-        }
-    }
-}
-
-/// Rewrites the `xl("…")` literals in every Python cell with `f`, which maps a reference held on
-/// sheet `host` to its new form. Every reference-moving edit (insert and delete of lines or cells,
-/// cut-move, sheet rename and delete) runs it, as it adjusts formulas. A literal is only replaced
-/// when the reference it names changed, and text that doesn't parse is kept. A cell's cached
-/// result is kept while its references still name the same data (a rename, a move); a reference
-/// the edit deleted (`#REF!`), or one that grew or shrank (rows or columns inserted or deleted
-/// inside it), leaves the result stale, so the cell is new code (`#BLOCKED!`) and the
-/// recalculation removes its spill. A rewrite that would
-/// make a cell's code longer than one cell holds (a longer sheet name, `Z1` becoming `AA1`) refuses
-/// the whole edit, which then changes nothing: see [`check_python_fits`].
-pub(crate) fn rewrite_python_refs(
-    wb: &mut gridcraft_model::Workbook,
-    f: &impl Fn(&str, gridcraft_formula::Expr) -> gridcraft_formula::Expr,
-) -> Result<()> {
-    for si in 0..wb.sheets.len() {
-        let Some(sh) = wb.sheets.get(si) else { continue };
-        let host = sh.name.clone();
-        let mut new_code: Vec<(CellRef, String, bool)> = Vec::new();
-        for (c, cell) in sh.cells.iter() {
-            let Some(py) = &cell.py else { continue };
-            let mut lost = false;
-            let changed = gridcraft_model::python::rewrite_xl(&py.code, |reference| {
-                let expr = gridcraft_formula::parse(reference).ok()?;
-                let before = gridcraft_formula::print(&expr);
-                let after = gridcraft_formula::print(&f(&host, expr));
-                lost |= (after.contains("#REF!") && !before.contains("#REF!")) || area_shape(&before) != area_shape(&after);
-                (after != before).then_some(after)
-            });
-            if let Some(code) = changed {
-                check_python_fits(&gridcraft_model::PyCode { code: code.clone(), object: py.object, ..Default::default() }, &host, c)?;
-                new_code.push((c, code, lost));
-            }
-        }
-        if new_code.is_empty() {
-            continue;
-        }
-        let Some(sh) = wb.sheet_mut(si) else { continue };
-        for (c, code, lost) in new_code {
-            if let Some(cell) = sh.cells.get_mut(c)
-                && let Some(py) = cell.py.as_mut()
-            {
-                let py = std::sync::Arc::make_mut(py);
-                py.code = code;
-                if lost {
-                    py.output = None;
-                    cell.value = Value::Error(gridcraft_core::CellError::Blocked);
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-/// The rows and columns a printed reference covers (`A1:B3`, `Sheet2!$A$1`, `C:E`), or `None`
-/// for any other form (a name, an error).
-fn area_shape(reference: &str) -> Option<(u32, u32)> {
-    let r = RangeRef::parse(reference.rsplit('!').next()?)?;
-    Some((r.height(), r.width()))
-}
-
-/// Refuses Python code an edit has made longer than one cell holds: the limit `python.set`
-/// enforces and opening a file applies (code over it is dropped to its value on open). The edit
-/// is refused rather than made, so no code is lost and none keeps a reference the edit moved.
-pub(crate) fn check_python_fits(py: &gridcraft_model::PyCode, sheet: &str, at: CellRef) -> Result<()> {
-    if py.fits() {
-        return Ok(());
-    }
-    Err(EngineError::Other(format!(
-        "The edit would make the Python code in {}!{} longer than Excel's {}-character formula limit, so nothing was changed. Shorten the code first.",
-        gridcraft_formula::quote_sheet(sheet),
-        at.a1(),
-        gridcraft_model::python::MAX_FORMULA_CHARS
-    )))
 }
@@ -137,23 +137,6 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result<Json> {
    Ok(json!({"active": d.selection.active.a1()}))
 }

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

-/// The result names the strings typed input read as something else, so a script notices without
-/// reading the file back (#2255). A formula and a leading apostrophe are not conversions.
-#[test]
-fn set_values_reports_the_strings_typed_input_read() {
-    let mut s = Session::new();
-    s.new_workbook();
-    let row = json!(["05.04.2026", "02/11/2026", "2.500", "4.25 %", "=1+1", "'keep"]);
-    let r = s.execute("range.setValues", json!({"range": "A1", "values": [row.clone()]})).unwrap();
-    assert_eq!(r["cells"], 6, "{r}");
-    assert_eq!(r["convertedCount"], 4, "{r}");
-    assert_eq!(r["converted"][0], json!({"cell": "A1", "input": "05.04.2026", "stored": "5/4/2026"}), "{r}");
-    assert_eq!(r["converted"][1], json!({"cell": "B1", "input": "02/11/2026", "stored": "2/11/2026"}), "{r}");
-    assert_eq!(r["converted"][2], json!({"cell": "C1", "input": "2.500", "stored": "2.5"}), "{r}");
-    assert_eq!(r["converted"][3], json!({"cell": "D1", "input": "4.25 %", "stored": "4.25%"}), "{r}");
-    // The report is a diagnostic, not a second copy of the data: a long input is cut.
-    let long = s.execute("range.setValues", json!({"range": "J1", "values": [["9".repeat(100)]]})).unwrap();
-    assert_eq!(long["convertedCount"], 1, "{long}");
-    let input = long["converted"][0]["input"].as_str().unwrap_or_default();
-    assert_eq!(input.chars().count(), 33, "32 characters and the ellipsis: {input}");
-    assert!(input.ends_with('…'), "{input}");
-    // Nothing is read with `parse: false`, so nothing is reported.
-    let verbatim = s.execute("range.setValues", json!({"range": "A3", "parse": false, "values": [row]})).unwrap();
-    assert_eq!(verbatim["convertedCount"], 0, "{verbatim}");
-    assert_eq!(verbatim["converted"], json!([]), "{verbatim}");
-}
-
-/// An empty string clears the cell with `parse: false` too, as `null` and the default path do: a
-/// script clearing cells with "" must not leave cells `COUNTA` counts.
-#[test]
-fn set_values_parse_false_clears_an_empty_string() {
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:B1", "values": [["keep", "keep"]]})).unwrap();
-    s.execute("home.bold", json!({"range": "A1"})).unwrap();
-    s.execute("range.setValues", json!({"range": "A1", "parse": false, "values": [["", ""]]})).unwrap();
-    let get = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap();
-    assert_eq!(get(&mut s, "A1")["type"], "empty");
-    assert_eq!(get(&mut s, "B1")["type"], "empty");
-    let d = s.doc().unwrap();
-    let sh = d.wb.sheet(0).unwrap();
-    assert!(d.wb.styles.get(sh.style_id(CellRef::parse("A1").unwrap())).font.bold, "clearing with \"\" keeps the formatting");
-    assert_eq!(s.execute("formulas.evaluate", json!({"formula": "=COUNTA(A1:B1)"})).unwrap(), json!(0.0));
-}
-
-/// The text `parse: false` stores is still text after the workbook is saved and reopened, and the
-/// default's reading of a date survives as a date (#2255).
-#[test]
-fn set_values_text_survives_an_xlsx_roundtrip() {
-    let mut s = Session::new();
-    s.new_workbook();
-    let values = json!([["05.04.2026", "2.500", "4.25 %", "=1+1", 3, true]]);
-    s.execute("range.setValues", json!({"range": "A1", "parse": false, "values": values})).unwrap();
-    s.execute("range.setValues", json!({"range": "A3", "values": [["05.04.2026"]]})).unwrap();
-    let bytes = crate::io::save_bytes(&s.doc().unwrap().wb, "book.xlsx").unwrap();
-    let (wb, _) = crate::io::open_bytes("book.xlsx", &bytes).unwrap();
-    let sh = wb.sheet(0).unwrap();
-    for (col, want) in [(0, "05.04.2026"), (1, "2.500"), (2, "4.25 %")] {
-        assert_eq!(sh.value(CellRef::new(0, col)), Value::text(want), "column {col} is the text it was given");
-    }
-    assert_eq!(sh.value(CellRef::new(0, 3)), Value::number(2.0), "=1+1 is still a formula");
-    assert_eq!(sh.value(CellRef::new(0, 4)), Value::number(3.0));
-    assert_eq!(sh.value(CellRef::new(0, 5)), Value::Bool(true));
-    // The default read the date, and the file keeps it as one.
-    let at = CellRef::new(2, 0);
-    assert_eq!(crate::display::cell_text(&wb, sh, at), "5/4/2026");
-    assert_eq!(wb.styles.get(sh.style_id(at)).num_fmt.as_str(), "m/d/yyyy");
-}
-
 #[test]
 fn legacy_array_entry() {
    let mut s = Session::new();
@@ -307,9 +239,6 @@ fn tsv() {
    assert_eq!(parse_tsv("a\tb\n1\t2\n"), vec![vec!["a", "b"], vec!["1", "2"]]);
    assert_eq!(parse_tsv("\"x\ty\"\tz"), vec![vec!["x\ty", "z"]]);
    assert_eq!(parse_tsv("\"he said \"\"hi\"\"\""), vec![vec!["he said \"hi\""]]);
-    // #2225: a quote that doesn't close the field leaves it as written, as Excel pastes it.
-    assert_eq!(parse_tsv("\"hi\" there\tx\n"), vec![vec!["\"hi\" there", "x"]]);
-    assert_eq!(parse_tsv("say \"hi\"\n"), vec![vec!["say \"hi\""]]);
 }

 #[test]
@@ -356,74 +285,6 @@ fn cut_paste_that_overflows_the_grid_moves_nothing() {
    assert_eq!(get(&mut s, "XFD2")["value"], json!(2.0));
 }

-#[test]
-fn drag_and_drop_asks_before_replacing_data() {
-    // #3136: dragging column B's border onto column A replaced A without asking.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:B3", "values": [["Apple", "Kiwi"], ["Pear", "Plum"], ["Fig", "Lime"]]})).unwrap();
-    s.execute("edit.copy", json!({"range": "D9"})).unwrap();
-    let text = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["input"].clone();
-    let r = s.execute("range.move", json!({"range": "B:B", "to": "A1"}));
-    let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") };
-    assert_eq!(q, "There's already data here. Do you want to replace it?");
-    // Nothing moved, and the copy made before is still on the clipboard.
-    assert_eq!(text(&mut s, "A1"), json!("Apple"));
-    assert_eq!(text(&mut s, "B1"), json!("Kiwi"));
-    assert!(s.clipboard.as_ref().is_some_and(|c| !c.cut && c.range.a1() == "D9"));
-    // Confirmed, column B replaces column A.
-    s.execute("range.move", json!({"range": "B:B", "to": "A1", "overwrite": true})).unwrap();
-    assert_eq!(text(&mut s, "A1"), json!("Kiwi"));
-    assert_eq!(text(&mut s, "A3"), json!("Lime"));
-    assert_eq!(text(&mut s, "B1"), json!(""));
-    // Onto empty cells, or overlapping only the moved cells themselves, nothing is asked.
-    s.execute("range.move", json!({"range": "A1:A3", "to": "A2"})).unwrap();
-    assert_eq!(text(&mut s, "A4"), json!("Lime"));
-    s.execute("range.move", json!({"range": "A2:A4", "to": "C2"})).unwrap();
-    assert_eq!(text(&mut s, "C2"), json!("Kiwi"));
-    assert!(s.execute("range.move", json!({"range": "C2"})).is_err(), "`to` is required");
-}
-
-#[test]
-fn drag_and_drop_asks_before_replacing_spilled_values() {
-    // Cells showing a dynamic array's spilled values hold no cell of their own, but they are data.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("cell.set", json!({"cell": "A1", "input": "=SEQUENCE(3)"})).unwrap();
-    s.execute("range.setValues", json!({"range": "C2:C3", "values": [["Kiwi"], ["Plum"]]})).unwrap();
-    let r = s.execute("range.move", json!({"range": "C2:C3", "to": "A2"}));
-    let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") };
-    assert_eq!(q, "There's already data here. Do you want to replace it?");
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    assert_eq!(sh.value(CellRef::new(2, 2)), Value::text("Plum"));
-    s.execute("range.move", json!({"range": "C2:C3", "to": "A2", "overwrite": true})).unwrap();
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    assert_eq!(sh.value(CellRef::new(1, 0)), Value::text("Kiwi"));
-}
-
-#[test]
-fn drag_and_drop_on_another_sheet_stays_on_that_sheet() {
-    // The move was checked on the range's sheet but pasted on the active one, replacing its data
-    // without asking.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.insertSheet", json!({"name": "Two"})).unwrap();
-    s.execute("range.setValues", json!({"range": "B1:B2", "values": [["Kiwi"], ["Plum"]]})).unwrap();
-    s.execute("sheet.activate", json!({"sheet": 0})).unwrap();
-    s.execute("cell.set", json!({"cell": "A1", "input": "Keep"})).unwrap();
-    s.execute("selection.set", json!({"range": "C5"})).unwrap();
-    s.execute("range.move", json!({"range": "Two!B1:B2", "to": "A1"})).unwrap();
-    // Sheet1 stays active with its own selection; the moved cells are on Two.
-    assert_eq!(s.doc().unwrap().wb.active_sheet(), 0);
-    assert_eq!(s.doc().unwrap().selection.a1(), "C5");
-    let wb = &s.doc().unwrap().wb;
-    let two = wb.sheet_index("Two").unwrap();
-    assert_eq!(wb.sheet(0).unwrap().value(CellRef::new(0, 0)), Value::text("Keep"));
-    assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(0, 0)), Value::text("Kiwi"));
-    assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(1, 0)), Value::text("Plum"));
-    assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(0, 1)), Value::Empty);
-}
-
 #[test]
 fn replace_case_insensitive() {
    assert_eq!(replace_ci("Apple apple APPLE", "apple", "pear"), "pear pear pear");
@@ -442,141 +303,3 @@ fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() {
    let sh = s.doc().unwrap().wb.active().unwrap();
    assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text));
 }
-
-#[test]
-fn next_corner_of_selection_goes_clockwise_and_anchors_there() {
-    // #1442, as Excel does it: B2 → D2 → D4 → B4 → B2, the area stays selected, and Shift+arrows
-    // then move the corner opposite the new active cell.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("selection.set", json!({"range": "B2:D4", "active": "B2"})).unwrap();
-    let mut seen = Vec::new();
-    for _ in 0..4 {
-        let r = s.execute("selection.nextCorner", json!({})).unwrap();
-        assert_eq!(r["selection"], "B2:D4");
-        seen.push(r["active"].as_str().unwrap().to_string());
-    }
-    assert_eq!(seen, ["D2", "D4", "B4", "B2"]);
-    s.execute("selection.nextCorner", json!({})).unwrap();
-    s.execute("selection.nextCorner", json!({})).unwrap();
-    s.execute("selection.move", json!({"dr": 0, "dc": 1, "extend": true})).unwrap();
-    assert_eq!(s.doc().unwrap().selection.current().a1(), "C2:D4");
-    // One row goes end to end; a single cell stays.
-    s.execute("selection.set", json!({"range": "B2:D2", "active": "B2"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "D2");
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B2");
-    s.execute("selection.set", json!({"range": "C5"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C5");
-}
-
-#[test]
-fn next_corner_skips_corners_the_sheet_protection_does_not_let_you_select() {
-    // With locked cells unselectable, Ctrl+. goes on to the next corner it may select.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.lockCell", json!({"range": "B2:C3", "on": false})).unwrap();
-    s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap();
-    s.execute("review.protectSheet", json!({"selectLockedCells": false})).unwrap();
-    let r = s.execute("selection.nextCorner", json!({})).unwrap();
-    assert_eq!((r["active"].as_str(), r["selection"].as_str()), (Some("B3"), Some("B2:D3")), "D2 and D3 are locked");
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B2");
-}
-
-#[test]
-fn next_corner_stops_once_on_a_merged_corner_at_its_top_left_cell() {
-    // A corner inside a merged cell is that merged cell, whose active cell is its top-left one.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.mergeCells", json!({"range": "C2:D2"})).unwrap();
-    s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap();
-    let seen: Vec<String> = (0..4).map(|_| s.execute("selection.nextCorner", json!({})).unwrap()["active"].as_str().unwrap().to_string()).collect();
-    assert_eq!(seen, ["C2", "D3", "B3", "B2"]);
-    // A selection that is one merged cell has no other corner.
-    s.execute("selection.set", json!({"range": "C2:D2", "active": "C2"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C2");
-}
-
-#[test]
-fn next_corner_skips_hidden_corners_and_stays_inside_the_selected_area() {
-    // A corner in a hidden column is passed over, as keyboard moves pass over hidden cells.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.hideColumns", json!({"cols": "D:D"})).unwrap();
-    s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap();
-    assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B3");
-    // Column C selected with B1:C1 merged: its top corner's merged cell starts in column B,
-    // outside the selection, so the active cell doesn't go there.
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("home.mergeCells", json!({"range": "B1:C1"})).unwrap();
-    s.execute("selection.set", json!({"cell": "C5"})).unwrap();
-    s.execute("selection.column", json!({})).unwrap();
-    let r = s.execute("selection.nextCorner", json!({})).unwrap();
-    assert_eq!((r["active"].as_str(), r["selection"].as_str()), (Some("C1048576"), Some("C:C")));
-}
-
-#[test]
-fn copy_quotes_only_cells_with_tabs_or_line_breaks() {
-    // #2225: a cell holding a quote was wrapped in quotes on copy; Excel quotes only text with a
-    // tab or line break, and pastes the result back as the same cells.
-    let mut s = Session::new();
-    s.new_workbook();
-    for (cell, input) in [("A1", "say \"hi\""), ("A2", "plain"), ("A3", "\"hi\" there"), ("A4", "x \"q\"\ny"), ("A5", "tab\tinside")] {
-        s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap();
-    }
-    let text = s.execute("edit.copy", json!({"range": "A1:A5"})).unwrap()["text"].as_str().unwrap().to_string();
-    assert_eq!(text, "say \"hi\"\nplain\n\"hi\" there\n\"x \"\"q\"\"\ny\"\n\"tab\tinside\"\n");
-    let rows = parse_tsv(&text);
-    let cells: Vec<&str> = rows.iter().map(|r| r[0].as_str()).collect();
-    assert_eq!(cells, ["say \"hi\"", "plain", "\"hi\" there", "x \"q\"\ny", "tab\tinside"]);
-}
-
-#[test]
-fn a_field_that_is_not_really_quoted_keeps_its_separators() {
-    // A field opening with a quote is quoted only if a closing quote ends it; when it doesn't (or
-    // never closes), the text is read as written, and the tabs and line breaks inside it still
-    // separate cells, as they would have without the leading quote.
-    assert_eq!(parse_tsv("\"a\tb\"x\tc"), vec![vec!["\"a", "b\"x", "c"]]);
-    assert_eq!(parse_tsv("\"a\tb\nc"), vec![vec!["\"a", "b"], vec!["c"]]);
-    assert_eq!(parse_tsv("\"a\tb\tc\n"), vec![vec!["\"a", "b", "c"]]);
-    // Cells copied without quotes (they hold no tab or line break) read back as the same cells.
-    let mut s = Session::new();
-    s.new_workbook();
-    for (cell, input) in [("A1", "'\"a"), ("B1", "b\"x"), ("C1", "c")] {
-        s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap();
-    }
-    let text = s.execute("edit.copy", json!({"range": "A1:C1"})).unwrap()["text"].as_str().unwrap().to_string();
-    assert_eq!(parse_tsv(&text), vec![vec!["\"a", "b\"x", "c"]], "{text:?}");
-    // Many fields that only look quoted: each is replayed at most once (the replay budget is the
-    // input's length), and every one is still its own cell.
-    let hostile = "\"x\t".repeat(50_000);
-    assert_eq!(parse_tsv(&hostile).first().map(Vec::len), Some(50_001));
-}
-
-/// `within: selection` searches only the selected cells, as Excel does with a range selected
-/// (#3224): Find All lists them, Find Next moves the active cell through them and keeps the range
-/// selected, and Replace changes only them.
-#[test]
-fn find_and_replace_within_the_selection() {
-    let mut s = Session::new();
-    s.new_workbook();
-    s.execute("range.setValues", json!({"range": "A1:B4", "values": [["pear", "pear"], ["plum", "pear"], ["pear", "fig"], ["pear", "pear"]]}))
-        .unwrap();
-    s.execute("selection.set", json!({"range": "B1:B4"})).unwrap();
-    let all = s.execute("edit.find", json!({"what": "pear", "all": true, "within": "selection"})).unwrap();
-    let cells: Vec<&str> = all["results"].as_array().unwrap().iter().filter_map(|r| r["cell"].as_str()).collect();
-    assert_eq!(cells, ["B1", "B2", "B4"], "only column B");
-    assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B2");
-    assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B4");
-    assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B1", "wraps inside the range");
-    let sel = &s.doc().unwrap().selection;
-    assert_eq!((sel.a1(), sel.active.a1()), ("B1:B4".to_string(), "B1".to_string()), "the range stays selected");
-    assert!(s.execute("edit.find", json!({"what": "plum", "within": "selection"})).is_err(), "A2 is outside the range");
-    assert_eq!(s.execute("edit.replace", json!({"what": "pear", "with": "kiwi", "within": "selection"})).unwrap()["replaced"], 3);
-    let sh = s.doc().unwrap().wb.active().unwrap();
-    let at = |a: &str| sh.value(CellRef::parse(a).unwrap());
-    assert_eq!((at("A1"), at("B1"), at("B4"), at("A4")), (Value::text("pear"), Value::text("kiwi"), Value::text("kiwi"), Value::text("pear")));
-    // The sheet scope is unchanged.
-    let all = s.execute("edit.find", json!({"what": "pear", "all": true})).unwrap();
-    assert_eq!(all["count"], 3, "A1, A3 and A4 on the whole sheet");
-}
@@ -1,305 +0,0 @@
-//! Equations (Insert › Symbols › Equation): floating shapes holding LaTeX source, laid out by
-//! `gridcraft-math` and drawn from the cached layout.
-//!
-//! An equation is drawn to fit its frame, so resizing the frame scales it. Inserting sizes the
-//! frame for the requested font size; editing keeps the current scale and resizes the frame to
-//! the new content.
-
-use gridcraft_math::{MathError, MathList};
-use gridcraft_model::{Anchor, AnchorMode, Color, EquationCache, Shape, ShapeKind};
-use serde_json::{Value as Json, json};
-
-use super::{CommandSpec, EngineError, PROTECTED, Result, Session, bad, cell_param, cmd, edit, f64_param, has_doc, ok, str_param, u32_param};
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        cmd!(
-            "insert.equation",
-            "Equation",
-            ["Insert", "Symbols"],
-            None,
-            "{latex: \"x^2\", cell?|at?: \"B2\", size?: 11 (points), color?: hex|\"auto\"}",
-            has_doc,
-            insert_equation
-        ),
-        cmd!("equation.edit", "Edit Equation", [], None, "{id, latex}", has_doc, edit_equation),
-    ]
-}
-
-/// Default equation font size, in points.
-pub const DEFAULT_SIZE_PT: f64 = 11.0;
-/// Space between an equation's frame and its content, in sheet pixels.
-pub const PADDING: f32 = 4.0;
-/// Sheet pixels per point.
-const PX_PER_PT: f64 = 96.0 / 72.0;
-
-/// The scale (sheet pixels per em) at which `list` fits a frame of `w` by `h` pixels.
-pub fn fit_scale(list: &MathList, w: f32, h: f32) -> f32 {
-    let (cw, ch) = (list.width.max(0.01), list.total_height().max(0.01));
-    let s = ((w - 2.0 * PADDING) / cw).min((h - 2.0 * PADDING) / ch);
-    if s.is_finite() { s.max(0.0) } else { 0.0 }
-}
-
-/// The frame size for `list` at `scale` pixels per em.
-fn frame_for(list: &MathList, scale: f32) -> (f32, f32) {
-    let w = list.width.max(0.5) * scale + 2.0 * PADDING;
-    let h = list.total_height().max(1.0) * scale + 2.0 * PADDING;
-    (w.clamp(8.0, 20_000.0), h.clamp(8.0, 20_000.0))
-}
-
-/// `latex` laid out, or a readable error with the position of the problem.
-fn lay_out(cmd: &str, latex: &str) -> Result<MathList> {
-    gridcraft_math::layout(latex).map_err(|e| bad(cmd, describe(latex, &e)))
-}
-
-/// "Error at character 5: Undefined control sequence: \foo".
-pub fn describe(latex: &str, e: &MathError) -> String {
-    match e.char_pos(latex) {
-        Some(p) => format!("equation error at character {p}: {}", e.message),
-        None => format!("equation error: {}", e.message),
-    }
-}
-
-fn insert_equation(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "insert.equation";
-    let latex = str_param(p, "latex").ok_or_else(|| bad(CMD, "`latex` must be the equation's LaTeX source, such as \"x^2 + y^2 = r^2\""))?;
-    if latex.trim().is_empty() {
-        return Err(bad(CMD, "`latex` is empty"));
-    }
-    let size = f64_param(p, "size").unwrap_or(DEFAULT_SIZE_PT);
-    if !(1.0..=409.0).contains(&size) {
-        return Err(bad(CMD, "`size` must be between 1 and 409 points"));
-    }
-    let color = match p.get("color") {
-        None | Some(Json::Null) => Color::Auto,
-        Some(c) => super::format::color_param(Some(c)).ok_or_else(|| bad(CMD, "`color` must be a hex colour such as \"#1F4E79\", or \"auto\""))?,
-    };
-    let list = lay_out(CMD, latex)?;
-    let at = match cell_param(s, p, "cell")? {
-        Some(c) => Some(c),
-        None => cell_param(s, p, "at")?,
-    };
-    let d = s.doc()?;
-    if d.wb.active().is_some_and(|sh| sh.is_protected()) {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
-    let at = at.unwrap_or(d.selection.active);
-    let id = d.wb.next_object_id();
-    let (width, height) = frame_for(&list, (size * PX_PER_PT) as f32);
-    let mut shape = Shape {
-        id,
-        kind: ShapeKind::Equation,
-        anchor: Anchor { cell: at, dx: 0.0, dy: 0.0, width, height, mode: AnchorMode::MoveOnly },
-        fill: Color::Auto,
-        line: color,
-        text: latex.to_string(),
-        format: Default::default(),
-        math: Default::default(),
-    };
-    shape.math.refresh(latex);
-    let sheet = d.wb.active_sheet();
-    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.shapes.push(shape);
-        Ok(json!({"equation": id}))
-    })
-}
-
-fn edit_equation(s: &mut Session, p: &Json) -> Result<Json> {
-    const CMD: &str = "equation.edit";
-    let id = u32_param(p, "id").ok_or_else(|| bad(CMD, "`id` must be an equation id"))?;
-    let latex = str_param(p, "latex").ok_or_else(|| bad(CMD, "`latex` must be the equation's LaTeX source"))?;
-    if latex.trim().is_empty() {
-        return Err(bad(CMD, "`latex` is empty; delete the equation instead"));
-    }
-    let d = s.doc()?;
-    let sheet = d.wb.active_sheet();
-    let sh = d.wb.active().ok_or_else(|| bad(CMD, "no such equation"))?;
-    let shape = sh.shapes.iter().find(|x| x.id == id && x.kind == ShapeKind::Equation).ok_or_else(|| bad(CMD, "no such equation"))?;
-    if sh.is_protected() {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
-    // The same source is a no-op, unless it has no layout yet (a file with more equations than
-    // are laid out at once): then OK lays it out.
-    if shape.text == latex && matches!(shape.math.get(latex), Some(Ok(_))) {
-        return ok();
-    }
-    let list = lay_out(CMD, latex)?;
-    // Keep the size the equation is drawn at now; without a layout, use the default size.
-    let scale = match shape.math.get(&shape.text) {
-        Some(Ok(old)) => fit_scale(old, shape.anchor.width, shape.anchor.height),
-        _ => 0.0,
-    };
-    let scale = if scale > 0.1 { scale } else { (DEFAULT_SIZE_PT * PX_PER_PT) as f32 };
-    let (width, height) = frame_for(&list, scale);
-    edit(s, |cx| {
-        let shape = cx.sheet_mut(sheet)?.shapes.iter_mut().find(|x| x.id == id).ok_or_else(|| bad(CMD, "no such equation"))?;
-        shape.text = latex.to_string();
-        shape.math = EquationCache::default();
-        shape.math.refresh(latex);
-        shape.anchor.width = width;
-        shape.anchor.height = height;
-        Ok(json!({"equation": id}))
-    })
-}
-
-// ---------------------------------------------------------------- PDF
-
-/// The first [`gridcraft_math::MAX_SOURCE_BYTES`] bytes of an equation's source, cut at a char
-/// boundary. A longer source never lays out (the editor refuses it, and a file can carry one of
-/// megabytes), so what shows it as text, the sheet painter and the PDF fallback, shows this much
-/// and does no work on the rest.
-pub fn source_excerpt(text: &str) -> &str {
-    let cap = gridcraft_math::MAX_SOURCE_BYTES;
-    if text.len() <= cap {
-        return text;
-    }
-    let mut end = cap;
-    while end > 0 && !text.is_char_boundary(end) {
-        end -= 1;
-    }
-    text.get(..end).unwrap_or("")
-}
-
-/// The PDF face for a glyph: Symbol for Greek letters and operators, else the Times (or
-/// Helvetica, Courier) face for its style. `None` when no standard font can show `c`.
-fn pdf_font(c: char, face: gridcraft_math::Face) -> Option<gridcraft_pdf::Font> {
-    use gridcraft_math::Face;
-    use gridcraft_pdf::Font;
-    let text = match face {
-        Face::Italic => Font::TimesItalic,
-        Face::Bold => Font::TimesBold,
-        Face::BoldItalic => Font::TimesBoldItalic,
-        Face::Sans => Font::Helvetica,
-        Face::SansBold => Font::HelveticaBold,
-        Face::SansItalic => Font::HelveticaOblique,
-        Face::Mono => Font::Courier,
-        Face::Roman | Face::Large(_) => Font::TimesRoman,
-    };
-    // Letters and digits stay in the text face; everything Symbol has goes to Symbol, whose
-    // operators (minus, equals, plus) match the maths better than the text faces'.
-    if c.is_ascii_alphanumeric() {
-        return Some(text);
-    }
-    if Font::Symbol.can_encode(c) {
-        return Some(Font::Symbol);
-    }
-    text.can_encode(c).then_some(text)
-}
-
-/// Draws an equation's layout into the box `(x, y, w, h)` (page points) of a PDF page, with
-/// `pad` points of padding. Glyphs no standard font has are drawn as `[?]` boxes.
-pub(crate) fn draw_pdf(pg: &mut gridcraft_pdf::Page, list: &MathList, rect: (f32, f32, f32, f32), pad: f32, ink: gridcraft_pdf::Rgb) {
-    use gridcraft_math::{Face, Item, PathCmd};
-    let (x, y, w, h) = rect;
-    let (cw, ch) = (list.width.max(0.01), list.total_height().max(0.01));
-    let s = ((w - 2.0 * pad) / cw).min((h - 2.0 * pad) / ch);
-    if !(s.is_finite() && s > 0.01) {
-        return;
-    }
-    let s = s.min(4000.0);
-    let (ox, oy) = (x + (w - cw * s) / 2.0, y + (h - ch * s) / 2.0);
-    let col = |c: Option<[u8; 3]>| c.unwrap_or(ink);
-    for item in list.items.iter().take(gridcraft_math::MAX_ITEMS) {
-        match item {
-            Item::Glyph(g) => {
-                let color = col(g.color);
-                let (gx, base) = (ox + g.x * s, oy + g.y * s);
-                // The radical sign: Symbol's glyph (AFM bounding box -147 to 917 high, right edge
-                // at 558, in 1/1000 em) fitted to the TeX box, so its top meets the vinculum.
-                if g.ch == '\u{221A}' {
-                    let size = (g.height + g.depth) * s / 1.064;
-                    if size.is_finite() && size >= 0.5 {
-                        let top = base - g.height * s;
-                        pg.text(gx + g.width * s - 0.558 * size, top + 0.917 * size, size, gridcraft_pdf::Font::Symbol, color, "\u{221A}");
-                    }
-                    continue;
-                }
-                let large = matches!(g.face, Face::Large(_));
-                let size = if large { (g.height + g.depth) * s } else { g.size * s };
-                if !(size.is_finite() && size >= 0.5) {
-                    continue;
-                }
-                let pick = pdf_font(g.ch, g.face).map(|f| (g.ch, f)).or_else(|| g.alt.and_then(|a| pdf_font(a, g.face).map(|f| (a, f))));
-                match pick {
-                    Some((c, font)) => {
-                        let text = c.to_string();
-                        if large {
-                            // Centred on the glyph's box, like the screen.
-                            let mid = oy + (g.y - (g.height - g.depth) / 2.0) * s;
-                            let tw = gridcraft_pdf::text_width(font, size, &text);
-                            pg.text(gx + (g.width * s - tw) / 2.0, mid + 0.25 * size, size, font, color, &text);
-                        } else {
-                            pg.text(gx, base, size, font, color, &text);
-                        }
-                    }
-                    None => {
-                        // [?]: the glyph's box with a question mark.
-                        let (bw, bh) = ((g.width.max(0.3)) * s, (g.height + g.depth) * s);
-                        pg.rect_stroke(gx, base - g.height * s, bw, bh, (0.05 * s).clamp(0.2, 1.0), color);
-                        let qs = (bh * 0.6).min(bw * 1.2).max(1.0);
-                        let qw = gridcraft_pdf::text_width(gridcraft_pdf::Font::Helvetica, qs, "?");
-                        pg.text(gx + (bw - qw) / 2.0, base - g.height * s + (bh + qs * 0.7) / 2.0, qs, gridcraft_pdf::Font::Helvetica, color, "?");
-                    }
-                }
-            }
-            Item::Rule(r) => {
-                if r.width > 0.0 && r.height > 0.0 {
-                    pg.fill_rect(ox + r.x * s, oy + r.y * s, r.width * s, (r.height * s).max(0.25), col(r.color));
-                }
-            }
-            Item::Path(p) => {
-                let (px, py) = (ox + p.x * s, oy + p.y * s);
-                let mut subs: Vec<Vec<[f32; 2]>> = vec![];
-                let mut cur: Vec<[f32; 2]> = vec![];
-                let at = |a: f32, b: f32| [px + a * s, py + b * s];
-                for c in &p.commands {
-                    match *c {
-                        PathCmd::MoveTo(a, b) => {
-                            if cur.len() > 1 {
-                                subs.push(std::mem::take(&mut cur));
-                            }
-                            cur = vec![at(a, b)];
-                        }
-                        PathCmd::LineTo(a, b) => cur.push(at(a, b)),
-                        PathCmd::QuadTo(x1, y1, a, b) => {
-                            let p0 = cur.last().copied().unwrap_or(at(x1, y1));
-                            let (c1, p1) = (at(x1, y1), at(a, b));
-                            for k in 1..=8 {
-                                let t = k as f32 / 8.0;
-                                let u = 1.0 - t;
-                                cur.push([u * u * p0[0] + 2.0 * u * t * c1[0] + t * t * p1[0], u * u * p0[1] + 2.0 * u * t * c1[1] + t * t * p1[1]]);
-                            }
-                        }
-                        PathCmd::CubicTo(x1, y1, x2, y2, a, b) => {
-                            let p0 = cur.last().copied().unwrap_or(at(x1, y1));
-                            let (c1, c2, p1) = (at(x1, y1), at(x2, y2), at(a, b));
-                            for k in 1..=10 {
-                                let t = k as f32 / 10.0;
-                                let u = 1.0 - t;
-                                let (a3, b3, c3, d3) = (u * u * u, 3.0 * u * u * t, 3.0 * u * t * t, t * t * t);
-                                cur.push([a3 * p0[0] + b3 * c1[0] + c3 * c2[0] + d3 * p1[0], a3 * p0[1] + b3 * c1[1] + c3 * c2[1] + d3 * p1[1]]);
-                            }
-                        }
-                        PathCmd::Close => {
-                            if cur.len() > 1 {
-                                subs.push(std::mem::take(&mut cur));
-                            }
-                        }
-                    }
-                }
-                if cur.len() > 1 {
-                    subs.push(cur);
-                }
-                let color = col(p.color);
-                for sub in subs.iter().filter(|v| v.len() <= 4000) {
-                    if p.fill && sub.len() >= 3 {
-                        // The PDF fill rule handles concave outlines itself.
-                        pg.polygon(sub, Some(color), None);
-                    } else {
-                        pg.polyline(sub, (0.05 * s).clamp(0.2, 1.0), color, &[]);
-                    }
-                }
-            }
-        }
-    }
-}
@@ -3,8 +3,8 @@

 use gridcraft_core::{CellRef, RangeRef, Value};
 use gridcraft_model::{
-    Anchor, Chart, Color, DefinedName, HAlign, LegendPos, NumFmt, Shape, ShapeKind, Sheet, SheetViewMode, TableColumn, TotalsFn, Trendline,
-    TrendlineKind, Workbook,
+    Anchor, Chart, Color, DefinedName, HAlign, LegendPos, NumFmt, Shape, Sheet, SheetViewMode, TableColumn, TotalsFn, Trendline, TrendlineKind,
+    Workbook,
 };
 use serde_json::{Value as Json, json};

@@ -28,7 +28,7 @@ use objects::{align, arrange, rotate, selection_pane, shape_fill, shape_outline}
 pub(crate) use scripts::has_scripts;
 use scripts::{all_scripts, delete_script, new_script, record, run_script, stop_action, trust_scripts};
 use window::{arrange_all, custom_views, hide_window, new_window, ruler, set_view, split, switch_windows, unhide_window, watch_window};
-pub(crate) use window::{keep_view_modes, keep_watch_list, window_param};
+pub(crate) use window::{keep_watch_list, window_param};

 pub fn specs() -> Vec<CommandSpec> {
    vec![
@@ -38,7 +38,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Add Chart Element",
            ["Chart Design", "Chart Layouts"],
            None,
-            "{chart?, element: title|legend|dataLabels|dataTable|gridlines|axisTitles|smooth|trendline, on?: bool, position?: bottom|top|left|right; dataTable: dataTableKeys?: bool, dataTableHorizontalBorder?: bool, dataTableVerticalBorder?: bool, dataTableOutline?: bool; trendline: series?: index (default all), type?: linear|exponential|linearForecast|movingAverage|logarithmic|power|polynomial, order?: 2..6, period?: 2..255, forward?, backward?, displayEquation?, displayRSquared?}",
+            "{chart?, element: title|legend|dataLabels|gridlines|axisTitles|smooth|trendline, on?: bool, position?: bottom|top|left|right; trendline: series?: index (default all), type?: linear|exponential|linearForecast|movingAverage|logarithmic|power|polynomial, order?: 2..6, period?: 2..255, forward?, backward?, displayEquation?, displayRSquared?}",
            has_doc,
            add_element
        ),
@@ -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, 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, 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, ids: [..], align: left|center|right|top|middle|bottom}",
            has_doc,
            align
        ),
@@ -310,7 +310,7 @@ pub fn specs() -> Vec<CommandSpec> {
            new_cell_style
        ),
        cmd!(query "home.addIns", "Add-ins", ["Home", "Add-ins"], None, "{} → GridCraft extends through MCP and scripts instead of add-ins", always, |_, _| Ok(json!({"addIns": [], "hint": "Use gridcraft-cli mcp or Automate › scripts"}))),
-        cmd!(query "formulas.recentlyUsed", "Recently Used", ["Formulas", "Function Library"], None, "{} → the functions most recently entered in formulas, newest first", has_doc, recently_used),
+        cmd!(query "formulas.recentlyUsed", "Recently Used", ["Formulas", "Function Library"], None, "{} → recently used functions in this workbook", has_doc, recently_used),
        cmd!(query "formulas.financial", "Financial", ["Formulas", "Function Library"], None, "{}", always, |s, _| s.execute("formulas.functions", json!({"category": "Financial"}))),
        cmd!(query "formulas.logical", "Logical", ["Formulas", "Function Library"], None, "{}", always, |s, _| s.execute("formulas.functions", json!({"category": "Logical"}))),
        cmd!(query "formulas.text", "Text", ["Formulas", "Function Library"], None, "{}", always, |s, _| s.execute("formulas.functions", json!({"category": "Text"}))),
@@ -51,7 +51,6 @@ pub(super) fn toggle_checkbox(s: &mut Session, p: &Json) -> Result<Json> {
            let sh = cx.sheet_mut(si)?;
            if let Some(cell) = sh.cells.get_mut(c)
                && cell.formula.is_none()
-                && cell.py.is_none()
            {
                // An empty checkbox cell counts as FALSE.
                let next = match cell.value {
@@ -123,10 +122,25 @@ pub(super) fn new_cell_style(s: &mut Session, p: &Json) -> Result<Json> {
    })
 }

-/// Formulas › Recently Used: the functions most recently entered in a formula, newest first
-/// ([`crate::Prefs::recent_functions`]).
 pub(super) fn recently_used(s: &mut Session, _: &Json) -> Result<Json> {
-    Ok(json!(s.prefs.recent_functions))
+    let mut seen: Vec<String> = Vec::new();
+    for (id, p) in s.journal.iter().rev() {
+        if id != "cell.set" {
+            continue;
+        }
+        let input = p.get("input").and_then(Json::as_str).unwrap_or("");
+        if let Ok(e) = gridcraft_formula::parse(input.trim_start_matches('=')) {
+            for f in e.functions() {
+                if !seen.iter().any(|x| x == f) {
+                    seen.push(f.to_string());
+                }
+            }
+        }
+        if seen.len() >= 10 {
+            break;
+        }
+    }
+    Ok(json!(seen))
 }

 pub(super) fn use_in_formula(s: &mut Session, p: &Json) -> Result<Json> {
@@ -43,7 +43,6 @@ pub(super) fn add_element(s: &mut Session, p: &Json) -> Result<Json> {
                }
            }
            "dataLabels" => c.data_labels = on,
-            "dataTable" => crate::cmd::insert::update_data_table(c, p, Some(on))?,
            "gridlines" => c.gridlines = on,
            "axisTitles" => {
                c.x_title = on.then(|| c.x_title.clone().unwrap_or_else(|| "Axis Title".into()));
@@ -1,29 +1,8 @@
-use gridcraft_model::ObjKind;
-
 use super::chart::format_series;
 use super::{
-    Anchor, CellRef, Color, EngineError, Json, Result, Session, Shape, ShapeKind, Sheet, anchor_mode_name, bad, bool_param, edit, json, str_param,
-    u32_param,
+    Anchor, CellRef, Color, EngineError, Json, Result, Session, Shape, Sheet, anchor_mode_name, bad, bool_param, edit, json, str_param, u32_param,
 };

-/// The kind of object a `kind` parameter names: `shape` when the parameter is absent; one that
-/// is present but not one of the names (`null`, a number, an unknown word) is an error, as for
-/// the `object.*` commands, where the kind is required.
-fn kind_param(p: &Json, cmd: &str) -> Result<ObjKind> {
-    let err = || bad(cmd, "kind must be chart, image, shape, slicer or equation");
-    match p.get("kind") {
-        None => Ok(ObjKind::Shape),
-        Some(Json::String(k)) => ObjKind::parse(k).ok_or_else(err),
-        Some(_) => Err(err()),
-    }
-}
-
-/// Whether `kind` names the shape `sh`: an equation is a shape too, and a plain shape is not an
-/// equation, as `Sheet::object_anchor` has it for the `object.*` commands.
-fn shape_is(kind: ObjKind, sh: &Shape) -> bool {
-    kind != ObjKind::Equation || sh.kind == ShapeKind::Equation
-}
-
 pub(super) fn shape_fill(s: &mut Session, p: &Json) -> Result<Json> {
    if str_param(p, "kind") == Some("shape") {
        let color = str_param(p, "color").and_then(Color::from_hex).unwrap_or_default();
@@ -54,10 +33,9 @@ fn with_shape(s: &mut Session, p: &Json, f: impl FnOnce(&mut Shape)) -> Result<J

 pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json> {
    let id = u32_param(p, "id").ok_or_else(|| bad("arrange", "missing `id`"))?;
-    let kind = kind_param(p, "arrange")?;
+    let kind = str_param(p, "kind").unwrap_or("shape").to_string();
    let extreme = bool_param(p, "toFront").or(bool_param(p, "toBack")).unwrap_or(false);
    let si = s.doc()?.wb.active_sheet();
-    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;
@@ -73,18 +51,23 @@ pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result<Json>
    }
    edit(s, |cx| {
        let sh = cx.sheet_mut(si)?;
-        // An id that is not an object of this kind is an error, so a stale id, or a shape's id
-        // given as an equation, never reorders something else or succeeds silently.
-        let found = match kind {
-            ObjKind::Chart => sh.charts.iter().position(|c| c.id == id).map(|i| reorder(&mut sh.charts, i, forward, extreme)),
-            ObjKind::Image => sh.images.iter().position(|c| c.id == id).map(|i| reorder(&mut sh.images, i, forward, extreme)),
-            ObjKind::Slicer => sh.slicers.iter().position(|c| c.id == id).map(|i| reorder(&mut sh.slicers, i, forward, extreme)),
-            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))
+        match kind.as_str() {
+            "chart" => {
+                if let Some(i) = sh.charts.iter().position(|c| c.id == id) {
+                    reorder(&mut sh.charts, 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"))?;
+            "image" => {
+                if let Some(i) = sh.images.iter().position(|c| c.id == id) {
+                    reorder(&mut sh.images, i, forward, extreme);
+                }
+            }
+            _ => {
+                if let Some(i) = sh.shapes.iter().position(|c| c.id == id) {
+                    reorder(&mut sh.shapes, i, forward, extreme);
+                }
+            }
+        }
        Ok(Json::Null)
    })
 }
@@ -94,8 +77,7 @@ pub(super) fn selection_pane(s: &mut Session, _: &Json) -> Result<Json> {
    let sh = d.wb.active().ok_or(EngineError::NoDocument)?;
    let mut v = Vec::new();
    for c in &sh.shapes {
-        let kind = if c.kind == ShapeKind::Equation { "equation" } else { "shape" };
-        v.push(json!({"kind": kind, "id": c.id, "name": format!("{:?} {}", c.kind, c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
+        v.push(json!({"kind": "shape", "id": c.id, "name": format!("{:?} {}", c.kind, c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
    }
    for c in &sh.images {
        v.push(json!({"kind": "image", "id": c.id, "name": format!("Picture {}", c.id), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
@@ -103,59 +85,33 @@ pub(super) fn selection_pane(s: &mut Session, _: &Json) -> Result<Json> {
    for c in &sh.charts {
        v.push(json!({"kind": "chart", "id": c.id, "name": format!("Chart {}", c.id), "title": c.title, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}));
    }
-    // Slicers paint above the other objects.
-    for c in &sh.slicers {
-        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))
 }

-/// The anchors of every object of `kind` on the sheet; under `equation`, only the equations.
-fn anchors_of(sh: &mut Sheet, kind: ObjKind) -> Vec<(u32, &mut Anchor)> {
+fn anchors_of<'a>(sh: &'a mut Sheet, kind: &str) -> Vec<(u32, &'a mut Anchor)> {
    match kind {
-        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(),
+        "chart" => sh.charts.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
+        "image" => sh.images.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
+        _ => sh.shapes.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(),
    }
 }

 pub(super) fn align(s: &mut Session, p: &Json) -> Result<Json> {
-    let kind = kind_param(p, "arrange.align")?;
-    // `ids` may be absent (nothing to align) but, present, must be an array whose every entry is
-    // an object id naming an object of the kind: a stale or mismatched id, or a value of another
-    // shape, is an error, as for `arrange` and the `object.*` commands, not something silently
-    // left out.
-    let bad_ids = || bad("arrange.align", "ids must be an array of object ids");
-    let ids: Vec<u32> = match p.get("ids") {
-        None => Vec::new(),
-        Some(Json::Array(a)) => a.iter().map(|v| v.as_u64().and_then(|x| u32::try_from(x).ok()).ok_or_else(bad_ids)).collect::<Result<_>>()?,
-        Some(_) => return Err(bad_ids()),
-    };
+    let kind = str_param(p, "kind").unwrap_or("shape").to_string();
+    let ids: Vec<u32> =
+        p.get("ids").and_then(Json::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(|x| x as u32)).collect()).unwrap_or_default();
    let how = str_param(p, "align").unwrap_or("left").to_string();
    let si = s.doc()?.wb.active_sheet();
-    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)> = {
            let shc = sheet.clone();
-            anchors_of(sheet, kind)
+            anchors_of(sheet, &kind)
                .into_iter()
                .filter(|(id, _)| ids.contains(id))
                .map(|(id, a)| (id, shc.col_left(a.cell.col) + a.dx as f64, shc.row_top(a.cell.row) + a.dy as f64, a.width, a.height))
                .collect()
        };
-        if let Some(missing) = ids.iter().find(|id| !geo.iter().any(|g| g.0 == **id)) {
-            return Err(bad("arrange.align", format!("no such object: {missing}")));
-        }
        if geo.len() < 2 {
            return Ok(Json::Null);
        }
@@ -164,7 +120,7 @@ pub(super) fn align(s: &mut Session, p: &Json) -> Result<Json> {
        let top = geo.iter().map(|g| g.2).fold(f64::INFINITY, f64::min);
        let bottom = geo.iter().map(|g| g.2 + g.4 as f64).fold(f64::NEG_INFINITY, f64::max);
        let shc = sheet.clone();
-        for (id, a) in anchors_of(sheet, kind) {
+        for (id, a) in anchors_of(sheet, &kind) {
            let Some(g) = geo.iter().find(|g| g.0 == id) else { continue };
            let (mut x, mut y) = (g.1, g.2);
            match how.as_str() {
@@ -138,7 +138,7 @@ pub(super) fn run_script(s: &mut Session, p: &Json) -> Result<Json> {
            let opened_dialog = s.ui_requests.get(before..).is_some_and(|new| new.iter().any(|r| matches!(r, crate::UiRequest::Dialog(..))));
            let changed = wb_before.as_ref().is_some_and(|(uid, wb)| s.docs.iter().any(|d| d.uid == *uid && !std::sync::Arc::ptr_eq(&d.wb, wb)));
            if !opened_dialog || changed {
-                ran_steps.push((id.to_string(), crate::record::with_toggle_state(id, st["params"].clone(), &result)));
+                ran_steps.push((id.to_string(), crate::record::with_toggle_state(st["params"].clone(), &result)));
            }
        }
    }
@@ -38,35 +38,6 @@ pub(crate) fn keep_watch_list(from: &Workbook, to: &mut std::sync::Arc<Workbook>
    wb.names.extend(keep);
 }

-/// Normal, Page Layout and Page Break Preview belong to the window, not to the edits: Excel doesn't
-/// undo a switch between them, and `set_view` is no undo step. So undo and redo keep each sheet's
-/// current view when they swap in another snapshot of the workbook, and a view kept this way
-/// doesn't make a saved workbook dirty.
-pub(crate) fn keep_view_modes(d: &mut crate::DocState, now: &Workbook) {
-    // Sheets have no stable id. A name missing from `now` is a rename being undone or redone, which
-    // keeps the sheet count and position: the sheet is the one at the same index, under a name the
-    // restored snapshot doesn't have.
-    let renamed = |i: usize| {
-        (now.sheets.len() == d.wb.sheets.len()).then(|| now.sheets.get(i)).flatten().filter(|sh| !d.wb.sheets.iter().any(|s| s.name == sh.name))
-    };
-    let current = |i: usize, name: &str| now.sheets.iter().find(|sh| sh.name == name).or_else(|| renamed(i)).map(|sh| sh.view);
-    let changed: Vec<(usize, SheetViewMode)> =
-        d.wb.sheets.iter().enumerate().filter_map(|(i, sh)| current(i, &sh.name).filter(|v| *v != sh.view).map(|v| (i, v))).collect();
-    if changed.is_empty() {
-        return;
-    }
-    let dirty = d.is_dirty();
-    let wb = std::sync::Arc::make_mut(&mut d.wb);
-    for (i, v) in changed {
-        if let Some(sh) = wb.sheet_mut(i) {
-            sh.view = v;
-        }
-    }
-    if !dirty {
-        d.saved = d.wb.clone();
-    }
-}
-
 pub(super) fn custom_views(s: &mut Session, p: &Json) -> Result<Json> {
    let d = s.doc()?;
    let mut views = stash_map(&d.wb, VIEWS_NAME);
@@ -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}))
 }
@@ -315,7 +315,7 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result<Json> {
        let vstyle = cx.wb.styles.derive(StyleId::DEFAULT, |st| st.num_fmt = vfmt.clone());
        let mut sheet = Sheet::new(sheet_name.clone());
        let put = |sheet: &mut Sheet, row: u32, col: u32, v: Value, style: StyleId| {
-            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style, py: None });
+            sheet.set_cell(CellRef::new(row, col), Cell { value: v, formula: None, style });
        };
        let formula = |sheet: &mut Sheet, row: u32, col: u32, text: String, style: StyleId| {
            let mut cell = Cell::formula(Formula::new(&text));
@@ -424,11 +424,8 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result<Json> {
            series,
            legend: LegendPos::Bottom,
            data_labels: false,
-            data_table: None,
            gridlines: true,
            style: 1,
-            hole_size: 75,
-            first_slice_angle: 0,
            x_title: None,
            y_title: None,
            source: None,
@@ -90,14 +90,8 @@ pub fn specs() -> Vec<CommandSpec> {
            format_cells
        ),
        // Alignment
-        CommandSpec {
-            shortcut_mac: Some("Cmd+L"),
-            ..cmd!("home.alignLeft", "Align Left", ["Home", "Alignment"], Some("Cmd+L"), "{range?}", has_doc, |s, p| halign(s, p, HAlign::Left))
-        },
-        CommandSpec {
-            shortcut_mac: Some("Cmd+E"),
-            ..cmd!("home.alignCenter", "Center", ["Home", "Alignment"], Some("Cmd+E"), "{range?}", has_doc, |s, p| halign(s, p, HAlign::Center))
-        },
+        cmd!("home.alignLeft", "Align Left", ["Home", "Alignment"], Some("Cmd+L"), "{range?}", has_doc, |s, p| halign(s, p, HAlign::Left)),
+        cmd!("home.alignCenter", "Center", ["Home", "Alignment"], Some("Cmd+E"), "{range?}", has_doc, |s, p| halign(s, p, HAlign::Center)),
        cmd!("home.alignRight", "Align Right", ["Home", "Alignment"], None, "{range?}", has_doc, |s, p| halign(s, p, HAlign::Right)),
        cmd!("home.justify", "Justify", ["Home", "Alignment"], None, "{range?}", has_doc, |s, p| halign(s, p, HAlign::Justify)),
        cmd!("home.alignTop", "Top Align", ["Home", "Alignment"], None, "{range?}", has_doc, |s, p| valign(s, p, VAlign::Top)),
@@ -656,7 +650,8 @@ fn merge(s: &mut Session, p: &Json, how: &str) -> Result<Json> {
                            let others: Vec<CellRef> = sh.cells.iter_range(m).map(|(c, _)| c).filter(|c| *c != m.start).collect();
                            for c in others {
                                if let Some(mut cell) = sh.cells.get(c).cloned() {
-                                    cell.clear_content();
+                                    cell.value = gridcraft_core::Value::Empty;
+                                    cell.formula = None;
                                    sh.set_cell(c, cell);
                                }
                                touched.push((sheet, c));
@@ -673,7 +668,8 @@ fn merge(s: &mut Session, p: &Json, how: &str) -> Result<Json> {
                        let others: Vec<CellRef> = sh.cells.iter_range(*r).map(|(c, _)| c).filter(|c| *c != r.start).collect();
                        for c in others {
                            if let Some(mut cell) = sh.cells.get(c).cloned() {
-                                cell.clear_content();
+                                cell.value = gridcraft_core::Value::Empty;
+                                cell.formula = None;
                                sh.set_cell(c, cell);
                            }
                            touched.push((sheet, c));
@@ -690,10 +686,7 @@ fn merge(s: &mut Session, p: &Json, how: &str) -> Result<Json> {
            let blocked = sh
                .cells
                .iter_range(reach)
-                // A Python cell's result is blocked and unblocked like a formula's.
-                .filter(|(_, x)| {
-                    (x.formula.is_some() || x.py.is_some()) && x.value == gridcraft_core::Value::Error(gridcraft_core::CellError::Spill)
-                });
+                .filter(|(_, x)| x.formula.is_some() && x.value == gridcraft_core::Value::Error(gridcraft_core::CellError::Spill));
            touched.extend(blocked.map(|(c, _)| (sheet, c)));
        }
        cx.changed.extend(touched);
@@ -9,17 +9,6 @@ use super::{
 /// sheet is `sheet`, else the prefix, else the active one. The selection belongs to the active
 /// sheet, so another sheet needs explicit lines.
 fn line_targets(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> {
-    let (sheet, lines) = resolve_lines(s, p, rows)?;
-    // Sizes and visibility are formatting of the line, which a protected sheet must allow.
-    if rows {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting rows", |p| p.format_rows)?;
-    } else {
-        crate::cmd::refuse_unless_allowed(s, sheet, "Formatting columns", |p| p.format_columns)?;
-    }
-    Ok((sheet, lines))
-}
-
-fn resolve_lines(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> {
    let key = if rows { "rows" } else { "cols" };
    let mut sheet = target_sheet(s, p)?;
    if let Some(t) = str_param(p, key) {
@@ -69,15 +69,6 @@ pub fn specs() -> Vec<CommandSpec> {
        ),
        cmd!(query "formulas.tracePrecedents", "Trace Precedents", ["Formulas", "Formula Auditing"], None, "{cell?} → ranges", has_doc, trace_precedents),
        cmd!(query "formulas.traceDependents", "Trace Dependents", ["Formulas", "Formula Auditing"], None, "{cell?} → cells", has_doc, trace_dependents),
-        cmd!(
-            query "formulas.traceError",
-            "Trace Error",
-            ["Formulas", "Formula Auditing"],
-            None,
-            "{cell?} → {sheet, cell, error, source: {sheet, cell}, arrows: [{from: {sheet, range}, to: {sheet, cell}, kind: \"error\"|\"precedent\"}], truncated}: from the cell, follows the first reference that shows the same error (in a range, its first cell showing it) back to the cell the error starts in, `source`. `error` arrows link the cells on the way; `precedent` arrows lead from the source's own references into it. A cell without an error gives `error` and `source` null and no arrows. A chain longer than 10,000 links stops there with `truncated` true and `source` null.",
-            has_doc,
-            trace_error
-        ),
        cmd!(noundo "formulas.selectPrecedents", "Select Precedents", ["Formulas", "Formula Auditing"], Some("Ctrl+["), "{cell?, all?: true = every level (Ctrl+Shift+[)} → selects the precedent cells", has_doc, select_precedents),
        cmd!(noundo "formulas.selectDependents", "Select Dependents", ["Formulas", "Formula Auditing"], Some("Ctrl+]"), "{cell?, all?: true = every level (Ctrl+Shift+])}", has_doc, select_dependents),
        cmd!(noundo "formulas.removeArrows", "Remove Arrows", ["Formulas", "Formula Auditing"], None, "{}", has_doc, |_, _| ok()),
@@ -101,7 +92,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
        ),
@@ -635,7 +626,7 @@ fn paste_name(s: &mut Session, p: &Json) -> Result<Json> {
                let sh = cx.sheet_mut(sheet)?;
                let style = sh.style_id(c);
                // The second column holds the refers-to text as a text value, with no formula.
-                sh.set_cell(c, Cell { value: Value::text(text.as_str()), formula: None, style, py: None });
+                sh.set_cell(c, Cell { value: Value::text(text.as_str()), formula: None, style });
                cx.touch(sheet, c);
            }
        }
@@ -662,79 +653,6 @@ fn trace_dependents(s: &mut Session, p: &Json) -> Result<Json> {
    Ok(Json::Array(v))
 }

-/// Trace Error goes back at most this many links; a longer chain stops there.
-const TRACE_ERROR_LINKS: usize = 10_000;
-
-/// Trace Error: from the cell, the first reference in its formula that shows the same error
-/// (in a range, the range's first cell showing it, row by row), then that cell's, and so on to the
-/// cell the error starts in: one none of whose references shows it, or one without references.
-/// Arrows link the cells on the way, and lead from the source's own references into it.
-fn trace_error(s: &mut Session, p: &Json) -> Result<Json> {
-    use std::collections::HashSet;
-    let d = s.doc()?;
-    let at = cell_param(s, p, "cell")?.unwrap_or(d.selection.active);
-    let sheet = d.wb.active_sheet();
-    let name = |si: usize| d.wb.sheet(si).map(|sh| sh.name.clone());
-    let cell = |(si, c): (usize, CellRef)| json!({"sheet": name(si), "cell": c.a1()});
-    let Some(error) = d.wb.sheet(sheet).and_then(|sh| sh.value(at).as_error()) else {
-        return Ok(json!({"sheet": name(sheet), "cell": at.a1(), "error": null, "source": null, "arrows": [], "truncated": false}));
-    };
-    // A value spilled by a dynamic array comes from its anchor's formula.
-    let precedents = |(si, c): (usize, CellRef)| {
-        let anchor = d.wb.sheet(si).filter(|sh| sh.cell(c).is_none_or(|x| x.formula.is_none())).and_then(|sh| sh.spill_anchor(c));
-        d.calc.graph.precedents_of((si, anchor.unwrap_or(c)))
-    };
-    // The walk keeps to cells it hasn't been to, so a circular reference ends it.
-    let mut chain = vec![(sheet, at)];
-    let mut seen: HashSet<(usize, CellRef)> = HashSet::from([(sheet, at)]);
-    let mut truncated = false;
-    let mut last = (sheet, at);
-    while let Some(next) = precedents(last).iter().find_map(|a| first_showing(&d.wb, a, error)) {
-        if !seen.insert(next) {
-            break;
-        }
-        if chain.len() > TRACE_ERROR_LINKS {
-            truncated = true;
-            break;
-        }
-        chain.push(next);
-        last = next;
-    }
-    let mut arrows = Vec::new();
-    // A chain cut short hasn't reached its source.
-    if !truncated {
-        let mut drawn = HashSet::new();
-        for a in precedents(last) {
-            if drawn.insert(a) {
-                arrows.push(json!({"from": {"sheet": name(a.sheet), "range": a.range.a1()}, "to": cell(last), "kind": "precedent"}));
-            }
-        }
-    }
-    // From the source outwards, as the error travels.
-    for pair in chain.windows(2).rev() {
-        if let [to, from] = pair {
-            arrows.push(json!({"from": {"sheet": name(from.0), "range": from.1.a1()}, "to": cell(*to), "kind": "error"}));
-        }
-    }
-    let source = if truncated { Json::Null } else { cell(last) };
-    Ok(json!({"sheet": name(sheet), "cell": at.a1(), "error": error.as_str(), "source": source, "arrows": arrows, "truncated": truncated}))
-}
-
-/// The first cell of an area, row by row, that shows `error`: a stored cell or a value spilled
-/// into the area by a dynamic array.
-fn first_showing(wb: &Workbook, a: &gridcraft_calc::Area, error: CellError) -> Option<(usize, CellRef)> {
-    let sh = wb.sheet(a.sheet)?;
-    let holds = |c: &Cell| !c.value.is_empty() || c.formula.is_some();
-    let stored = sh.cells.iter_range(a.range).find(|(_, c)| holds(c) && c.value.as_error() == Some(error)).map(|(at, _)| at);
-    let spilled = sh
-        .spill
-        .range(a.range.start..)
-        .take_while(|(at, _)| **at <= a.range.end)
-        .find(|(at, v)| a.range.contains(**at) && v.as_error() == Some(error) && !sh.cell(**at).is_some_and(holds))
-        .map(|(at, _)| *at);
-    stored.into_iter().chain(spilled).min().map(|c| (a.sheet, c))
-}
-
 /// Excel's Ctrl+[ / Ctrl+]: select the precedent (or dependent) cells. When they all live on
 /// another sheet, jump there. `all` walks every level (Ctrl+Shift+[ / Ctrl+Shift+]).
 fn select_trace_cells(s: &mut Session, p: &Json, precedents: bool) -> Result<Json> {
@@ -954,30 +872,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}))
    })
 }

@@ -1,12 +1,12 @@
 //! Insert tab: tables, charts, sparklines, pictures, shapes, hyperlinks, comments and notes,
 //! conditional formatting (Home › Styles) and symbols.

-use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef};
+use gridcraft_core::{CellRef, MAX_ROWS, RangeRef};
 use gridcraft_formula::adjust::{Axis, Edit};
 use gridcraft_model::{
    Anchor, BorderLine, BorderStyle, Borders, Cell, CellPicture, CfOperator, CfRule, CfValueKind, Chart, ChartKind, Color, Comment, CondFormat, Fill,
-    Formula, Hyperlink, Image, LegendPos, ObjKind, ObjRef, Series, Shape, ShapeKind, Sheet, Sparkline, SparklineKind, Style, Table, TableColumn,
-    TotalsFn, Underline, Workbook,
+    Formula, Hyperlink, Image, LegendPos, Series, Shape, ShapeKind, Sheet, Sparkline, SparklineKind, Style, Table, TableColumn, TotalsFn, Underline,
+    Workbook,
 };
 use serde_json::{Value as Json, json};

@@ -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?, quartiles?: exclusive|inclusive, style?, xTitle?, yTitle?, at?, width?, height?, dx?, dy?}",
            has_doc,
            chart_set
        ),
@@ -146,22 +146,14 @@ 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.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)}",
-            has_doc,
-            move_object
-        ),
+        cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape, id}", has_doc, delete_object),
+        cmd!("object.move", "Move Object", [], None, "{kind: chart|image|shape, id, at?: \"C3\", dx?, dy?, width?, height?}", has_doc, move_object),
        cmd!(
            "object.setAnchorMode",
            "Object Properties",
            [],
            None,
-            "{kind: chart|image|shape|slicer|equation|control, id, mode: moveAndSize|moveOnly|absolute}",
+            "{kind: chart|image|shape, id, mode: moveAndSize|moveOnly|absolute}",
            has_doc,
            set_anchor_mode
        ),
@@ -179,7 +171,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Open Hyperlink",
            [],
            None,
-            "{url?: \"https://…\" | \"mailto:…\" | \"Sheet2!A1\", cell?} (default: the cell's link); a reference selects; a web or e-mail address is an error unless the host allows it: the user opens those by clicking the link and confirming; any scheme but http, https and mailto is always an error",
+            "{url?: \"https://…\" | \"mailto:…\" | \"Sheet2!A1\", cell?} (default: the cell's link); only http, https and mailto are opened, any other scheme is an error; the UI asks before opening",
            has_doc,
            open_link
        ),
@@ -242,30 +234,14 @@ fn block(s: &Session, p: &Json) -> Result<RangeRef> {
 }

 fn chart_areas(s: &Session, p: &Json) -> Result<Vec<RangeRef>> {
-    let mut areas = if p.get("range").is_some() {
-        target_ranges(s, p)?
-    } else if s.doc()?.selection.ranges.len() > 1 {
-        s.doc()?.selection.ranges.clone()
-    } else {
-        vec![block(s, p)?]
-    };
-    // Whole columns/rows span a million cells: clip their far edges to the cells in use, so only
-    // a block that really is too large gets refused. Bounded areas keep their extent as given.
-    let sheet = target_sheet(s, p)?;
-    if let Some(used) = s.doc()?.wb.sheet(sheet).and_then(|sh| sh.used_range()) {
-        // Areas that start outside the used range keep their extent as given.
-        for r in &mut areas {
-            let whole_cols = r.start.row == 0 && r.end.row >= MAX_ROWS - 1;
-            let whole_rows = r.start.col == 0 && r.end.col >= MAX_COLS - 1;
-            if whole_cols && r.start.row <= used.end.row {
-                r.end.row = r.end.row.min(used.end.row);
-            }
-            if whole_rows && r.start.col <= used.end.col {
-                r.end.col = r.end.col.min(used.end.col);
-            }
-        }
+    if p.get("range").is_some() {
+        return target_ranges(s, p);
    }
-    Ok(areas)
+    let d = s.doc()?;
+    if d.selection.ranges.len() > 1 {
+        return Ok(d.selection.ranges.clone());
+    }
+    Ok(vec![block(s, p)?])
 }

 // ---------------------------------------------------------------- tables
@@ -316,7 +292,7 @@ fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
            let sh = cx.sheet_mut(sheet)?;
            // The header row pushes the data down one row: never off the end of the sheet.
            let last = RangeRef::new(CellRef::new(MAX_ROWS - 1, r.start.col), CellRef::new(MAX_ROWS - 1, r.end.col));
-            if sh.cells.iter_range(last).any(|(_, x)| x.has_content()) {
+            if sh.cells.iter_range(last).any(|(_, x)| x.formula.is_some() || !x.value.is_empty()) {
                return Err(EngineError::Other("To prevent possible loss of data, cells can't be pushed off the end of the worksheet.".into()));
            }
            sh.cells.shift_rows_in_cols(r.start.col, r.end.col, r.start.row, 1);
@@ -325,7 +301,7 @@ fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
            let e = Edit::InsertCells { axis: Axis::Rows, range: RangeRef::new(r.start, CellRef::new(r.start.row, r.end.col)) };
            shift_cell_features(sh, &e);
            let name = sh.name.clone();
-            rewrite(cx, &name, &e)?;
+            rewrite(cx, &name, &e);
            let sh = cx.sheet_mut(sheet)?;
            for (i, c) in (r.start.col..=r.end.col).enumerate() {
                sh.set_value(CellRef::new(r.start.row, c), gridcraft_core::Value::text(format!("Column{}", i + 1)));
@@ -476,10 +452,7 @@ fn write_totals(sh: &mut Sheet, ti: usize) {
        let c = CellRef::new(row, t.range.start.col + i as u32);
        if let Some(code) = col.totals.subtotal_code() {
            let f = format!("=SUBTOTAL({code},{}[{}])", t.name, col.name);
-            sh.set_cell(
-                c,
-                Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c), py: None },
-            );
+            sh.set_cell(c, Cell { formula: Some(std::sync::Arc::new(Formula::new(&f))), value: gridcraft_core::Value::Empty, style: sh.style_id(c) });
        } else if let Some(l) = &col.totals_label {
            sh.set_value(c, gridcraft_core::Value::text(l.as_str()));
        } else {
@@ -847,11 +820,8 @@ pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> {
        series,
        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
        data_labels: false,
-        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())),
@@ -897,11 +867,7 @@ fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
        let Some(c) = sh.charts.get_mut(ci) else { return Ok(Json::Null) };
        if let Some(t) = str_param(p, "type") {
            c.kind = chart_kind(t, str_param(p, "subtype").unwrap_or(""));
-            if !c.supports_data_table() {
-                c.data_table = None;
-            }
        }
-        update_data_table(c, p, bool_param(p, "dataTable"))?;
        if let Some(method) = quartiles {
            for series in &mut c.series {
                series.quartiles = method;
@@ -928,12 +894,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);
        }
@@ -944,10 +904,10 @@ fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
            c.anchor.cell = at;
        }
        if let Some(w) = f64_param(p, "width") {
-            c.anchor.width = w.clamp(20.0, size_cap(c.anchor.width)) as f32;
+            c.anchor.width = w.clamp(20.0, 10000.0) as f32;
        }
        if let Some(h) = f64_param(p, "height") {
-            c.anchor.height = h.clamp(20.0, size_cap(c.anchor.height)) as f32;
+            c.anchor.height = h.clamp(20.0, 10000.0) as f32;
        }
        if let Some(v) = f64_param(p, "dx") {
            c.anchor.dx = v as f32;
@@ -959,32 +919,6 @@ fn chart_set(s: &mut Session, p: &Json) -> Result<Json> {
    })
 }

-/// Shared by Chart Properties and Add Chart Element; no separate UI state.
-pub(super) fn update_data_table(c: &mut Chart, p: &Json, on: Option<bool>) -> Result<()> {
-    if p.get("dataTable").is_some_and(|v| !v.is_boolean()) {
-        return Err(bad("chart", "`dataTable` must be a boolean"));
-    }
-    if on == Some(false) {
-        c.data_table = None;
-        return Ok(());
-    }
-    let fields = ["dataTableKeys", "dataTableHorizontalBorder", "dataTableVerticalBorder", "dataTableOutline"];
-    if on == Some(true) || fields.iter().any(|k| p.get(k).is_some()) {
-        if !c.supports_data_table() {
-            return Err(bad("chart", "data tables need a column, bar, line, area or compatible combo chart"));
-        }
-        let table = c.data_table.get_or_insert_with(Default::default);
-        for (key, value) in
-            fields.into_iter().zip([&mut table.show_keys, &mut table.horizontal_border, &mut table.vertical_border, &mut table.outline])
-        {
-            if let Some(v) = p.get(key) {
-                *value = v.as_bool().ok_or_else(|| bad("chart", format!("`{key}` must be a boolean")))?;
-            }
-        }
-    }
-    Ok(())
-}
-
 fn chart_switch(s: &mut Session, p: &Json) -> Result<Json> {
    let (si, ci) = find_chart(s, p)?;
    edit(s, |cx| {
@@ -1108,10 +1042,6 @@ fn insert_picture(s: &mut Session, p: &Json) -> Result<Json> {
        .unwrap_or_else(|| if data.starts_with(&[0x89, b'P', b'N', b'G']) { "image/png".into() } else { "image/jpeg".into() });
    let (w, h) = crate::io::image_size(&data).unwrap_or((320, 240));
    let d = s.doc()?;
-    // Sheet protection locks drawing objects, as for a text box's text.
-    if d.wb.active().is_some_and(|sh| sh.is_protected()) {
-        return Err(EngineError::Other(PROTECTED.into()));
-    }
    let id = d.wb.next_object_id();
    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
    let scale = (640.0 / w.max(1) as f32).min(1.0);
@@ -1185,7 +1115,6 @@ fn insert_shape(s: &mut Session, p: &Json) -> Result<Json> {
        Color::Theme(4, -250)
    });
    let shape = Shape {
-        math: Default::default(),
        id,
        kind,
        anchor: Anchor {
@@ -1239,65 +1168,51 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result<Json> {
    })
 }

-/// The floating object a `{kind, id}` command names on the active sheet. Unknown kinds and
-/// 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 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))
-}
-
 fn delete_object(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, o) = object_param(s, p, "object.delete")?;
+    let id = u32_param(p, "id").ok_or_else(|| bad("object.delete", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("").to_string();
+    let sheet = s.doc()?.wb.active_sheet();
    edit(s, |cx| {
-        cx.sheet_mut(sheet)?.remove_object(o);
-        Ok(json!({"deleted": o}))
+        let sh = cx.sheet_mut(sheet)?;
+        match kind.as_str() {
+            "chart" => sh.charts.retain(|c| c.id != id),
+            "image" => sh.images.retain(|c| c.id != id),
+            "slicer" => sh.slicers.retain(|c| c.id != id),
+            _ => sh.shapes.retain(|c| c.id != id),
+        }
+        Ok(Json::Null)
    })
 }

-/// Largest offset (points) `object.move` accepts from the anchor cell.
-const MAX_OBJECT_OFFSET: f64 = 100_000.0;
-
-/// Largest width or height (points) `object.move` and `chart.set` give an object that is not
-/// already larger: see [`size_cap`].
-const MAX_OBJECT_SIZE: f64 = 10_000.0;
-
-/// The most a command may make a dimension that is `current` now: [`MAX_OBJECT_SIZE`], or the
-/// current size when a file made the object larger (the XLSX reader accepts anchors far past the
-/// limit). Such an object keeps its size when it is moved and shrinks by what a resize asks, but
-/// it never grows further, so hostile input is still capped. Never NaN: `f64::max` drops one.
-fn size_cap(current: f32) -> f64 {
-    MAX_OBJECT_SIZE.max(f64::from(current))
-}
-
 fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, o) = object_param(s, p, "object.move")?;
+    let id = u32_param(p, "id").ok_or_else(|| bad("object.move", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("").to_string();
+    let sheet = s.doc()?.wb.active_sheet();
    let at = cell_param(s, p, "at")?;
    edit(s, |cx| {
-        let Some(a) = cx.sheet_mut(sheet)?.object_anchor_mut(o) else { return Err(bad("object.move", "no such object")) };
+        let sh = cx.sheet_mut(sheet)?;
+        let anchor = match kind.as_str() {
+            "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "slicer" => sh.slicers.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "shape" => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            _ => None,
+        };
+        let Some(a) = anchor else { return Err(bad("object.move", "no such object")) };
        if let Some(at) = at {
            a.cell = at;
        }
        if let Some(v) = f64_param(p, "dx") {
-            a.dx = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32;
+            a.dx = v as f32;
        }
        if let Some(v) = f64_param(p, "dy") {
-            a.dy = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32;
+            a.dy = v as f32;
        }
        if let Some(v) = f64_param(p, "width") {
-            a.width = v.clamp(1.0, size_cap(a.width)) as f32;
+            a.width = v.clamp(1.0, 10000.0) as f32;
        }
        if let Some(v) = f64_param(p, "height") {
-            a.height = v.clamp(0.0, size_cap(a.height)) as f32;
+            a.height = v.clamp(0.0, 10000.0) as f32;
        }
        Ok(Json::Null)
    })
@@ -1307,10 +1222,21 @@ fn move_object(s: &mut Session, p: &Json) -> Result<Json> {
 /// cells" / "Don't move or size with cells"), so it follows — or ignores — its rows and columns
 /// when the sheet is sorted or edited structurally.
 fn set_anchor_mode(s: &mut Session, p: &Json) -> Result<Json> {
-    let (sheet, o) = object_param(s, p, "object.setAnchorMode")?;
+    let id = u32_param(p, "id").ok_or_else(|| bad("object.setAnchorMode", "missing `id`"))?;
+    let kind = str_param(p, "kind").unwrap_or("").to_string();
+    if !matches!(kind.as_str(), "chart" | "image" | "shape") {
+        return Err(bad("object.setAnchorMode", "kind must be chart, image or shape"));
+    }
    let mode = anchor_mode_param(p).ok_or_else(|| bad("object.setAnchorMode", "mode must be moveAndSize, moveOnly or absolute"))?;
+    let sheet = s.doc()?.wb.active_sheet();
    edit(s, |cx| {
-        let Some(a) = cx.sheet_mut(sheet)?.object_anchor_mut(o) else { return Err(bad("object.setAnchorMode", "no such object")) };
+        let sh = cx.sheet_mut(sheet)?;
+        let anchor = match kind.as_str() {
+            "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+            _ => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor),
+        };
+        let Some(a) = anchor else { return Err(bad("object.setAnchorMode", "no such object")) };
        a.mode = mode;
        Ok(json!({"mode": anchor_mode_name(mode)}))
    })
@@ -1341,7 +1267,7 @@ fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
        });
        let sh = cx.sheet_mut(sheet)?;
        if let Some(t) = text.clone().or_else(|| sh.value(at).is_empty().then(|| target.clone())) {
-            sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style, py: None });
+            sh.set_cell(at, Cell { value: gridcraft_core::Value::text(t.as_str()), formula: None, style: link_style });
        } else {
            sh.set_style(at, link_style);
        }
@@ -1351,11 +1277,9 @@ fn insert_link(s: &mut Session, p: &Json) -> Result<Json> {
    })
 }

-/// Follows a link: a reference selects it; anything else is refused ([`crate::links::classify`]).
-/// An `http`/`https`/`mailto` address is refused too unless the host set
-/// [`crate::links::LinkPolicy::Allow`]: every caller of a command may be a script or an agent, so
-/// the user opens such links by clicking and confirming, and the UI then calls
-/// [`Session::open_confirmed_link`] (#2181). Opens no dialog.
+/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the
+/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no
+/// dialog; the interactive click asks for confirmation first, in the UI.
 fn open_link(s: &mut Session, p: &Json) -> Result<Json> {
    let target = match str_param(p, "url").or_else(|| str_param(p, "target")) {
        Some(t) => t.to_string(),
@@ -1371,9 +1295,6 @@ fn open_link(s: &mut Session, p: &Json) -> Result<Json> {
    match crate::links::classify(&target) {
        crate::links::LinkKind::Internal(r) => super::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})),
        crate::links::LinkKind::External(u) => {
-            if s.link_policy != crate::links::LinkPolicy::Allow {
-                return Err(EngineError::Other(crate::links::NEEDS_CONFIRMATION.into()));
-            }
            s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone()));
            Ok(json!({"opened": u}))
        }
@@ -1753,13 +1674,7 @@ fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
            sh.cond_formats.clear();
        } else {
            for cf in sh.cond_formats.iter_mut() {
-                let before = RangeRef::top_left(&cf.ranges);
                cf.ranges.retain(|r| !ranges.iter().any(|x| x.intersects(r)));
-                // The relative formulas are written for the top-left cell: when it goes, they're
-                // rewritten for the new one, so the areas left keep reading the same cells.
-                if let (Some(from), Some(to)) = (before, RangeRef::top_left(&cf.ranges)) {
-                    rebase_cf_formulas(&mut cf.rule, from, to);
-                }
            }
            sh.cond_formats.retain(|c| !c.ranges.is_empty());
        }
@@ -1767,19 +1682,6 @@ fn clear_cf(s: &mut Session, p: &Json) -> Result<Json> {
    })
 }

-/// Moves the relative references of a rule's per-cell formulas written for `from` to `to`.
-fn rebase_cf_formulas(rule: &mut CfRule, from: CellRef, to: CellRef) {
-    let mv = |f: &str| crate::cmd::data::move_rule_formula(f, from, to);
-    match rule {
-        CfRule::CellIs { a, b, .. } => {
-            *a = mv(a);
-            *b = b.as_deref().map(mv);
-        }
-        CfRule::Expression { formula, .. } => *formula = mv(formula),
-        _ => {}
-    }
-}
-
 fn manage_cf(s: &mut Session, p: &Json) -> Result<Json> {
    let sheet = target_sheet(s, p)?;
    if p.get("delete").is_none() && p.get("moveUp").is_none() && p.get("moveDown").is_none() {
@@ -1827,7 +1729,6 @@ fn insert_icon(s: &mut Session, p: &Json) -> Result<Json> {
    let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active);
    let color = super::format::color_param(p.get("color")).unwrap_or(Color::Theme(1, 0));
    let shape = Shape {
-        math: Default::default(),
        id,
        kind: ShapeKind::Icon,
        anchor: Anchor { cell: at, dx: 4.0, dy: 4.0, width: size, height: size, mode: anchor_mode_param(p).unwrap_or_default() },
@@ -1847,86 +1748,6 @@ fn insert_icon(s: &mut Session, p: &Json) -> Result<Json> {
 mod tests {
    use super::*;

-    #[test]
-    fn chart_from_whole_columns_uses_the_rows_in_use() {
-        // #3114: selecting two whole columns of data refused the chart as "range too large".
-        let mut s = Session::new();
-        s.new_workbook();
-        let values: Vec<Vec<String>> = (1..=5).map(|i| vec![i.to_string(), (i * 10).to_string()]).collect();
-        s.execute("range.setValues", json!({"range": "A1:B5", "values": values})).unwrap();
-        s.execute("selection.set", json!({"range": "A:B"})).unwrap();
-        s.execute("insert.chart", json!({"type": "line"})).unwrap();
-        let d = s.doc().unwrap();
-        let chart = d.wb.active().unwrap().charts.last().unwrap();
-        let values: Vec<&str> = chart.series.iter().map(|x| x.values.as_str()).collect();
-        assert_eq!(values, ["Sheet1!$A$1:$A$5", "Sheet1!$B$1:$B$5"]);
-        // A block that really is too large still is.
-        s.execute("cell.set", json!({"cell": "B600000", "input": "1"})).unwrap();
-        assert!(s.execute("insert.chart", json!({"range": "A:B", "type": "line"})).is_err());
-        // A bounded block keeps its extent, even where it runs past the data.
-        s.execute("insert.chart", json!({"range": "A1:A20", "type": "line"})).unwrap();
-        let d = s.doc().unwrap();
-        let chart = d.wb.active().unwrap().charts.last().unwrap();
-        let values: Vec<&str> = chart.series.iter().map(|x| x.values.as_str()).collect();
-        assert_eq!(values, ["Sheet1!$A$1:$A$20"]);
-        // A bounded block entirely below the data keeps its extent.
-        s.execute("insert.chart", json!({"range": "C700000:C700010", "type": "line"})).unwrap();
-        let d = s.doc().unwrap();
-        let chart = d.wb.active().unwrap().charts.last().unwrap();
-        let values: Vec<&str> = chart.series.iter().map(|x| x.values.as_str()).collect();
-        assert_eq!(values, ["Sheet1!$C$700000:$C$700010"]);
-    }
-
-    #[test]
-    fn chart_data_table_commands_undo_and_follow_live_values() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Quarter", "Sales"], ["Q1", 10], ["Q2", 20]]})).unwrap();
-        s.execute("insert.chart", json!({"range": "A1:B3", "type": "column"})).unwrap();
-        s.execute("chart.addElement", json!({"element": "dataTable", "dataTableKeys": false})).unwrap();
-        let get = |s: &Session| s.active().unwrap().wb.active().unwrap().charts[0].clone();
-        let table = get(&s).data_table.unwrap();
-        assert!(!table.show_keys && table.horizontal_border && table.vertical_border && table.outline);
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(get(&s).data_table, None);
-        s.execute("edit.redo", json!({})).unwrap();
-        assert_eq!(get(&s).data_table, Some(table));
-        s.execute("chart.set", json!({"dataTableKeys": true, "dataTableHorizontalBorder": false})).unwrap();
-        assert!(get(&s).data_table.as_ref().unwrap().show_keys);
-        assert!(!get(&s).data_table.as_ref().unwrap().horizontal_border);
-        s.execute("cell.set", json!({"cell": "B2", "input": "=12*3"})).unwrap();
-        let d = s.active().unwrap();
-        assert_eq!(gridcraft_chart::resolve(&d.wb, 0, &get(&s)).series[0].values[0], Some(36.0));
-        s.execute("chart.addElement", json!({"element": "dataTable", "on": false})).unwrap();
-        assert_eq!(get(&s).data_table, None);
-        // Old JSON documents have no table field.
-        let mut json = serde_json::to_value(get(&s)).unwrap();
-        json.as_object_mut().unwrap().remove("data_table");
-        assert_eq!(serde_json::from_value::<Chart>(json).unwrap().data_table, None);
-    }
-
-    #[test]
-    fn chart_data_table_refuses_unsupported_types_without_changing_history() {
-        let mut s = Session::new();
-        s.new_workbook();
-        s.execute("range.setValues", json!({"range": "A1", "values": [["Q", "Sales"], ["Q1", 10], ["Q2", 20]]})).unwrap();
-        s.execute("insert.chart", json!({"range": "A1:B3", "type": "pie"})).unwrap();
-        let before = s.active().unwrap().wb.clone();
-        let history = s.execute("history.list", json!({})).unwrap();
-        for params in [json!({"dataTable": true}), json!({"dataTableKeys": true}), json!({"dataTable": "yes"})] {
-            assert!(s.execute("chart.set", params).is_err());
-            assert_eq!(s.active().unwrap().wb, before);
-            assert_eq!(s.execute("history.list", json!({})).unwrap(), history);
-        }
-        assert!(s.execute("chart.addElement", json!({"element": "dataTable"})).is_err());
-        s.execute("chart.set", json!({"type": "line", "dataTable": true})).unwrap();
-        assert!(s.active().unwrap().wb.active().unwrap().charts[0].data_table.is_some());
-        s.execute("chart.set", json!({"type": "scatter"})).unwrap();
-        assert!(s.active().unwrap().wb.active().unwrap().charts[0].data_table.is_none());
-        s.execute("edit.undo", json!({})).unwrap();
-        assert!(s.active().unwrap().wb.active().unwrap().charts[0].data_table.is_some());
-    }
-
    #[test]
    fn manage_rules_delete_then_move() {
        let mut s = Session::new();
@@ -260,7 +260,6 @@ pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> {
        series,
        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
        data_labels: false,
-        data_table: None,
        gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel),
        style: 1,
        x_title: None,
@@ -333,7 +333,6 @@ pub(super) fn insert_icon(s: &mut Session, p: &Json) -> Result<Json> {
        line: Color::Auto,
        text: name,
        format: Default::default(),
-        math: Default::default(),
    };
    let sheet = d.wb.active_sheet();
    edit(s, |cx| {
@@ -153,7 +153,6 @@ pub(super) fn insert_shape(s: &mut Session, p: &Json) -> Result<Json> {
        line,
        text: str_param(p, "text").unwrap_or("").into(),
        format: Default::default(),
-        math: Default::default(),
    };
    let sheet = d.wb.active_sheet();
    edit(s, |cx| {
@@ -60,7 +60,7 @@ pub(super) fn insert_table(s: &mut Session, p: &Json) -> Result<Json> {
            let e = Edit::InsertCells { axis: Axis::Rows, range: RangeRef::new(r.start, CellRef::new(r.start.row, r.end.col)) };
            shift_cell_features(sh, &e);
            let name = sh.name.clone();
-            rewrite(cx, &name, &e)?;
+            rewrite(cx, &name, &e);
            let sh = cx.sheet_mut(sheet)?;
            for (i, c) in (r.start.col..=r.end.col).enumerate() {
                sh.set_value(CellRef::new(r.start.row, c), gridcraft_core::Value::text(format!("Column{}", i + 1)));
@@ -9,7 +9,7 @@ pub fn specs() -> Vec<CommandSpec> {
    vec![
        cmd!(query "document.inspect", "Inspect Workbook", [], None, "{} → sheets, selection, names, tables, charts, dirty, trust (local|fromFile), history", has_doc, inspect),
        cmd!(query "sheet.read", "Read Range", [], None, "{range?: \"A1:D10\" (default: used range), sheet?, formulas?: bool, formatted?: bool} → rows of values", has_doc, read),
-        cmd!(query "cell.get", "Get Cell", [], None, "{cell?, sheet?} → value, formula, display text, style, comment, link, python {code, output, typeName, preview, stale}", has_doc, cell_get),
+        cmd!(query "cell.get", "Get Cell", [], None, "{cell?, sheet?} → value, formula, display text, style, comment, link", has_doc, cell_get),
        cmd!(query "selection.stats", "Selection Statistics", [], None, "{} → count, sum, average, min, max", has_doc, sel_stats),
        cmd!(query "history.list", "Undo History", [], None, "{} → undo/redo labels, grouping (an undo group is open)", has_doc, history),
        cmd!(query "app.commands", "List Commands", [], None, "{search?} → ids, labels, params", always, list_commands),
@@ -46,7 +46,7 @@ fn inspect(s: &mut Session, _: &Json) -> Result<Json> {
                "freeze": sh.freeze,
                "merges": sh.merges.iter().map(|m| m.a1()).collect::<Vec<_>>(),
                "tables": sh.tables.iter().map(|t| json!({"name": t.name, "range": t.range.a1(), "style": t.style, "totals": t.totals_row, "columns": t.columns.iter().map(|c| c.name.clone()).collect::<Vec<_>>()})).collect::<Vec<_>>(),
-                "charts": sh.charts.iter().map(|c| json!({"id": c.id, "kind": format!("{:?}", c.kind), "title": c.title, "at": c.anchor.cell.a1(), "series": c.series.len(), "dataTable": c.data_table.as_ref().map(|t| json!({"showKeys": t.show_keys, "horizontalBorder": t.horizontal_border, "verticalBorder": t.vertical_border, "outline": t.outline})), "trendlines": c.series.iter().flat_map(|s| s.trendlines.iter().map(|t| format!("{:?}", t.kind))).collect::<Vec<_>>()})).collect::<Vec<_>>(),
+                "charts": sh.charts.iter().map(|c| json!({"id": c.id, "kind": format!("{:?}", c.kind), "title": c.title, "at": c.anchor.cell.a1(), "series": c.series.len(), "trendlines": c.series.iter().flat_map(|s| s.trendlines.iter().map(|t| format!("{:?}", t.kind))).collect::<Vec<_>>()})).collect::<Vec<_>>(),
                "images": sh.images.len(),
                "shapes": sh.shapes.len(),
                "conditionalFormats": sh.cond_formats.len(),
@@ -137,13 +137,6 @@ fn cell_get(s: &mut Session, p: &Json) -> Result<Json> {
        "merge": sh.merge_at(c).map(|m| m.a1()),
        "comment": sh.comments.get(&c),
        "hyperlink": sh.hyperlinks.get(&c),
-        "python": cell.and_then(|x| x.py.as_deref()).map(|py| json!({
-            "code": py.code,
-            "output": if py.object { "object" } else { "value" },
-            "typeName": py.output.as_ref().map(|o| o.type_name.as_str()),
-            "preview": py.output.as_ref().map(|o| o.preview.as_str()),
-            "stale": py.stale,
-        })),
    }))
 }

@@ -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}))
@@ -65,10 +65,7 @@ pub(super) fn insert_pivot_chart(s: &mut Session, p: &Json) -> Result<Json> {
        series,
        legend: if matches!(kind, ChartKind::Pie | ChartKind::Doughnut) { LegendPos::Right } else { LegendPos::Bottom },
        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,
@@ -67,6 +67,9 @@ fn field_list(v: Option<&Json>) -> Vec<Json> {
 }

 pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
+    if s.doc()?.wb.protected_structure && matches!(str_param(p, "destination"), None | Some("new")) {
+        return Err(other("The workbook is protected and cannot be changed."));
+    }
    let source = source_param(s, p)?;
    let active = s.doc()?.wb.active_sheet();
    // Validate the source now (header names, size).
@@ -95,10 +98,6 @@ pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
        let at = RangeRef::parse(body).map(|r| r.start).ok_or_else(|| bad("insert.pivotTable", format!("not a cell: `{dest}`")))?;
        Some((si, at))
    };
-    // Decided on the resolved destination: `New`, ` new ` and an empty one all make a sheet.
-    if target.is_none() && s.doc()?.wb.protected_structure {
-        return Err(other("The workbook is protected and cannot be changed."));
-    }
    let replace = bool_param(p, "replace").unwrap_or(false);
    let rows = field_list(p.get("rows"));
    let columns = field_list(p.get("columns"));
@@ -256,10 +255,7 @@ pub(super) fn show_details(s: &mut Session, p: &Json) -> Result<Json> {
            }
        }
        for (c, h) in src.headers.iter().enumerate() {
-            sh.set_cell(
-                CellRef::new(0, c as u32),
-                Cell { value: gridcraft_core::Value::text(h.as_str()), formula: None, style: StyleId::default(), py: None },
-            );
+            sh.set_cell(CellRef::new(0, c as u32), Cell { value: gridcraft_core::Value::text(h.as_str()), formula: None, style: StyleId::default() });
        }
        for (r, i) in records.iter().enumerate() {
            let Some(rec) = src.rows.get(*i) else { continue };
@@ -268,7 +264,7 @@ pub(super) fn show_details(s: &mut Session, p: &Json) -> Result<Json> {
                if v.is_empty() && style == StyleId::default() {
                    continue;
                }
-                sh.set_cell(CellRef::new(r as u32 + 1, c as u32), Cell { value: v.clone(), formula: None, style, py: None });
+                sh.set_cell(CellRef::new(r as u32 + 1, c as u32), Cell { value: v.clone(), formula: None, style });
            }
        }
        let name = sh.name.clone();
@@ -507,13 +507,9 @@ pub(super) fn value_settings(s: &mut Session, p: &Json) -> Result<Json> {
        let mut v = cur.clone();
        if let Some(f) = func {
            v.func = f;
-            // An automatic caption follows the function. Count Numbers was captioned "Count
-            // Numbers of …" before it took Excel's "Count of …", and saved workbooks still carry it.
-            let is_auto = |base: &str| {
-                cur.name.eq_ignore_ascii_case(base) || cur.name.strip_prefix(base).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit()))
-            };
-            let legacy = cur.func == PivotFunc::CountNumbers && is_auto(&format!("Count Numbers of {}", cur.source_col));
-            if is_auto(&auto_name(cur.func, &cur.source_col)) || legacy {
+            // An automatic caption follows the function.
+            let auto = auto_name(cur.func, &cur.source_col);
+            if cur.name.eq_ignore_ascii_case(&auto) || cur.name.strip_prefix(auto.as_str()).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit())) {
                v.name = unique_value_name(pt, &auto_name(f, &cur.source_col), Some(i));
            }
        }
@@ -168,19 +168,6 @@ fn filters_and_report_filter_rows() {
    assert!(s.execute("pivot.filter", json!({"field": "Product", "selected": []})).is_err());
 }

-/// A selection of the most labels allowed (100,000) is looked up once per record, not scanned: the
-/// report still filters case-insensitively.
-#[test]
-fn a_huge_filter_selection_is_matched_through_a_set() {
-    let mut s = sales();
-    s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap();
-    let mut selected: Vec<String> = (0..99_999).map(|i| format!("Region {i}")).collect();
-    selected.push("EAST".into());
-    s.execute("pivot.filter", json!({"field": "Region", "selected": selected})).unwrap();
-    let gt = find_row(&s, "Grand Total").unwrap();
-    assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(415.0));
-}
-
 #[test]
 fn show_values_as() {
    let mut s = sales();
@@ -1026,36 +1013,3 @@ fn detail_cells_are_the_cells_show_details_takes() {
    let pt = &d.wb.active().unwrap().pivots[0];
    assert!(crate::pivot::detail_cells(&d.wb, pt, d.wb.active_sheet()).unwrap_err().contains("out of date"));
 }
-
-#[test]
-fn rank_ties_are_dense_and_count_numbers_is_captioned_count_of() {
-    // #1448 items 10 and 12: Excel ranks 5, 4, 3, 3, 4 as 1, 2, 3, 3, 2 (GridCraft gave 1, 2, 4,
-    // 4, 2), and captions a Count Numbers field "Count of Val".
-    let mut s = Session::new();
-    s.new_workbook();
-    let rows = json!([["Key", "Val"], ["A", 5], ["B", 4], ["C", 3], ["D", 3], ["E", 4]]);
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    s.execute("insert.pivotTable", json!({"source": "Sheet1!$A$1:$B$6", "destination": "Sheet1!D3", "rows": ["Key"], "values": ["Val"]})).unwrap();
-    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "rank"})).unwrap();
-    let ranks: Vec<Value> = ["E4", "E5", "E6", "E7", "E8"].iter().map(|a| val(&s, a)).collect();
-    assert_eq!(ranks, [1.0, 2.0, 3.0, 3.0, 2.0].map(Value::Number));
-    s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "normal", "func": "countNumbers"})).unwrap();
-    assert_eq!(text(&s, "E3"), "Count of Val");
-}
-
-#[test]
-fn legacy_count_numbers_caption_follows_the_function() {
-    // Workbooks saved before Count Numbers was captioned "Count of" carry "Count Numbers of Val";
-    // that is still an automatic caption, so it follows a new function. A custom name stays.
-    let mut s = Session::new();
-    s.new_workbook();
-    let rows = json!([["Key", "Val"], ["A", 5], ["B", 4]]);
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    s.execute("insert.pivotTable", json!({"source": "Sheet1!$A$1:$B$3", "destination": "Sheet1!D3", "rows": ["Key"], "values": ["Val"]})).unwrap();
-    for (legacy, after) in [("Count Numbers of Val", "Sum of Val"), ("Count Numbers of Val2", "Sum of Val"), ("Numbers counted", "Numbers counted")] {
-        s.execute("pivot.valueSettings", json!({"index": 0, "func": "countNumbers", "name": legacy})).unwrap();
-        assert_eq!(text(&s, "E3"), legacy);
-        s.execute("pivot.valueSettings", json!({"index": 0, "func": "sum"})).unwrap();
-        assert_eq!(text(&s, "E3"), after, "{legacy}");
-    }
-}
@@ -1,20 +1,20 @@
 //! Printing: Page Setup, pagination and PDF output (File › Print, File › Export › PDF).
 //!
-//! Sheets are paginated like Excel: the print area (or the used range plus drawing objects) is
-//! split into bands of rows and columns that fit the printable area at the page scale, honouring
-//! manual breaks, repeated title rows/columns, headings, Fit To and centring, and the pages follow
-//! the sheet's page order ("down, then over" by default, or "over, then down"). Each page is
-//! drawn into a PDF with `gridcraft-pdf`: fills, gridlines, borders, formatted text (fonts mapped
-//! to the standard 14 PDF fonts), merged cells, wrapping, overflow into empty neighbours,
-//! conditional formats, table styles, charts, images, shapes and sparklines. Headers and footers
-//! support `&L`/`&C`/`&R` sections and the `&P &N &D &T &A &F &Z` codes.
+//! Sheets are paginated like Excel's default "down, then over": the print area (or the used
+//! range plus drawing objects) is split into bands of rows and columns that fit the printable
+//! area at the page scale, honouring manual breaks, repeated title rows/columns, headings, Fit
+//! To and centring. Each page is drawn into a PDF with `gridcraft-pdf`: fills, gridlines,
+//! borders, formatted text (fonts mapped to the standard 14 PDF fonts), merged cells, wrapping,
+//! overflow into empty neighbours, conditional formats, table styles, charts, images, shapes and
+//! sparklines. Headers and footers support `&L`/`&C`/`&R` sections and the `&P &N &D &T &A &F &Z`
+//! codes.

 use gridcraft_core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value};
 #[cfg(test)]
 use gridcraft_model::{Alignment, Image, SheetViewMode};
 use gridcraft_model::{
-    Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PageOrder, PatternType, PrintSettings, ShapeKind, Sheet, Style, StyleId,
-    StyleTable, Underline, VAlign, Visibility, Workbook,
+    Anchor, BorderLine, BorderStyle, Borders, Color, HAlign, Orientation, PatternType, PrintSettings, ShapeKind, Sheet, Style, StyleId, StyleTable,
+    Underline, VAlign, Visibility, Workbook,
 };
 use gridcraft_pdf::{Font, Page, PdfDoc, Point, Rect, Rgb};
 use serde_json::{Value as Json, json};
@@ -69,7 +69,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Print Preview",
            ["File"],
            None,
-            "{page? (1-based), sheets?: active|all, range?, fitToPage?} → {pages, pageList: [{page, sheet, range, rows, columns, scale, paper, orientation, pageOrder, width, height}]} in print order",
+            "{page? (1-based), sheets?: active|all, range?, fitToPage?} → {pages, pageList: [{page, sheet, range, rows, columns, scale, paper, orientation, width, height}]}",
            has_doc,
            print_preview
        ),
@@ -78,7 +78,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Page Setup…",
            ["Page Layout", "Page Setup"],
            None,
-            "{sheet?, orientation?: portrait|landscape, paper?: Letter|Legal|A4|A3|A5|A6|Tabloid|Executive|Ledger|B4|B5|B6|B4 (ISO)|B5 (ISO)|B6 (ISO)|Japanese Postcard|Japanese Double Postcard|Japanese Envelope #3|Japanese Envelope #4|Japanese Envelope Kaku #2|Japanese Envelope Kaku #3 (B4/B5/B6 are the JIS sizes), margins?: {left,right,top,bottom,header,footer} (inches; also accepted as top-level keys), scale?: 10..400, fitWidth?, fitHeight? (pages; 0 = automatic), fitToPage?: bool, centerH?, centerV?, gridlines?, headings?, header?: \"&L&A&RPage &P of &N\", footer?, printArea?: \"A1:F50\" (\"\" clears), titleRows?: \"1:2\", titleCols?: \"A:A\", rowBreaks?: [46, 91], colBreaks?: [\"K\"], pageOrder?: downThenOver|overThenDown} → the sheet's print settings",
+            "{sheet?, orientation?: portrait|landscape, paper?: Letter|Legal|A4|A3|A5|A6|Tabloid|Executive|Ledger|B4|B5|B6|B4 (ISO)|B5 (ISO)|B6 (ISO)|Japanese Postcard|Japanese Double Postcard|Japanese Envelope #3|Japanese Envelope #4|Japanese Envelope Kaku #2|Japanese Envelope Kaku #3 (B4/B5/B6 are the JIS sizes), margins?: {left,right,top,bottom,header,footer} (inches; also accepted as top-level keys), scale?: 10..400, fitWidth?, fitHeight? (pages; 0 = automatic), fitToPage?: bool, centerH?, centerV?, gridlines?, headings?, header?: \"&L&A&RPage &P of &N\", footer?, printArea?: \"A1:F50\" (\"\" clears), titleRows?: \"1:2\", titleCols?: \"A:A\", rowBreaks?: [46, 91], colBreaks?: [\"K\"]} → the sheet's print settings",
            has_doc,
            page_setup
        ),
@@ -222,7 +222,6 @@ fn print_preview(s: &mut Session, p: &Json) -> Result<Json> {
                "scale": (lay.scale * 1000.0).round() / 10.0,
                "paper": lay.settings.paper,
                "orientation": if lay.settings.orientation == Orientation::Landscape { "landscape" } else { "portrait" },
-                "pageOrder": lay.settings.page_order.id(),
                "width": lay.page_w,
                "height": lay.page_h,
            }));
@@ -245,16 +244,6 @@ fn page_setup(s: &mut Session, p: &Json) -> Result<Json> {
        Some("landscape") => Some(Orientation::Landscape),
        Some(o) => return Err(bad(CMD, format!("orientation must be portrait or landscape, not `{o}`"))),
    };
-    let page_order = match p.get("pageOrder") {
-        None => None,
-        Some(v) => match v.as_str().and_then(PageOrder::parse) {
-            Some(o) => Some(o),
-            None => {
-                let shown = v.as_str().map_or_else(|| v.to_string(), str::to_string);
-                return Err(bad(CMD, format!("pageOrder must be downThenOver or overThenDown, not `{shown}`")));
-            }
-        },
-    };
    let paper = match str_param(p, "paper") {
        None => None,
        Some(name) => {
@@ -396,9 +385,6 @@ fn page_setup(s: &mut Session, p: &Json) -> Result<Json> {
        if let Some(b) = &col_breaks {
            pr.col_breaks = b.clone();
        }
-        if let Some(o) = page_order {
-            pr.page_order = o;
-        }
        Ok(())
    })?;
    let pr = s.doc()?.wb.sheet(si).map(|sh| sh.print.clone()).unwrap_or_default();
@@ -2,8 +2,8 @@ use super::layout::{DENSE_BLOCK, SheetLayout};
 use super::objects::draw_cell_picture;
 use super::text::{TextPlacement, draw_text};
 use super::{
-    BorderLine, BorderStyle, Borders, CellRef, Color, Font, Page, PatternType, Point, RangeRef, Rgb, Sheet, Style, StyleId, Underline, Value,
-    Workbook, split_sheet,
+    BorderLine, BorderStyle, Borders, CellRef, Color, Font, Page, PatternType, Point, RangeRef, Rgb, Sheet, Style, StyleId, Underline, Workbook,
+    split_sheet,
 };

 // ---------------------------------------------------------------- drawing
@@ -280,7 +280,6 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
                || merges.iter().any(|m| m.start == *c)
                || !sh.value(*c).is_empty()
                || l.style.borders != Borders::default()
-                || l.style.num_fmt.as_str() == "checkbox"
        })
        .collect();
    let rect_of = |c: CellRef| -> (f32, f32, f32, f32, bool) {
@@ -344,8 +343,6 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
        }
        if let Some(picture) = sh.cell_pictures.get(c) {
            draw_cell_picture(pg, &picture.data, (x, y, w, h), b.k);
-        } else if let Some(on) = checkbox_state(l, &sh.value(*c)) {
-            draw_checkbox(pg, (x, y, w, h), b.k, on);
        } else {
            draw_text(pg, b, TextPlacement { cell: *c, look: l, rect: (x, y, w, h), merged, merges: &merges, limits: (bx, bx + bw) });
        }
@@ -353,37 +350,6 @@ pub(super) fn draw_block(pg: &mut Page, b: &Block, gridlines: bool, cf: &mut Opt
    pg.restore();
 }

-/// A checkbox cell prints TRUE/FALSE (and empty) as a box, as on screen (#2972); other values
-/// print as text.
-fn checkbox_state(l: &Look, v: &Value) -> Option<bool> {
-    if l.style.num_fmt.as_str() != "checkbox" || l.cf.as_ref().is_some_and(|cf| cf.hide_value) {
-        return None;
-    }
-    match v {
-        Value::Bool(on) => Some(*on),
-        Value::Empty => Some(false),
-        _ => None,
-    }
-}
-
-/// A checkbox centred in the cell: white with a grey outline, or green with a white tick.
-fn draw_checkbox(pg: &mut Page, (x, y, w, h): (f32, f32, f32, f32), k: f32, on: bool) {
-    let s = (13.2 * k).min(w - 2.0 * k).min(h - 2.0 * k);
-    if s <= 0.0 {
-        return;
-    }
-    let (bx, by) = (x + (w - s) / 2.0, y + (h - s) / 2.0);
-    let corners = [[bx, by], [bx + s, by], [bx + s, by + s], [bx, by + s]];
-    if on {
-        let green = [0x10, 0x7C, 0x41];
-        pg.polygon(&corners, Some(green), Some((green, 0.75 * k)));
-        let tick = [[bx + 0.22 * s, by + 0.52 * s], [bx + 0.42 * s, by + 0.72 * s], [bx + 0.78 * s, by + 0.30 * s]];
-        pg.polyline(&tick, 0.14 * s, [0xFF, 0xFF, 0xFF], &[]);
-    } else {
-        pg.polygon(&corners, Some([0xFF, 0xFF, 0xFF]), Some(([110, 110, 110], 0.75 * k)));
-    }
-}
-
 pub(super) struct PendingPdfLink {
    pub(super) page: usize,
    pub(super) sheet: usize,
@@ -153,17 +153,6 @@ pub struct HfSection {
    pub size: Option<f32>,
 }

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

 /// Cells in a page block above which only stored cells are visited (not every grid position).
@@ -253,7 +253,15 @@ pub fn layout_sheet(wb: &Workbook, si: usize, opts: &PrintOptions, range_overrid
    let paginate = |lay: &mut SheetLayout, manual: bool| {
        lay.manual_breaks = manual;
        (lay.row_bands, lay.col_bands) = split_bands(sh, lay, MAX_PAGES);
-        lay.pages = page_sequence(lay.row_bands.len(), lay.col_bands.len(), lay.settings.page_order, MAX_PAGES);
+        lay.pages.clear();
+        'outer: for ci in 0..lay.col_bands.len() {
+            for ri in 0..lay.row_bands.len() {
+                if lay.pages.len() >= MAX_PAGES {
+                    break 'outer;
+                }
+                lay.pages.push((ri, ci));
+            }
+        }
    };
    match fit {
        Some((fw, fh)) => {
@@ -282,25 +290,6 @@ pub fn layout_sheet(wb: &Workbook, si: usize, opts: &PrintOptions, range_overrid
    Some(lay)
 }

-/// The pages of a sheet `rows` pages tall and `cols` pages wide as (row band, column band), in
-/// print order, at most `cap` of them: down each column of pages, then over to the next (Excel's
-/// default), or over each row of pages, then down to the next.
-pub(crate) fn page_sequence(rows: usize, cols: usize, order: PageOrder, cap: usize) -> Vec<(usize, usize)> {
-    let (outer, inner) = match order {
-        PageOrder::DownThenOver => (cols, rows),
-        PageOrder::OverThenDown => (rows, cols),
-    };
-    (0..outer)
-        .flat_map(|o| {
-            (0..inner).map(move |i| match order {
-                PageOrder::DownThenOver => (i, o),
-                PageOrder::OverThenDown => (o, i),
-            })
-        })
-        .take(cap)
-        .collect()
-}
-
 /// Inclusive-start/end index spans of the pages along one axis.
 pub(crate) type Bands = Vec<(u32, u32)>;

@@ -29,26 +29,6 @@ pub(super) fn draw_cell_picture(pg: &mut Page, data: &[u8], rect: (f32, f32, f32
 }

 /// Sheet pixel rectangle of an anchor.
-/// Most source lines printed for an equation that has no layout.
-pub(super) const MAX_FALLBACK_LINES: usize = 500;
-
-/// The lines of `text` printed in place of an equation that has no layout: those of its first
-/// `MAX_SOURCE_BYTES` (a longer source never lays out, and a file can carry megabytes) that fit a
-/// frame `h` points tall at `line_h` points per line (at least the first), and never more than
-/// [`MAX_FALLBACK_LINES`]. A single `pg.text` call would print every newline as `?`.
-pub(super) fn fallback_lines(text: &str, h: f32, line_h: f32) -> impl Iterator<Item = &str> {
-    let text = crate::cmd::equation::source_excerpt(text);
-    let fit = h / line_h;
-    let n = if fit >= MAX_FALLBACK_LINES as f32 {
-        MAX_FALLBACK_LINES
-    } else if fit >= 1.0 {
-        fit as usize
-    } else {
-        1
-    };
-    text.lines().take(n)
-}
-
 fn anchor_rect(sh: &Sheet, a: &Anchor) -> (f64, f64, f64, f64) {
    (sh.col_left(a.cell.col) + a.dx as f64, sh.row_top(a.cell.row) + a.dy as f64, a.width.max(0.0) as f64, a.height.max(0.0) as f64)
 }
@@ -99,25 +79,6 @@ pub(super) fn draw_objects(pg: &mut Page, wb: &Workbook, si: usize, sh: &Sheet,
            continue;
        }
        let (x, y, w, h) = place(r);
-        if shp.kind == ShapeKind::Equation {
-            let ink = rgb_of(shp.line, wb).unwrap_or([0, 0, 0]);
-            match shp.math.get(&shp.text) {
-                Some(Ok(list)) => crate::cmd::equation::draw_pdf(pg, list, (x, y, w, h), crate::cmd::equation::PADDING * b.k, ink),
-                _ => {
-                    // No layout (the source does not parse, or the file was past the layout
-                    // budget): the source, one text run per line, as many as the frame holds.
-                    let line_h = 12.0 * b.scale;
-                    // A long line stays inside the frame; this clip nests in the block's.
-                    pg.save();
-                    pg.clip_rect(x, y, w, h);
-                    for (i, line) in fallback_lines(&shp.text, h, line_h).enumerate() {
-                        pg.text(x + 2.0 * b.k, y + line_h * (i + 1) as f32, 10.0 * b.scale, Font::Courier, ink, line);
-                    }
-                    pg.restore();
-                }
-            }
-            continue;
-        }
        draw_shape(pg, wb, shp, b, (x, y, w, h));
    }
    for ch in &sh.charts {
@@ -16,25 +16,6 @@ fn contains(hay: &[u8], needle: &str) -> bool {
    hay.windows(needle.len()).any(|w| w == needle.as_bytes())
 }

-#[test]
-fn chart_data_table_prints_formatted_values_and_follows_recalculation() {
-    let mut s = s();
-    s.execute("range.setValues", json!({"range": "A1", "values": [["Quarter", "Sales"], ["Q1", 1234], ["Q2", 5678]]})).unwrap();
-    s.execute("home.numberFormat", json!({"range": "B2:B3", "format": "#,##0.00"})).unwrap();
-    s.execute("insert.chart", json!({"range": "A1:B3", "at": "D2", "type": "column"})).unwrap();
-    let (off, pages) = pdf_of(&mut s, json!({"fitToPage": true}));
-    assert_eq!(pages, 1);
-    let count = |bytes: &[u8], text: &str| String::from_utf8_lossy(bytes).matches(text).count();
-    s.execute("chart.set", json!({"dataTable": true})).unwrap();
-    let (on, _) = pdf_of(&mut s, json!({"fitToPage": true}));
-    assert_eq!(count(&on, "(1,234.00) Tj"), count(&off, "(1,234.00) Tj") + 1);
-    assert_eq!(count(&on, "(5,678.00) Tj"), count(&off, "(5,678.00) Tj") + 1);
-    s.execute("cell.set", json!({"cell": "B2", "input": "=1000+111"})).unwrap();
-    let (updated, _) = pdf_of(&mut s, json!({"fitToPage": true}));
-    assert!(!contains(&updated, "(1,234.00) Tj"));
-    assert!(count(&updated, "(1,111.00) Tj") >= 2, "cell and chart data table both print the new value");
-}
-
 #[test]
 fn pdf_export_keeps_safe_links_on_their_printed_pages() {
    let mut s = s();
@@ -167,142 +148,6 @@ fn wide_sheet_goes_down_then_over() {
    assert_eq!(pv["pageList"][2]["range"], "K1:O45");
 }

-/// The ranges of the printed pages, in print order.
-fn page_ranges(s: &mut Session) -> Vec<String> {
-    let pv = s.execute("file.printPreview", json!({})).unwrap();
-    let list = pv["pageList"].as_array().unwrap();
-    assert_eq!(pv["pages"], list.len());
-    for (i, page) in list.iter().enumerate() {
-        assert_eq!(page["page"], i + 1);
-        assert_eq!(page["pageOrder"], s.doc().unwrap().wb.active().unwrap().print.page_order.id());
-    }
-    list.iter().map(|p| p["range"].as_str().unwrap().to_string()).collect()
-}
-
-/// The content streams of an exported PDF's pages, in page order (pages without pictures are the
-/// file's only streams).
-fn pdf_pages(s: &mut Session) -> Vec<String> {
-    let (pdf, pages) = pdf_of(s, json!({}));
-    let text = String::from_utf8_lossy(&pdf);
-    let streams: Vec<String> = text.split("endstream").filter(|part| part.contains("stream\n")).map(str::to_string).collect();
-    assert_eq!(streams.len() as u64, pages);
-    streams
-}
-
-/// The page order measured in Excel: print area A1:D4 with a row break before row 3 and a column
-/// break before column C, so four pages two tall and two wide, each filled and labelled in its
-/// own colour, with `Page &P of &N` in the footer.
-fn two_by_two_pages() -> Session {
-    let mut s = s();
-    for (range, color, label) in
-        [("A1:B2", "#FF0000", "red"), ("A3:B4", "#00FF00", "green"), ("C1:D2", "#0000FF", "blue"), ("C3:D4", "#FFFF00", "yellow")]
-    {
-        s.execute("home.fillColor", json!({"range": range, "color": color})).unwrap();
-        s.execute("cell.set", json!({"cell": &range[..2], "input": label})).unwrap();
-    }
-    s.execute("pageLayout.pageSetup", json!({"printArea": "A1:D4", "rowBreaks": [3], "colBreaks": ["C"], "footer": "Page &P of &N"})).unwrap();
-    s
-}
-
-/// The colour of each printed page, read from its fill and label; each page's footer must
-/// number it in print order.
-fn printed_colours(s: &mut Session) -> Vec<&'static str> {
-    let pages = pdf_pages(s);
-    let n = pages.len();
-    pages
-        .iter()
-        .enumerate()
-        .map(|(i, page)| {
-            assert!(page.contains(&format!("(Page {} of {n}) Tj", i + 1)), "page {}: {page}", i + 1);
-            let found: Vec<&str> = [("red", "1 0 0 rg"), ("green", "0 1 0 rg"), ("blue", "0 0 1 rg"), ("yellow", "1 1 0 rg")]
-                .into_iter()
-                .filter(|(label, fill)| page.contains(&format!("({label}) Tj")) && page.contains(&format!("\n{fill}\n")))
-                .map(|(label, _)| label)
-                .collect();
-            assert_eq!(found.len(), 1, "page {}: {found:?}", i + 1);
-            found[0]
-        })
-        .collect()
-}
-
-#[test]
-fn page_order_sets_the_sequence_of_the_pages_as_measured_in_excel() {
-    let mut s = two_by_two_pages();
-    // Down, then over is the default: down the first column of pages, then the next.
-    assert_eq!(s.doc().unwrap().wb.active().unwrap().print.page_order, PageOrder::DownThenOver);
-    assert_eq!(s.execute("pageLayout.pageSetup", json!({})).unwrap()["page_order"], "downThenOver");
-    let down = ["A1:B2", "A3:B4", "C1:D2", "C3:D4"];
-    assert_eq!(page_ranges(&mut s), down);
-    assert_eq!(printed_colours(&mut s), ["red", "green", "blue", "yellow"]);
-    // Over, then down: across the first row of pages, then the next.
-    let r = s.execute("pageLayout.pageSetup", json!({"pageOrder": "overThenDown"})).unwrap();
-    assert_eq!(r["page_order"], "overThenDown");
-    let over = ["A1:B2", "C1:D2", "A3:B4", "C3:D4"];
-    assert_eq!(page_ranges(&mut s), over);
-    assert_eq!(printed_colours(&mut s), ["red", "blue", "green", "yellow"]);
-    assert_eq!(s.execute("file.printPreview", json!({"page": 2})).unwrap()["page"]["range"], "C1:D2");
-    // One undo step.
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(page_ranges(&mut s), down);
-    s.execute("edit.redo", json!({})).unwrap();
-    assert_eq!(page_ranges(&mut s), over);
-    // Anything but the two orders is refused and changes nothing, even next to a good value.
-    for bad in [json!("sideways"), json!("OverThenDown"), json!(""), json!(2), json!(null), json!(true), json!(["downThenOver"])] {
-        let e = s.execute("pageLayout.pageSetup", json!({"pageOrder": bad, "orientation": "landscape"})).unwrap_err();
-        assert!(e.to_string().contains("pageOrder"), "{bad}: {e}");
-    }
-    let pr = &s.doc().unwrap().wb.active().unwrap().print;
-    assert_eq!((pr.page_order, pr.orientation), (PageOrder::OverThenDown, Orientation::Portrait));
-    assert!(s.take_ui_requests().is_empty(), "a programmatic call never opens a dialog");
-    // First-page and odd/even headers go by the printed sequence too.
-    s.execute(
-        "pageLayout.headerFooter",
-        json!({"header": "&COdd &P", "evenHeader": "&CEven &P", "firstHeader": "&CCover", "differentFirst": true, "differentOddEven": true}),
-    )
-    .unwrap();
-    let pages = pdf_pages(&mut s);
-    for (page, (header, label)) in pages.iter().zip([("Cover", "red"), ("Even 2", "blue"), ("Odd 3", "green"), ("Even 4", "yellow")]) {
-        assert!(page.contains(&format!("({header}) Tj")) && page.contains(&format!("({label}) Tj")), "{header}: {page}");
-    }
-    s.execute("pageLayout.pageSetup", json!({"pageOrder": "downThenOver"})).unwrap();
-    assert_eq!(page_ranges(&mut s), down);
-    let pages = pdf_pages(&mut s);
-    for (page, (header, label)) in pages.iter().zip([("Cover", "red"), ("Even 2", "green"), ("Odd 3", "blue"), ("Even 4", "yellow")]) {
-        assert!(page.contains(&format!("({header}) Tj")) && page.contains(&format!("({label}) Tj")), "{header}: {page}");
-    }
-}
-
-#[test]
-fn page_order_without_breaks_and_with_print_titles() {
-    let mut s = s();
-    // Every cell shows its own address: 60 rows and 15 columns are two pages tall and two wide.
-    let rows: Vec<Vec<Json>> = (1..=60).map(|r| (0..15).map(|c| json!(format!("{}{r}", gridcraft_core::col_to_letters(c)))).collect()).collect();
-    s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap();
-    for titles in [false, true] {
-        if titles {
-            s.execute("pageLayout.pageSetup", json!({"titleRows": "1:1", "titleCols": "A:A"})).unwrap();
-        }
-        s.execute("pageLayout.pageSetup", json!({"pageOrder": "downThenOver"})).unwrap();
-        let down = page_ranges(&mut s);
-        if !titles {
-            assert_eq!(down, ["A1:J45", "A46:J60", "K1:O45", "K46:O60"]);
-        }
-        s.execute("pageLayout.pageSetup", json!({"pageOrder": "overThenDown"})).unwrap();
-        let over = page_ranges(&mut s);
-        assert_eq!(over, [down[0].clone(), down[2].clone(), down[1].clone(), down[3].clone()], "titles: {titles}");
-        // Each printed page starts with its own top-left cell; the title row and column (A1 is in
-        // both) repeat on every page in either order.
-        for (order, ranges) in [("overThenDown", &over), ("downThenOver", &down)] {
-            s.execute("pageLayout.pageSetup", json!({"pageOrder": order})).unwrap();
-            for (i, (page, range)) in pdf_pages(&mut s).iter().zip(ranges.iter()).enumerate() {
-                let top_left = range.split(':').next().unwrap();
-                assert!(page.contains(&format!("({top_left}) Tj")), "{order} page {}: no {top_left}", i + 1);
-                assert_eq!(page.contains("(A1) Tj"), titles || i == 0, "{order} page {}, titles: {titles}", i + 1);
-            }
-        }
-    }
-}
-
 #[test]
 fn first_and_even_pages_print_their_own_headers() {
    let mut s = s();
@@ -329,14 +174,6 @@ fn first_and_even_pages_print_their_own_headers() {
    assert!(contains(&pdf, "(Odd 1) Tj") && contains(&pdf, "(Odd 2) Tj") && !contains(&pdf, "(Cover) Tj"));
 }

-/// The y position of the first `(text) Tj` in a PDF (PDF space: larger is higher on the page).
-fn text_y(pdf: &[u8], text: &str) -> Option<f32> {
-    let s = String::from_utf8_lossy(pdf);
-    let before = &s[..s.find(&format!("({text}) Tj"))?];
-    let tm = before.rfind(" Tm")?;
-    before[..tm].rsplit([' ', '\n']).next()?.parse().ok()
-}
-
 /// The x position and font size of the first `(text) Tj` in a PDF.
 fn text_at(pdf: &[u8], text: &str) -> Option<(f32, f32)> {
    let s = String::from_utf8_lossy(pdf);
@@ -414,12 +251,6 @@ fn pdf_contains_text_and_header_codes_expand() {
    assert_eq!(r.text, "P4/9 9:00 AM");
    assert_eq!(expand_header_footer("plain", &cx)[1].text, "plain");
    assert_eq!(expand_header_footer("&", &cx)[1].text, "");
-    // A megabyte sheet name repeated by 5,000 `&A` codes stops at the section's 64 KiB.
-    let long = HfContext { sheet: "S".repeat(1024 * 1024), ..cx };
-    let [_, c, _] = expand_header_footer(&"&A".repeat(5_000), &long);
-    assert!(c.text.is_empty(), "the name alone is over the limit");
-    let short = HfContext { sheet: "S".repeat(1000), ..Default::default() };
-    assert_eq!(expand_header_footer(&"&A".repeat(5_000), &short)[1].text.len(), 65_000);
 }

 #[test]
@@ -642,11 +473,6 @@ fn hostile_settings_never_panic_and_cap_pages() {
    assert_eq!(pv["pages"].as_u64().unwrap(), MAX_PAGES as u64);
    let r = s.execute("file.exportPdf", json!({})).unwrap();
    assert_eq!(r["pages"], MAX_PAGES);
-    // Over, then down stops at the cap as well, along the first row of pages.
-    s.execute("pageLayout.pageSetup", json!({"pageOrder": "overThenDown"})).unwrap();
-    let pv = s.execute("file.printPreview", json!({})).unwrap();
-    assert_eq!(pv["pages"].as_u64().unwrap(), MAX_PAGES as u64);
-    assert_eq!(pv["pageList"][1]["rows"], pv["pageList"][0]["rows"], "the second page is beside the first");
    s.execute("pageLayout.pageSetup", json!({"fitWidth": 1, "fitHeight": 1, "titleRows": "1:1048576", "titleCols": "A:XFD", "headings": true}))
        .unwrap();
    let pv = s.execute("file.printPreview", json!({})).unwrap();
@@ -701,79 +527,6 @@ fn bands_unit() {
    assert!(w.len() > 2);
 }

-/// The wrapper `wrap_lines` replaced, re-measuring strings, as the reference for its lines.
-fn wrap_lines_remeasuring(text: &str, font: Font, size: f32, width: f32) -> Vec<String> {
-    let mut out = Vec::new();
-    for para in text.split('\n') {
-        let mut line = String::new();
-        for word in para.split(' ') {
-            let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") };
-            if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width {
-                line = cand;
-            } else {
-                out.push(std::mem::take(&mut line));
-                line = word.to_string();
-            }
-            while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 {
-                let chars: Vec<char> = line.chars().collect();
-                let (mut lo, mut hi) = (1usize, chars.len());
-                while lo < hi {
-                    let mid = lo + (hi - lo).div_ceil(2);
-                    let cut: String = chars[..mid].iter().collect();
-                    if gridcraft_pdf::text_width(font, size, &cut) <= width {
-                        lo = mid;
-                    } else {
-                        hi = mid - 1;
-                    }
-                }
-                if lo == chars.len() {
-                    break;
-                }
-                out.push(chars[..lo].iter().collect());
-                line = chars[lo..].iter().collect();
-            }
-            if out.len() > 2000 {
-                return out;
-            }
-        }
-        out.push(line);
-    }
-    out
-}
-
-#[test]
-fn wrap_lines_matches_the_remeasuring_wrapper() {
-    let texts = [
-        "the quick brown fox jumps",
-        "Supercalifragilistic",
-        "a  b   c\n\nverylongwordthatneedsbreaking short\nend ",
-        "Wide WWWWWWWWWW words, iiiiiiii narrow ones; mixed MMMMiiiiMMMM",
-        "€ ü ß — unicode Ünïcödé text",
-        "",
-        " ",
-    ];
-    for text in texts {
-        for font in [Font::Helvetica, Font::HelveticaBold, Font::Courier] {
-            for (size, width) in [(10.0, 50.0), (10.0, 20.0), (11.0, 1.0), (8.0, 300.0), (12.0, 0.0)] {
-                assert_eq!(wrap_lines(text, font, size, width), wrap_lines_remeasuring(text, font, size, width), "{text:?} {font:?} {size} {width}");
-            }
-        }
-    }
-}
-
-#[test]
-fn wrapping_a_long_word_in_a_narrow_box_stops_at_the_line_limit() {
-    // One character per line: the old wrapper re-measured and copied the rest of the word for
-    // each of the 100,000 lines before checking the limit.
-    let word = "w".repeat(100_000);
-    let lines = wrap_lines(&word, Font::Helvetica, 10.0, 1.0);
-    assert!(lines.len() <= 2002, "{}", lines.len());
-    assert!(lines.iter().all(|l| l == "w"));
-    // A long paragraph in a very wide box is one line.
-    let para = vec!["word"; 50_000].join(" ");
-    assert_eq!(wrap_lines(&para, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]);
-}
-
 #[test]
 fn center_across_spans_following_empty_center_across_cells() {
    let mut styles = StyleTable::default();
@@ -812,129 +565,3 @@ fn rotated_wrapped_text_prints_rotated() {
    assert_eq!(up + down, blocks.len(), "a header line printed flat: {blocks:?}");
    assert!((1..=3).contains(&up) && (1..=3).contains(&down), "up {up}, down {down}: {blocks:?}");
 }
-
-#[test]
-fn checkbox_cells_print_as_boxes_not_true_false() {
-    // #2972: a checkbox cell printed its value as TRUE or FALSE.
-    let mut s = s();
-    s.execute("insert.checkbox", json!({"range": "A1:A2"})).unwrap();
-    s.execute("cell.toggleCheckbox", json!({"cell": "A2"})).unwrap();
-    s.execute("cell.set", json!({"cell": "C1", "input": "TRUE"})).unwrap();
-    let (pdf, _) = pdf_of(&mut s, json!({}));
-    assert!(!contains(&pdf, "(FALSE) Tj"), "the unchecked box printed as FALSE");
-    // Only the plain TRUE in C1 prints as text; the checked box is a filled box.
-    let text = String::from_utf8_lossy(&pdf);
-    assert_eq!(text.matches("(TRUE) Tj").count(), 1, "the checked box printed as TRUE");
-    assert!(contains(&pdf, "0.063 0.486 0.255 rg"), "the checked box is not filled");
-    assert!(contains(&pdf, "0.431 0.431 0.431 RG"), "the unchecked box is not outlined");
-}
-
-#[test]
-fn an_equation_without_a_layout_prints_its_source_one_line_per_line() {
-    use super::objects::{MAX_FALLBACK_LINES, fallback_lines};
-    let mut s = s();
-    s.execute("insert.equation", json!({"latex": "x", "cell": "B2"})).unwrap();
-    // A file can carry a source the layout engine refuses: two lines here, in a frame 100 px
-    // (75 pt) tall, which holds six 12 pt lines.
-    let with_source = |text: &str| {
-        let mut wb = (*s.doc().unwrap().wb).clone();
-        if let Some(sh) = wb.sheet_mut(0) {
-            for x in sh.shapes.iter_mut() {
-                x.text = text.into();
-                x.anchor.height = 100.0;
-            }
-        }
-        let mut t = Session::new();
-        t.add_document(crate::DocState::new(wb, None, "Book".into(), crate::Trust::FromFile));
-        pdf_of(&mut t, json!({})).0
-    };
-    let pdf = with_source("frac{\nsecond line");
-    assert!(contains(&pdf, "(frac{) Tj"), "the first line is its own text run");
-    assert!(contains(&pdf, "(second line) Tj"), "and so is the second");
-    assert!(!contains(&pdf, "(frac{?second line) Tj"), "the newline is not printed as ?");
-    let (y1, y2) = (text_y(&pdf, "frac{").unwrap(), text_y(&pdf, "second line").unwrap());
-    assert!(y1 > y2 && y1 - y2 < 13.0, "the second line sits one line below the first: {y1} {y2}");
-    // Lines the frame cannot hold are not printed.
-    let pdf = with_source(&"l\n".repeat(10_000));
-    assert_eq!(String::from_utf8_lossy(&pdf).matches("(l) Tj").count(), 6);
-    // Whatever the frame, the count is capped; a frame too low for one line still shows the first.
-    let tall = "l\n".repeat(10_000);
-    assert_eq!(fallback_lines(&tall, f32::INFINITY, 12.0).count(), MAX_FALLBACK_LINES);
-    assert_eq!(fallback_lines(&tall, 1.0e9, 12.0).count(), MAX_FALLBACK_LINES);
-    assert_eq!(fallback_lines("a\nb\nc", 30.0, 12.0).count(), 2);
-    assert_eq!(fallback_lines("a\nb", 0.0, 12.0).count(), 1);
-    assert_eq!(fallback_lines("a\nb", f32::NAN, 12.0).count(), 1);
-}
-
-#[test]
-fn the_fallback_text_is_clipped_to_the_equation_frame() {
-    // A long line of a source that does not lay out, in a narrow frame (40 by 100 px, 30 by
-    // 75 pt): the lines are drawn inside a clip of the frame, nested in the block's, so they
-    // cannot run over neighbours, and the clip is lifted again before the next object (a text
-    // box below the equation in the same block) is drawn.
-    let mut s = s();
-    s.execute("insert.equation", json!({"latex": "x", "cell": "B2"})).unwrap();
-    s.execute("insert.textBox", json!({"at": "B12", "text": "later box"})).unwrap();
-    let mut wb = (*s.doc().unwrap().wb).clone();
-    if let Some(sh) = wb.sheet_mut(0) {
-        for x in sh.shapes.iter_mut().filter(|x| x.kind == gridcraft_model::ShapeKind::Equation) {
-            x.text = format!("frac{{{}", "l".repeat(200));
-            x.anchor.width = 40.0;
-            x.anchor.height = 100.0;
-        }
-    }
-    let mut t = Session::new();
-    t.add_document(crate::DocState::new(wb, None, "Book".into(), crate::Trust::FromFile));
-    let (pdf, _) = pdf_of(&mut t, json!({}));
-    let text = String::from_utf8_lossy(&pdf);
-    let clip = text.find("30 75 re W n").expect("a clip the size of the frame");
-    let run = text.find("(frac{llll").expect("the source line");
-    let later = text.find("(later box) Tj").expect("the text box after the equation");
-    assert!(clip < run && run < later, "clip, then the text, then the later object");
-    // The net number of saved graphics states (`q` less `Q`) before an operator.
-    let depth = |at: usize| text[..at].lines().filter(|l| *l == "q").count() as i64 - text[..at].lines().filter(|l| *l == "Q").count() as i64;
-    assert_eq!(depth(run), depth(clip), "the text is drawn under the frame's clip");
-    assert_eq!(depth(later), depth(clip) - 1, "the later object is drawn with the frame's state restored");
-}
-
-#[test]
-#[allow(clippy::disallowed_methods)] // tests run only off wasm, where the clock exists
-fn an_equation_source_of_a_megabyte_prints_a_bounded_excerpt() {
-    // A file can carry a source far past `MAX_SOURCE_BYTES` (the drawing part may be 512 MiB). It
-    // never lays out, so the fallback prints the first 4,096 bytes and does no work on the rest:
-    // the PDF holds one run of that length, not the megabyte, and export takes bounded time.
-    let mut s = s();
-    s.execute("insert.equation", json!({"latex": "x", "cell": "B2"})).unwrap();
-    let mut wb = (*s.doc().unwrap().wb).clone();
-    if let Some(sh) = wb.sheet_mut(0) {
-        for x in sh.shapes.iter_mut() {
-            x.text = "l".repeat(1 << 20);
-        }
-    }
-    let mut t = Session::new();
-    t.add_document(crate::DocState::new(wb, None, "Book".into(), crate::Trust::FromFile));
-    let start = std::time::Instant::now();
-    let (pdf, _) = pdf_of(&mut t, json!({}));
-    let took = start.elapsed();
-    let text = String::from_utf8_lossy(&pdf);
-    let longest = text.split(|c| c != 'l').map(str::len).max().unwrap_or(0);
-    assert_eq!(longest, gridcraft_math::MAX_SOURCE_BYTES, "the run is the excerpt and no more");
-    assert!(pdf.len() < 64 * 1024, "the PDF holds the excerpt, not the megabyte: {} bytes", pdf.len());
-    assert!(took < std::time::Duration::from_secs(5), "{took:?}");
-}
-
-#[test]
-fn equations_print_with_the_symbol_font() {
-    let mut s = s();
-    s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap();
-    s.execute("insert.equation", json!({"latex": "\\sum_{i=1}^{n} \\alpha_i \\le \\infty \\pm \\sqrt{x} \\times \\partial y", "cell": "B2"}))
-        .unwrap();
-    s.execute("insert.equation", json!({"latex": "\\mathbb{R} \\oplus \\text{\u{4E2D}}", "cell": "B8"})).unwrap();
-    let (pdf, _) = pdf_of(&mut s, json!({}));
-    assert!(contains(&pdf, "/BaseFont /Symbol >>"), "maths symbols use the Symbol font");
-    assert!(contains(&pdf, "/BaseFont /Times-Italic"), "variables are italic");
-    // The summation (0xE5) and alpha (0x61) codes in Symbol.
-    assert!(contains(&pdf, "(\\345) Tj") && contains(&pdf, "(a) Tj"));
-    // A glyph no standard font has is a [?] box.
-    assert!(contains(&pdf, "(?) Tj"));
-}
@@ -3,57 +3,42 @@ use super::{CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, Sheet

 const PAD_PX: f32 = 2.0;

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