Extents: share block-bounds memoization across all the entities measured

Each top-level bounds call started with an empty block cache, so measuring a space's extents or building a spatial-index chunk measured a block definition again for every reference to it: R references to a block of B entities cost R x B. BlockBoundsCache keeps the per-depth block bounds (separately for drawn bounds and extents, which differ on layers turned off) across one bulk operation; Drawing::extents and the spatial index use it (CWE-407).
Autosave: failures are shown, and a crash is recovered at the first relaunch (#2670 )
2026-11-03 08:52:05 -06:00 · 2026-11-02 20:23:52 -05:00 · 2026-11-02 18:06:35 -07:00 · 2026-11-02 19:26:12 -05:00 · 2026-11-02 17:10:53 -07:00 · 2026-11-02 16:51:54 -07:00
273 changed files with 15737 additions and 1238 deletions
@@ -62,6 +62,7 @@ jobs:
    permissions:
      # The reusable release workflow tags and uploads the draft release.
      contents: write
+      packages: write
    # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
    uses: storytold/craft-common-actions/.github/workflows/release.yml@main
    with:
@@ -2,8 +2,6 @@

 CADCraft is a clean-room, open-source, pure-Rust computer-aided design and drafting application targeting Autodesk AutoCAD parity — and superiority (speed, openness, agent control). It runs natively on macOS, Windows, Linux and FreeBSD, and on the web via WASM. Siblings with the same conventions: `../photocraft` (Photoshop-class), `../vectorcraft` (Illustrator), `../filmcraft` (Premiere), `../lightcraft` (Lightroom), `../pdfcraft` (Acrobat), `../effectcraft` (After Effects), `../designcraft` (InDesign).

-Standards and learnings shared across the crafting apps live in `../../craftrules` (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/autocad/*` (`01-observed-ui.md` holds measured observations of the running reference app; `04-menu-tree.txt` the menu tree by name).
 2. Library decisions: `plan/adr/0001-geometry-libraries.md` (what we may depend on, what is rejected for licence reasons).
@@ -12,7 +10,7 @@ Standards and learnings shared across the crafting apps live in `../../craftrule
 `plan/` is gitignored (local only).

 ## Never crash
-People trust CADCraft with their drawings; 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).
+People trust CADCraft with their drawings; a crash loses their work. **This outranks feature work.**
 - **No panics in non-test code:** no `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!`; no `unsafe` (`unsafe_code = "forbid"`).
 - **Errors are `Result<T, E>`** through the crate's error type and `?`. An unfinished feature returns an error or reports "not available yet"; it never panics.
 - **Input-derived numbers are hostile** (DXF/DWG files, command-line text, MCP/control params): `get()` not `[i]`, checked arithmetic, no NaN casts, cap input-sized allocations and loop counts.
@@ -47,25 +45,22 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr
 - Parallel agents: separate `CARGO_TARGET_DIR` per agent; edit only the crates you own; delete your target dir when done (disk).

 ## Roadmap
-`ROADMAP.md` (committed) is the one-page summary: stage, parity numbers, estimates. It follows craftrules' `standards/progress-docs.md`: the assessment is `docs/target-app-parity.md`, the work list `docs/gaps.md` (pick work from its top rows), milestones `docs/roadmap.md`, deep checklists `docs/geometry-parity.md`, `docs/ui-parity.md`, `docs/file-format-parity.md`, `docs/hardware-parity.md`, `docs/localization-parity.md`. PRs don't edit these docs: name the affected rows in the PR description, and maintainers update the rows, status lines and revision history in batches, which keeps open PRs from conflicting. `cargo xtask parity` regenerates the menu-breadth checklist in `docs/parity-checklist.md`.
+`ROADMAP.md` (committed) is the one-page summary: stage, parity numbers, estimates. The assessment is `docs/target-app-parity.md`, the work list `docs/gaps.md` (pick work from its top rows), milestones `docs/roadmap.md`, deep checklists `docs/geometry-parity.md`, `docs/ui-parity.md`, `docs/file-format-parity.md`, `docs/hardware-parity.md`, `docs/localization-parity.md`. PRs don't edit these docs: name the affected rows in the PR description, and maintainers update the rows, status lines and revision history in batches, which keeps open PRs from conflicting. `cargo xtask parity` regenerates the menu-breadth checklist in `docs/parity-checklist.md`.

 ## Contributor credits (About window)

 - About ▸ Contributors/Models are compiled into the binary from `contributors/contributors.json`
-  (commit stats; generated, never hand-edit) and `contributors/people.toml` (names people chose for
+  (commit stats; never hand-edit) and `contributors/people.toml` (names people chose for
  themselves). See `docs/contributors.md`.
 - **Agents working for a contributor:** when you prepare a PR, check whether your human's GitHub
  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, or run
-  `python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "…" --sync-github-name`)
+  (copy the template at the top of the file)
  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.
@@ -48,14 +48,14 @@ Generated-in-code assets are original and have no file to list:
 | `docs/images/ui-apartment.png` | CADCraft contributors | screenshot of CADCraft itself (examples/apartment.dxf) | MIT OR Apache-2.0 | Original; no Autodesk UI |
 | `docs/images/ui-layout.png` | CADCraft contributors | screenshot of CADCraft itself (a layout of examples/apartment.dxf) | MIT OR Apache-2.0 | Original; no Autodesk UI |
 | `docs/images/ui-bracket.png` | CADCraft contributors | screenshot of CADCraft itself (sample drawing generated in code) | MIT OR Apache-2.0 | Original; no Autodesk UI |
-| `docs/brand/artcraft-logo-white.png` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-logo-white.svg` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-logo.png` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-logo.svg` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-mark-black.png` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-mark-black.svg` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-mark.png` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
-| `docs/brand/artcraft-mark.svg` | ArtCraft Team | storytold/craftrules `assets/brand/` | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `docs/brand/artcraft-logo-white.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `docs/brand/artcraft-logo-white.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 (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `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-mark-black.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `docs/brand/artcraft-mark-black.svg` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `docs/brand/artcraft-mark.png` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |
+| `docs/brand/artcraft-mark.svg` | ArtCraft Team | ArtCraft brand kit | ArtCraft brand terms (`docs/brand/LICENSE-brand.txt`) | Trademark, not open source |

 ## Interface translations

@@ -71,9 +71,10 @@ Generated-in-code assets are original and have no file to list:
 | `crates/ui-egui/src/i18n/fr.tsv` | @pechnikov2026-star | Original French translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/zh.tsv` | @mayloglog | Original Simplified Chinese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/sv.tsv` | Erik Holmbom (@holmbom) with Claude Code (AI-assisted) | Original Swedish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; terminology and the running app reviewed by a native speaker |
-| `crates/ui-egui/src/i18n/it.tsv` | Emanuele Bottelli (AI-assisted) | Original Italian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
+| `crates/ui-egui/src/i18n/it.tsv` | Emanuele Bottelli (AI-assisted); terminology corrections: Andrea Brandi (@starise) with OpenAI Codex (AI-assisted) | Original Italian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; targeted Chamfer terminology review by a native speaker |
 | `crates/ui-egui/src/i18n/ko.tsv` | @huk082 (AI-assisted) | Original Korean translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; no font assets added |
 | `crates/ui-egui/src/i18n/ar.tsv` | @hasan-sdaif | Original Arabic translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/hu.tsv` | @Skaywalker | Original Hungarian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/tr.tsv` | @ogzhnklvz (AI-assisted) | Original Turkish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; written from the English strings, no other catalog used as a source; the running app reviewed by a native speaker |
 | `crates/ui-egui/src/i18n/el.tsv` | @Camthalion77 with ChatGPT (AI-assisted) | Original Greek translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; independent native proofreading pending |
+| `crates/ui-egui/src/i18n/vi.tsv` | @2ez4gcx with Claude Code (AI-assisted) | Original Vietnamese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; terminology chosen with a native speaker, full proofreading pending |
@@ -2,8 +2,6 @@

 CADCraft is a clean-room, open-source, pure-Rust computer-aided design and drafting application targeting Autodesk AutoCAD parity — and superiority (speed, openness, agent control). It runs natively on macOS, Windows, Linux and FreeBSD, and on the web via WASM. Siblings with the same conventions: `../photocraft` (Photoshop-class), `../vectorcraft` (Illustrator), `../filmcraft` (Premiere), `../lightcraft` (Lightroom), `../pdfcraft` (Acrobat), `../effectcraft` (After Effects), `../designcraft` (InDesign).

-Standards and learnings shared across the crafting apps live in `../../craftrules` (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/autocad/*` (`01-observed-ui.md` holds measured observations of the running reference app; `04-menu-tree.txt` the menu tree by name).
 2. Library decisions: `plan/adr/0001-geometry-libraries.md` (what we may depend on, what is rejected for licence reasons).
@@ -12,7 +10,7 @@ Standards and learnings shared across the crafting apps live in `../../craftrule
 `plan/` is gitignored (local only).

 ## Never crash
-People trust CADCraft with their drawings; 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).
+People trust CADCraft with their drawings; a crash loses their work. **This outranks feature work.**
 - **No panics in non-test code:** no `unwrap()`, `expect()`, `panic!`, `unreachable!`, `todo!`, `unimplemented!`; no `unsafe` (`unsafe_code = "forbid"`).
 - **Errors are `Result<T, E>`** through the crate's error type and `?`. An unfinished feature returns an error or reports "not available yet"; it never panics.
 - **Input-derived numbers are hostile** (DXF/DWG files, command-line text, MCP/control params): `get()` not `[i]`, checked arithmetic, no NaN casts, cap input-sized allocations and loop counts.
@@ -46,7 +44,7 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr
 - Parallel agents: separate `CARGO_TARGET_DIR` per agent; edit only the crates you own; delete your target dir when done (disk).

 ## Roadmap
-`ROADMAP.md` (committed) is the one-page summary: stage, parity numbers, estimates. It follows craftrules' `standards/progress-docs.md`: the assessment is `docs/target-app-parity.md`, the work list `docs/gaps.md` (pick work from its top rows), milestones `docs/roadmap.md`, deep checklists `docs/geometry-parity.md`, `docs/ui-parity.md`, `docs/file-format-parity.md`, `docs/hardware-parity.md`, `docs/localization-parity.md`. PRs don't edit these docs: name the affected rows in the PR description, and maintainers update the rows, status lines and revision history in batches, which keeps open PRs from conflicting. `cargo xtask parity` regenerates the menu-breadth checklist in `docs/parity-checklist.md`.
+`ROADMAP.md` (committed) is the one-page summary: stage, parity numbers, estimates. The assessment is `docs/target-app-parity.md`, the work list `docs/gaps.md` (pick work from its top rows), milestones `docs/roadmap.md`, deep checklists `docs/geometry-parity.md`, `docs/ui-parity.md`, `docs/file-format-parity.md`, `docs/hardware-parity.md`, `docs/localization-parity.md`. PRs don't edit these docs: name the affected rows in the PR description, and maintainers update the rows, status lines and revision history in batches, which keeps open PRs from conflicting. `cargo xtask parity` regenerates the menu-breadth checklist in `docs/parity-checklist.md`.

 ## 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.
@@ -268,7 +268,7 @@ dependencies = [
 "objc2-foundation 0.3.2",
 "parking_lot",
 "percent-encoding",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 "wl-clipboard-rs",
 "x11rb",
 ]
@@ -614,7 +614,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"

 [[package]]
 name = "cadcraft"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
@@ -632,6 +632,7 @@ dependencies = [
 "muda",
 "objc2-app-kit 0.3.2",
 "rfd",
+ "ron",
 "serde_json",
 "sys-locale",
 "thiserror 2.0.21",
@@ -643,7 +644,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-cli"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
@@ -659,14 +660,14 @@ dependencies = [

 [[package]]
 name = "cadcraft-color"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "serde",
 ]

 [[package]]
 name = "cadcraft-constraints"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-doc",
 "cadcraft-geom",
@@ -676,7 +677,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-doc"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-color",
 "cadcraft-geom",
@@ -687,14 +688,14 @@ dependencies = [

 [[package]]
 name = "cadcraft-dwg"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "acadrust",
 ]

 [[package]]
 name = "cadcraft-dxf"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "encoding_rs",
 "log",
@@ -703,7 +704,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-engine"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-color",
 "cadcraft-constraints",
@@ -724,24 +725,25 @@ dependencies = [

 [[package]]
 name = "cadcraft-fonts"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-geom",
 "harfrust 0.14.0",
+ "icu_segmenter",
 "skrifa 0.48.0",
 "unicode-bidi",
 ]

 [[package]]
 name = "cadcraft-geom"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "serde",
 ]

 [[package]]
 name = "cadcraft-io"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "acadrust",
 "cadcraft-color",
@@ -762,7 +764,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-mcp"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
@@ -775,7 +777,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-render"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-color",
 "cadcraft-doc",
@@ -789,7 +791,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-ui-egui"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-color",
 "cadcraft-doc",
@@ -815,7 +817,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-web"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
@@ -1115,6 +1117,15 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f8f80099a98041a3d1622845c271458a2d73e688351bf3cb999266764b81d48"

+[[package]]
+name = "core_maths"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30"
+dependencies = [
+ "libm",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -1191,7 +1202,7 @@ dependencies = [
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=04aa1703b32d299e54f78fcde4182f2b393a9116#04aa1703b32d299e54f78fcde4182f2b393a9116"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
 "chrono",
 "dunce",
@@ -1643,7 +1654,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
 "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -2435,6 +2446,29 @@ dependencies = [
 "zerovec",
 ]

+[[package]]
+name = "icu_segmenter"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db"
+dependencies = [
+ "core_maths",
+ "icu_collections",
+ "icu_locale_fallback",
+ "icu_provider",
+ "icu_segmenter_data",
+ "potential_utf",
+ "smallvec",
+ "utf8_iter",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_segmenter_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad"
+
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -3435,7 +3469,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
 "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4030,7 +4064,7 @@ dependencies = [
 "errno",
 "libc",
 "linux-raw-sys 0.12.1",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4087,7 +4121,7 @@ dependencies = [
 "security-framework",
 "security-framework-sys",
 "webpki-root-certs",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4562,10 +4596,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
 "fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
 "once_cell",
 "rustix 1.1.5",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -5471,7 +5505,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -5894,7 +5928,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"

 [[package]]
 name = "xtask"
-version = "0.15.1"
+version = "0.17.0"
 dependencies = [
 "chrono",
 "serde_json",
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 # default-members

 [workspace.package]
-version = "0.15.1"
+version = "0.17.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -51,6 +51,9 @@ skrifa = "0.48"
 # so the graph has both) and the Unicode Bidirectional Algorithm for right-to-left drawing text.
 harfrust = "0.14"
 unicode-bidi = "0.3.18"
+# Line-break opportunities between Thai words for MTEXT word wrap (Thai writes no spaces between
+# words): UAX #14 with ICU4X's compiled-in LSTM word model (not its dictionaries).
+icu_segmenter = { version = "~2.3", default-features = false, features = ["compiled_data", "lstm"] }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
 encoding_rs = "0.8.35"
 # XML for the SVG reader (streaming parser, no entity expansion beyond the five predefined ones)
@@ -66,7 +69,7 @@ egui-wgpu = "0.37"
 # Monotonic time on native and web (performance.now on wasm).
 web-time = "1.1"
 # craft-update: app-specific pretend versions apply to startup and manual checks.
-craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "04aa1703b32d299e54f78fcde4182f2b393a9116", features = ["egui"] }
+craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", features = ["egui"] }
 rfd = "0.17"
 arboard = { version = "3.6", default-features = false }

@@ -230,6 +230,11 @@ How image exports (PNG 2400×1600, SVG, PDF) are framed: `convert` fits the mode
 rectangle, centred and scaled without distortion; `--view extents` or `--view current` forces
 either framing. To frame a selection set, `zoom {"mode":"object"}` after selecting.

+When reading a file leaves something out (records a DXF reader can't place, object records of a
+damaged DWG), `info` reports it (`skipped`, `readNotes`), `convert` warns on stderr and `run`
+prints the DWG notes with its log; the exit code stays 0. MCP `open` replies with the notes as
+`warnings`.
+
 MCP tools include `command_line` (type at the prompt), `execute` (any command with JSON),
 `inspect_drawing`, `query_entities`, `render` (returns a PNG) and, when connected to the app,
 `screenshot` and `ui_click`. The desktop app's JSON control channel is documented in
@@ -377,7 +382,15 @@ 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/cadcraft/main/assets/app-icon/cadcraft-64.png" alt="" width="32" height="32"> | **CADCraft** | **Computer-aided design and drafting · you are here** | [GitHub](https://github.com/storytold/cadcraft) | [Website](https://getartcraft.com/apps/cadcraft) |
+| <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) | |

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

@@ -125,8 +125,8 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
 | 2026-10-12 | HATCHEDIT refuses an explicit bad `scale` or `angle` before it edits anything, so a rejected request leaves the drawing, undo and redo as they were (#724) |
 | 2026-10-10 | Merged main: Ukrainian interface (#36, first string catalog), Dynamic Input pointer boxes with Tab and relative entry (#60), press-drag selection windows (#63), WIPEOUT and hatch gradients kept through DXF/DWG save (#147, #162), SETVAR DIM* as style overrides (#129), UNITS dialog (#38), close-window save prompt (#47), DIMANGULAR on circles (#20), cargo fmt fixed on main. UI/UX 40% → 43% (dynamic input 15% → 45%), localization 3% → 5%; ready for real work ≈ 37% → 38% (weighted 37.2% → 37.7%), mainstream 27% → 28%, essentials 45% → 46%. Beta is now ~37 points away; hours unchanged within rounding. |
 | 2026-10-10 | Added mainstream practitioner (≈ 27%) and essentials user (≈ 45%) numbers; ready for real work unchanged at ≈ 37%. User evidence: 2 praise comments, 0 "switched from AutoCAD" reports, 27 of 37 open issues on the core path. |
-| 2026-10-10 | Stage re-normalized from alpha to **pre-alpha** under the craftrules core-workflow gate: drafting with tracking, blocks, plotting and lossless DWG save fail; dimensioning passes. Alpha is ≈ 125–190 h away. |
-| 2026-10-10 | Full re-measure against AutoCAD 2027 for Mac in the craftrules progress-docs format: menu breadth 245/491 (50%), ready for real work ≈ 37%, stage alpha. Remaining estimates rose (≈ 570 h → 1,300–2,100 h) on new evidence: behaviour audits found tracking/extension/parallel snaps and dynamic input are not real, saves drop unmodelled content, DWG saves as R2000, and the old estimate had no localization, ecosystem, stability, platform or AI rows. New docs: target-app-parity, gaps, roadmap, architecture, localization, file-format, hardware, UI and geometry parity; `docs/parity.md` became `docs/parity-checklist.md`. |
+| 2026-10-10 | Stage re-normalized from alpha to **pre-alpha** under the core-workflow gate: drafting with tracking, blocks, plotting and lossless DWG save fail; dimensioning passes. Alpha is ≈ 125–190 h away. |
+| 2026-10-10 | Full re-measure against AutoCAD 2027 for Mac: menu breadth 245/491 (50%), ready for real work ≈ 37%, stage alpha. Remaining estimates rose (≈ 570 h → 1,300–2,100 h) on new evidence: behaviour audits found tracking/extension/parallel snaps and dynamic input are not real, saves drop unmodelled content, DWG saves as R2000, and the old estimate had no localization, ecosystem, stability, platform or AI rows. New docs: target-app-parity, gaps, roadmap, architecture, localization, file-format, hardware, UI and geometry parity; `docs/parity.md` became `docs/parity-checklist.md`. |
 | 2026-10-10 | About 60 community PRs merged in a day: DXF fidelity (transparency, LWPOLYLINE elevation, frozen VP layers, dimension text rotation, arc-length dims, non-ASCII escapes), CJK font fallback, Save/Don't Save on close, Light/System themes, F2 history, trackpad pan, Linux XWayland drag-and-drop, correctness fixes across draw/modify/constraints. Release v0.4.0. |
 | 2026-10-08 | Releases v0.1.0–v0.3.0: Flatpak, AppImage updates, signed macOS universal, Windows x64/x86/arm64, Linux, FreeBSD and web builds. |
 | 2026-10-07 | Old assessment: menu breadth 233/491 (47%), ≈ 29% weighted parity, 2D drafting ≈ 55%, ≈ 570 h remaining; milestones as reported then: M1 ~85%, M2 ~65%, M3 ~75%, M4 ~50%, M5 ~35%, M6 ~55%, M7 ~55%, M8 ~20%, M9 ~60%, M10 ~70%, M11 0%, M12 ~25%, M13 ~10%. |
@@ -144,7 +144,7 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
 | 2026-10-10 | minor | Readiness-by-audience table with hours to ~95% for each number |
 | 2026-10-10 | minor | Mainstream practitioner and essentials user headline numbers |
 | 2026-10-10 | minor | Stage alpha → pre-alpha under the core-workflow gate; banner, why, headline row |
-| 2026-10-10 | major | Restructured to the progress-docs standard (stage, two numbers, dimensions, features, languages, upcoming, log); full re-measure; milestone detail moved to docs/roadmap.md, parity assessment to docs/target-app-parity.md |
+| 2026-10-10 | major | Progress docs restructured (stage, two numbers, dimensions, features, languages, upcoming, log); full re-measure; milestone detail moved to docs/roadmap.md, parity assessment to docs/target-app-parity.md |
 | 2026-10-07 | major | Alpha checklist, milestone table, ≈ 29% weighted parity estimate |

 ## Shared UI workspace integration
@@ -1,6 +1,6 @@
 use super::args::ConvertArgs;
 use super::error::Result;
-use super::output::{Streams, export_framed, export_window, skipped_message, undrawn_message};
+use super::output::{Streams, export_framed, export_window, read_note_messages, skipped_message, undrawn_message};
 use super::{open, unicode};
 use cadcraft_engine::Session;

@@ -9,7 +9,8 @@ pub(crate) fn convert(a: &ConvertArgs, io: &mut Streams) -> Result {
    let framing = a.framing.framing();
    let mut s = Session::empty();
    open(&mut s, &a.input)?;
-    if let Some(m) = skipped_message(s.doc()?, i) {
+    let d = s.doc()?;
+    for m in read_note_messages(d, i).into_iter().chain(skipped_message(d, i)) {
        io.errln(format_args!("{m}"));
    }
    if cadcraft_io::is_image(&a.output)
@@ -122,10 +122,21 @@ pub(crate) fn export_window(s: &Session, framing: Framing, before: Option<&[(u64
 /// Write `bytes` to `out` through the engine's atomic writer (an exclusively created sibling file
 /// renamed over `out`), so a failed or interrupted write leaves the previous file untouched. An
 /// existing `out` is resolved first: the rename would otherwise replace a symlink with a file and
-/// leave the file it points to (`--in-place` through a link) unchanged.
-pub(crate) fn write_atomic(out: &Path, bytes: &[u8]) -> Result<(), OutputError> {
+/// leave the file it points to (`--in-place` through a link) unchanged. Folders missing above `out`
+/// are created, and the topmost one returned for the caller to report.
+pub(crate) fn write_atomic(out: &Path, bytes: &[u8]) -> Result<Option<std::path::PathBuf>, OutputError> {
    let target = std::fs::canonicalize(out).unwrap_or_else(|_| out.to_path_buf());
-    cadcraft_engine::atomic_write::write_atomic(&target, bytes).map_err(|source| OutputError::Write { path: out.to_path_buf(), source })
+    let folder = cadcraft_engine::atomic_write::missing_folder(&target);
+    cadcraft_engine::atomic_write::write_atomic_making_folders(&target, bytes)
+        .map_err(|source| OutputError::Write { path: out.to_path_buf(), source })?;
+    Ok(folder)
+}
+
+/// Say that `out` went into a folder that didn't exist, so a mistyped path is noticed.
+pub(crate) fn report_new_folder(folder: Option<std::path::PathBuf>, io: &mut Streams) {
+    if let Some(folder) = folder {
+        io.errln(format_args!("created the folder {}, which did not exist", folder.display()));
+    }
 }

 pub(crate) fn export(s: &Session, out: &Path, io: &mut Streams) -> Result {
@@ -135,7 +146,8 @@ pub(crate) fn export(s: &Session, out: &Path, io: &mut Streams) -> Result {
 pub(crate) fn export_framed(s: &Session, out: &Path, window: Option<Bounds2>, io: &mut Streams) -> Result {
    let d = s.doc()?;
    let bytes = cadcraft_io::write_framed(d, out, window)?;
-    write_atomic(out, &bytes)?;
+    let folder = write_atomic(out, &bytes)?;
+    report_new_folder(folder, io);
    io.errln(format_args!("wrote {} ({} bytes)", out.display(), bytes.len()));
    if cadcraft_engine::cmd::file::drops_unknown(out) {
        let lost = cadcraft_engine::cmd::file::not_saved(d);
@@ -165,6 +177,12 @@ pub(crate) fn undrawn_message(d: &cadcraft_engine::doc::Drawing, path: &str) ->
    Some(format!("{path}: {n} {entities} not drawn ({})", list.join(", ")))
 }

+/// The reader's notes on what it left out of `path` (a damaged DWG's unreadable object records,
+/// #859), one warning line each; empty for a complete read.
+pub(crate) fn read_note_messages(d: &cadcraft_engine::doc::Drawing, path: &str) -> Vec<String> {
+    d.read_notes.iter().map(|note| format!("{path}: {note}")).collect()
+}
+
 /// The warning for the records of `path` the reader could not place, or `None` when there are none.
 pub(crate) fn skipped_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option<String> {
    let n = d.skipped_records.values().fold(0usize, |a, n| a.saturating_add(*n));
@@ -175,3 +193,20 @@ pub(crate) fn skipped_message(d: &cadcraft_engine::doc::Drawing, path: &str) ->
    let records = if n == 1 { "record" } else { "records" };
    Some(format!("{path}: {n} {records} could not be read and are left out ({})", list.join(", ")))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::read_note_messages;
+
+    #[test]
+    fn read_notes_become_one_warning_each() {
+        let mut d = cadcraft_engine::doc::Drawing::new_imperial();
+        assert!(read_note_messages(&d, "a.dwg").is_empty());
+        d.read_notes =
+            vec!["DWG: 3 of 10 object records couldn't be read and were left out (LINE × 3); saving over the original file would lose them".into()];
+        assert_eq!(
+            read_note_messages(&d, "a.dwg"),
+            vec!["a.dwg: DWG: 3 of 10 object records couldn't be read and were left out (LINE × 3); saving over the original file would lose them"]
+        );
+    }
+}
@@ -1,6 +1,6 @@
 use super::args::{SampleArgs, SampleName};
 use super::error::Result;
-use super::output::{Streams, write_atomic};
+use super::output::{Streams, report_new_folder, write_atomic};

 pub(crate) fn sample(a: &SampleArgs, io: &mut Streams) -> Result {
    let d = match a.name {
@@ -8,7 +8,8 @@ pub(crate) fn sample(a: &SampleArgs, io: &mut Streams) -> Result {
        SampleName::Floorplan => cadcraft_engine::sample::floor_plan(),
    };
    let bytes = cadcraft_io::write(&d, &a.output)?;
-    write_atomic(&a.output, &bytes)?;
+    let folder = write_atomic(&a.output, &bytes)?;
+    report_new_folder(folder, io);
    io.errln(format_args!("wrote {} ({} bytes)", a.output.display(), bytes.len()));
    Ok(())
 }
@@ -0,0 +1,69 @@
+//! A damaged DWG opens partially (#859); `info` lists the reader's notes on what it left out
+//! (`readNotes`) and `convert` warns with them before writing the copy, so a script or agent sees
+//! the loss. The exit code stays 0.
+
+use std::process::{Command, Output};
+
+fn cli(args: &[&str]) -> Output {
+    Command::new(env!("CARGO_BIN_EXE_cadcraft-cli")).args(args).output().unwrap()
+}
+
+/// A DWG of 200 lines, and a copy damaged so that the reader skips some of its records (found the
+/// way the reader's own test finds one: flipping a few bytes at a time across the objects area).
+fn dwg_and_damaged_copy() -> (Vec<u8>, Vec<u8>) {
+    let mut dxf = String::from("0\nSECTION\n2\nENTITIES\n");
+    for i in 0..200 {
+        dxf += &format!("0\nLINE\n8\n0\n10\n{i}\n20\n0\n11\n{i}\n21\n10\n");
+    }
+    dxf += "0\nENDSEC\n0\nEOF\n";
+    let d = cadcraft_io::read(dxf.as_bytes(), "lines.dxf").unwrap();
+    let opts = cadcraft_io::SaveOptions { version: Some(cadcraft_io::Version::R2000), binary: false };
+    let dwg = cadcraft_io::write_with(&d, "lines.dwg", &opts).unwrap();
+    let damaged = (dwg.len() / 4..dwg.len() * 3 / 5)
+        .step_by(97)
+        .map(|at| {
+            let mut b = dwg.clone();
+            b[at..at + 6].iter_mut().for_each(|x| *x ^= 0xA5);
+            b
+        })
+        .find(|b| cadcraft_io::read(b, "damaged.dwg").is_ok_and(|d| !d.read_notes.is_empty()))
+        .expect("no damaged copy read partially");
+    (dwg, damaged)
+}
+
+#[test]
+fn info_lists_and_convert_warns_about_read_notes() {
+    let dir = std::env::temp_dir().join(format!("cc-cli-read-notes-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let (whole, damaged) = dwg_and_damaged_copy();
+    let path = dir.join("damaged.dwg");
+    std::fs::write(&path, &damaged).unwrap();
+    let path = path.to_str().unwrap();
+
+    let out = cli(&["info", path]);
+    assert!(out.status.success(), "{:?}: {}", out.status, String::from_utf8_lossy(&out.stderr));
+    let v: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
+    let notes = v["readNotes"].as_array().unwrap();
+    assert_eq!(notes.len(), 1, "{v}");
+    assert!(notes[0].as_str().unwrap().contains(" couldn't be read and "), "{v}");
+
+    let copy = dir.join("copy.dxf");
+    let out = cli(&["convert", path, copy.to_str().unwrap()]);
+    assert!(out.status.success(), "{:?}: {}", out.status, String::from_utf8_lossy(&out.stderr));
+    let err = String::from_utf8_lossy(&out.stderr);
+    let warnings: Vec<&str> = err.lines().filter(|l| l.contains(" couldn't be read and ")).collect();
+    assert_eq!(warnings.len(), 1, "{err}");
+    assert!(warnings[0].starts_with(&format!("{path}: DWG: ")), "{err}");
+    assert!(copy.exists());
+
+    // A complete read: no notes, and no warning.
+    let intact = dir.join("whole.dwg");
+    std::fs::write(&intact, &whole).unwrap();
+    let out = cli(&["info", intact.to_str().unwrap()]);
+    let v: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
+    assert_eq!(v["readNotes"], serde_json::json!([]));
+    let out = cli(&["convert", intact.to_str().unwrap(), copy.to_str().unwrap()]);
+    assert!(out.status.success());
+    assert!(!String::from_utf8_lossy(&out.stderr).contains("couldn't be read"), "{}", String::from_utf8_lossy(&out.stderr));
+    let _ = std::fs::remove_dir_all(&dir);
+}
@@ -24,6 +24,9 @@ log = { workspace = true }
 clap = { workspace = true }
 thiserror = { workspace = true }
 chrono = { workspace = true }
+# Reads eframe's app.ron to tell whether a window state was saved (main.rs `saved_window`).
+# Already in Cargo.lock through eframe; same version so nothing is built twice.
+ron = "0.12"

 [build-dependencies]
 winresource = "0.1"
@@ -50,6 +53,9 @@ muda = { version = "0.21", default-features = false }
 # View ▸ Accessibility ▸ Animation Effects ▸ Use System Setting: the system's Reduce motion
 # (system_animations.rs). Already in Cargo.lock through muda.
 objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSWorkspace", "NSAccessibility"] }
+# The same winit eframe uses (the storytold fork, patched in the workspace): its opt-in that turns
+# AppKit's terminate (Cmd+Q, Dock Quit) into a close request, so unsaved changes are asked about.
+winit = { version = "0.30", default-features = false }

 # Rust HID backends: no proprietary SDK or C HID library.
 [target.'cfg(target_os = "windows")'.dependencies]
@@ -127,7 +127,8 @@ impl eframe::App for App {
        self.cad.cancel_screenshots();
        self.cad.shutdown_autosave();
    }
-    /// Preferences (the interface theme) survive restarts; window and egui state are not kept.
+    /// Preferences (the interface theme) survive restarts; eframe saves the window state itself
+    /// (`persist_window`); egui state is not kept.
    fn save(&mut self, storage: &mut dyn eframe::Storage) {
        storage.set_string(cadcraft_ui_egui::options::PROFILE_KEY, self.cad.profile_json());
        storage.set_string(cadcraft_ui_egui::PREFS_KEY, self.cad.prefs_json());
@@ -194,8 +195,51 @@ fn filters_for_save(name: &str) -> [(&'static str, &'static str); 6] {
    filters
 }

+/// Whether eframe's storage file (`app.ron`, a map of keys to strings) holds a saved main window
+/// state. An unreadable or malformed file counts as none, as it does for eframe.
+fn saved_window(app_ron: &str) -> bool {
+    ron::from_str::<std::collections::HashMap<String, String>>(app_ron).is_ok_and(|kv| kv.contains_key(WINDOW_KEY))
+}
+
+/// The window state from the last session is saved and will be restored (#2595).
+fn restores_window() -> bool {
+    eframe::storage_dir(APP_ID).and_then(|dir| std::fs::read_to_string(dir.join("app.ron")).ok()).is_some_and(|ron| saved_window(&ron))
+}
+
+/// The main window: its size, title bar, placement and rendering needs. `restoring`: a window state
+/// saved by the last session is restored instead of opening centred.
+fn window_options(restoring: bool) -> eframe::NativeOptions {
+    eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_title("CADCraft")
+            .with_inner_size([1600.0, 1000.0])
+            .with_min_inner_size([900.0, 560.0])
+            .with_drag_and_drop(true)
+            .with_fullsize_content_view(true)
+            .with_titlebar_shown(false)
+            .with_title_shown(false)
+            .with_app_id(APP_ID),
+        // The size, position and maximized state are kept between sessions (#2595); eframe keeps a
+        // restored window on the monitors that are connected now.
+        persist_window: true,
+        // The first launch opens centred on its screen, not cascaded from the top-left corner
+        // (#1129); later launches go back where the window was (eframe would centre over that).
+        // Wayland compositors place windows themselves.
+        centered: !restoring,
+        // CADCraft installs its own capped font chain (`theme::install_fonts`); never run
+        // system-font discovery as a hidden fallback.
+        system_font_fallback: false,
+        // A stencil buffer clips the contents of clipped layout viewports on the GPU.
+        stencil_buffer: STENCIL_BITS,
+        ..Default::default()
+    }
+}
+
 const APP_ID: &str = "ai.storyteller.cadcraft";

+/// The key eframe saves the main window state under in its storage.
+const WINDOW_KEY: &str = "window";
+
 /// Stencil bits of the window's render pass (see `NativeOptions::stencil_buffer`).
 const STENCIL_BITS: u8 = 8;

@@ -256,22 +300,7 @@ fn main() -> eframe::Result {
        // The crosshair is drawn by the app: present without a queue on Linux/BSD, where X11
        // swapchains hold two frames back under vsync (`CADCRAFT_VSYNC=1` restores vsync).
        wgpu_options: eframe::egui_wgpu::WgpuConfiguration::default().with_surface_config(surface),
-        viewport: egui::ViewportBuilder::default()
-            .with_title("CADCraft")
-            .with_inner_size([1600.0, 1000.0])
-            .with_min_inner_size([900.0, 560.0])
-            .with_drag_and_drop(true)
-            .with_fullsize_content_view(true)
-            .with_titlebar_shown(false)
-            .with_title_shown(false)
-            .with_app_id(APP_ID),
-        persist_window: false,
-        // CADCraft installs its own capped font chain (`theme::install_fonts`); never run
-        // system-font discovery as a hidden fallback.
-        system_font_fallback: false,
-        // A stencil buffer clips the contents of clipped layout viewports on the GPU.
-        stencil_buffer: STENCIL_BITS,
-        ..Default::default()
+        ..window_options(restores_window())
    };
    if let Some(icon) = app_icon() {
        options.viewport = options.viewport.with_icon(icon);
@@ -300,6 +329,16 @@ fn main() -> eframe::Result {
            b.with_x11();
        }));
    }
+    // macOS: Quit CADCraft (Cmd+Q), the Dock's Quit and logout end the app through AppKit's
+    // terminate, which would skip the unsaved-changes prompt (#2157). winit turns each into a
+    // close request for the window instead, so it asks first, as the close button does.
+    #[cfg(target_os = "macos")]
+    {
+        options.event_loop_builder = Some(Box::new(|b| {
+            use winit::platform::macos::EventLoopBuilderExtMacOS;
+            b.with_close_requested_on_terminate(true);
+        }));
+    }
    eframe::run_native(
        "CADCraft",
        options,
@@ -383,7 +422,7 @@ fn main() -> eframe::Result {

 #[cfg(test)]
 mod tests {
-    use super::{filters_for_save, follow_desktop};
+    use super::{filters_for_save, follow_desktop, saved_window, window_options};

    #[test]
    fn save_dialog_offers_dwg_with_the_drawing_format_first() {
@@ -401,6 +440,32 @@ mod tests {
        }
    }

+    /// #1129: the first launch opens centred, not cascaded from the top-left corner.
+    #[test]
+    fn the_first_launch_opens_centred() {
+        let o = window_options(false);
+        assert!(o.centered, "centred on launch");
+        assert!(o.persist_window, "the window state is saved for the next launch");
+    }
+
+    /// #2595: a saved window state (size, position, maximized) is restored, not centred over.
+    #[test]
+    fn a_saved_window_reopens_where_it_was() {
+        let o = window_options(true);
+        assert!(!o.centered, "centring would move a restored window");
+        assert!(o.persist_window);
+    }
+
+    /// Only a readable `app.ron` with a window entry counts as a saved window state.
+    #[test]
+    fn a_saved_window_is_read_from_app_ron() {
+        assert!(saved_window(r#"{"cadcraft.prefs": "{}", "window": "(maximized: true)"}"#));
+        assert!(!saved_window(r#"{"cadcraft.prefs": "{\"window\":1}"}"#), "a value mentioning it is not the key");
+        assert!(!saved_window(""));
+        assert!(!saved_window("{\"window\": "), "truncated");
+        assert!(!saved_window("not ron at all"));
+    }
+
    /// View ▸ Theme ▸ System on Linux: winit reports no theme, so the desktop's answer stands in;
    /// without one (or where winit answers and the desktop doesn't) the input is left alone.
    #[test]
@@ -1,13 +1,10 @@
-# Contributor names for the About window (craftrules standards/contributors.md).
+# Contributor names for the About window.
 #
 # 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.
 #
-# 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):
+# 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"
@@ -99,3 +96,9 @@ sync_github_name = false

 [people.dylanmtaylor]
 sync_github_name = true
+
+[people.GULERTOLGA]
+sync_github_name = true
+
+[people.starise]
+real_name = "Andrea Brandi"
@@ -194,7 +194,9 @@ pub struct Action {
 #[derive(Clone, Debug, PartialEq, Serialize)]
 #[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
 pub enum ActionKind {
-    /// Moves the vertices inside `frame` of the objects listed (all of an object not listed).
+    /// Moves the points of its objects inside `frame`: a line's or polyline's points inside it
+    /// (the whole of one outside it), any other object whole. `vertices` are the point indices the
+    /// file lists for each object, used only when the frame can't be tested (see `apply`).
    Stretch {
        frame: Vec<Vec2>,
        #[serde(serialize_with = "hex_vertices")]
@@ -403,7 +403,31 @@ fn move_entity(e: &mut Entity, vertices: Option<&[i32]>, v: Vec2) {
    }
 }

-/// Whether point `p` lies inside a stretch frame (two corners, or a polygon).
+/// Most points of a stretch frame whose objects' points are tested against it one by one. A frame
+/// is two corners or a short polygon; testing every point of every object against every edge of a
+/// longer one would grow with their product, so the action's own vertex lists are used instead.
+const MAX_FRAME_POINTS: usize = 1000;
+
+/// The indices of `points` inside stretch frame `frame`, or `None` when none is: an object the
+/// action selects that lies outside its frame moves whole.
+fn inside(frame: &[Vec2], points: impl Iterator<Item = Vec2>) -> Option<Vec<i32>> {
+    let idx: Vec<i32> = points.enumerate().filter(|(_, p)| in_frame(frame, *p)).filter_map(|(i, _)| i32::try_from(i).ok()).collect();
+    (!idx.is_empty()).then_some(idx)
+}
+
+/// The distance from `p` to the segment `a`-`b`, however short (`Line::dist` takes one shorter than
+/// `EPS` for its first point). It is measured from `a`, so a short segment far from the origin keeps
+/// the digits rounding there would drop.
+fn segment_dist(a: Vec2, b: Vec2, p: Vec2) -> f64 {
+    let d = b - a;
+    let w = p - a;
+    let l2 = d.len2();
+    let t = if l2 > 0.0 { (w.dot(d) / l2).clamp(0.0, 1.0) } else { 0.0 };
+    (w - d * t).len()
+}
+
+/// Whether point `p` lies inside a stretch frame (two corners, or a polygon). A point on its edge is
+/// inside, for a polygon as for two corners: within a billionth of the edge's length of it.
 fn in_frame(frame: &[Vec2], p: Vec2) -> bool {
    match frame {
        [a, b] => p.x >= a.x.min(b.x) && p.x <= a.x.max(b.x) && p.y >= a.y.min(b.y) && p.y <= a.y.max(b.y),
@@ -412,6 +436,9 @@ fn in_frame(frame: &[Vec2], p: Vec2) -> bool {
            let mut j = f.len() - 1;
            for i in 0..f.len() {
                let (Some(pi), Some(pj)) = (f.get(i), f.get(j)) else { break };
+                if segment_dist(*pj, *pi, p) <= 1e-9 * pi.dist(*pj) {
+                    return true;
+                }
                if (pi.y > p.y) != (pj.y > p.y) && p.x < (pj.x - pi.x) * (p.y - pi.y) / (pj.y - pi.y) + pi.x {
                    inside = !inside;
                }
@@ -464,7 +491,10 @@ fn apply(
                _ => 0.0,
            })
        };
-        let mult = if mult == 0.0 { 1.0 } else { mult };
+        // A zero multiplier would move nothing. AutoCAD 2024 moves such an action by the
+        // parameter's change and leaves its angle offset out (measured on a stretch action written
+        // with multiplier 0, angle offset 1 and group 280 = 1).
+        let (mult, angle) = if mult == 0.0 { (1.0, 0.0) } else { (mult, angle) };
        let v = Vec2::new(comp(0), comp(1)).rotate(angle) * mult;
        if !(v.x.is_finite() && v.y.is_finite()) || (v.x == 0.0 && v.y == 0.0) {
            continue;
@@ -473,6 +503,8 @@ fn apply(
        // this action's selection, so a selection that repeats a handle does not re-scan the
        // vertex list and re-clone its index vector per occurrence (CWE-400).
        let vtx_by_handle: HashMap<Handle, &Vec<i32>> = vertices.iter().rev().map(|(vh, i)| (*vh, i)).collect();
+        // Whether the frame (two corners or a polygon) is tested point by point.
+        let framed = (2..=MAX_FRAME_POINTS).contains(&frame.len());
        let mut handled: HashSet<Handle> = HashSet::new();
        for h in &a.selection {
            if !handled.insert(*h) {
@@ -502,7 +534,18 @@ fn apply(
                continue;
            }
            let Some(c) = copy_of(h) else { continue };
-            let idx = vtx_by_handle.get(h).map(|i| (*i).clone());
+            // The points of a line or polyline that move are those inside the frame where the
+            // dynamic block has them, all of them when none is, as AutoCAD 2024 moves them. It
+            // doesn't go by the vertex lists the action stores, which a block from another program
+            // can get wrong. A polyline's vertices are in its own plane: in the block's when its
+            // extrusion is exactly along z (a mirrored one is read flipped into it). Any tilt, however
+            // small, moves them by as much as the elevation times the tilt, so a tilted one keeps the
+            // stored list.
+            let idx = match def.entities.get(*h).map(|e| (&e.kind, e.common.extrusion)) {
+                Some((EntityKind::Line(l), _)) if framed => inside(frame, [l.a.xy(), l.b.xy()].into_iter()),
+                Some((EntityKind::LwPolyline(pl), n)) if framed && n.x == 0.0 && n.y == 0.0 => inside(frame, pl.vertices.iter().map(|v| v.p)),
+                _ => vtx_by_handle.get(h).map(|i| (*i).clone()),
+            };
            moves.entry(c).or_default().push((idx, v));
        }
    }
@@ -48,7 +48,7 @@ mod wipeout;

 pub use block::{Attrib, AttribModes, AttribProps, Insert, MultilineAttrib, mtext_literal};
 pub use common::{Common, Handle, Lineweight, RawTag, Transparency};
-pub use curves::{Arc, Circle, Ellipse, Face3d, Line, LwPolyline, Point, Polyline3d, RayLine, Solid};
+pub use curves::{Arc, Circle, Ellipse, Face3d, Line, LwPolyline, Point, PolyfaceMesh, Polyline3d, RayLine, Solid};
 pub use dim::{AssocSnap, DimAssoc, DimBreak, DimKind, DimMarks, Dimension, Inspection, JoggedRadius, Leader, MLeader};
 pub use fill::{Gradient, Hatch, HatchLoop};
 pub use layout::{Image, Table, TableCell, Viewport};
@@ -86,6 +86,7 @@ pub enum EntityKind {
    Solid(Solid),
    Trace(Solid),
    Face3d(Face3d),
+    PolyfaceMesh(PolyfaceMesh),
    Region(Region),
    Viewport(Viewport),
    Image(Image),
@@ -140,6 +141,7 @@ impl EntityKind {
            EntityKind::Solid(_) => "2D Solid",
            EntityKind::Trace(_) => "Trace",
            EntityKind::Face3d(_) => "3D Face",
+            EntityKind::PolyfaceMesh(_) => "Polyface Mesh",
            EntityKind::Region(_) => "Region",
            EntityKind::Viewport(_) => "Viewport",
            EntityKind::Image(_) => "Raster Image",
@@ -175,6 +177,7 @@ impl EntityKind {
            EntityKind::Solid(_) => "SOLID",
            EntityKind::Trace(_) => "TRACE",
            EntityKind::Face3d(_) => "3DFACE",
+            EntityKind::PolyfaceMesh(_) => "POLYLINE",
            EntityKind::Region(_) => "REGION",
            EntityKind::Viewport(_) => "VIEWPORT",
            EntityKind::Image(_) => "IMAGE",
@@ -218,10 +221,10 @@ impl EntityKind {
                let c = &s.corners;
                vec![Prim::Fill(vec![c[0].xy(), c[1].xy(), c[3].xy(), c[2].xy()])]
            }
-            EntityKind::Face3d(f) => {
-                let c = &f.corners;
-                let pts = [c[0].xy(), c[1].xy(), c[2].xy(), c[3].xy(), c[0].xy()];
-                pts.windows(2).filter_map(|w| Some(Prim::Seg(Segment::Line(GLine::new(*w.first()?, *w.get(1)?))))).collect()
+            EntityKind::Face3d(f) => f.visible_edges().into_iter().map(|(a, b)| Prim::Seg(Segment::Line(GLine::new(a.xy(), b.xy())))).collect(),
+            // Each face's visible edges (an edge flagged hidden, by a negative index, isn't drawn).
+            EntityKind::PolyfaceMesh(m) => {
+                m.faces3d().iter().flat_map(Face3d::visible_edges).map(|(a, b)| Prim::Seg(Segment::Line(GLine::new(a.xy(), b.xy())))).collect()
            }
            EntityKind::Region(r) => r.segments().into_iter().map(Prim::Seg).collect(),
            EntityKind::Hatch(h) => {
@@ -424,6 +427,7 @@ impl EntityKind {
            }
            EntityKind::Solid(so) | EntityKind::Trace(so) => so.corners.iter_mut().for_each(t3),
            EntityKind::Face3d(f) => f.corners.iter_mut().for_each(t3),
+            EntityKind::PolyfaceMesh(pm) => pm.vertices.iter_mut().for_each(t3),
            EntityKind::Region(r) => {
                for v in r.loops.iter_mut().flat_map(|l| l.vertices.iter_mut()) {
                    v.p = m.apply(v.p);
@@ -465,6 +469,92 @@ impl EntityKind {
        }
    }

+    /// Scale every height of the object by `f` about the height `base_z`: the Z of its points,
+    /// its elevation. With [`EntityKind::transform`] scaling about the base point's XY this is a
+    /// uniform 3D scale about the base point, as AutoCAD 2024's SCALE makes it. Sizes `transform`
+    /// already scales (text and helix heights, an insert's Z scale) are left alone; splines,
+    /// regions and wipeouts lie in the XY plane.
+    pub fn scale_heights(&mut self, base_z: f64, f: f64) {
+        let scale = |h: &mut f64| *h = base_z + (*h - base_z) * f;
+        let z = |p: &mut Vec3| scale(&mut p.z);
+        let text_z = |t: &mut Text| {
+            z(&mut t.insert);
+            if let Some(a) = &mut t.align_pt {
+                z(a);
+            }
+        };
+        let attribs_z = |attribs: &mut Vec<Attrib>| {
+            for a in attribs {
+                text_z(&mut a.text);
+                if let Some(ml) = &mut a.multiline {
+                    z(&mut ml.mtext.insert);
+                }
+            }
+        };
+        match self {
+            EntityKind::Line(l) => {
+                z(&mut l.a);
+                z(&mut l.b);
+            }
+            EntityKind::Point(p) => z(&mut p.p),
+            EntityKind::Circle(c) => z(&mut c.center),
+            EntityKind::Arc(a) => z(&mut a.center),
+            EntityKind::Ellipse(e) => z(&mut e.center),
+            EntityKind::LwPolyline(p) => scale(&mut p.elevation),
+            EntityKind::Polyline3d(p) => p.points.iter_mut().for_each(z),
+            EntityKind::Helix(h) => z(&mut h.center),
+            EntityKind::Ray(r) | EntityKind::XLine(r) => z(&mut r.base),
+            EntityKind::Text(t) => text_z(t),
+            EntityKind::AttDef(a) => {
+                text_z(&mut a.text);
+                if let Some(ml) = &mut a.multiline {
+                    z(&mut ml.mtext.insert);
+                }
+            }
+            EntityKind::MText(t) => z(&mut t.insert),
+            EntityKind::Insert(i) => {
+                z(&mut i.insert);
+                attribs_z(&mut i.attribs);
+            }
+            EntityKind::Dimension(d) => {
+                for p in [&mut d.defpt, &mut d.text_mid, &mut d.p13, &mut d.p14, &mut d.p15, &mut d.p16] {
+                    z(p);
+                }
+                if let Some(j) = &mut d.marks.jog_line {
+                    z(j);
+                }
+                if let Some(j) = &mut d.marks.jogged {
+                    z(&mut j.center);
+                    z(&mut j.jog);
+                }
+                d.marks.breaks.iter_mut().for_each(|b| z(&mut b.at));
+                d.block = None;
+            }
+            EntityKind::MLine(ml) => ml.vertices.iter_mut().for_each(|v| z(&mut v.p)),
+            EntityKind::Leader(l) => l.vertices.iter_mut().for_each(z),
+            EntityKind::MLeader(ml) => {
+                ml.leaders.iter_mut().flatten().for_each(z);
+                z(&mut ml.landing);
+                if let Some(t) = &mut ml.text {
+                    z(&mut t.insert);
+                }
+                if let Some(b) = &mut ml.block {
+                    z(&mut b.insert);
+                    attribs_z(&mut b.attribs);
+                }
+            }
+            EntityKind::Hatch(h) => scale(&mut h.elevation),
+            EntityKind::Solid(so) | EntityKind::Trace(so) => so.corners.iter_mut().for_each(z),
+            EntityKind::Face3d(fc) => fc.corners.iter_mut().for_each(z),
+            EntityKind::PolyfaceMesh(m) => m.vertices.iter_mut().for_each(z),
+            EntityKind::Viewport(v) => z(&mut v.center),
+            EntityKind::Image(i) => z(&mut i.insert),
+            EntityKind::Table(t) => z(&mut t.insert),
+            EntityKind::Tolerance(t) => z(&mut t.insert),
+            EntityKind::Spline(_) | EntityKind::Region(_) | EntityKind::Wipeout(_) | EntityKind::Unknown(_) => {}
+        }
+    }
+
    /// Grip points (editable defining points), in display order.
    pub fn grips(&self) -> Vec<Vec2> {
        // A broken table has a grip for each part.
@@ -526,6 +616,7 @@ impl EntityKind {
            }
            EntityKind::Solid(s) | EntityKind::Trace(s) => s.corners.iter().map(|c| c.xy()).collect(),
            EntityKind::Face3d(f) => f.corners.iter().map(|c| c.xy()).collect(),
+            EntityKind::PolyfaceMesh(m) => m.vertices.iter().map(|v| v.xy()).collect(),
            EntityKind::Region(r) => vec![r.bounds().center()],
            EntityKind::Viewport(v) => {
                let c = v.center.xy();
@@ -69,6 +69,52 @@ pub struct Face3d {
    pub hidden_edges: u8,
 }

+impl Face3d {
+    /// The edges drawn: side i (corner i to the next) unless bit i of `hidden_edges` hides it,
+    /// without the zero-length side of a triangle.
+    pub fn visible_edges(&self) -> Vec<(Vec3, Vec3)> {
+        let c = self.corners;
+        (0..4).filter(|i| self.hidden_edges & (1 << i) == 0).map(|i| (c[i], c[(i + 1) % 4])).filter(|(a, b)| a != b).collect()
+    }
+}
+
+/// POLYLINE polyface mesh (DXF flag 64): its vertices, and faces naming three or four of them
+/// by 1-based index as DXF stores them (0: no fourth vertex; a negative index hides the edge
+/// that starts at that vertex).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolyfaceMesh {
+    pub vertices: Vec<Vec3>,
+    pub faces: Vec<[i32; 4]>,
+}
+
+impl PolyfaceMesh {
+    /// The faces as 3D faces (what EXPLODE makes). Faces with fewer than three vertices or an
+    /// index outside the vertex list are skipped.
+    pub fn faces3d(&self) -> Vec<Face3d> {
+        self.faces.iter().filter_map(|f| self.face3d(f)).collect()
+    }
+    /// One face record as a 3D face: `None` when it names fewer than three vertices before a 0,
+    /// or one outside the vertex list.
+    pub fn face3d(&self, f: &[i32; 4]) -> Option<Face3d> {
+        let mut corners: Vec<Vec3> = Vec::with_capacity(4);
+        let mut hidden = 0u8;
+        for &ix in f.iter().take_while(|&&ix| ix != 0) {
+            let at = usize::try_from(ix.unsigned_abs()).ok().and_then(|n| n.checked_sub(1));
+            let p = *at.and_then(|n| self.vertices.get(n))?;
+            if ix < 0 {
+                hidden |= 1 << corners.len();
+            }
+            corners.push(p);
+        }
+        match corners.as_slice() {
+            // A triangle's closing edge is the 3DFACE's fourth (the third is degenerate).
+            [a, b, c] => Some(Face3d { corners: [*a, *b, *c, *c], hidden_edges: hidden | if hidden & 4 != 0 { 8 } else { 0 } }),
+            [a, b, c, d] => Some(Face3d { corners: [*a, *b, *c, *d], hidden_edges: hidden }),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct RayLine {
    pub base: Vec3,
@@ -52,6 +52,11 @@ pub struct Dimension {
    /// Anonymous block with the rendered geometry (from files); regenerated when edited.
    #[serde(default)]
    pub block: Option<String>,
+    /// Insertion point (DXF group 12): a dimension moved by an older AutoCAD keeps its offset
+    /// here with the `*D` block's contents left where they were, and is drawn translated by it.
+    /// Zero once the geometry is regenerated from the definition points.
+    #[serde(default)]
+    pub insertion_point: Vec3,
    /// Per-dimension style overrides (DIMOVERRIDE): DimStyle field names (camelCase) → values,
    /// merged over the named style.
    #[serde(default, skip_serializing_if = "serde_json::Map::is_empty")]
@@ -94,25 +94,48 @@ fn mtext_box(t: &crate::MText) -> Bounds2 {

 /// The box of what `e` draws (block contents on layers turned off left out).
 pub fn entity_bounds(d: &Drawing, e: &Entity, depth: usize) -> Bounds2 {
-    bounds_of(d, e, depth, false)
+    bounds_of(d, e, depth, false, &mut HashMap::new())
 }

 /// The box `e` takes in the drawing's extents: as [`entity_bounds`], but block contents on a layer
 /// turned off count, as AutoCAD 2024's ZOOM Extents counts them (a frozen layer's do not).
 pub fn extent_bounds(d: &Drawing, e: &Entity) -> Bounds2 {
-    bounds_of(d, e, 0, true)
+    bounds_of(d, e, 0, true, &mut HashMap::new())
 }

-fn bounds_of(d: &Drawing, e: &Entity, depth: usize, off_counts: bool) -> Bounds2 {
+/// The bounds of block contents measured so far, kept across the entities of one unchanged
+/// drawing. Measuring many entities with [`entity_bounds_cached`] or [`extent_bounds_cached`]
+/// and one cache measures each block definition once per depth for all of them; a fresh cache per
+/// entity would measure a block again for every reference to it, R references to a block of B
+/// entities costing R x B (CWE-407). Use a cache only while the drawing it measured is unchanged.
+#[derive(Default)]
+pub struct BlockBoundsCache<'a> {
+    /// By block name and depth, block contents on layers turned off left out ([`entity_bounds`]).
+    drawn: HashMap<(&'a str, usize), Bounds2>,
+    /// The same with those contents counted ([`extent_bounds`]).
+    extents: HashMap<(&'a str, usize), Bounds2>,
+}
+
+/// [`entity_bounds`] reusing the block bounds `cache` holds from earlier calls on drawing `d`.
+pub fn entity_bounds_cached<'a>(d: &'a Drawing, e: &Entity, depth: usize, cache: &mut BlockBoundsCache<'a>) -> Bounds2 {
+    bounds_of(d, e, depth, false, &mut cache.drawn)
+}
+
+/// [`extent_bounds`] reusing the block bounds `cache` holds from earlier calls on drawing `d`.
+pub fn extent_bounds_cached<'a>(d: &'a Drawing, e: &Entity, cache: &mut BlockBoundsCache<'a>) -> Bounds2 {
+    bounds_of(d, e, 0, true, &mut cache.extents)
+}
+
+fn bounds_of<'a>(d: &'a Drawing, e: &Entity, depth: usize, off_counts: bool, blocks: &mut HashMap<(&'a str, usize), Bounds2>) -> Bounds2 {
    // A top-level annotative object measures as it draws at the current annotation scale.
    if depth == 0 {
        match d.anno_draw(e) {
            crate::AnnoDraw::Plain => {}
            crate::AnnoDraw::Hidden => return Bounds2::EMPTY,
-            crate::AnnoDraw::Scaled(f) => return bounds_in(d, &crate::anno_scaled(e, f), 0, &mut HashMap::new(), off_counts),
+            crate::AnnoDraw::Scaled(f) => return bounds_in(d, &crate::anno_scaled(e, f), 0, blocks, off_counts),
        }
    }
-    bounds_in(d, e, depth, &mut HashMap::new(), off_counts)
+    bounds_in(d, e, depth, blocks, off_counts)
 }

 /// [`entity_bounds`] with the bounds of block contents (in block coordinates) already computed,
@@ -212,6 +235,10 @@ fn bounds_in<'a>(d: &'a Drawing, e: &Entity, depth: usize, blocks: &mut HashMap<
                        inner
                    }
                };
+                // The block draws translated by the insertion point (group 12), so its bounds
+                // move with it (#2634); the cache above keeps the block's own bounds.
+                let off = dm.insertion_point.xy();
+                let inner = if off == Vec2::ZERO { inner } else { Bounds2 { min: inner.min + off, max: inner.max + off } };
                b = b.union(&inner);
            }
            b
@@ -438,4 +465,53 @@ mod tests {
        empty.text = Some(crate::MText { contents: " ".into(), ..mtext });
        assert!(bounds(EntityKind::MLeader(empty)).max.x < 26.0);
    }
+
+    #[test]
+    fn a_shared_block_cache_measures_as_a_fresh_one_for_each_entity() {
+        let line = |a: (f64, f64), b: (f64, f64), layer: &str| {
+            let mut e = Entity::new(crate::Handle(1), EntityKind::Line(crate::Line { a: Vec3::new(a.0, a.1, 0.0), b: Vec3::new(b.0, b.1, 0.0) }));
+            e.common.layer = layer.into();
+            e
+        };
+        let ins = |block: &str, at: f64| {
+            Entity::new(
+                crate::Handle(2),
+                EntityKind::Insert(crate::Insert {
+                    block: block.into(),
+                    insert: Vec3::new(at, at, 0.0),
+                    scale: Vec3::new(1.0, 1.0, 1.0),
+                    rotation: 0.0,
+                    attribs: Vec::new(),
+                    cols: 1,
+                    rows: 1,
+                    col_spacing: 0.0,
+                    row_spacing: 0.0,
+                }),
+            )
+        };
+        let mut d = Drawing::new_imperial();
+        d.ensure_layer("OFF");
+        if let Some(l) = d.layer_mut("OFF") {
+            l.on = false;
+        }
+        // A block with a part on a layer turned off (left out when drawn, counted in extents),
+        // and a block that nests it.
+        let mut b = crate::Block::new("B");
+        b.entities.push(line((0.0, 0.0), (1.0, 1.0), "0"));
+        b.entities.push(line((0.0, 0.0), (5.0, 5.0), "OFF"));
+        d.blocks.insert("B".into(), std::sync::Arc::new(b));
+        let mut n = crate::Block::new("N");
+        n.entities.push(ins("B", 10.0));
+        d.blocks.insert("N".into(), std::sync::Arc::new(n));
+        let ents: Vec<Entity> = (0..50).map(|i| ins(if i % 2 == 0 { "B" } else { "N" }, f64::from(i))).collect();
+        // One cache for both kinds of measure, interleaved: neither may answer for the other.
+        let mut cache = BlockBoundsCache::default();
+        for e in &ents {
+            let (drawn, extents) = (entity_bounds_cached(&d, e, 0, &mut cache), extent_bounds_cached(&d, e, &mut cache));
+            let (want_drawn, want_extents) = (entity_bounds(&d, e, 0), extent_bounds(&d, e));
+            assert_eq!((drawn.min, drawn.max), (want_drawn.min, want_drawn.max));
+            assert_eq!((extents.min, extents.max), (want_extents.min, want_extents.max));
+            assert!(extents.width() > drawn.width());
+        }
+    }
 }
@@ -6,7 +6,7 @@
 //! named object dictionary, a table record, a block, an entity); references to objects that are
 //! gone are dropped. Commands don't edit it.

-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};

 use crate::{Handle, RawTag};

@@ -89,8 +89,170 @@ impl Foreign {
            && self.data_store.is_empty()
    }

-    /// The entities the data store has records for (their 320 handles).
+    /// The entities with a geometry record in the data store: an `ACDSRECORD` naming the entity
+    /// (320) that holds its `ASM_Data`. A 320 without one doesn't keep an entity's geometry.
    pub fn data_store_entities(&self) -> std::collections::BTreeSet<Handle> {
-        self.data_store.iter().filter(|t| t.code == 320).filter_map(|t| Handle::parse_hex(t.value.trim())).collect()
+        let mut out = std::collections::BTreeSet::new();
+        for rec in data_store_records(&self.data_store) {
+            let is_record = rec.first().is_some_and(|t| t.value.trim().eq_ignore_ascii_case("ACDSRECORD"));
+            if is_record && rec.iter().any(|t| t.code == 2 && t.value.trim().eq_ignore_ascii_case("ASM_Data")) {
+                out.extend(data_store_owner(rec).and_then(|t| Handle::parse_hex(t.value.trim())));
+            }
+        }
+        out
+    }
+}
+
+/// Whether a solid modeler entity (3DSOLID, REGION, BODY) holds its ACIS geometry as SAT text
+/// (groups 1 and 3), which DXF 2013 and later no longer has: those files keep it in the data
+/// store section, so an entity with SAT text and no record there can't be written to one (#2334).
+pub fn sat_text_acis(u: &crate::Unknown, handle: Handle, stored: &std::collections::BTreeSet<Handle>) -> bool {
+    ["3DSOLID", "REGION", "BODY"].iter().any(|t| u.dxf_type.eq_ignore_ascii_case(t)) && !stored.contains(&handle) && has_sat_text(&u.tags)
+}
+
+/// The entities a DXF of 2013 or later leaves out because they hold SAT-text ACIS data
+/// ([`sat_text_acis`]), counted by DXF type, across model space, layouts and block definitions.
+pub fn sat_text_dropped(d: &crate::Drawing) -> BTreeMap<String, usize> {
+    let stored = d.foreign.data_store_entities();
+    let mut out = BTreeMap::new();
+    // The writer saves xrefs as references: their blocks (and `xref|` ones) hold nothing in the file.
+    let own_blocks = d.blocks.values().filter(|b| b.xref_path.is_none() && !xref_dependent(&b.name));
+    let stores = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).chain(own_blocks.map(|b| &b.entities));
+    for e in stores.flat_map(|s| s.iter()) {
+        if let crate::EntityKind::Unknown(u) = &e.kind
+            && sat_text_acis(u, e.handle, &stored)
+        {
+            let n: &mut usize = out.entry(u.dxf_type.to_ascii_uppercase()).or_default();
+            *n = n.saturating_add(1);
+        }
+    }
+    out
+}
+
+/// Whether a symbol name belongs to an attached xref (`xref|name`): the DXF writer leaves such
+/// symbols out, and the contents of xref blocks too ([`Block::xref_path`](crate::Block::xref_path)).
+pub fn xref_dependent(name: &str) -> bool {
+    name.contains('|')
+}
+
+/// The records of a data store section's groups: each starts at a `0` group and runs to the next
+/// (the section's own groups before the first record are not part of one).
+pub fn data_store_records(tags: &[RawTag]) -> Vec<&[RawTag]> {
+    let mut out = Vec::new();
+    let mut start = tags.iter().position(|t| t.code == 0).unwrap_or(tags.len());
+    while start < tags.len() {
+        let end = tags.iter().skip(start + 1).position(|t| t.code == 0).map_or(tags.len(), |k| start + 1 + k);
+        out.push(tags.get(start..end).unwrap_or(&[]));
+        start = end;
+    }
+    out
+}
+
+/// Whether an entity's groups hold SAT text: groups 1 and 3 inside its `AcDbModelerGeometry`
+/// subclass. A file of a version before the subclass markers has no `100` groups: all of its
+/// groups (before the extended data) are the entity's.
+pub fn has_sat_text(tags: &[RawTag]) -> bool {
+    let own = tags.iter().take_while(|r| r.code < 1000);
+    let marked = tags.iter().take_while(|r| r.code < 1000).any(|r| r.code == 100);
+    let mut in_modeler = !marked;
+    for r in own {
+        if r.code == 100 {
+            in_modeler = r.value.trim().eq_ignore_ascii_case("AcDbModelerGeometry");
+        } else if in_modeler && (r.code == 1 || r.code == 3) {
+            return true;
+        }
+    }
+    false
+}
+
+/// The group naming the entity a data store record belongs to: its first `320`. A record is kept
+/// or dropped by this handle alone, in the writer and wherever the store is read.
+pub fn data_store_owner(record: &[RawTag]) -> Option<&RawTag> {
+    record.iter().find(|t| t.code == 320)
+}
+
+impl Foreign {
+    /// The kept objects by handle (the first of any that share one).
+    fn object_index(&self) -> BTreeMap<Handle, &ForeignObject> {
+        let mut m = BTreeMap::new();
+        for o in &self.objects {
+            m.entry(o.handle).or_insert(o);
+        }
+        m
+    }
+
+    /// The kept object `root` and the kept objects it owns, directly or not (dictionary entries
+    /// and child pointers, groups 350 and 360), `root` first.
+    pub fn tree(&self, root: Handle) -> Vec<Handle> {
+        // Indexed once: a file can keep many objects, and a lookup per pointer would grow with
+        // their product.
+        let by_handle = self.object_index();
+        let mut out = vec![root];
+        let mut seen = BTreeSet::from([root]);
+        let mut i = 0;
+        while let Some(&h) = out.get(i) {
+            i += 1;
+            let Some(o) = by_handle.get(&h) else { continue };
+            for c in o.tags.iter().filter(|t| matches!(t.code, 350 | 360)).filter_map(|t| Handle::parse_hex(t.value.trim())) {
+                if out.len() < 4096 && by_handle.contains_key(&c) && seen.insert(c) {
+                    out.push(c);
+                }
+            }
+        }
+        out
+    }
+
+    /// Copy the objects of `tree` (see [`Foreign::tree`]) of `src` into this one under the handles
+    /// `fresh` (the same order; two more follow for a field list), `owner` taking the place of the
+    /// root's owner. References to objects outside the tree become null. Fields keep a field
+    /// list: this one gets a copy of the source's if it has none.
+    pub fn adopt_tree(&mut self, src: &Foreign, tree: &[Handle], fresh: &[Handle], owner: Handle) {
+        if fresh.len() < tree.len() + 2 {
+            return;
+        }
+        let map: BTreeMap<Handle, Handle> = tree.iter().copied().zip(fresh.iter().copied()).collect();
+        let by_handle = src.object_index();
+        let mut kinds = Vec::new();
+        for (n, h) in tree.iter().enumerate() {
+            let Some(o) = by_handle.get(h) else { continue };
+            let mut c = (*o).clone();
+            let Some(&new) = fresh.get(n) else { continue };
+            c.handle = new;
+            for t in &mut c.tags {
+                if t.code == 5 {
+                    t.value = new.hex();
+                } else if matches!(t.code, 320..=369 | 390..=399) {
+                    let to = Handle::parse_hex(t.value.trim()).and_then(|h| map.get(&h).copied()).or((n == 0 && t.code == 330).then_some(owner));
+                    t.value = to.map_or_else(|| "0".to_string(), Handle::hex);
+                }
+            }
+            kinds.push(c.kind.clone());
+            self.objects.push(c);
+        }
+        if let Some(list) = src.objects.iter().find(|o| o.kind == "FIELDLIST").filter(|_| !self.objects.iter().any(|o| o.kind == "FIELDLIST")) {
+            let (Some(&h), Some(&nod)) = (fresh.get(tree.len()), fresh.get(tree.len() + 1)) else { return };
+            let mut c = list.clone();
+            c.handle = h;
+            for t in &mut c.tags {
+                match t.code {
+                    5 => t.value = h.hex(),
+                    330 => t.value = "0".to_string(),
+                    _ => {}
+                }
+            }
+            if let Some(t) = c.tags.iter_mut().find(|t| t.code == 330) {
+                t.value = nod.hex();
+            }
+            self.targets.insert(nod, ("NOD".to_string(), String::new()));
+            self.dictionary.push(("ACAD_FIELDLIST".to_string(), h));
+            kinds.push(c.kind.clone());
+            self.objects.push(c);
+        }
+        for k in kinds {
+            let named = |c: &Vec<RawTag>| c.iter().any(|t| t.code == 1 && t.value.eq_ignore_ascii_case(&k));
+            if !self.classes.iter().any(named) {
+                self.classes.extend(src.classes.iter().filter(|c| named(c)).cloned());
+            }
+        }
    }
 }
@@ -27,7 +27,7 @@ pub use cadcraft_color as color;
 pub use cadcraft_geom as geom;
 pub use constraint::*;
 pub use entity::*;
-pub use extents::{MAX_BLOCK_DEPTH, entity_bounds, extent_bounds};
+pub use extents::{BlockBoundsCache, MAX_BLOCK_DEPTH, entity_bounds, entity_bounds_cached, extent_bounds, extent_bounds_cached};
 pub use format::Format;
 pub use gdt::*;
 pub use header::{HVal, Header};
@@ -132,6 +132,10 @@ pub struct Drawing {
    /// Records of the file this drawing was read from that the reader could not place (a damaged
    /// file), counted by the section they came from. Never written to a file.
    pub skipped_records: BTreeMap<String, usize>,
+    /// A save option, set on the copy SAVEAS `portableFonts` writes: the file gets Windows fonts
+    /// for the Linux fonts of text styles, and each style keeps its own in CADCraft xdata, so the
+    /// drawing reopens with it. Never set on an open drawing.
+    pub portable_fonts: bool,
 }

 impl Default for Drawing {
@@ -191,6 +195,7 @@ impl Drawing {
            read_notes: Vec::new(),
            refedit: None,
            skipped_records: BTreeMap::new(),
+            portable_fonts: false,
        }
    }

@@ -378,10 +383,13 @@ impl Drawing {
    /// Bounds of the entities in a space that count in its extents ([`Drawing::in_extents`]).
    pub fn extents(&self, space: &Space) -> cadcraft_geom::Bounds2 {
        let mut b = cadcraft_geom::Bounds2::EMPTY;
+        // One block-bounds cache for the whole space: every reference to a block reuses its
+        // measured contents instead of measuring the definition again.
+        let mut cache = BlockBoundsCache::default();
        if let Some(store) = self.space(space) {
            for e in store.iter() {
                if self.in_extents(e) {
-                    b = b.union(&extent_bounds(self, e));
+                    b = b.union(&extent_bounds_cached(self, e, &mut cache));
                }
            }
        }
@@ -189,6 +189,19 @@ impl EntityStore {
            None => false,
        }
    }
+    /// The objects directly under and above `h` in the draw order (None at the bottom or the
+    /// top), when `h` is here.
+    pub fn neighbours(&self, h: Handle) -> Option<(Option<Handle>, Option<Handle>)> {
+        let pos = self.chunk_pos(self.chunk_id(h)?)?;
+        let items = &self.chunks.get(pos)?.items;
+        let i = items.iter().position(|e| e.handle == h)?;
+        let below = match i.checked_sub(1) {
+            Some(j) => items.get(j),
+            None => pos.checked_sub(1).and_then(|p| self.chunks.get(p)).and_then(|c| c.items.last()),
+        };
+        let above = items.get(i + 1).or_else(|| self.chunks.get(pos + 1).and_then(|c| c.items.first()));
+        Some((below.map(|e| e.handle), above.map(|e| e.handle)))
+    }
    /// Move `h` directly above (`above`) or under `anchor` in the draw order. False (and nothing
    /// moves) when either is absent or they are the same object.
    pub fn move_next_to(&mut self, h: Handle, anchor: Handle, above: bool) -> bool {
@@ -364,4 +377,26 @@ mod tests {
            assert_eq!(s.get(Handle(h)).map(|e| e.handle.0), Some(h));
        }
    }
+
+    #[test]
+    fn neighbours_across_chunks() {
+        let mut s = EntityStore::new();
+        for h in 1..=3000 {
+            s.push(ent(h));
+        }
+        assert_eq!(s.neighbours(Handle(1)), Some((None, Some(Handle(2)))));
+        assert_eq!(s.neighbours(Handle(1500)), Some((Some(Handle(1499)), Some(Handle(1501)))));
+        // The first and last objects of a chunk look into the chunks next to it.
+        let k = CHUNK_MAX as u64;
+        assert_eq!(s.neighbours(Handle(k)), Some((Some(Handle(k - 1)), Some(Handle(k + 1)))));
+        assert_eq!(s.neighbours(Handle(k + 1)), Some((Some(Handle(k)), Some(Handle(k + 2)))));
+        assert_eq!(s.neighbours(Handle(3000)), Some((Some(Handle(2999)), None)));
+        assert_eq!(s.neighbours(Handle(9999)), None);
+        assert!(s.move_next_to(Handle(3000), Handle(1), false));
+        assert_eq!(s.neighbours(Handle(1)), Some((Some(Handle(3000)), Some(Handle(2)))));
+        assert_eq!(s.neighbours(Handle(3000)), Some((None, Some(Handle(1)))));
+        let mut one = EntityStore::new();
+        one.push(ent(7));
+        assert_eq!(one.neighbours(Handle(7)), Some((None, None)));
+    }
 }
@@ -799,6 +799,10 @@ pub struct PageSetup {
    /// The layout's paper units are millimetres (plot paper units 1 in DXF) whatever the
    /// drawing's MEASUREMENT says; otherwise paper units follow MEASUREMENT (#1058).
    pub paper_mm: bool,
+    /// The paper image origin (DXF groups 148/149, in plot paper units) as the file had it, so a
+    /// save keeps where the sheet sits; `None` for a page CADCraft made, written as 0,0 (#2109).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image_origin: Option<Vec2>,
 }

 impl Default for PageSetup {
@@ -820,6 +824,7 @@ impl Default for PageSetup {
            show_plot_styles: false,
            plot_transparency: false,
            paper_mm: false,
+            image_origin: None,
        }
    }
 }
@@ -835,11 +840,15 @@ pub struct Layout {
    /// Saved paper-space view (centre, height).
    #[serde(default)]
    pub view: Option<(Vec2, f64)>,
+    /// The layout's limits (LAYOUT groups 10/11, lower left and upper right) as the file had
+    /// them; `None` for a layout CADCraft made, written as 0,0 to 12,9 (#2109).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limits: Option<(Vec2, Vec2)>,
 }

 impl Layout {
    pub fn new(name: &str, tab_order: u32) -> Self {
-        Layout { name: name.into(), tab_order, page: PageSetup::default(), entities: EntityStore::new(), view: None }
+        Layout { name: name.into(), tab_order, page: PageSetup::default(), entities: EntityStore::new(), view: None, limits: None }
    }
 }

@@ -55,6 +55,44 @@ fn frozen_layers_are_left_out_of_extents_and_layers_turned_off_are_not() {
    assert_eq!(d.extents(&Space::Model).max, Vec2::new(1.0, 1.0));
 }

+/// DXF group 12: a dimension moved by an older AutoCAD keeps its `*D` block where it was and
+/// the move in the insertion point, and the block draws translated by it. Extents follow the
+/// drawing, not the stale block contents (#2634).
+#[test]
+fn dimension_insertion_point_moves_its_block_in_extents() {
+    let moved = |ins: Vec3| {
+        let mut d = Drawing::new_metric();
+        let mut blk = Block::new("*D1");
+        blk.entities.push(on_layer("0", line((850.0, 920.0), (860.0, 920.0)), 2));
+        d.blocks.insert("*D1".into(), std::sync::Arc::new(blk));
+        let dm = Dimension {
+            kind: DimKind::Aligned,
+            defpt: Vec3::new(5.0, 1.0, 0.0),
+            text_mid: Vec3::ZERO,
+            p13: Vec3::ZERO,
+            p14: Vec3::new(10.0, 0.0, 0.0),
+            p15: Vec3::ZERO,
+            p16: Vec3::ZERO,
+            text: String::new(),
+            style: "Standard".into(),
+            measurement: 0.0,
+            text_rotation: 0.0,
+            user_text_pos: false,
+            block: Some("*D1".into()),
+            insertion_point: ins,
+            overrides: Default::default(),
+            assoc: Vec::new(),
+            marks: Default::default(),
+        };
+        d.add(&Space::Model, Common::default(), EntityKind::Dimension(dm)).unwrap();
+        d
+    };
+    // Without the offset the block's far-away contents reach the extents.
+    assert!(moved(Vec3::ZERO).extents(&Space::Model).max.x > 800.0);
+    // With it, the block draws at the definition points and the extents stay at the drawing.
+    assert!(moved(Vec3::new(-850.0, -920.0, 0.0)).extents(&Space::Model).max.x < 20.0);
+}
+
 /// ZOOM Extents in AutoCAD 2024 (accoreconsole, EXTMIN/EXTMAX read back; AutoCAD pads them by a
 /// few hundredths): a layer turned off counts and a frozen one does not, for an entity, for an
 /// entity inside a block, and for a block reference itself.
@@ -637,6 +675,7 @@ fn invisible_dimblock_entity_is_ignored_in_dimension_extents() {
                overrides: Default::default(),
                assoc: vec![],
                marks: Default::default(),
+                insertion_point: Vec3::ZERO,
            }),
        )
        .unwrap();
@@ -0,0 +1,19 @@
+//! A 3D face draws only its visible edges: `hidden_edges` bit i hides the side from corner i to
+//! the next, as DXF group 70 defines it, and a triangle's zero-length side isn't drawn.
+
+use cadcraft_doc::{EntityKind, Face3d, Prim};
+use cadcraft_geom::Vec3;
+
+fn sides(f: Face3d) -> usize {
+    EntityKind::Face3d(f).prims().iter().filter(|p| matches!(p, Prim::Seg(_))).count()
+}
+
+#[test]
+fn hidden_edges_are_not_drawn() {
+    let quad = [Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 0.0, 0.0), Vec3::new(1.0, 1.0, 0.0), Vec3::new(0.0, 1.0, 0.0)];
+    assert_eq!(sides(Face3d { corners: quad, hidden_edges: 0 }), 4);
+    assert_eq!(sides(Face3d { corners: quad, hidden_edges: 1 | 4 }), 2);
+    assert_eq!(sides(Face3d { corners: quad, hidden_edges: 15 }), 0);
+    let triangle = [quad[0], quad[1], quad[2], quad[2]];
+    assert_eq!(sides(Face3d { corners: triangle, hidden_edges: 0 }), 3);
+}
@@ -1,2 +1,3 @@
+mod face3d_hidden_edges;
 mod lin_pat_parse;
 mod sub_segment_alias;
@@ -13,4 +13,4 @@ workspace = true
 # 0.6.7 and 0.6.8 fix that but read some damaged DWGs as empty with no note (tests.rs, #800).
 [target.'cfg(not(any(target_arch = "wasm32", all(target_os = "freebsd", target_arch = "aarch64"))))'.dependencies]
 # MPL-2.0: used as an unmodified dependency only (see plan/adr/0001 and NOTICE).
-acadrust = "0.6.5"
+acadrust = "0.6.6"
@@ -110,8 +110,11 @@ mod native {
            notes.push(format!("DWG: {orphans} DGN line style component{s} that no line style definition uses {were} left out"));
        }
        let mut out = CappedWriter { buf: Vec::new(), limit: limits.max_dxf_bytes, exceeded: false };
-        let written = std::panic::catch_unwind(AssertUnwindSafe(|| acadrust::DxfWriter::new(&doc).write_to_writer(&mut out)))
-            .map_err(|_| "the DWG→DXF conversion failed on this file".to_string())?;
+        let written = std::panic::catch_unwind(AssertUnwindSafe(|| {
+            acadrust::DxfWriter::new(&doc).write_to_writer(&mut out)?;
+            mtext_contents(&doc, &mut out)
+        }))
+        .map_err(|_| "the DWG→DXF conversion failed on this file".to_string())?;
        if out.exceeded {
            return Err(format!(
                "DWG: converting this {} file produced more than {} of drawing data (the limit); \
@@ -124,6 +127,94 @@ mod native {
        Ok((add_header_vars(out.buf, &doc.header), notes))
    }

+    /// acadrust 0.6.6's ASCII writer treats a caret followed by a literal space as already
+    /// escaped, and turns line feeds into paragraph codes. Serialize affected MTEXT contents
+    /// from the native values instead, using its lossless string writer. All other groups,
+    /// including embedded-object data, remain byte-for-byte as the DXF writer emitted them.
+    fn mtext_contents(doc: &acadrust::CadDocument, out: &mut CappedWriter) -> acadrust::Result<()> {
+        use acadrust::io::dxf::{DxfStreamWriter, DxfTextWriter};
+        let contents: std::collections::HashMap<_, _> = doc
+            .entities()
+            .filter_map(|e| match e {
+                acadrust::EntityType::MText(t) if t.value.contains(['^', '\t', '\n']) => Some((t.common.handle.value(), t.value.as_str())),
+                _ => None,
+            })
+            .collect();
+        if contents.is_empty() {
+            return Ok(());
+        }
+        let dxf = std::mem::take(&mut out.buf);
+        let mut lines = dxf.split_inclusive(|b| *b == b'\n');
+        let (mut mtext, mut text, mut written) = (false, None, false);
+        while let Some(code) = lines.next() {
+            let value = lines.next().ok_or_else(|| std::io::Error::other("incomplete DWG bridge DXF pair"))?;
+            match code.trim_ascii() {
+                b"0" => {
+                    mtext = value.trim_ascii() == b"MTEXT";
+                    text = None;
+                    written = false;
+                }
+                b"5" if mtext => {
+                    text = std::str::from_utf8(value.trim_ascii()).ok().and_then(|s| u64::from_str_radix(s, 16).ok()).and_then(|h| contents.get(&h));
+                }
+                b"101" => mtext = false,
+                b"1" | b"3" if mtext && text.is_some() => {
+                    if let Some(&text) = text
+                        && !written
+                    {
+                        let mut writer = DxfTextWriter::new(&mut *out);
+                        if doc.version < acadrust::DxfVersion::AC1021
+                            && let Some(encoding) = acadrust::io::dxf::code_page::encoding_from_code_page(&doc.header.code_page)
+                        {
+                            writer.set_encoding(encoding);
+                        }
+                        // Each character can expand to two caret-escape characters. Keep
+                        // those pairs together and each group within 250 characters.
+                        let mut rest = text;
+                        while let Some((end, _)) = rest.char_indices().nth(125) {
+                            let (chunk, tail) = rest.split_at(end);
+                            writer.write_xrecord_string(3, chunk)?;
+                            rest = tail;
+                        }
+                        writer.write_xrecord_string(1, rest)?;
+                        written = true;
+                    }
+                    continue;
+                }
+                _ => {}
+            }
+            out.write_all(code)?;
+            out.write_all(value)?;
+        }
+        Ok(())
+    }
+
+    #[cfg(test)]
+    #[test]
+    fn mtext_contents_keeps_other_groups_and_the_output_limit() -> acadrust::Result<()> {
+        for version in [acadrust::DxfVersion::AC1015, acadrust::DxfVersion::AC1032] {
+            let mut doc = acadrust::CadDocument::new();
+            doc.version = version;
+            doc.header.code_page = "ANSI_1252".into();
+            let mut t = acadrust::MText::with_value("é ^ C", acadrust::Vector3::ZERO);
+            t.common.handle = acadrust::Handle::new(0x10);
+            doc.add_entity(acadrust::EntityType::MText(Box::new(t)))?;
+            // Only the MTEXT's own 1/3 groups change. The embedded object's groups and the
+            // following TEXT record must survive byte-for-byte, including their spaces.
+            let prefix = b"  0\r\nMTEXT\r\n  5\r\n10\r\n  8\r\n0\r\n";
+            let suffix = b"101\r\nEmbedded Object\r\n  1\r\n^ embedded\r\n  3\r\n^ tail\r\n  0\r\nTEXT\r\n  1\r\n^ plain\r\n";
+            let raw = [prefix.as_slice(), b"  3\r\nold\r\n  1\r\ntext\r\n", suffix.as_slice()].concat();
+            let mut out = CappedWriter { buf: raw.clone(), limit: 4096, exceeded: false };
+            mtext_contents(&doc, &mut out)?;
+            let value: &[u8] = if version == acadrust::DxfVersion::AC1015 { b"\xe9 ^  C" } else { "é ^  C".as_bytes() };
+            assert_eq!(out.buf, [prefix.as_slice(), b"  1\r\n", value, b"\r\n", suffix.as_slice()].concat());
+            let mut limited = CappedWriter { buf: raw, limit: 1, exceeded: false };
+            assert!(mtext_contents(&doc, &mut limited).is_err());
+            assert!(limited.exceeded);
+        }
+        Ok(())
+    }
+
    /// Most record types named in the skipped-records note.
    const NOTE_TYPES: usize = 6;

@@ -241,12 +332,51 @@ mod native {
    /// can cover rows × cols cells, so the total is bounded too.
    const MAX_MERGE_CELLS: usize = 1 << 24;

+    /// A table cell's own text height only when the file says it overrides the table style's.
+    /// acadrust's DXF writer writes a cell style's height (group 140) whenever the cell has a
+    /// style record, even a default 0.18 with no override flag, and CADCraft reads a 140 as an
+    /// override (#2501). The override is the cell style's TEXT_HEIGHT property flag or the
+    /// content's format override bit 128; without either the height is cleared (0 is no
+    /// override), so the table style's height applies.
+    fn table_cell_heights(doc: &mut acadrust::CadDocument) {
+        use acadrust::entities::table::CellStylePropertyFlags;
+        const CONTENT_TEXT_HEIGHT: i32 = 128;
+        for e in doc.entities_mut() {
+            let acadrust::entities::EntityType::Table(t) = e else { continue };
+            for cell in t.rows.iter_mut().flat_map(|r| r.cells.iter_mut()) {
+                // The first content's own height (group 144) when its format override sets bit 128.
+                // CADCraft keeps one height for the cell's text, so a later content's override
+                // must not stand in for the first content's.
+                let content_height = cell
+                    .contents
+                    .first()
+                    .filter(|c| c.format_override_flags & CONTENT_TEXT_HEIGHT != 0)
+                    .map(|c| c.text_height)
+                    .filter(|h| h.is_finite() && *h > 0.0);
+                if let Some(h) = content_height {
+                    // CADCraft reads only the style's height (group 140), so carry it there.
+                    cell.style.get_or_insert_with(acadrust::entities::table::CellStyle::new).text_height = h;
+                    continue;
+                }
+                // A style overrides through its property flags or, in newer files, its override
+                // flags; anything else is the writer's default and is cleared.
+                if let Some(style) = cell.style.as_mut()
+                    && !style.property_flags.contains(CellStylePropertyFlags::TEXT_HEIGHT)
+                    && style.override_flags & CellStylePropertyFlags::TEXT_HEIGHT.bits() as i32 == 0
+                {
+                    style.text_height = 0.0;
+                }
+            }
+        }
+    }
+
    /// The fix-ups made to a document after the DWG read, returning how many orphaned DGN
    /// components were dropped. The document comes from a third-party reader and is hostile.
    fn post_process(doc: &mut acadrust::CadDocument) -> usize {
        super::fail_in_test("post_process");
        current_style_names(doc);
        table_merges(doc);
+        table_cell_heights(doc);
        table_style_rows(doc, false);
        keep_sort_handles(doc);
        drop_orphaned_dgn_components(doc)
@@ -344,7 +474,7 @@ mod native {
    /// The DWG dimension flags byte. Its bit 1 is DXF group 70's bit 32 (ODA DWG specification,
    /// common dimension data), which acadrust keeps no copy of from DXF: it is set here as
    /// CADCraft's DXF writer always sets it (#1094). Bit 0, the opposite of group 70's bit 128,
-    /// acadrust 0.6.5 reads and writes itself.
+    /// acadrust 0.6.6 reads and writes itself.
    fn dimension_flags(doc: &mut acadrust::CadDocument) {
        for e in doc.entities_mut() {
            let acadrust::entities::EntityType::Dimension(d) = e else { continue };
@@ -730,6 +860,34 @@ mod native {
            assert_eq!(table_merges_within(&mut doc, usize::MAX), 100);
        }

+        /// A height marked only in the style's override flags (as newer files store it) is kept,
+        /// and the same height with no flag at all is cleared (review on #2588). Tested on the
+        /// read document because acadrust's DWG writer doesn't write the override flags.
+        #[test]
+        fn a_style_override_flag_keeps_the_cell_height() {
+            use acadrust::entities::table::{CellStyle, CellStylePropertyFlags};
+            let height = |override_flags: i32| {
+                let mut doc = doc_with_table(1, 1, 0);
+                for e in doc.entities_mut() {
+                    if let EntityType::Table(t) = e {
+                        for cell in t.rows.iter_mut().flat_map(|r| r.cells.iter_mut()) {
+                            let mut s = CellStyle::new();
+                            s.text_height = 0.5;
+                            s.override_flags = override_flags;
+                            cell.style = Some(s);
+                        }
+                    }
+                }
+                table_cell_heights(&mut doc);
+                doc.entities().find_map(|e| match e {
+                    EntityType::Table(t) => t.rows.first()?.cells.first()?.style.as_ref().map(|s| s.text_height),
+                    _ => None,
+                })
+            };
+            assert_eq!(height(CellStylePropertyFlags::TEXT_HEIGHT.bits() as i32), Some(0.5));
+            assert_eq!(height(0), Some(0.0));
+        }
+
        /// A panic in the post-read fix-ups is an error, not a crash (#1934).
        #[test]
        fn a_panic_in_post_processing_is_an_error() {
@@ -1076,4 +1234,51 @@ mod tests {
        assert!(ls.contains(&"LSDEFINITION") && !ls.contains(&"LSINTERNALCOMPONENT"), "{ls:?}");
        assert_eq!(notes, ["DWG: 3 DGN line style components that no line style definition uses were left out"]);
    }
+
+    /// AutoCAD's DWG scale action (BLOCKSCALEACTION) ends with a byte after its three
+    /// connections that DXF doesn't carry. acadrust 0.6.4 neither read nor wrote it, so AutoCAD
+    /// read past the object and refused every DWG CADCraft wrote with a dynamic block that scales
+    /// ("Error Decrypting Data"); 0.6.5 added it and 0.6.6, which this uses, still keeps it (0.6.6 also
+    /// fixes multi-layout DWGs, #1463). The byte reaches the DWG, and a scale action
+    /// from DXF is written whole, with the byte AutoCAD writes (0).
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn scale_actions_keep_the_byte_autocad_reads_after_their_connections() {
+        use acadrust::objects::*;
+        let scale_action = |doc: &acadrust::CadDocument| {
+            doc.objects.values().find_map(|o| match o {
+                ObjectType::DynamicBlock(DynamicBlockObject { data: DynamicBlockData::ScaleAction(s), .. }) => Some(s.clone()),
+                _ => None,
+            })
+        };
+        let mut doc = acadrust::CadDocument::new();
+        let h = doc.allocate_handle();
+        let conn = |code, name: &str| BlockConnection { code, name: name.into() };
+        let mut action = DynamicBlockObject::new("BLOCKSCALEACTION", "AcDbBlockScaleAction");
+        action.handle = h;
+        action.owner = doc.header.named_objects_dict_handle;
+        let mut a = BlockBasePointAction::default();
+        a.action.action.element.name = "Scale".into();
+        a.action.connections = vec![conn(2, "UpdatedBaseX"), conn(2, "UpdatedBaseY")];
+        a.action.dependent = true;
+        a.connections = vec![conn(2, "Scale"), conn(2, "XScale"), conn(2, "YScale")];
+        a.dwg_tail_byte = 7;
+        action.data = DynamicBlockData::ScaleAction(a.clone());
+        doc.objects.insert(h, ObjectType::DynamicBlock(action));
+
+        let dwg = acadrust::DwgWriter::write_to_vec(&doc).unwrap();
+        let back = acadrust::DwgReader::from_stream(std::io::Cursor::new(dwg)).read().unwrap();
+        assert_eq!(scale_action(&back).map(|s| s.dwg_tail_byte), Some(7), "the byte isn't written");
+
+        let mut dxf = Vec::new();
+        acadrust::DxfWriter::new(&doc).write_to_writer(&mut dxf).unwrap();
+        for version in ["AC1018", "AC1032"] {
+            let dwg = dxf_to_dwg_as(&dxf, version).unwrap();
+            let back = acadrust::DwgReader::from_stream(std::io::Cursor::new(dwg)).read().unwrap();
+            let read = scale_action(&back).unwrap_or_else(|| panic!("{version}: the scale action wasn't written"));
+            assert_eq!(read.connections, a.connections, "{version}");
+            assert_eq!(read.action.connections, a.action.connections, "{version}");
+            assert_eq!(read.dwg_tail_byte, 0, "{version}");
+        }
+    }
 }
@@ -42,6 +42,27 @@ pub fn write_atomic(path: &Path, bytes: &[u8]) -> io::Result<()> {
    write_atomic_with(path, permissions, |file| file.write_all(bytes))
 }

+/// The topmost folder missing above `path`: what [`write_atomic_making_folders`] will create.
+/// `None` when the file's folder exists, or when `path` itself exists (a dangling symlink's target
+/// folder is not ours to make).
+pub fn missing_folder(path: &Path) -> Option<PathBuf> {
+    if std::fs::symlink_metadata(path).is_ok() {
+        return None;
+    }
+    path.ancestors().skip(1).filter(|a| !a.as_os_str().is_empty()).take_while(|a| std::fs::symlink_metadata(a).is_err()).last().map(Path::to_path_buf)
+}
+
+/// [`write_atomic`] to a path the user named, first creating the folders missing above it: a
+/// mistyped folder costs less than a drawing that could not be written. The caller reports
+/// [`missing_folder`], asked before this call, so the new folder is never a surprise.
+pub fn write_atomic_making_folders(path: &Path, bytes: &[u8]) -> io::Result<()> {
+    if let Some(folder) = missing_folder(path) {
+        let dir = path.parent().unwrap_or(&folder);
+        std::fs::create_dir_all(dir).map_err(|e| io::Error::new(e.kind(), format!("the folder {} could not be created: {e}", dir.display())))?;
+    }
+    write_atomic(path, bytes)
+}
+
 /// [`write_atomic`] filling the temporary file through `fill` (streamed rather than one buffer),
 /// with `permissions` given to it from its creation (`None`: the usual creation mode). A symlink
 /// at `path` is replaced by the new file, never written through.
@@ -159,6 +180,30 @@ fn create_exclusive(path: &Path, permissions: Option<&Permissions>) -> io::Resul
 mod tests {
    use super::*;

+    #[test]
+    fn creates_missing_parent_directories() {
+        let dir = std::env::temp_dir().join(format!("cadcraft-aw-mkdir-{}-{}", std::process::id(), SEQ.fetch_add(1, Ordering::Relaxed)));
+        let dest = dir.join("new_folder").join("deeper").join("out.bin");
+        std::fs::create_dir_all(&dir).unwrap();
+        assert_eq!(missing_folder(&dest), Some(dir.join("new_folder")));
+        assert!(write_atomic(&dest, b"created").is_err(), "the plain writer never makes folders");
+        write_atomic_making_folders(&dest, b"created").unwrap();
+        assert_eq!(std::fs::read(&dest).unwrap(), b"created");
+        assert_eq!(missing_folder(&dest), None);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn a_folder_that_cannot_be_made_is_named_in_the_error() {
+        let dir = std::env::temp_dir().join(format!("cadcraft-aw-nomk-{}-{}", std::process::id(), SEQ.fetch_add(1, Ordering::Relaxed)));
+        std::fs::create_dir_all(&dir).unwrap();
+        let blocker = dir.join("a_file");
+        std::fs::write(&blocker, b"x").unwrap();
+        let e = write_atomic_making_folders(&blocker.join("sub").join("out.bin"), b"new").unwrap_err();
+        assert!(e.to_string().contains("could not be created"), "{e}");
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
    #[test]
    fn replaces_contents_atomically() {
        let dir = std::env::temp_dir().join(format!("cadcraft-aw-{}-{}", std::process::id(), SEQ.fetch_add(1, Ordering::Relaxed)));
@@ -259,6 +304,8 @@ mod tests {
        let link = dir.join("link.dxf");
        symlink("missing/real.dxf", &link).unwrap();
        assert!(write_atomic(&link, b"new").is_err());
+        assert!(write_atomic_making_folders(&link, b"new").is_err());
+        assert!(!dir.join("missing").exists(), "a link's unavailable target folder must not be created");
        assert!(std::fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
        std::fs::remove_dir_all(dir).unwrap();
    }
@@ -4,15 +4,18 @@
 //! autosave is written as DXF to `<SAVEFILEPATH>/<drawing>_<instance>_<uid>.sv$`. The file goes
 //! away when the drawing is saved or closed and when the app exits normally, so a file left behind
 //! means the app (or the machine) went down; the next start offers it for recovery. A running app
-//! keeps a lock file (`<instance>.lock`) fresh, so another copy running at the same time doesn't
-//! offer its files. SAVEFILEPATH may be a folder other programs use too, so only names built from
-//! an instance id ([`is_instance_id`]) are ever read as ours or deleted.
+//! holds an operating-system lock on its lock file (`<instance>.lock`) and keeps the file fresh, so
+//! another copy running at the same time doesn't offer its files. The system drops the lock the
+//! moment a process ends, however it ended, so a relaunch after a crash can offer recovery at once.
+//! Where locks aren't available, and for lock files of older versions, a file not refreshed for
+//! [`STALE_LOCK_SECS`] counts as stopped. SAVEFILEPATH may be a folder other programs use too, so
+//! only names built from an instance id ([`is_instance_id`]) are ever read as ours or deleted.
 //!
 //! [`Autosaver::plan`] decides what to write and delete (no I/O, so it is testable); on the desktop
 //! [`Autosaver::tick`] carries it out, writing on a background thread. SAVETIME and SAVEFILEPATH
 //! are profile settings: process-wide, not saved in the drawing.

-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{Arc, Mutex, Weak};

@@ -29,6 +32,10 @@ pub const DEFAULT_SAVETIME: u32 = 10;
 pub const MAX_SAVETIME: u32 = 600;
 /// A lock file not refreshed for this long belongs to an app that is no longer running.
 pub const STALE_LOCK_SECS: u64 = 5 * 60;
+/// How a lock file ends when its app holds the system lock on it, so a free lock proves the app
+/// stopped. Older versions write only the process id and never hold one.
+#[cfg(not(target_arch = "wasm32"))]
+const LOCK_HELD: &str = " held";
 /// How often a running app refreshes its lock file.
 #[cfg(not(target_arch = "wasm32"))]
 const HEARTBEAT_SECS: f64 = 60.0;
@@ -149,13 +156,19 @@ pub struct Autosaver {
    docs: HashMap<u64, Tracked>,
    /// Drawings whose autosave is being written right now.
    busy: HashSet<u64>,
-    /// Writes in progress; each tells whether its file was written.
+    /// Why the last autosave of each drawing failed, until one succeeds or the drawing no longer
+    /// needs it. Ordered, so [`Autosaver::failure`] doesn't change between frames.
+    failed: BTreeMap<u64, String>,
+    /// Writes in progress; each ends with why its file wasn't written, if it wasn't.
    #[cfg(not(target_arch = "wasm32"))]
-    running: Vec<(u64, std::thread::JoinHandle<bool>)>,
+    running: Vec<(u64, std::thread::JoinHandle<std::result::Result<(), String>>)>,
    #[cfg(not(target_arch = "wasm32"))]
    start: std::time::Instant,
    #[cfg(not(target_arch = "wasm32"))]
    last_beat: Option<f64>,
+    /// The lock file this app holds the system lock on, open for as long as the lock is wanted.
+    #[cfg(not(target_arch = "wasm32"))]
+    lock: Option<(std::path::PathBuf, std::fs::File)>,
 }

 impl Autosaver {
@@ -164,12 +177,15 @@ impl Autosaver {
            instance: instance.into(),
            docs: HashMap::new(),
            busy: HashSet::new(),
+            failed: BTreeMap::new(),
            #[cfg(not(target_arch = "wasm32"))]
            running: Vec::new(),
            #[cfg(not(target_arch = "wasm32"))]
            start: std::time::Instant::now(),
            #[cfg(not(target_arch = "wasm32"))]
            last_beat: None,
+            #[cfg(not(target_arch = "wasm32"))]
+            lock: None,
        }
    }

@@ -187,6 +203,11 @@ impl Autosaver {
        self.docs.values().filter_map(|t| t.file.clone()).collect()
    }

+    /// Why a drawing currently has no up-to-date recovery copy, for the host to show the user.
+    pub fn failure(&self) -> Option<&str> {
+        self.failed.values().next().map(String::as_str)
+    }
+
    /// What to do at `now` (seconds, any fixed origin) with SAVETIME `minutes` and autosave folder
    /// `dir`: write drawings changed `minutes` ago or earlier and not autosaved since, delete the
    /// files of drawings that were saved (no unsaved changes left) or closed.
@@ -220,6 +241,7 @@ impl Autosaver {
                    jobs.push(Job::Delete { path });
                }
                *t = Tracked::default();
+                self.failed.remove(&st.uid);
                continue;
            }
            let same = |w: &Option<Weak<Drawing>>, d: &Arc<Drawing>| w.as_ref().is_some_and(|w| std::ptr::eq(w.as_ptr(), Arc::as_ptr(d)));
@@ -248,6 +270,8 @@ impl Autosaver {
            t.since = None;
            jobs.push(Job::Write { uid: st.uid, path, doc });
        }
+        let docs = &self.docs;
+        self.failed.retain(|uid, _| docs.contains_key(uid));
        jobs
    }

@@ -277,12 +301,14 @@ pub use native::*;

 #[cfg(not(target_arch = "wasm32"))]
 mod native {
+    use std::fs::{File, OpenOptions, TryLockError};
+    use std::io::{Read, Write};
    use std::path::Path;
    use std::time::{Duration, SystemTime};

    use super::{
-        Autosaver, Drawing, HEARTBEAT_SECS, HashMap, Job, Recoverable, STALE_LOCK_SECS, Session, is_instance_id, parse_file_name, parse_lock_name,
-        savefilepath, savetime,
+        Autosaver, Drawing, HEARTBEAT_SECS, HashMap, Job, LOCK_HELD, Recoverable, STALE_LOCK_SECS, Session, is_instance_id, parse_file_name,
+        parse_lock_name, savefilepath, savetime,
    };

    /// A new instance id: the process id and the start time.
@@ -307,6 +333,28 @@ mod native {
        Some(SystemTime::now().duration_since(m).unwrap_or_default())
    }

+    /// Whether the app instance named by a lock file in `dir` may still be running: its system
+    /// lock answers at once, and the file's age decides when it can't (no lock support, a lock
+    /// file from an older version).
+    fn owner_alive(dir: &Path, instance: &str) -> bool {
+        let by_age = || instance_alive(lock_age(dir, instance));
+        let path = lock_path(dir, instance);
+        // Only a plain file is opened: opening a FIFO planted in a shared folder would block.
+        if !std::fs::symlink_metadata(&path).is_ok_and(|m| m.is_file()) {
+            return by_age();
+        }
+        let Ok(file) = File::open(&path) else { return by_age() };
+        match file.try_lock() {
+            Err(TryLockError::WouldBlock) => true,
+            Err(TryLockError::Error(_)) => by_age(),
+            Ok(()) => {
+                let mut text = String::new();
+                let held = file.take(64).read_to_string(&mut text).is_ok() && text.ends_with(LOCK_HELD);
+                !held && by_age()
+            }
+        }
+    }
+
    /// The autosave files in `dir` left behind by apps that are no longer running (never those of
    /// `own`, this app's instance), oldest first.
    pub fn recoverable(dir: &Path, own: &str) -> Vec<Recoverable> {
@@ -316,7 +364,7 @@ mod native {
        for e in entries.flatten().take(10_000) {
            let name = e.file_name().to_string_lossy().to_string();
            let Some((title, instance, _)) = parse_file_name(&name) else { continue };
-            if instance == own || *alive.entry(instance.to_string()).or_insert_with(|| instance_alive(lock_age(dir, instance))) {
+            if instance == own || *alive.entry(instance.to_string()).or_insert_with(|| owner_alive(dir, instance)) {
                continue;
            }
            let Ok(meta) = e.metadata() else { continue };
@@ -358,7 +406,7 @@ mod native {
        for n in &names {
            let Some(instance) = parse_lock_name(n) else { continue };
            let has_files = names.iter().any(|f| parse_file_name(f).is_some_and(|(_, i, _)| i == instance));
-            if !has_files && !instance_alive(lock_age(dir, instance)) {
+            if !has_files && !owner_alive(dir, instance) {
                let _ = std::fs::remove_file(dir.join(n));
            }
        }
@@ -416,24 +464,36 @@ mod native {
            writes
        }

+        /// Whether a background write hasn't finished yet. Its file can exist before it finishes
+        /// (the folder is synced after the rename), and until [`Autosaver::reap`] takes it in, the
+        /// drawing is left out of planning.
+        pub fn writing(&self) -> bool {
+            self.running.iter().any(|(_, h)| !h.is_finished())
+        }
+
        /// Take in the writes that have finished ([`Autosaver::tick`] does this first). A drawing
        /// whose write failed is no longer counted as autosaved: the next plan restarts its clock,
-        /// so it is tried again SAVETIME later even if it doesn't change.
+        /// so it is tried again SAVETIME later even if it doesn't change, and [`Autosaver::failure`]
+        /// says why until a write succeeds.
        pub fn reap(&mut self) {
            let (done, running) = std::mem::take(&mut self.running).into_iter().partition::<Vec<_>, _>(|(_, h)| h.is_finished());
            self.running = running;
            for (uid, h) in done {
                self.busy.remove(&uid);
-                if !h.join().unwrap_or(false) {
-                    self.unwritten(uid);
+                match h.join().unwrap_or_else(|_| Err("the autosave writer stopped unexpectedly".to_string())) {
+                    Ok(()) => {
+                        self.failed.remove(&uid);
+                    }
+                    Err(e) => self.unwritten(uid, e),
                }
            }
        }

-        fn unwritten(&mut self, uid: u64) {
+        fn unwritten(&mut self, uid: u64, why: String) {
            if let Some(t) = self.docs.get_mut(&uid) {
                t.written = None;
            }
+            self.failed.insert(uid, why);
        }

        /// Carry out jobs from [`Autosaver::plan`]: writes on a background thread, deletes now.
@@ -444,16 +504,17 @@ mod native {
                    Job::Write { uid, path, doc } => {
                        let Some(write) = crate::cmd::file::io().map(|h| h.write) else {
                            log::warn!("autosave: file formats are not available in this build");
+                            self.unwritten(uid, "file formats are not available in this build".to_string());
                            continue;
                        };
                        let spawned = std::thread::Builder::new().name("autosave".into()).spawn(move || match write_file(write, &doc, &path) {
                            Ok(()) => {
                                log::info!("autosaved {path}");
-                                true
+                                Ok(())
                            }
                            Err(e) => {
                                log::warn!("autosave {path}: {e}");
-                                false
+                                Err(format!("{path}: {e}"))
                            }
                        });
                        match spawned {
@@ -463,7 +524,7 @@ mod native {
                            }
                            Err(e) => {
                                log::warn!("autosave: {e}");
-                                self.unwritten(uid);
+                                self.unwritten(uid, e.to_string());
                            }
                        }
                    }
@@ -478,12 +539,31 @@ mod native {
            }
            self.last_beat = Some(now);
            let dir = Path::new(dir);
-            let r = create_folder(dir).and_then(|()| std::fs::write(lock_path(dir, &self.instance), std::process::id().to_string()));
-            if let Err(e) = r {
+            if let Err(e) = create_folder(dir).and_then(|()| self.refresh_lock(&lock_path(dir, &self.instance))) {
                log::warn!("autosave: lock file in {}: {e}", dir.display());
            }
        }

+        /// Refresh the lock file at `path`, taking the system lock on it first if this app doesn't
+        /// hold it there yet. Without one the file still works by its age.
+        fn refresh_lock(&mut self, path: &Path) -> std::io::Result<()> {
+            if let Some((held, file)) = &self.lock
+                && held == path
+            {
+                return file.set_modified(SystemTime::now());
+            }
+            self.lock = None;
+            let id = std::process::id();
+            let mut file = OpenOptions::new().write(true).create(true).truncate(false).open(path)?;
+            if file.try_lock().is_err() {
+                return std::fs::write(path, id.to_string());
+            }
+            file.set_len(0)?;
+            file.write_all(format!("{id}{LOCK_HELD}").as_bytes())?;
+            self.lock = Some((path.to_path_buf(), file));
+            Ok(())
+        }
+
        /// The app is closing normally: finish writes in progress, then delete this app's autosave
        /// files and its lock file.
        pub fn shutdown(&mut self) {
@@ -495,6 +575,7 @@ mod native {
                discard(&path);
            }
            self.docs.clear();
+            self.lock = None;
            let dir = savefilepath();
            if !dir.is_empty() && is_instance_id(&self.instance) {
                let _ = std::fs::remove_file(lock_path(Path::new(&dir), &self.instance));
@@ -268,11 +268,12 @@ impl DocState {
    }

    /// Start editing in the Block Editor `be` (the drawing is already the editor's): a fresh
-    /// undo history, nothing selected, model space.
+    /// undo history, nothing selected, nothing for OOPS, model space.
    fn enter_block_editor(&mut self, be: BlockEdit) {
        self.undo.clear();
        self.redo.clear();
        self.undo_ctl = Default::default();
+        self.erased = Default::default();
        self.selection.clear();
        self.previous_selection.clear();
        self.space = cadcraft_doc::Space::Model;
@@ -338,6 +339,7 @@ impl DocState {
        self.undo = host.undo;
        self.redo = host.redo;
        self.undo_ctl = host.undo_ctl;
+        self.erased = host.erased;
        // The drawing comes back with nothing selected; Previous is what was selected before.
        self.selection.clear();
        self.previous_selection = if host.selection.is_empty() { host.previous_selection } else { host.selection };
@@ -25,6 +25,7 @@ mod lisp;
 mod mleader_content;
 mod mleader_edit;
 mod modify;
+pub(crate) use modify::Erased;
 mod modify2;
 mod mtext_opts;
 mod overkill;
@@ -16,6 +16,7 @@ use crate::{Accept, EngineError, Input, Interactive, LeaderOrder, MLeaderOptions
 mod angular;
 mod common;
 mod edit;
+mod leader;
 mod linear;
 mod mleader;
 mod radial;
@@ -88,7 +89,10 @@ pub fn specs() -> Vec<CommandSpec> {
            .alias(&["mld"])
            .params("{points: [[arrow], ..., [landing]] ([location] with leaderType none), text?, leaderType?: straight|spline|none, block?: name, blockAttach?: center|insertion}")
            .interactive(|s| Ok(Box::new(MLeaderM::new(s)))),
-        CommandSpec::new("leader", "Leader", run_leader).alias(&["lead"]).params("{points: [[x,y]...], text?}"),
+        CommandSpec::new("leader", "Leader", run_leader)
+            .alias(&["lead"])
+            .params("{points: [[x,y]...], text?}")
+            .interactive(|_| Ok(Box::new(leader::LeaderM::default()))),
        CommandSpec::new("dimstyle.update", "Update", run_update)
            .menu(&["Dimension", "Update"])
            .params("{handles?}")
@@ -22,6 +22,7 @@ pub(super) fn dim(s: &Session, kind: DimKind, defpt: Vec2, p13: Vec2, p14: Vec2,
        overrides: s.doc().map(|d| d.dim_overrides()).unwrap_or_default(),
        assoc: Vec::new(),
        marks: Default::default(),
+        insertion_point: Vec3::ZERO,
    })
 }

@@ -0,0 +1,330 @@
+//! LEADER at the command line, as AutoCAD 2024 runs it (accoreconsole, synthetic drawings): the
+//! points, Format and Undo, then annotation text, no annotation, or a block.
+//!
+//! The leader takes a hook line, a horizontal last segment DIMASZ long, when its last segment is
+//! straight and more than 15° off horizontal and text follows it; the text sits DIMGAP past the
+//! leader's end, above it (DIMTAD on) or centred on it (DIMTAD 0), on the side the leader runs to.
+//! All sizes are scaled by DIMSCALE. The text and the leader are separate objects here: the
+//! drawing model has no link from a leader to its annotation.
+
+use super::common::style;
+use super::{Accept, EntityKind, Handle, Input, Interactive, MText, Prompt, Result, Session, Step, Vec2, v3};
+use crate::cmd::curves::KW;
+
+/// Where LEADER is in its prompts.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+enum Ask {
+    #[default]
+    Points,
+    Format,
+    FirstLine,
+    NextLine,
+    Option,
+    /// Copy: the text or multiline text to copy.
+    Copy,
+    BlockName,
+    BlockPoint,
+    BlockX,
+    BlockY,
+    BlockRotation,
+}
+
+#[derive(Default)]
+pub(super) struct LeaderM {
+    ask: Ask,
+    pts: Vec<Vec2>,
+    spline: bool,
+    no_arrow: bool,
+    lines: Vec<String>,
+    block: String,
+    block_at: Vec2,
+    block_scale: Vec2,
+}
+
+/// What follows the leader.
+enum Annotation {
+    Text(Vec<String>),
+    /// A copy of a text or multiline text: its contents, height, width and style.
+    Copy(MText),
+    None,
+    Block {
+        name: String,
+        at: Vec2,
+        scale: Vec2,
+        rotation: f64,
+    },
+}
+
+impl Interactive for LeaderM {
+    fn name(&self) -> &'static str {
+        "LEADER"
+    }
+    fn prompt(&self, _s: &Session) -> Prompt {
+        let last = self.pts.last().copied();
+        match self.ask {
+            Ask::Points => match self.pts.len() {
+                0 => Prompt::new("Specify leader start point", Accept::POINT),
+                1 => Prompt::new("Specify next point", Accept::POINT).base_opt(last),
+                _ => Prompt::new("Specify next point", Accept::POINT).kw(&["Annotation", "Format", "Undo"]).default("Annotation").base_opt(last),
+            },
+            Ask::Format => Prompt::new("Enter leader format option", KW).kw(&["Spline", "STraight", "Arrow", "None"]).default("Exit"),
+            // "or <options>": the default is the options, not a keyword list.
+            Ask::FirstLine => Prompt::new("Enter first line of annotation text or", Accept::TEXT).default("options"),
+            Ask::NextLine => Prompt::new("Enter next line of annotation text", Accept::TEXT),
+            Ask::Copy => Prompt::new("Select an object to copy", Accept::SELECT),
+            Ask::Option => Prompt::new("Enter an annotation option", KW).kw(&["Tolerance", "Copy", "Block", "None", "Mtext"]).default("Mtext"),
+            Ask::BlockName => Prompt::new("Enter block name", Accept::TEXT).kw(&["?"]),
+            Ask::BlockPoint => Prompt::new("Specify insertion point", Accept::POINT).kw(&["Basepoint", "Scale", "X", "Y", "Z", "Rotate"]),
+            Ask::BlockX => Prompt::new("Enter X scale factor, specify opposite corner", Accept::NUMBER).kw(&["Corner", "XYZ"]).default("1"),
+            Ask::BlockY => Prompt::new("Enter Y scale factor", Accept::NUMBER).default("use X scale factor"),
+            Ask::BlockRotation => Prompt::new("Specify rotation angle", Accept::NUMBER).default("0"),
+        }
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        match self.ask {
+            Ask::Points => match i {
+                Input::Point(p) => self.pts.push(p),
+                // Enter after one point: no leader.
+                Input::Enter if self.pts.len() < 2 => return Ok(Step::Done),
+                Input::Enter => self.ask = Ask::FirstLine,
+                Input::Keyword(k) => match k.as_str() {
+                    "Annotation" => self.ask = Ask::FirstLine,
+                    "Format" => self.ask = Ask::Format,
+                    _ => {
+                        self.pts.pop();
+                    }
+                },
+                _ => {}
+            },
+            Ask::Format => {
+                // Enter, or Exit typed, changes nothing; either way back to the points.
+                if let Input::Keyword(k) = &i {
+                    match k.as_str() {
+                        "Spline" => self.spline = true,
+                        "STraight" => self.spline = false,
+                        "Arrow" => self.no_arrow = false,
+                        _ => self.no_arrow = true,
+                    }
+                }
+                self.ask = Ask::Points;
+            }
+            Ask::FirstLine | Ask::NextLine => match i {
+                Input::Text(t) if !t.is_empty() => {
+                    self.lines.push(t);
+                    self.ask = Ask::NextLine;
+                }
+                _ if self.ask == Ask::NextLine => {
+                    let lines = std::mem::take(&mut self.lines);
+                    return self.finish(s, Annotation::Text(lines));
+                }
+                _ => self.ask = Ask::Option,
+            },
+            Ask::Option => match &i {
+                Input::Keyword(k) if k == "None" => return self.finish(s, Annotation::None),
+                Input::Keyword(k) if k == "Block" => self.ask = Ask::BlockName,
+                Input::Keyword(k) if k == "Copy" => self.ask = Ask::Copy,
+                Input::Text(_) => s.echo("Invalid option keyword."),
+                // Mtext (the default) and Tolerance open an editor or a dialog in AutoCAD; at the
+                // command line, as in accoreconsole, they come back to the first line.
+                _ => self.ask = Ask::FirstLine,
+            },
+            Ask::Copy => {
+                let picked = match &i {
+                    Input::Pick(hs) => hs.first().copied(),
+                    Input::Point(p) => crate::select::pick(s.doc()?, &s.state()?.edit_space(), *p, s.settings.pickbox.max(1.0) * s.pixel_size()),
+                    _ => None,
+                };
+                let text = picked.and_then(|h| s.doc().ok()?.entity(h).cloned()).and_then(|e| match &e.kind {
+                    EntityKind::Text(t) => Some(MText {
+                        insert: t.insert,
+                        height: t.height,
+                        width: 0.0,
+                        attach: 4,
+                        rotation: 0.0,
+                        style: t.style.clone(),
+                        contents: t.value.clone(),
+                        line_spacing: 1.0,
+                        line_spacing_exact: false,
+                        columns: None,
+                    }),
+                    EntityKind::MText(m) => Some(m.clone()),
+                    _ => None,
+                });
+                match text {
+                    Some(m) => return self.finish(s, Annotation::Copy(m)),
+                    None if picked.is_some() => s.echo("The object is not text."),
+                    None => {}
+                }
+            }
+            Ask::BlockName => {
+                let name = match i {
+                    Input::Text(t) => t.trim().to_string(),
+                    Input::Keyword(k) => k,
+                    _ => return Ok(Step::Continue),
+                };
+                if name == "?" {
+                    let names: Vec<String> = s.doc()?.blocks.values().filter(|b| !b.anonymous).map(|b| b.name.clone()).collect();
+                    s.echo(format!("Defined blocks: {}", if names.is_empty() { "(none)".into() } else { names.join(", ") }));
+                } else if s.doc()?.block(&name).is_none() {
+                    s.echo(format!("Block \"{name}\" not found."));
+                } else {
+                    self.block = name;
+                    self.ask = Ask::BlockPoint;
+                }
+            }
+            Ask::BlockPoint => match i {
+                Input::Point(p) => {
+                    self.block_at = p;
+                    self.ask = Ask::BlockX;
+                }
+                Input::Keyword(_) => s.echo("This option is not available here yet."),
+                _ => {}
+            },
+            Ask::BlockX => match scale(&i) {
+                Some(x) => {
+                    self.block_scale = Vec2::new(x, x);
+                    self.ask = Ask::BlockY;
+                }
+                None => s.echo("Requires a nonzero number."),
+            },
+            Ask::BlockY => {
+                match scale(&i) {
+                    Some(y) if !matches!(i, Input::Enter) => self.block_scale.y = y,
+                    Some(_) => {}
+                    None => {
+                        s.echo("Requires a nonzero number.");
+                        return Ok(Step::Continue);
+                    }
+                }
+                self.ask = Ask::BlockRotation;
+            }
+            Ask::BlockRotation => {
+                let rotation = match &i {
+                    Input::Enter => 0.0,
+                    Input::Text(t) => match s.angle_settings().direction(t) {
+                        Some(a) => a,
+                        None => {
+                            s.echo("Requires a valid angle.");
+                            return Ok(Step::Continue);
+                        }
+                    },
+                    _ => return Ok(Step::Continue),
+                };
+                let a = Annotation::Block { name: self.block.clone(), at: self.block_at, scale: self.block_scale, rotation };
+                return self.finish(s, a);
+            }
+        }
+        Ok(Step::Continue)
+    }
+}
+
+/// A scale factor typed, or 1 for Enter; `None` for zero or anything that isn't a number.
+fn scale(i: &Input) -> Option<f64> {
+    match i {
+        Input::Enter => Some(1.0),
+        Input::Text(t) => t.trim().parse::<f64>().ok().filter(|v| v.is_finite() && *v != 0.0),
+        _ => None,
+    }
+}
+
+impl LeaderM {
+    fn finish(&mut self, s: &mut Session, ann: Annotation) -> Result<Step> {
+        let pts = std::mem::take(&mut self.pts);
+        add_leader(s, &pts, self.spline, !self.no_arrow, ann)?;
+        Ok(Step::Done)
+    }
+}
+
+/// The dimension settings LEADER draws with, from the current dimension style and DIMSCALE.
+struct Sizes {
+    arrow: f64,
+    gap: f64,
+    text: f64,
+    above: bool,
+    text_style: String,
+}
+
+fn sizes(s: &Session) -> Sizes {
+    // The current style with the drawing's DIM* overrides (what SETVAR DIMTXT… sets).
+    let st = s.doc().ok().and_then(|d| d.dim_style(&style(s)).map(|st| st.with_overrides(&d.dim_overrides()))).unwrap_or_default();
+    let k = if st.scale > 0.0 { st.scale } else { 1.0 };
+    let text_style = if st.text_style.is_empty() { "Standard".to_string() } else { st.text_style.clone() };
+    Sizes { arrow: st.arrow_size * k, gap: st.text_gap.abs() * k, text: st.text_height * k, above: st.text_above != 0, text_style }
+}
+
+/// LEADER's JSON form: a straight leader with an arrow through `pts`, and `text` (lines split at
+/// `\n`) placed as the command line places it. The handles of the leader and its text.
+pub(super) fn json_leader(s: &mut Session, pts: &[Vec2], text: Option<&str>) -> Result<Vec<Handle>> {
+    let ann = match text {
+        Some(t) if !t.is_empty() => Annotation::Text(t.split('\n').map(str::to_string).collect()),
+        _ => Annotation::None,
+    };
+    add_leader(s, pts, false, true, ann)
+}
+
+/// Draw the leader through `pts` and its annotation, as AutoCAD 2024 places them; their handles.
+fn add_leader(s: &mut Session, pts: &[Vec2], spline: bool, arrow: bool, ann: Annotation) -> Result<Vec<Handle>> {
+    let (Some(&end), Some(&before)) = (pts.last(), pts.len().checked_sub(2).and_then(|i| pts.get(i))) else { return Ok(Vec::new()) };
+    let z = sizes(s);
+    // The side the leader runs to: right unless its last segment runs left.
+    let dir = if end.x < before.x { -1.0 } else { 1.0 };
+    let mut vertices = pts.to_vec();
+    if let Annotation::Text(_) | Annotation::Copy(_) = ann {
+        let d = end - before;
+        // A copied text is centred on its line, and with DIMTAD on that line is above the leader:
+        // the leader ends half the text height lower.
+        if let (Annotation::Copy(_), true, Some(last)) = (&ann, z.above, vertices.last_mut()) {
+            last.y -= z.text / 2.0;
+        }
+        let end = vertices.last().copied().unwrap_or(end);
+        // More than 15° off horizontal: a hook line DIMASZ long into the end.
+        if !spline && d.y.abs() > d.x.abs() * 15f64.to_radians().tan() {
+            let at = vertices.len() - 1;
+            vertices.insert(at, Vec2::new(end.x - dir * z.arrow, end.y));
+        }
+    }
+    let leader = s.add_entity(EntityKind::Leader(cadcraft_doc::Leader {
+        vertices: vertices.iter().map(|p| v3(*p)).collect(),
+        arrow,
+        spline,
+        style: style(s),
+    }))?;
+    let annotation = match ann {
+        Annotation::Text(lines) => {
+            let (attach, lift) = match (z.above, dir > 0.0) {
+                (true, true) => (7, z.gap),
+                (true, false) => (9, z.gap),
+                (false, true) => (4, 0.0),
+                (false, false) => (6, 0.0),
+            };
+            Some(s.add_entity(EntityKind::MText(MText {
+                insert: v3(end + Vec2::new(dir * z.gap, lift)),
+                height: z.text,
+                width: 0.0,
+                attach,
+                rotation: 0.0,
+                style: z.text_style,
+                contents: lines.join("\\P"),
+                line_spacing: 1.0,
+                line_spacing_exact: false,
+                columns: None,
+            }))?)
+        }
+        Annotation::Copy(m) => {
+            let lift = if z.above { z.gap } else { 0.0 };
+            let attach = if dir > 0.0 { 4 } else { 6 };
+            Some(s.add_entity(EntityKind::MText(MText { insert: v3(end + Vec2::new(dir * z.gap, lift)), attach, rotation: 0.0, ..m }))?)
+        }
+        Annotation::Block { name, at, scale, rotation } => {
+            match crate::cmd::blocks::insert_with(s, &name, at, scale, rotation, None, &serde_json::Map::new()) {
+                Ok(h) => Some(h),
+                Err(e) => {
+                    s.doc_mut()?.remove_entity(leader);
+                    return Err(e);
+                }
+            }
+        }
+        Annotation::None => None,
+    };
+    Ok(std::iter::once(leader).chain(annotation).collect())
+}
@@ -1,4 +1,3 @@
-use super::common::style;
 use super::{
    Accept, EngineError, EntityKind, Input, Interactive, LeaderOrder, MLeader, MLeaderOptions, MText, Prompt, Result, Session, Step, Value, Vec2,
    bad, json, points_param, str_param, v3,
@@ -57,33 +56,8 @@ pub(super) fn run_leader(s: &mut Session, p: &Value) -> Result<Value> {
    if pts.len() < 2 {
        return Err(bad("leader", "need 2+ points"));
    }
-    let st = style(s);
-    let h = s.add_entity(EntityKind::Leader(cadcraft_doc::Leader {
-        vertices: pts.iter().map(|q| v3(*q)).collect(),
-        arrow: true,
-        spline: false,
-        style: st,
-    }))?;
-    let mut out = vec![h.hex()];
-    if let (Some(t), Some(last)) = (str_param(p, "text"), pts.last()) {
-        let th = s.doc()?.dim_style(&style(s)).map(|d| d.text_height).unwrap_or(0.18);
-        out.push(
-            s.add_entity(EntityKind::MText(MText {
-                insert: v3(*last + Vec2::new(th * 0.5, th * 0.5)),
-                height: th,
-                width: 0.0,
-                attach: 4,
-                rotation: 0.0,
-                style: "Standard".into(),
-                contents: t.into(),
-                line_spacing: 1.0,
-                line_spacing_exact: false,
-                columns: None,
-            }))?
-            .hex(),
-        );
-    }
-    Ok(json!({ "handles": out }))
+    let hs = super::leader::json_leader(s, &pts, str_param(p, "text"))?;
+    Ok(json!({ "handles": hs.iter().map(|h| h.hex()).collect::<Vec<_>>() }))
 }

 /// The MLEADER Options prompt being answered.
@@ -1,4 +1,5 @@
-//! Array commands: ARRAY, ARRAYRECT and ARRAYPOLAR (ARRAYPATH lives in `modify2`).
+//! Array commands: ARRAY, ARRAYRECT, ARRAYPOLAR and the classic -ARRAY (ARRAYPATH lives in
+//! `modify2`).
 //!
 //! Arrays are associative by default (ARRAYASSOCIATIVITY): the source objects move into an
 //! anonymous source block and the array becomes one block reference to an anonymous array block
@@ -21,6 +22,7 @@ use super::{CommandSpec, bad, bool_or, f64_or, find_command, point_param, point_

 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};

+mod classic;
 mod edit;

 /// Most preview entities drawn while the array is edited.
@@ -48,6 +50,9 @@ pub fn specs() -> Vec<CommandSpec> {
                "{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
            )
            .interactive(|_| Ok(Box::new(PolarM::default()))),
+        CommandSpec::new("-array", "Array", classic::run_classic)
+            .params("{handles?, type?: \"rectangular\" (default) | \"polar\", rows? (1), cols? (1), rowSpacing?, colSpacing?, center, count, angle? (degrees, default 360), rotate?: bool (default true), base? ([x, y], default the DXF group 10 point of the last object)} → {created}: separate copies, as the classic -ARRAY makes them")
+            .interactive(|_| Ok(Box::new(classic::ClassicM::default()))),
    ]
    .into_iter()
    .chain(edit::specs())
@@ -369,10 +374,14 @@ fn run_arraypolar(s: &mut Session, p: &Value) -> Result<Value> {
    check_size(s, n.saturating_mul(rows).saturating_mul(levels), hs.len())?;
    let base = point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c);
    let row_spacing = f64_or(p, "rowSpacing", 1.0);
+    let fill = f64_or(p, "angle", 360.0);
+    if !(fill.abs() >= 1e-9 && fill.abs() <= 360.0 + 1e-9) {
+        return Err(other("Requires a fill angle between -360 and 360 degrees (not 0)."));
+    }
    let kind = ArrayKind::Polar(PolarArray {
        center: c - base,
        items: count32(n),
-        fill: f64_or(p, "angle", 360.0),
+        fill: fill.clamp(-360.0, 360.0),
        rotate: bool_or(p, "rotate", true),
        rows: count32(rows),
        row_spacing,
@@ -0,0 +1,255 @@
+//! -ARRAY: the classic command-line array, as AutoCAD 2024 runs it from AutoLISP's `command`
+//! (accoreconsole, every copy read back with `entget`). It makes separate copies, never an
+//! associative array:
+//! - "Enter the type of array [Rectangular/Polar] <R>": the default is the type used last;
+//! - Rectangular asks "Enter the number of rows (---) <1>" and "Enter the number of columns (|||)
+//!   <1>", then "Enter the distance between rows or specify unit cell (---)" only for more than one
+//!   row (two corners give both distances) and "Specify the distance between columns (|||)" only for
+//!   more than one column. The copy in row r and column c moves by (c·columns, r·rows): 2 rows and
+//!   2 columns at −12.57 and −18.01 put the copies below and to the left;
+//! - Polar asks "Specify center point of array or [Base]", "Enter the number of items in the
+//!   array", "Specify the angle to fill (+=ccw, -=cw) <360>" and "Rotate arrayed objects?
+//!   [Yes/No] <Y>". Items are 360/n apart around a full circle, else fill/(n − 1) apart (6 items in
+//!   270°: 54°; −90° turns clockwise). Not rotated, each copy moves as the DXF group 10 point of the
+//!   object selected last turns about the centre (a polyline's first vertex, an arc's centre), or
+//!   as the Base point does.
+
+use cadcraft_doc::Handle;
+use cadcraft_geom::{Mat3, Vec2};
+use serde_json::{Value, json};
+
+use super::super::machines::{SelOutcome, SelectPhase, number};
+use super::super::{bad, bool_or, f64_or, point_param, point_req, str_param, targets};
+use super::{KEYWORDS, angle, check_size, copy_all, count, count_or, max_count, other, yes_no};
+use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+enum Stage {
+    #[default]
+    Select,
+    Kind,
+    Rows,
+    Columns,
+    RowDistance,
+    /// The unit cell's other corner, after the first one.
+    Corner(Vec2),
+    ColumnDistance,
+    Center,
+    Base,
+    Items,
+    Fill,
+    Rotate,
+}
+
+#[derive(Default)]
+pub(super) struct ClassicM {
+    sel: SelectPhase,
+    objs: Vec<Handle>,
+    stage: Stage,
+    rows: u64,
+    columns: u64,
+    row_distance: f64,
+    center: Vec2,
+    base: Option<Vec2>,
+    items: u64,
+    fill: f64,
+}
+
+/// The moves of a rectangular array's copies (the objects themselves stay in row 0, column 0).
+fn rect_mats(rows: u64, columns: u64, row_distance: f64, column_distance: f64) -> Vec<Mat3> {
+    (0..rows)
+        .flat_map(|r| (0..columns).map(move |c| (r, c)))
+        .filter(|rc| *rc != (0, 0))
+        .map(|(r, c)| Mat3::translate(Vec2::new(c as f64 * column_distance, r as f64 * row_distance)))
+        .collect()
+}
+
+/// The transforms of a polar array's copies: `items` around `center` filling `fill` degrees,
+/// turned with it or moved as `base` turns.
+fn polar_mats(center: Vec2, items: u64, fill: f64, rotate: bool, base: Vec2) -> Vec<Mat3> {
+    let full = (fill.abs() - 360.0).abs() < 1e-9;
+    let gaps = if full { items } else { items.saturating_sub(1) }.max(1);
+    let step = fill.to_radians() / gaps as f64;
+    (1..items)
+        .map(|k| {
+            let a = step * k as f64;
+            if rotate { Mat3::rotate_about(center, a) } else { Mat3::translate(base.rotate_about(center, a) - base) }
+        })
+        .collect()
+}
+
+/// The DXF group 10 point of the last of `hs`, which a polar array that doesn't rotate its copies
+/// moves around the centre.
+fn last_point(s: &Session, hs: &[Handle]) -> Option<Vec2> {
+    let d = s.doc().ok()?;
+    hs.last().and_then(|h| d.entity(*h)).and_then(|e| crate::session::group_10(d, e))
+}
+
+/// -ARRAY's JSON form.
+pub(super) fn run_classic(s: &mut Session, p: &Value) -> Result<Value> {
+    let hs = targets(s, p)?;
+    let polar = match str_param(p, "type").map(str::to_ascii_lowercase).as_deref() {
+        None | Some("rectangular") => false,
+        Some("polar") => true,
+        Some(_) => return Err(bad("-array", "type must be \"rectangular\" or \"polar\"")),
+    };
+    // The size is checked before the copies' transforms are made.
+    let mats = if polar {
+        let center = point_req("-array", p, "center")?;
+        let items = count_or("-array", p, "count", 1)?;
+        check_size(s, items, hs.len())?;
+        let base = point_param(p, "base").or_else(|| last_point(s, &hs)).unwrap_or(center);
+        polar_mats(center, items, f64_or(p, "angle", 360.0), bool_or(p, "rotate", true), base)
+    } else {
+        let rows = count_or("-array", p, "rows", 1)?;
+        let columns = count_or("-array", p, "cols", 1)?;
+        check_size(s, rows.saturating_mul(columns), hs.len())?;
+        rect_mats(rows, columns, f64_or(p, "rowSpacing", 0.0), f64_or(p, "colSpacing", 0.0))
+    };
+    let created = copy_all(s, &hs, mats.into_iter())?;
+    Ok(json!({ "created": created }))
+}
+
+impl ClassicM {
+    /// Make the copies.
+    fn finish(&mut self, s: &mut Session, mats: Vec<Mat3>) -> Result<Step> {
+        check_size(s, mats.len() as u64 + 1, self.objs.len())?;
+        copy_all(s, &self.objs, mats.into_iter())?;
+        s.set_selection(Vec::new());
+        Ok(Step::Done)
+    }
+
+    /// After the rows and columns: the distances still needed, or the copies.
+    fn after_counts(&mut self, s: &mut Session) -> Result<Step> {
+        if self.rows > 1 {
+            self.stage = Stage::RowDistance;
+        } else if self.columns > 1 {
+            self.stage = Stage::ColumnDistance;
+        } else {
+            return self.finish(s, Vec::new());
+        }
+        Ok(Step::Continue)
+    }
+
+    fn rect(&mut self, s: &mut Session, column_distance: f64) -> Result<Step> {
+        let mats = rect_mats(self.rows, self.columns, self.row_distance, column_distance);
+        self.finish(s, mats)
+    }
+}
+
+impl Interactive for ClassicM {
+    fn name(&self) -> &'static str {
+        "-ARRAY"
+    }
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        self.sel = SelectPhase::begin(s);
+        if self.sel.done {
+            self.objs = self.sel.picked.clone();
+            self.stage = Stage::Kind;
+        }
+        Ok(Step::Continue)
+    }
+    fn prompt(&self, s: &Session) -> Prompt {
+        match self.stage {
+            Stage::Select => self.sel.prompt(),
+            Stage::Kind => Prompt::new("Enter the type of array", KEYWORDS)
+                .kw(&["Rectangular", "Polar"])
+                .default(if s.last_used.classic_array_polar { "P" } else { "R" }),
+            Stage::Rows => Prompt::new("Enter the number of rows (---)", Accept::NUMBER).default("1"),
+            Stage::Columns => Prompt::new("Enter the number of columns (|||)", Accept::NUMBER).default("1"),
+            Stage::RowDistance => Prompt::new("Enter the distance between rows or specify unit cell (---)", Accept::POINT_OR_NUMBER),
+            Stage::Corner(a) => Prompt::new("Specify opposite corner", Accept::POINT).corner(a),
+            Stage::ColumnDistance => Prompt::new("Specify the distance between columns (|||)", Accept::NUMBER),
+            Stage::Center => Prompt::new("Specify center point of array", Accept::POINT).kw(&["Base"]),
+            Stage::Base => Prompt::new("Specify base point of objects", Accept::POINT),
+            Stage::Items => Prompt::new("Enter the number of items in the array", Accept::NUMBER),
+            Stage::Fill => Prompt::new("Specify the angle to fill (+=ccw, -=cw)", Accept::NUMBER).default("360"),
+            Stage::Rotate => Prompt::new("Rotate arrayed objects?", KEYWORDS).kw(&["Yes", "No"]).default("Y"),
+        }
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        let max = max_count(s, 1, self.objs.len());
+        match (self.stage, i) {
+            (Stage::Select, i) => match self.sel.feed(s, &i)? {
+                SelOutcome::More => {}
+                SelOutcome::Done(hs) => {
+                    self.objs = hs;
+                    self.stage = Stage::Kind;
+                }
+                SelOutcome::Empty => return Ok(Step::Done),
+            },
+            (Stage::Kind, i) => {
+                let polar = match &i {
+                    Input::Enter => s.last_used.classic_array_polar,
+                    Input::Keyword(k) | Input::Text(k) => match k.trim().trim_start_matches('_').to_ascii_lowercase().chars().next() {
+                        Some('p') => true,
+                        Some('r') => false,
+                        _ => return Err(other("Invalid option keyword.")),
+                    },
+                    _ => return Ok(Step::Continue),
+                };
+                s.last_used.classic_array_polar = polar;
+                self.stage = if polar { Stage::Center } else { Stage::Rows };
+            }
+            (Stage::Rows, i) => {
+                if let Some(n) = count(&i, 1, max)? {
+                    self.rows = n;
+                    self.stage = Stage::Columns;
+                }
+            }
+            // No more columns than MAXARRAY allows with the rows.
+            (Stage::Columns, i) => {
+                if let Some(n) = count(&i, 1, max_count(s, self.rows, self.objs.len()))? {
+                    self.columns = n;
+                    return self.after_counts(s);
+                }
+            }
+            (Stage::RowDistance, Input::Point(a)) => self.stage = Stage::Corner(a),
+            (Stage::RowDistance, Input::Text(t)) => {
+                self.row_distance = number(&t).filter(|v| v.is_finite()).ok_or_else(|| other("Requires a distance."))?;
+                if self.columns <= 1 {
+                    return self.rect(s, 0.0);
+                }
+                self.stage = Stage::ColumnDistance;
+            }
+            // A unit cell gives both distances.
+            (Stage::Corner(a), Input::Point(b)) => {
+                self.row_distance = b.y - a.y;
+                return self.rect(s, b.x - a.x);
+            }
+            (Stage::ColumnDistance, Input::Text(t)) => {
+                let d = number(&t).filter(|v| v.is_finite()).ok_or_else(|| other("Requires a distance."))?;
+                return self.rect(s, d);
+            }
+            (Stage::Center, Input::Point(c)) => {
+                self.center = c;
+                self.stage = Stage::Items;
+            }
+            (Stage::Center, Input::Keyword(k)) if k == "Base" => self.stage = Stage::Base,
+            (Stage::Base, Input::Point(b)) => {
+                self.base = Some(b);
+                self.stage = Stage::Center;
+            }
+            (Stage::Items, i @ Input::Text(_)) => {
+                if let Some(n) = count(&i, 1, max)? {
+                    self.items = n;
+                    self.stage = Stage::Fill;
+                }
+            }
+            (Stage::Fill, i) => {
+                if let Some(a) = angle(&i, 360.0, &s.angle_settings())? {
+                    self.fill = a;
+                    self.stage = Stage::Rotate;
+                }
+            }
+            (Stage::Rotate, i) => {
+                let Some(rotate) = yes_no(&i, true) else { return Err(other("Invalid option keyword.")) };
+                let base = self.base.or_else(|| last_point(s, &self.objs)).unwrap_or(self.center);
+                let mats = polar_mats(self.center, self.items, self.fill, rotate, base);
+                return self.finish(s, mats);
+            }
+            _ => {}
+        }
+        Ok(Step::Continue)
+    }
+}
@@ -7,7 +7,7 @@ pub(in crate::cmd) mod purge;
 use std::sync::Arc;

 use cadcraft_doc::{Attrib, Block, Entity, EntityKind, HAlign, Handle, Insert, Text, VAlign};
-use cadcraft_geom::{Mat3, Vec2, Vec3};
+use cadcraft_geom::{Vec2, Vec3};
 use serde_json::{Value, json};

 use super::helpers::v3;
@@ -17,12 +17,14 @@ use super::{CommandSpec, bad, bool_or, f64_or, find_command, ok, point_param, po
 use super::has_doc;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};

+mod attdef;
 mod attedit;
 mod burst;
 mod description;
 mod dyngrip;
 mod extract;
 pub(crate) mod refedit;
+mod wblock;

 pub fn specs() -> Vec<CommandSpec> {
    vec![
@@ -45,10 +47,11 @@ pub fn specs() -> Vec<CommandSpec> {
            .menu(&["Draw", "Block", "Define Attributes..."])
            .alias(&["att", "-attdef"])
            .params("{tag, prompt?, default?, at, height?, invisible?}")
-            .interactive(|_| Ok(Box::new(AttdefM::default()))),
+            .interactive(|_| Ok(Box::new(attdef::AttdefM::default()))),
        attedit::attedit_spec(),
        attedit::dash_attedit_spec(),
-        CommandSpec::new("wblock", "Write Block", run_wblock).alias(&["w"]).params("{path, name? | handles?, base?}"),
+        wblock::wblock_spec(),
+        wblock::dash_wblock_spec(),
        CommandSpec::new("base", "Base", run_base).menu(&["Draw", "Block", "Base"]).params("{at: [x,y]}"),
        CommandSpec::new("blocks.dynamic", "Dynamic Block Data", run_dynamic)
            .params("{name (a block, or \"*Model_Space\" for a drawing that is a dynamic block's own)} → {parameters, actions, other} | null (not a dynamic block)")
@@ -184,9 +187,16 @@ pub(crate) fn make_block(s: &mut Session, name: &str, base: Vec2, hs: &[Handle],
        b.entities.push(e);
    }
    doc.blocks.insert(name.to_string(), Arc::new(b));
-    if keep != Keep::Retain {
-        for h in hs {
-            doc.remove_entity(*h);
+    match keep {
+        Keep::Retain => {}
+        Keep::Convert => {
+            for h in hs {
+                doc.remove_entity(*h);
+            }
+        }
+        // As after ERASE, OOPS brings them back.
+        Keep::Delete => {
+            super::modify::erase_kept(s, hs)?;
        }
    }
    s.set_selection(Vec::new());
@@ -361,53 +371,6 @@ fn run_attdef(s: &mut Session, p: &Value) -> Result<Value> {
    Ok(json!({ "handle": s.add_entity(k)?.hex() }))
 }

-fn run_wblock(s: &mut Session, p: &Value) -> Result<Value> {
-    let path = str_param(p, "path").ok_or_else(|| bad("wblock", "`path` is required"))?.to_string();
-    let src = s.doc()?;
-    let mut d = cadcraft_doc::Drawing::new_imperial();
-    d.layers = src.layers.clone();
-    d.linetypes = src.linetypes.clone();
-    d.text_styles = src.text_styles.clone();
-    d.dim_styles = src.dim_styles.clone();
-    d.blocks = src.blocks.clone();
-    // The base point becomes the written drawing's origin, its insertion base: by default 0,0 for
-    // objects and the block's base point for a block (`base` is then in block coordinates).
-    let base = point_param(p, "base");
-    d.header.set("INSBASE", cadcraft_doc::HVal::Point(Vec3::ZERO));
-    let m = Mat3::translate(-base.unwrap_or(Vec2::ZERO));
-    let ents: Vec<Entity> = if let Some(name) = str_param(p, "name") {
-        let b = src.block(name).ok_or_else(|| bad("wblock", format!("no block `{name}`")))?;
-        let m = Mat3::translate(-base.unwrap_or(b.base.xy()));
-        b.entities
-            .iter()
-            .map(|e| {
-                let mut e = (**e).clone();
-                e.kind.transform(&m);
-                e
-            })
-            .collect()
-    } else {
-        targets(s, p)?
-            .iter()
-            .filter_map(|h| src.entity(*h))
-            .map(|e| {
-                let mut e = (**e).clone();
-                e.kind.transform(&m);
-                e
-            })
-            .collect()
-    };
-    for mut e in ents {
-        e.handle = d.new_handle();
-        d.model.push(e);
-    }
-    let hooks = super::file::io().ok_or_else(|| bad("wblock", "file formats are not available in this build"))?;
-    let bytes = (hooks.write)(&d, &path).map_err(|e| bad("wblock", e))?;
-    #[cfg(not(target_arch = "wasm32"))]
-    std::fs::write(&path, &bytes).map_err(|e| bad("wblock", format!("{path}: {e}")))?;
-    Ok(json!({ "path": path, "entities": d.model.len(), "bytes": bytes.len() }))
-}
-
 fn run_base(s: &mut Session, p: &Value) -> Result<Value> {
    let at = point_req("base", p, "at")?;
    s.doc_mut()?.header.set("INSBASE", cadcraft_doc::HVal::Point(v3(at)));
@@ -595,6 +558,8 @@ enum InsStage {
    ZScale,
    Rotation,
    Attribs,
+    /// A Verify attribute asked again.
+    Verify,
 }

 #[derive(Default)]
@@ -615,8 +580,11 @@ struct InsertM {
    /// Where the block was dropped to pick a Basepoint on it.
    dropped: Option<Vec2>,
    rotation: Option<f64>,
-    attdefs: Vec<(String, String, String)>,
+    /// The attributes asked for: tag, prompt, default value, and Verify (asked again).
+    attdefs: Vec<(String, String, String, bool)>,
    values: serde_json::Map<String, Value>,
+    /// Verify attributes asked again so far.
+    verified: usize,
    /// `*name`: insert the block's objects (one uniform scale factor, no attribute values).
    explode: bool,
    /// The file waiting for the Redefine answer.
@@ -633,6 +601,17 @@ impl InsertM {
        } else {
            InsStage::Attribs
        };
+        if self.stage == InsStage::Attribs && self.values.is_empty() && !self.attdefs.is_empty() {
+            s.echo("Enter attribute values");
+        }
+        // Then the Verify attributes are asked again, with the values typed.
+        if self.stage == InsStage::Attribs && self.values.len() >= self.attdefs.len() && self.verified < self.verifying().len() {
+            if self.verified == 0 {
+                s.echo("Verify attribute values");
+            }
+            self.stage = InsStage::Verify;
+            return Ok(Step::Continue);
+        }
        if self.stage == InsStage::Attribs
            && self.values.len() >= self.attdefs.len()
            && let (Some(n), Some(a), Some(sc), Some(r)) = (self.name.clone(), self.at, self.scale, self.rotation)
@@ -646,20 +625,26 @@ impl InsertM {
        Ok(Step::Continue)
    }

-    /// Block `name` chosen: collect its attribute prompts and ask for the insertion point.
+    /// The Verify attributes asked for.
+    fn verifying(&self) -> Vec<&(String, String, String, bool)> {
+        self.attdefs.iter().filter(|a| a.3).collect()
+    }
+
+    /// Block `name` chosen: collect its attribute prompts and ask for the insertion point. Constant
+    /// and Preset attributes take their values without asking, and so do all of them with ATTREQ 0.
    fn choose(&mut self, s: &mut Session, name: &str) -> Result<()> {
        let Some(b) = s.doc()?.block(name).cloned() else {
            s.echo(format!("Block \"{name}\" not found."));
            return Ok(());
        };
-        self.attdefs = if self.explode {
+        self.attdefs = if self.explode || !s.settings.attreq {
            Vec::new()
        } else {
            b.entities
                .iter()
                .filter_map(|e| {
                    if let EntityKind::AttDef(a) = &e.kind {
-                        (!a.constant).then(|| (a.tag.clone(), a.prompt.clone(), a.text.value.clone()))
+                        (!a.constant && !a.modes.preset).then(|| (a.tag.clone(), a.prompt.clone(), a.text.value.clone(), a.modes.verify))
                    } else {
                        None
                    }
@@ -744,9 +729,14 @@ impl Interactive for InsertM {
            InsStage::ZScale => Prompt::new("Specify Z scale factor or", Accept::NUMBER).default("use X scale factor"),
            InsStage::Rotation => Prompt::new("Specify rotation angle", Accept::POINT_OR_NUMBER).default("0").base(at),
            InsStage::Attribs => {
-                let (_, prompt, default) = self.attdefs.get(self.values.len()).cloned().unwrap_or_default();
+                let (_, prompt, default, _) = self.attdefs.get(self.values.len()).cloned().unwrap_or_default();
                Prompt::new(if prompt.is_empty() { "Enter attribute value".into() } else { prompt }, Accept::TEXT).default(default)
            }
+            InsStage::Verify => {
+                let (tag, prompt) = self.verifying().get(self.verified).map(|a| (a.0.clone(), a.1.clone())).unwrap_or_default();
+                let typed = self.values.get(&tag).and_then(Value::as_str).unwrap_or_default().to_string();
+                Prompt::new(if prompt.is_empty() { "Enter attribute value".into() } else { prompt }, Accept::TEXT).default(typed)
+            }
        }
    }
    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
@@ -905,7 +895,7 @@ impl Interactive for InsertM {
                return self.advance(s);
            }
            InsStage::Attribs => {
-                let (tag, _, default) = self.attdefs.get(self.values.len()).cloned().unwrap_or_default();
+                let (tag, _, default, _) = self.attdefs.get(self.values.len()).cloned().unwrap_or_default();
                let v = match i {
                    Input::Text(t) => t,
                    _ => default,
@@ -913,6 +903,20 @@ impl Interactive for InsertM {
                self.values.insert(tag, Value::String(v));
                return self.advance(s);
            }
+            // Enter keeps the value typed.
+            InsStage::Verify => {
+                let tag = self.verifying().get(self.verified).map(|a| a.0.clone()).unwrap_or_default();
+                match i {
+                    Input::Text(t) => {
+                        self.values.insert(tag, Value::String(t));
+                    }
+                    Input::Enter => {}
+                    // A click or anything else is no answer: the value is asked for again.
+                    _ => return Ok(Step::Continue),
+                }
+                self.verified += 1;
+                return self.advance(s);
+            }
        }
        Ok(Step::Continue)
    }
@@ -934,52 +938,6 @@ impl Interactive for InsertM {
    }
 }

-#[derive(Default)]
-struct AttdefM {
-    tag: Option<String>,
-    prompt: Option<String>,
-    default: Option<String>,
-}
-
-impl Interactive for AttdefM {
-    fn name(&self) -> &'static str {
-        "ATTDEF"
-    }
-    fn prompt(&self, _s: &Session) -> Prompt {
-        match (&self.tag, &self.prompt, &self.default) {
-            (None, ..) => Prompt::new("Enter attribute tag name", Accept::TEXT),
-            (Some(_), None, _) => Prompt::new("Enter attribute prompt", Accept::TEXT),
-            (Some(_), Some(_), None) => Prompt::new("Enter default attribute value", Accept::TEXT),
-            _ => Prompt::new("Specify start point of text", Accept::POINT),
-        }
-    }
-    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
-        let text = match &i {
-            Input::Text(t) => Some(t.clone()),
-            Input::Enter => Some(String::new()),
-            _ => None,
-        };
-        match (&self.tag, &self.prompt, &self.default) {
-            (None, ..) => {
-                if let Some(t) = text.filter(|t| !t.trim().is_empty() && !t.contains(' ')) {
-                    self.tag = Some(t.to_ascii_uppercase());
-                }
-            }
-            (Some(_), None, _) => self.prompt = text,
-            (Some(_), Some(_), None) => self.default = text,
-            (Some(tag), Some(pr), Some(def)) => {
-                if let Input::Point(p) = i {
-                    let h = s.doc()?.header.f64("TEXTSIZE", 0.2);
-                    let k = attdef_kind(s, tag, pr, def, p, h, false);
-                    s.add_entity(k)?;
-                    return Ok(Step::Done);
-                }
-            }
-        }
-        Ok(Step::Continue)
-    }
-}
-
 mod attribs;
 mod battman;
 mod blockreplace;
@@ -0,0 +1,293 @@
+//! -ATTDEF at the command line, as AutoCAD 2024 runs it (accoreconsole): the attribute modes
+//! (kept in AFLAGS), the tag, prompt and default value (a constant attribute's value instead),
+//! then the text's point, justification, style, height and rotation.
+
+use cadcraft_doc::{AttribModes, HAlign, VAlign};
+
+use super::{Accept, Attrib, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Text, Vec2, number, v3};
+use crate::cmd::curves::KW;
+use crate::cmd::draw::justify;
+
+/// AFLAGS bits, as AutoCAD numbers the modes.
+const INVISIBLE: i64 = 1;
+const CONSTANT: i64 = 2;
+const VERIFY: i64 = 4;
+const PRESET: i64 = 8;
+const LOCK: i64 = 16;
+const MULTILINE: i64 = 32;
+
+const MODES: [&str; 7] = ["Invisible", "Constant", "Verify", "Preset", "Lock position", "Annotative", "Multiple lines"];
+const JUSTIFY: [&str; 15] = ["Left", "Center", "Right", "Align", "Middle", "Fit", "TL", "TC", "TR", "ML", "MC", "MR", "BL", "BC", "BR"];
+
+/// Where -ATTDEF is in its prompts.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+enum Ask {
+    #[default]
+    Modes,
+    Tag,
+    Prompt,
+    Value,
+    Point,
+    Justify,
+    Style,
+    Height,
+    Rotation,
+}
+
+pub(super) struct AttdefM {
+    ask: Ask,
+    flags: i64,
+    tag: String,
+    prompt: String,
+    value: String,
+    justify: (HAlign, VAlign),
+    style: String,
+    at: Vec2,
+    height: f64,
+}
+
+impl Default for AttdefM {
+    fn default() -> Self {
+        AttdefM {
+            ask: Ask::Modes,
+            flags: LOCK,
+            tag: String::new(),
+            prompt: String::new(),
+            value: String::new(),
+            justify: (HAlign::Left, VAlign::Baseline),
+            style: "Standard".into(),
+            at: Vec2::ZERO,
+            height: 0.0,
+        }
+    }
+}
+
+impl AttdefM {
+    fn echo_modes(&self, s: &mut Session) {
+        let yn = |bit: i64| if self.flags & bit != 0 { "Y" } else { "N" };
+        s.echo("Current attribute modes:");
+        s.echo(format!(
+            "Invisible={}  Constant={}  Verify={}  Preset={}  Lock position={}  Annotative=N  Multiple line={}",
+            yn(INVISIBLE),
+            yn(CONSTANT),
+            yn(VERIFY),
+            yn(PRESET),
+            yn(LOCK),
+            yn(MULTILINE)
+        ));
+    }
+
+    fn echo_style(&self, s: &mut Session) -> Result<()> {
+        let th = s.doc()?.header.f64("TEXTSIZE", 0.2);
+        s.echo(format!("Current text style:  \"{}\"  Text height:  {th:.4}  Justify:  {}", self.style, justify_name(self.justify)));
+        Ok(())
+    }
+
+    fn point_prompt(&self) -> &'static str {
+        match self.justify {
+            (HAlign::Center, VAlign::Baseline) => "Specify center point of text",
+            (HAlign::Right, VAlign::Baseline) => "Specify right endpoint of text baseline",
+            (HAlign::Middle, _) | (HAlign::Center, VAlign::Middle) => "Specify middle point of text",
+            (HAlign::Left, VAlign::Top) => "Specify top-left point of text",
+            (HAlign::Center, VAlign::Top) => "Specify top-center point of text",
+            (HAlign::Right, VAlign::Top) => "Specify top-right point of text",
+            (HAlign::Left, VAlign::Middle) => "Specify middle-left point of text",
+            (HAlign::Right, VAlign::Middle) => "Specify middle-right point of text",
+            (HAlign::Left, VAlign::Bottom) => "Specify bottom-left point of text",
+            (HAlign::Center, VAlign::Bottom) => "Specify bottom-center point of text",
+            (HAlign::Right, VAlign::Bottom) => "Specify bottom-right point of text",
+            _ => "Specify start point of text",
+        }
+    }
+
+    fn finish(&mut self, s: &mut Session, rotation: f64) -> Result<Step> {
+        let (h, v) = self.justify;
+        let left = h == HAlign::Left && v == VAlign::Baseline;
+        s.add_entity(EntityKind::AttDef(Attrib {
+            tag: self.tag.to_uppercase(),
+            text: Text {
+                insert: v3(self.at),
+                align_pt: if left { None } else { Some(v3(self.at)) },
+                height: self.height,
+                value: std::mem::take(&mut self.value),
+                rotation,
+                width_factor: 1.0,
+                oblique: 0.0,
+                style: self.style.clone(),
+                halign: h,
+                valign: v,
+            },
+            invisible: self.flags & INVISIBLE != 0,
+            constant: self.flags & CONSTANT != 0,
+            prompt: std::mem::take(&mut self.prompt),
+            props: Default::default(),
+            multiline: None,
+            modes: AttribModes { verify: self.flags & VERIFY != 0, preset: self.flags & PRESET != 0, lock_position: self.flags & LOCK != 0 },
+        }))?;
+        Ok(Step::Done)
+    }
+}
+
+/// The justification's name in "Current text style: … Justify: …".
+fn justify_name(j: (HAlign, VAlign)) -> &'static str {
+    JUSTIFY.into_iter().find(|k| justify(k) == Some(j)).unwrap_or("Left")
+}
+
+impl Interactive for AttdefM {
+    fn name(&self) -> &'static str {
+        "ATTDEF"
+    }
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        let d = s.doc()?;
+        self.flags = d.header.i64("AFLAGS", LOCK);
+        self.style = d.header.str("TEXTSTYLE", "Standard");
+        self.echo_modes(s);
+        Ok(Step::Continue)
+    }
+    fn prompt(&self, s: &Session) -> Prompt {
+        match self.ask {
+            Ask::Modes => Prompt::new("Enter an option to change", KW).kw(&MODES).default("done"),
+            Ask::Tag => Prompt::new("Enter attribute tag name", Accept::TEXT),
+            Ask::Prompt => Prompt::new("Enter attribute prompt", Accept::TEXT),
+            Ask::Value if self.flags & CONSTANT != 0 => Prompt::new("Enter attribute value", Accept::TEXT),
+            Ask::Value => Prompt::new("Enter default attribute value", Accept::TEXT),
+            // Once a justification is chosen AutoCAD asks for its point alone.
+            Ask::Point if self.justify == (HAlign::Left, VAlign::Baseline) => {
+                Prompt::new(self.point_prompt(), Accept::POINT).kw(&["Justify", "Style"])
+            }
+            Ask::Point => Prompt::new(self.point_prompt(), Accept::POINT),
+            Ask::Justify => Prompt::new("Enter an option", Accept::TEXT).kw(&JUSTIFY),
+            Ask::Style => Prompt::new("Enter style name", Accept::TEXT).kw(&["?"]).default(self.style.clone()),
+            Ask::Height => {
+                let th = s.doc().map(|d| d.header.f64("TEXTSIZE", 0.2)).unwrap_or(0.2);
+                Prompt::new("Specify height", Accept::POINT_OR_NUMBER).default(format!("{th:.4}")).base(self.at)
+            }
+            Ask::Rotation => Prompt::new("Specify rotation angle of text", Accept::POINT_OR_NUMBER).default("0").base(self.at),
+        }
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        match self.ask {
+            Ask::Modes => match &i {
+                Input::Keyword(k) => {
+                    let bit = match k.as_str() {
+                        "Invisible" => INVISIBLE,
+                        "Constant" => CONSTANT,
+                        "Verify" => VERIFY,
+                        "Preset" => PRESET,
+                        "Lock position" => LOCK,
+                        _ => {
+                            s.echo(format!("{k} attributes are not available yet."));
+                            return Ok(Step::Continue);
+                        }
+                    };
+                    self.flags ^= bit;
+                    s.doc_mut()?.header.set_i64("AFLAGS", self.flags);
+                    self.echo_modes(s);
+                }
+                Input::Enter => self.ask = Ask::Tag,
+                Input::Text(_) => s.echo("Invalid option keyword."),
+                _ => {}
+            },
+            Ask::Tag => match &i {
+                // AutoCAD takes spaces in a tag here, and upper-cases it.
+                Input::Text(t) if !t.trim().is_empty() => {
+                    self.tag = t.trim().to_string();
+                    self.ask = if self.flags & CONSTANT != 0 { Ask::Value } else { Ask::Prompt };
+                }
+                Input::Text(_) | Input::Enter => s.echo("Tag cannot be null"),
+                _ => {}
+            },
+            Ask::Prompt | Ask::Value => {
+                let t = match i {
+                    Input::Text(t) => t,
+                    Input::Enter => String::new(),
+                    _ => return Ok(Step::Continue),
+                };
+                if self.ask == Ask::Prompt {
+                    self.prompt = t;
+                    self.ask = Ask::Value;
+                } else {
+                    self.value = t;
+                    self.echo_style(s)?;
+                    self.ask = Ask::Point;
+                }
+            }
+            Ask::Point => match i {
+                Input::Point(p) => {
+                    self.at = p;
+                    self.ask = Ask::Height;
+                }
+                Input::Keyword(k) if k == "Justify" => self.ask = Ask::Justify,
+                Input::Keyword(_) => self.ask = Ask::Style,
+                _ => {}
+            },
+            Ask::Justify => {
+                // A justification goes on to its point; anything else is asked again.
+                if let Input::Keyword(k) | Input::Text(k) = &i {
+                    match justify(k) {
+                        // Aligned and fitted text take two points: not here yet.
+                        Some((HAlign::Aligned | HAlign::Fit, _)) => s.echo("Align and Fit are not available here yet."),
+                        Some(j) => {
+                            self.justify = j;
+                            self.ask = Ask::Point;
+                        }
+                        None => s.echo("Invalid option keyword."),
+                    }
+                }
+            }
+            Ask::Style => {
+                let name = match i {
+                    Input::Enter => self.style.clone(),
+                    Input::Text(t) | Input::Keyword(t) => t.trim().to_string(),
+                    _ => return Ok(Step::Continue),
+                };
+                if name == "?" {
+                    let names: Vec<String> = s.doc()?.text_styles.iter().map(|st| st.name.clone()).collect();
+                    s.echo(format!("Text styles: {}", names.join(", ")));
+                    return Ok(Step::Continue);
+                }
+                match s.doc()?.text_style(&name).map(|st| st.name.clone()) {
+                    Some(n) => {
+                        self.style = n;
+                        self.echo_style(s)?;
+                        self.ask = Ask::Point;
+                    }
+                    None => s.echo(format!("Cannot find text style \"{name}\".")),
+                }
+            }
+            Ask::Height => {
+                let th = s.doc()?.header.f64("TEXTSIZE", 0.2);
+                let h = match &i {
+                    Input::Enter => th,
+                    Input::Point(p) => self.at.dist(*p),
+                    // A distance, as TEXT takes its height (1'6" in feet and inches, too).
+                    Input::Text(t) => number(t).unwrap_or(0.0),
+                    _ => return Ok(Step::Continue),
+                };
+                if !(h.is_finite() && h > 0.0) {
+                    s.echo("Requires a positive height.");
+                    return Ok(Step::Continue);
+                }
+                self.height = h;
+                s.doc_mut()?.header.set_f64("TEXTSIZE", h);
+                self.ask = Ask::Rotation;
+            }
+            Ask::Rotation => {
+                let r = match &i {
+                    Input::Enter => 0.0,
+                    Input::Point(p) => self.at.angle_to(*p),
+                    Input::Text(t) => match s.angle_settings().direction(t) {
+                        Some(a) => a,
+                        None => {
+                            s.echo("Requires an angle.");
+                            return Ok(Step::Continue);
+                        }
+                    },
+                    _ => return Ok(Step::Continue),
+                };
+                return self.finish(s, r);
+            }
+        }
+        Ok(Step::Continue)
+    }
+}
@@ -59,7 +59,7 @@ pub(super) fn file_ref(s: &Session, t: &str) -> Option<FileRef> {
 }

 /// The file name without folders and extension (either separator, so Windows paths work anywhere).
-fn stem(path: &str) -> String {
+pub(super) fn stem(path: &str) -> String {
    let file = path.rsplit(['/', '\\']).next().unwrap_or(path);
    match file.rsplit_once('.') {
        Some((stem, _)) if !stem.is_empty() => stem.to_string(),
@@ -109,7 +109,7 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
        nb.name = to.clone();
        nb.entities = Default::default();
        for e in b.entities.iter() {
-            let e = adopt(&mut d, e, &renames);
+            let e = adopt(&mut d, src, e, &renames);
            nb.entities.push(e);
        }
        d.blocks.insert(to.clone(), Arc::new(nb));
@@ -118,7 +118,7 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
    b.base = src.header.point("INSBASE").filter(|p| p.x.is_finite() && p.y.is_finite() && p.z.is_finite()).unwrap_or_default();
    let mut ents = Vec::new();
    for e in src.model.iter() {
-        let e = adopt(&mut d, e, &renames);
+        let e = adopt(&mut d, src, e, &renames);
        d.ensure_layer(&e.common.layer);
        ents.push(e);
    }
@@ -183,9 +183,20 @@ fn block_names(d: &Drawing, src: &Drawing, defining: &str) -> BTreeMap<String, S

 /// A copy of a source entity for this drawing: a fresh handle, block references renamed, and
 /// links to other source objects (associative dimension points) dropped.
-fn adopt(d: &mut Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
+fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
    let mut e = e.clone();
+    let old = e.handle;
    e.handle = d.new_handle();
+    // An attribute definition keeps its field: its extension dictionary and the objects in it.
+    if matches!(e.kind, EntityKind::AttDef(_))
+        && let Some(root) = src.foreign.entities.get(&old).and_then(|x| x.xdict)
+    {
+        let tree = src.foreign.tree(root);
+        let fresh: Vec<Handle> = (0..tree.len() + 2).map(|_| d.new_handle()).collect();
+        let foreign = Arc::make_mut(&mut d.foreign);
+        foreign.adopt_tree(&src.foreign, &tree, &fresh, e.handle);
+        foreign.entities.entry(e.handle).or_default().xdict = fresh.first().copied();
+    }
    match &mut e.kind {
        EntityKind::Insert(i) => {
            if let Some(n) = renames.get(&i.block) {
@@ -197,7 +197,21 @@ pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
                .collect()
        }
        Kind::Linetypes => {
-            let used = lower(&mut entities(d).map(|e| e.common.linetype.clone()).chain(d.layers.iter().map(|l| l.linetype.clone())));
+            // Objects and layers use linetypes, and so do dimension styles and a dimension's own
+            // overrides (DIMLTYPE, DIMLTEX1, DIMLTEX2), and multiline styles' elements.
+            let styles = d.dim_styles.iter().flat_map(|s| [s.dim_linetype.clone(), s.ext_linetype1.clone(), s.ext_linetype2.clone()]);
+            let overrides = entities(d).filter_map(|e| if let EntityKind::Dimension(dm) = &e.kind { Some(dm) } else { None }).flat_map(|dm| {
+                ["dimLinetype", "extLinetype1", "extLinetype2"].into_iter().filter_map(|k| dm.overrides.get(k)?.as_str().map(str::to_string))
+            });
+            let mlines = d.mline_styles.iter().flat_map(|s| s.elements.iter().map(|el| el.linetype.clone()));
+            let used = lower(
+                &mut entities(d)
+                    .map(|e| e.common.linetype.clone())
+                    .chain(d.layers.iter().map(|l| l.linetype.clone()))
+                    .chain(styles)
+                    .chain(overrides)
+                    .chain(mlines),
+            );
            let cur = d.header.str("CELTYPE", "ByLayer");
            d.linetypes
                .iter()
@@ -218,6 +232,7 @@ pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
            let used = lower(&mut entities(d).filter_map(|e| match &e.kind {
                EntityKind::Dimension(dm) => Some(dm.style.clone()),
                EntityKind::Tolerance(t) => Some(t.style.clone()),
+                EntityKind::Leader(l) => Some(l.style.clone()),
                _ => None,
            }));
            let cur = d.header.str("DIMSTYLE", "Standard");
@@ -299,6 +314,41 @@ fn retain<T>(v: &mut Vec<T>, name: impl Fn(&T) -> &String, n: &str) -> bool {
    v.len() != before
 }

+/// Most passes [`purge_unused`] makes: each can free what the last one's objects used (a nested
+/// block, its layer, that layer's linetype).
+const MAX_PASSES: usize = 64;
+
+/// Remove every named object drawing `d` doesn't use, as PURGE All would, nested ones included;
+/// the defaults and the current ones stay. For a drawing being written (WBLOCK's), not the one
+/// being edited: nothing goes through the session or its undo.
+pub(in crate::cmd) fn purge_unused(d: &mut Drawing) {
+    for _ in 0..MAX_PASSES {
+        let mut removed = false;
+        for kind in ALL {
+            for name in candidates(d, *kind) {
+                removed |= match kind {
+                    Kind::Blocks => {
+                        let key = d.blocks.keys().find(|k| k.eq_ignore_ascii_case(&name)).cloned();
+                        key.is_some_and(|k| d.blocks.remove(&k).is_some())
+                    }
+                    Kind::Layers => retain(&mut d.layers, |l| &l.name, &name),
+                    Kind::TextStyles => retain(&mut d.text_styles, |t| &t.name, &name),
+                    Kind::Linetypes => retain(&mut d.linetypes, |t| &t.name, &name),
+                    Kind::Dimstyles => retain(&mut d.dim_styles, |t| &t.name, &name),
+                    Kind::MleaderStyles => retain(&mut d.mleader_styles, |t| &t.name, &name),
+                    Kind::MlineStyles => retain(&mut d.mline_styles, |t| &t.name, &name),
+                    Kind::TableStyles => retain(&mut d.table_styles, |t| &t.name, &name),
+                    Kind::Groups => retain(&mut d.groups, |g| &g.name, &name),
+                    Kind::ZeroLength | Kind::EmptyText | Kind::Absent | Kind::All => false,
+                };
+            }
+        }
+        if !removed {
+            break;
+        }
+    }
+}
+
 /// Model-space and layout objects with no length, or text with no characters.
 fn degenerate(d: &Drawing, kind: Kind) -> Vec<Handle> {
    let zero = |e: &EntityKind| match e {
@@ -281,6 +281,8 @@ fn close(s: &mut Session, save: bool) -> Result<Value> {
    }
    nd.end_refedit_discard(&r);
    *s.doc_mut()? = nd;
+    // The objects the edit managed were its own: OOPS doesn't bring them back after it.
+    s.state_mut()?.erased.forget(|h| r.owns(h));
    s.set_selection(Vec::new());
    Ok(json!({ "block": r.block, "saved": save, "objects": objects }))
 }
@@ -0,0 +1,353 @@
+//! WBLOCK (its JSON form) and -WBLOCK at the command line: objects, a block or the whole drawing
+//! written to a drawing file.
+
+use std::collections::BTreeMap;
+
+use cadcraft_doc::{Drawing, Entity, Handle};
+use cadcraft_geom::{Mat3, Vec2, Vec3};
+use serde_json::{Value, json};
+
+use super::super::curves::KW;
+use super::super::file::{drops_unknown, new_folder, not_saved, not_saved_message, report_new_folder, report_not_saved};
+use super::super::machines::{SelOutcome, SelectPhase};
+use super::super::modify::erase_kept;
+use super::super::{CommandSpec, bad, point_param, str_param, targets};
+use super::insert_file::stem;
+use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
+
+pub(super) fn wblock_spec() -> CommandSpec {
+    CommandSpec::new("wblock", "Write Block", run_wblock).alias(&["w"]).params("{path, name? | handles?, base?}")
+}
+
+/// -WBLOCK erases the objects it writes, whatever its mOde option says: AutoCAD 2024 does, and
+/// keeps "Object conversion=Delete" as the setting. OOPS brings them back, as after ERASE.
+pub(super) fn dash_wblock_spec() -> CommandSpec {
+    CommandSpec::new("-wblock", "Write Block", run_dash_wblock)
+        .params("{path, name? | handles?, base?} (the objects written are erased)")
+        .interactive(|_| Ok(Box::new(DashWblockM::default())))
+}
+
+/// The web build has no file system: -WBLOCK would erase objects it can't save.
+const NO_FILES: &str = "files can't be written in the web build";
+
+/// What WBLOCK writes.
+enum Source<'a> {
+    /// These objects, `base` becoming the written drawing's origin.
+    Objects(&'a [Handle], Vec2),
+    /// A block's objects, from its base point or `base` (in block coordinates).
+    Block(&'a str, Option<Vec2>),
+    /// The whole drawing.
+    Whole,
+}
+
+fn run_wblock(s: &mut Session, p: &Value) -> Result<Value> {
+    let path = str_param(p, "path").ok_or_else(|| bad("wblock", "`path` is required"))?.to_string();
+    let base = point_param(p, "base");
+    let folder = new_folder(&path);
+    let (entities, bytes, lost) = match str_param(p, "name") {
+        Some(name) => write(s, "wblock", &path, Source::Block(name, base))?,
+        None => write(s, "wblock", &path, Source::Objects(&targets(s, p)?, base.unwrap_or(Vec2::ZERO)))?,
+    };
+    let mut r = json!({ "path": path, "entities": entities, "bytes": bytes });
+    report_new_folder(s, &mut r, folder);
+    report_not_saved(s, &mut r, &lost);
+    Ok(r)
+}
+
+fn run_dash_wblock(s: &mut Session, p: &Value) -> Result<Value> {
+    if cfg!(target_arch = "wasm32") {
+        return Err(bad("-wblock", NO_FILES));
+    }
+    let path = str_param(p, "path").ok_or_else(|| bad("-wblock", "`path` is required"))?.to_string();
+    let base = point_param(p, "base");
+    let folder = new_folder(&path);
+    let (entities, bytes, lost) = match str_param(p, "name") {
+        Some(name) => write(s, "-wblock", &path, Source::Block(name, base))?,
+        None => {
+            let hs = targets(s, p)?;
+            // As at the command line, nothing selected writes no file.
+            if !hs.iter().any(|h| s.doc().is_ok_and(|d| d.entity(*h).is_some())) {
+                return Err(bad("-wblock", "no objects selected"));
+            }
+            let written = write(s, "-wblock", &path, Source::Objects(&hs, base.unwrap_or(Vec2::ZERO)))?;
+            erase(s, &hs)?;
+            written
+        }
+    };
+    let mut r = json!({ "path": path, "entities": entities, "bytes": bytes });
+    report_new_folder(s, &mut r, folder);
+    report_not_saved(s, &mut r, &lost);
+    Ok(r)
+}
+
+/// Write `what` to `path` through the io hooks; the objects written, the file's size and what a
+/// DWG file left out, for the caller to report as a save does. The
+/// written drawing keeps the source's settings and styles, as AutoCAD's -WBLOCK does: its units
+/// ($INSUNITS, $MEASUREMENT), so a block from a metric drawing is not declared in inches and
+/// scaled on insert, and its defaults (text size, current styles, annotation scales).
+fn write(s: &Session, cmd: &str, path: &str, what: Source) -> Result<(usize, usize, BTreeMap<String, usize>)> {
+    let src = s.doc()?;
+    // The base point becomes the written drawing's origin: by default 0,0 for objects and the
+    // block's base point for a block.
+    let d = match what {
+        Source::Whole => src.clone(),
+        Source::Block(name, base) => {
+            let b = src.block(name).ok_or_else(|| bad(cmd, format!("no block `{name}`")))?;
+            let m = Mat3::translate(-base.unwrap_or(b.base.xy()));
+            with_objects(src, b.entities.iter().map(|e| moved(e, &m)))
+        }
+        Source::Objects(hs, base) => {
+            let m = Mat3::translate(-base);
+            with_objects(src, hs.iter().filter_map(|h| src.entity(*h)).map(|e| moved(e, &m)))
+        }
+    };
+    let hooks = super::super::file::io().ok_or_else(|| bad(cmd, "file formats are not available in this build"))?;
+    let bytes = (hooks.write)(&d, path).map_err(|e| bad(cmd, e))?;
+    // Through a temporary file, as SAVE writes, so a failed write keeps the file it replaces.
+    #[cfg(not(target_arch = "wasm32"))]
+    crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
+    let lost = if drops_unknown(path) { not_saved(&d) } else { BTreeMap::new() };
+    Ok((d.model.len(), bytes.len(), lost))
+}
+
+/// Say on the command line what the written DWG file left out.
+fn echo_not_saved(s: &mut Session, lost: &BTreeMap<String, usize>) {
+    if let Some(msg) = not_saved_message(lost) {
+        s.echo(msg);
+    }
+}
+
+/// A new drawing of `ents`, with `src`'s settings and the layers, linetypes, styles and blocks
+/// they use, as AutoCAD's WBLOCK writes them (#2423): what nothing in it uses is purged, and
+/// the defaults and the current ones stay. Its insertion base is 0,0.
+fn with_objects(src: &Drawing, ents: impl Iterator<Item = Entity>) -> Drawing {
+    let mut d = Drawing::new_imperial();
+    d.header = src.header.clone();
+    d.layers = src.layers.clone();
+    d.linetypes = src.linetypes.clone();
+    d.text_styles = src.text_styles.clone();
+    d.dim_styles = src.dim_styles.clone();
+    d.mleader_styles = src.mleader_styles.clone();
+    d.table_styles = src.table_styles.clone();
+    d.mline_styles = src.mline_styles.clone();
+    d.scales = src.scales.clone();
+    d.blocks = src.blocks.clone();
+    d.header.set("INSBASE", cadcraft_doc::HVal::Point(Vec3::ZERO));
+    // The copied blocks keep their objects' handles, so the new ones start above them.
+    let kept: Vec<Handle> = d.blocks.values().flat_map(|b| b.entities.iter().map(|e| e.handle)).collect();
+    for h in kept {
+        d.bump_handseed(h);
+    }
+    for mut e in ents {
+        e.handle = d.new_handle();
+        d.model.push(e);
+    }
+    super::purge::purge_unused(&mut d);
+    d
+}
+
+fn moved(e: &Entity, m: &Mat3) -> Entity {
+    let mut e = e.clone();
+    e.kind.transform(m);
+    e
+}
+
+fn erase(s: &mut Session, hs: &[Handle]) -> Result<()> {
+    erase_kept(s, hs)?;
+    s.set_selection(Vec::new());
+    Ok(())
+}
+
+/// The file -WBLOCK writes for a typed name: as named when it ends in .dwg or .dxf, else with
+/// .dwg added, as AutoCAD names a drawing.
+fn output_path(typed: &str) -> String {
+    let t = typed.trim().trim_matches('"');
+    let lower = t.to_ascii_lowercase();
+    if lower.ends_with(".dwg") || lower.ends_with(".dxf") { t.to_string() } else { format!("{t}.dwg") }
+}
+
+/// Whether a file is there to replace; the web has no file system.
+fn exists(path: &str) -> bool {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        std::path::Path::new(path).exists()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        let _ = path;
+        false
+    }
+}
+
+/// Where -WBLOCK is in its prompts, as AutoCAD 2024 asks them.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+enum Ask {
+    #[default]
+    File,
+    /// The file exists: "… already exists, do you want to replace it? [Yes/No] <N>".
+    Replace,
+    /// A DXF file's decimal places of accuracy.
+    Precision,
+    /// An existing block, `=` (the block named as the file), `*` (the whole drawing), or Enter
+    /// for objects.
+    Block,
+    Base,
+    /// mOde at the base point prompt: asked, but the objects are erased whatever it says.
+    Mode,
+    Objects,
+}
+
+const SAME_NAME: &str = "= (block=output file)";
+const WHOLE: &str = "* (whole drawing)";
+
+#[derive(Default)]
+struct DashWblockM {
+    ask: Ask,
+    path: String,
+    base: Vec2,
+    sel: SelectPhase,
+}
+
+impl Interactive for DashWblockM {
+    fn name(&self) -> &'static str {
+        "WBLOCK"
+    }
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        if cfg!(target_arch = "wasm32") {
+            s.echo(format!("-WBLOCK: {NO_FILES}."));
+            return Ok(Step::Cancel);
+        }
+        s.echo("Current settings: Object conversion=Delete");
+        Ok(Step::Continue)
+    }
+    fn prompt(&self, _s: &Session) -> Prompt {
+        match self.ask {
+            Ask::File => Prompt::new("Enter name of output file", Accept::TEXT),
+            Ask::Replace => Prompt::new(format!("{} already exists, do you want to replace it?", self.path), KW).kw(&["Yes", "No"]).default("N"),
+            Ask::Precision => Prompt::new("Enter decimal places of accuracy (0 to 16)", Accept::NUMBER).kw(&["Binary", "Preview"]).default("16"),
+            Ask::Block => Prompt::new("Enter name of existing block", Accept::TEXT).kw(&[SAME_NAME, WHOLE]).default("define new drawing"),
+            Ask::Base => Prompt::new("Specify insertion base point", Accept::POINT).kw(&["mOde"]),
+            Ask::Mode => {
+                Prompt::new("Choose mode for selected object conversion", KW).kw(&["Convert to block", "Retain", "Delete"]).default("Delete")
+            }
+            Ask::Objects => self.sel.prompt(),
+        }
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        match self.ask {
+            Ask::File => {
+                if let Input::Text(t) = &i
+                    && !t.trim().trim_matches('"').is_empty()
+                {
+                    self.path = output_path(t);
+                    self.ask = if exists(&self.path) { Ask::Replace } else { self.after_file(s) };
+                }
+                Ok(Step::Continue)
+            }
+            Ask::Replace => match &i {
+                // Yes goes on; No, the default, ends the command; anything else is asked again.
+                Input::Keyword(k) if k == "Yes" => {
+                    self.ask = self.after_file(s);
+                    Ok(Step::Continue)
+                }
+                Input::Keyword(_) | Input::Enter => Ok(Step::Done),
+                _ => {
+                    s.echo("Invalid option keyword.");
+                    Ok(Step::Continue)
+                }
+            },
+            Ask::Precision => {
+                match &i {
+                    Input::Enter => self.ask = Ask::Block,
+                    // The file is written at full precision whatever is asked.
+                    Input::Text(t) if t.trim().parse::<u8>().is_ok_and(|n| n <= 16) => self.ask = Ask::Block,
+                    Input::Keyword(k) if k == "Binary" => s.echo("Binary DXF output is not available."),
+                    Input::Keyword(_) => {}
+                    _ => s.echo("Requires an integer between 0 and 16."),
+                }
+                Ok(Step::Continue)
+            }
+            Ask::Block => {
+                let name = match &i {
+                    Input::Enter => {
+                        self.ask = Ask::Base;
+                        return Ok(Step::Continue);
+                    }
+                    Input::Keyword(k) if k == WHOLE => return self.write(s, Source::Whole),
+                    Input::Keyword(k) if k == SAME_NAME => stem(&self.path),
+                    Input::Text(t) => t.trim().to_string(),
+                    // A point (from a LISP list) is a name too: AutoCAD answers Block "0,0" not found.
+                    Input::Point(p) => format!("{},{}", p.x, p.y),
+                    _ => return Ok(Step::Continue),
+                };
+                if s.doc()?.block(&name).is_none() {
+                    s.echo(format!("Block \"{name}\" not found."));
+                    return Ok(Step::Continue);
+                }
+                self.write(s, Source::Block(&name, None))
+            }
+            Ask::Base => {
+                match i {
+                    Input::Keyword(_) => self.ask = Ask::Mode,
+                    Input::Enter | Input::Text(_) => s.echo("Point or option keyword required."),
+                    Input::Point(p) => {
+                        self.base = p;
+                        self.sel = SelectPhase::begin(s);
+                        if self.sel.done {
+                            let picked = self.sel.picked.clone();
+                            return self.write_objects(s, &picked);
+                        }
+                        self.ask = Ask::Objects;
+                    }
+                    _ => {}
+                }
+                Ok(Step::Continue)
+            }
+            Ask::Mode => {
+                // Any answer, Enter included, goes back to the base point.
+                self.ask = Ask::Base;
+                Ok(Step::Continue)
+            }
+            Ask::Objects => match self.sel.feed(s, &i)? {
+                SelOutcome::More => Ok(Step::Continue),
+                // Nothing selected: nothing is written.
+                SelOutcome::Empty => Ok(Step::Done),
+                SelOutcome::Done(hs) => self.write_objects(s, &hs),
+            },
+        }
+    }
+}
+
+impl DashWblockM {
+    /// The prompt after the file name: a DXF file's precision, else the block.
+    fn after_file(&self, s: &mut Session) -> Ask {
+        if self.path.to_ascii_lowercase().ends_with(".dxf") {
+            s.echo("Current DXF settings: Precision= 16 Format= ASCII Preview= No");
+            Ask::Precision
+        } else {
+            Ask::Block
+        }
+    }
+
+    fn write(&self, s: &mut Session, what: Source) -> Result<Step> {
+        match write(s, "-wblock", &self.path, what) {
+            Ok((.., lost)) => echo_not_saved(s, &lost),
+            Err(e) => s.echo(e.to_string()),
+        }
+        Ok(Step::Done)
+    }
+
+    fn write_objects(&self, s: &mut Session, hs: &[Handle]) -> Result<Step> {
+        if hs.is_empty() {
+            return Ok(Step::Done);
+        }
+        match write(s, "-wblock", &self.path, Source::Objects(hs, self.base)) {
+            Ok((.., lost)) => {
+                echo_not_saved(s, &lost);
+                erase(s, hs)?;
+            }
+            Err(e) => s.echo(e.to_string()),
+        }
+        Ok(Step::Done)
+    }
+}
@@ -208,7 +208,7 @@ pub(crate) fn find(path: &str, host: Option<&Path>, chosen: bool) -> Result<Path
    }
    let (files, refused) = candidates(path, host, chosen);
    #[cfg(not(target_arch = "wasm32"))]
-    let found = files.into_iter().find(|p| p.is_file());
+    let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| files.iter().find_map(|p| case_insensitive(p)));
    #[cfg(target_arch = "wasm32")]
    let found: Option<PathBuf> = {
        let _ = files;
@@ -217,6 +217,43 @@ pub(crate) fn find(path: &str, host: Option<&Path>, chosen: bool) -> Result<Path
    found.ok_or(refused.map_or(Missing::NotFound, Missing::Refused))
 }

+/// Upper bound on directory entries scanned per path component by [`case_insensitive`].
+#[cfg(not(target_arch = "wasm32"))]
+const MAX_CASE_SCAN: usize = 10_000;
+
+/// The existing file `p` names when its letters' case is ignored, on file systems that don't
+/// ignore it themselves. Drawings made on Windows often store a reference as `PLAN.DWG` for
+/// `Plan.dwg`; Windows finds it, and so should Linux. Each missing component is matched against
+/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing.
+#[cfg(not(target_arch = "wasm32"))]
+fn case_insensitive(p: &Path) -> Option<PathBuf> {
+    use std::path::Component;
+    let mut out = PathBuf::new();
+    for c in p.components() {
+        let Component::Normal(name) = c else {
+            out.push(c.as_os_str());
+            continue;
+        };
+        let exact = out.join(name);
+        if exact.exists() {
+            out = exact;
+            continue;
+        }
+        let want = name.to_str()?.to_lowercase();
+        let mut hits = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out })
+            .ok()?
+            .take(MAX_CASE_SCAN)
+            .flatten()
+            .filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
+        let hit = hits.next()?;
+        if hits.next().is_some() {
+            return None;
+        }
+        out.push(hit.file_name());
+    }
+    out.is_file().then_some(out)
+}
+
 /// Read a drawing file through the host's io hooks, counting its bytes against the load's total.
 fn read(file: &Path, cx: &mut Ctx) -> Result<Drawing, String> {
    let hooks = super::super::super::file::io().ok_or("file formats are not available in this build")?;
@@ -33,6 +33,7 @@ use point::{DonutM, PointM, RayM, run_donut, run_point, run_ray};
 use polygon::{PolygonM, run_polygon};
 use solid::{SolidM, run_solid};
 use spline::{SplineM, run_spline};
+pub(crate) use text::justify;
 use text::{MTextM, TextM, run_mtext, run_text};

 /// Every draw command's spec: JSON parameters, menu path, aliases and the interactive prompt
@@ -153,19 +153,17 @@ impl Interactive for HelixM {
        }
        match (self.center, self.rb, self.rt) {
            (None, ..) => Prompt::new("Specify center point of base", Accept::POINT),
-            (Some(c), None, _) => {
-                Prompt::new(if self.diameter { "Specify base diameter" } else { "Specify base radius or" }, Accept::POINT_OR_NUMBER)
-                    .kw(if self.diameter { &[] } else { &["Diameter"] })
-                    .default("1.0000")
-                    .base(c)
-            }
+            (Some(c), None, _) => Prompt::new(if self.diameter { "Specify base diameter" } else { "Specify base radius" }, Accept::POINT_OR_NUMBER)
+                .kw(if self.diameter { &[] } else { &["Diameter"] })
+                .default("1.0000")
+                .base(c),
            (Some(c), Some(rb), None) => {
-                Prompt::new(if self.diameter { "Specify top diameter" } else { "Specify top radius or" }, Accept::POINT_OR_NUMBER)
+                Prompt::new(if self.diameter { "Specify top diameter" } else { "Specify top radius" }, Accept::POINT_OR_NUMBER)
                    .kw(if self.diameter { &[] } else { &["Diameter"] })
                    .default(format!("{rb:.4}"))
                    .base(c)
            }
-            (Some(c), Some(_), Some(_)) => Prompt::new("Specify helix height or", Accept::POINT_OR_NUMBER)
+            (Some(c), Some(_), Some(_)) => Prompt::new("Specify helix height", Accept::POINT_OR_NUMBER)
                .kw(&["Axis endpoint", "Turns", "turn Height", "tWist"])
                .default("1.0000")
                .base(c),
@@ -2,6 +2,7 @@ use super::{
    Accept, EntityKind, Input, Interactive, PolyVertex, Prompt, Result, Session, Step, Value, Vec2, added, bad, bool_or, curves, f64_or, lwpoly,
    number, other, point_param, point_req, rect_with_corners, size_param,
 };
+use crate::last_used::RectangModes;

 // =====================================================================================
 // RECTANG with Area / Dimensions / Rotation / Width / Elevation / Thickness
@@ -115,11 +116,58 @@ pub(crate) struct RectM2 {
    asking: Option<RAsk>,
 }

+/// A rectangle's rotation as AutoCAD 2024 shows it: degrees from 0 to 360, two decimals.
+fn rotation_text(rotation: f64) -> String {
+    let t = format!("{:.2}", rotation.to_degrees().rem_euclid(360.0));
+    if t == "360.00" { "0.00".into() } else { t }
+}
+
+/// AutoCAD 2024's line listing the RECTANG modes that are set, `None` when none is ("Current
+/// rectangle modes:  Chamfer=2.2518 x 3.7663  Rotation=50.50"): distances in the drawing's
+/// units, the rotation as [`rotation_text`] shows it.
+fn modes_line(s: &Session, m: &RectangModes) -> Option<String> {
+    let (u, p) = s.doc().map(|d| (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4))).unwrap_or((2, 4));
+    let d = |v: f64| crate::units::format_distance(v, u, p);
+    let mut parts = Vec::new();
+    if m.chamfer.0 > 0.0 || m.chamfer.1 > 0.0 {
+        parts.push(format!("Chamfer={} x {}", d(m.chamfer.0), d(m.chamfer.1)));
+    }
+    if m.fillet > 0.0 {
+        parts.push(format!("Fillet={}", d(m.fillet)));
+    }
+    if m.elevation != 0.0 {
+        parts.push(format!("Elevation={}", d(m.elevation)));
+    }
+    if m.thickness != 0.0 {
+        parts.push(format!("Thickness={}", d(m.thickness)));
+    }
+    if m.width > 0.0 {
+        parts.push(format!("Width={}", d(m.width)));
+    }
+    let rot = rotation_text(m.rotation);
+    if rot != "0.00" {
+        parts.push(format!("Rotation={rot}"));
+    }
+    (!parts.is_empty()).then(|| format!("Current rectangle modes:  {}", parts.join("  ")))
+}
+
 impl RectM2 {
+    /// The modes the next rectangle starts from.
+    fn modes(&self) -> RectangModes {
+        RectangModes {
+            chamfer: self.chamfer,
+            fillet: self.fillet,
+            width: self.width,
+            elevation: self.elevation,
+            thickness: self.thickness,
+            rotation: self.rotation,
+        }
+    }
    /// Adds the rectangle of full size `w` × `h` with the collected options, drawing it from
    /// the centre when centre mode is on, then applies the requested thickness.
    fn make(&self, s: &mut Session, w: f64, h: f64) -> Result<Step> {
        let Some(a) = self.first else { return Ok(Step::Cancel) };
+        s.last_used.rectang = self.modes();
        if w.abs() < 1e-12 || h.abs() < 1e-12 {
            return Err(other("The rectangle has no area."));
        }
@@ -155,6 +203,20 @@ impl Interactive for RectM2 {
    fn name(&self) -> &'static str {
        "RECTANG"
    }
+    /// Starts from the modes the last rectangle left, and lists the ones that are set.
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        let m = s.last_used.rectang;
+        self.chamfer = m.chamfer;
+        self.fillet = m.fillet;
+        self.width = m.width;
+        self.elevation = m.elevation;
+        self.thickness = m.thickness;
+        self.rotation = m.rotation;
+        if let Some(line) = modes_line(s, &m) {
+            s.echo(line);
+        }
+        Ok(Step::Continue)
+    }
    /// Asks for the pending option's value, or for the first and second points; in centre mode
    /// the first prompt asks for the centre instead of a corner.
    fn prompt(&self, _s: &Session) -> Prompt {
@@ -173,9 +235,9 @@ impl Interactive for RectM2 {
                RAsk::AreaWidth => num("Enter rectangle width", 10.0),
                RAsk::DimL => num("Specify length for rectangles", self.dims.map(|d| d.0).unwrap_or(10.0)),
                RAsk::DimW => num("Specify width for rectangles", self.dims.map(|d| d.1).unwrap_or(10.0)),
-                RAsk::Rotation => Prompt::new("Specify rotation angle or", Accept::POINT_OR_NUMBER)
+                RAsk::Rotation => Prompt::new("Specify rotation angle", Accept::POINT_OR_NUMBER)
                    .kw(&["Pick points"])
-                    .default(format!("{:.0}", self.rotation.to_degrees()))
+                    .default(rotation_text(self.rotation))
                    .base_opt(self.first),
                RAsk::RotPick1 => Prompt::new("Specify first point", Accept::POINT),
                RAsk::RotPick2(b) => Prompt::new("Specify second point", Accept::POINT).base(b),
@@ -207,8 +269,14 @@ impl Interactive for RectM2 {
                    self.chamfer.1 = self.chamfer.0;
                    self.asking = Some(RAsk::Chamfer2);
                }
-                RAsk::Chamfer2 => self.chamfer.1 = val(&i, self.chamfer.1)?.max(0.0),
-                RAsk::Fillet => self.fillet = val(&i, self.fillet)?.max(0.0),
+                RAsk::Chamfer2 => {
+                    self.chamfer.1 = val(&i, self.chamfer.1)?.max(0.0);
+                    self.fillet = 0.0;
+                }
+                RAsk::Fillet => {
+                    self.fillet = val(&i, self.fillet)?.max(0.0);
+                    self.chamfer = (0.0, 0.0);
+                }
                RAsk::Width => self.width = val(&i, self.width)?.max(0.0),
                RAsk::Elevation => self.elevation = val(&i, self.elevation)?,
                RAsk::Thickness => self.thickness = val(&i, self.thickness)?,
@@ -260,6 +328,8 @@ impl Interactive for RectM2 {
                    }
                }
            }
+            // A mode is kept as soon as it is set, even if no rectangle follows.
+            s.last_used.rectang = self.modes();
            return Ok(Step::Continue);
        }
        match i {
@@ -996,7 +996,8 @@ fn rectang_options_command_line() {
    s.cmdline("rectang 0,0 r p 0,0 1,1 d 2 2 5,5").unwrap();
    let pts = rect_pts(&s);
    assert!(pts.iter().any(|p| near(*p, 0.0, 8f64.sqrt())), "{pts:?}");
-    s.cmdline("rectang w 0.5 c 0.5 0.5 0,0 4,4").unwrap();
+    // RECTANG keeps the rotation of the rectangle before (45 degrees), as AutoCAD does: back to 0.
+    s.cmdline("rectang w 0.5 c 0.5 0.5 0,0 r 0 4,4").unwrap();
    match last(&s) {
        EntityKind::LwPolyline(p) => assert!(p.const_width == 0.5 && p.vertices.len() == 8),
        k => panic!("{k:?}"),
@@ -119,7 +119,7 @@ impl Interactive for XlineM2 {
                Some(b) => Prompt::new("Specify through point", Accept::POINT).base(b),
            },
            XMode::Fixed(_) => Prompt::new("Specify through point", Accept::POINT),
-            XMode::AngAsk => Prompt::new("Enter angle of xline (0) or", Accept::NUMBER).kw(&["Reference"]),
+            XMode::AngAsk => Prompt::new("Enter angle of xline (0)", Accept::NUMBER).kw(&["Reference"]),
            XMode::RefSelect => Prompt::new("Select a line object", Accept::POINT),
            XMode::RefAngle(_) => Prompt::new("Enter angle of xline", Accept::NUMBER).default("0"),
            XMode::Bisect => match self.bis.len() {
@@ -129,7 +129,7 @@ impl Interactive for XlineM2 {
            },
            XMode::OffDist => {
                let d = s.doc().map(|d| d.header.f64("OFFSETDIST", 1.0)).unwrap_or(1.0);
-                Prompt::new("Specify offset distance or", Accept::NUMBER).kw(&["Through"]).default(if d < 0.0 {
+                Prompt::new("Specify offset distance", Accept::NUMBER).kw(&["Through"]).default(if d < 0.0 {
                    "Through".into()
                } else {
                    format!("{d:.4}")
@@ -549,13 +549,7 @@ fn run_pasteorig(s: &mut Session, _p: &Value) -> Result<Value> {
 fn run_clear(s: &mut Session, _p: &Value) -> Result<Value> {
    let mut hs = s.selection();
    hs.retain(|h| !super::curves::is_locked(s, *h));
-    let d = s.doc_mut()?;
-    let mut n = 0;
-    for h in hs {
-        if d.remove_entity(h).is_some() {
-            n += 1;
-        }
-    }
+    let n = super::modify::erase_kept(s, &hs)?;
    s.set_selection(Vec::new());
    Ok(json!({ "erased": n }))
 }
@@ -82,7 +82,7 @@ fn write_file(cmd: &str, path: &str, bytes: &[u8]) -> Result<()> {
    {
        // Exclusively create a fresh temporary file and rename it into place so a planted
        // `<path>.cadcraft-tmp` symlink cannot redirect the export write (CWE-59).
-        crate::atomic_write::write_atomic(std::path::Path::new(path), bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))
+        crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))
    }
    #[cfg(target_arch = "wasm32")]
    {
@@ -117,14 +117,19 @@ fn run_export(s: &mut Session, p: &Value) -> Result<Value> {
    if !EXPORT_FORMATS.contains(&format.as_str()) {
        return Err(bad("export", "`format` must be dxf, dwg, svg, png or pdf (or give a `path` with one of those extensions)"));
    }
-    let bytes = (hooks.write)(s.doc()?, &format!("export.{format}")).map_err(|e| bad("export", e))?;
-    match path {
+    let file = format!("export.{format}");
+    let bytes = (hooks.write)(s.doc()?, &file).map_err(|e| bad("export", e))?;
+    let folder = path.and_then(super::file::new_folder);
+    let mut r = match path {
        Some(path) => {
            write_file("export", path, &bytes)?;
-            Ok(json!({ "path": path, "format": format, "bytes": bytes.len(), "message": format!("Exported to {path}") }))
+            json!({ "path": path, "format": format, "bytes": bytes.len(), "message": format!("Exported to {path}") })
        }
-        None => Ok(json!({ "data": base64_encode(&bytes), "format": format, "bytes": bytes.len() })),
-    }
+        None => json!({ "data": base64_encode(&bytes), "format": format, "bytes": bytes.len() }),
+    };
+    super::file::report_new_folder(s, &mut r, folder);
+    super::file::report_loss(s, &mut r, &file);
+    Ok(r)
 }

 // ---------- IMPORT ----------
@@ -330,17 +335,23 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
    if let Some(l) = p.get("landscape").and_then(Value::as_bool) {
        page.landscape = l;
    }
+    // A layout's saved page setup (plot window, scale to fit, scale, centring) applies unless the call says otherwise (#2493).
+    // An explicit `fit: false` without a `scale` asks for the plain 1:1 plot.
+    let plain = p.get("fit").and_then(Value::as_bool) == Some(false) && p.get("scale").is_none();
+    let saved = if space.is_paper() && !plain { cadcraft_render::paper::saved_plot(&page) } else { Default::default() };
    let sheet = Sheet::from_page(&page, paper::page_unit_mm(d, &page));
    let lineweights = p.get("lineweights").and_then(Value::as_bool).unwrap_or(if space.is_paper() { page.lineweights } else { true });
    let transparency = super::plotters::plot_transparency(s, p).unwrap_or(page.plot_transparency);
-    let fit = p.get("fit").and_then(Value::as_bool).unwrap_or(matches!(space, Space::Model));
-    let scale = p.get("scale").and_then(Value::as_f64).filter(|v| v.is_finite() && *v > 0.0);
+    let given_scale = p.get("scale").and_then(Value::as_f64).filter(|v| v.is_finite() && *v > 0.0);
+    // A saved scale to fit applies only when the call gives neither `fit` nor `scale`, as in the PDF.
+    let fit = p.get("fit").and_then(Value::as_bool).unwrap_or(matches!(space, Space::Model) || (saved.fit && given_scale.is_none()));
+    let scale = given_scale.or(saved.scale);
    let width = p.get("width").and_then(Value::as_u64).unwrap_or(PREVIEW_PX).clamp(16, MAX_PREVIEW_PX);
    let height = ((width as f64) * sheet.size.y / sheet.size.x).round();
    let height = if height.is_finite() { (height as u64).clamp(16, MAX_PREVIEW_PX) } else { width };
    let px_per_paper_unit = width as f64 / sheet.size.x;
    // Curves are flattened to about half a pixel.
-    let est = plot_scale(&d.extents(&space), &sheet, fit, scale);
+    let est = plot_scale(&saved.window.unwrap_or_else(|| d.extents(&space)), &sheet, fit, scale);
    let tol = 0.5 / (px_per_paper_unit * est);
    let ropts = cadcraft_render::Options {
        tolerance: if tol.is_finite() && tol > 0.0 { tol } else { 0.01 },
@@ -352,9 +363,13 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
        ..Default::default()
    };
    let list = cadcraft_render::build_plot(d, &space, &ropts);
-    let b = list.bounds;
+    let b = saved.window.unwrap_or(list.bounds);
    // Paper point q shows drawing point (q - to) / k + from.
-    let (from, k, to) = if fit || space == Space::Model {
+    let (from, k, to) = if saved.window.is_some() {
+        // A saved window, fitted or at a saved scale: its centre (or corner) on the printable area's.
+        let c = saved.center;
+        (if c { b.center() } else { b.min }, plot_scale(&b, &sheet, fit, scale), if c { sheet.printable.center() } else { sheet.printable.min })
+    } else if fit || space == Space::Model {
        (if b.is_empty() { Vec2::ZERO } else { b.center() }, plot_scale(&b, &sheet, fit, scale), sheet.printable.center())
    } else {
        (Vec2::ZERO, plot_scale(&b, &sheet, fit, scale), Vec2::ZERO)
@@ -372,7 +387,20 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
        px_per_mm: if lineweights && px_per_mm.is_finite() { px_per_mm } else { 0.0 },
        antialias: true,
    };
-    let png = cadcraft_render::raster::render_png(&list, &view, &ro).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
+    let mut pm = cadcraft_render::raster::render(&list, &view, &ro).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
+    // A placed plot (fitted, or a saved window) shows only inside the printable area, as the PDF and PNG plots clip it.
+    if fit || saved.window.is_some() || space == Space::Model {
+        // The view may scale and centre the sheet (the height cap), so map the printable corners
+        // (paper point q shows drawing point (q - to) / k + from) through it.
+        let screen = |q: Vec2| {
+            let (x, y) = view.to_screen((q - to) / k + from);
+            (f64::from(x), f64::from(y))
+        };
+        let (min, max) = (sheet.printable.min, sheet.printable.max);
+        let (a, b) = (screen(Vec2::new(min.x, max.y)), screen(Vec2::new(max.x, min.y)));
+        cadcraft_render::raster::blank_outside_pixels(&mut pm, a, b);
+    }
+    let png = pm.encode_png().map_err(|_| bad("preview", "rendering the preview failed"))?;
    let layout = space.tab_name();
    Ok(json!({ "data": base64_encode(&png), "width": w, "height": h, "layout": layout, "paper": page.paper, "landscape": page.landscape }))
 }
@@ -738,6 +766,140 @@ mod tests {
        assert_ne!(png(&mut s, json!({ "layout": "Layout1", "width": 200, "fit": false, "scale": 0.5 })), default, "scale 0.5 is not 1:1");
    }

+    /// A layout's saved page setup (plot window, scale to fit) shapes its preview by default, as
+    /// it shapes the PDF; `fit: false` still gives the plain 1:1 sheet (#2493).
+    #[test]
+    fn preview_uses_the_layouts_saved_page_setup_by_default() {
+        let mut s = Session::new();
+        s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
+        s.execute("line", &json!({ "points": [[20.0, 5.0], [836.0, 589.0]] })).unwrap();
+        s.execute("pagesetup", &json!({ "layout": "Layout1", "paper": "A4", "landscape": true, "margins": [0, 0, 0, 0] })).unwrap();
+        let png = |s: &mut Session, p: Value| s.execute("preview", &p).unwrap()["data"].as_str().unwrap_or_default().to_string();
+        let unsaved = png(&mut s, json!({ "layout": "Layout1", "width": 200 }));
+        let page = &mut s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page;
+        page.plot_area = "window".into();
+        page.plot_window = [20.0, 5.0, 836.0, 589.0];
+        page.scale_to_fit = true;
+        let saved = png(&mut s, json!({ "layout": "Layout1", "width": 200 }));
+        assert_ne!(saved, unsaved, "the saved window and scale to fit change the preview");
+        assert_eq!(png(&mut s, json!({ "layout": "Layout1", "width": 200, "fit": false })), unsaved, "fit: false is the plain 1:1 sheet");
+    }
+
+    /// With a saved plot window the preview follows the page setup's centring (fitted or not) and an
+    /// explicit `scale` beats a saved scale to fit, as in the PDF.
+    /// A placed saved window shows only inside the printable area, as the PDF and PNG plots clip it:
+    /// geometry in the margin leaves the preview unchanged.
+    #[test]
+    fn preview_clips_a_saved_window_to_the_printable_area() {
+        let build = |margin_line: bool| {
+            let mut s = Session::new();
+            s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
+            s.execute("line", &json!({ "points": [[0.0, 30.0], [100.0, 30.0]] })).unwrap();
+            if margin_line {
+                s.execute("line", &json!({ "points": [[-3.0, 0.0], [-3.0, 60.0]] })).unwrap();
+            }
+            s.execute("pagesetup", &json!({ "layout": "Layout1", "paper": "A4", "landscape": true, "margins": [10, 10, 10, 10] })).unwrap();
+            let page = &mut s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page;
+            page.plot_area = "window".into();
+            page.plot_window = [0.0, 0.0, 100.0, 60.0];
+            page.scale_to_fit = true;
+            page.center = true;
+            s.execute("preview", &json!({ "layout": "Layout1", "width": 600 })).unwrap()["data"].as_str().unwrap_or_default().to_string()
+        };
+        assert_eq!(build(true), build(false), "a line in the margin is clipped away");
+    }
+
+    /// On a tall sheet the height cap makes the view scale and centre the sheet in the image; the
+    /// printable clip must follow it, so ink in the margin is still blanked.
+    #[test]
+    fn preview_clip_follows_the_view_when_the_height_cap_applies() {
+        let build = |margin_line: bool| {
+            let mut s = Session::new();
+            s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
+            s.execute("line", &json!({ "points": [[0.0, 50.0], [100.0, 50.0]] })).unwrap();
+            if margin_line {
+                s.execute("line", &json!({ "points": [[-2.6, 0.0], [-2.6, 100.0]] })).unwrap();
+            }
+            s.execute("pagesetup", &json!({ "layout": "Layout1", "margins": [10, 10, 10, 10] })).unwrap();
+            let page = &mut s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page;
+            page.width_mm = 210.0;
+            page.height_mm = 1200.0;
+            page.landscape = false;
+            page.plot_area = "window".into();
+            page.plot_window = [0.0, 0.0, 100.0, 100.0];
+            page.scale_to_fit = true;
+            page.center = true;
+            s.execute("preview", &json!({ "layout": "Layout1", "width": 1000 })).unwrap()["data"].as_str().unwrap_or_default().to_string()
+        };
+        assert_eq!(build(true), build(false), "a line in the margin is clipped away on a tall sheet");
+    }
+
+    /// Hostile saved setups (a degenerate or far-away window, a scale of 0 or not finite) fall back
+    /// to the plain preview and never panic, and a layout with no saved setup previews exactly as
+    /// the plain 1:1 sheet does.
+    #[test]
+    fn preview_survives_hostile_saved_setups_and_default_is_unchanged() {
+        let mut s = Session::new();
+        s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
+        s.execute("line", &json!({ "points": [[20.0, 5.0], [200.0, 100.0]] })).unwrap();
+        s.execute("pagesetup", &json!({ "layout": "Layout1", "paper": "A4", "landscape": true })).unwrap();
+        let png = |s: &mut Session, p: Value| s.execute("preview", &p).unwrap()["data"].as_str().unwrap_or_default().to_string();
+        let call = json!({ "layout": "Layout1", "width": 200 });
+        let plain = png(&mut s, json!({ "layout": "Layout1", "width": 200, "fit": false }));
+        assert_eq!(png(&mut s, call.clone()), plain, "no saved setup: the default preview is the plain sheet");
+        let set = |s: &mut Session, window: [f64; 4], scale: f64, fit: bool| {
+            let page = &mut s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page;
+            page.plot_area = "window".into();
+            page.plot_window = window;
+            page.scale = scale;
+            page.scale_to_fit = fit;
+        };
+        let good = [0.0, 0.0, 100.0, 60.0];
+        let (nan, inf) = (f64::NAN, f64::INFINITY);
+        for window in [[5.0, 5.0, 5.0, 40.0], [5.0, 5.0, 40.0, 5.0], [nan, 0.0, 10.0, 10.0], [0.0, 0.0, inf, 10.0]] {
+            set(&mut s, window, 1.0, true);
+            assert_eq!(png(&mut s, call.clone()), plain, "{window:?}: a degenerate window changes nothing");
+        }
+        for scale in [0.0, -2.0, nan, inf] {
+            set(&mut s, good, scale, false);
+            let _ = png(&mut s, call.clone());
+            set(&mut s, [5.0, 5.0, 5.0, 40.0], scale, false);
+            assert_eq!(png(&mut s, call.clone()), plain, "{scale}: an unusable saved scale is ignored");
+        }
+        set(&mut s, [1e9, 1e9, 1e9 + 10.0, 1e9 + 10.0], 1.0, true);
+        let _ = png(&mut s, call.clone());
+        set(&mut s, [-1e300, -1e300, 1e300, 1e300], 1.0, true);
+        let _ = png(&mut s, call.clone());
+    }
+
+    #[test]
+    fn preview_honours_saved_centering_and_an_explicit_scale() {
+        let mut s = Session::new();
+        s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
+        s.execute("line", &json!({ "points": [[20.0, 5.0], [836.0, 589.0]] })).unwrap();
+        s.execute("pagesetup", &json!({ "layout": "Layout1", "paper": "A4", "landscape": true, "margins": [0, 0, 0, 0] })).unwrap();
+        let page = &mut s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page;
+        page.plot_area = "window".into();
+        page.plot_window = [20.0, 5.0, 400.0, 200.0];
+        page.scale_to_fit = true;
+        let png = |s: &mut Session, p: Value| s.execute("preview", &p).unwrap()["data"].as_str().unwrap_or_default().to_string();
+        let set_center = |s: &mut Session, c: bool| s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page.center = c;
+        set_center(&mut s, true);
+        let centred = png(&mut s, json!({ "layout": "Layout1", "width": 200 }));
+        set_center(&mut s, false);
+        // The window is fitted by width, so only the other axis shows where it sits.
+        let corner = png(&mut s, json!({ "layout": "Layout1", "width": 200 }));
+        assert_ne!(corner, centred, "a saved centre: false puts the fitted window at the printable corner");
+        let page = &mut s.doc_mut().unwrap().layouts.iter_mut().find(|l| l.name == "Layout1").unwrap().page;
+        page.center = true;
+        let by_scale = png(&mut s, json!({ "layout": "Layout1", "width": 200, "scale": 0.5 }));
+        assert_ne!(by_scale, centred, "an explicit scale is not the fitted plot");
+        assert_eq!(
+            by_scale,
+            png(&mut s, json!({ "layout": "Layout1", "width": 200, "fit": false, "scale": 0.5 })),
+            "scale decides, not the saved fit"
+        );
+    }
    #[test]
    fn pdfbook_collects_frames_into_one_pdf_per_row() {
        our_hooks();
@@ -85,12 +85,13 @@ pub fn deliver() -> Option<DeliverHook> {
    DELIVER.get().copied()
 }

-/// How a drawing file is written: its version (`None`: the drawing's own, `$ACADVER`) and
-/// binary instead of ASCII DXF.
+/// How a drawing file is written: its version (`None`: the drawing's own, `$ACADVER`), binary
+/// instead of ASCII DXF, and Windows fonts for Linux ones ([`cadcraft_doc::Drawing::portable_fonts`]).
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub struct SaveAs {
    pub version: Option<Version>,
    pub binary: bool,
+    pub portable_fonts: bool,
 }

 /// Write a drawing with [`SaveAs`] options (installed by hosts whose writer supports them).
@@ -131,7 +132,12 @@ fn save_options(cmd: &str, p: &Value) -> Result<SaveAs> {
        Some(Value::Bool(b)) => *b,
        Some(_) => return Err(bad(cmd, "`binary` must be true or false")),
    };
-    Ok(SaveAs { version, binary })
+    let portable_fonts = match p.get("portableFonts") {
+        None | Some(Value::Null) => false,
+        Some(Value::Bool(b)) => *b,
+        Some(_) => return Err(bad(cmd, "`portableFonts` must be true or false")),
+    };
+    Ok(SaveAs { version, binary, portable_fonts })
 }

 /// Whether `path` names a DXF file (or has no extension, which saves as DXF).
@@ -148,7 +154,9 @@ fn write_bytes(s: &Session, cmd: &str, path: &str, opts: &SaveAs) -> Result<Vec<
    }
    // A drawing file is the drawing outside the Block Editor; an image is what is shown.
    let d: &cadcraft_doc::Drawing = if is_drawing_file(path) { s.state()?.drawing() } else { s.doc()? };
-    let r = if *opts == SaveAs::default() {
+    let copy = (opts.portable_fonts && is_drawing_file(path)).then(|| Drawing { portable_fonts: true, ..d.clone() });
+    let d = copy.as_ref().unwrap_or(d);
+    let r = if opts.version.is_none() && !opts.binary {
        (hooks.write)(d, path)
    } else {
        let w = write_as().ok_or_else(|| bad(cmd, "saving at a chosen version or as binary DXF is not available in this build"))?;
@@ -178,11 +186,13 @@ pub fn specs() -> Vec<CommandSpec> {
        CommandSpec::new("saveas", "Save As...", run_saveas_reporting)
            .menu(&["File", "Save As..."])
            .key("Cmd+Shift+S")
-            .params("{path, version?: 2000|2004|2007|2010|2013|2018, binary?: bool}")
+            .params(
+                "{path, version?: 2000|2004|2007|2010|2013|2018, binary?: bool, portableFonts?: bool (Windows fonts for Linux ones, in this file)}",
+            )
            .noundo(),
        CommandSpec::new("document.switch", "Switch Drawing", run_switch).params("{index}").enabled(always).noundo(),
        CommandSpec::new("document.bytes", "Drawing as bytes", run_bytes)
-            .params("{format?: dxf, version?: 2000…2018, binary?: bool} → {data: base64}")
+            .params("{format?: dxf, version?: 2000…2018, binary?: bool, portableFonts?: bool} → {data: base64}")
            .noundo(),
        CommandSpec::new("script", "Run Script...", run_script)
            .menu(&["Tools", "Run Script..."])
@@ -395,7 +405,7 @@ fn run_closeall(s: &mut Session, _p: &Value) -> Result<Value> {
 }

 pub(crate) fn save_to(s: &mut Session, path: &str) -> Result<usize> {
-    let opts = SaveAs { version: None, binary: s.state()?.binary_dxf && is_dxf(path) };
+    let opts = SaveAs { binary: s.state()?.binary_dxf && is_dxf(path), ..SaveAs::default() };
    save_as(s, "save", path, &opts)
 }

@@ -430,13 +440,14 @@ fn save_as(s: &mut Session, cmd: &str, path: &str, opts: &SaveAs) -> Result<usiz
 fn store(path: &str, bytes: &[u8]) -> Result<()> {
    #[cfg(not(target_arch = "wasm32"))]
    {
-        if is_drawing_file(path) && crate::autosave::isavebak() {
+        // A file in a folder still to be made has nothing to back up.
+        if is_drawing_file(path) && crate::autosave::isavebak() && crate::atomic_write::missing_folder(std::path::Path::new(path)).is_none() {
            backup(std::path::Path::new(path))
                .map_err(|e| bad("save", format!("{path}: the backup copy could not be written ({e}); nothing was saved")))?;
        }
        // Exclusively create a fresh temporary file and rename it over `path`, so a planted
        // `<path>.cadcraft-tmp` symlink cannot redirect the write onto another file (CWE-59).
-        crate::atomic_write::write_atomic(std::path::Path::new(path), bytes).map_err(|e| bad("save", format!("{path}: {e}")))
+        crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad("save", format!("{path}: {e}")))
    }
    #[cfg(target_arch = "wasm32")]
    {
@@ -446,9 +457,20 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
    }
 }

-/// The backup of the drawing file `path`: `<name>.bak` beside it, as AutoCAD names it.
+/// The backup of the drawing file `path`, beside it. A DWG's is `<name>.bak`, as AutoCAD names it,
+/// in the extension's letter case (`plan.DWG` to `plan.BAK`); any other drawing appends `.bak`
+/// (`plan.dxf.bak`), so `plan.dwg` and `plan.dxf` in one folder never overwrite each other's backup.
 pub fn backup_path(path: &std::path::Path) -> std::path::PathBuf {
-    path.with_extension("bak")
+    match path.extension().map(|e| e.to_string_lossy()) {
+        Some(e) if e.eq_ignore_ascii_case("dwg") => path.with_extension(
+            e.chars().zip("bak".chars()).map(|(d, b)| if d.is_ascii_uppercase() { b.to_ascii_uppercase() } else { b }).collect::<String>(),
+        ),
+        _ => {
+            let mut name = path.as_os_str().to_os_string();
+            name.push(".bak");
+            name.into()
+        }
+    }
 }

 /// Whether `bytes` read as a DWG or a DXF (ASCII or binary) by their start: what a save keeps as
@@ -666,6 +688,7 @@ fn run_saveas(s: &mut Session, p: &Value) -> Result<Value> {
    if is_drawing_file(&path) {
        r["version"] = json!(opts.version.unwrap_or_else(|| drawing_version(s, &path)).year());
        r["binary"] = json!(opts.binary);
+        r["portableFonts"] = json!(opts.portable_fonts);
    }
    Ok(r)
 }
@@ -673,8 +696,11 @@ fn run_saveas(s: &mut Session, p: &Value) -> Result<Value> {
 /// The version a drawing is saved in at `path` when none is asked for: its `$ACADVER` (2018 by
 /// default), and for DWG at least 2004 (the io layer's rule: R2000 DWG has no true colours).
 fn drawing_version(s: &Session, path: &str) -> Version {
-    let v =
-        s.doc().ok().and_then(|d| d.header.get("ACADVER").and_then(cadcraft_doc::HVal::as_str).and_then(Version::for_acadver)).unwrap_or_default();
+    let v = s
+        .state()
+        .ok()
+        .and_then(|st| st.drawing().header.get("ACADVER").and_then(cadcraft_doc::HVal::as_str).and_then(Version::for_acadver))
+        .unwrap_or_default();
    if is_dxf(path) { v } else { v.max(Version::R2004) }
 }

@@ -703,6 +729,8 @@ fn run_bytes(s: &mut Session, p: &Value) -> Result<Value> {
    let mut r = json!({ "data": base64_encode(&bytes), "bytes": bytes.len() });
    if drops_unknown(format!("drawing.{fmt}")) {
        report_not_saved(s, &mut r, &lost);
+    } else if version >= Version::R2013 && is_dxf_file(format!("drawing.{fmt}")) {
+        report_sat_text_dropped(s, &mut r);
    }
    Ok(r)
 }
@@ -720,15 +748,28 @@ pub fn not_saved(d: &Drawing) -> std::collections::BTreeMap<String, usize> {
 /// store section, which is written back with the drawing (`Foreign::data_store`).
 const MODELER_TYPES: [&str; 3] = ["3DSOLID", "REGION", "BODY"];

+/// Entity types CADCraft doesn't model that the DWG bridge writes all the same: acadrust reads
+/// them from our DXF into entities of its own and writes them to DWG of every version we save,
+/// an OLE object with its frame and its embedded object's bytes unchanged. Matched exactly: the
+/// bridge gets the type as stored, and acadrust knows only this spelling of it.
+const DWG_WRITES: [&str; 1] = ["OLE2FRAME"];
+
 /// [`not_saved`] for a file saved as `version`. From 2013 on, a 3D solid, region or body the data
-/// store has a record for keeps its geometry and is not counted.
+/// store has a record for keeps its geometry and is not counted; neither are [`DWG_WRITES`].
 pub fn not_saved_as(d: &Drawing, version: Version) -> std::collections::BTreeMap<String, usize> {
    let mut out: std::collections::BTreeMap<String, usize> = std::collections::BTreeMap::new();
    let stored = if version >= Version::R2013 { d.foreign.data_store_entities() } else { Default::default() };
    let stores = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).chain(d.blocks.values().map(|b| &b.entities));
    for e in stores.flat_map(|s| s.iter()) {
        if let cadcraft_doc::EntityKind::Unknown(u) = &e.kind {
-            if MODELER_TYPES.iter().any(|t| u.dxf_type.eq_ignore_ascii_case(t)) && stored.contains(&e.handle) {
+            // A DWG before 2013 writes a solid's SAT text as it is; from 2013 the geometry has to be
+            // in the data store, and SAT text alone is lost (#2334).
+            if MODELER_TYPES.iter().any(|t| u.dxf_type.eq_ignore_ascii_case(t))
+                && (stored.contains(&e.handle) || (version < Version::R2013 && cadcraft_doc::foreign::has_sat_text(&u.tags)))
+            {
+                continue;
+            }
+            if DWG_WRITES.contains(&u.dxf_type.as_str()) {
                continue;
            }
            let n = out.entry(u.dxf_type.clone()).or_insert(0);
@@ -744,20 +785,39 @@ pub fn not_saved_message(lost: &std::collections::BTreeMap<String, usize>) -> Op
        return None;
    }
    let list: Vec<String> = lost.iter().map(|(t, n)| format!("{n} {t}")).collect();
-    Some(format!("Not saved in the DWG file (its writer can't write these object types yet; DXF keeps them): {}", list.join(", ")))
+    Some(format!(
+        "Not saved in the DWG file (its writer can't write these object types yet; DXF keeps them, solids only when saved as 2010 or earlier): {}",
+        list.join(", ")
+    ))
 }

 /// What saving the active drawing to `path` would leave out, before anything is written: empty
 /// when the format keeps everything. The interactive save asks with this; [`save_reporting`]
 /// reports the same list afterwards to callers that never get a dialog.
 pub fn loss_on_save(s: &Session, path: &str) -> std::collections::BTreeMap<String, usize> {
+    let version = drawing_version(s, path);
+    if is_dxf_file(path) && version >= Version::R2013 {
+        // The drawing a file holds: the host while the Block Editor is open.
+        return s.state().map(|st| cadcraft_doc::foreign::sat_text_dropped(st.drawing())).unwrap_or_default();
+    }
    if !drops_unknown(path) {
        return Default::default();
    }
-    let version = drawing_version(s, path);
    s.doc().map(|d| not_saved_as(d, version)).unwrap_or_default()
 }

+/// Report what the file `path`, just written at the drawing's own version, left out.
+pub(super) fn report_loss(s: &mut Session, r: &mut Value, path: &str) {
+    if is_dxf_file(path) {
+        if drawing_version(s, path) >= Version::R2013 {
+            report_sat_text_dropped(s, r);
+        }
+    } else {
+        let lost = loss_on_save(s, path);
+        report_not_saved(s, r, &lost);
+    }
+}
+
 /// Whether saving to `path` leaves out the entities [`not_saved`] counts: DWG does (the DWG
 /// bridge drops types it doesn't know); DXF writes them back as read.
 pub fn drops_unknown(path: impl AsRef<std::path::Path>) -> bool {
@@ -769,8 +829,53 @@ fn is_drawing_file(path: impl AsRef<std::path::Path>) -> bool {
    Format::from_path(path).is_some_and(Format::is_drawing)
 }

+/// Whether `path` is a DXF file.
+fn is_dxf_file(path: impl AsRef<std::path::Path>) -> bool {
+    Format::from_path(path) == Some(Format::Dxf)
+}
+
+/// Say on the command line which solid modeler entities a DXF of 2013 or later left out because
+/// they hold SAT-text ACIS data, which such files keep in a data store instead (#2334).
+fn report_sat_text_dropped(s: &mut Session, r: &mut Value) {
+    // The drawing a file holds: the host while the Block Editor is open.
+    let lost = s.state().map(|st| cadcraft_doc::foreign::sat_text_dropped(st.drawing())).unwrap_or_default();
+    if lost.is_empty() {
+        return;
+    }
+    let list: Vec<String> = lost.iter().map(|(t, n)| format!("{n} {t}")).collect();
+    s.echo(format!(
+        "Not saved in the DXF file (2013 and later keep ACIS geometry in a data store these entities have no record in; save as 2010 or earlier to keep them): {}",
+        list.join(", ")
+    ));
+    if let Some(o) = r.as_object_mut() {
+        o.insert("notSaved".into(), json!(lost));
+    }
+}
+
+/// The folder a write to `path` has to create, asked before writing so it can be reported after.
+/// The web has no folders.
+pub(super) fn new_folder(path: &str) -> Option<String> {
+    #[cfg(not(target_arch = "wasm32"))]
+    return crate::atomic_write::missing_folder(std::path::Path::new(path)).map(|f| f.display().to_string());
+    #[cfg(target_arch = "wasm32")]
+    {
+        let _ = path;
+        None
+    }
+}
+
+/// Say on the command line that the file went into a folder that didn't exist, so a mistyped path
+/// is noticed, and name the folder in the result's `createdFolder`.
+pub(super) fn report_new_folder(s: &mut Session, r: &mut Value, folder: Option<String>) {
+    let Some(folder) = folder else { return };
+    s.echo(format!("Created the folder {folder}, which did not exist. Check the path if you did not mean to."));
+    if let Some(o) = r.as_object_mut() {
+        o.insert("createdFolder".into(), json!(folder));
+    }
+}
+
 /// Say on the command line what the file couldn't keep, and list it in the result's `notSaved`.
-fn report_not_saved(s: &mut Session, r: &mut Value, lost: &std::collections::BTreeMap<String, usize>) {
+pub(super) fn report_not_saved(s: &mut Session, r: &mut Value, lost: &std::collections::BTreeMap<String, usize>) {
    let Some(msg) = not_saved_message(lost) else { return };
    s.echo(msg);
    if let Some(o) = r.as_object_mut() {
@@ -779,24 +884,64 @@ fn report_not_saved(s: &mut Session, r: &mut Value, lost: &std::collections::BTr
 }

 /// Save, then report the entities the file couldn't keep (nothing is dropped silently).
-fn save_reporting(s: &mut Session, p: &Value, run: fn(&mut Session, &Value) -> Result<Value>) -> Result<Value> {
+fn save_reporting(s: &mut Session, p: &Value, run: fn(&mut Session, &Value) -> Result<Value>, asked: Option<Version>) -> Result<Value> {
    // What the file will hold depends on the version it is saved as (the data store from 2013).
+    // QSAVE takes no `version` and keeps the drawing's own; SAVEAS writes the one asked for.
    let path = str_param(p, "path").map(str::to_string).or_else(|| s.state().ok().and_then(|st| st.path.clone())).unwrap_or_default();
-    let version = save_options("save", p).ok().and_then(|o| o.version).unwrap_or_else(|| drawing_version(s, &path));
+    let version = asked.unwrap_or_else(|| drawing_version(s, &path));
    let lost = s.doc().map(|d| not_saved_as(d, version)).unwrap_or_default();
+    let folder = new_folder(&path);
    let mut r = run(s, p)?;
+    report_new_folder(s, &mut r, folder);
    if r.get("path").and_then(Value::as_str).is_some_and(drops_unknown) {
        report_not_saved(s, &mut r, &lost);
+    } else if version >= Version::R2013 && r.get("path").and_then(Value::as_str).is_some_and(is_dxf_file) {
+        report_sat_text_dropped(s, &mut r);
+    }
+    if r.get("path").and_then(Value::as_str).is_some_and(is_drawing_file) {
+        report_fonts(s, &mut r);
    }
    Ok(r)
 }

+/// Name the text styles whose font in the saved file AutoCAD on Windows doesn't have: in the
+/// result, and at the command line when the list changed since the last save. Styles from an xref
+/// (`XREF|name`) aren't saved: AutoCAD takes them from the xref.
+fn report_fonts(s: &mut Session, r: &mut Value) {
+    use cadcraft_fonts::windows::{missing_on_windows, windows_font, written_font};
+    let portable = r.get("portableFonts").and_then(Value::as_bool).unwrap_or(false);
+    let Ok(d) = s.state().map(|st| st.drawing()) else { return };
+    let fonts: Vec<(String, String)> = d
+        .text_styles
+        .iter()
+        .filter(|t| !t.name.contains('|') && missing_on_windows(written_font(&t.font, portable)))
+        .map(|t| (t.name.clone(), t.font.clone()))
+        .collect();
+    let list = fonts.iter().map(|(style, font)| format!("{style} ({font})")).collect::<Vec<_>>().join(", ");
+    let changed = s.state_mut().map(|st| std::mem::replace(&mut st.fonts_noted, list.clone()) != list).unwrap_or(true);
+    if fonts.is_empty() {
+        return;
+    }
+    if changed {
+        let hint = if fonts.iter().any(|(_, font)| windows_font(font).is_some()) {
+            " SAVEAS with portableFonts writes Windows fonts for those that have one."
+        } else {
+            ""
+        };
+        s.echo(format!("Fonts AutoCAD on Windows doesn't have: {list}.{hint}"));
+    }
+    if let Some(o) = r.as_object_mut() {
+        o.insert("nonPortableFonts".into(), json!(fonts.iter().map(|(style, font)| json!({ "style": style, "font": font })).collect::<Vec<_>>()));
+    }
+}
+
 fn run_qsave_reporting(s: &mut Session, p: &Value) -> Result<Value> {
-    save_reporting(s, p, run_save)
+    save_reporting(s, p, run_save, None)
 }

 fn run_saveas_reporting(s: &mut Session, p: &Value) -> Result<Value> {
-    save_reporting(s, p, run_saveas)
+    let asked = save_options("saveas", p)?.version;
+    save_reporting(s, p, run_saveas, asked)
 }

 const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -15,6 +15,7 @@ use super::{CommandSpec, bad, bool_or, f64_or, point_param, points_param, size_p
 use crate::{Accept, EngineError, Input, Interactive, Picker, Prompt, Result, Session, Step};

 mod assoc;
+pub(crate) use assoc::detach;
 mod edit;
 mod pick;
 use super::has_doc;
@@ -121,7 +121,7 @@ pub(super) fn same_shape(a: &[PolyVertex], b: &[PolyVertex]) -> bool {
    ba.min.dist(bb.min) <= eps && ba.max.dist(bb.max) <= eps && (shoelace(&pa).abs() - shoelace(&pb).abs()).abs() <= eps * (1.0 + size)
 }

-pub(super) fn detach(h: &mut Hatch) {
+pub(crate) fn detach(h: &mut Hatch) {
    h.associative = false;
    h.loops.iter_mut().for_each(|l| l.sources.clear());
 }
@@ -34,7 +34,9 @@ pub fn polygon_vertices(center: Vec2, sides: usize, radius_pt: Vec2, inscribed:
    let r = d.len();
    let a0 = d.angle();
    let step = cadcraft_geom::TAU / n as f64;
-    let (r, a0) = if inscribed { (r, a0) } else { (r / (step / 2.0).cos(), a0 - step / 2.0) };
+    // Circumscribed: the picked point is an edge's midpoint and the first vertex is the end of
+    // that edge counter-clockwise from it, as AutoCAD 2024 numbers them.
+    let (r, a0) = if inscribed { (r, a0) } else { (r / (step / 2.0).cos(), a0 + step / 2.0) };
    (0..n).map(|i| PolyVertex::new(Vec2::polar(center, r, a0 + step * i as f64))).collect()
 }

@@ -62,43 +64,31 @@ pub fn polygon_from_edge(p1: Vec2, p2: Vec2, sides: usize) -> Vec<PolyVertex> {
    pts.into_iter().map(PolyVertex::new).collect()
 }

-/// Rectangle vertices with fillet radius or chamfer distances at every corner.
+/// Rectangle vertices from corner `a` to the opposite corner `b`, with a fillet radius or
+/// chamfer distances at every corner, in AutoCAD 2024's order: from `a` along X to `b`'s X, then
+/// `b`, then back along Y. A chamfer cuts the edge into each corner by its first distance and the
+/// edge out of it by its second; each fillet arc starts on the edge into its corner. A fillet or
+/// chamfer that doesn't fit leaves the corners square.
 pub fn rect_with_corners(a: Vec2, b: Vec2, fillet: f64, chamfer: (f64, f64)) -> Vec<PolyVertex> {
-    let (x0, x1) = (a.x.min(b.x), a.x.max(b.x));
-    let (y0, y1) = (a.y.min(b.y), a.y.max(b.y));
-    let w = x1 - x0;
-    let h = y1 - y0;
-    if fillet > 0.0 && fillet * 2.0 <= w.min(h) + 1e-12 {
-        let r = fillet;
-        let bul = cadcraft_geom::arc_to_bulge(std::f64::consts::FRAC_PI_2);
-        return vec![
-            PolyVertex::new(Vec2::new(x0 + r, y0)),
-            PolyVertex::with_bulge(Vec2::new(x1 - r, y0), bul),
-            PolyVertex::new(Vec2::new(x1, y0 + r)),
-            PolyVertex::with_bulge(Vec2::new(x1, y1 - r), bul),
-            PolyVertex::new(Vec2::new(x1 - r, y1)),
-            PolyVertex::with_bulge(Vec2::new(x0 + r, y1), bul),
-            PolyVertex::new(Vec2::new(x0, y1 - r)),
-            PolyVertex::with_bulge(Vec2::new(x0, y0 + r), bul),
-        ];
+    let corners = [a, Vec2::new(b.x, a.y), b, Vec2::new(a.x, b.y)];
+    let short = (b.x - a.x).abs().min((b.y - a.y).abs());
+    let (d_in, d_out, bulge) = if fillet > 0.0 && fillet * 2.0 <= short + 1e-12 {
+        // Counter-clockwise round the corners (a positive bulge) when `b` is up and right of `a`, or
+        // down and left.
+        let sign = if (b.x - a.x) * (b.y - a.y) >= 0.0 { 1.0 } else { -1.0 };
+        (fillet, fillet, sign * cadcraft_geom::arc_to_bulge(std::f64::consts::FRAC_PI_2))
+    } else if chamfer.0 > 0.0 && chamfer.1 > 0.0 && chamfer.0 + chamfer.1 <= short + 1e-12 {
+        (chamfer.0, chamfer.1, 0.0)
+    } else {
+        return corners.into_iter().map(PolyVertex::new).collect();
+    };
+    let mut out = Vec::with_capacity(8);
+    for (i, cur) in corners.iter().enumerate() {
+        let (Some(prev), Some(next)) = (corners.get((i + 3) % 4), corners.get((i + 1) % 4)) else { continue };
+        out.push(PolyVertex::with_bulge(*cur + (*prev - *cur).normalized() * d_in, bulge));
+        out.push(PolyVertex::new(*cur + (*next - *cur).normalized() * d_out));
    }
-    let (c1, c2) = chamfer;
-    if c1 > 0.0 && c2 > 0.0 && c1 + c1 <= w + 1e-12 && c2 + c2 <= h + 1e-12 {
-        return [
-            Vec2::new(x0 + c1, y0),
-            Vec2::new(x1 - c1, y0),
-            Vec2::new(x1, y0 + c2),
-            Vec2::new(x1, y1 - c2),
-            Vec2::new(x1 - c1, y1),
-            Vec2::new(x0 + c1, y1),
-            Vec2::new(x0, y1 - c2),
-            Vec2::new(x0, y0 + c2),
-        ]
-        .into_iter()
-        .map(PolyVertex::new)
-        .collect();
-    }
-    rect_vertices(Vec2::new(x0, y0), Vec2::new(x1, y1))
+    out
 }

 // ---------- the user's support files ----------
@@ -217,6 +217,11 @@ fn run_dist(s: &mut Session, p: &Value) -> Result<Value> {
    let a = point3_req(s, "dist", p, "p1")?;
    let b = point3_req(s, "dist", p, "p2")?;
    let d = b - a;
+    if !d.len().is_finite() {
+        return Err(bad("dist", "the distance is too large"));
+    }
+    s.distance = d.len();
+    s.last_point = a.xy();
    Ok(json!({
        "distance": d.len(),
        "angle": d.xy().angle().to_degrees(),
@@ -285,6 +290,14 @@ fn entity_z(e: &Entity, p: Vec2) -> Option<f64> {
        EntityKind::MText(t) => Some(t.insert.z),
        EntityKind::Insert(i) => Some(i.insert.z),
        EntityKind::Face3d(f) => face_z(&f.corners, p).or_else(|| along(&f.corners, true)),
+        // Drawn as its faces' visible edges: the Z on the nearest one.
+        EntityKind::PolyfaceMesh(m) => m
+            .faces3d()
+            .iter()
+            .flat_map(cadcraft_doc::Face3d::visible_edges)
+            .map(|(a, b)| on_segment(a, b))
+            .min_by(|a, b| a.1.total_cmp(&b.1))
+            .map(|(z, _)| z),
        _ => None,
    }
 }
@@ -422,6 +435,8 @@ fn run_area(s: &mut Session, p: &Value) -> Result<Value> {
    if let Some(what) = too_large(a, per) {
        return Err(bad("area", format!("the {what} is too large")));
    }
+    s.area = a;
+    s.perimeter = per;
    Ok(json!({ "area": a, "perimeter": per, "message": area_text(s, a, per) }))
 }

@@ -508,6 +523,13 @@ pub(super) fn object_area(s: &Session, h: Handle) -> Result<(f64, f64)> {
            total
        }
        EntityKind::Region(r) => (r.area(), r.perimeter()),
+        // Like an open polyline: the area closed by the chord, the perimeter its own length.
+        EntityKind::Spline(sp) if sp.is_valid() => {
+            let b = sp.bounds();
+            let pts = sp.tessellate_spans((b.min.dist(b.max) * 1e-7).max(1e-12));
+            // A length past f64's range is too large to report, as a polyline's is, not 0.
+            (cadcraft_geom::shoelace(&pts).abs(), sp.checked_length().unwrap_or(f64::INFINITY))
+        }
        _ => return Err(bad("area", "object has no area")),
    })
 }
@@ -574,6 +596,8 @@ fn run_inspect(s: &mut Session, p: &Value) -> Result<Value> {
        "view": { "center": [st.view().center.x, st.view().center.y], "height": st.view().height },
        // Records of the file the drawing came from that the reader could not place.
        "skipped": { "count": d.skipped_records.values().fold(0usize, |a, n| a.saturating_add(*n)), "sections": d.skipped_records },
+        // What reading the file left out, in words (a damaged DWG's unreadable object records).
+        "readNotes": d.read_notes,
    });
    if bool_or(p, "entities", true)
        && let (Some(o), Some(store)) = (out.as_object_mut(), d.space(&space))
@@ -864,16 +888,25 @@ impl Interactive for DistM {
                self.first_source = s.picked_viewport;
                Ok(Step::Continue)
            }
-            (Some(a), Input::Point(b)) => {
+            (Some(first), Input::Point(b)) => {
                let (a, b) = match (self.first_source, s.picked_viewport) {
                    (Some(first), Some(second)) if first.viewport == second.viewport => (first.point, second.point),
-                    _ => (a, b),
+                    _ => (first, b),
                };
                let (za, zb) = if self.first_source.is_some() || s.picked_viewport.is_some() { (0.0, 0.0) } else { (z_at(s, a), z_at(s, b)) };
-                let t = dist_text(s, Vec3::new(a.x, a.y, za), Vec3::new(b.x, b.y, zb));
+                let (a, b) = (Vec3::new(a.x, a.y, za), Vec3::new(b.x, b.y, zb));
+                if !(b - a).len().is_finite() {
+                    // The first point stays LASTPOINT, as after a measurement.
+                    s.last_point = first;
+                    return Err(bad("dist", "the distance is too large"));
+                }
+                let t = dist_text(s, a, b);
                for l in t.lines() {
                    s.echo(l.to_string());
                }
+                // As in AutoCAD, the second point doesn't become LASTPOINT: the first stays.
+                s.distance = (b - a).len();
+                s.last_point = first;
                Ok(Step::Done)
            }
            (Some(a), Input::Keyword(k)) if k == "Multiple points" => {
@@ -901,7 +934,11 @@ impl DistM {
            .as_deref()
            .or(self.multi.as_deref())
            .map_or(0.0, |pts| if closed { arcs::polyline(pts, &self.bulges, true).len() } else { path_len(pts, &self.bulges) });
+        if !d.is_finite() {
+            return Err(bad("dist", "the distance is too large"));
+        }
        s.echo(format!("Distance = {}", fmt_d(s, d)));
+        s.distance = d;
        Ok(Step::Done)
    }
 }
@@ -1115,10 +1152,14 @@ impl AreaM {
            return if self.mode == AreaMode::Single { Step::Done } else { Step::Continue };
        }
        s.echo(area_text(s, a, per));
+        // AREA: this area, or in Add and Subtract mode the running total; PERIMETER: this area's.
+        s.perimeter = per;
        if self.mode == AreaMode::Single {
+            s.area = a;
            return Step::Done;
        }
        self.total = total;
+        s.area = total;
        s.echo(format!("Total area = {}", fmt_d(s, self.total)));
        Step::Continue
    }
@@ -182,7 +182,7 @@ fn loaded_linetype(d: &cadcraft_doc::Drawing, cmd: &str, p: &Value) -> Result<Op
 }

 fn valid_name(n: &str) -> bool {
-    !n.trim().is_empty() && n.len() <= 255 && !n.chars().any(|c| "<>/\\\":;?*|,=`".contains(c))
+    !n.trim().is_empty() && n.len() <= 255 && !n.chars().any(|c| c.is_control() || "<>/\\\":;?*|,=`".contains(c))
 }

 fn run_new(s: &mut Session, p: &Value) -> Result<Value> {
@@ -84,11 +84,11 @@ pub fn specs() -> Vec<CommandSpec> {
            .menu(&["File", "Print..."])
            .key("Cmd+P")
            .alias(&["print"])
-            .params("{path? (else returns base64 `data`), layout?: current|\"Model\", paper?, landscape?, fit?: bool, scale?: number | \"1:50\", center?: bool (Model, default true), offset?: [x,y] mm (Model, when center is false; each within ±100000), lineweights?: bool, plotTransparency?: bool (default: the page setup's; PLOTTRANSPARENCYOVERRIDE 0/2 overrides it), plotArea?: extents|display|limits|window (Model) | layout, window?: [[x1,y1],[x2,y2]]} (typed or from the menu: the Plot dialog)")
+            .params("{path? (else returns base64 `data`), layout?: current|\"Model\", device?: \"CADCraft PDF\"|\"CADCraft PNG\"|\"CADCraft SVG\" | a plotter from PLOTTERMANAGER | \"None\" (default: a layout's page setup device; Model, or \"None\": no device, PDF; a device sets the output format and the papers), paper?: the device's paper (default: a layout keeps its page setup's; Model takes the device's default), landscape?, fit?: bool, scale?: number | \"1:50\", center?: bool (Model, default true), offset?: [x,y] mm (Model, when center is false; each within ±100000), lineweights?: bool, plotTransparency?: bool (default: the page setup's; PLOTTRANSPARENCYOVERRIDE 0/2 overrides it), plotArea?: extents|display|limits|window (Model) | layout, window?: [[x1,y1],[x2,y2]]} (typed or from the menu: the Plot dialog)")
            .noundo(),
        CommandSpec::new("exportpdf", "Export to PDF...", |s, p| run_plot(s, &super::plotters::plot_options(s, p, "exportpdf")?, "exportpdf"))
            .menu(&["File", "Export to PDF..."])
-            .params("{path? (else returns base64 `data`), layout?, paper?, landscape?, fit?, scale?, center?: bool (Model, default true), offset?: [x,y] mm (Model, when center is false; each within ±100000), lineweights?, plotTransparency?, plotArea?, window?} (as PLOT)")
+            .params("{path? (else returns base64 `data`), layout?, device? (its papers; the output stays PDF), paper?, landscape?, fit?, scale?, center?: bool (Model, default true), offset?: [x,y] mm (Model, when center is false; each within ±100000), lineweights?, plotTransparency?, plotArea?, window?} (as PLOT)")
            .noundo(),
        CommandSpec::new("mspace", "Model Space (in viewport)", run_mspace)
            .alias(&["ms"])
@@ -313,7 +313,7 @@ fn run_copy(s: &mut Session, p: &Value) -> Result<Value> {
        let h = d.new_handle();
        store.push(Entity { handle: h, ..Entity::clone(e) });
    }
-    d.layouts.push(Layout { name: to.clone(), tab_order: order, page: src.page, entities: store, view: src.view });
+    d.layouts.push(Layout { name: to.clone(), tab_order: order, page: src.page, entities: store, view: src.view, limits: src.limits });
    Ok(json!({ "name": to }))
 }

@@ -840,8 +840,11 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
                let path = _path;
                // Exclusively create a fresh temporary file and rename it into place so a planted
                // `<path>.cadcraft-tmp` symlink cannot redirect the plot write (CWE-59).
-                crate::atomic_write::write_atomic(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
-                Ok(json!({ "path": path, "bytes": bytes.len(), "layout": layout, "pages": pages }))
+                let folder = super::file::new_folder(path);
+                crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
+                let mut r = json!({ "path": path, "bytes": bytes.len(), "layout": layout, "pages": pages });
+                super::file::report_new_folder(s, &mut r, folder);
+                Ok(r)
            }
            #[cfg(target_arch = "wasm32")]
            {
@@ -333,9 +333,8 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
                Some(_path) => {
                    #[cfg(not(target_arch = "wasm32"))]
                    {
-                        let tmp = format!("{_path}.cadcraft-tmp");
-                        std::fs::write(&tmp, text.as_bytes()).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
-                        std::fs::rename(&tmp, _path).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
+                        crate::atomic_write::write_atomic(std::path::Path::new(_path), text.as_bytes())
+                            .map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
                        Ok(json!({ "name": name, "path": _path, "bytes": text.len() }))
                    }
                    #[cfg(target_arch = "wasm32")]
@@ -104,8 +104,10 @@ pub(super) fn run_saveas(s: &mut Session, p: &Value) -> Result<Value> {
    let t = template_of(d, &name)?;
    let hooks = io().ok_or_else(|| bad("layout.saveas", "file formats are not available in this build"))?;
    let bytes = (hooks.write)(&t, &path).map_err(|e| bad("layout.saveas", e))?;
+    let folder = super::super::file::new_folder(&path);
    store(&path, &bytes)?;
    let mut r = json!({ "name": name, "path": path, "bytes": bytes.len() });
+    super::super::file::report_new_folder(s, &mut r, folder);
    let lost = not_saved(&t);
    if drops_unknown(&path)
        && let Some(msg) = not_saved_message(&lost)
@@ -124,7 +126,7 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
    {
        // Exclusively create a fresh temporary file and rename it into place so a planted
        // `<path>.cadcraft-tmp` symlink cannot redirect the write (CWE-59).
-        crate::atomic_write::write_atomic(std::path::Path::new(path), bytes).map_err(|e| bad("layout.saveas", format!("{path}: {e}")))
+        crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad("layout.saveas", format!("{path}: {e}")))
    }
    #[cfg(target_arch = "wasm32")]
    {
@@ -293,3 +293,17 @@ fn mspace_edits_model_through_viewport() {
    s.execute("layout.set", &json!({"name": "Model"})).unwrap();
    assert!(s.state().unwrap().mspace.is_none());
 }
+
+/// PLOT and EXPORTPDF help name the `device` parameter, and PLOT's help every built-in device (#2557).
+#[test]
+fn plot_help_names_the_device_and_the_built_in_devices() {
+    for id in ["plot", "exportpdf"] {
+        let help = crate::find_command(id).map(|c| c.params).unwrap_or_default();
+        assert!(help.contains("device?"), "{id}: {help}");
+    }
+    let help = crate::find_command("plot").map(|c| c.params).unwrap_or_default();
+    for name in ["CADCraft PDF", "CADCraft PNG", "CADCraft SVG"] {
+        assert!(super::super::plotters::find_device(name).is_some(), "{name} is not a device");
+        assert!(help.contains(name), "plot help lacks {name}");
+    }
+}
@@ -20,6 +20,7 @@ mod break_join;
 mod explode;
 mod fillet;
 mod offset;
+mod oops;
 mod select_then;
 mod stretch;
 mod transform;
@@ -30,6 +31,8 @@ use explode::run_explode;
 pub(crate) use explode::{explode_kind, explode_with};
 use fillet::{FilletM, run_chamfer, run_fillet};
 use offset::{OffsetM, run_offset};
+use oops::run_oops;
+pub(crate) use oops::{Erased, erase_kept};
 use select_then::{DisplaceM, Op, SelectThen};
 use stretch::{StretchM, run_stretch};
 pub(crate) use transform::transform_entities;
@@ -43,6 +46,7 @@ pub fn specs() -> Vec<CommandSpec> {
            .alias(&["e", "delete"])
            .params("{handles?: [hex]} (default: selection)")
            .interactive(|_| Ok(Box::new(SelectThen::new(Op::Erase)))),
+        CommandSpec::new("oops", "Oops", run_oops).params("{} (brings back what the last ERASE, BLOCK or -WBLOCK removed)"),
        CommandSpec::new("move", "Move", run_move)
            .menu(&["Modify", "Move"])
            .alias(&["m"])
@@ -61,7 +65,7 @@ pub fn specs() -> Vec<CommandSpec> {
        CommandSpec::new("scale", "Scale", run_scale)
            .menu(&["Modify", "Scale"])
            .alias(&["sc"])
-            .params("{handles?, base: [x,y], factor, copy?: bool}")
+            .params("{handles?, base: [x,y] or [x,y,z] (default Z: ELEVATION), factor, copy?: bool}")
            .interactive(|_| Ok(Box::new(SelectThen::new(Op::Scale)))),
        CommandSpec::new("mirror", "Mirror", run_mirror)
            .menu(&["Modify", "Mirror"])
@@ -151,6 +151,12 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
                })
                .collect(),
        ),
+        // A polyface mesh explodes into its 3D faces; one without any stays as it is.
+        EntityKind::PolyfaceMesh(m) => {
+            let faces = m.faces3d();
+            (!faces.is_empty())
+                .then(|| faces.into_iter().map(|f| Entity { handle: Handle(0), common: e.common.clone(), kind: EntityKind::Face3d(f) }).collect())
+        }
        EntityKind::MLine(m) => Some(crate::cmd::draw2::mline::explode(e, m)),
        EntityKind::MText(m) => Some(explode_mtext(e, m)),
        // A region explodes into its boundary's lines and arcs.
@@ -212,12 +212,35 @@ pub(super) fn run_offset(s: &mut Session, p: &Value) -> Result<Value> {
    Ok(json!({ "handle": nh.hex() }))
 }

+/// The copy at the source's height, as AutoCAD 2024's OFFSET makes it: a line's end Zs, an arc's
+/// or circle's centre Z, a polyline's elevation (an ellipse's offset, a polyline, at its centre Z).
+fn keep_z(src: &EntityKind, k: &mut EntityKind) {
+    match (src, k) {
+        (EntityKind::Line(s), EntityKind::Line(l)) => {
+            l.a.z = s.a.z;
+            l.b.z = s.b.z;
+        }
+        (EntityKind::Circle(s), EntityKind::Circle(c)) => c.center.z = s.center.z,
+        (EntityKind::Arc(s), EntityKind::Arc(a)) => a.center.z = s.center.z,
+        (EntityKind::LwPolyline(s), EntityKind::LwPolyline(p)) => p.elevation = s.elevation,
+        (EntityKind::Ellipse(s), EntityKind::LwPolyline(p)) => p.elevation = s.center.z,
+        (EntityKind::Ray(s) | EntityKind::XLine(s), EntityKind::Ray(r) | EntityKind::XLine(r)) => r.base.z = s.base.z,
+        _ => {}
+    }
+}
+
 /// Add the offset copy `k` of `src` (on the current layer instead of the source's when
-/// `current_layer`), then erase the source when `erase` and its layer is not locked.
-fn add_offset(s: &mut Session, src: &Entity, k: EntityKind, current_layer: bool, erase: bool) -> Result<Handle> {
+/// `current_layer`), then erase the source when `erase` and its layer is not locked. The copy is
+/// at the source's height ([`keep_z`]); a circle's or arc's copy has no thickness, a polyline's
+/// keeps it, as AutoCAD 2024 makes them.
+fn add_offset(s: &mut Session, src: &Entity, mut k: EntityKind, current_layer: bool, erase: bool) -> Result<Handle> {
+    keep_z(&src.kind, &mut k);
    let space = s.space();
    let d = s.doc_mut()?;
    let mut common = src.common.clone();
+    if matches!(k, EntityKind::Circle(_) | EntityKind::Arc(_)) {
+        common.thickness = 0.0;
+    }
    if current_layer {
        common.layer = d.header.str("CLAYER", "0");
    }
@@ -0,0 +1,181 @@
+//! OOPS: bring back the objects the last ERASE (or the Delete key) removed, or BLOCK deleting the
+//! objects it makes a block of, or -WBLOCK the objects it writes, with their handles and each where
+//! it was in the draw order, as AutoCAD 2024 does (accoreconsole, the drawing's `entnext` order read
+//! back afterwards).
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use cadcraft_doc::{Drawing, Entity, EntityKind, EntityStore, Handle, Space};
+use serde_json::{Value, json};
+
+use crate::{Result, Session};
+
+/// One erased object, with the objects that were directly under and above it.
+#[derive(Clone, Debug)]
+struct Taken {
+    space: Space,
+    entity: Arc<Entity>,
+    below: Option<Handle>,
+    above: Option<Handle>,
+}
+
+/// What the drawing's last erase removed, for OOPS.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Erased(Vec<Taken>);
+
+impl Erased {
+    /// Never bring back the objects `drop` picks.
+    pub(crate) fn forget(&mut self, drop: impl Fn(Handle) -> bool) {
+        self.0.retain(|t| !drop(t.entity.handle));
+    }
+}
+
+/// Remove the objects `hs` and keep them for OOPS in place of what an earlier erase kept.
+/// Returns how many went; when none did, OOPS keeps what it had.
+pub(crate) fn erase_kept(s: &mut Session, hs: &[Handle]) -> Result<usize> {
+    let d = s.doc_mut()?;
+    // Every neighbour is read before anything goes: objects erased together may be neighbours.
+    let at: Vec<(Handle, Space, Option<Handle>, Option<Handle>)> = hs
+        .iter()
+        .filter_map(|&h| {
+            let space = d.space_of(h)?;
+            let (below, above) = d.space(&space)?.neighbours(h)?;
+            Some((h, space, below, above))
+        })
+        .collect();
+    let mut taken = Vec::with_capacity(at.len());
+    for (h, space, below, above) in at {
+        if let Some(entity) = d.space_mut(&space).and_then(|st| st.remove(h)) {
+            taken.push(Taken { space, entity, below, above });
+        }
+    }
+    let n = taken.len();
+    // During REFEDIT, removing an object outside the working set gets the command undone
+    // (`refedit::after_command`), so what OOPS had stays.
+    let refused = taken.iter().any(|t| crate::cmd::blocks::refedit::locked(d, t.entity.handle));
+    if n > 0 && !refused {
+        s.state_mut()?.erased = Erased(taken);
+    }
+    Ok(n)
+}
+
+pub(super) fn run_oops(s: &mut Session, _p: &Value) -> Result<Value> {
+    let taken = s.state()?.erased.0.clone();
+    let editing = s.state()?.block_edit.as_ref().map(|b| b.name.clone());
+    let back: Vec<bool> = {
+        let d = s.doc()?;
+        let in_blocks = in_blocks(d, &taken, editing.as_deref());
+        taken.iter().map(|t| !in_blocks.contains(&t.entity.handle) && can_return(d, t)).collect()
+    };
+    // Nothing to bring back leaves the drawing as it is: no undo step.
+    if !back.contains(&true) {
+        return Ok(json!({ "restored": 0 }));
+    }
+    let n = restore(s.doc_mut()?, &taken, &back);
+    Ok(json!({ "restored": n }))
+}
+
+/// The handles of `taken` that a block's object has now (an undo can take the drawing back to
+/// before an erased object was made, and a block's new object take its handle). The block open
+/// in the Block Editor (`editing`) doesn't count: its objects there keep the handles they have in
+/// it.
+fn in_blocks(d: &Drawing, taken: &[Taken], editing: Option<&str>) -> HashSet<Handle> {
+    let hs: HashSet<Handle> = taken.iter().map(|t| t.entity.handle).collect();
+    let mut out = HashSet::new();
+    for b in d.blocks.values() {
+        if editing.is_some_and(|n| b.name.eq_ignore_ascii_case(n)) {
+            continue;
+        }
+        // Through whichever is smaller.
+        if b.entities.len() < hs.len() {
+            out.extend(b.entities.iter().map(|e| e.handle).filter(|h| hs.contains(h)));
+        } else {
+            out.extend(hs.iter().copied().filter(|h| b.entities.contains(*h)));
+        }
+    }
+    out
+}
+
+/// Whether `t` can come back: it is not in the drawing (OOPS again, or an undo brought it back),
+/// its handle is one the drawing has given out, a reference being edited in place (REFEDIT)
+/// doesn't keep it out, and its layout, layer and block are still there.
+fn can_return(d: &Drawing, t: &Taken) -> bool {
+    let h = t.entity.handle;
+    h.0 < d.handseed
+        && d.entity(h).is_none()
+        && !crate::cmd::blocks::refedit::locked(d, h)
+        && d.space(&t.space).is_some()
+        && d.layer(&t.entity.common.layer).is_some()
+        && match &t.entity.kind {
+            EntityKind::Insert(i) => d.block(&i.block).is_some(),
+            _ => true,
+        }
+}
+
+/// Put back the objects `back` marks. Each run of objects that were neighbours comes back from
+/// its bottom one up, so each goes directly above the one that was under it.
+fn restore(d: &mut Drawing, taken: &[Taken], back: &[bool]) -> usize {
+    let index: HashMap<Handle, usize> = taken.iter().enumerate().map(|(i, t)| (t.entity.handle, i)).collect();
+    let next: HashMap<Handle, usize> = taken.iter().enumerate().filter_map(|(i, t)| Some((t.below.filter(|b| index.contains_key(b))?, i))).collect();
+    let mut done = vec![false; taken.len()];
+    let mut n = 0;
+    for first in 0..taken.len() {
+        if taken[first].below.is_some_and(|b| index.contains_key(&b)) {
+            continue;
+        }
+        let mut at = Some(first);
+        while let Some(i) = at {
+            if std::mem::replace(&mut done[i], true) {
+                break;
+            }
+            if back[i] && put_back(d, taken, &index, i) {
+                n += 1;
+            }
+            at = next.get(&taken[i].entity.handle).copied();
+        }
+    }
+    n
+}
+
+/// Put `taken[i]` back directly above the nearest object that was under it and is here; when
+/// those are gone, directly under the nearest one that was above it; else on top.
+fn put_back(d: &mut Drawing, taken: &[Taken], index: &HashMap<Handle, usize>, i: usize) -> bool {
+    let t = &taken[i];
+    let Some(store) = d.space_mut(&t.space) else { return false };
+    let h = t.entity.handle;
+    store.push(Entity::clone(&t.entity));
+    match nearest(store, taken, index, t.below, |t| t.below) {
+        Some(Some(b)) => {
+            store.move_next_to(h, b, true);
+        }
+        Some(None) => {
+            store.send_to_back(h);
+        }
+        None => {
+            if let Some(Some(a)) = nearest(store, taken, index, t.above, |t| t.above) {
+                store.move_next_to(h, a, false);
+            }
+        }
+    }
+    true
+}
+
+/// From `h`, past objects erased with it that are not here, to the first object that is
+/// (`Some(Some)`), the end of the draw order (`Some(None)`), or an object that is gone (`None`).
+fn nearest(
+    store: &EntityStore,
+    taken: &[Taken],
+    index: &HashMap<Handle, usize>,
+    mut h: Option<Handle>,
+    step: fn(&Taken) -> Option<Handle>,
+) -> Option<Option<Handle>> {
+    for _ in 0..=taken.len() {
+        let Some(x) = h else { return Some(None) };
+        if store.contains(x) {
+            return Some(Some(x));
+        }
+        h = step(taken.get(*index.get(&x)?)?);
+    }
+    None
+}
@@ -1,6 +1,6 @@
 use super::break_join::join;
 use super::explode::explode;
-use super::transform::{erase, transform_entities};
+use super::transform::{at_elevation, erase, scale_entities, transform_entities};
 use super::{
    Accept, EngineError, EntityKind, Handle, Input, Interactive, Mat3, Prompt, Result, SelOutcome, SelectPhase, Session, Step, Vec2, line, number,
 };
@@ -242,7 +242,7 @@ impl SelectThen {
        let f = require_length(Some(f))?;
        // The next SCALE offers this factor.
        s.last_used.scale_factor = f;
-        transform_entities(s, &self.objs, &Mat3::scale_about(base, f), self.copy_mode)?;
+        scale_entities(s, &self.objs, at_elevation(s, base), f, self.copy_mode)?;
        s.set_selection(Vec::new());
        Ok(Step::Done)
    }
@@ -439,13 +439,13 @@ impl Interactive for SelectThen {
                };
                if f > 1e-12 && f.is_finite() {
                    s.last_used.scale_factor = f;
-                    transform_entities(s, &self.objs, &Mat3::scale_about(self.pts[0], f), self.copy_mode)?;
+                    scale_entities(s, &self.objs, at_elevation(s, self.pts[0]), f, self.copy_mode)?;
                }
                s.set_selection(Vec::new());
                Ok(Step::Done)
            }
            (Op::Mirror, 1, Input::Point(p)) => {
-                if p.near(self.pts[0], 1e-12) {
+                if p.near(self.pts[0], cadcraft_geom::EPS) {
                    return Err(EngineError::Other("Mirror line points must differ.".into()));
                }
                self.pts.push(p);
@@ -1,8 +1,33 @@
-use super::{Entity, Handle, Mat3, Result, Session, Value, Vec2, bad, bool_or, f64_req, json, point_param, point_req, targets};
+use cadcraft_geom::Vec3;
+
+use super::{Entity, Handle, Mat3, Result, Session, Value, Vec2, bad, bool_or, erase_kept, f64_req, json, point_param, point_req, targets};

 // ---------------- core operations ----------------

 pub(crate) fn transform_entities(s: &mut Session, hs: &[Handle], m: &Mat3, copy: bool) -> Result<Vec<Handle>> {
+    edit_entities(s, hs, copy, |e| e.kind.transform(m))
+}
+
+/// Scale `hs` by `f` about `base` in 3D, as AutoCAD 2024's SCALE does: about the base point's XY,
+/// and every height of the objects about its Z, their thickness too.
+pub(crate) fn scale_entities(s: &mut Session, hs: &[Handle], base: Vec3, f: f64, copy: bool) -> Result<Vec<Handle>> {
+    let m = Mat3::scale_about(base.xy(), f);
+    edit_entities(s, hs, copy, |e| {
+        e.kind.transform(&m);
+        e.kind.scale_heights(base.z, f);
+        e.common.thickness *= f;
+    })
+}
+
+/// `p` at the current elevation (ELEVATION), the Z AutoCAD gives a point entered without one.
+pub(crate) fn at_elevation(s: &Session, p: Vec2) -> Vec3 {
+    let z = s.doc().map(|d| d.header.f64("ELEVATION", 0.0)).ok().filter(|z| z.is_finite());
+    Vec3::new(p.x, p.y, z.unwrap_or(0.0))
+}
+
+/// Apply `edit` to each of `hs` still in the drawing, or to a copy of each when `copy`; an object
+/// on a locked layer is left alone unless it is copied. The handles edited or made.
+fn edit_entities(s: &mut Session, hs: &[Handle], copy: bool, edit: impl Fn(&mut Entity)) -> Result<Vec<Handle>> {
    let d = s.doc_mut()?;
    let mut out = Vec::new();
    for h in hs {
@@ -11,7 +36,7 @@ pub(crate) fn transform_entities(s: &mut Session, hs: &[Handle], m: &Mat3, copy:
            let Some(e) = d.entity(*h).map(|e| (**e).clone()) else { continue };
            let nh = d.new_handle();
            let mut ne = Entity { handle: nh, ..e };
-            ne.kind.transform(m);
+            edit(&mut ne);
            if let Some(st) = d.space_mut(&sp) {
                st.push(ne);
                out.push(nh);
@@ -21,7 +46,7 @@ pub(crate) fn transform_entities(s: &mut Session, hs: &[Handle], m: &Mat3, copy:
            if locked {
                continue;
            }
-            d.modify_entity(*h, |e| e.kind.transform(m))?;
+            d.modify_entity(*h, &edit)?;
            out.push(*h);
        }
    }
@@ -29,14 +54,9 @@ pub(crate) fn transform_entities(s: &mut Session, hs: &[Handle], m: &Mat3, copy:
 }

 pub(super) fn erase(s: &mut Session, hs: &[Handle]) -> Result<usize> {
-    let d = s.doc_mut()?;
-    let mut n = 0;
-    for h in hs {
-        let locked = d.entity(*h).and_then(|e| d.layer(&e.common.layer)).is_some_and(|l| l.locked);
-        if !locked && d.remove_entity(*h).is_some() {
-            n += 1;
-        }
-    }
+    let d = s.doc()?;
+    let free: Vec<Handle> = hs.iter().copied().filter(|h| !d.entity(*h).and_then(|e| d.layer(&e.common.layer)).is_some_and(|l| l.locked)).collect();
+    let n = erase_kept(s, &free)?;
    s.set_selection(Vec::new());
    Ok(n)
 }
@@ -92,7 +112,12 @@ pub(super) fn run_scale(s: &mut Session, p: &Value) -> Result<Value> {
    if f <= 0.0 {
        return Err(bad("scale", "factor must be positive"));
    }
-    let r = transform_entities(s, &hs, &Mat3::scale_about(base, f), bool_or(p, "copy", false))?;
+    // A Z given with the base point, as AutoCAD takes one; without one, the current elevation.
+    let base = match p.get("base").and_then(|b| b.get(2)) {
+        Some(z) => z.as_f64().map(|z| Vec3::new(base.x, base.y, z)).ok_or_else(|| bad("scale", "`base` Z must be a number"))?,
+        None => at_elevation(s, base),
+    };
+    let r = scale_entities(s, &hs, base, f, bool_or(p, "copy", false))?;
    Ok(json!({ "handles": r.iter().map(|h| h.hex()).collect::<Vec<_>>() }))
 }

@@ -100,7 +125,7 @@ pub(super) fn run_mirror(s: &mut Session, p: &Value) -> Result<Value> {
    let hs = targets(s, p)?;
    let a = point_req("mirror", p, "p1")?;
    let b = point_req("mirror", p, "p2")?;
-    if a.near(b, 1e-12) {
+    if a.near(b, cadcraft_geom::EPS) {
        return Err(bad("mirror", "mirror line points coincide"));
    }
    let erase_src = bool_or(p, "erase", false);
@@ -81,7 +81,7 @@ impl Interactive for BlendM {
            return Prompt::new("Enter continuity", curves::KW).kw(&["Tangent", "Smooth"]).default("Tangent");
        }
        match self.first {
-            None => Prompt::new("Select first object or", Accept::POINT).kw(&["CONtinuity"]),
+            None => Prompt::new("Select first object", Accept::POINT).kw(&["CONtinuity"]),
            Some(_) => Prompt::new("Select second point", Accept::POINT),
        }
    }
@@ -194,14 +194,14 @@ impl Interactive for LengthenM {
    fn prompt(&self, _s: &Session) -> Prompt {
        match self.phase {
            LPhase::Main => {
-                Prompt::new("Select an object to measure or", Accept::POINT).kw(&["DElta", "Percent", "Total", "DYnamic"]).default("DYnamic")
+                Prompt::new("Select an object to measure", Accept::POINT).kw(&["DElta", "Percent", "Total", "DYnamic"]).default("DYnamic")
            }
-            LPhase::Delta => Prompt::new("Enter delta length or", Accept::NUMBER).kw(&["Angle"]).default("0.0000"),
+            LPhase::Delta => Prompt::new("Enter delta length", Accept::NUMBER).kw(&["Angle"]).default("0.0000"),
            LPhase::DeltaAngle => Prompt::new("Enter delta angle", Accept::NUMBER).default("0"),
            LPhase::Percent => Prompt::new("Enter percentage length", Accept::NUMBER).default("100.0000"),
-            LPhase::Total => Prompt::new("Specify total length or", Accept::NUMBER).kw(&["Angle"]).default("1.0000"),
+            LPhase::Total => Prompt::new("Specify total length", Accept::NUMBER).kw(&["Angle"]).default("1.0000"),
            LPhase::TotalAngle => Prompt::new("Specify total angle", Accept::NUMBER).default("57"),
-            LPhase::Change => Prompt::new("Select an object to change or", Accept::POINT).kw(&["Undo"]),
+            LPhase::Change => Prompt::new("Select an object to change", Accept::POINT).kw(&["Undo"]),
            LPhase::DynEnd(..) => Prompt::new("Specify new end point", Accept::POINT),
        }
    }
@@ -87,8 +87,8 @@ impl Interactive for NcopyM {
    }
    fn prompt(&self, _s: &Session) -> Prompt {
        match (self.selecting_done, self.base) {
-            (false, _) => Prompt::new("Select nested objects to copy or", Accept::POINT).kw(&["Settings"]),
-            (true, None) => Prompt::new("Specify base point or", Accept::POINT).kw(&["Displacement", "Multiple"]).default("Displacement"),
+            (false, _) => Prompt::new("Select nested objects to copy", Accept::POINT).kw(&["Settings"]),
+            (true, None) => Prompt::new("Specify base point", Accept::POINT).kw(&["Displacement", "Multiple"]).default("Displacement"),
            (true, Some(b)) => Prompt::new("Specify second point or <use first point as displacement>", Accept::POINT).base(b),
        }
    }
@@ -398,7 +398,7 @@ impl Interactive for PeditM {
    fn prompt(&self, s: &Session) -> Prompt {
        match self.phase {
            PPhase::MSelect | PPhase::MConvert | PPhase::MMain | PPhase::MWidth | PPhase::MFuzz => self.multi_prompt(),
-            PPhase::Select => Prompt::new("Select polyline or", Accept::POINT).kw(&["Multiple"]),
+            PPhase::Select => Prompt::new("Select polyline", Accept::POINT).kw(&["Multiple"]),
            PPhase::Convert => {
                Prompt::new("Object selected is not a polyline. Do you want to turn it into one?", curves::KW).kw(&["Yes", "No"]).default("Y")
            }
@@ -103,6 +103,7 @@ pub(crate) fn flatten_kind(k: &mut EntityKind) {
        EntityKind::Hatch(h) => h.elevation = 0.0,
        EntityKind::Solid(so) | EntityKind::Trace(so) => so.corners.iter_mut().for_each(z),
        EntityKind::Face3d(f) => f.corners.iter_mut().for_each(z),
+        EntityKind::PolyfaceMesh(m) => m.vertices.iter_mut().for_each(z),
        EntityKind::Region(_) => {}
        EntityKind::Image(i) => {
            z(&mut i.insert);
@@ -146,20 +146,49 @@ impl Opts {
    }
 }

-/// Round every number of a JSON value to a multiple of `q`.
-fn quantize(v: &mut Value, q: f64) {
+/// Take the measurements (floating-point numbers) out of a JSON value, in order, leaving a marker
+/// in their place: two objects are equal when what is left matches, counts and flags included,
+/// and each pair of measurements is within the tolerance.
+fn split_numbers(v: &mut Value, nums: &mut Vec<f64>) {
    match v {
        Value::Number(n) => {
-            if let Some(x) = n.as_f64() {
-                *v = json!((x / q).round());
+            if n.is_f64()
+                && let Some(x) = n.as_f64()
+            {
+                nums.push(x);
+                *v = Value::String(NUMBER.into());
            }
        }
-        Value::Array(a) => a.iter_mut().for_each(|x| quantize(x, q)),
-        Value::Object(o) => o.values_mut().for_each(|x| quantize(x, q)),
+        Value::Array(a) => a.iter_mut().for_each(|x| split_numbers(x, nums)),
+        Value::Object(o) => o.values_mut().for_each(|x| split_numbers(x, nums)),
        _ => {}
    }
 }

+/// What [`split_numbers`] leaves where a number was.
+const NUMBER: &str = "\u{0}#";
+
+/// Whether two lists of numbers match pairwise to within `tol`.
+fn within(a: &[f64], b: &[f64], tol: f64) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() <= tol)
+}
+
+/// The numbers summed with weights in [1, 2) that no simple pattern shares (golden-ratio steps),
+/// so points on a diagonal of a grid don't all get the same sum; and the sum of the weights.
+fn weighted_sum(nums: &[f64]) -> (f64, f64) {
+    nums.iter().enumerate().fold((0.0, 0.0), |(sum, total), (j, x)| {
+        let w = 1.0 + (j as f64 * 0.618_033_988_749_895).fract();
+        (sum + w * x, total + w)
+    })
+}
+
+/// The cell of `x` on a grid of `step`. Values within one step of each other land in the same or
+/// neighbouring cells; values too large for the grid share the outermost ones.
+fn cell_of(x: f64, step: f64) -> i64 {
+    let k = (x / step).floor();
+    if k.is_finite() { k.clamp(-9e15, 9e15) as i64 } else { i64::MIN }
+}
+
 #[derive(Default)]
 struct Report {
    duplicates: usize,
@@ -234,33 +263,37 @@ fn overkill(s: &mut Session, hs: Option<Vec<Handle>>, o: &Opts) -> Result<Report

 /// Equal objects (numbers compared to the tolerance): the first in draw order stays, unless a
 /// later one is followed by an associative object.
+///
+/// Objects are hashed by their properties and shape (their JSON without the numbers), then by a
+/// weighted sum of their numbers on a grid of the tolerance times the weights' sum: two equal
+/// objects' sums are that close, so they land in the same or neighbouring cells, wherever the
+/// numbers fall.
 fn duplicates(cands: &[Cand], o: &Opts, gone: &mut [bool], rep: &mut Report) {
-    let mut seen: HashMap<(u32, String), usize> = HashMap::new();
-    for (i, c) in cands.iter().enumerate() {
+    // Keepers so far: (properties, shape) → cell of the sum → their numbers.
+    type Keepers = HashMap<i64, Vec<Vec<f64>>>;
+    let mut seen: HashMap<(u32, String), Keepers> = HashMap::new();
+    // Followed objects first, so a keeper is never displaced: everything deleted is within the
+    // tolerance of an object that stays.
+    let (followed, rest): (Vec<usize>, Vec<usize>) = (0..cands.len()).partition(|i| cands.get(*i).is_some_and(|c| c.protected));
+    for i in followed.into_iter().chain(rest) {
+        let Some(c) = cands.get(i) else { continue };
        let Ok(mut v) = serde_json::to_value(&c.e.kind) else { continue };
-        if o.tol > 0.0 {
-            quantize(&mut v, o.q());
+        let mut nums = Vec::new();
+        split_numbers(&mut v, &mut nums);
+        let (sum, weights) = weighted_sum(&nums);
+        let cell = cell_of(sum, o.q() * weights.max(1.0));
+        let cells = seen.entry((c.prop, v.to_string())).or_default();
+        let found = [cell.saturating_sub(1), cell, cell.saturating_add(1)]
+            .into_iter()
+            .any(|k| cells.get(&k).is_some_and(|keepers| keepers.iter().any(|n| within(n, &nums, o.tol))));
+        if !found || c.protected {
+            // A followed object stays even when it matches another.
+            cells.entry(cell).or_default().push(nums);
+            continue;
        }
-        let key = (c.prop, v.to_string());
-        match seen.get(&key).copied() {
-            None => {
-                seen.insert(key, i);
-            }
-            Some(k) => {
-                let keeper_protected = cands.get(k).is_some_and(|x| x.protected);
-                let victim = match (keeper_protected, c.protected) {
-                    (_, false) => i,
-                    (false, true) => {
-                        seen.insert(key, i);
-                        k
-                    }
-                    (true, true) => continue,
-                };
-                if let Some(g) = gone.get_mut(victim) {
-                    *g = true;
-                    rep.duplicates += 1;
-                }
-            }
+        if let Some(g) = gone.get_mut(i) {
+            *g = true;
+            rep.duplicates += 1;
        }
    }
 }
@@ -421,8 +454,8 @@ fn collinear(members: &[&LineRec], cands: &[Cand], o: &Opts, gone: &mut [bool],
 fn arcs(cands: &[Cand], o: &Opts, gone: &mut [bool], changed: &mut HashMap<usize, EntityKind>, rep: &mut Report) {
    let q = o.q();
    let g = q.max(1e-9);
-    let cell = |x: f64| (x / g).round() as i64;
-    let mut buckets: HashMap<(u32, i64, i64, i64, i64), Vec<usize>> = HashMap::new();
+    // (index, properties, centre and radius); cells of `g` hold them.
+    let mut recs: Vec<(usize, u32, [f64; 4])> = Vec::new();
    for (i, c) in cands.iter().enumerate() {
        if gone.get(i).copied().unwrap_or(true) || c.protected {
            continue;
@@ -442,12 +475,45 @@ fn arcs(cands: &[Cand], o: &Opts, gone: &mut [bool], changed: &mut HashMap<usize
        {
            continue;
        }
-        buckets.entry((c.prop, cell(center.x), cell(center.y), cell(r), cell(center.z))).or_default().push(i);
+        recs.push((i, c.prop, [center.x, center.y, r, center.z]));
    }
-    let mut keys: Vec<_> = buckets.keys().copied().collect();
-    keys.sort_unstable();
-    for key in keys {
-        let Some(group) = buckets.get(&key) else { continue };
+    // Those within `g` of each other in centre and radius are on one circle. Each object joins the
+    // first group whose every member is within `g` of it, or starts one: matches don't chain, so
+    // nothing is deleted for matching only an object that itself matches the keeper. Members are
+    // looked for in the neighbouring cells too, so values on either side of a cell boundary meet.
+    let mut grid: HashMap<(u32, [i64; 4]), Vec<usize>> = HashMap::new();
+    let mut group_of: Vec<usize> = Vec::with_capacity(recs.len());
+    // Each group's records, in draw order; groups in the order of their first object.
+    let mut members: Vec<Vec<usize>> = Vec::new();
+    for (ri, (_, prop, v)) in recs.iter().enumerate() {
+        let cells = v.map(|x| cell_of(x, g));
+        let mut near_groups: Vec<usize> = Vec::new();
+        for n in 0..81_i64 {
+            let near = [n % 3 - 1, n / 3 % 3 - 1, n / 9 % 3 - 1, n / 27 % 3 - 1];
+            let mut key = cells;
+            for (k, d) in key.iter_mut().zip(near) {
+                *k = k.saturating_add(d);
+            }
+            near_groups.extend(grid.get(&(*prop, key)).map(Vec::as_slice).unwrap_or_default().iter().filter_map(|rj| group_of.get(*rj)));
+        }
+        near_groups.sort_unstable();
+        near_groups.dedup();
+        let fits = |gi: &usize| members.get(*gi).is_some_and(|m| m.iter().all(|rk| recs.get(*rk).is_some_and(|(_, _, w)| within(v, w, g))));
+        let gi = match near_groups.into_iter().find(fits) {
+            Some(gi) => gi,
+            None => {
+                members.push(Vec::new());
+                members.len() - 1
+            }
+        };
+        if let Some(m) = members.get_mut(gi) {
+            m.push(ri);
+        }
+        group_of.push(gi);
+        grid.entry((*prop, cells)).or_default().push(ri);
+    }
+    let groups = members.iter().map(|m| m.iter().filter_map(|ri| recs.get(*ri).map(|r| r.0)).collect::<Vec<usize>>());
+    for group in groups {
        if group.len() < 2 {
            continue;
        }
@@ -465,7 +531,7 @@ fn arcs(cands: &[Cand], o: &Opts, gone: &mut [bool], changed: &mut HashMap<usize
            }
            continue;
        }
-        same_circle(group, cands, o, gone, changed, rep);
+        same_circle(&group, cands, o, gone, changed, rep);
    }
 }

@@ -101,9 +101,7 @@ impl PlotterStore {
            write: |n, t| {
                let p = file(n)?;
                std::fs::create_dir_all(dir()?).map_err(|e| e.to_string())?;
-                let tmp = p.with_extension("json.cadcraft-tmp");
-                std::fs::write(&tmp, t).map_err(|e| format!("{n}: {e}"))?;
-                std::fs::rename(&tmp, &p).map_err(|e| format!("{n}: {e}"))
+                crate::atomic_write::write_atomic(&p, t.as_bytes()).map_err(|e| format!("{n}: {e}"))
            },
            delete: |n| std::fs::remove_file(file(n)?).map_err(|e| format!("{n}: {e}")),
        }
@@ -1,7 +1,9 @@
 //! Properties: per-object property edits, current properties, CHPROP, MATCHPROP, linetypes, units,
 //! RENAME.

+mod change;
 mod chprop;
+mod dash_units;
 mod matchprop;
 mod rename;

@@ -23,6 +25,10 @@ pub fn specs() -> Vec<CommandSpec> {
        CommandSpec::new("chprop", "Change Properties", chprop::run_chprop)
            .params("as properties.set, leaving out objects on locked layers → {changed, locked} (the command line asks Color, LAyer, LType, ltScale, LWeight, Thickness and TRansparency in turn)")
            .interactive(|_| Ok(Box::new(chprop::ChpropM::new()))),
+        CommandSpec::new("change", "Change", change::run_change)
+            .alias(&["-ch"])
+            .params("{handles?, point?: [x, y], elevation?} → {changed, ignored, differingZ, detachedHatches, locked}: the point moves the nearer end of each line to it (level or plumb with the other end under ORTHOMODE) and, when it is the one object, passes a circle through it or places a text, attribute definition or block reference at it (`ignored` otherwise); `elevation` sets the z of objects whose points share one (`differingZ` otherwise); objects on locked layers are left out (the command line asks Specify change point or [Properties], then about each circle, text, attribute definition and block reference in turn)")
+            .interactive(|_| Ok(Box::new(change::ChangeM::new()))),
        CommandSpec::new("matchprop", "Match Properties", matchprop::run_matchprop)
            .menu(&["Modify", "Match Properties"])
            .alias(&["ma", "painter"])
@@ -38,6 +44,7 @@ pub fn specs() -> Vec<CommandSpec> {
        CommandSpec::new("lweight", "Lineweight...", run_lweight).menu(&["Format", "Lineweight..."]).alias(&["lw", "lineweight"]).params("{lineweight: mm | ByLayer}"),
        CommandSpec::new("ltscale", "Linetype Scale", run_ltscale).alias(&["lts"]).params("{scale}").interactive(|_| Ok(Box::new(LtscaleM))),
        CommandSpec::new("units", "Units...", run_units).menu(&["Format", "Units..."]).alias(&["un"]).params("{lunits?: 1..5, luprec?: 0..8, aunits?: 0..4, auprec?: 0..8, insunits?}"),
+        CommandSpec::new("-units", "Units", run_units).alias(&["-un"]).params("(as UNITS)").interactive(|_| Ok(Box::new(dash_units::DashUnits::default()))),
        CommandSpec::new("thickness", "Thickness", run_thickness)
            .menu(&["Format", "Thickness"])
            .params("{thickness} (THICKNESS: the 3D thickness given to new lines, arcs, circles, points and polylines; may be negative) → {thickness}")
@@ -758,10 +765,13 @@ fn run_style_current(s: &mut Session, p: &Value) -> Result<Value> {
    ok()
 }

-/// Text style names used by entities (in model, paper spaces and blocks) and dimension styles.
+/// Text style names used by entities (in model, paper spaces and blocks), dimension,
+/// multileader and table styles (their cell styles), and the text of complex linetypes.
 pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
    let mut out: Vec<String> = d.dim_styles.iter().map(|s| s.text_style.clone()).collect();
    out.extend(d.mleader_styles.iter().map(|s| s.text_style.clone()));
+    out.extend(d.table_styles.iter().flat_map(|s| s.cell_styles.iter().map(|c| c.text_style.clone())));
+    out.extend(d.linetypes.iter().flat_map(|lt| lt.pattern.iter().filter_map(|el| el.style.clone())));
    let stores = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).chain(d.blocks.values().map(|b| &b.entities));
    for st in stores {
        for e in st.iter() {
@@ -1181,6 +1191,11 @@ fn run_rename(s: &mut Session, p: &Value) -> Result<Value> {
            run_dimstyle_rename(s, &json!({ "from": from, "to": to }))?;
        }
        "linetype" | "ltype" => {
+            // Stored trimmed, as -RENAME types it: lookups compare names untrimmed.
+            let to = to.trim().to_string();
+            if !rename::valid_name(&to) {
+                return Err(bad("rename", format!("`{to}` is not a valid linetype name")));
+            }
            let d = s.doc_mut()?;
            if ["ByBlock", "ByLayer", "Continuous"].iter().any(|n| from.eq_ignore_ascii_case(n)) {
                return Err(bad("rename", format!("the {from} linetype cannot be renamed")));
@@ -1246,6 +1261,19 @@ mod tests {
        assert_eq!(col(&s), Color::ByBlock);
    }

+    #[test]
+    fn rename_linetype_rejects_invalid_names() {
+        let mut s = Session::new();
+        s.execute("linetype", &json!({ "load": "DASHED" })).unwrap();
+        for to in ["", "  ", "A;B", "A|B", "*X"] {
+            let r = s.execute("rename", &json!({ "table": "linetype", "from": "DASHED", "to": to }));
+            assert!(r.is_err(), "renamed DASHED to {to:?}: {r:?}");
+            assert!(s.doc().unwrap().linetype("DASHED").is_some());
+        }
+        s.execute("rename", &json!({ "table": "linetype", "from": "DASHED", "to": " DASH2 " })).unwrap();
+        assert!(s.doc().unwrap().linetype("DASH2").is_some());
+    }
+
    #[test]
    fn properties_set_rejects_unloaded_linetype() {
        let mut s = Session::new();
@@ -0,0 +1,544 @@
+//! CHANGE: change objects by a change point, or change their properties, as AutoCAD 2024 does.
+//!
+//! "Specify change point or [Properties]" follows "Select objects", which leaves objects on locked
+//! layers out as CHPROP does. Properties is CHPROP's loop with Elev added: the elevation is set
+//! when the command ends, and objects whose points differ in z keep theirs ("Cannot change
+//! elevation of objects with differing Z coordinates."). A change point, or Enter, goes through the
+//! objects in the order they were selected. Measured from AutoLISP's `command` (accoreconsole,
+//! every object read back with `entget`):
+//! - each line moves its end nearer the point to it: (0,0)–(50,0) with (60,10) gives
+//!   (0,0)–(60,10), with (−5,5) gives (−5,5)–(50,0). Under ORTHOMODE the moved end stays level or
+//!   plumb with the other one ((60,0)). Enter leaves lines alone;
+//! - a circle passes through the point (centre (100,0) and (115,0): radius 15), or asks "Specify
+//!   new circle radius <no change>";
+//! - a text is placed by the point (the alignment point of justified text), or asks "Specify new
+//!   text insertion point <no change>"; then "Enter new text style", "Specify new height" (not
+//!   with a style of fixed height, nor for Aligned text), "Specify new rotation angle" (not for
+//!   Aligned or Fit text, whose two points set it) and "Enter new text". An
+//!   attribute definition asks "Enter new tag", "Enter new prompt" and "Enter new default value" in
+//!   place of the text. A style that does not exist is refused: `Style "5" not defined - use STYLE
+//!   command.`;
+//! - a block reference is placed by the point, its attributes moving and turning with it, or asks
+//!   "Specify new block insertion point <no change>"; then "Specify new block rotation angle";
+//! - the point places a circle, text or block reference only when it is the one object selected:
+//!   with others, "Change point ignored" comes before that object's questions, which are asked as
+//!   for Enter;
+//! - other objects (arcs, polylines…) are left alone, and with nothing to change it says "No
+//!   changeable object selected".
+//!
+//! Elev sets the z of lines, 3D polylines and solids whose points share one, and of points,
+//! circles, arcs, ellipses, polylines, hatches (no longer associative: "Hatch boundary
+//! associativity removed."), texts, multiline texts and block references.
+
+use std::collections::{HashSet, VecDeque};
+
+use cadcraft_doc::{Attrib, EntityKind, HAlign, Handle, Text};
+use cadcraft_geom::{Mat3, Vec2, Vec3};
+use serde_json::{Value, json};
+
+use super::super::machines::{SelOutcome, SelectPhase, number};
+use super::super::{bad, f64_req, point_req, targets};
+use super::chprop::{ChpropM, begin_unlocked, feed_unlocked, locked};
+use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
+
+/// A question CHANGE asks about one object.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Ask {
+    /// Not a question: "Change point ignored" as the object comes up.
+    Ignored,
+    Radius,
+    TextPoint,
+    Style,
+    Height,
+    Rotation,
+    Value,
+    Tag,
+    AttPrompt,
+    Default,
+    BlockPoint,
+    BlockRotation,
+}
+
+enum Stage {
+    Select,
+    Point,
+    Properties(Box<ChpropM>),
+    /// The questions left, in order, each about one object.
+    Asking(VecDeque<(Handle, Ask)>),
+}
+
+pub(super) struct ChangeM {
+    select: SelectPhase,
+    handles: Vec<Handle>,
+    stage: Stage,
+}
+
+impl ChangeM {
+    pub(super) fn new() -> Self {
+        ChangeM { select: SelectPhase::default(), handles: Vec::new(), stage: Stage::Select }
+    }
+
+    /// Apply the change point `p` (`None`: Enter) and line up the questions it leaves.
+    fn change_point(&mut self, s: &mut Session, p: Option<Vec2>) -> Result<Step> {
+        let alone = self.handles.len() == 1;
+        let ortho = s.drafting_settings().orthomode;
+        let mut asks = VecDeque::new();
+        let mut changeable = false;
+        for &h in &self.handles {
+            let Some(kind) = s.doc()?.entity(h).map(|e| e.kind.clone()) else { continue };
+            if matches!(kind, EntityKind::Line(_)) {
+                if let Some(p) = p {
+                    move_end(s, h, p, ortho)?;
+                    changeable = true;
+                }
+                continue;
+            }
+            let Some(questions) = questions(&kind) else { continue };
+            changeable = true;
+            let placed = p.filter(|_| alone);
+            if p.is_some() && !alone {
+                asks.push_back((h, Ask::Ignored));
+            }
+            if let Some(q) = placed {
+                place(s, h, q)?;
+            }
+            // The point answers the first question: the radius or the insertion point.
+            asks.extend(questions.iter().skip(usize::from(placed.is_some())).map(|a| (h, *a)));
+        }
+        if !changeable {
+            s.echo("No changeable object selected");
+            return Ok(Step::Done);
+        }
+        self.stage = Stage::Asking(asks);
+        self.advance(s)
+    }
+
+    /// Pass over what needs no answer: say "Change point ignored", and skip what [`skipped`]
+    /// says isn't asked. Done when nothing is left to ask.
+    fn advance(&mut self, s: &mut Session) -> Result<Step> {
+        let Stage::Asking(asks) = &mut self.stage else { return Ok(Step::Continue) };
+        while let Some(&(h, ask)) = asks.front() {
+            match ask {
+                Ask::Ignored => s.echo("Change point ignored"),
+                a if skipped(s, h, a) => {}
+                _ => return Ok(Step::Continue),
+            }
+            asks.pop_front();
+        }
+        s.set_selection(Vec::new());
+        Ok(Step::Done)
+    }
+}
+
+/// The questions about an object of `kind`, the first answered by the change point when it is
+/// the one object; `None` when the change point leaves it alone.
+fn questions(kind: &EntityKind) -> Option<&'static [Ask]> {
+    Some(match kind {
+        EntityKind::Circle(_) => &[Ask::Radius],
+        EntityKind::Text(_) => &[Ask::TextPoint, Ask::Style, Ask::Height, Ask::Rotation, Ask::Value],
+        EntityKind::AttDef(_) => &[Ask::TextPoint, Ask::Style, Ask::Height, Ask::Rotation, Ask::Tag, Ask::AttPrompt, Ask::Default],
+        EntityKind::Insert(_) => &[Ask::BlockPoint, Ask::BlockRotation],
+        _ => return None,
+    })
+}
+
+fn text_of(kind: &EntityKind) -> Option<&Text> {
+    match kind {
+        EntityKind::Text(t) | EntityKind::AttDef(Attrib { text: t, .. }) => Some(t),
+        _ => None,
+    }
+}
+
+fn text_of_mut(kind: &mut EntityKind) -> Option<&mut Text> {
+    match kind {
+        EntityKind::Text(t) | EntityKind::AttDef(Attrib { text: t, .. }) => Some(t),
+        _ => None,
+    }
+}
+
+/// Where a circle, text or block reference is measured from: its centre, the point it is placed by
+/// (the alignment point of justified text) or its insertion point.
+fn anchor(kind: &EntityKind) -> Option<Vec2> {
+    match kind {
+        EntityKind::Circle(c) => Some(c.center.xy()),
+        EntityKind::Insert(i) => Some(i.insert.xy()),
+        k => text_of(k).map(Text::justify_point),
+    }
+}
+
+/// Whether CHANGE passes over `ask` for text `h`: the height of a text whose style has a fixed
+/// one or that is Aligned, and the rotation of Aligned or Fit text (their two points set it).
+fn skipped(s: &Session, h: Handle, ask: Ask) -> bool {
+    let Ok(d) = s.doc() else { return false };
+    let Some(t) = d.entity(h).and_then(|e| text_of(&e.kind)) else { return false };
+    match ask {
+        Ask::Height => t.halign == HAlign::Aligned || d.text_style(&t.style).is_some_and(|st| st.height > 0.0),
+        Ask::Rotation => matches!(t.halign, HAlign::Aligned | HAlign::Fit),
+        _ => false,
+    }
+}
+
+/// Move the end of line `h` nearer `p` to it; under ortho, level or plumb with the other end.
+fn move_end(s: &mut Session, h: Handle, p: Vec2, ortho: bool) -> Result<()> {
+    let settings = s.drafting_settings();
+    s.doc_mut()?.modify_entity(h, |e| {
+        if let EntityKind::Line(l) = &mut e.kind {
+            let (end, other) = if l.a.xy().dist(p) <= l.b.xy().dist(p) { (&mut l.a, l.b) } else { (&mut l.b, l.a) };
+            let q = if ortho { crate::snap::iso::constrain(&settings, other.xy(), p) } else { p };
+            end.x = q.x;
+            end.y = q.y;
+        }
+    })?;
+    Ok(())
+}
+
+/// Place circle, text or block reference `h` by `q`: a circle passes through it, a text or block
+/// reference moves there (with its attributes).
+fn place(s: &mut Session, h: Handle, q: Vec2) -> Result<()> {
+    s.doc_mut()?.modify_entity(h, |e| {
+        if let EntityKind::Circle(c) = &mut e.kind {
+            let r = c.center.xy().dist(q);
+            if r > 0.0 && r.is_finite() {
+                c.radius = r;
+            }
+        } else if let Some(at) = anchor(&e.kind) {
+            e.kind.transform(&Mat3::translate(q - at));
+        }
+    })?;
+    Ok(())
+}
+
+/// Set a circle's radius or a text's height.
+fn set_length(s: &mut Session, h: Handle, v: f64) -> Result<()> {
+    s.doc_mut()?.modify_entity(h, |e| match &mut e.kind {
+        EntityKind::Circle(c) => c.radius = v,
+        k => {
+            if let Some(t) = text_of_mut(k) {
+                t.height = v;
+            }
+        }
+    })?;
+    Ok(())
+}
+
+/// Set a text's rotation, or turn a block reference (and its attributes) to `angle` about its
+/// insertion point.
+fn set_rotation(s: &mut Session, h: Handle, angle: f64) -> Result<()> {
+    s.doc_mut()?.modify_entity(h, |e| {
+        if let EntityKind::Insert(i) = &e.kind {
+            let m = Mat3::rotate_about(i.insert.xy(), angle - i.rotation);
+            e.kind.transform(&m);
+        } else if let Some(t) = text_of_mut(&mut e.kind) {
+            t.rotation = cadcraft_geom::norm_angle(angle);
+        }
+    })?;
+    Ok(())
+}
+
+/// Take an answer to `ask` about `h`; `false` when it was refused (the question comes again).
+fn answer(s: &mut Session, h: Handle, ask: Ask, i: Input) -> Result<bool> {
+    let at = s.doc()?.entity(h).and_then(|e| anchor(&e.kind)).unwrap_or(Vec2::ZERO);
+    match (ask, i.clone()) {
+        // Enter keeps what there is.
+        (_, Input::Enter) => {}
+        (Ask::TextPoint | Ask::BlockPoint, Input::Point(q)) => place(s, h, q)?,
+        (Ask::TextPoint | Ask::BlockPoint, _) => return Err(EngineError::Other("Point or option keyword required.".into())),
+        (Ask::Radius | Ask::Height, Input::Point(_) | Input::Text(_)) => {
+            let v = match &i {
+                Input::Point(q) => q.dist(at),
+                Input::Text(t) => number(t).ok_or_else(|| EngineError::Other("Requires numeric distance or second point.".into()))?,
+                _ => 0.0,
+            };
+            if !(v > 0.0 && v.is_finite()) {
+                return Err(EngineError::Other("Value must be positive and nonzero.".into()));
+            }
+            set_length(s, h, v)?;
+        }
+        (Ask::Rotation | Ask::BlockRotation, Input::Point(q)) => set_rotation(s, h, at.angle_to(q))?,
+        (Ask::Rotation | Ask::BlockRotation, Input::Text(t)) => {
+            let a = s.angle_settings().direction(&t).ok_or_else(|| EngineError::Other("Requires an angle.".into()))?;
+            set_rotation(s, h, a)?;
+        }
+        (Ask::Style, Input::Text(t) | Input::Keyword(t)) => {
+            let name = t.trim();
+            let Some(style) = s.doc()?.text_style(name).map(|st| st.name.clone()) else {
+                s.echo(format!("Style \"{name}\" not defined - use STYLE command."));
+                return Ok(false);
+            };
+            s.doc_mut()?.modify_entity(h, |e| {
+                if let Some(t) = text_of_mut(&mut e.kind) {
+                    t.style = style;
+                }
+            })?;
+        }
+        (Ask::Value | Ask::Tag | Ask::AttPrompt | Ask::Default, Input::Text(t) | Input::Keyword(t)) => {
+            s.doc_mut()?.modify_entity(h, |e| match (&mut e.kind, ask) {
+                (EntityKind::AttDef(a), Ask::Tag) => a.tag = t,
+                (EntityKind::AttDef(a), Ask::AttPrompt) => a.prompt = t,
+                (k, _) => {
+                    if let Some(x) = text_of_mut(k) {
+                        x.value = t;
+                    }
+                }
+            })?;
+        }
+        _ => return Ok(false),
+    }
+    Ok(true)
+}
+
+/// The question `ask` about `h`.
+fn ask_prompt(s: &Session, h: Handle, ask: Ask) -> Prompt {
+    let d = s.doc().ok();
+    let kind = d.and_then(|d| d.entity(h)).map(|e| &e.kind);
+    let at = kind.and_then(anchor);
+    let text = kind.and_then(text_of);
+    // As the drawing shows directions: from ANGBASE in the ANGDIR sense (ANGBASE 90° shows a text
+    // at 0° as 270.00).
+    let deg = |a: f64| format!("{:.2}", s.angle_settings().shown(a).to_degrees());
+    match ask {
+        Ask::Radius => Prompt::new("Specify new circle radius", Accept::POINT_OR_NUMBER).default("no change").base_opt(at).distance(),
+        Ask::TextPoint => Prompt::new("Specify new text insertion point", Accept::POINT).default("no change"),
+        Ask::BlockPoint => Prompt::new("Specify new block insertion point", Accept::POINT).default("no change"),
+        Ask::Style => Prompt::new("Enter new text style", Accept::TEXT).default(text.map(|t| t.style.clone()).unwrap_or_default()),
+        Ask::Height => Prompt::new("Specify new height", Accept::POINT_OR_NUMBER)
+            .default(format!("{:.4}", text.map_or(0.0, |t| t.height)))
+            .base_opt(at)
+            .distance(),
+        Ask::Rotation => {
+            Prompt::new("Specify new rotation angle", Accept::POINT_OR_NUMBER).default(deg(text.map_or(0.0, |t| t.rotation))).base_opt(at)
+        }
+        Ask::BlockRotation => {
+            let r = match kind {
+                Some(EntityKind::Insert(i)) => i.rotation,
+                _ => 0.0,
+            };
+            Prompt::new("Specify new block rotation angle", Accept::POINT_OR_NUMBER).default(deg(r)).base_opt(at)
+        }
+        Ask::Value => Prompt::new("Enter new text", Accept::TEXT).default(text.map(|t| t.value.clone()).unwrap_or_default()),
+        Ask::Default => Prompt::new("Enter new default value", Accept::TEXT).default(text.map(|t| t.value.clone()).unwrap_or_default()),
+        Ask::Tag | Ask::AttPrompt => {
+            let (msg, v) = match (kind, ask) {
+                (Some(EntityKind::AttDef(a)), Ask::Tag) => ("Enter new tag", a.tag.clone()),
+                (Some(EntityKind::AttDef(a)), _) => ("Enter new prompt", a.prompt.clone()),
+                (_, Ask::Tag) => ("Enter new tag", String::new()),
+                _ => ("Enter new prompt", String::new()),
+            };
+            Prompt::new(msg, Accept::TEXT).default(v)
+        }
+        Ask::Ignored => Prompt::new("", Accept::TEXT),
+    }
+}
+
+/// The one z of `zs`, to rounding; `None` when they differ.
+fn shared_z(zs: impl IntoIterator<Item = f64>) -> Option<f64> {
+    let mut zs = zs.into_iter();
+    let first = zs.next().unwrap_or(0.0);
+    zs.all(|z| (z - first).abs() <= 1e-9 * (1.0 + first.abs())).then_some(first)
+}
+
+/// The elevation of an object Elev sets: `Some(None)` when its points differ in z (a line between
+/// two heights), `None` for the kinds Elev leaves alone.
+pub(super) fn elevation_of(kind: &EntityKind) -> Option<Option<f64>> {
+    match kind {
+        EntityKind::Line(l) => Some(shared_z([l.a.z, l.b.z])),
+        EntityKind::Polyline3d(p) => Some(shared_z(p.points.iter().map(|q| q.z))),
+        EntityKind::Solid(so) | EntityKind::Trace(so) => Some(shared_z(so.corners.iter().map(|c| c.z))),
+        EntityKind::Point(p) => Some(Some(p.p.z)),
+        EntityKind::Circle(c) => Some(Some(c.center.z)),
+        EntityKind::Arc(a) => Some(Some(a.center.z)),
+        EntityKind::Ellipse(e) => Some(Some(e.center.z)),
+        EntityKind::LwPolyline(p) => Some(Some(p.elevation)),
+        EntityKind::Hatch(h) => Some(Some(h.elevation)),
+        EntityKind::MText(t) => Some(Some(t.insert.z)),
+        EntityKind::Insert(i) => Some(Some(i.insert.z)),
+        k => text_of(k).map(|t| Some(t.insert.z)),
+    }
+}
+
+/// Move `text` up by `dz`.
+fn raise_text(text: &mut Text, dz: f64) {
+    for p in std::iter::once(&mut text.insert).chain(text.align_pt.as_mut()) {
+        p.z += dz;
+    }
+}
+
+fn set_elevation(kind: &mut EntityKind, z: f64) {
+    let set = |p: &mut Vec3| p.z = z;
+    match kind {
+        EntityKind::Line(l) => {
+            set(&mut l.a);
+            set(&mut l.b);
+        }
+        EntityKind::Polyline3d(p) => p.points.iter_mut().for_each(set),
+        EntityKind::Solid(so) | EntityKind::Trace(so) => so.corners.iter_mut().for_each(set),
+        EntityKind::Point(p) => set(&mut p.p),
+        EntityKind::Circle(c) => set(&mut c.center),
+        EntityKind::Arc(a) => set(&mut a.center),
+        EntityKind::Ellipse(e) => set(&mut e.center),
+        EntityKind::LwPolyline(p) => p.elevation = z,
+        EntityKind::Hatch(h) => {
+            h.elevation = z;
+            crate::cmd::hatch::detach(h);
+        }
+        EntityKind::MText(t) => set(&mut t.insert),
+        // A block reference's attributes go up with it.
+        EntityKind::Insert(i) => {
+            let dz = z - i.insert.z;
+            set(&mut i.insert);
+            for a in &mut i.attribs {
+                raise_text(&mut a.text, dz);
+                if let Some(ml) = &mut a.multiline {
+                    ml.mtext.insert.z += dz;
+                }
+            }
+        }
+        k => {
+            if let Some(t) = text_of_mut(k) {
+                let dz = z - t.insert.z;
+                raise_text(t, dz);
+            }
+        }
+    }
+}
+
+/// What [`elevate`] did.
+pub(super) struct Elevated {
+    /// The objects whose elevation was set.
+    pub(super) set: Vec<Handle>,
+    /// Objects whose points differ in z, which keep theirs.
+    pub(super) differing: usize,
+    /// Associative hatches, which no longer are.
+    pub(super) detached: usize,
+}
+
+/// Set the elevation of the objects among `hs` whose points share one.
+pub(super) fn elevate(s: &mut Session, hs: &[Handle], z: f64) -> Result<Elevated> {
+    let d = s.doc_mut()?;
+    let mut r = Elevated { set: Vec::new(), differing: 0, detached: 0 };
+    for &h in hs {
+        let Some(e) = d.entity(h) else { continue };
+        match elevation_of(&e.kind) {
+            Some(Some(_)) => {
+                r.detached += usize::from(matches!(&e.kind, EntityKind::Hatch(hatch) if hatch.associative));
+                d.modify_entity(h, |e| set_elevation(&mut e.kind, z))?;
+                r.set.push(h);
+            }
+            Some(None) => r.differing += 1,
+            None => {}
+        }
+    }
+    Ok(r)
+}
+
+/// Properties ▸ Elev as the command ends: set the elevation, and say what was left alone or
+/// changed besides.
+pub(super) fn elevate_and_say(s: &mut Session, hs: &[Handle], z: f64) -> Result<()> {
+    let r = elevate(s, hs, z)?;
+    if r.differing > 0 {
+        s.echo("Cannot change elevation of objects with differing Z coordinates.");
+    }
+    if r.detached > 0 {
+        s.echo("Hatch boundary associativity removed.");
+    }
+    Ok(())
+}
+
+/// CHANGE's JSON form: `point` changes the objects as the change point does (`ignored`: circles,
+/// texts and block references it leaves alone because others were selected too), `elevation` as
+/// Properties ▸ Elev does (`differingZ`: objects whose points differ in z; `detachedHatches`:
+/// associative hatches that no longer are); objects on locked layers are left out (`locked`).
+pub(super) fn run_change(s: &mut Session, p: &Value) -> Result<Value> {
+    // A point or an elevation that can't be read is refused, and so is a call with neither.
+    let point = p.get("point").map(|_| point_req("change", p, "point")).transpose()?;
+    let elevation = p.get("elevation").map(|_| f64_req("change", p, "elevation")).transpose()?;
+    if point.is_none() && elevation.is_none() {
+        return Err(bad("change", "`point` or `elevation` is required"));
+    }
+    let hs = targets(s, p)?;
+    let locked = locked(s, &hs);
+    let free: Vec<Handle> = hs.into_iter().filter(|h| !locked.contains(h)).collect();
+    let (mut changed, mut ignored, mut differing, mut detached) = (HashSet::new(), 0, 0, 0);
+    if let Some(q) = point {
+        let ortho = s.drafting_settings().orthomode;
+        for &h in &free {
+            let Some(kind) = s.doc()?.entity(h).map(|e| e.kind.clone()) else { continue };
+            if matches!(kind, EntityKind::Line(_)) {
+                move_end(s, h, q, ortho)?;
+                changed.insert(h);
+            } else if questions(&kind).is_some() {
+                if free.len() == 1 {
+                    place(s, h, q)?;
+                    changed.insert(h);
+                } else {
+                    ignored += 1;
+                }
+            }
+        }
+    }
+    if let Some(z) = elevation {
+        let r = elevate(s, &free, z)?;
+        changed.extend(r.set);
+        (differing, detached) = (r.differing, r.detached);
+    }
+    Ok(json!({ "changed": changed.len(), "ignored": ignored, "differingZ": differing, "detachedHatches": detached, "locked": locked.len() }))
+}
+
+impl Interactive for ChangeM {
+    fn name(&self) -> &'static str {
+        "CHANGE"
+    }
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        self.select = begin_unlocked(s);
+        if self.select.done {
+            self.handles = self.select.picked.clone();
+            self.stage = Stage::Point;
+        }
+        Ok(Step::Continue)
+    }
+    fn prompt(&self, s: &Session) -> Prompt {
+        match &self.stage {
+            Stage::Select => self.select.prompt(),
+            Stage::Point => Prompt::new("Specify change point", Accept::POINT).kw(&["Properties"]),
+            Stage::Properties(m) => m.prompt(s),
+            Stage::Asking(asks) => asks.front().map_or_else(|| Prompt::new("", Accept::TEXT), |&(h, ask)| ask_prompt(s, h, ask)),
+        }
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        match &mut self.stage {
+            Stage::Select => {
+                return Ok(match feed_unlocked(&mut self.select, s, i)? {
+                    SelOutcome::More => Step::Continue,
+                    SelOutcome::Done(hs) => {
+                        self.handles = hs;
+                        self.stage = Stage::Point;
+                        Step::Continue
+                    }
+                    SelOutcome::Empty => {
+                        s.set_selection(Vec::new());
+                        Step::Done
+                    }
+                });
+            }
+            Stage::Properties(m) => return m.input(s, i),
+            Stage::Asking(asks) => {
+                let Some(&(h, ask)) = asks.front() else { return Ok(Step::Done) };
+                if !answer(s, h, ask, i)? {
+                    return Ok(Step::Continue);
+                }
+                asks.pop_front();
+                return self.advance(s);
+            }
+            Stage::Point => {}
+        }
+        match i {
+            Input::Keyword(k) if k == "Properties" => {
+                self.stage = Stage::Properties(Box::new(ChpropM::change_properties(self.handles.clone())));
+                Ok(Step::Continue)
+            }
+            Input::Point(p) => self.change_point(s, Some(p)),
+            Input::Enter => self.change_point(s, None),
+            _ => Err(EngineError::Other("Point or option keyword required.".into())),
+        }
+    }
+}
@@ -28,6 +28,9 @@ use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};

 const PROPERTIES: [&str; 7] = ["Color", "LAyer", "LType", "ltScale", "LWeight", "Thickness", "TRansparency"];

+/// CHANGE's Properties: CHPROP's list with Elev.
+const CHANGE_PROPERTIES: [&str; 8] = ["Color", "Elev", "LAyer", "LType", "ltScale", "LWeight", "Thickness", "TRansparency"];
+
 /// What CHPROP asks for.
 #[derive(Clone, Copy, Debug, PartialEq)]
 enum Ask {
@@ -40,6 +43,7 @@ enum Ask {
    Lineweight,
    Thickness,
    Transparency,
+    Elevation,
 }

 pub(super) struct ChpropM {
@@ -47,11 +51,35 @@ pub(super) struct ChpropM {
    handles: Vec<Handle>,
    /// `None` while objects are selected.
    ask: Option<Ask>,
+    /// CHANGE's Properties: Elev is on the list.
+    change: bool,
+    /// The elevation typed at Elev, set when the command ends.
+    elevation: Option<f64>,
 }

 impl ChpropM {
    pub(super) fn new() -> Self {
-        ChpropM { select: SelectPhase::default(), handles: Vec::new(), ask: None }
+        ChpropM { select: SelectPhase::default(), handles: Vec::new(), ask: None, change: false, elevation: None }
+    }
+
+    /// CHANGE's Properties option on `handles`.
+    pub(super) fn change_properties(handles: Vec<Handle>) -> Self {
+        ChpropM { select: SelectPhase::default(), handles, ask: Some(Ask::Property), change: true, elevation: None }
+    }
+
+    fn keywords(&self) -> &'static [&'static str] {
+        if self.change { &CHANGE_PROPERTIES } else { &PROPERTIES }
+    }
+
+    /// The selection's common elevation, or "varies" (as a line between two heights does alone).
+    fn common_elevation(&self, s: &Session) -> String {
+        let Ok(d) = s.doc() else { return String::new() };
+        let zs: Vec<Option<f64>> = self.handles.iter().filter_map(|h| d.entity(*h)).filter_map(|e| super::change::elevation_of(&e.kind)).collect();
+        match zs.first() {
+            None => format!("{:.4}", 0.0),
+            Some(Some(z)) if zs.iter().all(|o| *o == Some(*z)) => format!("{z:.4}"),
+            Some(_) => "varies".into(),
+        }
    }

    /// The selection's common value of a property, or "varies".
@@ -151,6 +179,13 @@ impl ChpropM {
                    return Ok(false);
                }
            }
+            Ask::Elevation => match number(word).filter(|v| v.is_finite()) {
+                Some(z) => self.elevation = Some(z),
+                None => {
+                    s.echo("Requires a number.");
+                    return Ok(false);
+                }
+            },
            Ask::Property => {}
        }
        Ok(true)
@@ -158,7 +193,7 @@ impl ChpropM {
 }

 /// The objects among `hs` on locked layers.
-fn locked(s: &Session, hs: &[Handle]) -> HashSet<Handle> {
+pub(super) fn locked(s: &Session, hs: &[Handle]) -> HashSet<Handle> {
    hs.iter().copied().filter(|h| is_locked(s, *h)).collect()
 }

@@ -170,6 +205,38 @@ fn say_locked(s: &mut Session, n: usize) {
    }
 }

+/// Start selecting objects, leaving those on locked layers out of the pickfirst selection (and
+/// saying how many); `done` when some of it is left.
+pub(super) fn begin_unlocked(s: &mut Session) -> SelectPhase {
+    let mut select = SelectPhase::begin(s);
+    if select.done {
+        let locked = locked(s, &select.picked);
+        if !locked.is_empty() {
+            select.picked.retain(|h| !locked.contains(h));
+            say_locked(s, locked.len());
+            s.set_selection(select.picked.clone());
+            // Nothing left of the pickfirst selection: ask for objects instead.
+            select.done = !select.picked.is_empty();
+        }
+    }
+    select
+}
+
+/// Feed `i` to `select`, leaving picked objects on locked layers out and saying how many after
+/// what was found.
+pub(super) fn feed_unlocked(select: &mut SelectPhase, s: &mut Session, i: Input) -> Result<SelOutcome> {
+    let (i, n) = match i {
+        Input::Pick(hs) if !select.removing => {
+            let locked = locked(s, &hs);
+            (Input::Pick(hs.into_iter().filter(|h| !locked.contains(h)).collect()), locked.len())
+        }
+        i => (i, 0),
+    };
+    let outcome = select.feed(s, &i)?;
+    say_locked(s, n);
+    Ok(outcome)
+}
+
 /// CHPROP's JSON form: `properties.set` on the objects that are not on locked layers, which the
 /// command leaves out too; "locked" says how many were.
 pub(super) fn run_chprop(s: &mut Session, p: &Value) -> Result<Value> {
@@ -242,17 +309,7 @@ impl Interactive for ChpropM {
        "CHPROP"
    }
    fn begin(&mut self, s: &mut Session) -> Result<Step> {
-        self.select = SelectPhase::begin(s);
-        if self.select.done {
-            let locked = locked(s, &self.select.picked);
-            if !locked.is_empty() {
-                self.select.picked.retain(|h| !locked.contains(h));
-                say_locked(s, locked.len());
-                s.set_selection(self.select.picked.clone());
-                // Nothing left of the pickfirst selection: ask for objects instead.
-                self.select.done = !self.select.picked.is_empty();
-            }
-        }
+        self.select = begin_unlocked(s);
        if self.select.done {
            self.handles = self.select.picked.clone();
            self.ask = Some(Ask::Property);
@@ -262,7 +319,7 @@ impl Interactive for ChpropM {
    fn prompt(&self, s: &Session) -> Prompt {
        let Some(ask) = self.ask else { return self.select.prompt() };
        match ask {
-            Ask::Property => Prompt::new("Enter property to change", Accept::TEXT).kw(&PROPERTIES),
+            Ask::Property => Prompt::new("Enter property to change", Accept::TEXT).kw(self.keywords()),
            Ask::Color => {
                Prompt::new("New color", Accept::TEXT).kw(&["Truecolor"]).default(self.current(s, |e| e.common.color.name().to_ascii_uppercase()))
            }
@@ -275,21 +332,13 @@ impl Interactive for ChpropM {
            Ask::Lineweight => Prompt::new("Enter new lineweight", Accept::TEXT).default(self.current(s, |e| lineweight_name(e.common.lineweight))),
            Ask::Thickness => Prompt::new("Specify new thickness", Accept::NUMBER).default(self.current(s, |e| format!("{:.4}", e.common.thickness))),
            Ask::Transparency => Prompt::new("Enter transparency value", KW).default(self.current(s, |e| e.common.transparency.name())),
+            Ask::Elevation => Prompt::new("Specify new elevation", Accept::NUMBER).default(self.common_elevation(s)),
        }
    }
    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
        let Some(ask) = self.ask else {
            // Objects on locked layers are left out, and said after what was found.
-            let (i, n) = match i {
-                Input::Pick(hs) if !self.select.removing => {
-                    let locked = locked(s, &hs);
-                    (Input::Pick(hs.into_iter().filter(|h| !locked.contains(h)).collect()), locked.len())
-                }
-                i => (i, 0),
-            };
-            let outcome = self.select.feed(s, &i)?;
-            say_locked(s, n);
-            return Ok(match outcome {
+            return Ok(match feed_unlocked(&mut self.select, s, i)? {
                SelOutcome::More => Step::Continue,
                SelOutcome::Done(hs) => {
                    self.handles = hs;
@@ -304,6 +353,10 @@ impl Interactive for ChpropM {
        };
        match (ask, i) {
            (Ask::Property, Input::Enter) => {
+                // CHANGE sets the elevation as it ends.
+                if let Some(z) = self.elevation {
+                    super::change::elevate_and_say(s, &self.handles, z)?;
+                }
                s.set_selection(Vec::new());
                return Ok(Step::Done);
            }
@@ -315,12 +368,13 @@ impl Interactive for ChpropM {
                    "ltScale" => Ask::LtScale,
                    "LWeight" => Ask::Lineweight,
                    "Thickness" => Ask::Thickness,
+                    "Elev" => Ask::Elevation,
                    _ => Ask::Transparency,
                });
            }
            (Ask::Property, Input::Text(t)) => {
                let t = t.trim().trim_start_matches('_').to_ascii_lowercase();
-                let n = PROPERTIES.iter().filter(|k| k.to_ascii_lowercase().starts_with(&t)).count();
+                let n = self.keywords().iter().filter(|k| k.to_ascii_lowercase().starts_with(&t)).count();
                s.echo(if n > 1 { "Ambiguous response, please clarify..." } else { "Invalid option keyword." });
            }
            (Ask::Color, Input::Keyword(k)) if k == "Truecolor" => self.ask = Some(Ask::TrueColor),
@@ -0,0 +1,213 @@
+//! -UNITS: the drawing's units at the command line, with AutoCAD 2024's prompts and listings.
+
+use std::f64::consts::TAU;
+
+use crate::units::{AngleSettings, format_angle};
+use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
+
+const REPORT_FORMATS: [&str; 10] = [
+    "Report formats:      (Examples)",
+    "  1.  Scientific      1.55E+01",
+    "  2.  Decimal         15.50",
+    "  3.  Engineering     1'-3.50\"",
+    "  4.  Architectural   1'-3 1/2\"",
+    "  5.  Fractional      15 1/2",
+    "With the exception of Engineering and Architectural formats,",
+    "these formats can be used with any basic unit of measurement.",
+    "For example, Decimal mode is perfect for metric units as well",
+    "as decimal English units.",
+];
+
+const ANGLE_SYSTEMS: [&str; 6] = [
+    "Systems of angle measure:      (Examples)",
+    "  1.  Decimal degrees           45.0000",
+    "  2.  Degrees/minutes/seconds   45d0'0\"",
+    "  3.  Grads                     50.0000g",
+    "  4.  Radians                   0.7854r",
+    "  5.  Surveyor's units          N 45d0'0\" E",
+];
+
+const DENOMINATOR: &str = "Enter denominator of smallest fraction to display";
+
+/// The drawing's units, as -UNITS shows and asks them.
+struct Units {
+    lunits: i64,
+    luprec: i64,
+    aunits: i64,
+    auprec: i64,
+    angbase: f64,
+    clockwise: bool,
+}
+
+impl Units {
+    fn of(s: &Session) -> Units {
+        let Ok(d) = s.doc() else { return Units { lunits: 2, luprec: 4, aunits: 0, auprec: 0, angbase: 0.0, clockwise: false } };
+        let h = &d.header;
+        let angbase = h.f64("ANGBASE", 0.0);
+        Units {
+            lunits: h.i64("LUNITS", 2).clamp(1, 5),
+            luprec: h.i64("LUPREC", 4).clamp(0, 8),
+            aunits: h.i64("AUNITS", 0).clamp(0, 4),
+            auprec: h.i64("AUPREC", 0).clamp(0, 8),
+            angbase: if angbase.is_finite() { angbase } else { 0.0 },
+            clockwise: h.i64("ANGDIR", 0) != 0,
+        }
+    }
+
+    /// Architectural and fractional units give their precision as a fraction's denominator.
+    fn fractional(&self) -> bool {
+        matches!(self.lunits, 4 | 5)
+    }
+
+    /// Direction `a` (radians counterclockwise from +X) in the angle format, measured as the
+    /// drawing measures angles but from +X: -UNITS shows north as 270 when angles turn clockwise.
+    fn direction_text(&self, a: f64) -> String {
+        format_angle(if self.clockwise { -a } else { a }, self.aunits, self.auprec)
+    }
+
+    /// A typed direction of angle 0, in radians counterclockwise from +X: an amount in the angle
+    /// format, or with its own unit (`45d`, `0.5r`, `100g`, a bearing `N45dE`, `N`), measured
+    /// from +X as the drawing measures angles.
+    fn direction(&self, t: &str) -> Option<f64> {
+        let a = AngleSettings { aunits: self.aunits, ..AngleSettings::default() }.amount(t)?;
+        let a = if self.clockwise { -a } else { a };
+        a.is_finite().then(|| a.rem_euclid(TAU))
+    }
+}
+
+/// An integer answer in `lo..=hi`, or AutoCAD's message for one that isn't.
+fn integer(t: &str, lo: i64, hi: i64) -> Result<i64> {
+    let v = t.trim().parse::<i64>().map_err(|_| EngineError::Other("Requires an integer value.".into()))?;
+    if (lo..=hi).contains(&v) { Ok(v) } else { Err(EngineError::Other(format!("Requires an integer between {lo} and {hi}."))) }
+}
+
+#[derive(Clone, Copy, Default)]
+enum Ask {
+    #[default]
+    LengthFormat,
+    LengthPrecision,
+    AngleFormat,
+    AnglePrecision,
+    Direction,
+    Clockwise,
+}
+
+/// -UNITS: the length format and precision, the angle format and precision, the direction of
+/// angle 0 and whether angles turn clockwise, asked in that order. As in AutoCAD, each answer is
+/// kept as it is given (Esc keeps the ones before it), and choosing another format resets its
+/// precision to 4, the precision then offered.
+#[derive(Default)]
+pub(super) struct DashUnits {
+    ask: Ask,
+}
+
+impl Interactive for DashUnits {
+    fn name(&self) -> &'static str {
+        "-UNITS"
+    }
+
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        for l in REPORT_FORMATS {
+            s.echo(l);
+        }
+        Ok(Step::Continue)
+    }
+
+    fn prompt(&self, s: &Session) -> Prompt {
+        let u = Units::of(s);
+        match self.ask {
+            Ask::LengthFormat => Prompt::new("Enter choice, 1 to 5", Accept::NUMBER).default(u.lunits.to_string()),
+            Ask::LengthPrecision if u.fractional() => {
+                Prompt::new("(1, 2, 4, 8, 16, 32, 64, 128, or 256)", Accept::NUMBER).default((1_i64 << u.luprec).to_string())
+            }
+            Ask::LengthPrecision => {
+                Prompt::new("Enter number of digits to right of decimal point (0 to 8)", Accept::NUMBER).default(u.luprec.to_string())
+            }
+            Ask::AngleFormat => Prompt::new("Enter choice, 1 to 5", Accept::NUMBER).default((u.aunits + 1).to_string()),
+            Ask::AnglePrecision => {
+                Prompt::new("Enter number of fractional places for display of angles (0 to 8)", Accept::NUMBER).default(u.auprec.to_string())
+            }
+            Ask::Direction => {
+                Prompt::new(format!("Enter direction for angle {}", u.direction_text(0.0)), Accept::TEXT).default(u.direction_text(u.angbase))
+            }
+            Ask::Clockwise => Prompt::new("Measure angles clockwise?", Accept::TEXT).kw(&["Yes", "No"]).default(if u.clockwise { "Y" } else { "N" }),
+        }
+    }
+
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        let u = Units::of(s);
+        let text = match &i {
+            Input::Text(t) => Some(t.as_str()),
+            Input::Enter => None,
+            Input::Keyword(k) => Some(k.as_str()),
+            _ => return Ok(Step::Continue),
+        };
+        let h = &mut s.doc_mut()?.header;
+        match self.ask {
+            Ask::LengthFormat => {
+                let l = text.map_or(Ok(u.lunits), |t| integer(t, 1, 5))?;
+                if l != u.lunits {
+                    h.set_i64("LUNITS", l);
+                    h.set_i64("LUPREC", 4);
+                }
+                self.ask = Ask::LengthPrecision;
+                if matches!(l, 4 | 5) {
+                    s.echo(DENOMINATOR);
+                }
+            }
+            Ask::LengthPrecision => {
+                let prec = if u.fractional() {
+                    let den = text.map_or(Some(1 << u.luprec), |t| t.trim().parse::<i64>().ok());
+                    let Some(p) = den.and_then(|d| (0..=8).find(|p| 1_i64 << p == d)) else {
+                        s.echo("Invalid choice.");
+                        s.echo(DENOMINATOR);
+                        return Ok(Step::Continue);
+                    };
+                    p
+                } else {
+                    text.map_or(Ok(u.luprec), |t| integer(t, 0, 8))?
+                };
+                h.set_i64("LUPREC", prec);
+                self.ask = Ask::AngleFormat;
+                for l in ANGLE_SYSTEMS {
+                    s.echo(l);
+                }
+            }
+            Ask::AngleFormat => {
+                let a = text.map_or(Ok(u.aunits + 1), |t| integer(t, 1, 5))? - 1;
+                if a != u.aunits {
+                    h.set_i64("AUNITS", a);
+                    h.set_i64("AUPREC", 4);
+                }
+                self.ask = Ask::AnglePrecision;
+            }
+            Ask::AnglePrecision => {
+                h.set_i64("AUPREC", text.map_or(Ok(u.auprec), |t| integer(t, 0, 8))?);
+                self.ask = Ask::Direction;
+                let u = Units::of(s);
+                s.echo(format!("Direction for angle {}:", u.direction_text(0.0)));
+                for (name, deg) in [("East    3", 0.0), ("North  12", 90.0), ("West    9", 180.0), ("South   6", 270.0)] {
+                    s.echo(format!("   {name} o'clock  =  {}", u.direction_text(f64::to_radians(deg))));
+                }
+            }
+            Ask::Direction => {
+                if let Some(t) = text {
+                    let a = u.direction(t).ok_or_else(|| EngineError::Other("Requires valid numeric angle or two points.".into()))?;
+                    h.set_f64("ANGBASE", a);
+                }
+                self.ask = Ask::Clockwise;
+            }
+            Ask::Clockwise => {
+                let clockwise = match text.map(|t| t.trim().trim_start_matches('_').to_ascii_lowercase()) {
+                    None => u.clockwise,
+                    Some(t) if t == "y" || t == "yes" => true,
+                    Some(t) if t == "n" || t == "no" => false,
+                    Some(_) => return Err(EngineError::Other("Invalid option keyword.".into())),
+                };
+                h.set_i64("ANGDIR", i64::from(clockwise));
+                return Ok(Step::Done);
+            }
+        }
+        Ok(Step::Continue)
+    }
+}
@@ -8,7 +8,7 @@ use serde_json::json;
 use super::super::bad;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};

-fn valid_name(n: &str) -> bool {
+pub(super) fn valid_name(n: &str) -> bool {
    !n.trim().is_empty() && n.len() <= 255 && !n.starts_with('*') && !n.chars().any(|c| "<>/\\\":;?*|,=`".contains(c))
 }

@@ -112,7 +112,7 @@ impl Interactive for BreakM {
    fn prompt(&self, _s: &Session) -> Prompt {
        match self.table {
            None => Prompt::new("Select a table", Accept::SELECT),
-            Some(_) => Prompt::new("Enter maximum part height or", Accept::POINT_OR_NUMBER).kw(&["Off"]),
+            Some(_) => Prompt::new("Enter maximum part height", Accept::POINT_OR_NUMBER).kw(&["Off"]),
        }
    }
    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
@@ -333,6 +333,9 @@ fn call(name: &str, args: &[Val]) -> Result<Val, String> {
        "min" | "max" => {
            arity(1, MAX_ARGS)?;
            let vs = (0..args.len()).map(n).collect::<Result<Vec<_>, _>>()?;
+            if vs.iter().any(|v| !v.is_finite()) {
+                return Err("result is not a finite number".into());
+            }
            let f = if name == "min" { f64::min } else { f64::max };
            Ok(Val::Num(vs.into_iter().reduce(f).unwrap_or(0.0)))
        }
@@ -597,6 +600,10 @@ mod tests {
        assert!(ev("[1").is_err());
        assert!(ev(&"[".repeat(5000)).is_err());
        assert_eq!(ev("min(3,1,2)"), Ok(Val::Num(1.0)));
+        assert!(ev("min(sqrt(-1), 5)").is_err());
+        assert!(ev("max(5, ln(-1))").is_err());
+        assert!(ev("min(exp(1000), 5)").is_err());
+        assert!(ev("max(exp(1000), 5)").is_err());
        assert_eq!(ev("1e-3*2"), Ok(Val::Num(0.002)));
        assert!(ev("max(1,2,3,4,5,6,7,8,9)").is_err());
    }
@@ -35,6 +35,11 @@ pub struct DocState {
    /// The Block Editor (BEDIT), when it is open: `doc` is then the editor's drawing, and the
    /// drawing itself waits in it ([`DocState::drawing`]).
    pub block_edit: Option<blockedit::BlockEdit>,
+    /// What the last erase removed, for OOPS.
+    pub(crate) erased: crate::cmd::Erased,
+    /// The fonts missing on Windows that a save last named: the next save names them again only
+    /// when they change.
+    pub(crate) fonts_noted: String,
 }

 static NEXT_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -61,6 +66,8 @@ impl DocState {
            uid: NEXT_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
            binary_dxf: false,
            block_edit: None,
+            erased: Default::default(),
+            fonts_noted: String::new(),
        }
    }
    /// The drawing has changes not saved to its file, or the Block Editor has changes not yet
@@ -68,6 +75,14 @@ impl DocState {
    pub fn is_dirty(&self) -> bool {
        !Arc::ptr_eq(self.drawing(), &self.saved) || self.block_unsaved()
    }
+    /// Show the drawing an undo or redo step holds, with nothing selected; returns the drawing as
+    /// it was, as the step back.
+    pub(crate) fn swap_in(&mut self, snap: Snapshot) -> Snapshot {
+        let cur = Snapshot { label: snap.label, doc: std::mem::replace(&mut self.doc, snap.doc), selection: std::mem::take(&mut self.selection) };
+        self.follow_layout(&cur.doc);
+        self.revision += 1;
+        cur
+    }
    /// After undo/redo replaced the drawing (`before` is the one shown until then): if the current
    /// layout no longer exists, follow it to its other name when it was renamed (same tab order,
    /// a name `before` did not have), else go to the Model tab.
@@ -226,6 +226,7 @@ pub fn stretch_grip(kind: &EntityKind, index: usize, to: Vec2) -> Option<EntityK
        }
        EntityKind::Solid(s) | EntityKind::Trace(s) => set_xy(s.corners.get_mut(index)?, to),
        EntityKind::Face3d(f) => set_xy(f.corners.get_mut(index)?, to),
+        EntityKind::PolyfaceMesh(m) => set_xy(m.vertices.get_mut(index)?, to),
        EntityKind::Region(_) => return Some(translated(kind, delta)),
        EntityKind::Viewport(v) => {
            let opposite = *grips.get((index + 2) % 4)?;
@@ -25,6 +25,10 @@ pub struct LastUsed {
    pub mleader_block: String,
    /// BREAKLINE's Block, Size and Extension.
    pub breakline: cmd::BreaklineOptions,
+    /// -ARRAY's type: Polar instead of Rectangular.
+    pub classic_array_polar: bool,
+    /// RECTANG's chamfer, fillet, width, elevation, thickness and rotation.
+    pub rectang: RectangModes,
 }

 impl Default for LastUsed {
@@ -39,10 +43,26 @@ impl Default for LastUsed {
            mleader: MLeaderOptions::default(),
            mleader_block: String::new(),
            breakline: cmd::BreaklineOptions::default(),
+            classic_array_polar: false,
+            rectang: RectangModes::default(),
        }
    }
 }

+/// The modes RECTANG keeps from one rectangle to the next, as AutoCAD 2024 does. Chamfer and
+/// fillet exclude each other: setting one clears the other.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct RectangModes {
+    /// First and second chamfer distances.
+    pub chamfer: (f64, f64),
+    pub fillet: f64,
+    pub width: f64,
+    pub elevation: f64,
+    pub thickness: f64,
+    /// Radians.
+    pub rotation: f64,
+}
+
 /// Which part of a multileader MLEADER places first.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub enum LeaderOrder {
@@ -92,6 +92,12 @@ pub struct Session {
    pub last_command: Option<String>,
    /// LASTPOINT.
    pub last_point: Vec2,
+    /// AREA and PERIMETER: the last area AREA or MEASUREGEOM measured (in their Add and Subtract
+    /// modes the running total) and that area's perimeter. Not saved, as in AutoCAD.
+    pub area: f64,
+    pub perimeter: f64,
+    /// DISTANCE: the last distance DIST or MEASUREGEOM measured (with Multiple points, the total).
+    pub distance: f64,
    /// The last segment given at a point prompt (its base point and the point): polar angles
    /// relative to the last segment (POLARMODE bit 1) are measured from it.
    pub last_segment: Option<(Vec2, Vec2)>,
@@ -173,6 +179,9 @@ impl Session {
            log: Vec::new(),
            last_command: None,
            last_point: Vec2::ZERO,
+            area: 0.0,
+            perimeter: 0.0,
+            distance: 0.0,
            last_segment: None,
            last_polar: None,
            point_mods: Vec::new(),
@@ -18,7 +18,7 @@ use std::sync::Arc;

 use cadcraft_doc::{Drawing, Handle};

-use crate::{Input, Prompt, Session};
+use crate::{Input, Prompt, Session, undoctl};
 use eval::{Ctx, Machine, Need, Outcome};
 use value::{Sym, Value};

@@ -111,6 +111,8 @@ pub struct LispState {
    run: Option<Box<Run>>,
    /// A routine runs, from its start to its end (also while its machine is out of `run`).
    active: bool,
+    /// The running routine's own undo steps (also while its machine is out of `run`).
+    steps: RoutineSteps,
    /// Files loaded by APPLOAD, by name, for `(load name)` where there is no file system.
    files: HashMap<String, String>,
    /// Where startup files are read from (see `startup.rs`).
@@ -123,6 +125,19 @@ pub struct LispState {
    pub(crate) limits: Limits,
 }

+/// What U and REDO inside the running routine take back: the commands it ran, each as the drawing
+/// was before it, last last. The routine is still one undo step once it ends.
+#[derive(Default)]
+struct RoutineSteps {
+    /// The drawing the routine runs in.
+    uid: u64,
+    undo: std::collections::VecDeque<crate::Snapshot>,
+    redo: std::collections::VecDeque<crate::Snapshot>,
+    /// Where the routine's undo step starts, when U or REDO inside it went on to the drawing's
+    /// own steps; else where the routine started.
+    base: Option<(Arc<Drawing>, Vec<Handle>)>,
+}
+
 /// What a run may use (see [`value`]'s memory notes).
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct Limits {
@@ -247,6 +262,7 @@ impl Session {
        let st = self.state()?;
        let before = Some((st.doc.clone(), st.selection.clone()));
        let uid = st.uid;
+        self.lisp.steps = RoutineSteps { uid, ..RoutineSteps::default() };
        self.lisp.run = Some(Box::new(Run {
            machine,
            uid,
@@ -324,7 +340,7 @@ impl Session {
                Ok(o) => o,
                Err(p) => {
                    // A panic inside a built-in: put the drawing back as the routine found it.
-                    if let Some((doc, sel)) = &run.before
+                    if let Some((doc, sel)) = self.lisp.steps.base.as_ref().or(run.before.as_ref())
                        && let Some(st) = self.docs.iter_mut().find(|d| d.uid == run.uid)
                    {
                        st.doc = doc.clone();
@@ -422,6 +438,7 @@ impl Session {
    fn lisp_end(&mut self, result: std::result::Result<Value, String>) {
        let Some(run) = self.lisp.run.take() else { return };
        self.lisp.active = false;
+        let steps = std::mem::take(&mut self.lisp.steps);
        let mut env = self.lisp.envs.remove(&run.uid).unwrap_or_default();
        self.lisp_flush(&mut env, true);
        self.lisp.envs.insert(run.uid, env);
@@ -431,7 +448,7 @@ impl Session {
                self.echo(text);
            }
        }
-        if let Some((doc, sel)) = run.before
+        if let Some((doc, sel)) = steps.base.or(run.before)
            && let Some(st) = self.docs.iter_mut().find(|d| d.uid == run.uid)
            && !Arc::ptr_eq(&doc, &st.doc)
        {
@@ -489,6 +506,7 @@ impl Session {
            self.lisp_error(LispError::quit(msg));
        } else if self.lisp.active {
            self.lisp.active = false;
+            self.lisp.steps = RoutineSteps::default();
            self.echo(format!("; error: {msg}"));
            self.lisp_last = Some(Err(msg));
        } else {
@@ -577,6 +595,67 @@ impl Session {
        self.lisp.active
    }

+    /// A command the running routine ran changed the drawing (`snap` holds it as it was): U inside
+    /// the routine takes it back, as AutoCAD's does, while the routine stays one undo step. UNDO
+    /// Control One keeps only the last, None none.
+    pub(crate) fn lisp_record_step(&mut self, snap: crate::Snapshot) {
+        let Some(uid) = self.routine_steps() else { return };
+        let mut control = undoctl::Control::All;
+        // A command ends what REDO could bring back, the drawing's own steps too.
+        if let Some(st) = self.docs.iter_mut().find(|d| d.uid == uid) {
+            st.redo.clear();
+            control = st.undo_ctl.control;
+        }
+        let steps = &mut self.lisp.steps;
+        steps.redo.clear();
+        match control {
+            undoctl::Control::None => steps.undo.clear(),
+            undoctl::Control::One => {
+                steps.undo.clear();
+                steps.undo.push_back(snap);
+            }
+            // As many as the drawing keeps.
+            undoctl::Control::All => {
+                steps.undo.push_back(snap);
+                if steps.undo.len() > undoctl::MAX_UNDO {
+                    steps.undo.pop_front();
+                }
+            }
+        }
+    }
+
+    /// U (or with `redo`, REDO) inside the running routine: take its last command back (or bring
+    /// back what U took). None when it has none left, and the drawing's own steps go on from there.
+    pub(crate) fn lisp_take_back(&mut self, redo: bool) -> Option<String> {
+        let uid = self.routine_steps()?;
+        let st = self.docs.iter_mut().find(|d| d.uid == uid)?;
+        let steps = &mut self.lisp.steps;
+        let (from, to) = if redo { (&mut steps.redo, &mut steps.undo) } else { (&mut steps.undo, &mut steps.redo) };
+        let cur = st.swap_in(from.pop_back()?);
+        let label = cur.label.clone();
+        to.push_back(cur);
+        Some(label)
+    }
+
+    /// U or REDO inside the running routine went on to the drawing's steps before it: the
+    /// routine's own undo step starts from the drawing as that left it, and REDO brings back that
+    /// step before what U took back of the routine's.
+    pub(crate) fn lisp_rebase(&mut self) {
+        if self.routine_steps().is_none() {
+            return;
+        }
+        if let Ok(st) = self.state() {
+            self.lisp.steps.base = Some((st.doc.clone(), st.selection.clone()));
+            self.lisp.steps.redo.clear();
+        }
+    }
+
+    /// The active drawing's uid when a routine runs in it.
+    fn routine_steps(&self) -> Option<u64> {
+        let uid = self.state().ok()?.uid;
+        (self.lisp.active && self.lisp.steps.uid == uid).then_some(uid)
+    }
+
    /// The commands the active drawing's LISP defines (`c:` functions), uppercase and sorted.
    pub fn lisp_commands(&self) -> Vec<String> {
        let Ok(uid) = self.state().map(|s| s.uid) else { return Vec::new() };
@@ -60,20 +60,43 @@ pub(super) fn atoi(a: &[Value]) -> R {
    Ok(Value::Int(t.get(..end).and_then(|n| n.parse::<i64>().ok()).map(|n| n as i32).unwrap_or(0)))
 }

-/// C's `atof`: the longest number at the start; 0.0 when there is none.
+/// C's `atof`: the number token at the start; 0.0 when there is none.
+/// An overflowing token clamps to the largest finite value of its sign.
 pub(super) fn atof(a: &[Value]) -> R {
    arity(a, 1, 1)?;
    let s = string(&a[0])?;
-    // The longest prefix (of the first 64 characters) that reads as a finite number.
-    let t: String = s.trim_start().chars().take(64).collect();
-    let ends: Vec<usize> = t.char_indices().map(|(i, _)| i).skip(1).chain(std::iter::once(t.len())).collect();
-    let v = ends.iter().rev().find_map(|&e| t.get(..e).and_then(|p| p.parse::<f64>().ok()).filter(|v| v.is_finite() && !p_is_word(&t[..e])));
-    Ok(Value::Real(v.unwrap_or(0.0)))
-}
-
-/// Words Rust reads as numbers that C's `atof` doesn't ("inf", "nan", "infinity").
-fn p_is_word(p: &str) -> bool {
-    p.chars().any(|c| c.is_ascii_alphabetic() && !matches!(c, 'e' | 'E'))
+    let b = s.trim_start().as_bytes();
+    let digits = |mut i: usize| {
+        while b.get(i).is_some_and(u8::is_ascii_digit) {
+            i += 1;
+        }
+        i
+    };
+    let mut i = usize::from(matches!(b.first(), Some(b'-' | b'+')));
+    let int_end = digits(i);
+    let mut end = int_end;
+    let mut mantissa = int_end > i;
+    if b.get(end) == Some(&b'.') {
+        let frac_end = digits(end + 1);
+        if mantissa || frac_end > end + 1 {
+            mantissa = true;
+            end = frac_end;
+        }
+    }
+    if mantissa && matches!(b.get(end), Some(b'e' | b'E')) {
+        i = end + 1 + usize::from(matches!(b.get(end + 1), Some(b'-' | b'+')));
+        let exp_end = digits(i);
+        if exp_end > i {
+            end = exp_end;
+        }
+    }
+    let v = if mantissa { b.get(..end).and_then(|t| std::str::from_utf8(t).ok()).and_then(|t| t.parse::<f64>().ok()) } else { None };
+    let v = match v {
+        Some(v) if v.is_finite() => v,
+        Some(v) if v.is_infinite() => f64::MAX.copysign(v),
+        _ => 0.0,
+    };
+    Ok(Value::Real(v))
 }

 pub(super) fn chr(a: &[Value]) -> R {
@@ -1039,3 +1039,12 @@ fn a_lisp_value_at_a_prompt_is_not_evaluated_again() {
    });
    assert_eq!(r, Some(4.0));
 }
+
+#[test]
+fn atof_out_of_range_exponent_reads_whole_token() {
+    let mut s = Session::new();
+    // Overflow must not fall back to a shorter prefix such as "1e40".
+    assert_eq!(ok(&mut s, "(> (atof \"1e400\") 1e300)"), "T");
+    assert_eq!(ok(&mut s, "(< (atof \"-1e400\") -1e300)"), "T");
+    assert_eq!(ok(&mut s, "(= (atof \"1e-400\") 0.0)"), "T");
+}
@@ -26,6 +26,41 @@ impl Accept {
    pub const SELECT: Accept = Accept { point: true, number: false, text: false, select: true, enter: true };
 }

+/// Prompts that ask for one of their keywords, which AutoCAD 2024 writes without "or" before them:
+/// "Enter an option [?/Make/Set/…]:", "Enter layout option [Copy/Delete/…/?] <set>:", "New color
+/// [Truecolor/COlorbook] <BYLAYER>:". A prompt asking for something else besides its keywords has
+/// it: "Enter block name or [?]:", "Specify insertion base point or [Basepoint/…]:". Read from
+/// AutoCAD's command line over measured runs, where no prompt was written both ways.
+const NO_OR: [&str; 27] = [
+    "Bring to front",
+    "Calculate rectangle dimensions based on",
+    "Choose mode for selected object conversion",
+    "Create annotative block",
+    "Enter a configuration option",
+    "Enter a plotting preference",
+    "Enter an annotation option",
+    "Enter an option",
+    "Enter an option to change",
+    "Enter attribute visibility setting",
+    "Enter justification",
+    "Enter layout option",
+    "Enter leader format option",
+    "Enter line spacing type",
+    "Enter object ordering option",
+    "Enter polyline linetype generation option",
+    "Enter property to change",
+    "Enter the type of array",
+    "Enter type of unused objects to purge",
+    "Enter viewport arrangement",
+    "Explode block",
+    "New color",
+    "Orient relative to sheet in paper space viewports",
+    "Select a content type",
+    "Select a leader type",
+    "Use landing",
+    "Viewport View Locking",
+];
+
 /// A prompt shown on the command line.
 #[derive(Clone, Debug, Default, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -148,15 +183,7 @@ impl Prompt {
        }
        let mut s = self.message.clone();
        if !self.keywords.is_empty() {
-            // A question offers its answers ("Fix any errors detected? [Yes/No]"); anything else
-            // offers options besides what it asks for ("Specify next point or [Undo]").
-            s.push_str(if self.message.is_empty() {
-                "["
-            } else if self.message.ends_with('?') {
-                " ["
-            } else {
-                " or ["
-            });
+            s.push_str(self.keyword_lead());
            s.push_str(&self.keywords.join("/"));
            s.push(']');
        }
@@ -166,6 +193,20 @@ impl Prompt {
        s.push(':');
        s
    }
+    /// What goes between the message and its keywords. A question offers its answers ("Fix any
+    /// errors detected? [Yes/No]"), and so does a prompt for an option ([`NO_OR`]): " [". Anything
+    /// else offers options besides what it asks for ("Specify next point or [Undo]"): " or [". With
+    /// no message, "[". The command line in the window draws the keywords itself and takes this
+    /// too.
+    pub fn keyword_lead(&self) -> &'static str {
+        if self.message.is_empty() {
+            "["
+        } else if self.message.ends_with('?') || NO_OR.contains(&self.message.as_str()) {
+            " ["
+        } else {
+            " or ["
+        }
+    }
    /// Match typed text against keywords: full word or the capitalised shortcut, case-insensitive.
    pub fn match_keyword(&self, text: &str) -> Option<String> {
        let t = text.trim();
@@ -338,6 +379,13 @@ mod tests {
        assert_eq!(p.display(), "Specify next point or [Undo/Close]:");
        let q = Prompt::new("Erase polyline?", Accept::TEXT).kw(&["Yes", "No"]).default("No");
        assert_eq!(q.display(), "Erase polyline? [Yes/No] <No>:");
+        // A prompt for an option has no "or", as AutoCAD writes it.
+        let o = Prompt::new("Enter an option", Accept::TEXT).kw(&["Close", "Join"]);
+        assert_eq!(o.display(), "Enter an option [Close/Join]:");
+        let c = Prompt::new("New color", Accept::TEXT).kw(&["Truecolor", "COlorbook"]).default("BYLAYER");
+        assert_eq!(c.display(), "New color [Truecolor/COlorbook] <BYLAYER>:");
+        let b = Prompt::new("Enter block name", Accept::TEXT).kw(&["?"]);
+        assert_eq!(b.display(), "Enter block name or [?]:");
        assert_eq!(p.match_keyword("u").as_deref(), Some("Undo"));
        assert_eq!(p.match_keyword("CL").as_deref(), Some("Close"));
        assert_eq!(p.match_keyword("x"), None);
@@ -32,6 +32,7 @@ fn dim(kind: DimKind, p13: Vec2, p14: Vec2, defpt: Vec2) -> EntityKind {
        overrides: Default::default(),
        assoc: Vec::new(),
        marks: Default::default(),
+        insertion_point: Vec3::ZERO,
    })
 }

@@ -182,6 +183,7 @@ pub fn bracket() -> Drawing {
            overrides: Default::default(),
            assoc: Vec::new(),
            marks: Default::default(),
+            insertion_point: Vec3::ZERO,
        }),
    );
    add(
@@ -203,6 +205,7 @@ pub fn bracket() -> Drawing {
            overrides: Default::default(),
            assoc: Vec::new(),
            marks: Default::default(),
+            insertion_point: Vec3::ZERO,
        }),
    );

@@ -29,7 +29,7 @@ pub fn hit_polylines(d: &Drawing, e: &Entity, tol: f64) -> Vec<Vec<Vec2>> {
                let list = cadcraft_render::build_entities(
                    d,
                    std::iter::once(e),
-                    &cadcraft_render::Options { tolerance: tol, text: false, ..Default::default() },
+                    &cadcraft_render::Options { tolerance: tol, text: false, linetypes: false, ..Default::default() },
                );
                v = list.prims.iter().map(|p| list.points(p).to_vec()).collect();
                v.push(vec![c[0], c[1], c[2], c[3], c[0]]);
@@ -117,11 +117,15 @@ fn in_text(d: &Drawing, e: &Entity, p: Vec2) -> bool {
        // A dimension with a block (as AutoCAD saves them) is drawn from that block: its text is
        // the text there, not the text the dimension's own geometry would place.
        EntityKind::Dimension(dm) => match dm.block.as_ref().and_then(|n| d.block(n)) {
-            Some(blk) => blk.entities.iter().any(|be| match &be.kind {
-                EntityKind::MText(t) => in_box(cadcraft_render::layout_mtext_entity(d, t).strokes.into_iter().flatten(), t.rotation, p),
-                EntityKind::Text(_) => entity_bounds(d, be, 0).contains(p),
-                _ => false,
-            }),
+            // The block draws translated by the insertion point (group 12): test there (#2634).
+            Some(blk) => {
+                let p = p - dm.insertion_point.xy();
+                blk.entities.iter().any(|be| match &be.kind {
+                    EntityKind::MText(t) => in_box(cadcraft_render::layout_mtext_entity(d, t).strokes.into_iter().flatten(), t.rotation, p),
+                    EntityKind::Text(_) => entity_bounds(d, be, 0).contains(p),
+                    _ => false,
+                })
+            }
            None => {
                let g = cadcraft_render::dimension_in(d, dm);
                in_box(g.text.iter().flatten().chain(g.text_glyphs.iter().flatten().flatten()).copied(), g.text_angle, p)
@@ -502,6 +506,56 @@ mod tests {
        // Only one within reach: that one, whatever the order.
        assert_eq!(pick(&d, &Space::Model, Vec2::new(41.3, 50.0), 1.0), Some(line));
    }
+
+    /// A block holding a diagonal dashed line, inserted at `scale`.
+    fn dashed_block(length: f64, scale: f64) -> (Drawing, Handle) {
+        let mut d = Drawing::new_imperial();
+        d.linetypes.extend(cadcraft_doc::library::standard_linetypes().into_iter().filter(|l| l.name == "DASHED"));
+        let mut line =
+            Entity::new(Handle(1), EntityKind::Line(cadcraft_doc::Line { a: Vec3::new(0.0, 0.0, 0.0), b: Vec3::new(length, length, 0.0) }));
+        line.common.linetype = "DASHED".into();
+        let mut blk = cadcraft_doc::Block::new("B");
+        blk.entities.push(line);
+        d.blocks.insert("B".into(), std::sync::Arc::new(blk));
+        let insert = cadcraft_doc::Insert {
+            block: "B".into(),
+            insert: Vec3::new(0.0, 0.0, 0.0),
+            scale: Vec3::new(scale, scale, 1.0),
+            rotation: 0.0,
+            attribs: Vec::new(),
+            cols: 1,
+            rows: 1,
+            col_spacing: 0.0,
+            row_spacing: 0.0,
+        };
+        let h = d.add(&Space::Model, Common::default(), EntityKind::Insert(insert)).unwrap();
+        (d, h)
+    }
+
+    /// Every mouse move over a block hit-tests what it draws. Two blocks with a fine pattern on
+    /// long lines (inserted at 0.001) made 5.8 million dashes, and half a second, per move (#1285).
+    #[test]
+    fn hit_testing_a_block_does_not_lay_out_its_dashes() {
+        let (d, h) = dashed_block(20_000.0, 0.001);
+        let e = d.entity(h).unwrap();
+        let drawn = cadcraft_render::build_entities(&d, std::iter::once(e.as_ref()), &cadcraft_render::Options { text: false, ..Default::default() });
+        assert!(drawn.prims.len() > 10_000, "the pattern draws {} dashes", drawn.prims.len());
+        // The line, and the block's bounding rectangle.
+        assert_eq!(hit_polylines(&d, e, 0.01).len(), 2);
+    }
+
+    /// A dashed line in a block is hit across its gaps, as one outside a block is.
+    #[test]
+    fn a_dashed_line_in_a_block_is_picked_in_a_gap() {
+        let (d, h) = dashed_block(100.0, 1.0);
+        let e = d.entity(h).unwrap();
+        let drawn = cadcraft_render::build_entities(&d, std::iter::once(e.as_ref()), &cadcraft_render::Options { text: false, ..Default::default() });
+        let (a, b) = (drawn.prims.first().unwrap(), drawn.prims.get(1).unwrap());
+        let (end, start) = (*drawn.points(a).last().unwrap(), *drawn.points(b).first().unwrap());
+        assert!(end.dist(start) > 0.01, "a gap between the first two dashes");
+        let gap = end + (start - end) * 0.5;
+        assert_eq!(pick(&d, &Space::Model, gap, end.dist(start) / 8.0), Some(h));
+    }
 }

 #[cfg(test)]
@@ -13,3 +13,5 @@ mod files;
 mod interactive;
 mod picking;
 mod zoom;
+
+pub(crate) use picking::group_10;
@@ -66,17 +66,25 @@ impl Session {
            (r, _) => r,
        };
        let grouped = self.lisp_groups_undo();
+        let mut in_routine = None;
        if spec.undoable
            && let Some((doc, sel, uid)) = before
            && let Some(st) = self.docs.iter_mut().find(|d| d.uid == uid)
            && !Arc::ptr_eq(&doc, &st.doc)
        {
-            // Inside a LISP routine the routine's single undo step records it.
-            if !grouped {
-                st.push_undo(Snapshot { label: spec.label.to_string(), doc, selection: sel });
+            let snap = Snapshot { label: spec.label.to_string(), doc, selection: sel };
+            // Inside a LISP routine the routine's single undo step records it, and the routine
+            // keeps it for U inside it.
+            if grouped {
+                in_routine = Some(snap);
+            } else {
+                st.push_undo(snap);
            }
            st.revision += 1;
        }
+        if let Some(snap) = in_routine {
+            self.lisp_record_step(snap);
+        }
        result
    }

@@ -89,27 +97,32 @@ impl Session {

    // ---------------- undo ----------------

+    /// Take the last step back. Inside a LISP routine, the routine's last command first; past
+    /// those, the drawing's step before the routine, which then starts from there.
    pub fn undo(&mut self) -> Result<Option<String>> {
+        if let Some(label) = self.lisp_take_back(false) {
+            return Ok(Some(label));
+        }
        let st = self.state_mut()?;
        let Some(snap) = st.undo.pop() else { return Ok(None) };
-        let cur = Snapshot { label: snap.label.clone(), doc: st.doc.clone(), selection: st.selection.clone() };
-        st.doc = snap.doc;
-        st.follow_layout(&cur.doc);
-        st.selection = Vec::new();
+        let cur = st.swap_in(snap);
+        let label = cur.label.clone();
        st.redo.push(cur);
-        st.revision += 1;
-        Ok(Some(snap.label))
+        self.lisp_rebase();
+        Ok(Some(label))
    }

+    /// Bring back what the last undo took back; inside a LISP routine, what U inside it took first.
    pub fn redo(&mut self) -> Result<Option<String>> {
+        if let Some(label) = self.lisp_take_back(true) {
+            return Ok(Some(label));
+        }
        let st = self.state_mut()?;
        let Some(snap) = st.redo.pop() else { return Ok(None) };
-        let cur = Snapshot { label: snap.label.clone(), doc: st.doc.clone(), selection: st.selection.clone() };
-        st.doc = snap.doc;
-        st.follow_layout(&cur.doc);
-        st.selection = Vec::new();
+        let cur = st.swap_in(snap);
+        let label = cur.label.clone();
        st.undo.push(cur);
-        st.revision += 1;
-        Ok(Some(snap.label))
+        self.lisp_rebase();
+        Ok(Some(label))
    }
 }
@@ -379,12 +379,16 @@ impl Session {
        }
        self.after_command(Some(&run.before), None, true);
        // A transparent command's changes belong to the command it ran inside, and a command a
-        // LISP routine ran belongs to the routine's single undo step.
+        // LISP routine ran belongs to the routine's single undo step (the routine keeps it for U
+        // inside it).
        if self.suspended.is_some() || self.lisp_groups_undo() {
            if let Ok(st) = self.state_mut()
                && !Arc::ptr_eq(&run.before, &st.doc)
            {
                st.revision += 1;
+                if self.suspended.is_none() {
+                    self.lisp_record_step(Snapshot { label: label.to_string(), doc: run.before, selection: run.selection_before });
+                }
            }
            return;
        }
@@ -162,7 +162,7 @@ impl Session {

 /// An object's DXF group 10 point: the first point of its entity list, or its first grip where
 /// entity lists are not built in.
-fn group_10(d: &Drawing, e: &Entity) -> Option<Vec2> {
+pub(crate) fn group_10(d: &Drawing, e: &Entity) -> Option<Vec2> {
    let Some(codec) = cmd::file::entity_codec() else { return e.kind.grips().first().copied() };
    let (_, tags) = (codec.groups)(d, e);
    let i = tags.iter().position(|t| t.code == 10)?;
@@ -127,6 +127,9 @@ pub struct Settings {
    pub polardist: f64,
    /// AUDITCTL: 1 creates an audit report (.adt) file when AUDIT is run (default: 0).
    pub auditctl: bool,
+    /// ATTREQ: 0 inserts blocks with their attributes' default values instead of asking for them
+    /// (default: 1).
+    pub attreq: bool,
 }

 impl Default for Settings {
@@ -191,6 +194,7 @@ impl Default for Settings {
            polarsnap: false,
            polardist: 0.0,
            auditctl: false,
+            attreq: true,
        }
    }
 }
@@ -15,7 +15,7 @@
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex};

-use cadcraft_doc::{Block, DimStyle, Drawing, Entity, EntityKind, EntityStore, Space, entity_bounds};
+use cadcraft_doc::{Block, BlockBoundsCache, DimStyle, Drawing, Entity, EntityKind, EntityStore, Space, entity_bounds_cached};
 use cadcraft_geom::Bounds2;
 use rstar::primitives::{GeomWithData, Rectangle};
 use rstar::{AABB, RTree};
@@ -44,6 +44,8 @@ struct ChunkIx {
 impl ChunkIx {
    fn build(d: &Drawing, key: usize, items: &[Arc<Entity>]) -> ChunkIx {
        let mut infinite = Vec::new();
+        // One block-bounds cache for the chunk: references to the same block measure it once.
+        let mut cache = BlockBoundsCache::default();
        let bounds = items
            .iter()
            .enumerate()
@@ -51,7 +53,7 @@ impl ChunkIx {
                if matches!(e.kind, EntityKind::XLine(_) | EntityKind::Ray(_)) {
                    infinite.push(u32::try_from(i).unwrap_or(u32::MAX));
                }
-                entity_bounds(d, e, 0)
+                entity_bounds_cached(d, e, 0, &mut cache)
            })
            .collect();
        let serial = NEXT_SERIAL.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
@@ -94,6 +96,28 @@ fn hidden_layers(d: &Drawing) -> impl Iterator<Item = &str> {
    d.layers.iter().filter(|l| !l.visible()).map(|l| l.name.as_str())
 }

+/// A copy of `tree` with `removed` taken out and `inserted` added, or `None` when the caller must
+/// bulk-load instead. rstar 0.13 can panic ("This is a bug in rstar.") when inserting after removals
+/// in a bulk-loaded tree (#2468), and picking is outside the command guard, so that panic would end
+/// the app. The web build can't catch a panic, so it always bulk-loads.
+fn patch_tree(tree: &RTree<Item>, removed: impl Iterator<Item = Item>, inserted: impl Iterator<Item = Item>) -> Option<RTree<Item>> {
+    if cfg!(target_arch = "wasm32") {
+        return None;
+    }
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        let mut tree = tree.clone();
+        for it in removed {
+            tree.remove(&it);
+        }
+        for it in inserted {
+            tree.insert(it);
+        }
+        tree
+    }))
+    .map_err(|_| log::warn!("spatial index: rstar failed to patch the tree; rebuilding it"))
+    .ok()
+}
+
 impl SpatialIndex {
    /// Build an index over a store (no caching).
    pub fn build(d: &Drawing, store: &EntityStore) -> SpatialIndex {
@@ -127,23 +151,11 @@ impl SpatialIndex {
            offset = offset.saturating_add(n);
        }
        // Patch the previous tree when most of it survives; otherwise bulk-load.
-        let tree = match prev {
-            Some(p) if kept.len() * 2 >= chunks.len().max(1) => {
-                let mut tree = p.tree.clone();
-                for (_, c) in p.chunks.iter().filter(|(_, c)| !kept.contains(&c.serial)) {
-                    for it in c.items() {
-                        tree.remove(&it);
-                    }
-                }
-                for c in &fresh {
-                    for it in c.items() {
-                        tree.insert(it);
-                    }
-                }
-                tree
-            }
-            _ => RTree::bulk_load(chunks.iter().flat_map(|(_, c)| c.items()).collect()),
-        };
+        let patched = prev.filter(|_| kept.len() * 2 >= chunks.len().max(1)).and_then(|p| {
+            let removed = p.chunks.iter().filter(|(_, c)| !kept.contains(&c.serial)).flat_map(|(_, c)| c.items());
+            patch_tree(&p.tree, removed, fresh.iter().flat_map(|c| c.items()))
+        });
+        let tree = patched.unwrap_or_else(|| RTree::bulk_load(chunks.iter().flat_map(|(_, c)| c.items()).collect()));
        let offsets = chunks.iter().map(|(off, c)| (c.serial, *off)).collect();
        let infinite = chunks.iter().flat_map(|(off, c)| c.infinite.iter().map(move |i| off + i)).collect();
        SpatialIndex {
@@ -190,7 +202,7 @@ impl SpatialIndex {
        let (c, l) = self.locate(i)?;
        c.ents.get(l)
    }
-    /// The bounds of the entity at draw index `i` (as [`entity_bounds`] computes them).
+    /// The bounds of the entity at draw index `i` (as [`cadcraft_doc::entity_bounds`] computes them).
    pub fn bounds(&self, i: u32) -> Bounds2 {
        self.locate(i).and_then(|(c, l)| c.bounds.get(l).copied()).unwrap_or(Bounds2::EMPTY)
    }
@@ -367,6 +379,40 @@ mod tests {
        Some(Arc::new(SpatialIndex::build(d, &d.model)))
    }

+    /// The edits of #2468, on rstar alone: its insert panics for seed 8. A failed patch falls back
+    /// to a bulk load, and every tree holds exactly the live items.
+    #[test]
+    fn rstar_patch_failures_fall_back_to_a_rebuild() {
+        fn item(r: &mut Rng, s: u32, i: u32) -> Item {
+            let (x, y, w, h) = (r.f() * 1000.0, r.f() * 1000.0, r.f() * 50.0, r.f() * 50.0);
+            GeomWithData::new(Rectangle::from_corners([x, y], [x + w, y + h]), (s, i))
+        }
+        for seed in 1..=10u64 {
+            let mut r = Rng(seed * 7919);
+            let n_chunks = 4 + (r.f() * 20.0) as u32;
+            let mut chunks: Vec<Vec<Item>> = (0..n_chunks)
+                .map(|s| {
+                    let n = 1 + (r.f() * 60.0) as u32;
+                    (0..n).map(|i| item(&mut r, s, i)).collect()
+                })
+                .collect();
+            let mut tree = RTree::bulk_load(chunks.iter().flatten().cloned().collect());
+            for serial in (n_chunks..).take(300) {
+                let c = (r.f() * chunks.len() as f64) as usize;
+                let n = (chunks[c].len() as i64 + if r.f() < 0.5 { -1 } else { 1 }).max(0) as u32;
+                let fresh: Vec<Item> = (0..n).map(|i| item(&mut r, serial, i)).collect();
+                let patched = patch_tree(&tree, chunks[c].iter().cloned(), fresh.iter().cloned());
+                chunks[c] = fresh;
+                tree = patched.unwrap_or_else(|| RTree::bulk_load(chunks.iter().flatten().cloned().collect()));
+                let mut held: Vec<(u32, u32)> = tree.iter().map(|it| it.data).collect();
+                let mut live: Vec<(u32, u32)> = chunks.iter().flatten().map(|it| it.data).collect();
+                held.sort_unstable();
+                live.sort_unstable();
+                assert_eq!(held, live, "seed {seed}, serial {serial}");
+            }
+        }
+    }
+
    #[test]
    fn pick_parity_with_scan() {
        for seed in [3, 11, 97] {
--- a/Show More
+++ b/Show More