Release 0.17.1

Run the signed release from the release environment
2026-11-15 10:23:43 -06:00 · 2026-11-04 19:50:38 -05:00 · 2026-11-04 19:48:04 -05:00 · 2026-11-04 19:35:54 -05:00 · 2026-11-04 18:50:12 -05:00
337 changed files with 5583 additions and 20855 deletions
@@ -1,28 +0,0 @@
-name: House rules
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - AGENTS.md
-      - CLAUDE.md
-      - .github/workflows/house-rules.yml
-  pull_request:
-    paths:
-      - AGENTS.md
-      - CLAUDE.md
-      - .github/workflows/house-rules.yml
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: house-rules-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  house-rules:
-    uses: storytold/craft-common-actions/.github/workflows/house-rules.yml@main
-    with:
-      rust: true
@@ -23,5 +23,39 @@ jobs:
    uses: storytold/craft-common-actions/.github/workflows/nix.yml@main

  git-sources:
-    # Tracks @main so suite-wide CI fixes reach every app without a PR in each repository.
-    uses: storytold/craft-common-actions/.github/workflows/git-sources.yml@main
+    name: Git dependencies come from storytold
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Git dependencies come from storytold
+        run: |
+          set -euo pipefail
+          test -f Cargo.lock || { echo "Cargo.lock is missing"; exit 1; }
+          # Source replacement, patches and path overrides in cargo config never show up
+          # in Cargo.lock. Parsed rather than grepped: TOML has many spellings of one key.
+          # Cargo still reads the legacy .cargo/config.
+          python3 - <<'PY'
+          import os, sys, tomllib
+          for path in (".cargo/config", ".cargo/config.toml"):
+              if not os.path.exists(path):
+                  continue
+              config = tomllib.load(open(path, "rb"))
+              replaced = [name for name, source in config.get("source", {}).items()
+                          if isinstance(source, dict) and "replace-with" in source]
+              if replaced or "patch" in config or "paths" in config:
+                  print(f"{path} replaces, patches or overrides a source")
+                  sys.exit(1)
+          PY
+          # Fails when Cargo.lock is out of date with the manifests.
+          cargo metadata --locked --format-version 1 > /dev/null
+          python3 - <<'PY'
+          import sys, tomllib
+          lock = tomllib.load(open("Cargo.lock", "rb"))
+          bad = sorted({p["source"] for p in lock.get("package", [])
+                        if p.get("source", "").startswith("git+")
+                        and not p["source"].startswith("git+https://github.com/storytold/")})
+          if bad:
+              print("Git dependencies outside github.com/storytold:", *bad, sep="\n")
+              sys.exit(1)
+          PY
@@ -27,10 +27,6 @@ jobs:
    name: Windows installation policy (no app build)
    runs-on: windows-latest
    steps:
-      - name: Harden runner
-        uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
-        with:
-          egress-policy: audit
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
@@ -1,10 +1,6 @@
 name: Release

 on:
-  # A nightly dry run on main: every release build except macOS, nothing signed or released
-  # (craft-common-actions release.yml `dry-run`). Finds release-only breakage before release day.
-  schedule:
-    - cron: "8 1 * * *"
  push:
    branches: [release]
  workflow_dispatch:
@@ -22,15 +18,47 @@ concurrency:
  cancel-in-progress: false

 jobs:
-  # Regenerates contributors/contributors.json for the release commit; every build bundles it.
-  credits:
+  git-sources:
+    name: Git dependencies come from storytold
+    runs-on: ubuntu-latest
    permissions:
      contents: read
-      pull-requests: read
-    uses: storytold/craft-common-actions/.github/workflows/refresh-contributors.yml@main
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Git dependencies come from storytold
+        run: |
+          set -euo pipefail
+          test -f Cargo.lock || { echo "Cargo.lock is missing"; exit 1; }
+          # Source replacement, patches and path overrides in cargo config never show up
+          # in Cargo.lock. Parsed rather than grepped: TOML has many spellings of one key.
+          # Cargo still reads the legacy .cargo/config.
+          python3 - <<'PY'
+          import os, sys, tomllib
+          for path in (".cargo/config", ".cargo/config.toml"):
+              if not os.path.exists(path):
+                  continue
+              config = tomllib.load(open(path, "rb"))
+              replaced = [name for name, source in config.get("source", {}).items()
+                          if isinstance(source, dict) and "replace-with" in source]
+              if replaced or "patch" in config or "paths" in config:
+                  print(f"{path} replaces, patches or overrides a source")
+                  sys.exit(1)
+          PY
+          # Fails when Cargo.lock is out of date with the manifests.
+          cargo metadata --locked --format-version 1 > /dev/null
+          python3 - <<'PY'
+          import sys, tomllib
+          lock = tomllib.load(open("Cargo.lock", "rb"))
+          bad = sorted({p["source"] for p in lock.get("package", [])
+                        if p.get("source", "").startswith("git+")
+                        and not p["source"].startswith("git+https://github.com/storytold/")})
+          if bad:
+              print("Git dependencies outside github.com/storytold:", *bad, sep="\n")
+              sys.exit(1)
+          PY

  release:
-    needs: credits
+    needs: git-sources
    permissions:
      # The reusable release workflow tags and uploads the draft release.
      contents: write
@@ -38,12 +66,10 @@ jobs:
    # 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:
-      dry-run: ${{ github.event_name == 'schedule' }}
      app-name: cadcraft
      app-title: CADCraft
      craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
      version: ${{ inputs.version }}
-      contributors-artifact: ${{ needs.credits.outputs.artifact-name }}
    secrets:
      APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
      APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
@@ -1,62 +1,13 @@
-<!-- craft-house-rules:start core source=dde09ea31e2e457f5b4653a6e76f7cdf55944bdf sha256=540e6cea75d12d0710c3dca89658328e81e508ecef102446ca5bb95b7c0b92bb -->
-## House rules
-
-These apply in every Craft repository. A later rule may be stricter, not weaker. The source is `standards/house-rules-core.md` in `storytold/craft-contrib`. Propose changes there, not in a copy.
-
-1. **A person is accountable.** Whoever runs an agent answers for what it opens and for its review comments.
-2. **Check, then claim.** Before writing code, read the issue comments, search pull requests for `#N` and the keywords, and check recent commits on `main`. Comment on the issue first. Release a claim you will not finish.
-3. **Verify, don't guess.** Open a definition before using it. Confirm the cause in the code, even when someone names a location.
-4. **Keep fixes narrow and tested.** Fix what the issue describes, where the bug is. Add a test that fails without the fix.
-5. **Review the diff before opening a pull request.** Identifiers exist as used, the test fails without the fix, nothing unrelated changed, and the description is true.
-6. **Look for a better pull request.** If another fixes the same thing, close yours when it is better or equal, and say why.
-7. **Report only what ran.** Say what you tested and what you could not run. Without a local build or test, say so and rely on CI before marking ready.
-8. **`main` changes through a pull request.** Do not push to it. Branch protection enforces this. There is no exception.
-9. **Stop and ask only about** licensing outside the allowlist, publishing, releases, a new remote, secrets, spending money, destructive git, and anything else hard to undo. Otherwise keep working. `plan/` is a gitignored notebook, not rules. Without it, do not ask for it and do not stop.
-10. **Keep secrets and personal details out** of the repository, logs and requests.
-11. **CI stays shared.** Workflows call `storytold/craft-common-actions`. Do not change CI in a feature or fix pull request. If CI cannot cover a change, open an issue there.
-12. **Guards say why.** A check that looks removable says what it prevents. Read that before changing it.
-13. **Instructions must be readable by everyone.** No notes about one machine, and no links to files a reader cannot open. `craftrules` is retired. Do not link to it.
-14. **Keep pull requests moving.** Concurrent pull requests are fine; unanswered actionable feedback is not. Respond in 7 days, a reminder at 14, closure eligible at 30, from when an actionable request waits on the author. Suggestions and unconfirmed bot findings do not start the clock. A fix, explanation or agreed plan resets it; unrelated activity does not. Waiting on a reviewer or maintainer pauses it and does not count against the author. A maintainer decides closure; it is never automatic. Reuse search results, do not poll, and stop at a rate limit.
-15. **No agent attribution.** A pull request does not say an agent wrote it. A repository rule may not require that.
-<!-- craft-house-rules:end -->
-<!-- craft-house-rules:start rust source=dde09ea31e2e457f5b4653a6e76f7cdf55944bdf sha256=387e0ccb4b49e567f60951d7d6fff7305054c89f43ad812b9993dc7c38528013 -->
-## Rust Craft repositories
-
-These apply to native Craft apps and to shared Rust libraries. Select them by repository type. A repository that merely contains some Rust does not take this block. Rules later in a repository's file may be stricter, but not weaker. The source is `standards/house-rules-rust.md` in [storytold/craft-contrib](https://github.com/storytold/craft-contrib).
-
-1. **Never crash.** Non-test code does not panic and has no `unsafe`, except where the repository file names an exception. Return errors, treat input as hostile, and bound recursion and allocations. New production crate roots copy the `deny` attribute from an existing crate: `clippy::unwrap_used`, `clippy::expect_used`, `clippy::panic`, `clippy::unimplemented`, `clippy::todo`, `clippy::unreachable`. Every crash fix comes with a test that panicked before the fix.
-2. **Clean room.** Learn from observed behaviour and public specifications. Do not copy another product's code, assets, strings or artwork. Check a dependency's licence before adding it.
-3. **Assets and fonts.** Every asset is original or suitably licensed, and is recorded in `ATTRIBUTION.md` in the same change. Font files live in [storytold/craft-fonts](https://github.com/storytold/craft-fonts), not in the app repository.
-4. **Rust only for native Craft apps.** No handwritten JavaScript or TypeScript, and no Tauri, Electron or webview shell, in those apps. Shared tooling follows its documented technical scope and maintainer-approved exceptions. Craft PR Review's existing Tauri and TypeScript UI is one such exception. It does not relax this rule for native apps. Preserve any existing web build.
-5. **Time goes through `chrono`.** Do not hand-roll calendar conversion. For dates beyond what `chrono` can represent, follow [standards/time.md](https://github.com/storytold/craft-contrib/blob/main/standards/time.md).
-6. **Contributor credits.** Add or edit only your own person's entry in `contributors/people.toml`, and only after asking them. Never guess a name or hand-edit `contributors.json`.
-
-## Licence allowlist
-
-Dependencies and assets use SPDX identifiers. An expression is allowed when every identifier is in this list. A repository may name a shorter list. It may not add an identifier here by editing its own copy of these rules.
-
- `ISC`
- `MIT`
- `BSD-2-Clause`
- `BSD-3-Clause`
- `Apache-2.0`
- `OFL-1.1`
- `Ubuntu-font-1.0`
- `Bitstream-Vera`
- `CC0-1.0`
- `CC-BY-4.0`
- `CC-BY-SA-4.0`
- `LicenseRef-Public-Domain`
-
-`LicenseRef-Storyteller-Trademark` is not in this list. It covers Storyteller brand marks only, where a repository already says so.
-<!-- craft-house-rules:end -->
-
 # CADCraft — instructions for agents

 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).

 ## Start every session here
-Read [`ROADMAP.md`](ROADMAP.md) and [`docs/gaps.md`](docs/gaps.md). `plan/` is an optional gitignored notebook (status, execution notes, `plan/autocad/*`). Do not ask for it and do not stop when it is absent. Licence choices stay inside the house-rules allowlist.
+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).
+3. Follow the autonomous operation protocol (`plan/execution-plan.md` §6). Don't stop to ask unless it lists the decision as the owner's.
+
+`plan/` is gitignored (local only).

 ## Never crash
 People trust CADCraft with their drawings; a crash loses their work. **This outranks feature work.**
@@ -77,8 +28,9 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr
 - **Programmatic calls never open dialogs.** `engine.execute` runs the JSON form with defaults; only menu/toolbar invocation starts the interactive prompt sequence.
 - **Layering** is enforced by `cargo xtask layers`: L0 `geom`, `dxf` → L1 `color`, `doc` → L2 `fonts`, `render`, `constraints` → L3 `io` → L4 `engine` → L5 `ui-egui`, `mcp` → apps. Nothing below L5 depends on egui/eframe/winit/wgpu/rfd. **The UI crate is swappable.**
 - **The UI is thin**: panels read engine state and act through `app.run(id, params)` / `app.start(id)` / `app.cmdline(text)`. Colours come from `theme::Tokens`.
+- **Time goes through `chrono`** (workspace dependency). Never hand-roll UTC/calendar conversion (days-to-date algorithms, leap-year math); a crate owns only its output format string. The one exception is range extension: past the years chrono can represent, shift the date by whole 400-year Gregorian cycles (146,097 days, after which the calendar repeats), let chrono compute the month and day, and add the cycles back to the year (splitting seconds into hours, minutes and seconds is plain arithmetic).
 - **Rust only** (no handwritten JS/TS). **Never break wasm** (`cargo xtask wasm`).
- **Quality gates** before every commit: `cargo xtask ci` (fmt, clippy -D warnings, tests, assets, layers, wasm). Commit after every feature arc that builds.
+- **Quality gates** before every commit: `cargo xtask ci` (fmt, clippy -D warnings, tests, assets, layers, wasm). Commit after every feature arc that builds, and push to `main`.

 ## Running and looking at the app
 - `cargo run --release -p cadcraft -- --sample --control PORT` (sample drawing + control channel). Pick a free port; other crafting apps use control ports too.
@@ -62,7 +62,6 @@ Generated-in-code assets are original and have no file to list:
 | Asset | Author | Source | Licence | Notes |
 |---|---|---|---|---|
 | `crates/ui-egui/src/i18n/uk.tsv` | @dmatviichuk | Original Ukrainian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
-| `crates/ui-egui/src/i18n/pl.tsv` | @neronek22 (Echo Rozumu & Gadajło; AI-assisted) | Original Polish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/de.tsv` | the CADCraft contributors | Original German translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/es.tsv` | @PedroGuille | Original Spanish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
 | `crates/ui-egui/src/i18n/pt_br.tsv` | @WladmirJunior | Original Brazilian Portuguese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
@@ -77,6 +76,5 @@ Generated-in-code assets are original and have no file to list:
 | `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); 46 later rows: @V1dalTheAbidal with Claude Code (AI-assisted) | Original Greek translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; the 46 later rows were read by their contributor, a native Greek speaker; independent native proofreading of the whole file pending |
+| `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 |
-| `crates/ui-egui/src/i18n/ka.tsv` | Davit Matchakhelidze (@devius), native speaker, with Claude Code | Original Georgian 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; terminology and doubtful strings decided by a native Georgian speaker; no font assets added (the Georgian face comes from craft-fonts) |
@@ -1 +1,52 @@
-@AGENTS.md
+# CADCraft — instructions for agents
+
+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).
+
+## 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).
+3. Follow the autonomous operation protocol (`plan/execution-plan.md` §6). Don't stop to ask unless it lists the decision as the owner's.
+
+`plan/` is gitignored (local only).
+
+## Never crash
+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.
+- **Bound recursion** (nested/cyclic block references: `MAX_BLOCK_DEPTH`).
+- **Last-resort guard:** `Session::execute` and every step of an interactive command (its factory, `begin`, input, `prompt`, `preview` and the passes after it; `crates/engine/src/guard.rs`) run under `catch_unwind`; an escaped panic restores the drawing and reports an error. It does nothing on wasm, where a panic aborts.
+- **Prove it:** every crash fix lands with a regression test (see `crates/engine/tests/panic_hunt.rs` and `hostile_dxf_does_not_panic` in `crates/io/src/tests.rs`).
+- Every workspace crate manifest carries `[lints] workspace = true` to inherit `[workspace.lints]`; every production crate root carries `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`.
+
+## Non-negotiables
+- **Clean-room.** AutoCAD is installed on the dev machine and may be *observed* black-box: run it, use its UI with synthetic drawings, take screenshots (by window id) stored only under `plan/autocad/screenshots/` (never committed). **Never** read, disassemble or copy anything inside the AutoCAD bundle (names/listings only); never copy Autodesk fonts (SHX), hatch patterns (`.pat`), linetypes (`.lin`), templates, CUI/PGP files, icons, artwork or help text; never commit files produced by AutoCAD. File formats come from public specifications (Autodesk's published DXF Reference, the Open Design Alliance's public DWG specification) and our own synthetic tests. Never copy or link GPL/LGPL/AGPL code (LibreDWG, LibreCAD, QCAD, FreeCAD's planegcs, SolveSpace, OpenCASCADE) — don't even read their sources.
+- **Assets — absolutely essential.** CADCraft contains **no Autodesk, Adobe or Avid iconography, images, fonts, patterns or artwork — ever.** Every icon is drawn in code (`crates/ui-egui/src/icons.rs`), every hatch pattern and linetype is our own definition (`crates/doc/src/library.rs`), the drafting font is our own (`crates/fonts/src/stroke.rs`). Any file asset must be original, public domain/CC0, OSI-licensed, or redistributable Creative Commons (or licensed open source by a contributor who made it), and **must have a row in `ATTRIBUTION.md`** with author, source and licence (`cargo xtask assets` enforces it). The only exception is the ArtCraft brand in `docs/brand/` (trademarks, `docs/brand/LICENSE-brand.txt`). Screenshots of Autodesk software are never committed. Breaking this rule is the most serious mistake you can make in this repo.
+- **Fonts live in [`storytold/craft-fonts`](https://github.com/storytold/craft-fonts)**, never in this repo. It is an optional build input (`CRAFT_FONTS_DIR`, embedded by `crates/fonts/build.rs`), never a `Cargo.toml` dependency. Code and tests must work without it.
+- **Shared test corpora** live in separate repos (`storytold/<app>-corpus`); never commit large binary fixtures here.
+- **Everything is a command.** User-visible behaviour = a command in `crates/engine/src/cmd/*` (`CommandSpec`: id = AutoCAD's command name in lower case, label, menu path, shortcut, aliases, params doc, `enabled`, JSON `run`, optional `interactive` prompt machine) + tests. UI-only commands live in `crates/ui-egui/src/menus.rs` (`UI_COMMANDS`). The command line, menus, toolbar, Tool Sets, scripts, CLI, control channel and MCP all reach the same commands.
+- **Programmatic calls never open dialogs.** `engine.execute` runs the JSON form with defaults; only menu/toolbar invocation starts the interactive prompt sequence.
+- **Layering** is enforced by `cargo xtask layers`: L0 `geom`, `dxf` → L1 `color`, `doc` → L2 `fonts`, `render`, `constraints` → L3 `io` → L4 `engine` → L5 `ui-egui`, `mcp` → apps. Nothing below L5 depends on egui/eframe/winit/wgpu/rfd. **The UI crate is swappable.**
+- **The UI is thin**: panels read engine state and act through `app.run(id, params)` / `app.start(id)` / `app.cmdline(text)`. Colours come from `theme::Tokens`.
+- **Rust only** (no handwritten JS/TS). **Never break wasm** (`cargo xtask wasm`).
+- **Quality gates** before every commit: `cargo xtask ci` (fmt, clippy -D warnings, tests, assets, layers, wasm). Commit after every feature arc that builds, and push to `main`.
+
+## Running and looking at the app
+- `cargo run --release -p cadcraft -- --sample --control PORT` (sample drawing + control channel). Pick a free port; other crafting apps use control ports too.
+- Drive it with JSON lines on `127.0.0.1:PORT`:
+  - `{"id":1,"method":"cmdline.input","params":{"text":"circle 0,0 5"}}` — type at the command line exactly like a user (prompts, keywords, `@dx,dy`, `@d<a`, direct distance entry).
+  - `{"id":2,"method":"engine.execute","params":{"command":"line","params":{"points":[[0,0],[10,0]]}}}` — JSON form.
+  - `{"id":3,"method":"ui.screenshot","params":{"path":"/tmp/shot.png"}}` then read the PNG.
+  - Methods: `crates/ui-egui/src/control.rs`; protocol doc: `docs/control-protocol.md`.
+- **For UI work, look at the result** (screenshot, read the PNG) and compare with `plan/autocad/screenshots/`. If no frame is presented (screen locked) use `ui.render` or `cadcraft-cli`.
+- Headless: `cadcraft-cli run --sample --script 'LINE 0,0 10,10\n' --export out.png`; `cadcraft-cli info file.dxf`; `cadcraft-cli mcp`.
+- Shell gotcha: `mv`/`cp` may be aliased interactive — use `/bin/mv -f` / `/bin/cp -f`.
+- 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. 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.
+- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
+- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
@@ -614,7 +614,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"

 [[package]]
 name = "cadcraft"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
@@ -631,7 +631,6 @@ dependencies = [
 "log",
 "muda",
 "objc2-app-kit 0.3.2",
- "pollster 1.0.1",
 "rfd",
 "ron",
 "serde_json",
@@ -645,7 +644,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-cli"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
@@ -661,14 +660,14 @@ dependencies = [

 [[package]]
 name = "cadcraft-color"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "serde",
 ]

 [[package]]
 name = "cadcraft-constraints"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-doc",
 "cadcraft-geom",
@@ -678,7 +677,7 @@ dependencies = [

 [[package]]
 name = "cadcraft-doc"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-color",
 "cadcraft-geom",
@@ -687,19 +686,36 @@ dependencies = [
 "thiserror 2.0.21",
 ]

+[[package]]
+name = "cadcraft-dwg"
+version = "0.17.1"
+dependencies = [
+ "acadrust",
+ "log",
+]
+
+[[package]]
+name = "cadcraft-dxf"
+version = "0.17.1"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "cadcraft-engine"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-color",
 "cadcraft-constraints",
 "cadcraft-doc",
+ "cadcraft-dxf",
 "cadcraft-fonts",
 "cadcraft-geom",
 "cadcraft-io",
 "cadcraft-render",
 "craft-docpath",
- "craft-dxf",
 "libc",
 "log",
 "rstar",
@@ -710,10 +726,9 @@ dependencies = [

 [[package]]
 name = "cadcraft-fonts"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-geom",
- "craft-dxf",
 "encoding_rs",
 "harfrust 0.14.0",
 "icu_segmenter",
@@ -723,23 +738,23 @@ dependencies = [

 [[package]]
 name = "cadcraft-geom"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "serde",
 ]

 [[package]]
 name = "cadcraft-io"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "acadrust",
 "cadcraft-color",
 "cadcraft-doc",
+ "cadcraft-dwg",
+ "cadcraft-dxf",
 "cadcraft-fonts",
 "cadcraft-geom",
 "cadcraft-render",
- "craft-dwg",
- "craft-dxf",
 "craft-pdf",
 "image",
 "miniz_oxide 0.9.1",
@@ -752,24 +767,20 @@ dependencies = [

 [[package]]
 name = "cadcraft-mcp"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-io",
 "cadcraft-render",
 "clap",
- "craft-jsonrpc",
- "craft-mcp",
 "getrandom 0.4.3",
- "libc",
 "log",
 "serde_json",
- "tiny-skia",
 ]

 [[package]]
 name = "cadcraft-render"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-color",
 "cadcraft-doc",
@@ -783,14 +794,13 @@ dependencies = [

 [[package]]
 name = "cadcraft-ui-egui"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-color",
 "cadcraft-doc",
 "cadcraft-engine",
 "cadcraft-fonts",
 "cadcraft-geom",
- "cadcraft-io",
 "cadcraft-render",
 "chrono",
 "craft-ui",
@@ -798,7 +808,6 @@ dependencies = [
 "craft-window",
 "egui",
 "egui-wgpu",
- "egui_extras",
 "egui_kittest",
 "image",
 "log",
@@ -811,17 +820,14 @@ dependencies = [

 [[package]]
 name = "cadcraft-web"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "cadcraft-engine",
 "cadcraft-fonts",
 "cadcraft-io",
 "cadcraft-ui-egui",
- "craft-web-api",
- "craft-web-host",
 "eframe",
 "egui",
- "js-sys",
 "log",
 "serde_json",
 "wasm-bindgen",
@@ -1138,25 +1144,6 @@ name = "craft-docpath"
 version = "0.1.0"
 source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"

-[[package]]
-name = "craft-dwg"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf#7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf"
-dependencies = [
- "acadrust",
- "log",
-]
-
-[[package]]
-name = "craft-dxf"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=006e4df225fca57e95ead0fb1f91920900798a99#006e4df225fca57e95ead0fb1f91920900798a99"
-dependencies = [
- "encoding_rs",
- "log",
- "thiserror 2.0.21",
-]
-
 [[package]]
 name = "craft-fonts-build"
 version = "0.1.0"
@@ -1185,23 +1172,6 @@ dependencies = [
 "writeable",
 ]

-[[package]]
-name = "craft-jsonrpc"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=2c9903ca1d892b5446acf3598d8b142f3e64842f#2c9903ca1d892b5446acf3598d8b142f3e64842f"
-dependencies = [
- "serde_json",
-]
-
-[[package]]
-name = "craft-mcp"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=2c9903ca1d892b5446acf3598d8b142f3e64842f#2c9903ca1d892b5446acf3598d8b142f3e64842f"
-dependencies = [
- "craft-jsonrpc",
- "serde_json",
-]
-
 [[package]]
 name = "craft-pdf"
 version = "0.1.0"
@@ -1236,7 +1206,7 @@ dependencies = [
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
 "chrono",
 "dunce",
@@ -1246,7 +1216,6 @@ dependencies = [
 "image",
 "log",
 "plist",
- "rustix 1.1.5",
 "semver",
 "serde",
 "serde_json",
@@ -1260,26 +1229,6 @@ dependencies = [
 "zip",
 ]

-[[package]]
-name = "craft-web-api"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
-dependencies = [
- "js-sys",
- "serde_json",
- "wasm-bindgen",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "craft-web-host"
-version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "craft-window"
 version = "0.1.0"
@@ -1564,19 +1513,6 @@ dependencies = [
 "winit",
 ]

-[[package]]
-name = "egui_extras"
-version = "0.37.0"
-source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
-dependencies = [
- "ahash",
- "egui",
- "enum-map",
- "itertools",
- "log",
- "profiling",
-]
-
 [[package]]
 name = "egui_glow"
 version = "0.37.0"
@@ -1645,26 +1581,6 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"

-[[package]]
-name = "enum-map"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4532960034c15ba2f55e9eee631040ecc473c32e6c4b200828c759840f13a06"
-dependencies = [
- "enum-map-derive",
-]
-
-[[package]]
-name = "enum-map-derive"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7127272f64b3e098f7d81f350d672081b879bff896d219c42370dc858b1af9ff"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 3.0.9",
-]
-
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -6016,7 +5932,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"

 [[package]]
 name = "xtask"
-version = "0.21.0"
+version = "0.17.1"
 dependencies = [
 "chrono",
 "serde_json",
@@ -6249,6 +6165,7 @@ dependencies = [
 "nix 0.31.3",
 "typed-path",
 "windows-sys 0.61.2",
+ "zopfli",
 ]

 [[package]]
@@ -6263,6 +6180,18 @@ version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

+[[package]]
+name = "zopfli"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11"
+dependencies = [
+ "bumpalo",
+ "crc32fast",
+ "log",
+ "simd-adler32",
+]
+
 [[package]]
 name = "zune-core"
 version = "0.5.3"
@@ -6318,3 +6247,23 @@ dependencies = [
 "syn 3.0.9",
 "winnow",
 ]
+
+[[patch.unused]]
+name = "egui_demo_lib"
+version = "0.37.0"
+source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
+
+[[patch.unused]]
+name = "egui_extras"
+version = "0.37.0"
+source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
+
+[[patch.unused]]
+name = "egui_inspection"
+version = "0.37.0"
+source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
+
+[[patch.unused]]
+name = "egui_system_font_provider"
+version = "0.37.0"
+source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a"
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 # default-members

 [workspace.package]
-version = "0.21.0"
+version = "0.17.1"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -13,9 +13,8 @@ repository = "https://github.com/storytold/cadcraft"
 [workspace.dependencies]
 # internal
 cadcraft-geom = { path = "crates/geom" }
-# DXF tags: the shared reader and writer (moved from crates/dxf; craft-libs#791).
-craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "006e4df225fca57e95ead0fb1f91920900798a99" }
-craft-dwg = { git = "https://github.com/storytold/craft-libs", rev = "7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf" }
+cadcraft-dxf = { path = "crates/dxf" }
+cadcraft-dwg = { path = "crates/dwg" }
 cadcraft-color = { path = "crates/color" }
 cadcraft-doc = { path = "crates/doc" }
 cadcraft-constraints = { path = "crates/constraints" }
@@ -25,8 +24,6 @@ cadcraft-io = { path = "crates/io" }
 cadcraft-engine = { path = "crates/engine" }
 cadcraft-ui-egui = { path = "crates/ui-egui" }
 cadcraft-mcp = { path = "crates/mcp" }
-craft-mcp = { git = "https://github.com/storytold/craft-libs", rev = "2c9903ca1d892b5446acf3598d8b142f3e64842f" }
-craft-jsonrpc = { git = "https://github.com/storytold/craft-libs", rev = "2c9903ca1d892b5446acf3598d8b142f3e64842f" }
 # Which paths stored in a drawing (xrefs, data links) may be opened.
 craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
 # PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
@@ -66,15 +63,13 @@ quick-xml = "0.42"
 craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", features = ["serde"] }
 craft-window = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", features = ["egui"] }
 egui = { version = "0.37", default-features = false, features = ["default_fonts", "monochrome_emoji_fonts"] }
-# Resizable table columns (About ▸ Contributors / Models); no image loaders.
-egui_extras = { version = "0.37", default-features = false }
 egui_kittest = "0.37"
 eframe = { version = "0.37", default-features = false }
 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 = "6e03f65bf45181db77ba6229716e6624db9eb25b", 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 }

@@ -121,5 +116,8 @@ egui-wgpu = { git = "https://github.com/storytold/egui.git", rev = "6d518fc79968
 egui_glow = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 egui_extras = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 egui_kittest = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
+egui_system_font_provider = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 eframe = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
+egui_demo_lib = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
+egui_inspection = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 winit = { git = "https://github.com/storytold/winit.git", rev = "a517b3846ee8457d84ee4975110bfda6797c44dc" }
@@ -118,7 +118,7 @@ numbers):
 | Layouts & plotting | Paper-space layouts, viewports (scale, lock, per-viewport layer freeze), MSPACE/PSPACE through viewports, page setups, PLOT and EXPORTPDF |
 | Parametric | Geometric and dimensional constraints, AUTOCONSTRAIN, PARAMETERS with expressions, conflict detection; constraints re-solve after every edit |
 | Grips | Hot grips with Space to cycle Stretch, Move, Rotate, Scale and Mirror |
-| Interface languages | English, Ukrainian (Українська), Brazilian Portuguese (Português (Brasil)), German (Deutsch), Spanish (Español), Czech (Čeština), Russian (Русский), French (Français), Simplified Chinese (简体中文, with an installed CJK font), Italian (Italiano), Korean (한국어, with an installed Hangul font), Swedish (Svenska), Arabic (العربية, with an installed Arabic font), Hungarian (Magyar), Turkish (Türkçe), Greek (Ελληνικά), Bosnian (Bosanski) and Georgian (ქართული), live switching and a remembered Auto/system-language choice; [details](docs/localization.md) |
+| Interface languages | English, Ukrainian (Українська), Brazilian Portuguese (Português (Brasil)), German (Deutsch), Spanish (Español), Czech (Čeština), Russian (Русский), French (Français), Simplified Chinese (简体中文, with an installed CJK font), Italian (Italiano), Korean (한국어, with an installed Hangul font), Swedish (Svenska), Arabic (العربية, with an installed Arabic font), Hungarian (Magyar) and Turkish (Türkçe), live switching and a remembered Auto/system-language choice; [details](docs/localization.md) |
 | Automation | MCP server, JSON control channel, `cadcraft-cli` (info, convert, run, commands, mcp) |

 ## Quick start
@@ -2,18 +2,16 @@

 **Stage: pre-alpha** · next: alpha, ~2 points (38% → 40% ready for real work) and ~125–190 Opus 5.5 hours away (the four failing core workflows of the [alpha gate](docs/roadmap.md#alpha-gate))

-> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-10-24 · **Change:** minor (re-audit against main 41d9b5e95: language table, CI gate, open-PR count; previously: progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-21 · **Change:** trivial (progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027

 CADCraft targets full parity with AutoCAD (2D drafting first, then annotation, layouts and
 plotting, DWG, parametrics and 3D), plus what AutoCAD doesn't have: agent control over MCP, a
 scriptable CLI, a web build, Linux and FreeBSD builds, and a free licence.

 **Why pre-alpha:** four of AutoCAD's five core workflows fail the [alpha gate](docs/roadmap.md#alpha-gate).
-Precise drafting still has approximate ellipse and spline intersections and a few stubbed prompt options
-(object snap tracking, TRIM/EXTEND/OFFSET options and typed snap overrides have landed); dynamic blocks can't be
-authored and xrefs can't be edited in place (the Block Editor, REFEDIT, dynamic block editing and XCLIP have landed);
-plots go only to PDF, PNG and SVG files (plot styles and the Plot dialog have landed); and a DWG saved by
-CADCraft drops what acadrust doesn't model and has never been checked in
+Precise drafting lacks object snap tracking and has stubbed TRIM/EXTEND/OFFSET options; blocks
+can't be edited in a block editor (REFEDIT edits them in place, xrefs not yet); plots ignore plot styles; and a DWG saved by
+CADCraft drops everything it doesn't model and has never been checked in
 AutoCAD. Dimensioning passes. Ready for real work (≈ 38%) is also under the ~40% alpha bar. Beta
 is ≈ 600–930 h away.

@@ -21,7 +19,7 @@ is ≈ 600–930 h away.

 | Number | Value | Kind |
 |---|---|---|
-| Feature breadth (AutoCAD for Mac menu items with a live command) | **50%** (245 / 491 at the 2026-10-10 re-measure, including UI-only commands; not re-measured since; the generated checklist counts engine commands only and now reads 298 / 491; 2D menus only ≈ 65%) | measured ([parity-checklist.md](docs/parity-checklist.md) + UI-only commands) |
+| Feature breadth (AutoCAD for Mac menu items with a live command) | **50%** (245 / 491; 2D menus only ≈ 65%) | measured ([parity-checklist.md](docs/parity-checklist.md) + UI-only commands) |
 | Ready for real work | **≈ 38%** | estimated ([target-app-parity.md](docs/target-app-parity.md)) |
 | Mainstream practitioner (2D drafter) | **≈ 28%** (lower than the full number: file exchange, stability and interaction discounts multiply) | estimated ([target-app-parity.md](docs/target-app-parity.md#mainstream-practitioner)) |
 | Essentials user | **≈ 46%** | estimated ([target-app-parity.md](docs/target-app-parity.md#essentials-user)) |
@@ -82,40 +80,40 @@ Hours are Opus 5.5 agent wall-clock hours, calibrated on this repo's own build:

 ## Languages

-AutoCAD 2027 for Mac ships 8 interface languages; CADCraft ships English plus eighteen catalogs
-(Ukrainian, Brazilian Portuguese, German, Spanish, Czech, Russian, French, Simplified Chinese, Italian, Korean, Swedish, Arabic, Greek, Hungarian, Turkish, Bosnian, Georgian and Vietnamese). Detail: [localization-parity.md](docs/localization-parity.md).
+AutoCAD 2027 for Mac ships 8 interface languages; CADCraft ships English plus partial
+Ukrainian and German. Detail: [localization-parity.md](docs/localization-parity.md).

 | Language | Status | UI translated |
 |---|---|---:|
 | English | full | 100% |
-| Simplified Chinese | partial | 1,337 catalog rows |
-| Spanish | partial | 1,243 catalog rows |
+| Simplified Chinese | none | 0% |
+| Spanish | none | 0% |
 | Hindi | none | 0% |
-| Arabic | partial | 1,229 catalog rows |
-| French | partial | 1,004 catalog rows |
-| Portuguese (Brazilian) | partial | 1,243 catalog rows |
+| Arabic | none | 0% |
+| French | none | 0% |
+| Portuguese | none | 0% |
 | Indonesian | none | 0% |
 | Japanese | none | 0% |
-| Greek | partial | 1,330 catalog rows; independent proofreading pending |
-| German | partial | 1,031 catalog rows |
-| Korean | partial | 1,235 catalog rows |
-| Vietnamese | partial | 1,460 catalog rows (2026-11-07); native review pending |
+| Greek | complete current catalog | 1,330 current source keys; independent proofreading pending |
+| German | partial | ≈ 100% of the catalog (989 rows) |
+| Korean | none | 0% |
+| Vietnamese | none | 0% |

-Other languages shipped: Ukrainian (1,357 rows, the reference catalog, #36), Czech (1,215), Russian (1,005), Italian (1,352), Swedish (1,382), Hungarian (1,326) and Turkish (1,330), counted 2026-10-24; engine messages stay English. Every catalog but Ukrainian's has strings added since it landed that still fall back to English: 6 (Italian, Swedish) to 296 (French) per `cargo xtask i18n` ([localization-parity.md](docs/localization-parity.md)).
+Other languages shipped: Ukrainian and German (989 catalog rows each; Ukrainian landed with #36), Brazilian Portuguese, Spanish, Czech, Russian, French, Simplified Chinese and Italian (1,227 rows, 2026-10-12); engine messages stay English.

 ## Upcoming

 Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md).

-1. Gate and land: CI runs `cargo xtask ci` on every PR since #1987 (fmt on main is fixed); land the 450 open PRs (2026-10-24) (15–25 h).
-2. Stop losing data on save (DXF done, #528; native MULTILEADER, #459, and the save version, #421, done; through DWG, acadrust still drops some content) (30–45 h).
+1. Gate and land: fix fmt on main, run `cargo xtask ci` on every PR, land the 47 open PRs (15–25 h).
+2. Stop losing data on save; native MULTILEADER; save DWG/DXF at a chosen version (30–45 h).
 3. Real-file DWG/DXF corpus and a black-box check in AutoCAD (10–15 h + owner).
-4. ~~Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
-   editable dynamic input.~~ Done (#379, #441, #60, #519; `snap/tracking.rs`, `pointmod.rs`, `dyninput.rs`).
-5. ~~Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER.~~ Done (#397, #408, #547); the stubs left are in gaps F1.
-6. ~~Autosave, recovery, AUDIT, RECOVER.~~ Done on the desktop (#406, #416); the web build has no autosave (gaps F4).
+4. Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
+   editable dynamic input (25–35 h).
+5. Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER (15–25 h).
+6. Autosave, recovery, AUDIT, RECOVER (10–15 h).
 7. Exact ellipse/spline geometry and correct polyline offsets (30–50 h).
-8. Xrefs, block editor, groups, then dynamic blocks (80–120 h): xrefs (#525), groups (#417), the Block Editor (#824, #833, #885), REFEDIT (#818), XCLIP and XCLIPFRAME (#2354) and dynamic block references (#838–#883) landed; left: dynamic-block authoring, editing an xref in place.
+8. Xrefs, block editor, groups, then dynamic blocks (80–120 h).

 ## Progress log

@@ -138,7 +136,6 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)

 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-24 | minor | Re-audit against main 41d9b5e95: language table, CI gate and open-PR count re-checked against main 41d9b5e95 |
 | 2026-10-21 | trivial | Progress log: proxy objects keep their class through a save (#1812) |
 | 2026-10-14 | minor | Progress log: HATCHEDIT boundary add/remove |
 | 2026-10-12 | trivial | Progress log: closed-polyline TRIM (#726) |
@@ -162,31 +162,19 @@ pub(crate) fn export_framed(s: &Session, out: &Path, window: Option<Bounds2>, io
 /// as unknown objects, `Proxy` in `info`), or `None` when there are none.
 pub(crate) fn undrawn_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option<String> {
    let mut types: std::collections::BTreeMap<&str, usize> = std::collections::BTreeMap::new();
-    let mut ole = 0usize;
    for e in d.model.iter() {
-        // An OLE2FRAME's frame outline is drawn, so it isn't an undrawn entity; its content is
-        // not, which gets a note of its own.
        if let cadcraft_engine::doc::EntityKind::Unknown(u) = &e.kind {
-            if u.is_ole_frame() && cadcraft_engine::doc::ole_frame(&u.tags).is_some() {
-                ole = ole.saturating_add(1);
-                continue;
-            }
            let n = types.entry(u.dxf_type.as_str()).or_insert(0);
            *n = n.saturating_add(1);
        }
    }
    let n = types.values().fold(0usize, |a, n| a.saturating_add(*n));
-    let mut lines = Vec::new();
-    if n > 0 {
-        let list: Vec<String> = types.iter().map(|(t, n)| format!("{t}: {n}")).collect();
-        let entities = if n == 1 { "entity" } else { "entities" };
-        lines.push(format!("{path}: {n} {entities} not drawn ({})", list.join(", ")));
+    if n == 0 {
+        return None;
    }
-    if ole > 0 {
-        let objects = if ole == 1 { "object" } else { "objects" };
-        lines.push(format!("{path}: {ole} OLE {objects} shown as the frame only (the OLE content is not drawn)"));
-    }
-    if lines.is_empty() { None } else { Some(lines.join("\n")) }
+    let list: Vec<String> = types.iter().map(|(t, n)| format!("{t}: {n}")).collect();
+    let entities = if n == 1 { "entity" } else { "entities" };
+    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,
@@ -16,13 +16,6 @@ fn a_real_worker_reads_and_writes_and_its_death_is_an_error_here() {
    let read = cadcraft_io::read(&written, "a.dwg").unwrap();
    assert_eq!(read.model.len(), drawing.model.len());

-    // A drawing whose kept objects came from a 2018 file: the worker gets that version with the
-    // request and reads the bridge DXF as it, as this process does.
-    let mut kept = drawing.clone();
-    kept.foreign = std::sync::Arc::new(cadcraft_engine::doc::foreign::Foreign { version: Some("AC1032".into()), ..Default::default() });
-    let written = cadcraft_io::write(&kept, "a.dwg").unwrap();
-    assert_eq!(cadcraft_io::read(&written, "a.dwg").unwrap().model.len(), drawing.model.len());
-
    // A decode error comes back as that error, not as the worker stopping.
    let mut bad = in_process.clone();
    bad.truncate(64);
@@ -7,25 +7,6 @@ fn cli(args: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_cadcraft-cli")).args(args).output().unwrap()
 }

-/// A fresh scratch directory that is removed on drop, also when an assertion fails.
-struct Scratch(std::path::PathBuf);
-
-impl Scratch {
-    fn new(tag: &str) -> Self {
-        let dir = std::env::temp_dir().join(format!("cc-cli-{tag}-{}", std::process::id()));
-        // A directory left behind by an earlier run with the same process id must not leak in.
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir(&dir).expect("create scratch dir");
-        Scratch(dir)
-    }
-}
-
-impl Drop for Scratch {
-    fn drop(&mut self) {
-        let _ = std::fs::remove_dir_all(&self.0);
-    }
-}
-
 /// A line, two foreign REGIONs and a PDF underlay: the last three are kept as unknown entities.
 const PROXIES: &str = "0\nSECTION\n2\nENTITIES\n\
 0\nLINE\n8\n0\n10\n0\n20\n0\n11\n5\n21\n5\n\
@@ -36,8 +17,8 @@ const PROXIES: &str = "0\nSECTION\n2\nENTITIES\n\

 #[test]
 fn convert_to_an_image_warns_about_entities_it_cannot_draw() {
-    let scratch = Scratch::new("undrawn");
-    let dir = scratch.0.clone();
+    let dir = std::env::temp_dir().join(format!("cc-cli-undrawn-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
    let input = dir.join("proxies.dxf");
    std::fs::write(&input, PROXIES).unwrap();
    let input = input.to_str().unwrap();
@@ -68,37 +49,5 @@ fn convert_to_an_image_warns_about_entities_it_cannot_draw() {
    let out = cli(&["convert", sample.to_str().unwrap(), dir.join("sample.svg").to_str().unwrap()]);
    assert!(out.status.success());
    assert!(!String::from_utf8_lossy(&out.stderr).contains("not drawn"), "{}", String::from_utf8_lossy(&out.stderr));
-}
-
-/// An OLE2FRAME's frame outline is drawn, so an image export doesn't call it an undrawn entity (#2422); it
-/// says once that the OLE content inside the frame is not drawn (review on #2587).
-#[test]
-fn an_ole_frame_is_noted_as_frame_only() {
-    let scratch = Scratch::new("ole");
-    let dir = scratch.0.clone();
-    let input = dir.join("ole.dxf");
-    let ole = "0\nSECTION\n2\nENTITIES\n0\nOLE2FRAME\n8\n0\n100\nAcDbOle2Frame\n10\n0\n20\n0\n30\n0\n11\n5\n21\n-3\n31\n0\n0\nENDSEC\n0\nEOF\n";
-    std::fs::write(&input, ole).unwrap();
-    let out = cli(&["convert", input.to_str().unwrap(), dir.join("out.png").to_str().unwrap()]);
-    assert!(out.status.success());
-    let err = String::from_utf8_lossy(&out.stderr);
-    assert!(!err.contains("entity not drawn") && !err.contains("entities not drawn"), "{err}");
-    let notes: Vec<&str> = err.lines().filter(|l| l.contains("OLE")).collect();
-    assert_eq!(notes, [format!("{}: 1 OLE object shown as the frame only (the OLE content is not drawn)", input.display())], "{err}");
-}
-
-/// An OLE2FRAME without usable corners (here group 11/21 missing) has no outline to draw, so it is
-/// an undrawn entity, not "shown as the frame only" (review on #2587).
-#[test]
-fn an_ole_frame_without_corners_is_counted_as_not_drawn() {
-    let scratch = Scratch::new("ole-nocorner");
-    let dir = scratch.0.clone();
-    let input = dir.join("ole.dxf");
-    let ole = "0\nSECTION\n2\nENTITIES\n0\nOLE2FRAME\n8\n0\n100\nAcDbOle2Frame\n10\n0\n20\n0\n30\n0\n0\nENDSEC\n0\nEOF\n";
-    std::fs::write(&input, ole).unwrap();
-    let out = cli(&["convert", input.to_str().unwrap(), dir.join("out.png").to_str().unwrap()]);
-    assert!(out.status.success());
-    let err = String::from_utf8_lossy(&out.stderr);
-    assert!(err.contains(&format!("{}: 1 entity not drawn (OLE2FRAME: 1)", input.display())), "{err}");
-    assert!(!err.contains("frame only"), "{err}");
+    let _ = std::fs::remove_dir_all(&dir);
 }
@@ -19,10 +19,6 @@ cadcraft-engine = { workspace = true }
 cadcraft-ui-egui = { workspace = true }
 cadcraft-io = { workspace = true }
 cadcraft-fonts = { workspace = true }
-# The host messages (storytold/craft-libs): one contract and one bridge for the web builds.
-# The page command API (storytold/craft-libs#413): window.cadcraft over the control channel.
-craft-web-api = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
-craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
 egui = { workspace = true }
 log = { workspace = true }
 serde_json = { workspace = true }
@@ -35,5 +31,4 @@ web-sys = { version = "0.3", features = ["HtmlInputElement", "FileList", "File"]
 eframe = { workspace = true, features = ["persistence", "wgpu", "accesskit"] }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
-js-sys = "0.3"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Location", "Navigator", "Blob", "BlobPropertyBag", "Url", "MessageEvent", "UrlSearchParams", "MediaQueryList", "Event", "EventTarget", "CustomEvent", "CustomEventInit"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Location", "Navigator", "Blob", "BlobPropertyBag", "Url", "MessageEvent", "UrlSearchParams", "MediaQueryList"] }
@@ -1,61 +0,0 @@
-//! `window.cadcraft`: the page command API (`craft-web-api`, storytold/craft-libs#413) over the app's
-//! own control channel, the one the desktop control server drives (`docs/control-protocol.md`).
-//!
-//! The crate owns the JavaScript side (`request`, `execute`, `commands`, `docInspect`, `uiInspect`,
-//! `screenshot`, as promises with a timeout). This module is CADCraft's part: a [`Request`] that
-//! queues a [`ControlRequest`] for the app, which answers it on its next frame, and waits for the
-//! reply. A call the page gave up on drops its [`PendingReply`], which cancels a request the app has
-//! not started, so the app skips it instead of running it late.
-
-use std::rc::Rc;
-use std::sync::mpsc::{Receiver, channel};
-
-use cadcraft_ui_egui::{ControlRequest, PendingReply};
-use craft_web_api::methods::Methods;
-use craft_web_api::page::{PageApi, Request};
-use serde_json::{Value, json};
-use wasm_bindgen_futures::JsFuture;
-
-/// The app id in `window.<app>`.
-const APP: &str = "cadcraft";
-
-/// How often a waiting call looks for the app's reply, in milliseconds (about a frame).
-const POLL_MS: i32 = 16;
-
-/// Put `window.cadcraft` on the page and return the queue the app drains each frame (hand it to
-/// `CadApp::with_control`). An existing `window.cadcraft` keeps the functions it already has.
-pub fn install(ctx: egui::Context) -> Receiver<ControlRequest> {
-    let (queue, requests) = channel::<ControlRequest>();
-    let request: Request = Rc::new(move |method, params| {
-        let (control, reply) = ControlRequest::new(method, params);
-        if queue.send(control).is_err() {
-            return Box::pin(async { json!({"ok": false, "error": "the app is not running"}) });
-        }
-        ctx.request_repaint();
-        Box::pin(wait(reply))
-    });
-    if let Err(e) = Rc::new(PageApi::new(APP, Methods::default(), request)).install() {
-        log::warn!("couldn't install window.{APP}: {e:?}");
-    }
-    requests
-}
-
-/// The app's reply, polled about once a frame. Dropping this future (the page's timeout) drops
-/// `reply`, which cancels the request if the app has not started it.
-async fn wait(reply: PendingReply) -> Value {
-    loop {
-        if let Some(reply) = reply.try_reply() {
-            return reply;
-        }
-        sleep(POLL_MS).await;
-    }
-}
-
-async fn sleep(ms: i32) {
-    let promise = js_sys::Promise::new(&mut |resolve, _| {
-        if let Some(window) = web_sys::window() {
-            let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms);
-        }
-    });
-    let _ = JsFuture::from(promise).await;
-}
@@ -1,37 +1,28 @@
-//! Host modes: a page that runs CADCraft opens drawings in it and stores what it saves instead
-//! of the browser downloading. The messages and the two transports are `craft-web-host`'s
-//! (storytold/craft-libs), the same contract as the other Craft apps' bridges, with the
-//! `cadcraft:` prefix. This module is CADCraft's part of it.
+//! The `postMessage` bridge to a same-origin parent page (`?host=parent`), for pages that embed
+//! CADCraft in an `<iframe>` (such as a Nextcloud app). Messages are plain objects with a `type`:
 //!
-//! - `?host=parent` (an `<iframe>`, such as a Nextcloud app) talks to the same-origin parent over
-//!   `postMessage`; `data-host="page"` on the canvas (the page's own document, no iframe) uses
-//!   DOM `CustomEvent`s on the canvas instead. `?host=parent` wins when both are present. With no
-//!   parent, or a parent on another origin, there is no bridge: the normal app with downloads.
-//! - `cadcraft:ready` once the app is listening; send a drawing now. CADCraft reads bytes, so it
-//!   says `file: false` and a host sends `bytes`.
-//! - `cadcraft:open` (from the host): `{ name, bytes }`. It opens like a file picked with
-//!   File › Open or dropped on the window; an oversized drawing is refused before it is copied.
-//! - `cadcraft:save` (to the host): `{ name, saveAs, bytes }` for every file CADCraft would
-//!   otherwise download (SAVE, SAVEAS, exports): it replaces the engine's delivery hook. The host
-//!   stores the file and reports failures itself. CADCraft doesn't tell the host which saves
-//!   make a file the document, so `saveAs` is always `false`.
-//! - `cadcraft:dirty` whenever unsaved changes appear or go away, `cadcraft:failed` when the app
-//!   couldn't start.
+//! - `cadcraft:ready` (to the parent): `{ version }`, the app is listening; send a drawing now.
+//! - `cadcraft:open` (from the parent): `{ name, bytes }`, bytes an `ArrayBuffer` or
+//!   `Uint8Array`. It opens like a file picked with File › Open or dropped on the window.
+//! - `cadcraft:save` (to the parent): `{ name, bytes }` (a transferred `ArrayBuffer`) for every
+//!   file CADCraft would otherwise download (SAVE, SAVEAS, exports): it replaces the engine's
+//!   delivery hook. The parent stores the file and reports failures itself.
+//! - `cadcraft:dirty` (to the parent): `{ dirty }` whenever unsaved changes appear or go away.
+//! - `cadcraft:failed` (to the parent): `{ error }` when the app couldn't start.
 //!
-//! In both host modes the app starts on the Start tab rather than an empty Drawing1, and the
-//! host guards leaving the page.
+//! Only the parent window on the page's own origin is heard or answered. In host mode the app
+//! starts on the Start tab rather than an empty Drawing1, and the parent guards leaving the page.

-use std::cell::RefCell;
-use std::rc::Rc;
+use std::cell::{Cell, RefCell};

 use cadcraft_ui_egui::CadApp;
-use craft_web_host::web::{FileData, Host, Message};
+use wasm_bindgen::JsCast as _;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::closure::Closure;
+use web_sys::js_sys;

-/// The app id in the host messages (`cadcraft:ready`).
-const APP: &str = "cadcraft";
-
-/// The name a drawing gets when the host sent none (the crate says `document` for a blank name).
-const DEFAULT_NAME: &str = "Drawing.dxf";
+/// Longest file name taken from the parent page.
+const MAX_NAME_CHARS: usize = 255;

 thread_local! {
    /// The bridge [`deliver`] posts through (the engine's hook is a plain `fn`).
@@ -40,15 +31,25 @@ thread_local! {

 #[derive(Clone)]
 pub struct Bridge {
-    host: Rc<Host>,
+    window: web_sys::Window,
+    parent: web_sys::Window,
+    origin: String,
 }

+/// The unsaved-changes state last reported to the parent.
+#[derive(Default)]
+pub struct DirtyReport(Cell<Option<bool>>);
+
 impl Bridge {
-    /// The bridge for this page, or `None` when CADCraft isn't hosted: no `?host=parent` and no
-    /// `data-host="page"` on the canvas, an unframed `?host=parent` page (it stays the normal app
-    /// with downloads), or a parent on another origin.
-    pub fn connect(canvas: &web_sys::HtmlCanvasElement) -> Option<Self> {
-        Some(Self { host: Rc::new(Host::connect(APP, canvas)?) })
+    /// `None` when the page isn't framed (there is no parent to talk to).
+    pub fn new() -> Option<Self> {
+        let window = web_sys::window()?;
+        let parent = window.parent().ok().flatten()?;
+        if js_sys::Object::is(&parent, &window) {
+            return None;
+        }
+        let origin = window.location().origin().ok()?;
+        Some(Self { window, parent, origin })
    }

    /// Make this the bridge [`deliver`] uses.
@@ -57,55 +58,94 @@ impl Bridge {
    }

    pub fn post_ready(&self) {
-        let _ = self.host.post_ready(env!("CARGO_PKG_VERSION"), false);
+        self.send(&[("type", "cadcraft:ready".into()), ("version", env!("CARGO_PKG_VERSION").into())]);
    }

    pub fn post_failed(&self, error: &str) {
-        let _ = self.host.post_failed(error, None);
+        self.send(&[("type", "cadcraft:failed".into()), ("error", error.into())]);
    }

-    /// Hear drawings from the host; they arrive through the upload inbox.
+    /// Hear drawings from the parent; they arrive through the upload inbox.
    pub fn listen(&self, inbox: crate::upload::Inbox) {
-        self.host.listen(move |message| {
-            if let Message::Open { name, data } = message {
-                receive_open(&name, &data, &inbox);
+        let parent = self.parent.clone();
+        let origin = self.origin.clone();
+        let on_message = Closure::<dyn FnMut(web_sys::MessageEvent)>::new(move |event: web_sys::MessageEvent| {
+            if event.origin() != origin || !event.source().is_some_and(|s| js_sys::Object::is(&s, &parent)) {
+                return;
            }
+            let data = event.data();
+            if string(&data, "type").as_deref() != Some("cadcraft:open") {
+                return;
+            }
+            let name = string(&data, "name")
+                .filter(|n| !n.trim().is_empty())
+                .map(|n| n.chars().take(MAX_NAME_CHARS).collect())
+                .unwrap_or_else(|| "Drawing.dxf".to_string());
+            // Refuse an oversized drawing before copying it into the app's memory.
+            let Some(array) = byte_array(&data) else { return };
+            if let Some(e) = CadApp::open_size_error(&name, u64::from(array.length())) {
+                inbox.refuse(e);
+                return;
+            }
+            inbox.receive(name, array.to_vec());
        });
+        if self.window.add_event_listener_with_callback("message", on_message.as_ref().unchecked_ref()).is_ok() {
+            // The listener lives as long as the page.
+            on_message.forget();
+        }
    }

-    /// After each logic callback (including a hidden tab's): tell the host when unsaved changes
-    /// appear or go away. The crate does not repeat a state it already reported, so this is
-    /// idempotent.
-    pub fn report_dirty(&self, app: &CadApp) {
-        self.host.post_dirty(app.session.docs.iter().any(|d| d.is_dirty()));
+    /// After each logic callback (including a hidden tab's): tell the parent when unsaved changes
+    /// appear or go away. `DirtyReport` suppresses duplicates, so this is idempotent.
+    pub fn report_dirty(&self, app: &CadApp, reported: &DirtyReport) {
+        let dirty = app.session.docs.iter().any(|d| d.is_dirty());
+        if reported.0.get() != Some(dirty) && self.send(&[("type", "cadcraft:dirty".into()), ("dirty", dirty.into())]) {
+            reported.0.set(Some(dirty));
+        }
    }

    fn post_save(&self, name: &str, bytes: &[u8]) -> Result<(), String> {
-        self.host.post_save(name, bytes, None, false)
+        let buffer = js_sys::Uint8Array::from(bytes).buffer();
+        let message = message(&[("type", "cadcraft:save".into()), ("name", name.into()), ("bytes", buffer.clone().into())])
+            .ok_or_else(|| "couldn't build the message".to_string())?;
+        self.parent
+            .post_message_with_transfer(&message, &self.origin, &js_sys::Array::of1(&buffer))
+            .map_err(|e| e.as_string().unwrap_or_else(|| format!("{e:?}")))
+    }
+
+    /// Post a message to the parent; false if it couldn't be sent.
+    fn send(&self, fields: &[(&str, JsValue)]) -> bool {
+        message(fields).is_some_and(|m| self.parent.post_message(&m, &self.origin).is_ok())
    }
 }

 /// The engine's delivery hook in host mode ([`cadcraft_engine::cmd::file::set_deliver`]): hand
-/// the file to the host page. `Ok` once it was sent; the engine then counts a drawing as saved.
+/// the file to the parent page. `Ok` once it was posted; the engine then counts a drawing as saved.
 pub fn deliver(name: &str, _mime: &str, bytes: &[u8]) -> Result<(), String> {
    let bridge = BRIDGE.with(|b| b.borrow().clone()).ok_or("the page that embeds CADCraft is gone")?;
    bridge.post_save(name, bytes)
 }

-/// The `cadcraft:open` payload, `{ name, bytes }` where `bytes` holds a drawing: it opens like a
-/// file picked with File › Open or dropped on the window. The crate has cleaned the name (and cut
-/// it to 255 characters); a blank one comes as `document` and becomes `Drawing.dxf`. An oversized
-/// drawing is refused before it is copied.
-fn receive_open(name: &str, data: &FileData, inbox: &crate::upload::Inbox) {
-    let name = if name == "document" { DEFAULT_NAME } else { name }.to_string();
-    let FileData::Bytes(array) = data else {
-        inbox.refuse(format!("Open: {name} came as a File; CADCraft reads bytes"));
-        return;
-    };
-    // Refuse an oversized drawing before copying it into the app's memory (the data's own length).
-    if let Some(e) = CadApp::open_size_error(&name, data.size() as u64) {
-        inbox.refuse(e);
-        return;
+fn message(fields: &[(&str, JsValue)]) -> Option<js_sys::Object> {
+    let m = js_sys::Object::new();
+    for (key, value) in fields {
+        js_sys::Reflect::set(&m, &JsValue::from_str(key), value).ok()?;
+    }
+    Some(m)
+}
+
+fn string(data: &JsValue, key: &str) -> Option<String> {
+    js_sys::Reflect::get(data, &JsValue::from_str(key)).ok()?.as_string()
+}
+
+/// `bytes` (an `ArrayBuffer` or `Uint8Array`) as a view, not yet copied.
+fn byte_array(data: &JsValue) -> Option<js_sys::Uint8Array> {
+    let bytes = js_sys::Reflect::get(data, &JsValue::from_str("bytes")).ok()?;
+    if let Some(array) = bytes.dyn_ref::<js_sys::Uint8Array>() {
+        Some(array.clone())
+    } else if bytes.is_instance_of::<js_sys::ArrayBuffer>() {
+        Some(js_sys::Uint8Array::new(&bytes))
+    } else {
+        None
    }
-    inbox.receive(name, array.to_vec());
 }
@@ -6,12 +6,9 @@
 //! with egui shapes instead of the GPU canvas, `?sample` opens the sample drawing. Saving downloads
 //! the drawing through the browser (`download.rs`). With `?host=parent` (inside an `<iframe>`), a
 //! same-origin parent page sends the drawing to open and stores what CADCraft saves instead
-//! (`host.rs`); a page can also host CADCraft in its own document (no iframe) with
-//! `data-host="page"` on the canvas, talking over DOM `CustomEvent`s on it (`host.rs`).
+//! (`host.rs`).
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]

-#[cfg(target_arch = "wasm32")]
-mod api;
 #[cfg(target_arch = "wasm32")]
 pub mod download;
 #[cfg(target_arch = "wasm32")]
@@ -30,11 +27,16 @@ mod web {
    const LOADING_ID: &str = "cadcraft_loading";

    /// The app, the files File > Open… and drag and drop read for it in the background, the
-    /// host page (`?host=parent`, or `data-host="page"` on the canvas), the browser's
-    /// `prefers-reduced-motion` (it stays
+    /// page embedding it (`?host=parent`), the browser's `prefers-reduced-motion` (it stays
    /// live, so View ▸ Accessibility ▸ Animation Effects ▸ Use System Setting follows a change),
    /// and the document title last written to the page.
-    struct Shell(CadApp, crate::upload::Inbox, Option<crate::host::Bridge>, Option<web_sys::MediaQueryList>, Option<String>);
+    struct Shell(
+        CadApp,
+        crate::upload::Inbox,
+        Option<(crate::host::Bridge, crate::host::DirtyReport)>,
+        Option<web_sys::MediaQueryList>,
+        Option<String>,
+    );

    impl eframe::App for Shell {
        /// Runs one frame: takes in files dropped on or picked for the page, drains the background
@@ -49,10 +51,10 @@ mod web {
            self.0.logic(ctx);
            let drawing = self.0.session.state().ok();
            crate::push_title(&mut self.4, drawing.map(|d| d.title.as_str()), drawing.is_some_and(|d| d.is_dirty()), set_page_title);
-            // The crate suppresses duplicates, so reporting after every logic callback
+            // `DirtyReport` suppresses duplicates, so reporting after every logic callback
            // (including a hidden tab's) is idempotent and keeps the parent's guard current.
-            if let Some(bridge) = &self.2 {
-                bridge.report_dirty(&self.0);
+            if let Some((bridge, reported)) = &self.2 {
+                bridge.report_dirty(&self.0, reported);
            }
        }
        /// Forward raw input to the web `CadApp` and capture Tab at the command line.
@@ -98,10 +100,8 @@ mod web {
        web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
    }

-    /// The app's canvas: the one element `index.html` and every embedding page must provide,
-    /// with the id the app looks up.
-    fn app_canvas() -> Option<web_sys::HtmlCanvasElement> {
-        web_sys::window()?.document()?.get_element_by_id(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok())
+    fn query_param(key: &str) -> Option<String> {
+        web_sys::UrlSearchParams::new_with_str(&query()).ok()?.get(key)
    }

    /// No file picker on the web: Save / Save As from the menu (and the close prompt) download the
@@ -128,17 +128,10 @@ mod web {
            groups: cadcraft_io::entity_groups,
            entity: cadcraft_io::entity_from_groups,
        });
-        let Some(canvas) = app_canvas() else {
-            log::error!("missing <canvas id=\"{CANVAS_ID}\">");
-            return;
-        };
        // `?host=parent`: a same-origin page framing CADCraft (such as a Nextcloud app) opens
-        // drawings in it and stores what it saves. Otherwise `data-host="page"` on the canvas
-        // opts in a page that runs CADCraft in its own document (no iframe) and talks over DOM
-        // `CustomEvent`s on the canvas (`host`). With neither, there is no file system here:
-        // saved files reach the user as browser downloads; an unframed `?host=parent` stays
-        // that normal app.
-        let bridge = crate::host::Bridge::connect(&canvas);
+        // drawings in it and stores what it saves. Otherwise there is no file system here: saved
+        // files reach the user as browser downloads.
+        let bridge = if query_param("host").as_deref() == Some("parent") { crate::host::Bridge::new() } else { None };
        match &bridge {
            Some(bridge) => {
                bridge.install();
@@ -149,6 +142,10 @@ mod web {
        let app_bridge = bridge.clone();
        wasm_bindgen_futures::spawn_local(async move {
            let Some(document) = web_sys::window().and_then(|w| w.document()) else { return };
+            let Some(canvas) = document.get_element_by_id(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok()) else {
+                log::error!("missing <canvas id=\"{CANVAS_ID}\">");
+                return;
+            };
            let mut options = eframe::WebOptions::default();
            if query().contains("webgl")
                && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
@@ -160,10 +157,9 @@ mod web {
                    canvas,
                    options,
                    Box::new(move |cc| {
-                        // Embedded, the host sends the drawing: start on the Start tab, not Drawing1.
+                        // Embedded, the parent sends the drawing: start on the Start tab, not Drawing1.
                        let session = if app_bridge.is_some() { Session::empty() } else { Session::new() };
-                        let control = crate::api::install(cc.egui_ctx.clone());
-                        let mut app = CadApp::new(session, services()).with_control(control);
+                        let mut app = CadApp::new(session, services());
                        app.system_languages =
                            web_sys::window().map(|w| w.navigator().languages().iter().filter_map(|v| v.as_string()).collect()).unwrap_or_default();
                        if let Some(profile) = cc.storage.and_then(|s| s.get_string(cadcraft_ui_egui::options::PROFILE_KEY)) {
@@ -196,9 +192,10 @@ mod web {
                            picker.pick();
                            None
                        }));
-                        let host = app_bridge.inspect(|bridge| {
+                        let host = app_bridge.map(|bridge| {
                            bridge.listen(inbox.clone());
                            bridge.post_ready();
+                            (bridge, crate::host::DirtyReport::default())
                        });
                        let reduced_motion = web_sys::window().and_then(|w| w.match_media("(prefers-reduced-motion: reduce)").ok().flatten());
                        Ok(Box::new(Shell(app, inbox, host, reduced_motion, None)))
@@ -55,11 +55,7 @@ muda = { version = "0.21", default-features = false }
 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.
-# `rwh_06`: the window handle a file dialog shown as a sheet attaches to (src/sheet.rs).
-winit = { version = "0.30", default-features = false, features = ["rwh_06"] }
-# Waits for the answer of a file dialog shown as a sheet (src/sheet.rs). MIT OR Apache-2.0, already
-# in Cargo.lock through eframe.
-pollster = "1"
+winit = { version = "0.30", default-features = false }

 # Rust HID backends: no proprietary SDK or C HID library.
 [target.'cfg(target_os = "windows")'.dependencies]
@@ -250,18 +250,17 @@ fn parse_line(bytes: &[u8]) -> Line {
        Ok(v) => v,
        Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
    };
-    let Value::Object(mut obj) = msg else {
+    let Some(obj) = msg.as_object() else {
        return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
    };
-    let Some(Value::String(method)) = obj.remove("method") else {
+    let Some(method) = obj.get("method").and_then(Value::as_str) else {
        return Line::Reject("not a control request (missing string `method`); closing the connection".into());
    };
-    // Moved out of the parsed object, not cloned: `params` can be most of the line.
    Line::Request {
-        id: obj.remove("id").unwrap_or(Value::Null),
-        method,
-        params: obj.remove("params").unwrap_or(json!({})),
-        token: obj.remove("token").and_then(|t| if let Value::String(t) = t { Some(t) } else { None }),
+        id: obj.get("id").cloned().unwrap_or(Value::Null),
+        method: method.to_string(),
+        params: obj.get("params").cloned().unwrap_or(json!({})),
+        token: obj.get("token").and_then(Value::as_str).map(str::to_string),
    }
 }

@@ -148,20 +148,7 @@ pub fn rotate(dir: &Path) -> std::io::Result<(PathBuf, File)> {
 /// One formatted log line: `<timestamp> <LEVEL> [<thread>] <target>: <message>\n`.
 pub fn format_line(ts: &str, level: log::Level, thread: &str, target: &str, message: &str) -> String {
    let message = message.strip_suffix('\n').unwrap_or(message);
-    // A message can carry text from a file (a code page name, a path), so it must not be able to
-    // start what looks like another record: control characters other than tab and line feed are
-    // shown escaped, and every continuation line is indented, so only this function's own
-    // timestamp is ever at the start of a line.
-    let mut safe = String::with_capacity(message.len());
-    for c in message.chars() {
-        match c {
-            '\n' => safe.push_str("\n    "),
-            '\t' => safe.push('\t'),
-            c if c.is_control() => safe.extend(c.escape_default()),
-            c => safe.push(c),
-        }
-    }
-    format!("{ts} {level:<5} [{thread}] {target}: {safe}\n")
+    format!("{ts} {level:<5} [{thread}] {target}: {message}\n")
 }

 /// Where formatted lines go besides standard error: kept in memory until a file is attached,
@@ -454,14 +441,8 @@ mod tests {
            format_line("2026-10-08T07:59:17.728Z", log::Level::Warn, "main", "cadcraft", "app icon: invalid PNG signature"),
            "2026-10-08T07:59:17.728Z WARN  [main] cadcraft: app icon: invalid PNG signature\n"
        );
-        // A multi-line message keeps its lines, indented so they can't pass for records; the
-        // record still ends in exactly one newline.
-        assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\n    b\n"));
-        // Control characters in a message (from a file) can't forge a record.
-        let forged = format_line("t", log::Level::Warn, "w", "x", "page\r\n2026-01-01T00:00:00Z ERROR [main] x: fake\u{1b}[0m");
-        assert_eq!(forged.lines().count(), 2);
-        assert!(forged.lines().skip(1).all(|l| l.starts_with("    ")));
-        assert!(!forged.contains('\r') && !forged.contains('\u{1b}'));
+        // A multi-line message keeps its lines; the record still ends in exactly one newline.
+        assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\nb\n"));
    }

    #[test]
@@ -23,15 +23,13 @@ mod launch_args;
 mod logging;
 #[cfg(target_os = "macos")]
 mod native_menu;
-#[cfg(target_os = "macos")]
-mod sheet;
 mod spacemouse;
 mod system_animations;
 mod workspace;

 use cadcraft_engine::Session;
 use cadcraft_ui_egui::switch::Switch;
-use cadcraft_ui_egui::{CadApp, Pick, Services, i18n};
+use cadcraft_ui_egui::{CadApp, Services, i18n};

 struct App {
    cad: CadApp,
@@ -161,41 +159,28 @@ pub fn install_io() {

 fn services() -> Services {
    Services {
-        pick_open: Some(Box::new(|| file_dialog(&Pick::Open).pick_file().map(|p| p.to_string_lossy().to_string()))),
-        pick_save: Some(Box::new(|name: &str| file_dialog(&Pick::Save(name.into())).save_file().map(|p| p.to_string_lossy().to_string()))),
-        // macOS shows the dialogs as sheets (`sheet::start_pick`), set once the window exists.
-        start_pick: None,
-        // APPLOAD: AutoLISP routines only, starting where the last one was loaded from.
-        pick_lisp: Some(Box::new(|dir: &str| file_dialog(&Pick::Lisp(dir.into())).pick_file().map(|p| p.to_string_lossy().to_string()))),
-        no_file_system: false,
-        pick_pgp: Some(Box::new(|dir: Option<&str>| {
-            file_dialog(&Pick::Pgp(dir.unwrap_or_default().into())).pick_file().map(|p| p.to_string_lossy().to_string())
+        pick_open: Some(Box::new(|| {
+            rfd::FileDialog::new()
+                .add_filter(i18n::t("Drawings (DWG, DXF)"), &["dwg", "dxf", "dwt"])
+                .add_filter(i18n::t("SVG drawings (SVG, SVGZ)"), &["svg", "svgz"])
+                .add_filter(i18n::t("All files"), &["*"])
+                .pick_file()
+                .map(|p| p.to_string_lossy().to_string())
        })),
-    }
-}
-
-/// The file types `pick` offers: (label, extensions). Shared by the blocking dialogs and the
-/// macOS sheets.
-fn filters(pick: &Pick) -> Vec<(&'static str, Vec<&'static str>)> {
-    match pick {
-        Pick::Open => vec![
-            (i18n::t("Drawings (DWG, DXF)"), vec!["dwg", "dxf", "dwt"]),
-            (i18n::t("SVG drawings (SVG, SVGZ)"), vec!["svg", "svgz"]),
-            (i18n::t("All files"), vec!["*"]),
-        ],
-        Pick::Save(name) => filters_for_save(name).iter().map(|(label, ext)| (i18n::t(label), vec![*ext])).collect(),
-        Pick::Lisp(_) => vec![(i18n::t("AutoLISP (LSP)"), vec!["lsp"]), (i18n::t("All files"), vec!["*"])],
-        Pick::Pgp(_) => vec![(i18n::t("Alias files (PGP)"), vec!["pgp"])],
-    }
-}
-
-/// The blocking dialog for `pick` (Windows, Linux, FreeBSD).
-fn file_dialog(pick: &Pick) -> rfd::FileDialog {
-    let dialog = filters(pick).iter().fold(rfd::FileDialog::new(), |d, (label, exts)| d.add_filter(*label, exts));
-    match pick {
-        Pick::Save(name) => dialog.set_file_name(name),
-        Pick::Lisp(dir) | Pick::Pgp(dir) if !dir.is_empty() => dialog.set_directory(dir),
-        _ => dialog,
+        pick_save: Some(Box::new(|name: &str| {
+            filters_for_save(name)
+                .iter()
+                .fold(rfd::FileDialog::new().set_file_name(name), |d, (label, ext)| d.add_filter(i18n::t(label), &[*ext]))
+                .save_file()
+                .map(|p| p.to_string_lossy().to_string())
+        })),
+        // APPLOAD: AutoLISP routines only, starting where the last one was loaded from.
+        pick_lisp: Some(Box::new(|dir: &str| {
+            let dialog = rfd::FileDialog::new().add_filter(i18n::t("AutoLISP (LSP)"), &["lsp"]).add_filter(i18n::t("All files"), &["*"]);
+            let dialog = if dir.is_empty() { dialog } else { dialog.set_directory(dir) };
+            dialog.pick_file().map(|p| p.to_string_lossy().to_string())
+        })),
+        no_file_system: false,
    }
 }

@@ -368,12 +353,6 @@ fn main() -> eframe::Result {
        options,
        Box::new(move |cc| {
            let mut app = CadApp::new(Session::empty(), services());
-            // File dialogs are sheets on macOS: a modal loop inside the event handler crashes the
-            // app when the dialog is resized (#1527).
-            #[cfg(target_os = "macos")]
-            if let Some(window) = cc.winit_window().cloned() {
-                app.services.start_pick = Some(sheet::start_pick(window, cc.egui_ctx.clone()));
-            }
            let (workspace, restored, workspace_error) = workspace::Workspace::load(vars.config_dir.as_deref());
            if let Some(ui) = restored {
                app.ui = ui;
@@ -1,51 +0,0 @@
-//! macOS file dialogs as sheets. Shown in line, or from a helper thread that rfd hands to the main
-//! thread's modal loop, a panel runs AppKit's modal event loop; resizing it sends window events
-//! back into winit's event handler and winit aborts the app (#1527). A sheet returns at once and
-//! the window keeps running; a thread of its own waits for the answer.
-
-use std::sync::Arc;
-
-use cadcraft_ui_egui::{Pick, StartPick};
-
-type Answer = std::pin::Pin<Box<dyn std::future::Future<Output = Option<String>> + Send>>;
-
-/// `Services::start_pick`: shows `pick` as a sheet on `window`; `ui` is woken when it answers.
-pub fn start_pick(window: Arc<winit::window::Window>, ui: egui::Context) -> StartPick {
-    Box::new(move |pick, done| {
-        let (sheet_tx, sheet_rx) = std::sync::mpsc::channel::<Answer>();
-        let ui = ui.clone();
-        // The thread first, so the answer of a sheet once shown always has somewhere to go. If it
-        // cannot start, `done` is dropped unanswered and the app says the dialog could not be
-        // shown.
-        let spawned = std::thread::Builder::new().name("file-dialog".into()).spawn(move || {
-            if let Ok(answer) = sheet_rx.recv() {
-                done(pollster::block_on(answer));
-                ui.request_repaint();
-            }
-        });
-        if let Err(e) = spawned {
-            log::warn!("file dialog: {e}");
-            return;
-        }
-        // rfd builds the panel and begins the sheet here, on the main thread (as it must).
-        let dialog =
-            crate::filters(&pick).iter().fold(rfd::AsyncFileDialog::new().set_parent(&*window), |d, (label, exts)| d.add_filter(*label, exts));
-        let path = |f: rfd::FileHandle| f.path().to_string_lossy().to_string();
-        let answer: Answer = match pick {
-            Pick::Save(name) => {
-                let picked = dialog.set_file_name(name).save_file();
-                Box::pin(async move { picked.await.map(path) })
-            }
-            Pick::Lisp(dir) | Pick::Pgp(dir) => {
-                let dialog = if dir.is_empty() { dialog } else { dialog.set_directory(dir) };
-                let picked = dialog.pick_file();
-                Box::pin(async move { picked.await.map(path) })
-            }
-            Pick::Open => {
-                let picked = dialog.pick_file();
-                Box::pin(async move { picked.await.map(path) })
-            }
-        };
-        let _ = sheet_tx.send(answer);
-    })
-}
@@ -37,9 +37,7 @@ display_name = "Tasos Sangiotis"
 sync_github_name = false

 [people.vangel76]
-real_name = "Valentin Klein"
-display_name = "vangel76"
-sync_github_name = false
+sync_github_name = true

 [people.WladmirJunior]
 real_name = "Wladmir Júnior"
@@ -90,10 +88,6 @@ sync_github_name = false
 real_name = "Robert Lee"
 sync_github_name = true

-[people.assamaral]
-real_name = "assamaral"
-sync_github_name = false
-
 [people.2ez4gcx]
 real_name = "Doan Huynh Huu Khuong"
 display_name = "Doan Huynh Huu Khuong"
@@ -115,9 +109,3 @@ real_name = "Andrea Brandi"

 [people.qinshah]
 sync_github_name = true
-
-[people.helenkwok]
-real_name = "Helen Kwok"
-
-[people.V1dalTheAbidal]
-sync_github_name = true
@@ -232,10 +232,6 @@ pub fn infer_placed(d: &Drawing, placed: &[Handle], others: &[Handle], o: &Infer
    let mut extra = Vec::new();
    let mut on = Vec::new();
    for (rp, p) in g.points.iter().filter(|(r, _)| placed.contains(&r.handle)) {
-        // Nothing is added once the candidates are full, so the points left need no search.
-        if extra.len() + on.len() + out.len() >= MAX_CANDIDATES {
-            break;
-        }
        if out.iter().any(|c| c.kind == ConstraintKind::Coincident && c.refs.contains(rp)) {
            continue;
        }
@@ -271,22 +267,20 @@ pub fn infer_placed(d: &Drawing, placed: &[Handle], others: &[Handle], o: &Infer
    // Perpendicular lines meeting in a T (a perpendicular snap onto the middle of a line).
    let atol = if o.angle_tolerance.is_finite() { o.angle_tolerance.clamp(0.0, 45.0).to_radians() } else { 0.0 };
    let allow_per = o.types.is_empty() || o.types.iter().any(|t| t.eq_ignore_ascii_case(ConstraintKind::Perpendicular.name()));
-    'per: for (r1, a1, b1) in g.lines.iter().filter(|(r, _, _)| allow_per && placed.contains(&r.handle)) {
+    for (r1, a1, b1) in g.lines.iter().filter(|(r, _, _)| placed.contains(&r.handle)) {
        for (r2, a2, b2) in g.lines.iter().filter(|(r, _, _)| r.handle != r1.handle) {
-            // Full: nothing more can be added, so the pairs left need no geometry or duplicate search.
-            if out.len() + extra.len() + on.len() >= MAX_CANDIDATES {
-                break 'per;
-            }
            let (l1, l2) = (Line::new(*a1, *b1), Line::new(*a2, *b2));
            let touches = |l: &Line, p: Vec2| l.dist(p) <= tol && (0.0..=1.0).contains(&l.param_of(p));
            let tee = [*a1, *b1].iter().any(|p| touches(&l2, *p)) || [*a2, *b2].iter().any(|p| touches(&l1, *p));
            let ang = ang_between(*b1 - *a1, *b2 - *a2);
-            // The duplicate search scans every candidate, so it comes after the cheap tests.
-            if tee
+            let dup = out.iter().any(|c| c.kind == ConstraintKind::Perpendicular && c.refs.contains(r1) && c.refs.contains(r2));
+            if allow_per
+                && tee
+                && !dup
                && (std::f64::consts::FRAC_PI_2 - ang).abs() <= atol
                && l1.len() > tol
                && l2.len() > tol
-                && !out.iter().any(|c| c.kind == ConstraintKind::Perpendicular && c.refs.contains(r1) && c.refs.contains(r2))
+                && out.len() < MAX_CANDIDATES
            {
                out.push(Constraint { id: 0, kind: ConstraintKind::Perpendicular, refs: vec![*r1, *r2], name: String::new(), expr: String::new() });
            }
@@ -138,9 +138,7 @@ pub fn dof(d: &Drawing, handles: &[Handle]) -> Result<DofReport, SolveError> {
    let cons: Vec<&Constraint> = d.constraints.iter().take(MAX_CONSTRAINTS).collect();
    let mut prep = Prep::new(crate::model::MAX_RIGID_WORK);
    let (comps, _) = build_with(d, &cons, &SolveOptions::default(), &mut prep)?;
-    // The selection as a set, built once: a scan of the list per slot multiplied the two sizes.
-    let selected: HashSet<Handle> = handles.iter().copied().collect();
-    let want = |h: Handle| handles.is_empty() || selected.contains(&h);
+    let want = |h: Handle| handles.is_empty() || handles.contains(&h);
    let mut objects = Vec::new();
    let mut seen = HashSet::new();
    let mut total = Some(0usize);
@@ -204,23 +204,6 @@ impl ArrayParams {
        self.replaced.iter().rev().find(|r| (r.i, r.j, r.level) == (i, j, level)).map_or(self.source.as_str(), |r| r.block.as_str())
    }

-    /// [`block_for`](Self::block_for) for many items: the replacements are indexed once (the last
-    /// entry for a place wins, as there), so each lookup is O(1) instead of a scan of `replaced`.
-    pub fn block_lookup<'a>(&'a self) -> impl Fn(u32, u32, u32) -> &'a str + 'a {
-        // Only places `items()` generates are indexed, so stray out-of-range records cost nothing.
-        let (cols, rows) = match &self.kind {
-            ArrayKind::Rect(r) => (r.cols, r.rows),
-            ArrayKind::Polar(p) => (p.items, p.rows),
-        };
-        let index: std::collections::HashMap<(u32, u32, u32), &str> = self
-            .replaced
-            .iter()
-            .filter(|r| r.i < cols && r.j < rows && r.level < self.levels)
-            .map(|r| ((r.i, r.j, r.level), r.block.as_str()))
-            .collect();
-        move |i, j, level| index.get(&(i, j, level)).copied().unwrap_or(self.source.as_str())
-    }
-
    /// The block references that make up the array block: one per item, on layer 0 with ByBlock
    /// properties so they take the array's. Handles are allocated from `d`. `None` when the
    /// parameters are not [valid](Self::is_valid).
@@ -234,10 +217,9 @@ impl ArrayParams {
            ..Common::default()
        };
        let mut out = Vec::with_capacity(items.len());
-        let block_for = self.block_lookup();
        for it in items {
            let ins = Insert {
-                block: block_for(it.i, it.j, it.level).to_string(),
+                block: self.block_for(it.i, it.j, it.level).to_string(),
                insert: it.insert,
                scale: Vec3::new(1.0, 1.0, 1.0),
                rotation: it.rotation,
@@ -319,18 +301,6 @@ mod tests {
        }
    }

-    #[test]
-    fn block_lookup_agrees_with_block_for_and_the_last_replacement_wins() {
-        let mut p = rect(3, 2);
-        let r = |i, j, level, b: &str| ReplacedItem { i, j, level, block: b.into() };
-        p.replaced = vec![r(1, 0, 0, "A"), r(1, 0, 0, "B"), r(2, 1, 1, "C")];
-        let look = p.block_lookup();
-        for (i, j, level) in [(0, 0, 0), (1, 0, 0), (2, 1, 1), (2, 1, 0)] {
-            assert_eq!(look(i, j, level), p.block_for(i, j, level));
-        }
-        assert_eq!((look(1, 0, 0), look(0, 0, 0)), ("B", "*U1"));
-    }
-
    #[test]
    fn rect_items_go_column_row_level() {
        let items = rect(3, 2).items().unwrap_or_default();
@@ -674,10 +674,6 @@ fn apply(
 /// Associative hatches of block `b` whose loop is one closed polyline of the block take its
 /// outline again (it may have been stretched).
 fn refill_hatches(b: &mut Block) {
-    // Each loop gets its own copy of the outline, so many small loops on one big outline multiply it;
-    // past this many vertices in all, the remaining loops keep the outline they have.
-    const MAX_REFILLED_VERTICES: usize = 4_000_000;
-    let mut budget = MAX_REFILLED_VERTICES;
    let outlines: HashMap<Handle, Vec<cadcraft_geom::PolyVertex>> = b
        .entities
        .iter()
@@ -693,9 +689,7 @@ fn refill_hatches(b: &mut Block) {
                for l in &mut hh.loops {
                    if let [s] = l.sources.as_slice()
                        && let Some(vs) = outlines.get(s)
-                        && let Some(left) = budget.checked_sub(vs.len())
                    {
-                        budget = left;
                        l.vertices.clone_from(vs);
                    }
                }
@@ -60,13 +60,6 @@ pub struct Unknown {
    pub tags: Vec<RawTag>,
 }

-impl Unknown {
-    /// Whether this is an OLE2FRAME (the type name is matched without regard to case).
-    pub fn is_ole_frame(&self) -> bool {
-        self.dxf_type.eq_ignore_ascii_case("OLE2FRAME")
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "camelCase")]
 pub enum EntityKind {
@@ -476,7 +469,6 @@ impl EntityKind {
                let a = if mirror { t.rotation() } else { t.rotation() + rot };
                t.dir = Vec2::from_angle(cadcraft_geom::norm_angle(a)).to3(0.0);
            }
-            EntityKind::Unknown(u) if u.is_ole_frame() => crate::ole_frame_transform(&mut u.tags, m),
            EntityKind::Unknown(_) => {}
        }
    }
@@ -9,239 +9,6 @@ use crate::{Drawing, Entity, EntityKind, LwPolyline, Prim};
 /// Nested block references deeper than this are ignored (cyclic or hostile files).
 pub const MAX_BLOCK_DEPTH: usize = 16;

-/// Positions in `tags` of the groups outside application-defined `102 {` .. `102 }` groups, whose
-/// codes are the application's own and not the entity's.
-fn outside_app(tags: &[crate::RawTag]) -> impl Iterator<Item = usize> + '_ {
-    let mut in_app = false;
-    tags.iter().enumerate().filter_map(move |(i, t)| {
-        if t.code == 102 {
-            in_app = t.value.starts_with('{');
-            None
-        } else {
-            (!in_app).then_some(i)
-        }
-    })
-}
-
-/// The positions of the frame's corner groups 10, 20, 11, 21 (in that order) and their values:
-/// the first of each outside application groups, found in one pass that stops at the last.
-fn ole_corner_groups(tags: &[crate::RawTag]) -> Option<[(usize, f64); 4]> {
-    let mut found: [Option<(usize, f64)>; 4] = [None; 4];
-    for i in outside_app(tags) {
-        let Some(t) = tags.get(i) else { continue };
-        let slot = match t.code {
-            10 => 0,
-            20 => 1,
-            11 => 2,
-            21 => 3,
-            _ => continue,
-        };
-        if let Some(f) = found.get_mut(slot).filter(|f| f.is_none()) {
-            *f = Some((i, t.value.trim().parse::<f64>().ok().filter(|v| v.is_finite())?));
-            if found.iter().all(Option::is_some) {
-                break;
-            }
-        }
-    }
-    let [Some(a), Some(b), Some(c), Some(d)] = found else { return None };
-    Some([a, b, c, d])
-}
-
-/// The closed outline of an OLE2FRAME from its upper-left (groups 10, 20) and lower-right
-/// (groups 11, 21) corners (DXF Reference, OLE2FRAME); `None` when either is missing or not finite.
-pub fn ole_frame(tags: &[crate::RawTag]) -> Option<[Vec2; 5]> {
-    let [(_, x1), (_, y1), (_, x2), (_, y2)] = ole_corner_groups(tags)?;
-    let (a, b) = (Vec2::new(x1, y1), Vec2::new(x2, y2));
-    Some([a, Vec2::new(b.x, a.y), b, Vec2::new(a.x, b.y), a])
-}
-
-/// The bytes of the OLE data before its corners: a 2-byte marker.
-const OLE_HEADER: usize = 2;
-/// The corners in the OLE data: four of x, y, z as little-endian doubles (upper left, upper right,
-/// lower right, lower left).
-const OLE_CORNERS: usize = 12;
-
-/// Replace the four corners at the start of the OLE data (the 310 groups' hex, in order) by `new`
-/// (upper left, upper right, lower right, lower left), keeping z and every group's length and
-/// letter case. Only the groups that cover the header are decoded and rewritten; the rest of the
-/// payload is not touched. Data that is not valid hex, too short, or whose corners are not the old
-/// `frame`'s is left alone.
-fn ole_data_transform(tags: &mut [crate::RawTag], new: [Vec2; 4], frame: [f64; 4]) {
-    const END: usize = OLE_HEADER + OLE_CORNERS * 8;
-    let mut bytes: Vec<u8> = Vec::with_capacity(END);
-    // The groups read, and how many leading bytes of each belong to the header.
-    let mut spans: Vec<(usize, usize)> = Vec::new();
-    for i in outside_app(tags).filter(|&i| tags.get(i).is_some_and(|t| t.code == 310)) {
-        if bytes.len() >= END {
-            break;
-        }
-        let Some(t) = tags.get(i) else { return };
-        let s = t.value.trim();
-        if s.len() % 2 != 0 || !s.is_ascii() {
-            return;
-        }
-        let take = (s.len() / 2).min(END - bytes.len());
-        for k in 0..take {
-            // `from_str_radix` also takes a sign, so each digit is checked first.
-            let Some(h) = s.get(2 * k..2 * k + 2).filter(|h| h.bytes().all(|b| b.is_ascii_hexdigit())) else { return };
-            let Ok(b) = u8::from_str_radix(h, 16) else { return };
-            bytes.push(b);
-        }
-        spans.push((i, take));
-    }
-    if bytes.len() < END {
-        return;
-    }
-    // Only data whose corners are this frame's corners (UL, UR, LR, LL) has the layout above; any
-    // other header is not ours to rewrite.
-    let [x1, y1, x2, y2] = frame;
-    let want = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)];
-    // Two corners match within a fixed tolerance for ordinary coordinates (CORNER_EPS at most), or
-    // within a few ulps of the coordinate where that is larger, which is from about 1.1e9 up.
-    let near = |a: f64, b: f64| {
-        let m = a.abs().max(b.abs());
-        (a - b).abs() <= (1e-9 * m.max(1.0)).min(CORNER_EPS).max(4.0 * f64::EPSILON * m)
-    };
-    for (c, (wx, wy)) in want.iter().enumerate() {
-        let at = OLE_HEADER + c * 24;
-        let rd = |o: usize| bytes.get(o..o + 8).and_then(|s| <[u8; 8]>::try_from(s).ok()).map(f64::from_le_bytes);
-        let (Some(x), Some(y)) = (rd(at), rd(at + 8)) else { return };
-        if !(near(x, *wx) && near(y, *wy)) {
-            return;
-        }
-    }
-    for (c, p) in new.iter().enumerate() {
-        let at = OLE_HEADER + c * 24;
-        if let Some(s) = bytes.get_mut(at..at + 8) {
-            s.copy_from_slice(&p.x.to_le_bytes());
-        }
-        if let Some(s) = bytes.get_mut(at + 8..at + 16) {
-            s.copy_from_slice(&p.y.to_le_bytes());
-        }
-    }
-    let mut pos = 0;
-    for (i, n) in spans {
-        let (Some(t), Some(chunk)) = (tags.get_mut(i), bytes.get(pos..pos + n)) else { return };
-        // Leave any padding around the digits, and the digits after the header, as they were.
-        let start = t.value.len() - t.value.trim_start().len();
-        // Only the rewritten digits and a few after them, for the case of the nearest letter: a
-        // hostile 310 line can be as long as the file (the value is checked to be ASCII above).
-        let end = start.saturating_add(2 * n + 64).min(t.value.len());
-        let hex = recase(chunk, t.value.get(start..end).unwrap_or_default());
-        t.value.replace_range(start..start + 2 * n, &hex);
-        pos += n;
-    }
-}
-
-/// The hex of `chunk`, each digit in the case of the digit at the same place in `old`. A digit that
-/// was a number and becomes a letter takes the case of the nearest letter in `old`, upper when there
-/// is none, so bytes that did not change keep their exact text.
-fn recase(chunk: &[u8], old: &str) -> String {
-    let old = old.as_bytes();
-    // For each place, whether the letter nearest to it (the one at it, else the closest before or
-    // after; the one before on a tie) is lower case: one pass for the next letter at or after each
-    // place, one for the previous, then the nearer of the two.
-    let mut next: Vec<Option<(usize, bool)>> = vec![None; old.len()];
-    let mut seen: Option<(usize, bool)> = None;
-    for (i, c) in old.iter().enumerate().rev() {
-        if c.is_ascii_alphabetic() {
-            seen = Some((i, c.is_ascii_lowercase()));
-        }
-        if let Some(slot) = next.get_mut(i) {
-            *slot = seen;
-        }
-    }
-    let mut lower_at = vec![false; old.len()];
-    let mut prev: Option<(usize, bool)> = None;
-    for (i, c) in old.iter().enumerate() {
-        if c.is_ascii_alphabetic() {
-            prev = Some((i, c.is_ascii_lowercase()));
-        }
-        let after = next.get(i).copied().flatten();
-        let lower = match (prev, after) {
-            (Some((p, lp)), Some((q, lq))) => {
-                if i - p <= q - i {
-                    lp
-                } else {
-                    lq
-                }
-            }
-            (Some((_, l)), None) | (None, Some((_, l))) => l,
-            (None, None) => false,
-        };
-        if let Some(slot) = lower_at.get_mut(i) {
-            *slot = lower;
-        }
-    }
-    let mut out = String::with_capacity(chunk.len() * 2);
-    for (k, b) in chunk.iter().enumerate() {
-        for (j, d) in [b >> 4, b & 15].into_iter().enumerate() {
-            let digit = char::from_digit(d.into(), 16).unwrap_or('0');
-            out.push(if lower_at.get(2 * k + j).copied().unwrap_or(false) { digit } else { digit.to_ascii_uppercase() });
-        }
-    }
-    out
-}
-
-/// The fixed part of the tolerance when matching the corners in the OLE data to the frame's. The
-/// header holds the same f64 the frame groups print, so they agree to a few ulps. Up to about 1.1e9
-/// a fixed tolerance of at most this decides, so that distinct geometry does not match; above that,
-/// four ulps of the coordinate (`4 * EPSILON * |x|`) exceed it and decide instead.
-const CORNER_EPS: f64 = 1e-6;
-
-/// Transform an OLE2FRAME by `m`: its two corners are mapped through `m` (a DWG save writes the
-/// frame's position from these groups), and so are the corners at the start of its OLE data (310
-/// groups), which a reader of the saved file may trust instead. The frame stays axis aligned with
-/// its upper-left corner first. A matrix that keeps the axes or swaps them (a move, scale, mirror or
-/// quarter turn) gives the box of the two mapped corners. Any other turn would collapse that box
-/// (a square turned 45° maps its two corners level), so the frame's centre is mapped and its size
-/// kept, scaled by `m`'s, its sides swapped when the turn is nearer a quarter turn. Commands refuse
-/// a rotation or mirror (see [`ole_frame_accepts`]), but internal callers such as EXPLODE, REFEDIT
-/// and paste still apply them, and must leave a consistent frame. A frame with no usable corners is
-/// left alone.
-pub fn ole_frame_transform(tags: &mut [crate::RawTag], m: &cadcraft_geom::Mat3) {
-    let Some([(ix1, x1), (iy1, y1), (ix2, x2), (iy2, y2)]) = ole_corner_groups(tags) else { return };
-    let frame = [x1, y1, x2, y2];
-    let t = 1e-12 * (m.a.abs() + m.b.abs() + m.c.abs() + m.d.abs());
-    let axes_kept = (m.b.abs() <= t && m.c.abs() <= t) || (m.a.abs() <= t && m.d.abs() <= t);
-    let (a, b) = if axes_kept {
-        (m.apply(Vec2::new(x1, y1)), m.apply(Vec2::new(x2, y2)))
-    } else {
-        let center = m.apply(Vec2::new((x1 + x2) / 2.0, (y1 + y2) / 2.0));
-        // A plain turn keeps the size exactly; cos² + sin² can miss 1 by an ulp or two.
-        let s = (m.a * m.d - m.b * m.c).abs().sqrt();
-        let scale = if (s - 1.0).abs() < 1e-12 { 1.0 } else { s };
-        let (mut w, mut h) = ((x2 - x1).abs() * scale, (y2 - y1).abs() * scale);
-        // Where the frame's x axis goes: nearer to y than to x is nearer a quarter turn.
-        if m.b.abs() > m.a.abs() {
-            std::mem::swap(&mut w, &mut h);
-        }
-        (center - Vec2::new(w, h) / 2.0, center + Vec2::new(w, h) / 2.0)
-    };
-    if !(a.x.is_finite() && a.y.is_finite() && b.x.is_finite() && b.y.is_finite()) {
-        return;
-    }
-    let (lo, hi) = (Vec2::new(a.x.min(b.x), a.y.min(b.y)), Vec2::new(a.x.max(b.x), a.y.max(b.y)));
-    let (ul, lr) = (Vec2::new(lo.x, hi.y), Vec2::new(hi.x, lo.y));
-    for (i, v) in [(ix1, ul.x), (iy1, ul.y), (ix2, lr.x), (iy2, lr.y)] {
-        if let Some(t) = tags.get_mut(i) {
-            t.value = v.to_string();
-        }
-    }
-    ole_data_transform(tags, [ul, Vec2::new(lr.x, ul.y), lr, Vec2::new(ul.x, lr.y)], frame);
-}
-
-/// Whether `m` can move an OLE2FRAME: a translation (move, copy, stretch of the whole frame) or a
-/// uniform scale with a positive factor, which keep the frame axis aligned and its upper-left corner
-/// upper-left.
-pub fn ole_frame_accepts(m: &cadcraft_geom::Mat3) -> bool {
-    const T: f64 = 1e-12;
-    // The tolerance grows with the scale: a matrix built from two angles (ALIGN) leaves rounding noise
-    // in b and c of about `scale * 1e-16`.
-    let t = T * m.a.abs();
-    m.b.abs() < t && m.c.abs() < t && m.a > 0.0 && (m.a - m.d).abs() <= t
-}
-
 /// Bounds of a single-line TEXT / ATTDEF / ATTRIB of `len` characters, following its justification
 /// the same way the renderer places it (the stroke font is about 0.88 of the height per character).
 fn text_box(t: &crate::Text, len: usize) -> Bounds2 {
@@ -420,15 +187,10 @@ fn bounds_in<'a>(d: &'a Drawing, e: &Entity, depth: usize, blocks: &mut HashMap<
                    b = Bounds2::from_points(c.polygon().into_iter().map(|p| m.apply(p)));
                }
                if ins.cols > 1 || ins.rows > 1 {
-                    // The grid's four corner copies (as many as are drawn): turned, the far corner
-                    // alone misses the side ones.
-                    let (cols, rows) =
-                        (f64::from(ins.cols.clamp(1, 10_000).saturating_sub(1)), f64::from(ins.rows.clamp(1, 10_000).saturating_sub(1)));
-                    let one = b;
-                    for (c, r) in [(cols, 0.0), (0.0, rows), (cols, rows)] {
-                        let off = Vec2::new(ins.col_spacing * c, ins.row_spacing * r).rotate(ins.rotation);
-                        b = b.union(&Bounds2::from_points(one.corners().map(|p| p + off)));
-                    }
+                    let off =
+                        Vec2::new(ins.col_spacing * f64::from(ins.cols.saturating_sub(1)), ins.row_spacing * f64::from(ins.rows.saturating_sub(1)))
+                            .rotate(ins.rotation);
+                    b = b.union(&Bounds2::from_points(b.corners().map(|c| c + off)));
                }
            }
            for a in &ins.attribs {
@@ -516,8 +278,6 @@ fn bounds_in<'a>(d: &'a Drawing, e: &Entity, depth: usize, blocks: &mut HashMap<
            Bounds2::from_points([o, o + u, o + v, o + u + v])
        }
        EntityKind::LwPolyline(p) => lwpolyline_bounds(p),
-        // An OLE object's content is not drawn, but its frame is, so the frame counts (#2422).
-        EntityKind::Unknown(u) if u.is_ole_frame() => ole_frame(&u.tags).map_or(Bounds2::EMPTY, Bounds2::from_points),
        kind => {
            let mut b = Bounds2::EMPTY;
            for p in kind.prims() {
@@ -713,41 +473,6 @@ mod tests {
        assert!(bounds(EntityKind::MLeader(empty)).max.x < 26.0);
    }

-    /// An OLE2FRAME counts in the extents through its corner tags (#2422); a missing or
-    /// non-finite corner counts as nothing.
-    #[test]
-    fn ole_frame_counts_in_extents() {
-        let tag = |code: i32, value: &str| crate::RawTag { code, value: value.into() };
-        let frame = |tags: Vec<crate::RawTag>| EntityKind::Unknown(crate::Unknown { dxf_type: "OLE2FRAME".into(), tags });
-        let b = bounds(frame(vec![tag(10, "30"), tag(20, "-19"), tag(11, "35"), tag(21, "-22")]));
-        assert_eq!((b.min, b.max), (Vec2::new(30.0, -22.0), Vec2::new(35.0, -19.0)));
-        assert!(bounds(frame(vec![tag(10, "1"), tag(20, "2")])).is_empty(), "one corner is not a frame");
-        assert!(bounds(frame(vec![tag(10, "NaN"), tag(20, "0"), tag(11, "1"), tag(21, "inf")])).is_empty());
-        assert!(bounds(EntityKind::Unknown(crate::Unknown { dxf_type: "OTHER".into(), tags: vec![tag(10, "5"), tag(20, "5")] })).is_empty());
-    }
-
-    /// Groups 10/20 inside an application-defined `102 {...}` group belong to the application, not
-    /// to the frame: the real corners come after it (review on #2587).
-    #[test]
-    fn ole_frame_skips_application_groups() {
-        let tag = |code: i32, value: &str| crate::RawTag { code, value: value.into() };
-        let tags = vec![
-            tag(102, "{ACAD_REACTORS"),
-            tag(10, "900"),
-            tag(20, "900"),
-            tag(11, "901"),
-            tag(21, "901"),
-            tag(102, "}"),
-            tag(10, "30"),
-            tag(20, "-19"),
-            tag(11, "35"),
-            tag(21, "-22"),
-        ];
-        let q = ole_frame(&tags).expect("frame");
-        assert_eq!((q[0], q[2]), (Vec2::new(30.0, -19.0), Vec2::new(35.0, -22.0)));
-        assert!(ole_frame(&tags[..6]).is_none(), "corners only inside the group are not a frame");
-    }
-
    #[test]
    fn a_shared_block_cache_measures_as_a_fresh_one_for_each_entity() {
        let line = |a: (f64, f64), b: (f64, f64), layer: &str| {
@@ -797,322 +522,4 @@ mod tests {
            assert!(extents.width() > drawn.width());
        }
    }
-
-    /// A turned array of references reaches its side copies, not only the first and the last;
-    /// a hostile count measures only the copies that are drawn.
-    #[test]
-    fn a_rotated_array_counts_every_corner_copy() {
-        let mut d = Drawing::new_metric();
-        let mut b = crate::Block::new("B");
-        b.entities.push(Entity::new(crate::Handle(1), EntityKind::Line(crate::Line { a: Vec3::ZERO, b: Vec3::new(1.0, 0.0, 0.0) })));
-        d.blocks.insert("B".into(), std::sync::Arc::new(b));
-        let array = |cols: u32, rows: u32, rotation: f64| {
-            let ins = crate::Insert {
-                block: "B".into(),
-                scale: Vec3::new(1.0, 1.0, 1.0),
-                rotation,
-                cols,
-                rows,
-                col_spacing: 10.0,
-                row_spacing: 10.0,
-                ..crate::Insert::default()
-            };
-            Entity::new(crate::Handle(2), EntityKind::Insert(ins))
-        };
-        // Turned 45°: the copies sit at (0, 0), (7.07, 7.07), (-7.07, 7.07) and (0, 14.14).
-        let b = entity_bounds(&d, &array(2, 2, std::f64::consts::FRAC_PI_4), 0);
-        let side = 10.0 * std::f64::consts::FRAC_1_SQRT_2;
-        assert!((b.min.x + side).abs() < 1e-9 && b.max.x >= side, "{b:?}");
-        assert!((b.max.y - 2.0 * side - std::f64::consts::FRAC_1_SQRT_2).abs() < 1e-9, "{b:?}");
-        // The renderer draws at most 10,000 columns.
-        let b = entity_bounds(&d, &array(u32::MAX, 1, 0.0), 0);
-        assert!((b.max.x - (10.0 * 9_999.0 + 1.0)).abs() < 1e-6, "{b:?}");
-    }
-
-    /// An OLE2FRAME at large coordinates, with its OLE data header holding the frame's corners
-    /// shifted by `dx` in x.
-    fn big_frame(dx: f64) -> Vec<crate::RawTag> {
-        let (x1, y1, x2, y2) = (1e9, 1e9, 1e9 + 10.0, 1e9 + 5.0);
-        let mut blob = vec![1u8, 0];
-        for (x, y) in [(x1, y1), (x2, y1), (x2, y2), (x1, y2)] {
-            for v in [x + dx, y, 7.0] {
-                blob.extend_from_slice(&v.to_le_bytes());
-            }
-        }
-        let tag = |code: i32, value: String| crate::RawTag { code, value };
-        vec![
-            tag(10, x1.to_string()),
-            tag(20, y1.to_string()),
-            tag(11, x2.to_string()),
-            tag(21, y2.to_string()),
-            tag(310, blob.iter().map(|b| format!("{b:02X}")).collect()),
-        ]
-    }
-
-    /// The x of the first corner in the OLE data of a [`big_frame`].
-    fn data_x(tags: &[crate::RawTag]) -> f64 {
-        let hex = tags.last().map(|t| t.value.as_str()).unwrap_or_default();
-        let bytes: Vec<u8> = (0..hex.len() / 2).filter_map(|i| u8::from_str_radix(hex.get(2 * i..2 * i + 2)?, 16).ok()).collect();
-        bytes.get(2..10).and_then(|s| <[u8; 8]>::try_from(s).ok()).map(f64::from_le_bytes).unwrap_or(f64::NAN)
-    }
-
-    /// The match between the frame and the corners in its OLE data does not loosen with the
-    /// coordinate: half a unit off at 1e9 is not the frame, so the bytes stay as they are (review
-    /// on #2587).
-    #[test]
-    fn a_half_unit_offset_at_large_coordinates_is_not_the_frame() {
-        let mut tags = big_frame(0.5);
-        let before = tags.last().cloned();
-        ole_frame_transform(&mut tags, &cadcraft_geom::Mat3::translate(Vec2::new(1.0, 1.0)));
-        assert_eq!(tags.first().map(|t| t.value.as_str()), Some("1000000001"), "the frame tags move");
-        assert_eq!(tags.last().map(|t| &t.value), before.as_ref().map(|t| &t.value), "the 310 bytes stay identical");
-    }
-
-    #[test]
-    fn exact_corners_at_large_coordinates_still_move() {
-        let mut tags = big_frame(0.0);
-        ole_frame_transform(&mut tags, &cadcraft_geom::Mat3::translate(Vec2::new(1.0, 1.0)));
-        assert_eq!(data_x(&tags), 1e9 + 1.0);
-    }
-
-    /// A translation, and a uniform positive scale about any point, keep a frame axis aligned and
-    /// upper-left; a rotation, a mirror, a non-uniform or non-positive scale do not.
-    #[test]
-    fn ole_frame_accepts_translations_and_uniform_positive_scales_only() {
-        use cadcraft_geom::Mat3;
-        let p = Vec2::new(3.0, -4.0);
-        assert!(ole_frame_accepts(&Mat3::translate(p)));
-        assert!(ole_frame_accepts(&Mat3::scale_about(p, 2.5)));
-        assert!(ole_frame_accepts(&Mat3::scale_about(p, 1e-3)));
-        assert!(!ole_frame_accepts(&Mat3::scale(2.0, 3.0)));
-        assert!(!ole_frame_accepts(&Mat3::scale_about(p, -1.0)));
-        assert!(!ole_frame_accepts(&Mat3::scale_about(p, 0.0)));
-        assert!(!ole_frame_accepts(&Mat3::rotate_about(p, 0.5)));
-        assert!(!ole_frame_accepts(&Mat3::mirror(Vec2::new(0.0, 0.0), Vec2::new(1.0, 0.0))));
-    }
-    /// ALIGN with a scale builds its matrix from two angles that agree only to rounding, so a large
-    /// scale leaves a rotation part of about `scale * 1e-16`. That is a scale, not a turn: the
-    /// tolerance for it grows with the scale, while a real turn is still refused (review on #2587).
-    #[test]
-    fn ole_frame_accepts_a_large_scale_with_rounding_noise_in_its_rotation() {
-        use cadcraft_geom::Mat3;
-        let p = Vec2::new(3.0, -4.0);
-        let noisy = Mat3::scale_about(p, 1e6).then_before(Mat3::rotate_about(p, 2e-16));
-        assert!(noisy.b.abs() > 1e-12, "the setup must exceed an absolute tolerance: {}", noisy.b);
-        assert!(ole_frame_accepts(&noisy));
-        let turned = Mat3::scale_about(p, 1e6).then_before(Mat3::rotate_about(p, 1e-6));
-        assert!(!ole_frame_accepts(&turned));
-    }
-
-    /// The corners (x, y) in the OLE data header of a frame built by [`big_frame`]-style tags.
-    fn header_corners(tags: &[crate::RawTag]) -> Vec<(f64, f64)> {
-        let hex: String = tags.iter().filter(|t| t.code == 310).map(|t| t.value.as_str()).collect();
-        let bytes: Vec<u8> = (0..hex.len() / 2).filter_map(|i| u8::from_str_radix(hex.get(2 * i..2 * i + 2)?, 16).ok()).collect();
-        let f = |o: usize| bytes.get(o..o + 8).and_then(|s| <[u8; 8]>::try_from(s).ok()).map(f64::from_le_bytes).unwrap_or(f64::NAN);
-        (0..4).map(|c| (f(2 + c * 24), f(10 + c * 24))).collect()
-    }
-
-    fn small_frame() -> Vec<crate::RawTag> {
-        let mut blob = vec![1u8, 0];
-        for (x, y) in [(30.0f64, -19.0f64), (35.0, -19.0), (35.0, -22.0), (30.0, -22.0)] {
-            for v in [x, y, 7.0] {
-                blob.extend_from_slice(&v.to_le_bytes());
-            }
-        }
-        let tag = |code: i32, value: &str| crate::RawTag { code, value: value.into() };
-        vec![
-            tag(10, "30"),
-            tag(20, "-19"),
-            tag(11, "35"),
-            tag(21, "-22"),
-            crate::RawTag { code: 310, value: blob.iter().map(|b| format!("{b:02X}")).collect() },
-        ]
-    }
-
-    /// Internal callers (EXPLODE, REFEDIT, paste, array placement) transform a frame by any matrix.
-    /// It stays axis aligned: groups 10/20 are the upper-left of its box, 11/21 the lower-right,
-    /// and the OLE data holds the same box (review on #2587). A mirror keeps the axes, so the box
-    /// is that of the mapped corners; a 30° turn keeps the frame's own 5 x 3 about its turned
-    /// centre, where the corners' box would flatten it.
-    #[test]
-    fn a_rotated_frame_stays_axis_aligned_and_consistent() {
-        use cadcraft_geom::Mat3;
-        let rotate = Mat3::rotate_about(Vec2::new(1.0, 2.0), 30f64.to_radians());
-        let mirror = Mat3::mirror(Vec2::new(0.0, 0.0), Vec2::new(1.0, 0.0));
-        for (m, turned) in [(rotate, true), (mirror, false)] {
-            let mut tags = small_frame();
-            let mapped = if turned {
-                let c = m.apply(Vec2::new(32.5, -20.5));
-                [c - Vec2::new(2.5, 1.5), c + Vec2::new(2.5, 1.5)]
-            } else {
-                [m.apply(Vec2::new(30.0, -19.0)), m.apply(Vec2::new(35.0, -22.0))]
-            };
-            let (minx, maxx) = (mapped[0].x.min(mapped[1].x), mapped[0].x.max(mapped[1].x));
-            let (miny, maxy) = (mapped[0].y.min(mapped[1].y), mapped[0].y.max(mapped[1].y));
-            ole_frame_transform(&mut tags, &m);
-            let g = |code: i32| tags.iter().find(|t| t.code == code).and_then(|t| t.value.parse::<f64>().ok()).unwrap_or(f64::NAN);
-            assert_eq!((g(10), g(20), g(11), g(21)), (minx, maxy, maxx, miny));
-            assert_eq!(header_corners(&tags), vec![(minx, maxy), (maxx, maxy), (maxx, miny), (minx, miny)]);
-        }
-    }
-    /// `from_str_radix` accepts a leading sign, so "+A" must not count as a hex byte (review on
-    /// #2587): data with one is not valid and MOVE leaves its bytes alone.
-    #[test]
-    fn a_plus_sign_in_ole_data_is_not_hex() {
-        let mut tags = small_frame();
-        let hex = tags.last().map(|t| t.value.clone()).unwrap_or_default();
-        // The marker's first byte is 01: "+1" would decode to the same byte.
-        let signed = format!("+1{}", hex.get(2..).unwrap_or_default());
-        if let Some(t) = tags.last_mut() {
-            t.value = signed.clone();
-        }
-        ole_frame_transform(&mut tags, &cadcraft_geom::Mat3::translate(Vec2::new(10.0, 5.0)));
-        assert_eq!(tags.first().map(|t| t.value.as_str()), Some("40"), "the frame tags still move");
-        assert_eq!(tags.last().map(|t| t.value.as_str()), Some(signed.as_str()));
-    }
-
-    /// A payload of 1,000 groups of 127 bytes: only the group(s) holding the 98-byte header are
-    /// rewritten. Later groups stay as they were, even ones that are not valid hex or have padding
-    /// (the old code re-encoded the whole payload and gave up on any bad group).
-    #[test]
-    fn a_large_ole_payload_only_rewrites_its_leading_groups() {
-        let mut tags = small_frame();
-        let first = tags.pop().map(|t| t.value).unwrap_or_default();
-        let mut head = first.clone();
-        // Fill the first group up to 127 bytes.
-        head.push_str(&"ab".repeat(127 - first.len() / 2));
-        tags.push(crate::RawTag { code: 310, value: head });
-        for g in 1..1000 {
-            let value = match g {
-                2 => format!("  {}  ", "Ab".repeat(127)),
-                500 => "ZZ".repeat(127),
-                _ => "ab".repeat(127),
-            };
-            tags.push(crate::RawTag { code: 310, value });
-        }
-        let rest: Vec<String> = tags.iter().skip(5).map(|t| t.value.clone()).collect();
-        ole_frame_transform(&mut tags, &cadcraft_geom::Mat3::translate(Vec2::new(10.0, 5.0)));
-        assert_eq!(header_corners(&tags[..5]), vec![(40.0, -14.0), (45.0, -14.0), (45.0, -17.0), (40.0, -17.0)]);
-        let after: Vec<String> = tags.iter().skip(5).map(|t| t.value.clone()).collect();
-        assert_eq!(after, rest, "every group after the first is string-identical");
-        assert_eq!(tags.get(4).map(|t| t.value.len()), Some(254), "the first group keeps its length");
-    }
-
-    /// Above about 8.6e9 one ulp of an f64 is more than the fixed ceiling on the corner match, so a
-    /// text corner one ulp from the header double must still count as the same corner (review on
-    /// #2587).
-    #[test]
-    fn ole_frame_moves_at_2e10_with_a_one_ulp_text_corner() {
-        let mut tags = big_frame(0.0);
-        // Rebuild the frame at 2e10: the header keeps the exact corners, the text is one ulp off.
-        let (x1, y1, x2, y2) = (2e10f64, 2e10f64, 2e10 + 10.0, 2e10 + 5.0);
-        let mut blob = vec![1u8, 0];
-        for (x, y) in [(x1, y1), (x2, y1), (x2, y2), (x1, y2)] {
-            for v in [x, y, 7.0] {
-                blob.extend_from_slice(&v.to_le_bytes());
-            }
-        }
-        let text_x1 = f64::from_bits(x1.to_bits() + 1);
-        tags[0].value = text_x1.to_string();
-        tags[1].value = y1.to_string();
-        tags[2].value = x2.to_string();
-        tags[3].value = y2.to_string();
-        if let Some(t) = tags.last_mut() {
-            t.value = blob.iter().map(|b| format!("{b:02X}")).collect();
-        }
-        ole_frame_transform(&mut tags, &cadcraft_geom::Mat3::translate(Vec2::new(1e4, 1e4)));
-        assert_eq!(header_corners(&tags)[0].0, text_x1 + 1e4, "the header moved with the frame");
-    }
-
-    /// Below scale 1 the rotation bound is still relative to the scale: a small real turn at a tiny
-    /// scale is refused, and so is a non-uniform scale whose two factors differ by more than a
-    /// relative 1e-12 (review on #2587).
-    #[test]
-    fn ole_frame_refuses_a_small_turn_at_a_tiny_scale() {
-        use cadcraft_geom::Mat3;
-        let p = Vec2::new(3.0, -4.0);
-        let turned = Mat3::scale_about(p, 1e-9).then_before(Mat3::rotate_about(p, 0.05f64.to_radians()));
-        assert!(!ole_frame_accepts(&turned));
-        assert!(ole_frame_accepts(&Mat3::scale_about(p, 1e-9)));
-        assert!(!ole_frame_accepts(&Mat3::scale(1e-6, 1e-6 + 5e-13)));
-    }
-
-    /// Hex digits keep the case they had: bytes the transform does not change come back as the
-    /// identical text, also in a group that mixes upper and lower case (review on #2587).
-    #[test]
-    fn moving_an_ole_frame_keeps_each_hex_digits_case() {
-        let mut tags = small_frame();
-        let old = tags.last().map(|t| t.value.clone()).unwrap_or_default();
-        let mixed: String = old.chars().enumerate().map(|(i, c)| if i < 24 { c.to_ascii_lowercase() } else { c }).collect();
-        assert_ne!(mixed, old);
-        if let Some(t) = tags.last_mut() {
-            t.value = mixed.clone();
-        }
-        ole_frame_transform(&mut tags, &cadcraft_geom::Mat3::translate(Vec2::new(10.0, 5.0)));
-        let new = tags.last().map(|t| t.value.clone()).unwrap_or_default();
-        assert_eq!(new.len(), mixed.len());
-        let byte = |s: &str, i: usize| s.get(2 * i..2 * i + 2).and_then(|h| u8::from_str_radix(h, 16).ok());
-        let mut same = 0;
-        for i in 0..mixed.len() / 2 {
-            if byte(&mixed, i) == byte(&new, i) {
-                same += 1;
-                assert_eq!(mixed.get(2 * i..2 * i + 2), new.get(2 * i..2 * i + 2), "byte {i}");
-            }
-        }
-        assert!(same > 40, "most of the header is unchanged: {same}");
-        assert_eq!(header_corners(&tags)[0], (40.0, -14.0));
-    }
-
-    /// A frame from `(x1, y1)` (upper left) to `(x2, y2)` (lower right), its OLE header holding the
-    /// same corners.
-    fn frame_at(x1: f64, y1: f64, x2: f64, y2: f64) -> Vec<crate::RawTag> {
-        let mut blob = vec![1u8, 0];
-        for (x, y) in [(x1, y1), (x2, y1), (x2, y2), (x1, y2)] {
-            for v in [x, y, 0.0] {
-                blob.extend_from_slice(&v.to_le_bytes());
-            }
-        }
-        let tag = |code: i32, value: String| crate::RawTag { code, value };
-        vec![
-            tag(10, x1.to_string()),
-            tag(20, y1.to_string()),
-            tag(11, x2.to_string()),
-            tag(21, y2.to_string()),
-            tag(310, blob.iter().map(|b| format!("{b:02X}")).collect()),
-        ]
-    }
-
-    fn size(tags: &[crate::RawTag]) -> (f64, f64, Vec2) {
-        let o = ole_frame(tags).unwrap();
-        let b = Bounds2::from_points(o);
-        (b.width(), b.height(), b.center())
-    }
-
-    /// A frame turned by an angle that isn't a quarter turn keeps its size about its turned
-    /// centre instead of collapsing to the box of its two corners (a 10 x 10 square turned 45°
-    /// became 14.14 x 0), and the OLE header follows (#2587 review).
-    #[test]
-    fn a_frame_turned_off_the_axes_keeps_its_size() {
-        use cadcraft_geom::Mat3;
-        let close = |a: f64, b: f64| (a - b).abs() < 1e-9;
-        let mut tags = frame_at(0.0, 10.0, 10.0, 0.0);
-        ole_frame_transform(&mut tags, &Mat3::rotate(std::f64::consts::FRAC_PI_4));
-        let (w, h, c) = size(&tags);
-        assert!(close(w, 10.0) && close(h, 10.0), "{w} x {h}");
-        assert!(close(c.x, 0.0) && close(c.y, 50f64.sqrt()), "{c:?}");
-        let (ul, lr) = (header_corners(&tags)[0], header_corners(&tags)[2]);
-        assert!(close(ul.0, -5.0) && close(lr.1, 50f64.sqrt() - 5.0), "the header follows: {ul:?} {lr:?}");
-        // Nearer a quarter turn, the sides swap: a 10 wide, 4 tall frame turned 100° is 4 x 10.
-        let mut tags = frame_at(0.0, 4.0, 10.0, 0.0);
-        ole_frame_transform(&mut tags, &Mat3::rotate(100f64.to_radians()));
-        let (w, h, _) = size(&tags);
-        assert!(close(w, 4.0) && close(h, 10.0), "{w} x {h}");
-        // A turn and its inverse bring the frame back.
-        let mut tags = frame_at(2.0, 9.0, 7.0, 3.0);
-        let m = Mat3::rotate(0.3);
-        ole_frame_transform(&mut tags, &m);
-        ole_frame_transform(&mut tags, &m.inverse().unwrap());
-        let (w, h, c) = size(&tags);
-        assert!(close(w, 5.0) && close(h, 6.0) && close(c.x, 4.5) && close(c.y, 6.0), "{w} x {h} at {c:?}");
-    }
 }
@@ -55,8 +55,6 @@ impl ForeignExtra {
 pub struct Foreign {
    /// CLASS records (groups after `0 CLASS`) of the kept objects' and entities' types.
    pub classes: Vec<Vec<RawTag>>,
-    /// Classes retain every source position, including duplicate names.
-    pub complete_class_table: bool,
    /// Kept objects, in file order.
    pub objects: Vec<ForeignObject>,
    /// Entries of the named object dictionary that CADCraft doesn't write itself: (key, object).
@@ -77,19 +75,9 @@ pub struct Foreign {
    /// surfaces, which from 2013 on those entities don't carry themselves: each `ACDSRECORD`
    /// names its entity with a 320 handle (see [`Foreign::data_store_entities`]).
    pub data_store: Vec<RawTag>,
-    /// The `$ACADVER` of the file all this was read from: its groups are in that version's form.
-    /// The drawing's own `$ACADVER` is the version it is saved as, which SAVEAS changes, so a
-    /// later save must not take it for this one (#2471).
-    pub version: Option<String>,
 }

 impl Foreign {
-    /// The class of the file's CLASSES a proxy's group 91 names (see [`class_number`]), if any.
-    /// Saving as DWG keeps a proxy with that class and leaves out one whose class it can't name.
-    pub fn proxy_class(&self, tags: &[RawTag]) -> Option<&str> {
-        class_index(class_number(tags.iter().map(|r| (r.code, r.value.as_str())))).and_then(|i| self.class_order.get(i)).map(String::as_str)
-    }
-
    pub fn is_empty(&self) -> bool {
        self.objects.is_empty()
            && self.dictionary.is_empty()
@@ -268,29 +256,3 @@ impl Foreign {
        }
    }
 }
-
-/// Where a proxy's class number is: its first group 91 outside the `102 {NAME` … `102 }` groups
-/// (an application's can hold a 91 of its own) and before any xdata.
-pub fn class_group<S: AsRef<str>>(groups: impl IntoIterator<Item = (i32, S)>) -> Option<usize> {
-    let mut in_group = false;
-    for (i, (code, value)) in groups.into_iter().enumerate() {
-        match code {
-            1000.. => return None,
-            102 => in_group = value.as_ref().trim().starts_with('{'),
-            91 if !in_group => return Some(i),
-            _ => {}
-        }
-    }
-    None
-}
-
-/// A proxy's class number (see [`class_group`]).
-pub fn class_number<S: AsRef<str>>(groups: impl IntoIterator<Item = (i32, S)> + Clone) -> Option<i64> {
-    let i = class_group(groups.clone())?;
-    groups.into_iter().nth(i).and_then(|(_, v)| v.as_ref().trim().parse().ok())
-}
-
-/// The place in CLASSES a class number names (500 is the first class).
-pub fn class_index(number: Option<i64>) -> Option<usize> {
-    usize::try_from(number?.checked_sub(500)?).ok()
-}
@@ -90,23 +90,6 @@ impl Header {
            .filter(|p| p.is_finite() && if allow_zero { p.x >= 0.0 && p.y >= 0.0 } else { p.x > 0.0 && p.y > 0.0 })
            .unwrap_or(Vec2::new(0.5, 0.5))
    }
-    /// The model view the drawing was saved at: `$VIEWCTR` (centre) and `$VIEWSIZE` (height, in
-    /// drawing units), when both are present and usable. A DXF file keeps the pair in HEADER and
-    /// repeats it in the `*ACTIVE` VPORT record (12/22 and 40); a reader opens the drawing on it
-    /// rather than on the extents, so a drawing saved on one detail of a large sheet opens there.
-    pub fn saved_view(&self) -> Option<(Vec2, f64)> {
-        let center = self.point("VIEWCTR")?.xy();
-        let height = self.get("VIEWSIZE").and_then(HVal::as_f64)?;
-        (center.is_finite() && height.is_finite() && height > 1e-9).then_some((center, height))
-    }
-    /// Record the view the drawing is saved at (see [`Header::saved_view`]). A view that cannot
-    /// be shown is not recorded, so a usable stored view is never replaced by an unusable one.
-    pub fn set_saved_view(&mut self, center: Vec2, height: f64) {
-        if center.is_finite() && height.is_finite() && height > 1e-9 {
-            self.set("VIEWCTR", HVal::Point(center.to3(0.0)));
-            self.set_f64("VIEWSIZE", height);
-        }
-    }
    pub fn set_f64(&mut self, name: &str, v: f64) {
        self.set(name, HVal::Real(v));
    }
@@ -29,10 +29,7 @@ pub use cadcraft_color as color;
 pub use cadcraft_geom as geom;
 pub use constraint::*;
 pub use entity::*;
-pub use extents::{
-    BlockBoundsCache, MAX_BLOCK_DEPTH, entity_bounds, entity_bounds_cached, extent_bounds, extent_bounds_cached, ole_frame, ole_frame_accepts,
-    ole_frame_transform,
-};
+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};
@@ -486,24 +486,16 @@ impl DimStyle {

    /// Set fields from a JSON object of field or DIM* variable names (numbers, booleans as
    /// 0/1, colours as ACI numbers or names). Returns the names that were not recognised or
-    /// had unusable values. When several spellings name one field, the last one wins and the
-    /// superseded ones are not validated.
+    /// had unusable values.
    pub fn apply_fields(&mut self, src: &serde_json::Map<String, serde_json::Value>) -> Vec<String> {
        use serde_json::Value;
        let mut rejected = Vec::new();
        let Ok(mut cur) = serde_json::to_value(&*self) else { return src.keys().cloned().collect() };
-        // Spellings of one field (`DIMPOST`, `dimpost`, `textPrefix`…): only the last is applied, so
-        // the style is checked once per field, not once per spelling (each check copies its strings).
-        let last_spelling: std::collections::HashMap<&str, &String> =
-            src.keys().filter_map(|k| DimStyle::field_name(k).filter(|f| *f != "name").map(|f| (f, k))).collect();
        for (k, v) in src {
            let Some(field) = DimStyle::field_name(k).filter(|f| *f != "name") else {
                rejected.push(k.clone());
                continue;
            };
-            if last_spelling.get(field) != Some(&k) {
-                continue;
-            }
            let Some(obj) = cur.as_object_mut() else { break };
            let Some(old) = obj.get(field).cloned() else {
                rejected.push(k.clone());
@@ -807,13 +799,6 @@ 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,
-    /// Paper size (DXF groups 44, 45) and plot rotation (group 73) as the file stored them.
-    /// Saving writes them back while they still describe `width_mm`, `height_mm` and
-    /// `landscape`, so each program's convention for media defined wider than tall survives a
-    /// round trip: AutoCAD stores a portrait size and a quarter turn, ZWCAD the media's own size
-    /// and no turn (#1463). `None` for page setups made in CADCraft.
-    #[serde(skip)]
-    pub file_paper: Option<(f64, f64, i64)>,
    /// 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")]
@@ -839,7 +824,6 @@ impl Default for PageSetup {
            show_plot_styles: false,
            plot_transparency: false,
            paper_mm: false,
-            file_paper: None,
            image_origin: None,
        }
    }
@@ -714,14 +714,3 @@ fn space_names_its_tab() {
    assert_eq!(p.layout(), Some("Sheet A"));
    assert_eq!(p.tab_name(), "Sheet A");
 }
-
-/// Several spellings of one DIM field apply once, the last in the map's order, and none is rejected.
-#[test]
-fn dim_style_spellings_of_one_field_apply_once() {
-    let mut st = DimStyle::default();
-    let m = serde_json::json!({ "textHeight": 2.5, "TEXTHEIGHT": 3.5, "DIMTXT": 4.5 });
-    let m = m.as_object().unwrap();
-    let want = m.values().next_back().and_then(serde_json::Value::as_f64).unwrap();
-    assert!(st.apply_fields(m).is_empty());
-    assert_eq!(st.text_height, want);
-}
@@ -0,0 +1,19 @@
+[package]
+name = "cadcraft-dwg"
+description = "CADCraft DWG bridge: converts DWG to and from DXF bytes using the acadrust crate (MPL-2.0, used unmodified)"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+log = { workspace = true }
+
+# The same targets as build.rs's `no_dwg_bridge` leave acadrust out: wasm32, and FreeBSD aarch64,
+# where acadrust 0.6.6 passes a `*const c_char` (u8 there) to its own `*const i8` sysctlbyname.
+# 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.6"
@@ -0,0 +1,12 @@
+//! Sets `no_dwg_bridge` on the targets built without acadrust (see Cargo.toml): the DWG functions
+//! there return an error that says to use DXF.
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo::rustc-check-cfg=cfg(no_dwg_bridge)");
+    let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
+    let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    if arch == "wasm32" || (os == "freebsd" && arch == "aarch64") {
+        println!("cargo::rustc-cfg=no_dwg_bridge");
+    }
+}
@@ -0,0 +1,333 @@
+//! The DWG reader and writer in a child process.
+//!
+//! An allocation failure or stack overflow in the third-party code ends the process it runs in, and
+//! `catch_unwind` can't stop that. So the app runs them in a copy of itself: [`use_own_worker`] says
+//! how to start one, and [`serve_if_asked`], first thing in `main`, turns the copy into a worker
+//! that reads one request from standard input and writes one reply to standard output. A file that
+//! kills the worker then costs that one open or save, and every other open drawing stays safe.
+//!
+//! Without a worker (libraries, tests, a build that can't start one) [`decode`] and [`encode_as`]
+//! run in the calling process, as they always did. There's no memory limit on the worker yet: that
+//! takes per-platform system calls, which `unsafe_code = "forbid"` keeps out of this crate.
+//!
+//! A reply comes from a process that just handled a possibly hostile file, so it is parsed as
+//! untrusted input.
+
+use std::ffi::OsString;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::sync::Mutex;
+use std::sync::mpsc::{RecvTimeoutError, channel};
+use std::time::Duration;
+
+use super::Limits;
+
+/// The argument that makes the app a worker.
+pub const WORKER_ARG: &str = "--dwg-worker";
+/// Bumped when the messages change: an app updated while running may start a newer copy.
+const PROTOCOL: u8 = 1;
+const DECODE: u8 = 1;
+const ENCODE: u8 = 2;
+const CRASH: u8 = 0xff;
+/// How long one file may take before the worker is stopped. It can't be interrupted otherwise.
+const TIMEOUT: Duration = Duration::from_secs(30 * 60);
+/// Most bytes accepted for what a reply carries besides the drawing.
+const MAX_NOTES_BYTES: u64 = 64 << 20;
+/// Most bytes accepted as a written DWG.
+const MAX_DWG_REPLY: u64 = 2 << 30;
+/// Most bytes one request holds: the largest input, whichever the direction, and its header.
+const MAX_REQUEST: u64 = (2 << 30) + 256;
+
+struct Worker {
+    program: PathBuf,
+    args: Vec<OsString>,
+}
+
+static WORKER: Mutex<Option<Worker>> = Mutex::new(None);
+
+/// Start `program args` as the worker from now on. `program` must call [`serve_if_asked`].
+pub fn use_worker(program: PathBuf, args: Vec<OsString>) {
+    if let Ok(mut w) = WORKER.lock() {
+        *w = Some(Worker { program, args });
+    }
+}
+
+/// Use a copy of this program as the worker, started with [`WORKER_ARG`]. If its path can't be
+/// found, the reader and writer stay in this process.
+pub fn use_own_worker() {
+    match std::env::current_exe() {
+        Ok(program) => use_worker(program, vec![WORKER_ARG.into()]),
+        Err(e) => log::warn!("DWG worker: can't find this program: {e}"),
+    }
+}
+
+/// Serve one request and return the exit code if this process was started as a worker.
+pub fn serve_if_asked() -> Option<i32> {
+    (std::env::args_os().nth(1)? == WORKER_ARG).then(|| serve(std::io::stdin().lock(), std::io::stdout().lock()))
+}
+
+/// [`super::dwg_to_dxf_noted`] in the worker, when there is one.
+pub fn decode(bytes: &[u8], limits: Limits) -> Result<(Vec<u8>, Vec<String>), String> {
+    // Before starting a process, and so the same limit holds with or without one.
+    if bytes.len() > limits.max_dwg_bytes {
+        return super::dwg_to_dxf_noted(bytes, limits);
+    }
+    let reply_limit = (limits.max_dxf_bytes as u64).saturating_add(MAX_NOTES_BYTES);
+    match call(&request(DECODE, limits, ""), bytes, reply_limit, "reading this file") {
+        Some(reply) => reply?,
+        None => super::dwg_to_dxf_noted(bytes, limits),
+    }
+}
+
+/// [`super::dxf_to_dwg_as`] in the worker, when there is one.
+pub fn encode_as(dxf: &[u8], version: &str) -> Result<Vec<u8>, String> {
+    encode_noted(dxf, version).map(|(dwg, _)| dwg)
+}
+
+/// [`super::dxf_to_dwg_noted`] in the worker, when there is one. What the writer left out comes
+/// back as notes of `TYPE<tab>count`.
+pub fn encode_noted(dxf: &[u8], version: &str) -> Result<(Vec<u8>, super::Unwritten), String> {
+    if u8::try_from(version.len()).is_err() {
+        return Err(super::unsupported(version));
+    }
+    match call(&request(ENCODE, Limits::DEFAULT, version), dxf, MAX_DWG_REPLY, "writing this file") {
+        Some(reply) => reply?.map(|(dwg, notes)| (dwg, unwritten_from(&notes))),
+        None => super::dxf_to_dwg_noted(dxf, version),
+    }
+}
+
+fn unwritten_from(notes: &[String]) -> super::Unwritten {
+    notes.iter().filter_map(|n| n.split_once('\t')).filter_map(|(kind, n)| Some((kind.to_string(), n.parse::<usize>().ok()?))).fold(
+        super::Unwritten::new(),
+        |mut m, (kind, n)| {
+            *m.entry(kind).or_insert(0) = n;
+            m
+        },
+    )
+}
+
+/// Make the worker abort, as the third-party code can: what the tests prove isolation with.
+#[doc(hidden)]
+pub fn crash_worker_for_test() -> Result<(), String> {
+    call(&request(CRASH, Limits::DEFAULT, ""), &[], 1024, "testing").ok_or("no worker")??.map(|_| ())
+}
+
+fn request(op: u8, limits: Limits, version: &str) -> Vec<u8> {
+    let mut r = vec![PROTOCOL, op];
+    r.extend((limits.max_dwg_bytes as u64).to_le_bytes());
+    r.extend((limits.max_dxf_bytes as u64).to_le_bytes());
+    r.push(u8::try_from(version.len()).unwrap_or(0));
+    r.extend(version.as_bytes());
+    r
+}
+
+type Reply = Result<(Vec<u8>, Vec<String>), String>;
+
+/// Run one request in a worker. `None`: none could be started, so the caller does the work.
+/// `Err`: the worker went wrong, and `doing` says at what, for the user.
+fn call(header: &[u8], payload: &[u8], reply_limit: u64, doing: &str) -> Option<Result<Reply, String>> {
+    let mut command = {
+        let worker = WORKER.lock().ok()?;
+        let worker = worker.as_ref()?;
+        let mut c = Command::new(&worker.program);
+        c.args(&worker.args);
+        c
+    };
+    command.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null());
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+        command.creation_flags(CREATE_NO_WINDOW);
+    }
+    let mut child = match command.spawn() {
+        Ok(c) => c,
+        Err(e) => {
+            log::warn!("DWG worker: can't start it: {e}");
+            return None;
+        }
+    };
+    let (Some(mut to_child), Some(from_child)) = (child.stdin.take(), child.stdout.take()) else {
+        let _ = child.kill();
+        let _ = child.wait();
+        return None;
+    };
+    let received = std::thread::scope(|scope| {
+        // Written beside the read: a worker that replies before it has read everything, or dies,
+        // must block neither side. A failed write shows up as the reply going wrong.
+        scope.spawn(move || {
+            let _ = to_child.write_all(header).and_then(|()| to_child.write_all(payload));
+        });
+        let (tx, rx) = channel();
+        scope.spawn(move || {
+            let mut reply = Vec::new();
+            let read = from_child.take(reply_limit).read_to_end(&mut reply);
+            let _ = tx.send(read.map(|_| reply));
+        });
+        let received = rx.recv_timeout(TIMEOUT);
+        if matches!(received, Err(RecvTimeoutError::Timeout)) {
+            let _ = child.kill();
+        }
+        received
+    });
+    let status = child.wait();
+    let stopped = || format!("the DWG worker stopped while {doing}; nothing else is affected");
+    Some(match (received, status) {
+        (Err(RecvTimeoutError::Timeout), _) => Err(format!("{doing} took too long, so the DWG worker was stopped; nothing else is affected")),
+        (Ok(Ok(reply)), Ok(status)) if status.success() => parse_reply(reply).ok_or_else(stopped),
+        _ => Err(stopped()),
+    })
+}
+
+/// Take `n` bytes off the front of `b`.
+fn take<'a>(b: &mut &'a [u8], n: usize) -> Option<&'a [u8]> {
+    let (head, tail) = b.split_at_checked(n)?;
+    *b = tail;
+    Some(head)
+}
+
+fn take_u32(b: &mut &[u8]) -> Option<usize> {
+    let bytes: [u8; 4] = take(b, 4)?.try_into().ok()?;
+    usize::try_from(u32::from_le_bytes(bytes)).ok()
+}
+
+fn take_u64(b: &mut &[u8]) -> Option<u64> {
+    Some(u64::from_le_bytes(take(b, 8)?.try_into().ok()?))
+}
+
+/// A reply: 0, the note count, each note with its length, then the bytes with their length; or 1
+/// and a message. `None` when it isn't one, whole. Takes the reply, because the bytes can be most
+/// of the memory the app may use: they are kept, not copied.
+fn parse_reply(mut reply: Vec<u8>) -> Option<Reply> {
+    let total = reply.len();
+    let mut b = &reply[..];
+    match *take(&mut b, 1)?.first()? {
+        0 => {
+            let count = take_u32(&mut b)?;
+            let mut notes = Vec::new();
+            for _ in 0..count {
+                let n = take_u32(&mut b)?;
+                notes.push(String::from_utf8_lossy(take(&mut b, n)?).into_owned());
+            }
+            let n = usize::try_from(take_u64(&mut b)?).ok()?;
+            if b.len() != n {
+                return None;
+            }
+            reply.drain(..total - n);
+            Some(Ok((reply, notes)))
+        }
+        1 => Some(Err(String::from_utf8_lossy(b).into_owned())),
+        _ => None,
+    }
+}
+
+fn write_reply(out: &mut impl Write, reply: Reply) -> std::io::Result<()> {
+    match reply {
+        Ok((bytes, notes)) => {
+            out.write_all(&[0])?;
+            out.write_all(&u32::try_from(notes.len()).unwrap_or(0).to_le_bytes())?;
+            for note in &notes {
+                out.write_all(&u32::try_from(note.len()).unwrap_or(0).to_le_bytes())?;
+                if u32::try_from(note.len()).is_ok() {
+                    out.write_all(note.as_bytes())?;
+                }
+            }
+            out.write_all(&(bytes.len() as u64).to_le_bytes())?;
+            out.write_all(&bytes)?;
+        }
+        Err(e) => {
+            out.write_all(&[1])?;
+            out.write_all(e.as_bytes())?;
+        }
+    }
+    out.flush()
+}
+
+/// What a request asks for, or why it can't be served.
+fn handle(mut b: &[u8]) -> Reply {
+    let bad = || "the DWG worker got a request it can't read (a different CADCraft version?)".to_string();
+    if take(&mut b, 1).and_then(<[u8]>::first) != Some(&PROTOCOL) {
+        return Err(bad());
+    }
+    let op = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
+    let max_dwg_bytes = take_u64(&mut b).and_then(|n| usize::try_from(n).ok()).ok_or_else(bad)?;
+    let max_dxf_bytes = take_u64(&mut b).and_then(|n| usize::try_from(n).ok()).ok_or_else(bad)?;
+    let version_len = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
+    let version = take(&mut b, usize::from(version_len)).and_then(|v| std::str::from_utf8(v).ok()).ok_or_else(bad)?;
+    match op {
+        DECODE => super::dwg_to_dxf_noted(b, Limits { max_dwg_bytes, max_dxf_bytes }),
+        ENCODE => super::dxf_to_dwg_noted(b, version).map(|(dwg, left_out)| (dwg, left_out.iter().map(|(kind, n)| format!("{kind}\t{n}")).collect())),
+        CRASH => std::process::abort(),
+        _ => Err(bad()),
+    }
+}
+
+/// Serve the one request on `input`. The exit code is 0 unless the reply couldn't be sent.
+fn serve(input: impl Read, mut output: impl Write) -> i32 {
+    let mut request = Vec::new();
+    let reply = match input.take(MAX_REQUEST).read_to_end(&mut request) {
+        Ok(_) => handle(&request),
+        Err(e) => Err(format!("the DWG worker could not read its request: {e}")),
+    };
+    i32::from(write_reply(&mut output, reply).is_err())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn wire(reply: Reply) -> Vec<u8> {
+        let mut out = Vec::new();
+        write_reply(&mut out, reply).unwrap();
+        out
+    }
+
+    #[test]
+    fn what_the_writer_left_out_survives_the_reply() {
+        let notes = vec!["ACME_WIDGET\t2".to_string(), "not a count".to_string(), "X\tmany".to_string()];
+        assert_eq!(unwritten_from(&notes), [("ACME_WIDGET".to_string(), 2)].into_iter().collect());
+    }
+
+    #[test]
+    fn replies_round_trip() {
+        let ok: Reply = Ok((b"bytes".to_vec(), vec!["one".into(), "two é".into()]));
+        assert_eq!(parse_reply(wire(ok.clone())), Some(ok));
+        let failed: Reply = Err("DWG: no".into());
+        assert_eq!(parse_reply(wire(failed.clone())), Some(failed));
+    }
+
+    #[test]
+    fn a_reply_cut_short_or_made_up_is_refused() {
+        let whole = wire(Ok((b"bytes".to_vec(), vec!["note".into()])));
+        for n in 0..whole.len() {
+            assert_eq!(parse_reply(whole[..n].to_vec()), None, "cut at {n}");
+        }
+        assert_eq!(parse_reply(vec![7, 0, 0]), None);
+        // A note count far beyond what follows ends at the first missing note.
+        assert_eq!(parse_reply(vec![0, 0xff, 0xff, 0xff, 0xff]), None);
+        assert_eq!(parse_reply(vec![0, 1, 0, 0, 0, 0xff, 0xff, 0xff, 0xff]), None);
+    }
+
+    #[test]
+    fn a_request_it_cannot_read_is_an_error_not_a_crash() {
+        for request in [
+            &[][..],
+            &[PROTOCOL + 1, DECODE],
+            &[PROTOCOL],
+            &[PROTOCOL, DECODE, 1, 2, 3],
+            &[PROTOCOL, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ] {
+            assert!(handle(request).is_err(), "{request:?}");
+        }
+    }
+
+    #[test]
+    fn serving_reports_a_decode_failure_as_a_reply() {
+        let mut request = self::request(DECODE, Limits::DEFAULT, "");
+        request.extend(b"AC1032 not really a drawing");
+        let mut out = Vec::new();
+        assert_eq!(serve(&request[..], &mut out), 0);
+        assert!(matches!(parse_reply(out.clone()), Some(Err(_))), "{out:?}");
+    }
+}
@@ -0,0 +1,14 @@
+[package]
+name = "cadcraft-dxf"
+description = "Standalone DXF tag reader/writer (ASCII and binary, pre-2007 code pages), from the published DXF reference"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+thiserror = { workspace = true }
+log = { workspace = true }
+encoding_rs = { workspace = true }
@@ -0,0 +1,330 @@
+//! Text decoding for DXF files.
+//!
+//! R2007 (AC1021) and later DXF files are UTF-8. Older ones store text in the code page named by
+//! the `$DWGCODEPAGE` header variable (`ANSI_1252`, `ANSI_932`, `DOS850`, …); characters outside
+//! it are written as `\U+XXXX` (any character) or `\M+nXXXX` (a double-byte character of an East
+//! Asian code page) escapes, which [`crate::parse`] decodes after the bytes.
+//!
+//! The Windows, ISO and East Asian code pages are decoded with `encoding_rs`; DOS 437, 850 and
+//! 852 with the tables below (the upper halves of the IBM PC code pages; the lower halves are
+//! ASCII). Decoding never fails: a byte sequence that is invalid in the code page (a truncated
+//! double-byte character, an unassigned byte) becomes U+FFFD and the bytes after it decode
+//! normally, so line ends and the group structure survive.
+
+use std::borrow::Cow;
+
+use encoding_rs::Encoding;
+
+/// How the bytes of a code page become text.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Decoder {
+    Utf8,
+    Encoding(&'static Encoding),
+    /// Single-byte DOS code page: ASCII, then these 128 characters for bytes 0x80–0xFF.
+    Table(&'static [char; 128]),
+}
+
+/// The decoder for a `$DWGCODEPAGE` value (case-insensitive), or `None` when CADCraft doesn't
+/// know the code page.
+pub(crate) fn decoder(code_page: &str) -> Option<Decoder> {
+    use encoding_rs as e;
+    let name = code_page.trim().to_ascii_uppercase().replace(['-', ' '], "_");
+    let enc = match name.as_str() {
+        "UTF8" | "UTF_8" | "UNICODE" => return Some(Decoder::Utf8),
+        "ASCII" | "ANSI_1252" | "ISO8859_1" | "ISO_8859_1" => e::WINDOWS_1252,
+        "ANSI_874" => e::WINDOWS_874,
+        "ANSI_932" | "DOS932" | "SHIFT_JIS" => e::SHIFT_JIS,
+        "ANSI_936" | "GB2312" | "GBK" => e::GBK,
+        "ANSI_949" | "KSC5601" | "KOREAN" => e::EUC_KR,
+        "ANSI_950" | "BIG5" => e::BIG5,
+        "ANSI_1250" => e::WINDOWS_1250,
+        "ANSI_1251" => e::WINDOWS_1251,
+        "ANSI_1253" => e::WINDOWS_1253,
+        "ANSI_1254" | "ISO8859_9" | "ISO_8859_9" => e::WINDOWS_1254,
+        "ANSI_1255" => e::WINDOWS_1255,
+        "ANSI_1256" => e::WINDOWS_1256,
+        "ANSI_1257" => e::WINDOWS_1257,
+        "ANSI_1258" => e::WINDOWS_1258,
+        "ISO8859_2" | "ISO_8859_2" => e::ISO_8859_2,
+        "ISO8859_3" | "ISO_8859_3" => e::ISO_8859_3,
+        "ISO8859_4" | "ISO_8859_4" => e::ISO_8859_4,
+        "ISO8859_5" | "ISO_8859_5" => e::ISO_8859_5,
+        "ISO8859_6" | "ISO_8859_6" => e::ISO_8859_6,
+        "ISO8859_7" | "ISO_8859_7" => e::ISO_8859_7,
+        "ISO8859_8" | "ISO_8859_8" => e::ISO_8859_8,
+        "DOS866" => e::IBM866,
+        "MACINTOSH" | "MAC_ROMAN" => e::MACINTOSH,
+        "DOS437" => return Some(Decoder::Table(&DOS437)),
+        "DOS850" => return Some(Decoder::Table(&DOS850)),
+        "DOS852" => return Some(Decoder::Table(&DOS852)),
+        _ => return None,
+    };
+    Some(Decoder::Encoding(enc))
+}
+
+/// Decode `bytes` from the code page `code_page` names (a `$DWGCODEPAGE` value such as
+/// `ANSI_1251`), or `None` when CADCraft doesn't know that code page. Invalid sequences become
+/// U+FFFD; escapes (`\U+XXXX`, `\M+nXXXX`) are left as they are.
+pub fn decode_code_page(bytes: &[u8], code_page: &str) -> Option<String> {
+    decoder(code_page).map(|d| decode(bytes, d).into_owned())
+}
+
+/// The code page a pre-2007 file's text is written in, or `None` for pure ASCII with escapes:
+/// when CADCraft doesn't know `code_page`, and for `ASCII` (the reader takes such files as
+/// Windows-1252, but a writer must keep them ASCII) and `UTF8`/`UNICODE`, which no pre-2007
+/// reader expects.
+pub(crate) fn encoder(code_page: &str) -> Option<Decoder> {
+    if code_page.trim().eq_ignore_ascii_case("ASCII") {
+        return None;
+    }
+    decoder(code_page).filter(|d| !matches!(d, Decoder::Utf8))
+}
+
+/// Append the bytes of the non-ASCII character `c` in the code page `d`, and return true, when
+/// the code page has it; otherwise append nothing and return false (the caller escapes it).
+pub(crate) fn encode_char(c: char, d: Decoder, out: &mut Vec<u8>) -> bool {
+    let mut buf = [0; 4];
+    match d {
+        // Not a pre-2007 code page ([`encoder`] never gives it): escaped.
+        Decoder::Utf8 => return false,
+        Decoder::Encoding(e) => {
+            let (bytes, _, unmappable) = e.encode(c.encode_utf8(&mut buf));
+            // A code page byte that is ASCII would read back as another character, and a NUL,
+            // CR or LF would break the group, so only all-high-bit sequences or proper double-byte
+            // characters are kept (their trail byte may be ASCII, as in Shift-JIS).
+            if unmappable || bytes.is_empty() || !bytes.first().is_some_and(|b| *b >= 0x80) || bytes.iter().any(|b| matches!(b, 0 | b'\r' | b'\n')) {
+                return false;
+            }
+            out.extend_from_slice(&bytes);
+        }
+        Decoder::Table(t) => {
+            let Some(i) = t.iter().position(|&x| x == c).and_then(|i| u8::try_from(i).ok()) else { return false };
+            out.push(0x80 | i);
+        }
+    }
+    true
+}
+
+/// Decode bytes with a decoder. UTF-8 that isn't valid falls back to Windows-1252.
+pub(crate) fn decode(bytes: &[u8], d: Decoder) -> Cow<'_, str> {
+    match d {
+        Decoder::Utf8 => match std::str::from_utf8(bytes) {
+            Ok(s) => Cow::Borrowed(s),
+            Err(_) => encoding_rs::WINDOWS_1252.decode_without_bom_handling(bytes).0,
+        },
+        Decoder::Encoding(e) => e.decode_without_bom_handling(bytes).0,
+        Decoder::Table(t) => match std::str::from_utf8(bytes) {
+            Ok(s) if s.is_ascii() => Cow::Borrowed(s),
+            _ => Cow::Owned(
+                bytes
+                    .iter()
+                    .map(|&b| if b.is_ascii() { char::from(b) } else { t.get(usize::from(b & 0x7F)).copied().unwrap_or('\u{FFFD}') })
+                    .collect(),
+            ),
+        },
+    }
+}
+
+/// The `$DWGCODEPAGE` value of an ASCII DXF file: the line two lines after a `$DWGCODEPAGE`
+/// line (the group code `3` between them), looked for in the HEADER section only (the scan stops
+/// at the first `ENDSEC`). Works on the raw bytes, before they are decoded.
+fn ascii_code_page(bytes: &[u8]) -> Option<&[u8]> {
+    let mut lines = bytes.split(|&b| b == b'\n').map(<[u8]>::trim_ascii);
+    while let Some(line) = lines.next() {
+        if line == b"ENDSEC" {
+            return None;
+        }
+        if line.eq_ignore_ascii_case(b"$DWGCODEPAGE") {
+            return match (lines.next(), lines.next()) {
+                (Some(b"3"), Some(value)) => Some(value),
+                _ => None,
+            };
+        }
+    }
+    None
+}
+
+/// Decode a whole ASCII DXF file. Valid UTF-8 is read as UTF-8: R2007+ files, pure-ASCII files,
+/// and older files from writers that ignored the code page. Anything else is decoded from the
+/// file's `$DWGCODEPAGE`, or from Windows-1252 (the usual `ANSI_1252`) when the header has none
+/// or names a code page CADCraft doesn't know, which is logged as a warning.
+pub(crate) fn decode_ascii_file(bytes: &[u8]) -> Cow<'_, str> {
+    if let Ok(s) = std::str::from_utf8(bytes) {
+        return Cow::Borrowed(s);
+    }
+    let d = match ascii_code_page(bytes) {
+        Some(name) => {
+            let name = String::from_utf8_lossy(name);
+            decoder(&name).unwrap_or_else(|| {
+                log::warn!("DXF: unknown code page `{name}`; reading the text as ANSI_1252");
+                Decoder::Utf8
+            })
+        }
+        None => Decoder::Utf8,
+    };
+    decode(bytes, d)
+}
+
+/// The text state of a binary DXF file, learnt from its header as the tags go by: `$ACADVER`
+/// (R2007+ strings are UTF-8) and `$DWGCODEPAGE` (the code page of older files). Both come
+/// first in the HEADER section and are ASCII, so every later string is decoded right.
+#[derive(Default)]
+pub(crate) struct BinaryText {
+    /// The header variable whose value comes next (after a group 9).
+    var: Option<HeaderVar>,
+    utf8: bool,
+    code_page: Option<Decoder>,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum HeaderVar {
+    AcadVer,
+    CodePage,
+}
+
+impl BinaryText {
+    /// Decode one string value of group `code` and update the state from it. Strings of R2007+
+    /// files, and of files without a code page, are UTF-8 when valid (else Windows-1252); older
+    /// files' strings are in their code page.
+    pub(crate) fn string(&mut self, code: i32, raw: &[u8]) -> String {
+        let d = if self.utf8 { Decoder::Utf8 } else { self.code_page.unwrap_or(Decoder::Utf8) };
+        let s = decode(raw, d).into_owned();
+        match (code, self.var.take()) {
+            (9, _) => {
+                self.var = match s.trim() {
+                    "$ACADVER" => Some(HeaderVar::AcadVer),
+                    "$DWGCODEPAGE" => Some(HeaderVar::CodePage),
+                    _ => None,
+                }
+            }
+            (1, Some(HeaderVar::AcadVer)) => self.utf8 = is_utf8_version(&s),
+            (3, Some(HeaderVar::CodePage)) => {
+                self.code_page = decoder(&s);
+                if self.code_page.is_none() {
+                    log::warn!("DXF: unknown code page `{}`; reading the text as ANSI_1252", s.trim());
+                }
+            }
+            _ => {}
+        }
+        s
+    }
+}
+
+/// True for an `$ACADVER` of R2007 (AC1021) or later, whose text is UTF-8.
+fn is_utf8_version(acadver: &str) -> bool {
+    acadver.trim().strip_prefix("AC").and_then(|n| n.parse::<u32>().ok()).is_some_and(|n| n >= 1021)
+}
+
+/// The double-byte code page of a `\M+n` escape: 1 Japanese (Shift-JIS), 2 Traditional Chinese
+/// (Big5), 3 Korean (Wansung), 5 Simplified Chinese (GB 2312). 4 (Korean Johab) is not
+/// supported, so its escapes stay literal.
+pub(crate) fn mif_encoding(n: char) -> Option<&'static Encoding> {
+    match n {
+        '1' => Some(encoding_rs::SHIFT_JIS),
+        '2' => Some(encoding_rs::BIG5),
+        '3' => Some(encoding_rs::EUC_KR),
+        '5' => Some(encoding_rs::GBK),
+        _ => None,
+    }
+}
+
+// Generated from the IBM PC code page definitions (bytes 0x80–0xFF in order).
+const DOS437: [char; 128] = [
+    '\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{00E0}', '\u{00E5}', '\u{00E7}', '\u{00EA}', '\u{00EB}', '\u{00E8}', '\u{00EF}',
+    '\u{00EE}', '\u{00EC}', '\u{00C4}', '\u{00C5}', '\u{00C9}', '\u{00E6}', '\u{00C6}', '\u{00F4}', '\u{00F6}', '\u{00F2}', '\u{00FB}', '\u{00F9}',
+    '\u{00FF}', '\u{00D6}', '\u{00DC}', '\u{00A2}', '\u{00A3}', '\u{00A5}', '\u{20A7}', '\u{0192}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
+    '\u{00F1}', '\u{00D1}', '\u{00AA}', '\u{00BA}', '\u{00BF}', '\u{2310}', '\u{00AC}', '\u{00BD}', '\u{00BC}', '\u{00A1}', '\u{00AB}', '\u{00BB}',
+    '\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{2561}', '\u{2562}', '\u{2556}', '\u{2555}', '\u{2563}', '\u{2551}', '\u{2557}',
+    '\u{255D}', '\u{255C}', '\u{255B}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{255E}', '\u{255F}',
+    '\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{2567}', '\u{2568}', '\u{2564}', '\u{2565}', '\u{2559}',
+    '\u{2558}', '\u{2552}', '\u{2553}', '\u{256B}', '\u{256A}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{258C}', '\u{2590}', '\u{2580}',
+    '\u{03B1}', '\u{00DF}', '\u{0393}', '\u{03C0}', '\u{03A3}', '\u{03C3}', '\u{00B5}', '\u{03C4}', '\u{03A6}', '\u{0398}', '\u{03A9}', '\u{03B4}',
+    '\u{221E}', '\u{03C6}', '\u{03B5}', '\u{2229}', '\u{2261}', '\u{00B1}', '\u{2265}', '\u{2264}', '\u{2320}', '\u{2321}', '\u{00F7}', '\u{2248}',
+    '\u{00B0}', '\u{2219}', '\u{00B7}', '\u{221A}', '\u{207F}', '\u{00B2}', '\u{25A0}', '\u{00A0}',
+];
+const DOS850: [char; 128] = [
+    '\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{00E0}', '\u{00E5}', '\u{00E7}', '\u{00EA}', '\u{00EB}', '\u{00E8}', '\u{00EF}',
+    '\u{00EE}', '\u{00EC}', '\u{00C4}', '\u{00C5}', '\u{00C9}', '\u{00E6}', '\u{00C6}', '\u{00F4}', '\u{00F6}', '\u{00F2}', '\u{00FB}', '\u{00F9}',
+    '\u{00FF}', '\u{00D6}', '\u{00DC}', '\u{00F8}', '\u{00A3}', '\u{00D8}', '\u{00D7}', '\u{0192}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
+    '\u{00F1}', '\u{00D1}', '\u{00AA}', '\u{00BA}', '\u{00BF}', '\u{00AE}', '\u{00AC}', '\u{00BD}', '\u{00BC}', '\u{00A1}', '\u{00AB}', '\u{00BB}',
+    '\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{00C1}', '\u{00C2}', '\u{00C0}', '\u{00A9}', '\u{2563}', '\u{2551}', '\u{2557}',
+    '\u{255D}', '\u{00A2}', '\u{00A5}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{00E3}', '\u{00C3}',
+    '\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{00A4}', '\u{00F0}', '\u{00D0}', '\u{00CA}', '\u{00CB}',
+    '\u{00C8}', '\u{0131}', '\u{00CD}', '\u{00CE}', '\u{00CF}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{00A6}', '\u{00CC}', '\u{2580}',
+    '\u{00D3}', '\u{00DF}', '\u{00D4}', '\u{00D2}', '\u{00F5}', '\u{00D5}', '\u{00B5}', '\u{00FE}', '\u{00DE}', '\u{00DA}', '\u{00DB}', '\u{00D9}',
+    '\u{00FD}', '\u{00DD}', '\u{00AF}', '\u{00B4}', '\u{00AD}', '\u{00B1}', '\u{2017}', '\u{00BE}', '\u{00B6}', '\u{00A7}', '\u{00F7}', '\u{00B8}',
+    '\u{00B0}', '\u{00A8}', '\u{00B7}', '\u{00B9}', '\u{00B3}', '\u{00B2}', '\u{25A0}', '\u{00A0}',
+];
+const DOS852: [char; 128] = [
+    '\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{016F}', '\u{0107}', '\u{00E7}', '\u{0142}', '\u{00EB}', '\u{0150}', '\u{0151}',
+    '\u{00EE}', '\u{0179}', '\u{00C4}', '\u{0106}', '\u{00C9}', '\u{0139}', '\u{013A}', '\u{00F4}', '\u{00F6}', '\u{013D}', '\u{013E}', '\u{015A}',
+    '\u{015B}', '\u{00D6}', '\u{00DC}', '\u{0164}', '\u{0165}', '\u{0141}', '\u{00D7}', '\u{010D}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
+    '\u{0104}', '\u{0105}', '\u{017D}', '\u{017E}', '\u{0118}', '\u{0119}', '\u{00AC}', '\u{017A}', '\u{010C}', '\u{015F}', '\u{00AB}', '\u{00BB}',
+    '\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{00C1}', '\u{00C2}', '\u{011A}', '\u{015E}', '\u{2563}', '\u{2551}', '\u{2557}',
+    '\u{255D}', '\u{017B}', '\u{017C}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{0102}', '\u{0103}',
+    '\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{00A4}', '\u{0111}', '\u{0110}', '\u{010E}', '\u{00CB}',
+    '\u{010F}', '\u{0147}', '\u{00CD}', '\u{00CE}', '\u{011B}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{0162}', '\u{016E}', '\u{2580}',
+    '\u{00D3}', '\u{00DF}', '\u{00D4}', '\u{0143}', '\u{0144}', '\u{0148}', '\u{0160}', '\u{0161}', '\u{0154}', '\u{00DA}', '\u{0155}', '\u{0170}',
+    '\u{00FD}', '\u{00DD}', '\u{0163}', '\u{00B4}', '\u{00AD}', '\u{02DD}', '\u{02DB}', '\u{02C7}', '\u{02D8}', '\u{00A7}', '\u{00F7}', '\u{00B8}',
+    '\u{00B0}', '\u{00A8}', '\u{02D9}', '\u{0171}', '\u{0158}', '\u{0159}', '\u{25A0}', '\u{00A0}',
+];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn code_page_names() {
+        let d = |bytes: &[u8], cp: &str| decode_code_page(bytes, cp);
+        assert_eq!(d(b"\xCF\xF0\xE8\xE2\xE5\xF2", "ANSI_1251").as_deref(), Some("Привет"));
+        assert_eq!(d(b"\xCF\xF0\xE8\xE2\xE5\xF2", " ansi_1251 ").as_deref(), Some("Привет"));
+        assert_eq!(d(b"\x90\x7D\x96\xCA", "ANSI_932").as_deref(), Some("図面"));
+        assert_eq!(d(b"\xCD\xBC\xB2\xE3", "GB2312").as_deref(), Some("图层"));
+        assert_eq!(d(b"\xB9\xCF\xBC\x68", "BIG5").as_deref(), Some("圖層"));
+        assert_eq!(d(b"\xB5\xB5\xB8\xE9", "ANSI_949").as_deref(), Some("도면"));
+        assert_eq!(d(b"\xD3\xF7\xDD\xE4\xE9\xEF", "ANSI_1253").as_deref(), Some("Σχέδιο"));
+        assert_eq!(d(b"\xC0\xD2\xBE", "ANSI_874").as_deref(), Some("ภาพ"));
+        assert_eq!(d(b"\x80", "ANSI_1252").as_deref(), Some("€"));
+        // DOS 437 and 850 agree on letters but differ on 0x9B (¢ / ø).
+        assert_eq!(d(b"Gr\x94\xE1e \x9B", "DOS437").as_deref(), Some("Größe ¢"));
+        assert_eq!(d(b"Gr\x94\xE1e \x9B", "dos850").as_deref(), Some("Größe ø"));
+        assert_eq!(d(b"\xBD\xA2\x88w", "DOS852").as_deref(), Some("Żółw"));
+        assert_eq!(d(b"\x91\xAB\xAE\xA9", "DOS866").as_deref(), Some("Слой"));
+        assert_eq!(d("é".as_bytes(), "UTF8").as_deref(), Some("é"));
+        assert_eq!(d(b"x", "ANSI_1361"), None);
+        assert_eq!(d(b"x", "EBCDIC"), None);
+        assert_eq!(d(b"x", ""), None);
+    }
+
+    #[test]
+    fn invalid_sequences_become_replacement_characters() {
+        // A Shift-JIS lead byte cut off by the line end keeps the line end.
+        assert_eq!(decode_code_page(b"\x90\n1\n", "ANSI_932").as_deref(), Some("\u{FFFD}\n1\n"));
+        assert_eq!(decode_code_page(b"\x90", "ANSI_932").as_deref(), Some("\u{FFFD}"));
+        assert_eq!(decode_code_page(b"\xFF\xFF", "ANSI_936").as_deref(), Some("\u{FFFD}\u{FFFD}"));
+    }
+
+    #[test]
+    fn header_scan() {
+        let head = b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1251\r\n0\nENDSEC\n";
+        assert_eq!(ascii_code_page(head), Some(&b"ANSI_1251"[..]));
+        // Only the HEADER section counts.
+        assert_eq!(ascii_code_page(b"0\nSECTION\n2\nHEADER\n0\nENDSEC\n9\n$DWGCODEPAGE\n3\nANSI_1251\n"), None);
+        // Wrong group code, or the file ends early.
+        assert_eq!(ascii_code_page(b"9\n$DWGCODEPAGE\n1\nANSI_1251\n"), None);
+        assert_eq!(ascii_code_page(b"9\n$DWGCODEPAGE\n3"), None);
+        assert!(is_utf8_version("AC1021") && is_utf8_version(" AC1032 "));
+        assert!(!is_utf8_version("AC1018") && !is_utf8_version("AC1009") && !is_utf8_version("garbage"));
+    }
+
+    #[test]
+    fn mif_escapes() {
+        let one = |s: &str| crate::parse(format!("1\n{s}\n0\nEOF\n").as_bytes()).unwrap()[0].str();
+        assert_eq!(one("\\M+5BCFE\\M+1907D\\M+2B9CF\\M+3B5B5!"), "件図圖도!");
+        assert_eq!(one("\\M+5BCFE\\U+0021"), "件!");
+        // Johab, unknown code pages, bad hex, short escapes and unassigned codes stay literal.
+        for s in ["\\M+4ABCD", "\\M+9BCFE", "\\M+5GGGG", "\\M+5BC", "\\M+", "\\M+50041", "\\M+5FFFF"] {
+            assert_eq!(one(s), s);
+        }
+    }
+}
@@ -0,0 +1,827 @@
+//! A standalone DXF tag reader and writer.
+//!
+//! DXF is a sequence of (group code, value) pairs. This crate parses ASCII and binary DXF into a
+//! flat list of [`Tag`]s, splits them into sections and entities, and writes tags back. Mapping
+//! tags to a drawing model is left to the caller. Written from Autodesk's published DXF
+//! Reference; depends on nothing else in the workspace.
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+#![forbid(unsafe_code)]
+
+use std::fmt::Write as _;
+use std::io::Write as _;
+
+mod version;
+pub use version::Version;
+
+#[derive(Debug, thiserror::Error)]
+pub enum DxfError {
+    #[error("not a DXF file")]
+    NotDxf,
+    #[error("line {line}: bad group code `{text}`")]
+    BadCode { line: usize, text: String },
+    #[error("unexpected end of file")]
+    Eof,
+    /// More group codes than [`MAX_TAGS`]: `tags` is the count found (or the count read when the
+    /// limit was reached), `limit` the maximum.
+    #[error("drawing too large: {tags} DXF group codes, more than the {limit} CADCraft reads (set CADCRAFT_MAX_DXF_TAGS to read more)")]
+    TooLarge { tags: usize, limit: usize },
+    /// The memory for `tags` group codes couldn't be had: an error, not the process ending.
+    #[error("not enough memory to read this drawing's {tags} DXF group codes")]
+    OutOfMemory { tags: usize },
+}
+
+pub type Result<T> = std::result::Result<T, DxfError>;
+
+/// A typed group value.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Value {
+    Str(String),
+    Real(f64),
+    Int(i64),
+    Bool(bool),
+    /// Binary chunk (310–319, 1004) as hex text.
+    Hex(String),
+}
+
+impl Value {
+    pub fn as_str(&self) -> String {
+        match self {
+            Value::Str(s) | Value::Hex(s) => s.clone(),
+            Value::Real(r) => format_real(*r),
+            Value::Int(i) => i.to_string(),
+            Value::Bool(b) => i64::from(*b).to_string(),
+        }
+    }
+    pub fn as_f64(&self) -> f64 {
+        match self {
+            Value::Real(r) if r.is_finite() => *r,
+            Value::Int(i) => *i as f64,
+            Value::Str(s) => s.trim().parse::<f64>().ok().filter(|v| v.is_finite()).unwrap_or(0.0),
+            Value::Bool(b) => f64::from(u8::from(*b)),
+            _ => 0.0,
+        }
+    }
+    pub fn as_i64(&self) -> i64 {
+        match self {
+            Value::Int(i) => *i,
+            Value::Real(r) if r.is_finite() => *r as i64,
+            Value::Str(s) => s.trim().parse::<i64>().unwrap_or_else(|_| s.trim().parse::<f64>().map(|f| f as i64).unwrap_or(0)),
+            Value::Bool(b) => i64::from(*b),
+            _ => 0,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Tag {
+    pub code: i32,
+    pub value: Value,
+}
+
+impl Tag {
+    pub fn new(code: i32, value: Value) -> Self {
+        Tag { code, value }
+    }
+    pub fn s(code: i32, v: impl Into<String>) -> Self {
+        Tag { code, value: Value::Str(v.into()) }
+    }
+    pub fn f(code: i32, v: f64) -> Self {
+        Tag { code, value: Value::Real(if v.is_finite() { v } else { 0.0 }) }
+    }
+    pub fn i(code: i32, v: i64) -> Self {
+        Tag { code, value: Value::Int(v) }
+    }
+    pub fn str(&self) -> String {
+        self.value.as_str()
+    }
+    pub fn f64(&self) -> f64 {
+        self.value.as_f64()
+    }
+    pub fn i64(&self) -> i64 {
+        self.value.as_i64()
+    }
+}
+
+/// The value type for a group code (DXF Reference, "Group Code Value Types").
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    Str,
+    Real,
+    Int16,
+    Int32,
+    Int64,
+    Bool,
+    Hex,
+}
+
+pub fn kind_of(code: i32) -> Kind {
+    match code {
+        0..=9 => Kind::Str,
+        10..=59 => Kind::Real,
+        60..=79 => Kind::Int16,
+        90..=99 => Kind::Int32,
+        100..=109 => Kind::Str,
+        110..=149 => Kind::Real,
+        160..=169 => Kind::Int64,
+        170..=179 => Kind::Int16,
+        210..=239 => Kind::Real,
+        270..=289 => Kind::Int16,
+        290..=299 => Kind::Bool,
+        300..=309 => Kind::Str,
+        310..=319 => Kind::Hex,
+        320..=369 => Kind::Str,
+        370..=389 => Kind::Int16,
+        390..=399 => Kind::Str,
+        400..=409 => Kind::Int16,
+        410..=419 => Kind::Str,
+        420..=429 => Kind::Int32,
+        430..=439 => Kind::Str,
+        440..=449 => Kind::Int32,
+        450..=459 => Kind::Int32,
+        460..=469 => Kind::Real,
+        470..=479 => Kind::Str,
+        480..=481 => Kind::Str,
+        999 => Kind::Str,
+        1000..=1003 => Kind::Str,
+        1004 => Kind::Hex,
+        1005..=1009 => Kind::Str,
+        1010..=1059 => Kind::Real,
+        1060..=1070 => Kind::Int16,
+        1071 => Kind::Int32,
+        _ => Kind::Str,
+    }
+}
+
+fn typed(code: i32, text: &str) -> Value {
+    let t = text.trim();
+    match kind_of(code) {
+        Kind::Real => t.parse::<f64>().ok().filter(|v| v.is_finite()).map(Value::Real).unwrap_or(Value::Real(0.0)),
+        Kind::Int16 | Kind::Int32 | Kind::Int64 => {
+            t.parse::<i64>().map(Value::Int).unwrap_or_else(|_| Value::Int(t.parse::<f64>().map(|f| f as i64).unwrap_or(0)))
+        }
+        Kind::Bool => Value::Bool(t.parse::<i64>().unwrap_or(0) != 0),
+        Kind::Hex => Value::Hex(t.to_string()),
+        Kind::Str => Value::Str(text.trim_end_matches(['\r', '\n']).to_string()),
+    }
+}
+
+const BINARY_SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
+/// Most group codes read from one file by default. A `Tag` takes 40 bytes plus its text, so this
+/// bounds the tag list to about 4 GB plus text. 50 million rejected large DWGs that converted fine
+/// (a 172 MB drawing has 56 million, issue #1948). The file-size limits bound memory too: 512 MB
+/// for a DXF opened directly, 1 GB for a DWG's DXF rendition. Set `CADCRAFT_MAX_DXF_TAGS` to
+/// raise or lower it.
+pub const MAX_TAGS: usize = 100_000_000;
+
+/// Environment variable overriding [`MAX_TAGS`] (a positive integer).
+pub const MAX_TAGS_ENV: &str = "CADCRAFT_MAX_DXF_TAGS";
+
+/// The group-code limit in effect: [`MAX_TAGS_ENV`] when set to a positive integer, else
+/// [`MAX_TAGS`].
+pub fn max_tags() -> usize {
+    max_tags_from(std::env::var(MAX_TAGS_ENV).ok().as_deref())
+}
+
+fn max_tags_from(v: Option<&str>) -> usize {
+    v.and_then(|s| s.trim().replace('_', "").parse::<usize>().ok()).filter(|&n| n > 0).unwrap_or(MAX_TAGS)
+}
+
+mod codepage;
+pub use codepage::decode_code_page;
+
+/// Parse a DXF file (ASCII or binary).
+pub fn parse(bytes: &[u8]) -> Result<Vec<Tag>> {
+    parse_with_limit(bytes, max_tags())
+}
+
+/// [`parse`] with an explicit group-code limit. For ASCII DXF the limit is checked up front from
+/// the line count, before the text is decoded or any tag allocated, so an oversized file fails in
+/// milliseconds instead of after it has filled memory.
+pub fn parse_with_limit(bytes: &[u8], max_tags: usize) -> Result<Vec<Tag>> {
+    if let Some(body) = bytes.strip_prefix(BINARY_SENTINEL) {
+        return parse_binary_with_limit(body, max_tags);
+    }
+    // Count nonblank group-code/value pairs, stopping at EOF just as the parser does.
+    let mut lines = bytes.split(|&b| b == b'\n');
+    let mut tags = 0;
+    while let Some(code) = lines.next() {
+        let code = code.trim_ascii();
+        if code.is_empty() {
+            continue;
+        }
+        let Some(value) = lines.next() else { break };
+        tags += 1;
+        if code == b"0" && value.trim_ascii() == b"EOF" {
+            break;
+        }
+    }
+    if tags > max_tags {
+        return Err(DxfError::TooLarge { tags, limit: max_tags });
+    }
+    parse_ascii_counted(&codepage::decode_ascii_file(bytes), max_tags, tags)
+}
+
+/// The four hex digits of a `\U+XXXX` escape starting at `chars[i]`, if there is one.
+fn escape_at(chars: &[char], i: usize) -> Option<u32> {
+    if chars.get(i) != Some(&'\\') || chars.get(i + 1) != Some(&'U') || chars.get(i + 2) != Some(&'+') {
+        return None;
+    }
+    let hex = chars.get(i + 3..i + 7)?;
+    if !hex.iter().all(char::is_ascii_hexdigit) {
+        return None;
+    }
+    hex.iter().try_fold(0u32, |acc, c| Some(acc * 16 + c.to_digit(16)?))
+}
+
+/// The character of a `\M+nXXXX` escape starting at `chars[i]`, if there is one: `n` names a
+/// double-byte code page and `XXXX` is the character's two bytes in hex.
+fn mif_escape_at(chars: &[char], i: usize) -> Option<char> {
+    if chars.get(i) != Some(&'\\') || chars.get(i + 1) != Some(&'M') || chars.get(i + 2) != Some(&'+') {
+        return None;
+    }
+    let enc = codepage::mif_encoding(*chars.get(i + 3)?)?;
+    let hex = chars.get(i + 4..i + 8)?;
+    if !hex.iter().all(char::is_ascii_hexdigit) {
+        return None;
+    }
+    let code = hex.iter().try_fold(0u16, |acc, c| Some(acc * 16 + u16::try_from(c.to_digit(16)?).ok()?))?;
+    let bytes = code.to_be_bytes();
+    let text = enc.decode_without_bom_handling_and_without_replacement(&bytes)?;
+    let mut it = text.chars();
+    it.next().filter(|_| it.next().is_none())
+}
+
+/// Unescape the `\U+XXXX` sequences pre-R2007 DXF uses for characters outside the file's code
+/// page (four hex digits, one UTF-16 code unit; characters above U+FFFF are a surrogate pair of
+/// escapes), and the `\M+nXXXX` sequences for double-byte East Asian characters. Malformed
+/// escapes, unpaired surrogates and unknown `\M+` code pages are kept as literal text.
+fn unescape_unicode(s: &str) -> String {
+    if !s.contains("\\U+") && !s.contains("\\M+") {
+        return s.to_string();
+    }
+    let mut out = String::with_capacity(s.len());
+    let chars: Vec<char> = s.chars().collect();
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        if let Some(ch) = mif_escape_at(&chars, i) {
+            out.push(ch);
+            i += 8;
+            continue;
+        }
+        if let Some(unit) = escape_at(&chars, i) {
+            if let Some(ch) = char::from_u32(unit) {
+                out.push(ch);
+                i += 7;
+                continue;
+            }
+            if (0xD800..0xDC00).contains(&unit)
+                && let Some(low) = escape_at(&chars, i + 7).filter(|u| (0xDC00..0xE000).contains(u))
+                && let Some(ch) = char::from_u32(0x10000 + ((unit - 0xD800) << 10) + (low - 0xDC00))
+            {
+                out.push(ch);
+                i += 14;
+                continue;
+            }
+        }
+        out.push(c);
+        i += 1;
+    }
+    out
+}
+
+pub fn parse_ascii(text: &str) -> Result<Vec<Tag>> {
+    parse_ascii_counted(text, max_tags(), 0)
+}
+
+/// [`parse_ascii`] of a file known to hold `expected` group codes. Their list is reserved first,
+/// with an allocation that can fail: where the system refuses that much memory, opening the file
+/// is an error instead of the end of the app. Growing the list instead could also briefly take
+/// half as much again.
+#[allow(clippy::while_let_loop)]
+fn parse_ascii_counted(text: &str, max_tags: usize, expected: usize) -> Result<Vec<Tag>> {
+    let mut tags = Vec::new();
+    tags.try_reserve_exact(expected.min(max_tags)).map_err(|_| DxfError::OutOfMemory { tags: expected })?;
+    let mut lines = text.strip_prefix('\u{feff}').unwrap_or(text).lines().enumerate();
+    loop {
+        let Some((ln, code_line)) = lines.next() else { break };
+        let ct = code_line.trim();
+        if ct.is_empty() {
+            continue;
+        }
+        let code: i32 = ct.parse().map_err(|_| DxfError::BadCode { line: ln + 1, text: ct.chars().take(40).collect() })?;
+        let Some((_, val)) = lines.next() else { return Err(DxfError::Eof) };
+        let v = typed(code, val);
+        let v = match v {
+            Value::Str(s) => Value::Str(unescape_unicode(&s)),
+            o => o,
+        };
+        tags.push(Tag { code, value: v });
+        if tags.len() > max_tags {
+            return Err(DxfError::TooLarge { tags: tags.len(), limit: max_tags });
+        }
+        if code == 0 && tags.last().is_some_and(|t| t.str() == "EOF") {
+            break;
+        }
+    }
+    if tags.is_empty() {
+        return Err(DxfError::NotDxf);
+    }
+    Ok(tags)
+}
+
+struct Cur<'a> {
+    b: &'a [u8],
+    p: usize,
+}
+
+impl<'a> Cur<'a> {
+    fn take(&mut self, n: usize) -> Result<&[u8]> {
+        let end = self.p.checked_add(n).ok_or(DxfError::Eof)?;
+        let s = self.b.get(self.p..end).ok_or(DxfError::Eof)?;
+        self.p = end;
+        Ok(s)
+    }
+    fn u8(&mut self) -> Result<u8> {
+        Ok(*self.take(1)?.first().ok_or(DxfError::Eof)?)
+    }
+    fn i16(&mut self) -> Result<i16> {
+        let s = self.take(2)?;
+        Ok(i16::from_le_bytes([s[0], s[1]]))
+    }
+    fn i32(&mut self) -> Result<i32> {
+        let s = self.take(4)?;
+        Ok(i32::from_le_bytes([s[0], s[1], s[2], s[3]]))
+    }
+    fn i64(&mut self) -> Result<i64> {
+        let s = self.take(8)?;
+        let mut a = [0u8; 8];
+        a.copy_from_slice(s);
+        Ok(i64::from_le_bytes(a))
+    }
+    fn f64(&mut self) -> Result<f64> {
+        let s = self.take(8)?;
+        let mut a = [0u8; 8];
+        a.copy_from_slice(s);
+        Ok(f64::from_le_bytes(a))
+    }
+    /// The bytes of a zero-terminated string (without the zero), decoded by the caller.
+    fn cstr(&mut self) -> Result<&'a [u8]> {
+        let start = self.p;
+        while self.p < self.b.len() && self.b.get(self.p) != Some(&0) {
+            self.p += 1;
+        }
+        let s = self.b.get(start..self.p).unwrap_or(&[]);
+        if self.p >= self.b.len() {
+            return Err(DxfError::Eof);
+        }
+        self.p += 1;
+        Ok(s)
+    }
+}
+
+/// Binary DXF (R13+: 2-byte group codes).
+pub fn parse_binary(b: &[u8]) -> Result<Vec<Tag>> {
+    parse_binary_with_limit(b, max_tags())
+}
+
+fn parse_binary_with_limit(b: &[u8], max_tags: usize) -> Result<Vec<Tag>> {
+    let mut c = Cur { b, p: 0 };
+    let mut text = codepage::BinaryText::default();
+    let mut tags = Vec::new();
+    while c.p < b.len() {
+        let mut code = i32::from(c.i16()?);
+        if code == 255 {
+            code = i32::from(c.i16()?);
+        }
+        let v = match kind_of(code) {
+            Kind::Str => Value::Str(unescape_unicode(&text.string(code, c.cstr()?))),
+            Kind::Real => Value::Real(c.f64()?),
+            Kind::Int16 => Value::Int(i64::from(c.i16()?)),
+            Kind::Int32 => Value::Int(i64::from(c.i32()?)),
+            Kind::Int64 => Value::Int(c.i64()?),
+            Kind::Bool => Value::Bool(c.u8()? != 0),
+            Kind::Hex => {
+                let n = usize::from(c.u8()?);
+                let bytes = c.take(n)?;
+                let mut s = String::with_capacity(n * 2);
+                for x in bytes {
+                    let _ = write!(s, "{x:02X}");
+                }
+                Value::Hex(s)
+            }
+        };
+        let eof = code == 0 && matches!(&v, Value::Str(s) if s == "EOF");
+        tags.push(Tag { code, value: v });
+        if tags.len() > max_tags {
+            return Err(DxfError::TooLarge { tags: tags.len(), limit: max_tags });
+        }
+        if eof {
+            break;
+        }
+    }
+    if tags.is_empty() {
+        return Err(DxfError::NotDxf);
+    }
+    Ok(tags)
+}
+
+/// Format a real the way DXF writers usually do (shortest round-trip, with a decimal point).
+pub fn format_real(v: f64) -> String {
+    if !v.is_finite() {
+        return "0.0".into();
+    }
+    let s = format!("{v}");
+    if s.contains('.') || s.contains('e') || s.contains("inf") || s.contains("NaN") { s } else { format!("{s}.0") }
+}
+
+/// Write tags as ASCII DXF (CRLF line ends, codes right-aligned to 3 as is conventional).
+///
+/// The output is pure ASCII: non-ASCII characters in strings are written as `\U+XXXX` escapes,
+/// the pre-R2007 convention, so it is correct whatever `$DWGCODEPAGE` the header declares.
+pub fn write_ascii(tags: &[Tag]) -> String {
+    write_ascii_as(tags, false)
+}
+
+/// Write tags as ASCII DXF with text in UTF-8 (`utf8`, the R2007+ convention: non-ASCII
+/// characters as they are) or escaped as `\U+XXXX` (older versions, see [`write_ascii`]). Line
+/// breaks inside strings become spaces either way.
+pub fn write_ascii_as(tags: &[Tag], utf8: bool) -> String {
+    let bytes = ascii(tags, if utf8 { Strings::Utf8 } else { Strings::Escaped(None) });
+    // Both forms are UTF-8 (the escaped one is ASCII).
+    String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned())
+}
+
+/// Write tags as pre-R2007 ASCII DXF with text in the code page `code_page` names (a
+/// `$DWGCODEPAGE` value such as `ANSI_1252`), as the DXF Reference describes for those versions:
+/// a character the code page has is written as its bytes, any other as a `\U+XXXX` escape. A
+/// code page CADCraft doesn't know, `ASCII`, and `UTF8`/`UNICODE` (not a pre-2007 code page)
+/// give [`write_ascii`]'s pure ASCII output. So does a file whose code page bytes happen to be
+/// valid UTF-8 (`СІ` in ANSI_1251 is D1 B2, U+0472), since readers, ours included, take an ASCII
+/// DXF that is valid UTF-8 as UTF-8.
+pub fn write_ascii_in(tags: &[Tag], code_page: &str) -> Vec<u8> {
+    let bytes = ascii(tags, Strings::Escaped(codepage::encoder(code_page)));
+    if !bytes.is_ascii() && std::str::from_utf8(&bytes).is_ok() {
+        return ascii(tags, Strings::Escaped(None));
+    }
+    bytes
+}
+
+/// How a writer stores string values.
+#[derive(Clone, Copy)]
+enum Strings {
+    /// As they are (R2007+).
+    Utf8,
+    /// ASCII as it is, other characters in this code page when it has them, otherwise as
+    /// `\U+XXXX` escapes (before R2007).
+    Escaped(Option<codepage::Decoder>),
+}
+
+fn ascii(tags: &[Tag], strings: Strings) -> Vec<u8> {
+    let mut out = Vec::with_capacity(tags.len() * 16);
+    for t in tags {
+        let _ = write!(out, "{:>3}\r\n", t.code);
+        match &t.value {
+            Value::Str(s) => push_string(s, strings, &mut out),
+            Value::Real(r) => out.extend_from_slice(format_real(*r).as_bytes()),
+            Value::Int(i) => out.extend_from_slice(i.to_string().as_bytes()),
+            Value::Bool(b) => out.extend_from_slice(i64::from(*b).to_string().as_bytes()),
+            Value::Hex(h) => out.extend_from_slice(h.as_bytes()),
+        }
+        out.extend_from_slice(b"\r\n");
+    }
+    out
+}
+
+/// Write tags as binary DXF (DXF Reference, "Binary DXF Files", R13+ layout): the sentinel,
+/// then per tag a 2-byte little-endian group code and the value in the binary form of the code's
+/// [`Kind`]: a zero-terminated string, an 8-byte real, a 2-, 4- or 8-byte integer, a 1-byte
+/// boolean, or a binary chunk (one length byte, then up to 255 bytes; longer data is split into
+/// several groups of the same code). Strings are UTF-8 when `utf8` (R2007+), otherwise escaped as
+/// in [`write_ascii`]. A tag's value is converted to its code's kind, so a number written as text
+/// is stored as a number; a code outside the 16-bit range is skipped.
+pub fn write_binary(tags: &[Tag], utf8: bool) -> Vec<u8> {
+    binary(tags, if utf8 { Strings::Utf8 } else { Strings::Escaped(None) })
+}
+
+/// Write tags as pre-R2007 binary DXF with text in the code page `code_page` names, as
+/// [`write_ascii_in`] does.
+pub fn write_binary_in(tags: &[Tag], code_page: &str) -> Vec<u8> {
+    binary(tags, Strings::Escaped(codepage::encoder(code_page)))
+}
+
+fn binary(tags: &[Tag], strings: Strings) -> Vec<u8> {
+    let mut out = Vec::with_capacity(BINARY_SENTINEL.len() + tags.len() * 12);
+    out.extend_from_slice(BINARY_SENTINEL);
+    for t in tags {
+        let Ok(code) = i16::try_from(t.code) else { continue };
+        let code_bytes = code.to_le_bytes();
+        match kind_of(t.code) {
+            Kind::Str => {
+                out.extend_from_slice(&code_bytes);
+                let s = match &t.value {
+                    Value::Str(s) => s.clone(),
+                    v => v.as_str(),
+                };
+                let mut text = Vec::with_capacity(s.len());
+                push_string(&s, strings, &mut text);
+                out.extend(text.into_iter().filter(|&b| b != 0));
+                out.push(0);
+            }
+            Kind::Real => {
+                out.extend_from_slice(&code_bytes);
+                out.extend_from_slice(&t.value.as_f64().to_le_bytes());
+            }
+            Kind::Int16 => {
+                out.extend_from_slice(&code_bytes);
+                let v = t.value.as_i64().clamp(i64::from(i16::MIN), i64::from(i16::MAX));
+                out.extend_from_slice(&i16::try_from(v).unwrap_or_default().to_le_bytes());
+            }
+            Kind::Int32 => {
+                out.extend_from_slice(&code_bytes);
+                let v = t.value.as_i64().clamp(i64::from(i32::MIN), i64::from(i32::MAX));
+                out.extend_from_slice(&i32::try_from(v).unwrap_or_default().to_le_bytes());
+            }
+            Kind::Int64 => {
+                out.extend_from_slice(&code_bytes);
+                out.extend_from_slice(&t.value.as_i64().to_le_bytes());
+            }
+            Kind::Bool => {
+                out.extend_from_slice(&code_bytes);
+                out.push(u8::from(t.value.as_i64() != 0));
+            }
+            Kind::Hex => {
+                let bytes = hex_bytes(&t.value.as_str());
+                // An empty chunk is still one group, as in ASCII.
+                let mut chunks: Vec<&[u8]> = bytes.chunks(255).collect();
+                if chunks.is_empty() {
+                    chunks.push(&[]);
+                }
+                for chunk in chunks {
+                    out.extend_from_slice(&code_bytes);
+                    out.push(u8::try_from(chunk.len()).unwrap_or(u8::MAX));
+                    out.extend_from_slice(chunk);
+                }
+            }
+        }
+    }
+    out
+}
+
+/// The bytes of hex text, two digits each; anything that isn't a pair of hex digits is skipped.
+fn hex_bytes(s: &str) -> Vec<u8> {
+    let digits: Vec<u8> = s.bytes().filter_map(|b| char::from(b).to_digit(16).and_then(|d| u8::try_from(d).ok())).collect();
+    digits.as_chunks::<2>().0.iter().map(|[hi, lo]| (hi << 4) | lo).collect()
+}
+
+/// Whether `bytes` are a binary DXF file (they start with the binary sentinel).
+pub fn is_binary(bytes: &[u8]) -> bool {
+    bytes.starts_with(BINARY_SENTINEL)
+}
+
+/// A string value as `strings` stores it. Line breaks become spaces. Before R2007 the text is
+/// in the `$DWGCODEPAGE` code page: ASCII stays as it is, a character the code page has becomes
+/// its bytes, and every other one `\U+XXXX` (a surrogate pair of escapes above U+FFFF). Without
+/// a code page the result is ASCII, so it is valid in any code page. In every form a backslash
+/// that would start a `\U+` or `\M+` sequence is written as `\U+005C`, so the reader gives back
+/// the literal text (#2050). So is a double-byte character whose trail byte is 0x5C (`\`) in that
+/// place, such as Shift-JIS `表` or Big5 `許`: CADCraft decodes the code page before it looks for
+/// escapes, but a reader that looks first would take that byte and the `U+` after it for one.
+fn push_string(s: &str, strings: Strings, out: &mut Vec<u8>) {
+    let chars: Vec<char> = s.chars().collect();
+    let escape_at = |j: usize| matches!(chars.get(j), Some('U' | 'M')) && chars.get(j + 1) == Some(&'+');
+    for (i, &c) in chars.iter().enumerate() {
+        match (c, strings) {
+            ('\r' | '\n', _) => out.push(b' '),
+            ('\\', _) if escape_at(i + 1) => {
+                out.extend_from_slice(b"\\U+005C");
+            }
+            (c, Strings::Utf8) => out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
+            (c, _) if c.is_ascii() => out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
+            (c, Strings::Escaped(Some(d))) if code_page_bytes(c, d, escape_at(i + 1), out) => {}
+            (c, Strings::Escaped(_)) => {
+                let mut units = [0u16; 2];
+                for u in c.encode_utf16(&mut units) {
+                    let _ = write!(out, "\\U+{u:04X}");
+                }
+            }
+        }
+    }
+}
+
+/// `c` in the code page `d`, if it has it, unless it is a double-byte character whose trail byte
+/// is 0x5C and an escape's `U+` or `M+` follows (`before_escape`): see [`push_string`].
+fn code_page_bytes(c: char, d: codepage::Decoder, before_escape: bool, out: &mut Vec<u8>) -> bool {
+    let start = out.len();
+    if !codepage::encode_char(c, d, out) {
+        return false;
+    }
+    if before_escape && out.len() - start > 1 && out.last() == Some(&b'\\') {
+        out.truncate(start);
+        return false;
+    }
+    true
+}
+
+/// A section: `0 SECTION / 2 NAME ... 0 ENDSEC`.
+#[derive(Clone, Debug, Default)]
+pub struct Section {
+    pub name: String,
+    pub tags: Vec<Tag>,
+}
+
+/// Split a tag stream into sections.
+pub fn sections(tags: &[Tag]) -> Vec<Section> {
+    let mut out = Vec::new();
+    let mut i = 0;
+    while i < tags.len() {
+        let is_sec = tags.get(i).is_some_and(|t| t.code == 0 && t.str() == "SECTION");
+        if is_sec {
+            let name = tags.get(i + 1).filter(|t| t.code == 2).map(Tag::str).unwrap_or_default();
+            let start = i + 2;
+            let mut j = start;
+            while j < tags.len() && !(tags.get(j).is_some_and(|t| t.code == 0 && t.str() == "ENDSEC")) {
+                j += 1;
+            }
+            out.push(Section { name, tags: tags.get(start..j).unwrap_or(&[]).to_vec() });
+            i = j + 1;
+        } else {
+            i += 1;
+        }
+    }
+    out
+}
+
+/// Split a run of tags into records starting at each code-0 tag: (type, tags after the 0).
+pub fn records(tags: &[Tag]) -> Vec<(String, Vec<Tag>)> {
+    let mut out: Vec<(String, Vec<Tag>)> = Vec::new();
+    for t in tags {
+        if t.code == 0 {
+            out.push((t.str(), Vec::new()));
+        } else if let Some(last) = out.last_mut() {
+            last.1.push(t.clone());
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn literal_escape_text_roundtrips() {
+        for utf8 in [false, true] {
+            for text in ["\\U+00E9", "\\M+183A4F", "a\\nb \\P", "\\\\U+00E9", "\\U+005C"] {
+                let tags = vec![Tag::s(8, text)];
+                let back = parse_ascii(&write_ascii_as(&tags, utf8)).unwrap();
+                assert_eq!(back, tags, "utf8={utf8} {text}");
+                let back = parse_binary(&write_binary(&tags, utf8)).unwrap();
+                assert_eq!(back[1..], tags[..], "binary utf8={utf8} {text}");
+            }
+        }
+    }
+
+    #[test]
+    fn blank_lines_do_not_consume_group_code_limit() {
+        let tags = parse_with_limit(b"0\nEOF\n\n\n", 1).expect("one group code should fit a limit of one");
+        assert_eq!(tags, vec![Tag::s(0, "EOF")]);
+    }
+
+    #[test]
+    fn ascii_roundtrip() {
+        let tags = vec![
+            Tag::s(0, "SECTION"),
+            Tag::s(2, "ENTITIES"),
+            Tag::s(0, "LINE"),
+            Tag::s(8, "0"),
+            Tag::f(10, 1.5),
+            Tag::f(20, 2.0),
+            Tag::i(62, 1),
+            Tag::s(0, "ENDSEC"),
+            Tag::s(0, "EOF"),
+        ];
+        let text = write_ascii(&tags);
+        let back = parse(text.as_bytes()).unwrap();
+        assert_eq!(back, tags);
+        let secs = sections(&back);
+        assert_eq!(secs.len(), 1);
+        assert_eq!(secs[0].name, "ENTITIES");
+        let recs = records(&secs[0].tags);
+        assert_eq!(recs[0].0, "LINE");
+        assert_eq!(recs[0].1.len(), 4);
+    }
+
+    #[test]
+    fn binary_parse() {
+        let mut b = BINARY_SENTINEL.to_vec();
+        let push_str = |b: &mut Vec<u8>, code: i16, s: &str| {
+            b.extend_from_slice(&code.to_le_bytes());
+            b.extend_from_slice(s.as_bytes());
+            b.push(0);
+        };
+        push_str(&mut b, 0, "LINE");
+        b.extend_from_slice(&10i16.to_le_bytes());
+        b.extend_from_slice(&3.25f64.to_le_bytes());
+        b.extend_from_slice(&62i16.to_le_bytes());
+        b.extend_from_slice(&5i16.to_le_bytes());
+        push_str(&mut b, 0, "EOF");
+        let tags = parse(&b).unwrap();
+        assert_eq!(tags[1], Tag::f(10, 3.25));
+        assert_eq!(tags[2], Tag::i(62, 5));
+    }
+
+    #[test]
+    fn malformed_inputs() {
+        assert!(parse(b"").is_err());
+        assert!(parse(b"abc\nxyz\n").is_err());
+        assert!(parse(b"0\n").is_err());
+        let mut b = BINARY_SENTINEL.to_vec();
+        b.extend_from_slice(&10i16.to_le_bytes());
+        b.extend_from_slice(&[1, 2, 3]);
+        assert!(parse(&b).is_err());
+        // Bad numbers become 0 rather than failing.
+        let t = parse(b"10\nnotanumber\n0\nEOF\n").unwrap();
+        assert_eq!(t[0].f64(), 0.0);
+    }
+
+    #[test]
+    fn unicode_escapes_and_latin1() {
+        let t = parse(b"1\nCaf\\U+00E9\n0\nEOF\n").unwrap();
+        assert_eq!(t[0].str(), "Café");
+        let t = parse(b"1\nCaf\xe9\n0\nEOF\n").unwrap();
+        assert_eq!(t[0].str(), "Café");
+    }
+
+    #[test]
+    fn surrogate_pair_escapes() {
+        let t = parse(b"1\n\\U+D83D\\U+DE00 \\u+56fe\\U+53f7\n0\nEOF\n").unwrap();
+        assert_eq!(t[0].str(), "😀 \\u+56fe号");
+    }
+
+    #[test]
+    fn hostile_escapes_stay_literal() {
+        for s in [
+            "\\U+",
+            "\\U",
+            "\\",
+            "a\\U+ZZZZ",
+            "\\U+12",
+            "\\U+D800",
+            "\\U+DC00",
+            "\\U+D800\\U+0041",
+            "\\U+D83D\\U+DE",
+            "\\U++123",
+            "\\U+-123",
+            "x\\U+12\u{e9}4",
+        ] {
+            let t = parse(format!("1\n{s}\n0\nEOF\n").as_bytes()).unwrap();
+            let expect = if s == "\\U+D800\\U+0041" { "\\U+D800A" } else { s };
+            assert_eq!(t[0].str(), expect, "{s:?}");
+        }
+    }
+
+    #[test]
+    fn writes_non_ascii_as_escapes() {
+        let tags = vec![Tag::s(1, "图号 Ä°ø 😀\r\nend"), Tag::s(1000, "Ø"), Tag::s(0, "EOF")];
+        let text = write_ascii(&tags);
+        assert!(text.is_ascii());
+        assert!(text.contains("\\U+56FE\\U+53F7 \\U+00C4\\U+00B0\\U+00F8 \\U+D83D\\U+DE00  end\r\n"));
+        let back = parse(text.as_bytes()).unwrap();
+        assert_eq!(back[0].str(), "图号 Ä°ø 😀  end");
+        assert_eq!(back[1].str(), "Ø");
+    }
+
+    #[test]
+    fn binary_strings_unescape() {
+        let mut b = BINARY_SENTINEL.to_vec();
+        b.extend_from_slice(&1i16.to_le_bytes());
+        b.extend_from_slice(b"\\U+56FE\\U+53F7\0");
+        b.extend_from_slice(&0i16.to_le_bytes());
+        b.extend_from_slice(b"EOF\0");
+        assert_eq!(parse(&b).unwrap()[0].str(), "图号");
+    }
+}
+
+#[cfg(test)]
+mod limit_tests {
+    use super::*;
+
+    #[test]
+    fn tag_limit_defaults_and_env_override() {
+        assert_eq!(max_tags_from(None), MAX_TAGS);
+        assert_eq!(max_tags_from(Some("")), MAX_TAGS);
+        assert_eq!(max_tags_from(Some("0")), MAX_TAGS);
+        assert_eq!(max_tags_from(Some("abc")), MAX_TAGS);
+        assert_eq!(max_tags_from(Some(" 400_000_000 ")), 400_000_000);
+        // Issue #1948: the default must admit a DXF rendition well above 50 million group codes.
+        const { assert!(MAX_TAGS >= 100_000_000) };
+    }
+
+    #[test]
+    fn the_tag_list_is_reserved_once_and_a_refusal_is_an_error() {
+        let tags = parse_ascii_counted("0\nSECTION\n0\nENDSEC\n0\nEOF\n", MAX_TAGS, 3).unwrap();
+        assert_eq!((tags.len(), tags.capacity()), (3, 3));
+        let e = parse_ascii_counted("0\nEOF\n", usize::MAX, usize::MAX).unwrap_err();
+        assert!(matches!(e, DxfError::OutOfMemory { .. }), "{e}");
+    }
+}
@@ -0,0 +1,117 @@
+//! The DXF/DWG file versions CADCraft writes (DXF Reference, HEADER `$ACADVER`).
+
+/// A file version CADCraft can save: the AutoCAD release that introduced the format. Each format
+/// also serves the releases after it (2018 is still AutoCAD's current format).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Version {
+    /// AutoCAD 2000/2002 (AC1015).
+    R2000,
+    /// AutoCAD 2004–2006 (AC1018).
+    R2004,
+    /// AutoCAD 2007–2009 (AC1021): the first version whose DXF text is UTF-8.
+    R2007,
+    /// AutoCAD 2010–2012 (AC1024).
+    R2010,
+    /// AutoCAD 2013–2017 (AC1027).
+    R2013,
+    /// AutoCAD 2018 and later (AC1032), the default.
+    #[default]
+    R2018,
+}
+
+impl Version {
+    /// Every version, oldest first.
+    pub const ALL: [Version; 6] = [Version::R2000, Version::R2004, Version::R2007, Version::R2010, Version::R2013, Version::R2018];
+
+    /// The `$ACADVER` code ("AC1032").
+    pub fn code(self) -> &'static str {
+        match self {
+            Version::R2000 => "AC1015",
+            Version::R2004 => "AC1018",
+            Version::R2007 => "AC1021",
+            Version::R2010 => "AC1024",
+            Version::R2013 => "AC1027",
+            Version::R2018 => "AC1032",
+        }
+    }
+
+    /// The release year that names the version ("2018").
+    pub fn year(self) -> &'static str {
+        match self {
+            Version::R2000 => "2000",
+            Version::R2004 => "2004",
+            Version::R2007 => "2007",
+            Version::R2010 => "2010",
+            Version::R2013 => "2013",
+            Version::R2018 => "2018",
+        }
+    }
+
+    /// A version named by its year ("2018", "R2018") or its `$ACADVER` code ("AC1032"), any case.
+    pub fn parse(s: &str) -> Option<Version> {
+        let s = s.trim();
+        let year = s.strip_prefix(['R', 'r']).unwrap_or(s);
+        Version::ALL.into_iter().find(|v| v.year() == year || v.code().eq_ignore_ascii_case(s))
+    }
+
+    /// The version to save a file of `$ACADVER` `code` in: the same version when CADCraft writes
+    /// it, else the nearest one it does (R2000 for older files, 2018 for newer ones); `None` when
+    /// the code isn't a version code at all.
+    pub fn for_acadver(code: &str) -> Option<Version> {
+        let code = code.trim();
+        if let Some(v) = Version::ALL.into_iter().find(|v| v.code().eq_ignore_ascii_case(code)) {
+            return Some(v);
+        }
+        code.get(..2).filter(|p| p.eq_ignore_ascii_case("AC"))?;
+        let n = code.get(2..).filter(|d| d.bytes().all(|b| b.is_ascii_digit())).and_then(|d| d.parse::<u32>().ok())?;
+        Some(match n {
+            ..1018 => Version::R2000,
+            1018..1021 => Version::R2004,
+            1021..1024 => Version::R2007,
+            1024..1027 => Version::R2010,
+            1027..1032 => Version::R2013,
+            _ => Version::R2018,
+        })
+    }
+
+    /// Whether text in this version's DXF is UTF-8 (2007 and later). Older versions keep text in
+    /// the `$DWGCODEPAGE` code page, which CADCraft avoids by escaping non-ASCII as `\U+XXXX`.
+    pub fn utf8(self) -> bool {
+        self >= Version::R2007
+    }
+}
+
+impl std::fmt::Display for Version {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.year())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_years_and_codes() {
+        assert_eq!(Version::parse("2018"), Some(Version::R2018));
+        assert_eq!(Version::parse(" r2004 "), Some(Version::R2004));
+        assert_eq!(Version::parse("ac1021"), Some(Version::R2007));
+        assert_eq!(Version::parse("2005"), None);
+        assert_eq!(Version::parse(""), None);
+        for v in Version::ALL {
+            assert_eq!(Version::parse(v.code()), Some(v));
+            assert_eq!(Version::parse(v.year()), Some(v));
+        }
+    }
+
+    #[test]
+    fn file_versions_map_to_the_nearest_writable_one() {
+        assert_eq!(Version::for_acadver("AC1009"), Some(Version::R2000));
+        assert_eq!(Version::for_acadver("AC1014"), Some(Version::R2000));
+        assert_eq!(Version::for_acadver("AC1024"), Some(Version::R2010));
+        assert_eq!(Version::for_acadver("AC1035"), Some(Version::R2018));
+        assert_eq!(Version::for_acadver("MC0.0"), None);
+        assert_eq!(Version::for_acadver("AC"), None);
+        assert_eq!(Version::for_acadver("AC99999999999999999999"), None);
+    }
+}
@@ -0,0 +1,19 @@
+//! A UTF-8 byte order mark at the start of an ASCII DXF is skipped.
+
+const BODY: &str = "  0\r\nSECTION\r\n  2\r\nENTITIES\r\n  0\r\nENDSEC\r\n  0\r\nEOF\r\n";
+
+#[test]
+fn utf8_bom_bytes_are_skipped() {
+    let plain = cadcraft_dxf::parse(BODY.as_bytes()).expect("plain parses");
+    let mut bytes = vec![0xEF, 0xBB, 0xBF];
+    bytes.extend_from_slice(BODY.as_bytes());
+    let with_bom = cadcraft_dxf::parse(&bytes);
+    assert!(with_bom.is_ok(), "{with_bom:?}");
+    assert_eq!(with_bom.map(|t| t.len()).unwrap_or(0), plain.len());
+}
+
+#[test]
+fn bom_text_is_skipped() {
+    let text = format!("\u{feff}{BODY}");
+    assert!(cadcraft_dxf::parse_ascii(&text).is_ok());
+}
@@ -0,0 +1,75 @@
+//! Binary DXF writing (#421): every value kind round-trips through `write_binary` and `parse`,
+//! and hostile binary input never panics.
+
+use cadcraft_dxf::{Tag, Value, is_binary, parse, write_ascii_as, write_binary};
+
+fn sample() -> Vec<Tag> {
+    vec![
+        Tag::s(0, "SECTION"),
+        Tag::s(2, "ENTITIES"),
+        Tag::s(0, "TEXT"),
+        Tag::s(5, "1F"),
+        Tag::f(10, -3.25),
+        Tag::i(62, 5),
+        Tag::i(90, 70_000),
+        Tag::i(160, 1 << 40),
+        Tag::new(290, Value::Bool(true)),
+        Tag::new(310, Value::Hex("00FFA5".into())),
+        Tag::s(1, "图号 Café 😀"),
+        Tag::i(1071, -2),
+        Tag::s(0, "ENDSEC"),
+        Tag::s(0, "EOF"),
+    ]
+}
+
+#[test]
+fn binary_roundtrips_every_value_kind() {
+    for utf8 in [false, true] {
+        let bytes = write_binary(&sample(), utf8);
+        assert!(is_binary(&bytes));
+        assert_eq!(parse(&bytes).unwrap(), sample(), "utf8 = {utf8}");
+    }
+    // Pre-2007 strings are escaped to ASCII, 2007+ ones are UTF-8.
+    let old = write_binary(&sample(), false);
+    assert!(old.windows(7).any(|w| w == b"\\U+56FE"));
+    let new = write_binary(&sample(), true);
+    assert!(new.windows("图号".len()).any(|w| w == "图号".as_bytes()));
+}
+
+#[test]
+fn binary_converts_values_to_their_codes_kind() {
+    // A number held as text at a numeric code, an out-of-range 16-bit value, a long chunk.
+    let long = "AB".repeat(300);
+    let tags = vec![Tag::s(70, "12"), Tag::i(62, 1 << 20), Tag::new(310, Value::Hex(long)), Tag::s(0, "EOF")];
+    let back = parse(&write_binary(&tags, true)).unwrap();
+    assert_eq!(back[0], Tag::i(70, 12));
+    assert_eq!(back[1], Tag::i(62, i64::from(i16::MAX)));
+    assert_eq!(back[2].code, 310);
+    assert_eq!(back[3].code, 310, "300 bytes are split into chunks of at most 255");
+    assert_eq!(back[2].str().len() + back[3].str().len(), 600);
+}
+
+#[test]
+fn utf8_ascii_keeps_text_and_drops_line_breaks() {
+    let text = write_ascii_as(&[Tag::s(1, "图号\r\nÄ"), Tag::s(0, "EOF")], true);
+    assert!(text.contains("图号  Ä\r\n"));
+    assert_eq!(parse(text.as_bytes()).unwrap()[0].str(), "图号  Ä");
+}
+
+#[test]
+fn hostile_binary_input_never_panics() {
+    let good = write_binary(&sample(), true);
+    // Every truncation, and every single-byte corruption of the body.
+    for n in 0..good.len() {
+        let _ = parse(good.get(..n).unwrap());
+    }
+    for i in 22..good.len() {
+        for b in [0u8, 0x7f, 0xff] {
+            let mut bad = good.clone();
+            bad[i] = b;
+            let _ = parse(&bad);
+        }
+    }
+    // A sentinel and nothing else is not a drawing.
+    assert!(parse(b"AutoCAD Binary DXF\r\n\x1a\0").is_err());
+}
@@ -0,0 +1,116 @@
+//! Pre-R2007 DXF text is written in the `$DWGCODEPAGE` code page: characters it has as their
+//! bytes, the others as `\U+XXXX` escapes; every form reads back to the same text.
+
+use cadcraft_dxf::{Tag, parse, write_ascii, write_ascii_in, write_binary_in};
+
+fn file(code_page: &str, text: &str) -> Vec<Tag> {
+    vec![
+        Tag::s(0, "SECTION"),
+        Tag::s(2, "HEADER"),
+        Tag::s(9, "$ACADVER"),
+        Tag::s(1, "AC1015"),
+        Tag::s(9, "$DWGCODEPAGE"),
+        Tag::s(3, code_page),
+        Tag::s(0, "ENDSEC"),
+        Tag::s(0, "SECTION"),
+        Tag::s(2, "ENTITIES"),
+        Tag::s(0, "TEXT"),
+        Tag::s(1, text),
+        Tag::s(0, "ENDSEC"),
+        Tag::s(0, "EOF"),
+    ]
+}
+
+fn contains(bytes: &[u8], part: &[u8]) -> bool {
+    bytes.windows(part.len()).any(|w| w == part)
+}
+
+#[test]
+fn text_is_written_in_the_code_page() {
+    // (code page, text, the bytes written for it)
+    let cases: [(&str, &str, &[u8]); 6] = [
+        ("ANSI_1252", "Ação € 图", b"A\xE7\xE3o \x80 \\U+56FE"),
+        ("ANSI_1251", "Слой é", b"\xD1\xEB\xEE\xE9 \\U+00E9"),
+        ("ANSI_932", "表図面 é", b"\x95\x5C\x90\x7D\x96\xCA \\U+00E9"),
+        ("DOS850", "Größe €", b"Gr\x94\xE1e \\U+20AC"),
+        ("ANSI_1252", "😀", b"\\U+D83D\\U+DE00"),
+        // A code page CADCraft doesn't know: everything non-ASCII is escaped.
+        ("ANSI_1361", "Ação", b"A\\U+00E7\\U+00E3o"),
+    ];
+    for (cp, text, raw) in cases {
+        let tags = file(cp, text);
+        for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
+            assert!(contains(&bytes, raw), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
+            assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
+        }
+    }
+}
+
+/// Without a known code page, and for `ASCII`, `UTF8` and `UNICODE` headers, the output is what
+/// `write_ascii` writes (pure ASCII with escapes), line breaks included.
+#[test]
+fn unknown_ascii_and_utf8_code_pages_are_pure_ascii() {
+    for cp in ["EBCDIC", "ASCII", "ascii ", "UTF8", "UNICODE"] {
+        let tags = file(cp, "Ação\r\nfim");
+        let bytes = write_ascii_in(&tags, cp);
+        assert!(bytes.is_ascii(), "{cp}");
+        assert_eq!(bytes, write_ascii(&tags).into_bytes(), "{cp}");
+        assert!(contains(&bytes, b"A\\U+00E7\\U+00E3o  fim"), "{cp}");
+        assert!(write_binary_in(&tags, cp).iter().all(u8::is_ascii), "{cp} binary");
+    }
+}
+
+/// Code page bytes that happen to form valid UTF-8 (`СІ` in ANSI_1251 is D1 B2, which is U+0472
+/// in UTF-8) would be read back as UTF-8 from an ASCII file, so that file is written with
+/// escapes. Binary DXF reads strings by the header's code page and keeps the bytes.
+#[test]
+fn code_page_bytes_that_are_valid_utf8_are_escaped_in_ascii() {
+    let tags = file("ANSI_1251", "СІ");
+    let ascii = write_ascii_in(&tags, "ANSI_1251");
+    assert!(ascii.is_ascii(), "{:?}", String::from_utf8_lossy(&ascii));
+    assert!(contains(&ascii, b"\\U+0421\\U+0406"));
+    assert_eq!(parse(&ascii).unwrap()[10].str(), "СІ");
+    let binary = write_binary_in(&tags, "ANSI_1251");
+    assert!(contains(&binary, b"\xD1\xB2"));
+    assert_eq!(parse(&binary).unwrap()[10].str(), "СІ");
+    // Bytes that are not valid UTF-8 stay as they are.
+    assert!(contains(&write_ascii_in(&file("ANSI_1251", "Слой"), "ANSI_1251"), b"\xD1\xEB\xEE\xE9"));
+}
+
+/// A literal `\U+` or `\M+` in the text (#2050) reads back as written alongside code page bytes,
+/// in ASCII and binary, including an ASCII file that falls back to escapes because its bytes
+/// would read as UTF-8.
+#[test]
+fn literal_escapes_survive_code_page_text() {
+    for (cp, text) in
+        [("ANSI_1252", "Ação \\U+00E9 \\M+183A4F"), ("ANSI_1251", "Слой \\U+0041"), ("ANSI_1251", "СІ \\U+0041"), ("ANSI_932", "表 \\M+1")]
+    {
+        let tags = file(cp, text);
+        for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
+            assert!(contains(&bytes, b"\\U+005C"), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
+            assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
+        }
+    }
+}
+
+/// Double-byte code pages whose trail byte can be 0x5C (`\\`): Shift-JIS `表` (95 5C) and `ソ`
+/// (83 5C), Big5 `許` (B3 5C), GBK `乗` (81 5C). Right before `U+` or `M+`, such a character is
+/// written as an escape, so even a reader that looks for escapes before it decodes the code page
+/// reads it right. Elsewhere it stays as its bytes. Both forms read back as written.
+#[test]
+fn a_trail_byte_backslash_never_starts_an_escape() {
+    let cases: [(&str, &str, &[u8], &[u8]); 4] = [
+        ("ANSI_932", "表U+0041 表示", b"\\U+8868U+0041 \x95\x5C\x8E\xA6", b"\x95\x5CU+"),
+        ("ANSI_932", "ソM+1A2B", b"\\U+30BDM+1A2B", b"\x83\x5CM+"),
+        ("ANSI_950", "許U+0041", b"\\U+8A31U+0041", b"\xB3\x5CU+"),
+        ("ANSI_936", "乗U+0041", b"\\U+4E57U+0041", b"\x81\x5CU+"),
+    ];
+    for (cp, text, written, never) in cases {
+        let tags = file(cp, text);
+        for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
+            assert!(contains(&bytes, written), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
+            assert!(!contains(&bytes, never), "{cp} {what}: a trail byte starts an escape");
+            assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
+        }
+    }
+}
@@ -0,0 +1,145 @@
+//! Small independent byte fixtures for DXF tag types, text encoding, framing and failures.
+//! Handwritten examples, not files from a CAD application or generated by our writer.
+//! Background on the tag model and file structure:
+//! https://ezdxf.readthedocs.io/en/stable/dxfinternals/dxftags.html
+//! https://ezdxf.readthedocs.io/en/stable/dxfinternals/filestructure.html
+//! ASCII spacing is our writer's documented convention; binary fixtures specify actual bytes.
+
+use cadcraft_dxf::{DxfError, Tag, Value, parse, parse_with_limit, write_ascii_as, write_binary};
+
+const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
+
+fn fixtures() -> Vec<(Tag, &'static [u8], &'static [u8])> {
+    vec![
+        (Tag::s(1, " A "), b"  1\r\n A \r\n", b"\x01\0 A \0"),
+        (Tag::s(1, ""), b"  1\r\n\r\n", b"\x01\0\0"),
+        (Tag::s(105, "AB12"), b"105\r\nAB12\r\n", b"\x69\0AB12\0"),
+        (Tag::new(10, Value::Real(-3.25)), b" 10\r\n-3.25\r\n", b"\x0a\0\0\0\0\0\0\0\x0a\xc0"),
+        (Tag::i(70, -32768), b" 70\r\n-32768\r\n", b"\x46\0\0\x80"),
+        (Tag::i(90, -2147483648), b" 90\r\n-2147483648\r\n", b"\x5a\0\0\0\0\x80"),
+        (Tag::i(160, 9223372036854775807), b"160\r\n9223372036854775807\r\n", b"\xa0\0\xff\xff\xff\xff\xff\xff\xff\x7f"),
+        (Tag::new(290, Value::Bool(false)), b"290\r\n0\r\n", b"\x22\x01\0"),
+        (Tag::new(299, Value::Bool(true)), b"299\r\n1\r\n", b"\x2b\x01\x01"),
+        (Tag::new(310, Value::Hex("00FF80".into())), b"310\r\n00FF80\r\n", b"\x36\x01\x03\0\xff\x80"),
+        (Tag::new(1004, Value::Hex(String::new())), b"1004\r\n\r\n", b"\xec\x03\0"),
+        (Tag::i(1070, -2), b"1070\r\n-2\r\n", b"\x2e\x04\xfe\xff"),
+        (Tag::i(1071, 65536), b"1071\r\n65536\r\n", b"\x2f\x04\0\0\x01\0"),
+    ]
+}
+
+#[test]
+fn reads_independently_authored_ascii_and_binary_values() {
+    for (expected, ascii, binary) in fixtures() {
+        assert_eq!(parse(ascii).unwrap(), std::slice::from_ref(&expected), "ASCII code {}", expected.code);
+        let bytes = [SENTINEL, binary].concat();
+        assert_eq!(parse(&bytes).unwrap(), std::slice::from_ref(&expected), "binary code {}", expected.code);
+    }
+}
+
+#[test]
+fn writes_independently_specified_ascii_and_binary_bytes() {
+    for (tag, ascii, binary) in fixtures() {
+        for utf8 in [false, true] {
+            let tags = std::slice::from_ref(&tag);
+            assert_eq!(write_ascii_as(tags, utf8).as_bytes(), ascii, "ASCII code {}", tag.code);
+            assert_eq!(write_binary(tags, utf8), [SENTINEL, binary].concat(), "binary code {}", tag.code);
+        }
+    }
+}
+
+#[test]
+fn integer_code_ranges_have_independent_binary_widths() {
+    // Specification ranges and widths, never kind_of(): a shared reader/writer mistake
+    // can round-trip every boundary value while still using the wrong number of bytes.
+    let widths = [
+        (vec![60..=79, 170..=179, 270..=289, 370..=389, 400..=409, 1060..=1070], 2, i64::from(i16::MIN), i64::from(i16::MAX)),
+        (vec![90..=99, 420..=429, 440..=459, 1071..=1071], 4, i64::from(i32::MIN), i64::from(i32::MAX)),
+        (std::iter::once(160..=169).collect(), 8, i64::MIN, i64::MAX),
+    ];
+    for (ranges, width, min, max) in widths {
+        for code in ranges.into_iter().flatten() {
+            for value in [min, min + 1, -1, 0, 1, max - 1, max] {
+                // Binary DXF uses a little-endian 16-bit group code and a fixed-width,
+                // little-endian two's-complement integer. Encoding is version-independent.
+                let code_bytes = u16::try_from(code).unwrap().to_le_bytes();
+                let value_bytes = value.to_le_bytes();
+                let expected = [SENTINEL, &code_bytes, &value_bytes[..width]].concat();
+                let tags = [Tag::i(code, value)];
+                for utf8 in [false, true] {
+                    assert_eq!(write_binary(&tags, utf8), expected, "code={code} value={value} utf8={utf8}");
+                }
+                assert_eq!(parse(&expected).unwrap(), tags, "code={code} value={value}");
+            }
+        }
+    }
+}
+
+#[test]
+fn text_encoding_has_independent_wire_expectations() {
+    let tags = [Tag::s(1, "é😀")];
+    let escaped = b"\\U+00E9\\U+D83D\\U+DE00";
+    let utf8 = b"\xc3\xa9\xf0\x9f\x98\x80";
+    for (unicode, text) in [(false, escaped.as_slice()), (true, utf8.as_slice())] {
+        let ascii = [b"  1\r\n".as_slice(), text, b"\r\n"].concat();
+        let binary = [SENTINEL, b"\x01\0", text, b"\0"].concat();
+        assert_eq!(write_ascii_as(&tags, unicode).as_bytes(), ascii, "utf8={unicode}");
+        assert_eq!(write_binary(&tags, unicode), binary, "utf8={unicode}");
+        assert_eq!(parse(&ascii).unwrap(), tags);
+        assert_eq!(parse(&binary).unwrap(), tags);
+    }
+    // Pre-2007 code-page bytes are independent of the writer, which emits Unicode escapes.
+    let ascii = b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1252\n0\nENDSEC\n1\n\x80\xe9\n0\nEOF\n";
+    let binary = [
+        SENTINEL,
+        b"\0\0SECTION\0\x02\0HEADER\0\x09\0$ACADVER\0\x01\0AC1015\0\x09\0$DWGCODEPAGE\0\x03\0ANSI_1252\0\0\0ENDSEC\0\x01\0\x80\xe9\0\0\0EOF\0",
+    ]
+    .concat();
+    for bytes in [ascii.as_slice(), binary.as_slice()] {
+        let tags = parse(bytes).unwrap();
+        assert_eq!(tags[7], Tag::s(1, "€é"));
+    }
+}
+
+#[test]
+fn ascii_accepts_line_endings_padding_and_no_final_newline() {
+    let expected = [Tag::i(70, -7), Tag::s(1, "  text  "), Tag::s(0, "EOF")];
+    for newline in ["\n", "\r\n"] {
+        for final_newline in [false, true] {
+            let mut text = [" 70 ", " -7 ", "1", "  text  ", "0", "EOF"].join(newline);
+            if final_newline {
+                text.push_str(newline);
+            }
+            assert_eq!(parse(text.as_bytes()).unwrap(), expected, "newline={newline:?} final={final_newline}");
+        }
+    }
+}
+
+#[test]
+fn malformed_and_truncated_values_are_errors_not_panics() {
+    assert!(matches!(parse(b""), Err(DxfError::NotDxf)));
+    assert!(matches!(parse(b"oops\nvalue\n"), Err(DxfError::BadCode { line: 1, .. })));
+    assert!(matches!(parse(b"10\n"), Err(DxfError::Eof)));
+    assert!(matches!(parse(SENTINEL), Err(DxfError::NotDxf)));
+    for (_, _, binary) in fixtures() {
+        // Every cut inside the first record is an error, unlike cuts between complete records:
+        // the tag API deliberately accepts streams without an EOF record.
+        for cut in 1..binary.len() {
+            let bytes = [SENTINEL, &binary[..cut]].concat();
+            assert!(matches!(parse(&bytes), Err(DxfError::Eof)), "binary={binary:?} cut={cut}");
+        }
+    }
+}
+
+#[test]
+fn tag_limit_accepts_the_exact_boundary_and_rejects_one_less() {
+    let ascii = b"1\nA\n70\n-7\n0\nEOF\n";
+    let binary = [SENTINEL, b"\x01\0A\0\x46\0\xf9\xff\0\0EOF\0"].concat();
+    for bytes in [ascii.as_slice(), binary.as_slice()] {
+        for limit in 0..3 {
+            assert!(matches!(parse_with_limit(bytes, limit), Err(DxfError::TooLarge { limit: actual, .. }) if actual == limit));
+        }
+        for limit in [3, 4] {
+            assert_eq!(parse_with_limit(bytes, limit).unwrap(), [Tag::s(1, "A"), Tag::i(70, -7), Tag::s(0, "EOF")]);
+        }
+    }
+}
@@ -0,0 +1,119 @@
+//! Hex payload conformance is distinct from binary framing capacity: DXF groups 310–319 and
+//! 1004 specify at most 127 payload bytes per chunk, even though a length byte represents 255.
+//! Inspect writer bytes without our parser; accept any compliant partition preserving payload,
+//! code and following-record framing. Oversized binary read fixtures test tolerance only.
+//! Pending writer regressions extend the chunk-size finding in issue #1025.
+//! Public DXF Reference, Group Codes in Numerical Order and Binary DXF Files:
+//! https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-3F0380A5-1C15-464D-BC66-2C5F094BCFB9.htm
+//! https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-FC1C3C69-DBC2-49E4-893A-000D6538C0FE.htm
+
+use cadcraft_dxf::{Tag, Value, parse, write_ascii_as, write_binary};
+
+const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
+const FOLLOWING_BINARY: &[u8] = b"\x46\0\xf9\xff"; // group 70, signed i16 -7
+
+fn payload(length: usize) -> Vec<u8> {
+    (0..length).map(|index| u8::try_from(index * 37 % 256).unwrap()).collect()
+}
+
+fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|byte| format!("{byte:02X}")).collect()
+}
+
+fn input(code: i32, bytes: &[u8]) -> [Tag; 2] {
+    [Tag::new(code, Value::Hex(hex(bytes))), Tag::i(70, -7)]
+}
+
+fn check_ascii(code: i32, bytes: &[u8], utf8: bool) {
+    let wire = write_ascii_as(&input(code, bytes), utf8);
+    let lines: Vec<_> = wire.lines().collect();
+    let (chunks, following) = lines.split_at(lines.len().checked_sub(2).unwrap());
+    assert_eq!(following[0].trim(), "70");
+    assert_eq!(following[1], "-7");
+    assert!(!chunks.is_empty(), "an empty payload must still have a tag");
+    let (records, remainder) = chunks.as_chunks::<2>();
+    assert!(remainder.is_empty(), "incomplete group/value pair");
+    let context = format!("ASCII code={code} bytes={} utf8={utf8}", bytes.len());
+    let mut back = Vec::new();
+    for record in records {
+        assert_eq!(record[0].trim().parse::<i32>().unwrap(), code, "{context}");
+        let text = record[1];
+        assert!(text.len() <= 254, "{context}: {} hex characters exceed 127 payload bytes", text.len());
+        assert!(text.bytes().all(|b| b.is_ascii_hexdigit()), "{context}: invalid hex");
+        let (pairs, remainder) = text.as_bytes().as_chunks::<2>();
+        assert!(remainder.is_empty(), "{context}: partial byte");
+        back.extend(pairs.iter().map(|pair| u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap()));
+    }
+    assert_eq!(back, bytes, "{context}: complete payload and byte order");
+}
+
+fn check_binary(code: i32, bytes: &[u8], utf8: bool) {
+    let wire = write_binary(&input(code, bytes), utf8);
+    let mut chunks = wire.strip_prefix(SENTINEL).unwrap().strip_suffix(FOLLOWING_BINARY).unwrap();
+    assert!(!chunks.is_empty(), "an empty payload must still have a tag");
+    let context = format!("binary code={code} bytes={} utf8={utf8}", bytes.len());
+    let mut back = Vec::new();
+    while !chunks.is_empty() {
+        let (&[lo, hi, length], rest) = chunks.split_first_chunk::<3>().unwrap();
+        assert_eq!(i32::from(u16::from_le_bytes([lo, hi])), code, "{context}");
+        assert!(length <= 127, "{context}: {length} bytes exceed the documented group limit");
+        let (chunk, next) = rest.split_at(usize::from(length));
+        back.extend_from_slice(chunk);
+        chunks = next;
+    }
+    assert_eq!(back, bytes, "{context}: complete payload and byte order");
+}
+
+#[test]
+fn conforming_payloads_have_independent_ascii_and_binary_wire_checks() {
+    for code in (310..=319).chain([1004]) {
+        for length in [0, 1, 2, 126, 127] {
+            for utf8 in [false, true] {
+                let bytes = payload(length);
+                check_ascii(code, &bytes, utf8);
+                check_binary(code, &bytes, utf8);
+            }
+        }
+    }
+}
+
+#[test]
+fn binary_reader_tolerates_the_full_length_byte_domain() {
+    // This is deliberately permissive input, not an assertion that oversized chunks conform
+    // or that the writer should produce them. The following record catches framing mistakes.
+    for code in (310_u16..=319).chain([1004]) {
+        for length in 0..=u8::MAX {
+            let bytes = payload(usize::from(length));
+            let mut wire = SENTINEL.to_vec();
+            wire.extend_from_slice(&code.to_le_bytes());
+            wire.push(length);
+            wire.extend_from_slice(&bytes);
+            wire.extend_from_slice(FOLLOWING_BINARY);
+            assert_eq!(parse(&wire).unwrap(), input(i32::from(code), &bytes), "code={code} length={length}");
+        }
+    }
+}
+
+#[test]
+#[ignore = "Confirmed ASCII DXF writer nonconformance: hex payloads above 127 bytes are emitted as one oversized chunk"]
+fn ascii_writer_splits_large_payloads_into_conforming_chunks() {
+    for code in (310..=319).chain([1004]) {
+        for length in [128, 254, 255, 256, 1024] {
+            for utf8 in [false, true] {
+                check_ascii(code, &payload(length), utf8);
+            }
+        }
+    }
+}
+
+#[test]
+#[ignore = "Confirmed binary DXF writer nonconformance: 255-byte partitioning exceeds the documented 127-byte group limit"]
+fn binary_writer_splits_large_payloads_into_conforming_chunks() {
+    for code in (310..=319).chain([1004]) {
+        for length in [128, 254, 255, 256, 1024] {
+            for utf8 in [false, true] {
+                check_binary(code, &payload(length), utf8);
+            }
+        }
+    }
+}
@@ -0,0 +1,148 @@
+//! Deterministic tag preservation through the public byte API, in both encodings and every
+//! supported version. Inputs have the group code's type and representable values; lossy
+//! coercions are not accepted as round-trip equality. Real values must retain their bits.
+
+use cadcraft_dxf::{Tag, Value, Version, is_binary, parse, write_ascii_as, write_binary};
+
+fn check(case: &str, body: &[Tag]) {
+    for version in Version::ALL {
+        let mut original = vec![
+            Tag::s(0, "SECTION"),
+            Tag::s(2, "HEADER"),
+            Tag::s(9, "$ACADVER"),
+            Tag::s(1, version.code()),
+            Tag::s(9, "$DWGCODEPAGE"),
+            Tag::s(3, "ANSI_1252"),
+            Tag::s(0, "ENDSEC"),
+            Tag::s(0, "SECTION"),
+            Tag::s(2, "ENTITIES"),
+        ];
+        original.extend_from_slice(body);
+        original.extend([Tag::s(0, "ENDSEC"), Tag::s(0, "EOF")]);
+        for binary in [false, true] {
+            let mut current = original.clone();
+            for pass in 1..=2 {
+                let context = format!("{case} · {version} · binary={binary} · pass={pass}");
+                let bytes = if binary { write_binary(&current, version.utf8()) } else { write_ascii_as(&current, version.utf8()).into_bytes() };
+                assert_eq!(is_binary(&bytes), binary, "{context}");
+                let back = parse(&bytes).unwrap_or_else(|e| panic!("{context}: {e}"));
+                assert_eq!(back.len(), original.len(), "{context}: tag count");
+                for (index, (expected, actual)) in original.iter().zip(&back).enumerate() {
+                    assert_eq!(actual, expected, "{context}: tag[{index}]");
+                    if let (Value::Real(a), Value::Real(b)) = (&expected.value, &actual.value) {
+                        assert_eq!(b.to_bits(), a.to_bits(), "{context}: tag[{index}] real bits");
+                    }
+                }
+                assert_eq!(back, current, "{context}: no additional changes on resave");
+                current = back;
+            }
+        }
+    }
+}
+
+#[test]
+fn integer_width_boundaries() {
+    // Explicit reference ranges, not obtained from the codec's kind_of().
+    let widths = [
+        (vec![60..=79, 170..=179, 270..=289, 370..=389, 400..=409, 1060..=1070], i64::from(i16::MIN), i64::from(i16::MAX)),
+        (vec![90..=99, 420..=429, 440..=459, 1071..=1071], i64::from(i32::MIN), i64::from(i32::MAX)),
+        (std::iter::once(160..=169).collect(), i64::MIN, i64::MAX),
+    ];
+    for (ranges, min, max) in widths {
+        for value in [min, min + 1, -1, 0, 1, max - 1, max] {
+            let tags: Vec<_> = ranges.iter().cloned().flatten().map(|code| Tag::i(code, value)).collect();
+            check(&format!("integer/{min}..{max}/{value}"), &tags);
+        }
+    }
+}
+
+#[test]
+fn finite_reals_keep_all_bits() {
+    let values = [
+        0.0,
+        -0.0,
+        f64::from_bits(1),
+        -f64::from_bits(1),
+        f64::MIN_POSITIVE,
+        f64::MIN_POSITIVE.next_down(),
+        0.1,
+        -3.25,
+        1.0_f64.next_down(),
+        1.0,
+        1.0_f64.next_up(),
+        1e-100,
+        -1e100,
+        f64::MAX,
+        f64::MIN,
+    ];
+    for value in values {
+        let tags: Vec<_> =
+            [10..=59, 110..=149, 210..=239, 460..=469, 1010..=1059].into_iter().flatten().map(|code| Tag::new(code, Value::Real(value))).collect();
+        check(&format!("real/{:016X}", value.to_bits()), &tags);
+    }
+}
+
+#[test]
+fn booleans() {
+    for value in [false, true] {
+        let tags: Vec<_> = (290..=299).map(|code| Tag::new(code, Value::Bool(value))).collect();
+        check(&format!("bool/{value}"), &tags);
+    }
+}
+
+#[test]
+fn strings_preserve_whitespace_unicode_and_literal_escapes() {
+    // No CR/LF or NUL: those are line/string delimiters, not losslessly writable payloads.
+    let values = [
+        ("empty", ""),
+        ("spaces", "  leading and trailing  "),
+        ("tabs", "\tindented\t"),
+        ("unicode", "Café Ø 图号 Україна 😀 e\u{301}"),
+        ("literal-escapes", r"\U+0041 \M+183A4 \U+D83D\U+DE00 \\U+005C \P %%c"),
+        ("malformed-escapes", r"\U+ \U+ZZZZ \U+D800 \U+DC00 \M+9FFFF"),
+    ];
+    for (case, value) in values {
+        let tags: Vec<_> =
+            [0..=9, 100..=100, 102..=102, 105..=105, 300..=309, 320..=369, 410..=419, 430..=439, 470..=479, 480..=481, 1000..=1003, 1005..=1005]
+                .into_iter()
+                .flatten()
+                .map(|code| Tag::s(code, value))
+                .collect();
+        check(case, &tags);
+    }
+    for length in [1, 254, 255, 256, 1024] {
+        check(&format!("string/length={length}"), &[Tag::s(1, "x".repeat(length))]);
+    }
+}
+
+#[test]
+fn hex_chunks_keep_bytes_and_order() {
+    // DXF groups 310–319 and 1004 permit 127 payload bytes per chunk. A binary length
+    // byte can represent more, but that is reader tolerance, not writer conformance.
+    // Larger payloads need chunk-size/reassembly checks rather than exact tag equality;
+    // see hex_chunks.rs for the independent wire checks and pending writer regressions.
+    for length in [0, 1, 2, 126, 127] {
+        let hex: String = (0..length).map(|i| format!("{:02X}", (i * 37) % 256)).collect();
+        let tags: Vec<_> = (310..=319).chain([1004]).map(|code| Tag::new(code, Value::Hex(hex.clone()))).collect();
+        check(&format!("hex/bytes={length}"), &tags);
+    }
+}
+
+#[test]
+fn mixed_values_and_repeated_codes_keep_order() {
+    check(
+        "mixed/repeated-codes",
+        &[
+            Tag::s(0, "TEST"),
+            Tag::f(10, 1.25),
+            Tag::s(1, "first"),
+            Tag::f(10, -2.5),
+            Tag::i(70, -7),
+            Tag::s(1, "second"),
+            Tag::new(290, Value::Bool(true)),
+            Tag::new(310, Value::Hex("00FF80".into())),
+            Tag::i(160, i64::MAX),
+            Tag::s(1, ""),
+        ],
+    );
+}
@@ -12,7 +12,7 @@ workspace = true
 cadcraft-geom = { workspace = true }
 cadcraft-color = { workspace = true }
 cadcraft-doc = { workspace = true }
-craft-dxf = { workspace = true }
+cadcraft-dxf = { workspace = true }
 cadcraft-constraints = { workspace = true }
 cadcraft-fonts = { workspace = true }
 cadcraft-render = { workspace = true }
@@ -40,12 +40,8 @@ fn arc_geom(a: &cadcraft_doc::Arc) -> cadcraft_geom::Arc {

 /// Where a snap sits on an object now.
 pub fn snap_point(d: &Drawing, a: &DimAssoc) -> Option<Vec2> {
-    snap_on(d, &d.entity(a.handle)?.kind, &a.snap)
-}
-
-/// Where `snap` sits on an object of kind `kind` (an intersection finds its other line in `d`).
-fn snap_on(d: &Drawing, kind: &EntityKind, snap: &AssocSnap) -> Option<Vec2> {
-    match (kind, snap) {
+    let e = d.entity(a.handle)?;
+    match (&e.kind, &a.snap) {
        (EntityKind::Line(l), AssocSnap::Start) => Some(l.a.xy()),
        (EntityKind::Line(l), AssocSnap::End) => Some(l.b.xy()),
        (EntityKind::Line(l), AssocSnap::Mid) => Some(l.a.xy().mid(l.b.xy())),
@@ -92,61 +88,6 @@ fn candidates(kind: &EntityKind) -> Vec<(AssocSnap, Vec2)> {
    }
 }

-/// Whether two snaps are the same kind of object point: an endpoint or vertex, a centre, or a
-/// midpoint.
-fn same_kind(a: &AssocSnap, b: &AssocSnap) -> bool {
-    matches!(
-        (a, b),
-        (AssocSnap::Start | AssocSnap::End | AssocSnap::Vertex { .. }, AssocSnap::Start | AssocSnap::End | AssocSnap::Vertex { .. })
-            | (AssocSnap::Center, AssocSnap::Center)
-            | (AssocSnap::Mid, AssocSnap::Mid)
-    )
-}
-
-/// BREAK or TRIM reshaped the object `pieces[0]` (which was `old`) and added the other pieces:
-/// move the dimension attachments on it as AutoCAD 2024 does. An attachment whose point is still
-/// a point of the same kind on the object stays there (a closed polyline opened by BREAK numbers
-/// its vertices from the break); one whose point is on a new piece moves to that piece, so a
-/// dimension across a line broken in its middle stays where it was; any other is left as it was,
-/// so the dimension follows the object's new end when that end was cut off. Attachments at an
-/// angle on a circle or arc and at an intersection stay on the object. [`update`] moves the
-/// definition points after the command.
-pub fn follow_pieces(d: &mut Drawing, old: &EntityKind, pieces: &[Handle]) {
-    let Some(&h) = pieces.first() else { return };
-    let mut changes: Vec<(Handle, Vec<DimAssoc>)> = Vec::new();
-    for store in std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)) {
-        for e in store.iter() {
-            let EntityKind::Dimension(dm) = &e.kind else { continue };
-            if !dm.assoc.iter().any(|a| a.handle == h) {
-                continue;
-            }
-            let assoc: Vec<DimAssoc> = dm.assoc.iter().map(|a| on_piece(d, old, pieces, a).unwrap_or_else(|| a.clone())).collect();
-            if assoc != dm.assoc {
-                changes.push((e.handle, assoc));
-            }
-        }
-    }
-    for (dh, assoc) in changes {
-        let _ = d.modify_entity(dh, |e| {
-            if let EntityKind::Dimension(dm) = &mut e.kind {
-                dm.assoc = assoc;
-            }
-        });
-    }
-}
-
-/// The piece attachment `a` moves to when its object became `pieces` (see [`follow_pieces`]).
-fn on_piece(d: &Drawing, old: &EntityKind, pieces: &[Handle], a: &DimAssoc) -> Option<DimAssoc> {
-    if pieces.first() != Some(&a.handle) || matches!(a.snap, AssocSnap::OnCircle { .. } | AssocSnap::Intersection { .. }) {
-        return None;
-    }
-    let p = snap_on(d, old, &a.snap)?;
-    pieces.iter().find_map(|&ph| {
-        let (snap, _) = candidates(&d.entity(ph)?.kind).into_iter().find(|(s, q)| same_kind(&a.snap, s) && close(p, *q))?;
-        Some(DimAssoc { point: a.point.clone(), handle: ph, snap })
-    })
-}
-
 /// An object point exactly at `p` (an endpoint, vertex, centre or midpoint) to attach to.
 pub fn find_snap(d: &Drawing, space: &Space, p: Vec2) -> Option<(Handle, AssocSnap)> {
    if !p.is_finite() {
@@ -303,10 +244,8 @@ pub fn recompute(dm: &Dimension, prev: Option<&Dimension>, before: &Drawing, aft
    let was = prev.unwrap_or(dm);
    nd.assoc.retain(|a| {
        let Some(old) = def_point(was, &a.point) else { return false };
-        // Only follow if the point sat on the object before the change, as attached then (BREAK
-        // and TRIM may have moved the attachment to a piece of the object since).
-        let held = was.assoc.iter().find(|o| o.point == a.point).unwrap_or(a);
-        if let Some(prev) = snap_point(before, held)
+        // Only follow if the point sat on the object before the change.
+        if let Some(prev) = snap_point(before, a)
            && !close(prev, old.xy())
        {
            return false;
@@ -365,20 +304,16 @@ pub fn update(after: &mut Arc<Drawing>, before: &Drawing) -> usize {
                if dm.assoc.is_empty() {
                    continue;
                }
-                let prev = match before.entity(e.handle).map(|x| &x.kind) {
-                    Some(EntityKind::Dimension(p)) => Some(p),
-                    _ => None,
-                };
-                // Its objects changed, or the command moved an attachment (BREAK and TRIM move them
-                // to new pieces, which a later pick of the same TRIM may reshape again).
                let touched = dm.assoc.iter().any(|a| {
-                    src_changed(before, d, a.handle)
-                        || matches!(a.snap, AssocSnap::Intersection { other } if src_changed(before, d, other))
-                        || prev.is_some_and(|p| !p.assoc.contains(a))
+                    src_changed(before, d, a.handle) || matches!(a.snap, AssocSnap::Intersection { other } if src_changed(before, d, other))
                });
                if !touched {
                    continue;
                }
+                let prev = match before.entity(e.handle).map(|x| &x.kind) {
+                    Some(EntityKind::Dimension(p)) => Some(p),
+                    _ => None,
+                };
                let nd = recompute(dm, prev, before, d);
                if nd != *dm {
                    changes.push((e.handle, nd));
@@ -16,31 +16,10 @@ use std::fs::{File, OpenOptions, Permissions};
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::{Arc, Mutex, OnceLock, Weak};

 /// Monotonic counter making temporary names unique within this process without a RNG dependency.
 static SEQ: AtomicU64 = AtomicU64::new(0);

-/// Locks held from destination metadata inspection through rename, so concurrent writes cannot
-/// combine permissions from one version of a path with the group of another.
-fn path_lock(path: &Path) -> Arc<Mutex<()>> {
-    static LOCKS: OnceLock<Mutex<std::collections::HashMap<PathBuf, Weak<Mutex<()>>>>> = OnceLock::new();
-    let absolute = if path.is_absolute() { path.to_path_buf() } else { std::env::current_dir().unwrap_or_default().join(path) };
-    let key = match (absolute.parent(), absolute.file_name()) {
-        (Some(parent), Some(name)) => std::fs::canonicalize(parent).unwrap_or_else(|_| parent.to_path_buf()).join(name),
-        _ => absolute,
-    };
-    let mut locks = LOCKS.get_or_init(|| Mutex::new(std::collections::HashMap::new())).lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-    locks.retain(|_, lock| lock.strong_count() > 0);
-    if let Some(lock) = locks.get(&key).and_then(Weak::upgrade) {
-        lock
-    } else {
-        let lock = Arc::new(Mutex::new(()));
-        locks.insert(key, Arc::downgrade(&lock));
-        lock
-    }
-}
-
 /// How many fresh temporary names to try before giving up (each collision is another local race).
 const MAX_TRIES: u32 = 32;

@@ -54,15 +33,13 @@ pub fn write_atomic(path: &Path, bytes: &[u8]) -> io::Result<()> {
    // A symlinked destination is resolved so the link stays a link and its target is replaced.
    let resolved = resolve_symlink(path)?;
    let path = resolved.as_deref().unwrap_or(path);
-    let lock = path_lock(path);
-    let _guard = lock.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
    let permissions = match std::fs::symlink_metadata(path) {
        Ok(meta) if meta.is_file() => Some(meta.permissions()),
        Ok(_) => None,
        Err(e) if e.kind() == io::ErrorKind::NotFound => None,
        Err(e) => return Err(e),
    };
-    write_atomic_with_locked(path, permissions, |file| file.write_all(bytes))
+    write_atomic_with(path, permissions, |file| file.write_all(bytes))
 }

 /// The topmost folder missing above `path`: what [`write_atomic_making_folders`] will create.
@@ -90,30 +67,10 @@ pub fn write_atomic_making_folders(path: &Path, bytes: &[u8]) -> io::Result<()>
 /// 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.
 pub fn write_atomic_with(path: &Path, permissions: Option<Permissions>, fill: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> {
-    let lock = path_lock(path);
-    let _guard = lock.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-    write_atomic_with_locked(path, permissions, fill)
-}
-
-/// [`write_atomic_with`] with permissions derived under the same destination lock as the write.
-pub fn write_atomic_with_permissions(
-    path: &Path,
-    permissions: impl FnOnce() -> io::Result<Option<Permissions>>,
-    fill: impl FnOnce(&mut File) -> io::Result<()>,
-) -> io::Result<()> {
-    let lock = path_lock(path);
-    let _guard = lock.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-    let permissions = permissions()?;
-    write_atomic_with_locked(path, permissions, fill)
-}
-
-fn write_atomic_with_locked(path: &Path, permissions: Option<Permissions>, fill: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> {
    let dir = path.parent().filter(|p| !p.as_os_str().is_empty()).map_or_else(|| PathBuf::from("."), Path::to_path_buf);
    let (mut file, tmp) = create_temp(&dir, permissions.as_ref())?;
    let write = (|| {
        if let Some(permissions) = permissions {
-            #[cfg(unix)]
-            let permissions = keep_group(&file, path, permissions);
            file.set_permissions(permissions)?;
        }
        fill(&mut file)?;
@@ -133,20 +90,6 @@ fn write_atomic_with_locked(path: &Path, permissions: Option<Permissions>, fill:
    Ok(())
 }

-/// `permissions` for the new file when `path` already exists: the group bits mean "this group" only
-/// if the file is still in the old file's group, so the group is restored first. When it can't be
-/// (the user is not a member of it), the group bits are dropped rather than handed to another group.
-#[cfg(unix)]
-fn keep_group(file: &File, path: &Path, permissions: Permissions) -> Permissions {
-    use std::os::unix::fs::{MetadataExt, PermissionsExt, fchown};
-    let Ok(old) = std::fs::symlink_metadata(path) else { return permissions };
-    // A file already in the old group needs no change (and a restrictive syscall policy may refuse a no-op fchown).
-    if !old.is_file() || file.metadata().is_ok_and(|m| m.gid() == old.gid()) || fchown(file, None, Some(old.gid())).is_ok() {
-        return permissions;
-    }
-    Permissions::from_mode(permissions.mode() & !0o070)
-}
-
 /// Flush `dir` so a rename just made in it survives a crash or power loss (POSIX records a
 /// rename in the directory, not in the file). Best effort: some file systems (network shares)
 /// refuse to sync a directory, and the file itself is already on disk.
@@ -288,33 +231,6 @@ mod tests {
        std::fs::remove_dir_all(&dir).ok();
    }

-    /// The replacement keeps the old file's group (when the user is in another group, as `id -G`
-    /// says) together with its mode, so the group bits never name a different group.
-    #[cfg(unix)]
-    #[test]
-    fn keeps_the_group_and_mode_of_the_file_it_replaces() {
-        use std::os::unix::fs::{MetadataExt, PermissionsExt, chown};
-        let dir = std::env::temp_dir().join(format!("cadcraft-aw-grp-{}-{}", std::process::id(), SEQ.fetch_add(1, Ordering::Relaxed)));
-        std::fs::create_dir_all(&dir).unwrap();
-        let dest = dir.join("out.bin");
-        std::fs::write(&dest, b"old").unwrap();
-        std::fs::set_permissions(&dest, Permissions::from_mode(0o640)).unwrap();
-        let own = std::fs::metadata(&dest).unwrap().gid();
-        let other = std::process::Command::new("id")
-            .arg("-G")
-            .output()
-            .ok()
-            .and_then(|o| String::from_utf8_lossy(&o.stdout).split_whitespace().filter_map(|g| g.parse::<u32>().ok()).find(|g| *g != own));
-        if let Some(gid) = other {
-            chown(&dest, None, Some(gid)).unwrap();
-        }
-        let want = std::fs::metadata(&dest).unwrap();
-        write_atomic(&dest, b"new").unwrap();
-        let got = std::fs::metadata(&dest).unwrap();
-        assert_eq!((got.gid(), got.mode() & 0o777), (want.gid(), 0o640));
-        std::fs::remove_dir_all(&dir).ok();
-    }
-
    #[cfg(unix)]
    #[test]
    fn does_not_follow_a_planted_temp_symlink() {
@@ -144,10 +144,10 @@ impl BlockEdit {
        }
        let host = &self.host.doc;
        let mut d = editor.clone();
-        // When saving a copy, the source keeps its last saved definition. The editor's own
-        // table entry can still be the one from before BSAVE; the copy gets the edited data.
+        // When the block is saved under another name, the edited block keeps the drawing's
+        // description and block `name` gets the description changed in the editor.
        if !name.eq_ignore_ascii_case(&self.name) {
-            restore_saved_definition(&mut d, host, &self.name);
+            keep_description(&mut d, host, &self.name);
        }
        d.model = host.model.clone();
        d.layouts = host.layouts.clone();
@@ -176,13 +176,16 @@ impl BlockEdit {
    }
 }

-/// Keep the source block's saved objects and metadata when the edited objects are saved as a copy.
-/// Without a saved source, drop the empty definition an editor description may have created.
-fn restore_saved_definition(d: &mut Drawing, host: &Drawing, name: &str) {
+/// Give block `name` of `d` the description `host` has for it, or, when `host` has no such block,
+/// drop the empty definition a description gives a block the editor started and never saved.
+fn keep_description(d: &mut Drawing, host: &Drawing, name: &str) {
    match host.block(name) {
        Some(h) => {
-            let key = d.blocks.keys().find(|key| key.eq_ignore_ascii_case(name)).cloned().unwrap_or_else(|| h.name.clone());
-            d.blocks.insert(key, h.clone());
+            if let Some((_, b)) = d.blocks.iter_mut().find(|(k, _)| k.eq_ignore_ascii_case(name))
+                && b.description != h.description
+            {
+                Arc::make_mut(b).description = h.description.clone();
+            }
        }
        None => d.blocks.retain(|k, b| !(k.eq_ignore_ascii_case(name) && b.entities.is_empty())),
    }
@@ -299,7 +302,7 @@ impl DocState {
            let was = be.name.clone();
            let reconcile = |doc: &mut Arc<Drawing>| {
                let editor = Arc::make_mut(doc);
-                restore_saved_definition(editor, &d, &was);
+                keep_description(editor, &d, &was);
                editor.blocks.retain(|k, _| !k.eq_ignore_ascii_case(&name));
                editor.blocks.insert(name.clone(), b.clone());
            };
@@ -178,34 +178,14 @@ fn create(s: &mut Session, objs: &[Handle], base: Vec2, p: ArrayParams, assoc: b
    Ok(json!({ "created": n }))
 }

-/// The most objects EXPLODE of one associative array makes from its source objects (ten times the
-/// default MAXARRAY).
-const MAX_EXPLODED_OBJECTS: usize = 1_000_000;
-
 /// EXPLODE of an associative array: every item becomes the objects of its block (the source
 /// objects, or a replacement block's reference), in world coordinates. `None` for other objects.
-///
-/// An array that would explode into more than [`MAX_EXPLODED_OBJECTS`] objects (items times the
-/// objects of the source block, which a file sets freely) is not expanded here: `None`, so EXPLODE
-/// takes the array block's own items.
 pub(crate) fn explode_array(d: &Drawing, e: &Entity) -> Option<Vec<Entity>> {
    let EntityKind::Insert(ins) = &e.kind else { return None };
    let p = d.array_params(e)?;
    let blk = d.block(&ins.block)?;
    let m = ins.transform(blk.base.xy());
-    // Count first: a hostile array must be refused before any entity is cloned.
-    let total = blk
-        .entities
-        .iter()
-        .map(|it| match &it.kind {
-            EntityKind::Insert(i) if i.block.eq_ignore_ascii_case(&p.source) => d.block(&i.block).map_or(1, |b| b.entities.len()),
-            _ => 1,
-        })
-        .fold(0usize, usize::saturating_add);
-    if total > MAX_EXPLODED_OBJECTS {
-        return None;
-    }
-    let mut out = Vec::with_capacity(total);
+    let mut out = Vec::new();
    for item in blk.entities.iter() {
        let item = placed(e, item, &m);
        let source = match &item.kind {
@@ -213,9 +193,7 @@ pub(crate) fn explode_array(d: &Drawing, e: &Entity) -> Option<Vec<Entity>> {
            _ => None,
        };
        match source {
-            Some((im, b)) => {
-                out.extend(b.entities.iter().map(|se| placed(&item, se, &im)));
-            }
+            Some((im, b)) => out.extend(b.entities.iter().map(|se| placed(&item, se, &im))),
            None => out.push(item),
        }
    }
@@ -270,16 +248,9 @@ fn max_count(s: &Session, others: u64, objs: usize) -> u64 {
 }

 fn copy_all(s: &mut Session, hs: &[Handle], mats: impl Iterator<Item = Mat3>) -> Result<usize> {
-    // Every copy is checked before the first is made: a refusal part way would leave the copies
-    // already added in the drawing (a failed command is not rolled back).
-    let mats: Vec<Mat3> = mats.collect();
-    // A matrix every frame accepts needs no look at the objects; otherwise they are looked at once.
-    if mats.iter().any(|m| !cadcraft_doc::ole_frame_accepts(m)) && super::modify::holds_ole_frame(s, hs, true)? {
-        return Err(super::modify::ole_refusal());
-    }
    let mut n = 0;
-    for m in &mats {
-        n += transform_entities(s, hs, m, true)?.len();
+    for m in mats {
+        n += transform_entities(s, hs, &m, true)?.len();
    }
    Ok(n)
 }
@@ -188,9 +188,8 @@ fn item_at(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Option<(u32, u32, u32)
    let mut best: Option<((u32, u32, u32), f64)> = None;
    // Each block's own extents, measured once.
    let mut extents: HashMap<String, (Vec2, Bounds2)> = HashMap::new();
-    let block_for = p.block_lookup();
    for it in p.items()? {
-        let name = block_for(it.i, it.j, it.level);
+        let name = p.block_for(it.i, it.j, it.level);
        let (base, local) = match extents.get(name) {
            Some(x) => *x,
            None => {
@@ -157,7 +157,7 @@ fn write_audit_log(_: &Session, _: &crate::audit::Report) {}

 #[cfg(not(target_arch = "wasm32"))]
 fn read_path(cmd: &str, path: &str) -> Result<Vec<u8>> {
-    crate::capped_read::read_capped(std::path::Path::new(path), file::MAX_DRAWING_BYTES).map_err(|e| bad(cmd, format!("{path}: {e}")))
+    std::fs::read(path).map_err(|e| bad(cmd, format!("{path}: {e}")))
 }

 #[cfg(target_arch = "wasm32")]
@@ -15,7 +15,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St

 pub(super) fn blockreplace_spec() -> CommandSpec {
    CommandSpec::new("blockreplace", "Replace Block...", run_blockreplace)
-        .menu(&["Tools", "Additional Tools", "Replace Block..."])
+        .menu(&["Tools", "Express Tools", "Replace Block..."])
        .alias(&["-blockreplace"])
        .params("{block (the block whose references are replaced), with (the replacement block), purge?: bool (default false: remove the replaced block's definition when nothing references it any more)} → {block, with, replaced, purged}")
        .interactive(|_| Ok(Box::new(BlockreplaceM::default())))
@@ -184,10 +184,8 @@ impl Interactive for BlockreplaceM {
    }
    fn prompt(&self, _s: &Session) -> Prompt {
        match self.stage {
-            Stage::Old => Prompt::new("Enter the name of the block to replace", Accept::TEXT).kw(&["?", "Select"]).takes_block(),
-            Stage::New => {
-                Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]).takes_block()
-            }
+            Stage::Old => Prompt::new("Enter the name of the block to replace", Accept::TEXT).kw(&["?", "Select"]),
+            Stage::New => Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]),
            Stage::Select => Prompt::new("Select a block reference", Accept::SELECT),
            Stage::Purge => Prompt::new(format!("Purge the unreferenced block definition {}?", self.old), KW).kw(&["Yes", "No"]).default("Yes"),
        }
@@ -12,7 +12,7 @@ use crate::{Result, Session};

 pub(super) fn burst_spec() -> CommandSpec {
    CommandSpec::new("burst", "Explode Attributes to Text", run_burst)
-        .menu(&["Tools", "Additional Tools", "Explode Attributes to Text"])
+        .menu(&["Tools", "Express Tools", "Explode Attributes to Text"])
        .params("{handles?} (block references; other objects are left alone) → {handles}")
        .interactive(|_| Ok(Box::new(SelectRun::new("burst", "BURST"))))
 }
@@ -2,9 +2,9 @@
 //! block name and values, or one row per reference with its handle, layer, position and
 //! rotation — returned, written to a CSV file and/or inserted as a table. Tags match in any case.

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

-use cadcraft_doc::{Drawing, EntityKind, Insert};
+use cadcraft_doc::{EntityKind, Insert};
 use cadcraft_geom::Vec2;
 use serde_json::{Value, json};

@@ -88,73 +88,20 @@ fn matches(spec: &str, text: &str) -> bool {
    spec.split(',').any(|p| wildcard(p.trim(), text))
 }

-/// The constant attribute values of a block definition whose tags are selected for output.
-fn constants(b: &cadcraft_doc::Block, selected: &[String]) -> Vec<(String, String)> {
-    let mut v: Vec<(String, String)> = Vec::new();
-    for e in b.entities.iter() {
-        if let EntityKind::AttDef(a) = &e.kind
-            && a.constant
-            && selected.iter().any(|tag| tag == &a.tag.to_ascii_uppercase())
-            && !v.iter().any(|(t, _)| t.eq_ignore_ascii_case(&a.tag))
-        {
-            v.push((a.tag.to_ascii_uppercase(), a.text.value.clone()));
-        }
-    }
-    v
-}
-
-/// The attribute values of `ins` that `o.tags` selects: its own, then the constant ones of its
-/// block (`consts`, read once per block). Values no column shows are not copied.
-fn values(ins: &Insert, consts: &[(String, String)], selected: &[String]) -> Vec<(String, String)> {
-    let mut v: Vec<(String, String)> = ins
-        .attribs
-        .iter()
-        .map(|a| (a.tag.to_ascii_uppercase(), a))
-        .filter(|(t, _)| selected.contains(t))
-        .map(|(t, a)| (t, a.text.value.clone()))
-        .collect();
-    for (t, val) in consts {
-        if !v.iter().any(|(k, _)| k.eq_ignore_ascii_case(t)) {
-            v.push((t.clone(), val.clone()));
-        }
-    }
-    v
-}
-
-/// Select the output columns before copying any attribute text. A block definition can contain
-/// many large constants that do not survive the table's 190-column limit.
-fn selected_tags(ents: &[std::sync::Arc<cadcraft_doc::Entity>], d: &Drawing, o: &Options) -> Vec<String> {
-    let mut selected = Vec::new();
-    let mut add = |tag: &str| {
-        let tag = tag.to_ascii_uppercase();
-        if selected.len() < MAX_TAGS && matches(&o.tags, &tag) && !selected.contains(&tag) {
-            selected.push(tag);
-        }
-    };
-    let mut scanned = std::collections::HashSet::new();
-    for entity in ents {
-        let EntityKind::Insert(ins) = &entity.kind else { continue };
-        let anonymous = ins.block.starts_with('*') || d.block(&ins.block).is_some_and(|b| b.anonymous);
-        if anonymous || !matches(&o.blocks, &ins.block) {
-            continue;
-        }
-        for attribute in &ins.attribs {
-            add(&attribute.tag);
-        }
-        // A block's constants are read once, however many inserts reference it.
-        if scanned.insert(ins.block.as_str())
-            && let Some(block) = d.block(&ins.block)
-        {
-            for entity in block.entities.iter() {
-                if let EntityKind::AttDef(attribute) = &entity.kind
-                    && attribute.constant
-                {
-                    add(&attribute.tag);
-                }
+/// The attribute values of `ins`: its own, then the constant ones of its block.
+fn values(d: &cadcraft_doc::Drawing, ins: &Insert) -> Vec<(String, String)> {
+    let mut v: Vec<(String, String)> = ins.attribs.iter().map(|a| (a.tag.to_ascii_uppercase(), a.text.value.clone())).collect();
+    if let Some(b) = d.block(&ins.block) {
+        for e in b.entities.iter() {
+            if let EntityKind::AttDef(a) = &e.kind
+                && a.constant
+                && !v.iter().any(|(t, _)| t.eq_ignore_ascii_case(&a.tag))
+            {
+                v.push((a.tag.to_ascii_uppercase(), a.text.value.clone()));
            }
        }
    }
-    selected
+    v
 }

 /// The block references to extract from: `handles` when given, else model space and the layouts.
@@ -165,9 +112,7 @@ fn found(s: &Session, p: &Value, o: &Options) -> Result<Vec<Found>> {
    } else {
        d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).cloned().collect()
    };
-    let selected = selected_tags(&ents, d, o);
    let mut out = Vec::new();
-    let mut consts: HashMap<String, Vec<(String, String)>> = HashMap::new();
    for e in &ents {
        let EntityKind::Insert(ins) = &e.kind else { continue };
        let anonymous = ins.block.starts_with('*') || d.block(&ins.block).is_some_and(|b| b.anonymous);
@@ -176,17 +121,12 @@ fn found(s: &Session, p: &Value, o: &Options) -> Result<Vec<Found>> {
        }
        let block = d.block(&ins.block).map(|b| b.name.clone()).unwrap_or_else(|| ins.block.clone());
        out.push(Found {
+            block,
            handle: e.handle.hex(),
            layer: e.common.layer.clone(),
            at: ins.insert.xy(),
            rotation: ins.rotation.to_degrees(),
-            block: block.clone(),
-            values: values(
-                ins,
-                // Keyed by the resolved definition's exact name: `Part` and `PART` can both exist.
-                consts.entry(block.clone()).or_insert_with(|| d.block(&ins.block).map(|b| constants(b, &selected)).unwrap_or_default()),
-                &selected,
-            ),
+            values: values(d, ins),
        });
    }
    Ok(out)
@@ -85,8 +85,7 @@ fn read_drawing(path: &str) -> Result<Drawing> {
 fn read_file(_path: &str) -> Result<Vec<u8>> {
    #[cfg(not(target_arch = "wasm32"))]
    {
-        crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
-            .map_err(|e| bad("insert", format!("{_path}: {e}")))
+        std::fs::read(_path).map_err(|e| bad("insert", format!("{_path}: {e}")))
    }
    #[cfg(target_arch = "wasm32")]
    Err(bad("insert", "paths are not available on the web"))
@@ -34,7 +34,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
            .noundo(),
        CommandSpec::new("-xref", "External References", run_dash_xref)
            .alias(&["-xr"])
-            .params("{option: \"?\"|bind|detach|path|unload|reload|overlay|attach|type, names?: \"A,B*\" (default *), exact?: bool (names are literal xref names, no wildcards or commas), path? (path, attach, overlay), insert?: bool (bind: Insert type), overlay?: bool (type), at?, scale?, rotation? (attach)}")
+            .params("{option: \"?\"|bind|detach|path|unload|reload|overlay|attach|type, names?: \"A,B*\" (default *), path? (path, attach, overlay), insert?: bool (bind: Insert type), overlay?: bool (type), at?, scale?, rotation? (attach)}")
            .interactive(|_| Ok(Box::new(XrefM::new("-XREF", XStage::Option)))),
        CommandSpec::new("xbind", "Bind...", run_xbind)
            .menu(&["Modify", "Object", "External Reference", "Bind..."])
@@ -50,7 +50,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
 }

 /// Load the xrefs of drawing `i`, just opened (OPEN): the opened state counts as saved, and the
-/// view frames the drawing with them, unless the drawing opened on the view it was saved at.
+/// view frames the drawing with them.
 pub(crate) fn after_open(s: &mut Session, i: usize) {
    let px = s.viewport_px;
    let Some(st) = s.docs.get_mut(i) else { return };
@@ -61,7 +61,7 @@ pub(crate) fn after_open(s: &mut Session, i: usize) {
    let out = load::load_all(Arc::make_mut(&mut st.doc), path.as_deref());
    st.saved = st.doc.clone();
    let ext = st.doc.extents(&cadcraft_doc::Space::Model);
-    if !ext.is_empty() && crate::view::saved_view(&st.doc).is_none() {
+    if !ext.is_empty() {
        // Fit in the frame of the saved twist, which open_drawing has restored.
        let twist = st.view().twist;
        let (center, w, h) = crate::View::twisted_box(ext, twist);
@@ -201,46 +201,6 @@ fn run_xattach(s: &mut Session, p: &Value) -> Result<Value> {

 /// The xrefs a JSON call names (`names`, default all); an error when none match.
 fn named(s: &Session, cmd: &str, p: &Value) -> Result<Vec<String>> {
-    if p.get("exact").and_then(Value::as_bool) == Some(true) {
-        let lits: Vec<&str> = match p.get("names") {
-            Some(Value::Array(a)) => a.iter().filter_map(Value::as_str).collect(),
-            Some(Value::String(t)) => vec![t.as_str()],
-            _ => str_param(p, "name").into_iter().collect(),
-        };
-        let d = s.doc()?;
-        let mut names = Vec::new();
-        let mut selected = std::collections::HashSet::new();
-        // Symbol names are case-insensitive: two xrefs that differ only by case can't be loaded together.
-        let mut folded = std::collections::HashMap::new();
-        for literal in &lits {
-            if let Some(block) = xrefs(d).find(|block| block.name == *literal) {
-                if let Some(first) = folded.insert(block.name.to_ascii_lowercase(), block.name.clone()).filter(|f| *f != block.name) {
-                    return Err(bad(cmd, format!("xref names \"{first}\" and \"{}\" differ only by case", block.name)));
-                }
-                if selected.insert(block.name.clone()) {
-                    names.push(block.name.clone());
-                }
-                continue;
-            }
-            let normalized = literal.to_ascii_lowercase();
-            let mut matches = xrefs(d).filter(|block| block.name.to_ascii_lowercase() == normalized);
-            if let Some(block) = matches.next() {
-                if matches.next().is_some() {
-                    return Err(bad(cmd, format!("xref name \"{literal}\" is ambiguous ignoring case")));
-                }
-                if let Some(first) = folded.insert(block.name.to_ascii_lowercase(), block.name.clone()).filter(|f| *f != block.name) {
-                    return Err(bad(cmd, format!("xref names \"{first}\" and \"{}\" differ only by case", block.name)));
-                }
-                if selected.insert(block.name.clone()) {
-                    names.push(block.name.clone());
-                }
-            }
-        }
-        if names.is_empty() {
-            return Err(bad(cmd, format!("no xref named \"{}\"", lits.join(","))));
-        }
-        return Ok(names);
-    }
    let pattern = match p.get("names") {
        Some(Value::Array(a)) => a.iter().filter_map(Value::as_str).collect::<Vec<_>>().join(","),
        Some(Value::String(t)) => t.clone(),
@@ -263,19 +223,6 @@ fn run_xref(s: &mut Session, _p: &Value) -> Result<Value> {
    Ok(r)
 }

-/// An error when two of `names` (or, with `all`, one of them and any other attached xref) differ only
-/// by case: symbol names are case-insensitive, so such xrefs cannot be handled together, and the
-/// command must refuse before it changes anything.
-fn refuse_case_clash(d: &Drawing, cmd: &str, names: &[String], all: bool) -> Result<()> {
-    let others: Vec<&str> = if all { xrefs(d).map(|b| b.name.as_str()).collect() } else { names.iter().map(String::as_str).collect() };
-    for n in names {
-        if let Some(o) = others.iter().find(|o| *o != n && o.eq_ignore_ascii_case(n)) {
-            return Err(bad(cmd, format!("xref names \"{n}\" and \"{o}\" differ only by case")));
-        }
-    }
-    Ok(())
-}
-
 fn run_dash_xref(s: &mut Session, p: &Value) -> Result<Value> {
    let option = str_param(p, "option").unwrap_or("?").trim().to_ascii_lowercase();
    let host = host(s);
@@ -305,7 +252,6 @@ fn run_dash_xref(s: &mut Session, p: &Value) -> Result<Value> {
        }
        "detach" | "d" => {
            let names = named(s, "-xref", p)?;
-            refuse_case_clash(s.doc()?, "-xref", &names, true)?;
            let mut erased = 0;
            for n in &names {
                erased += load::detach(s.doc_mut()?, n);
@@ -330,7 +276,6 @@ fn run_dash_xref(s: &mut Session, p: &Value) -> Result<Value> {
        "path" | "p" => {
            let path = str_param(p, "path").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("-xref", "`path` is required"))?.to_string();
            let names = named(s, "-xref", p)?;
-            refuse_case_clash(s.doc()?, "-xref", &names, false)?;
            let d = s.doc_mut()?;
            for n in &names {
                if let Some(b) = d.blocks.get_mut(n) {
@@ -313,23 +313,7 @@ pub(crate) fn load(d: &mut Drawing, name: &str, host: Option<&str>, chosen: bool
 /// [`load`] the xrefs `names` within one set of limits.
 pub(crate) fn load_each(d: &mut Drawing, names: &[String], host: Option<&str>, chosen: bool) -> Vec<Outcome> {
    let mut cx = Ctx::new(host);
-    // Names are case-insensitive, so a name that differs only by case from an earlier one is the same xref.
-    let mut seen = std::collections::HashMap::new();
-    names
-        .iter()
-        .flat_map(|n| match seen.entry(n.to_ascii_lowercase()) {
-            std::collections::hash_map::Entry::Vacant(v) => {
-                v.insert(n.as_str());
-                load_with(d, n, host, chosen, &mut cx)
-            }
-            // Reported, not silent: the skipped xref keeps its status and is not loaded here.
-            std::collections::hash_map::Entry::Occupied(o) => vec![Outcome {
-                name: String::new(),
-                status: XrefStatus::Unresolved,
-                detail: format!("xref \"{n}\" not loaded: it differs only by case from \"{}\"", o.get()),
-            }],
-        })
-        .collect()
+    names.iter().flat_map(|n| load_with(d, n, host, chosen, &mut cx)).collect()
 }

 impl Ctx {
@@ -453,32 +453,14 @@ impl Chain {
    }
    /// Point and unit tangent at arc length `d` from the start (clamped).
    pub fn at_length(&self, d: f64) -> Option<(Vec2, Vec2)> {
-        self.at_length_in(&self.end_lengths(), d)
-    }
-    /// The arc length from the chain's start to the end of each segment, for [`Self::at_length_in`].
-    pub fn end_lengths(&self) -> Vec<f64> {
-        self.segs
-            .iter()
-            .scan(0.0, |acc, s| {
-                *acc += s.len();
-                Some(*acc)
-            })
-            .collect()
-    }
-    /// [`Self::at_length`] with the segment end lengths computed once (`ends` from
-    /// [`Self::end_lengths`]), so many samples along one chain each cost a binary search.
-    pub fn at_length_in(&self, ends: &[f64], d: f64) -> Option<(Vec2, Vec2)> {
-        let first = ends.partition_point(|e| d > e + 1e-12);
-        // A segment of no length can't hold the point; the next one that has length does.
-        // `ends` never decreases, so the first segment past `first` with length is found by search
-        // (a run of zero-length segments can be long) instead of a scan.
-        let base = first.checked_sub(1).and_then(|p| ends.get(p)).copied().unwrap_or(0.0);
-        let i = first + ends.get(first..).unwrap_or_default().partition_point(|e| *e <= base);
-        let i = (i < self.segs.len()).then_some(i);
-        if let Some(s) = i.and_then(|i| self.segs.get(i)) {
-            let start = i.and_then(|i| i.checked_sub(1)).and_then(|p| ends.get(p)).copied().unwrap_or(0.0);
-            let t = ((d - start) / s.len()).clamp(0.0, 1.0);
-            return Some((s.at(t), s.tangent(t)));
+        let mut acc = 0.0;
+        for s in &self.segs {
+            let l = s.len();
+            if d <= acc + l + 1e-12 && l > 0.0 {
+                let t = ((d - acc) / l).clamp(0.0, 1.0);
+                return Some((s.at(t), s.tangent(t)));
+            }
+            acc += l;
        }
        self.segs.last().map(|s| (s.end(), s.tangent(1.0)))
    }
@@ -658,34 +640,6 @@ pub fn reverse_vertices(vs: &[PolyVertex], closed: bool) -> Vec<PolyVertex> {
 mod tests {
    use super::*;

-    /// The indexed lookup gives the point and tangent a scan from the start gives, also past the
-    /// ends and over a segment of no length.
-    #[test]
-    fn at_length_in_matches_a_scan() {
-        let l = |a: (f64, f64), b: (f64, f64)| Segment::Line(Line::new(Vec2::new(a.0, a.1), Vec2::new(b.0, b.1)));
-        let c = Chain {
-            segs: vec![l((0.0, 0.0), (0.0, 0.0)), l((0.0, 0.0), (4.0, 0.0)), l((4.0, 0.0), (4.0, 0.0)), l((4.0, 0.0), (4.0, 3.0))],
-            closed: false,
-        };
-        let ends = c.end_lengths();
-        for d in [-1.0, 0.0, 1.5, 4.0, 4.0 + 1e-13, 5.0, 7.0, 9.0] {
-            // The scan this replaced.
-            let mut acc = 0.0;
-            let mut want = c.segs.last().map(|s| (s.end(), s.tangent(1.0)));
-            for s in &c.segs {
-                let len = s.len();
-                if d <= acc + len + 1e-12 && len > 0.0 {
-                    let t = ((d - acc) / len).clamp(0.0, 1.0);
-                    want = Some((s.at(t), s.tangent(t)));
-                    break;
-                }
-                acc += len;
-            }
-            assert_eq!(c.at_length_in(&ends, d), want, "d = {d}");
-            assert_eq!(c.at_length(d), want);
-        }
-    }
-
    #[test]
    fn arc_builders() {
        let a = arc_sca(Vec2::new(1.0, 0.0), Vec2::ZERO, std::f64::consts::FRAC_PI_2).unwrap();
@@ -20,7 +20,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
 pub fn specs() -> Vec<CommandSpec> {
    vec![
        CommandSpec::new("breakline", "Break-line Symbol", run_breakline)
-            .menu(&["Tools", "Additional Tools", "Break-line Symbol"])
+            .menu(&["Tools", "Express Tools", "Break-line Symbol"])
            .params(
                "{p1, p2, at?: [x,y] (symbol location; default the midpoint), size? (default 1, times DIMSCALE), \
                 extension? (past both points; default 0), block? (a block with two points on Defpoints; default the built-in symbol)} → {handle}",
@@ -36,18 +36,16 @@ fn check_block(s: &Session, b: Option<&str>) -> Result<()> {
 pub(crate) fn divide_points(c: &Chain, n: usize) -> Vec<(Vec2, Vec2)> {
    let l = c.len();
    let range = if c.closed { 0..n } else { 1..n };
-    let ends = c.end_lengths();
-    range.filter_map(|i| c.at_length_in(&ends, l * i as f64 / n as f64)).collect()
+    range.filter_map(|i| c.at_length(l * i as f64 / n as f64)).collect()
 }

 pub(crate) fn measure_points(c: &Chain, step: f64) -> Vec<(Vec2, Vec2)> {
    let l = c.len();
-    let ends = c.end_lengths();
    let mut out = Vec::new();
    let mut k = 1usize;
    while (k as f64) * step < l - 1e-9 && out.len() < MAX_GEN {
        let d = k as f64 * step;
-        out.extend(c.at_length_in(&ends, d));
+        out.extend(c.at_length(d));
        k += 1;
    }
    out
@@ -58,9 +58,8 @@ pub(crate) fn cloud_vertices(boundary: &[Vec2], arc_len: f64, per_edge: bool, re
            closed: true,
        };
        let k = ((perim / arc_len).round() as usize).clamp(3, MAX_GEN);
-        let ends = chain.end_lengths();
        for j in 0..k {
-            out.extend(chain.at_length_in(&ends, perim * j as f64 / k as f64).map(|x| x.0));
+            out.extend(chain.at_length(perim * j as f64 / k as f64).map(|x| x.0));
        }
    }
    let b = if reverse { -0.5 } else { 0.5 };
@@ -557,15 +557,9 @@ fn run_clear(s: &mut Session, _p: &Value) -> Result<Value> {
 fn run_selectall(s: &mut Session, _p: &Value) -> Result<Value> {
    let space = s.space();
    let d = s.doc()?;
-    let frozen = s.viewport_frozen();
    let hs: Vec<Handle> = d
        .space(&space)
-        .map(|st| {
-            st.iter()
-                .filter(|e| crate::select::selectable(d, e, frozen) && d.layer(&e.common.layer).is_none_or(|l| !l.locked))
-                .map(|e| e.handle)
-                .collect()
-        })
+        .map(|st| st.iter().filter(|e| d.is_visible(e) && d.layer(&e.common.layer).is_none_or(|l| !l.locked)).map(|e| e.handle).collect())
        .unwrap_or_default();
    let n = hs.len();
    s.set_selection(hs);
@@ -586,19 +580,16 @@ fn run_select(s: &mut Session, p: &Value) -> Result<Value> {
    let add = bool_or(p, "add", false);
    let picked: Vec<Handle> = if let Some(w) = points_param(p, "window") {
        let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("select", "window needs 2 corners")) };
-        crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), Bounds2::new(*a, *b), bool_or(p, "crossing", false))
+        crate::select::select_window(s.doc()?, &space, Bounds2::new(*a, *b), bool_or(p, "crossing", false))
    } else if let Some(at) = point_param(p, "at") {
        let ap = f64_or(p, "aperture", s.pixel_size() * s.settings.pickbox * 1.5);
-        crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), at, ap).into_iter().collect()
+        crate::select::pick(s.doc()?, &space, at, ap).into_iter().collect()
    } else if let Some(f) = points_param(p, "fence") {
-        crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &f)
-    } else if ["handles", "handle"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null())) {
-        targets(s, p)?
+        crate::select::select_fence(s.doc()?, &space, &f)
    } else {
-        // Nothing to select with: the selection stays, also what the active viewport does not draw.
-        s.stored_selection()
+        targets(s, p)?
    };
-    let mut sel = if add { s.stored_selection() } else { Vec::new() };
+    let mut sel = if add { s.selection() } else { Vec::new() };
    sel.extend(picked);
    s.set_selection(sel);
    let sel = s.selection();
@@ -204,8 +204,7 @@ fn import_drawing(s: &mut Session, src: &Drawing, at: Vec2, scale: f64, file: &s
 fn read_file(_path: &str) -> Result<Vec<u8>> {
    #[cfg(not(target_arch = "wasm32"))]
    {
-        crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
-            .map_err(|e| bad("import", format!("{_path}: {e}")))
+        std::fs::read(_path).map_err(|e| bad("import", format!("{_path}: {e}")))
    }
    #[cfg(target_arch = "wasm32")]
    Err(bad("import", "paths are not available on the web; pass `data`"))
@@ -8,7 +8,7 @@ mod template;
 use std::sync::OnceLock;

 use cadcraft_doc::{Drawing, Format};
-pub use craft_dxf::Version;
+pub use cadcraft_dxf::Version;
 use serde_json::{Value, json};

 use super::{CommandSpec, EngineError, Interactive, always, bad, bool_or, find_command, ok, str_param};
@@ -16,15 +16,15 @@ use super::{CommandSpec, EngineError, Interactive, always, bad, bool_or, find_co
 use crate::{Accept, Input, Prompt, Result, Session, Step};

 /// The rules the Command Aliases dialog checks before it sends an alias to ALIASEDIT.
-pub use pgp::{MAX_ALIAS_PROFILE_BYTES, MAX_ALIASES, alias_name, alias_profile, command_id, restore_aliases};
-pub(crate) use pgp::{greek_alias, specs as alias_specs, user_alias};
+pub use pgp::{MAX_ALIASES, alias_name, command_id};
+pub(crate) use pgp::{specs as alias_specs, user_alias};
 pub use template::{qnew_template, set_qnew_template};

 /// Largest drawing accepted from a local path, matching the per-file xref limit. A path naming an
 /// endless device must be rejected before it exhausts memory (CWE-400), so native opens read
 /// through [`crate::capped_read`] rather than buffering to EOF.
 #[cfg(not(target_arch = "wasm32"))]
-pub(crate) const MAX_DRAWING_BYTES: usize = 512 << 20;
+const MAX_DRAWING_BYTES: usize = 512 << 20;
 /// Largest `.scr` script accepted from a local path.
 #[cfg(not(target_arch = "wasm32"))]
 const MAX_SCRIPT_BYTES: usize = 64 << 20;
@@ -53,9 +53,9 @@ pub fn io() -> Option<&'static IoHooks> {
 /// (installed by the app with the DXF reader and writer, a lower layer).
 pub struct EntityCodec {
    /// The entity's type name and the groups of its record, without its `0` group.
-    pub groups: fn(&Drawing, &cadcraft_doc::Entity) -> (String, Vec<craft_dxf::Tag>),
+    pub groups: fn(&Drawing, &cadcraft_doc::Entity) -> (String, Vec<cadcraft_dxf::Tag>),
    /// An entity from a type name and groups.
-    pub entity: fn(&str, &[craft_dxf::Tag]) -> Option<(cadcraft_doc::Common, cadcraft_doc::EntityKind)>,
+    pub entity: fn(&str, &[cadcraft_dxf::Tag]) -> Option<(cadcraft_doc::Common, cadcraft_doc::EntityKind)>,
 }

 static CODEC: OnceLock<EntityCodec> = OnceLock::new();
@@ -340,7 +340,7 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
        let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
        cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
    }
-    Ok(ReadFile { drawing, binary_dxf: craft_dxf::is_binary(bytes), name: name.to_string(), path })
+    Ok(ReadFile { drawing, binary_dxf: cadcraft_dxf::is_binary(bytes), name: name.to_string(), path })
 }

 fn add_read(s: &mut Session, drawing: Drawing, binary_dxf: bool, name: &str, path: Option<String>) -> usize {
@@ -365,12 +365,10 @@ pub(crate) fn open_bytes(s: &mut Session, bytes: &[u8], name: &str, path: Option
 fn opened(s: &Session, i: usize, entities: bool) -> Value {
    let d = s.docs.get(i).map(|st| &st.doc);
    let warnings = d.map(|d| d.read_notes.clone()).unwrap_or_default();
-    // Opened on the view it was saved at: a viewer keeps it instead of fitting the extents.
-    let saved_view = d.is_some_and(|d| crate::view::saved_view(d).is_some());
    if entities {
-        json!({ "index": i, "entities": d.map(|d| d.entity_count()), "warnings": warnings, "saved_view": saved_view })
+        json!({ "index": i, "entities": d.map(|d| d.entity_count()), "warnings": warnings })
    } else {
-        json!({ "index": i, "warnings": warnings, "saved_view": saved_view })
+        json!({ "index": i, "warnings": warnings })
    }
 }

@@ -503,7 +501,7 @@ pub fn backup_path(path: &std::path::Path) -> std::path::PathBuf {
 pub fn looks_like_drawing(bytes: &[u8]) -> bool {
    // DWG: a version tag like `AC1032` (R12 is `AC1009`).
    let dwg = bytes.len() >= 6 && bytes.starts_with(b"AC") && bytes[2..6].iter().all(|b| b.is_ascii_digit());
-    if dwg || craft_dxf::is_binary(bytes) {
+    if dwg || cadcraft_dxf::is_binary(bytes) {
        return true;
    }
    // ASCII DXF: optional comments (999), then group 0 SECTION.
@@ -533,7 +531,7 @@ pub fn completeness(head: &[u8], tail: &[u8], len: u64) -> Option<bool> {
        // Too short for any DWG's header: cut off, not unknown.
        return if head.len() < 256 { Some(false) } else { dwg_complete(head, len) };
    }
-    if craft_dxf::is_binary(head) {
+    if cadcraft_dxf::is_binary(head) {
        return Some(tail.ends_with(b"EOF\0"));
    }
    let text = String::from_utf8_lossy(tail);
@@ -625,40 +623,6 @@ pub fn save_keeps_current(_path: &std::path::Path) -> bool {
    false
 }

-/// The mode of a new backup: no more open than the drawing (`src_mode`, group `src_gid`) nor than the
-/// `.bak` it replaces (`old`: mode and group). The backup keeps the old `.bak`'s group, so when that
-/// differs from the drawing's group, its group bits are dropped and its other bits are capped by
-/// the drawing's group bits: a member of the drawing's group must not gain access through `other`.
-#[cfg(unix)]
-fn backup_mode(src_mode: u32, src_gid: u32, old: Option<(u32, u32)>) -> u32 {
-    let mut mode = src_mode & 0o777;
-    if let Some((old_mode, old_gid)) = old {
-        mode &= old_mode;
-        if old_gid != src_gid {
-            mode = without_group(src_mode, mode);
-        }
-    }
-    mode
-}
-
-/// `mode` for a backup that is not in the drawing's group: no group bits, and `other` capped by the
-/// drawing's group bits (`src_mode`).
-#[cfg(unix)]
-fn without_group(src_mode: u32, mode: u32) -> u32 {
-    (mode & !0o070) & (!0o007 | ((src_mode & 0o070) >> 3))
-}
-
-/// A first backup is created in the process's (or folder's) group, not the drawing's: move it to the
-/// drawing's group before any data is written, else drop its group bits ([`without_group`]).
-#[cfg(unix)]
-fn adopt_source_group(out: &std::fs::File, src: &std::fs::Metadata) -> std::io::Result<()> {
-    use std::os::unix::fs::{MetadataExt, PermissionsExt, fchown};
-    if out.metadata()?.gid() == src.gid() || fchown(out, None, Some(src.gid())).is_ok() {
-        return Ok(());
-    }
-    out.set_permissions(std::fs::Permissions::from_mode(without_group(src.mode(), src.mode() & 0o777)))
-}
-
 /// Before `path` is replaced: copy it to its `.bak`, streamed and written atomically too
 /// ([`crate::atomic_write::write_atomic_with`]). Nothing
 /// to keep when there is no file yet. A file that doesn't look like a drawing
@@ -682,23 +646,19 @@ fn backup(path: &std::path::Path) -> std::io::Result<()> {
    // failed write leaves the old .bak as it was; a symlink at the .bak is replaced, never
    // written through.
    #[cfg(unix)]
-    let source_metadata = src.metadata()?;
-    #[cfg(unix)]
-    let first_backup = std::cell::Cell::new(false);
-    #[cfg(unix)]
-    let permissions = || {
-        use std::os::unix::fs::{MetadataExt, PermissionsExt};
-        let old = std::fs::symlink_metadata(&bak).ok().filter(|m| m.is_file());
-        first_backup.set(old.is_none());
-        Ok(Some(std::fs::Permissions::from_mode(backup_mode(source_metadata.mode(), source_metadata.gid(), old.map(|m| (m.mode(), m.gid()))))))
+    let permissions = {
+        use std::os::unix::fs::PermissionsExt;
+        let mut mode = src.metadata()?.permissions().mode() & 0o777;
+        if let Ok(m) = std::fs::symlink_metadata(&bak)
+            && m.is_file()
+        {
+            mode &= m.permissions().mode();
+        }
+        Some(std::fs::Permissions::from_mode(mode))
    };
    #[cfg(not(unix))]
-    let permissions = || Ok(None);
-    crate::atomic_write::write_atomic_with_permissions(&bak, permissions, |out| {
-        #[cfg(unix)]
-        if first_backup.get() {
-            adopt_source_group(out, &source_metadata)?;
-        }
+    let permissions = None;
+    crate::atomic_write::write_atomic_with(&bak, permissions, |out| {
        std::io::Write::write_all(out, &head)?;
        std::io::copy(&mut src, out).map(|_| ())
    })
@@ -817,10 +777,7 @@ const MODELER_TYPES: [&str; 3] = ["3DSOLID", "REGION", "BODY"];
 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; neither are [`DWG_WRITES`], nor
-/// another program's proxy entity whose class the file names: the DWG writes it with that class.
-/// Before 2013, or when its group 91 names no class of the file, the DWG leaves the proxy out and
-/// it is 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() };
@@ -837,21 +794,10 @@ pub fn not_saved_as(d: &Drawing, version: Version) -> std::collections::BTreeMap
            if DWG_WRITES.contains(&u.dxf_type.as_str()) {
                continue;
            }
-            if version >= Version::R2013 && u.dxf_type.eq_ignore_ascii_case("ACAD_PROXY_ENTITY") && d.foreign.proxy_class(&u.tags).is_some() {
-                continue;
-            }
            let n = out.entry(u.dxf_type.clone()).or_insert(0);
            *n = n.saturating_add(1);
        }
    }
-    // Another program's proxy objects (in the OBJECTS section) follow the same rule as its proxy
-    // entities: the DWG writer leaves them out before 2013, or when their class can't be named.
-    for o in d.foreign.objects.iter().filter(|o| o.kind.eq_ignore_ascii_case("ACAD_PROXY_OBJECT")) {
-        if version < Version::R2013 || d.foreign.proxy_class(&o.tags).is_none() {
-            let n = out.entry("ACAD_PROXY_OBJECT".to_string()).or_insert(0);
-            *n = n.saturating_add(1);
-        }
-    }
    out
 }

@@ -1069,52 +1015,6 @@ mod tests {
    use crate::Session;
    use crate::temp_dir::TempDir;

-    /// A backup is never more open than the drawing or the old `.bak`, and loses the group bits when
-    /// it would keep the old `.bak`'s group while the drawing is in another.
-    #[cfg(unix)]
-    #[test]
-    fn backup_mode_drops_group_bits_for_a_different_group() {
-        use super::backup_mode;
-        assert_eq!(backup_mode(0o640, 10, None), 0o640);
-        assert_eq!(backup_mode(0o640, 10, Some((0o664, 10))), 0o640);
-        assert_eq!(backup_mode(0o640, 10, Some((0o664, 20))), 0o600);
-        assert_eq!(backup_mode(0o644, 10, Some((0o644, 20))), 0o604);
-        assert_eq!(backup_mode(0o600, 10, Some((0o664, 10))), 0o600);
-    }
-
-    /// With no `.bak` yet, the first backup takes the drawing's group (when the user is in another
-    /// group, as `id -G` says), never the group the new file would be created in.
-    #[cfg(unix)]
-    #[test]
-    fn first_backup_takes_the_drawings_group() {
-        use std::os::unix::fs::{MetadataExt, PermissionsExt, chown};
-        let dir = TempDir::new("first-bak-grp");
-        let src = dir.join("a.dxf");
-        std::fs::write(&src, "0\nSECTION\n2\nHEADER\n0\nENDSEC\n0\nEOF\n").unwrap();
-        std::fs::set_permissions(&src, std::fs::Permissions::from_mode(0o640)).unwrap();
-        let own = std::fs::metadata(&src).unwrap().gid();
-        let other = std::process::Command::new("id")
-            .arg("-G")
-            .output()
-            .ok()
-            .and_then(|o| String::from_utf8_lossy(&o.stdout).split_whitespace().filter_map(|g| g.parse::<u32>().ok()).find(|g| *g != own));
-        if let Some(gid) = other {
-            chown(&src, None, Some(gid)).unwrap();
-        }
-        super::backup(&src).unwrap();
-        let (s, b) = (std::fs::metadata(&src).unwrap(), std::fs::metadata(super::backup_path(&src)).unwrap());
-        assert_eq!((b.gid(), b.mode() & 0o777), (s.gid(), 0o640));
-    }
-
-    /// The fail-safe when the group cannot be adopted: no group bits, `other` capped by the group's.
-    #[cfg(unix)]
-    #[test]
-    fn without_group_drops_group_bits_and_caps_other() {
-        assert_eq!(super::without_group(0o640, 0o640), 0o600);
-        assert_eq!(super::without_group(0o604, 0o604), 0o600);
-        assert_eq!(super::without_group(0o644, 0o644), 0o604);
-    }
-
    fn active_title(s: &Session) -> String {
        s.state().unwrap().title.clone()
    }
@@ -8,7 +8,7 @@ use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;

-use cadcraft_doc::{BlockBoundsCache, Drawing, Entity, EntityKind, Handle, MAX_BLOCK_DEPTH, Space, entity_bounds_cached};
+use cadcraft_doc::{Drawing, Entity, EntityKind, Handle, MAX_BLOCK_DEPTH, Space, entity_bounds};
 use cadcraft_geom::{Bounds2, Vec2};
 use serde_json::{Value, json};

@@ -110,7 +110,7 @@ fn other_drawing(s: &Session, p: &Value) -> Result<(Arc<Drawing>, String)> {
 fn read_path(_path: &str) -> Result<Vec<u8>> {
    #[cfg(not(target_arch = "wasm32"))]
    {
-        crate::capped_read::read_capped(std::path::Path::new(_path), super::MAX_DRAWING_BYTES).map_err(|e| bad("compare", format!("{_path}: {e}")))
+        std::fs::read(_path).map_err(|e| bad("compare", format!("{_path}: {e}")))
    }
    #[cfg(target_arch = "wasm32")]
    Err(bad("compare", "paths are not available on the web: open the other drawing and compare with it by name (`document`)"))
@@ -375,20 +375,16 @@ fn run_compare(s: &mut Session, p: &Value) -> Result<Value> {
    }
    let Diff { added, removed, changed, common, truncated } = diff(&cur, &other, &space);
    let mut boxes = Vec::new();
-    // One block-bounds cache for each drawing, so a block many differing entities refer to is
-    // measured once, not once per entity.
-    let (mut cur_cache, mut other_cache) = (BlockBoundsCache::default(), BlockBoundsCache::default());
-    fn bound<'a>(boxes: &mut Vec<Bounds2>, d: &'a Drawing, h: Handle, cache: &mut BlockBoundsCache<'a>) {
-        if let Some(b) = d.entity(h).map(|e| entity_bounds_cached(d, e, 0, cache)).filter(|b| !b.is_empty() && b.min.is_finite() && b.max.is_finite())
-        {
+    let mut bound = |d: &Drawing, h: Handle| {
+        if let Some(b) = d.entity(h).map(|e| entity_bounds(d, e, 0)).filter(|b| !b.is_empty() && b.min.is_finite() && b.max.is_finite()) {
            boxes.push(b);
        }
-    }
-    added.iter().for_each(|h| bound(&mut boxes, &cur, *h, &mut cur_cache));
-    removed.iter().for_each(|h| bound(&mut boxes, &other, *h, &mut other_cache));
+    };
+    added.iter().for_each(|h| bound(&cur, *h));
+    removed.iter().for_each(|h| bound(&other, *h));
    for (a, b, _, _) in &changed {
-        bound(&mut boxes, &cur, *a, &mut cur_cache);
-        bound(&mut boxes, &other, *b, &mut other_cache);
+        bound(&cur, *a);
+        bound(&other, *b);
    }
    let regions = regions(&boxes);
    let ch: Vec<Value> = changed
@@ -1,16 +1,11 @@
 //! The user's command alias file (the publicly documented `.pgp` format: `ALIAS, *COMMAND` lines,
 //! `;` comments): ALIASEDIT and REINIT.
 //!
-//! A loaded file replaces the user aliases, which add to or override the built-in ones for every
-//! drawing; command names themselves always win. Lines that define external commands
+//! A loaded file adds aliases or overrides the built-in ones for the rest of the session, for
+//! every drawing; command names themselves always win. Lines that define external commands
 //! (programs the file would have the application start) are never run: they are skipped with a
 //! note. CADCraft ships no alias file; the aliases built into the command catalog stay the
 //! defaults.
-//!
-//! The aliases are user settings, never part of a drawing: [`alias_profile`] gives them (and the
-//! file REINIT reads) to the host's user profile, and [`restore_aliases`] brings them back on the
-//! next start. The desktop and web hosts keep that profile; the headless CLI has no profile, so
-//! aliases set in a script last for that session only.

 use std::collections::BTreeMap;
 use std::sync::{Mutex, MutexGuard, OnceLock, PoisonError};
@@ -25,21 +20,10 @@ use super::{CommandSpec, Result, Session, bad, bool_or, find_command};
 pub const MAX_ALIASES: usize = 10_000;
 /// Longest alias name.
 const MAX_ALIAS_CHARS: usize = 64;
-/// Longest command id (the catalog's longest is `texttofront.dimensions`; a test keeps it true).
-const MAX_COMMAND_ID_CHARS: usize = 32;
 /// Longest line read.
 const MAX_LINE_CHARS: usize = 4096;
 /// Most warnings reported.
 const MAX_WARNINGS: usize = 100;
-/// Longest alias file path kept in the user profile.
-const MAX_ALIAS_FILE_CHARS: usize = 1024;
-
-/// The largest alias section [`alias_profile`] can produce: [`MAX_ALIASES`] entries, each a
-/// [`MAX_ALIAS_CHARS`]-character name (up to four UTF-8 bytes per character, and JSON adds its
-/// quotes) mapped to a command id, plus the alias file path and the section's keys. A host that
-/// keeps the section in its user profile allows at least this much, so a full set always comes
-/// back after a restart.
-pub const MAX_ALIAS_PROFILE_BYTES: usize = MAX_ALIASES * (MAX_ALIAS_CHARS * 4 + MAX_COMMAND_ID_CHARS + 6) + MAX_ALIAS_FILE_CHARS * 4 + 64;

 #[derive(Default)]
 struct Aliases {
@@ -59,55 +43,6 @@ pub(crate) fn user_alias(name: &str) -> Option<String> {
    store().map.get(name).cloned()
 }

-/// The user alias that is the Greek word `word` in another case or accent.
-pub(crate) fn greek_alias(word: &str) -> Option<String> {
-    let same = crate::keyboard::same_greek_word_as(word)?;
-    store().map.keys().find(|alias| same(alias)).cloned()
-}
-
-/// The user aliases and the file REINIT reads, as the host's user profile keeps them:
-/// `{"aliases": {alias: command}, "file": path or null}`. Not drawing data.
-pub fn alias_profile() -> Value {
-    let st = store();
-    // A path [`restore_aliases`] would refuse is left out, so it can't grow the profile either.
-    json!({ "aliases": st.map, "file": st.file.as_deref().filter(|f| keepable_path(f)) })
-}
-
-/// Whether the profile keeps an alias file path: short enough, and no control characters.
-fn keepable_path(f: &str) -> bool {
-    f.chars().count() <= MAX_ALIAS_FILE_CHARS && !f.chars().any(char::is_control)
-}
-
-/// Restore aliases saved by [`alias_profile`], replacing the user aliases and the file.
-///
-/// The saved set is untrusted (a hand-edited or older profile): entries that are not aliases of
-/// real commands are skipped, command names are never aliased, at most [`MAX_ALIASES`] are kept,
-/// and a malformed section changes nothing.
-pub fn restore_aliases(saved: &Value) {
-    let Some(obj) = saved.as_object() else { return };
-    let file = match obj.get("file") {
-        None | Some(Value::Null) => None,
-        Some(Value::String(f)) if keepable_path(f) => Some(f.clone()),
-        Some(Value::String(_)) => None,
-        // A file entry that is not a path makes the section malformed: keep the aliases as they are.
-        Some(_) => return,
-    };
-    let Some(map) = obj.get("aliases").and_then(Value::as_object) else { return };
-    let mut aliases = BTreeMap::new();
-    // Entries that are skipped don't use up the cap.
-    for (alias, target) in map {
-        if aliases.len() >= MAX_ALIASES {
-            break;
-        }
-        let Ok(name) = alias_name(alias) else { continue };
-        let Some(id) = target.as_str().and_then(command_id) else { continue };
-        aliases.insert(name, id);
-    }
-    let mut st = store();
-    st.map = aliases;
-    st.file = file;
-}
-
 /// The command id `target` names (`*LINE`, `_.line`, `-LAYER`…), if there is such a command.
 pub fn command_id(target: &str) -> Option<String> {
    let t = target.trim().trim_start_matches('*').trim().trim_start_matches(['_', '.']).to_ascii_lowercase();
@@ -266,25 +201,3 @@ pub(crate) fn specs() -> Vec<CommandSpec> {
        CommandSpec::new("reinit", "Reinitialize", run_reinit).params("{file? | text?} (default: the alias file loaded last)").enabled(always).noundo(),
    ]
 }
-
-#[cfg(test)]
-mod tests {
-    use super::MAX_COMMAND_ID_CHARS;
-
-    /// [`super::MAX_ALIAS_PROFILE_BYTES`] bounds a saved alias's command id by the longest id in
-    /// the catalog: keep that true as commands are added.
-    #[test]
-    fn every_command_id_fits_the_saved_alias_bound() {
-        for spec in crate::cmd::command_specs() {
-            assert!(spec.id.chars().count() <= MAX_COMMAND_ID_CHARS, "`{}` exceeds the alias profile bound", spec.id);
-        }
-    }
-
-    /// An alias file path the profile couldn't restore isn't saved in it.
-    #[test]
-    fn only_paths_the_profile_restores_are_saved() {
-        assert!(super::keepable_path("C:\\support\\mine.pgp"));
-        assert!(!super::keepable_path(&"x".repeat(super::MAX_ALIAS_FILE_CHARS + 1)));
-        assert!(!super::keepable_path("mine\n.pgp"));
-    }
-}
@@ -74,7 +74,7 @@ fn read_template(path: &str) -> Result<Drawing> {

 #[cfg(not(target_arch = "wasm32"))]
 fn read_bytes(path: &str) -> Result<Vec<u8>> {
-    crate::capped_read::read_capped(std::path::Path::new(path), super::MAX_DRAWING_BYTES).map_err(|e| bad("new", format!("template {path}: {e}")))
+    std::fs::read(path).map_err(|e| bad("new", format!("template {path}: {e}")))
 }

 #[cfg(target_arch = "wasm32")]
@@ -43,8 +43,7 @@ pub(crate) struct GripEdit {
    hot: Vec<(Handle, usize)>,
    /// Typed `GRIP`: still collecting grips ("Select grips").
    picking: bool,
-    /// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the objects of the
-    /// selection that the view being edited shows.
+    /// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the selection.
    targets: Vec<Handle>,
    base: Vec2,
    mode: GripMode,
@@ -70,13 +69,6 @@ fn positive(v: Option<f64>) -> Result<f64> {
    v.filter(|f| f.is_finite() && *f > 1e-12).ok_or_else(|| other("Requires a positive number."))
 }

-/// Whether the view being edited shows `h`. A hidden object (HIDEOBJECTS, an off or frozen layer,
-/// a layer frozen in the active MSPACE viewport) takes no part in a grip edit, even when Undo or
-/// a selection command put it back into the selection.
-fn shown(s: &Session, h: Handle) -> bool {
-    s.state().is_ok_and(|st| st.doc.entity(h).is_some_and(|e| st.shows(e)))
-}
-
 impl GripEdit {
    fn new(s: &Session, hot: Vec<(Handle, usize)>) -> Result<Self> {
        let mut g = GripEdit {
@@ -95,22 +87,16 @@ impl GripEdit {
        Ok(g)
    }

-    /// Make grip `index` of `h` hot (the first one becomes the base point). The grip of an object
-    /// the view being edited does not show is left out, and so are the hidden objects of the
-    /// selection.
+    /// Make grip `index` of `h` hot (the first one becomes the base point).
    fn add_hot(&mut self, s: &Session, (h, i): (Handle, usize)) -> Result<()> {
        if self.hot.contains(&(h, i)) || self.hot.len() >= MAX_HOT {
            return Ok(());
        }
        let p = s.grips_of(h)?.get(i).copied().ok_or_else(|| other("no such grip"))?;
-        // After the lookup: a missing object or grip stays the error it was.
-        if !shown(s, h) {
-            return Ok(());
-        }
        if self.hot.is_empty() {
            self.base = p;
            self.targets.push(h);
-            self.targets.extend(s.selection().into_iter().filter(|x| *x != h && shown(s, *x)));
+            self.targets.extend(s.selection().into_iter().filter(|x| *x != h));
        } else if !self.targets.contains(&h) {
            self.targets.push(h);
        }
@@ -121,13 +107,13 @@ impl GripEdit {
    /// The grips of the selected objects at `p` (typed `GRIP`): all objects with a grip there.
    fn grips_at(s: &Session, p: Vec2) -> Vec<(Handle, usize)> {
        let tol = (s.pixel_size() * (s.settings.gripsize + 3.0)).max(1e-9 * (1.0 + p.len()));
-        let Ok(st) = s.state() else { return Vec::new() };
+        let Ok(d) = s.doc() else { return Vec::new() };
        let mut out = Vec::new();
        for h in s.selection().into_iter().take(MAX_HOT) {
            if super::curves::is_locked(s, h) {
                continue;
            }
-            let Some(e) = st.doc.entity(h).filter(|e| st.shows(e)) else { continue };
+            let Some(e) = d.entity(h) else { continue };
            let gs = e.kind.grips();
            // The nearest grip of this object within the tolerance.
            let best = gs
@@ -484,9 +470,7 @@ impl Interactive for GripEdit {
 impl Session {
    /// Make grips hot and start editing them (the UI's click on a grip; Shift+click collects
    /// several first). `hot` lists (object, grip index); the first is the base grip. The grip
-    /// modes and their options then run at the command line like any prompt. Grips of objects the
-    /// view being edited does not show are left out (the first grip left is the base grip), and it
-    /// is an error when none is left.
+    /// modes and their options then run at the command line like any prompt.
    pub fn start_grip_edit(&mut self, hot: &[(Handle, usize)]) -> Result<()> {
        if self.running.is_some() {
            self.cancel();
@@ -495,9 +479,6 @@ impl Session {
            return Err(other("no grip"));
        }
        let g = GripEdit::new(self, hot.to_vec())?;
-        if g.hot.is_empty() {
-            return Err(other("no grip"));
-        }
        let label = g.label();
        let machine = crate::guard::Guarded::wrap(Box::new(g));
        let st = self.state()?;
@@ -28,8 +28,7 @@ pub fn specs() -> Vec<CommandSpec> {
 const MEMBER_PICKS: &[&str] = &["groupedit", "-group"];

 /// `hs` plus the other members of the selectable groups they belong to (in the space being
-/// edited, visible, and inside an MSPACE viewport not on a layer frozen in it), when PICKSTYLE
-/// has group selection on. Order: `hs` first.
+/// edited, visible), when PICKSTYLE has group selection on. Order: `hs` first.
 pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
    if s.settings.pickstyle & 1 == 0 || hs.is_empty() || s.running.as_ref().is_some_and(|r| MEMBER_PICKS.contains(&r.id.as_str())) {
        return hs;
@@ -40,7 +39,6 @@ pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
    }
    let space = s.space();
    let Some(store) = d.space(&space) else { return hs };
-    let frozen = s.viewport_frozen();
    // Member → its selectable groups, built once (window selections may hold many objects).
    let mut of: HashMap<Handle, Vec<usize>> = HashMap::new();
    for (i, g) in d.groups.iter().enumerate().filter(|(_, g)| g.selectable) {
@@ -58,7 +56,7 @@ pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
            }
            let Some(g) = d.groups.get(*gi) else { continue };
            for m in &g.members {
-                if store.get(*m).is_some_and(|e| crate::select::selectable(d, e, frozen)) && seen.insert(*m) {
+                if store.get(*m).is_some_and(|e| d.is_visible(e)) && seen.insert(*m) {
                    out.push(*m);
                }
            }
@@ -533,19 +533,6 @@ fn run_region(s: &mut Session, p: &Value) -> Result<Value> {
    Ok(json!({ "message": format!("{n} Region(s) created.") }))
 }

-/// Whether the upper-case `name` is a pattern: a standard one or a loaded one.
-fn pattern_exists(name: &str) -> bool {
-    cadcraft_doc::library::pattern(name).is_some() || patfile::user_pattern(name).is_some()
-}
-
-/// The existing pattern `name` means, typed at the pattern prompt: read upper-cased, else a loaded
-/// pattern's own name when only its Greek spelling differs in case or accent (σολιδ for ΣΟΛΙΔ).
-pub(crate) fn pattern_named(name: &str) -> Option<String> {
-    let name = name.trim();
-    let up = name.to_ascii_uppercase();
-    if pattern_exists(&up) { Some(up) } else { patfile::user_pattern_name(name) }
-}
-
 /// The origin sub-prompt's keywords (a point sets a new origin).
 const ORIGIN_KW: [&str; 6] = ["Bottom left", "bottom Right", "Top left", "top riGht", "Center", "Use current"];

@@ -610,7 +597,7 @@ impl HatchM {
                    Some(n) => n,
                    None => t.trim().to_ascii_uppercase(),
                };
-                if pattern_exists(&up) {
+                if cadcraft_doc::library::pattern(&up).is_some() || patfile::user_pattern(&up).is_some() {
                    self.settings.pattern = up.clone();
                    s.doc_mut()?.header.set_str("HPNAME", &up);
                } else {
@@ -28,13 +28,6 @@ pub(crate) fn user_pattern(name: &str) -> Option<UserPattern> {
    store().iter().find(|p| p.name.eq_ignore_ascii_case(name)).cloned()
 }

-/// The name of the user pattern that is the Greek word `name` in another case or accent
-/// ([`user_pattern`] folds ASCII only).
-pub(crate) fn user_pattern_name(name: &str) -> Option<String> {
-    let same = crate::keyboard::same_greek_word_as(name)?;
-    store().iter().find(|p| same(&p.name)).map(|p| p.name.clone())
-}
-
 /// The line families a new hatch of pattern `name` carries: a user pattern's, else none (the
 /// library's patterns are drawn and saved from the library).
 pub(crate) fn lines_for(name: &str) -> Vec<PatternLine> {
@@ -591,7 +591,7 @@ fn run_inspect(s: &mut Session, p: &Value) -> Result<Value> {
        "dimStyles": d.dim_styles.iter().map(|l| l.name.clone()).collect::<Vec<_>>(),
        "blocks": d.blocks.keys().filter(|k| !k.starts_with('*')).cloned().collect::<Vec<_>>(),
        "layouts": d.layouts.iter().map(|l| l.name.clone()).collect::<Vec<_>>(),
-        "selection": st.shown_selection().iter().map(|h| h.hex()).collect::<Vec<_>>(),
+        "selection": st.selection.iter().map(|h| h.hex()).collect::<Vec<_>>(),
        "undo": st.undo.iter().rev().take(20).map(|u| u.label.clone()).collect::<Vec<_>>(),
        "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.
@@ -786,28 +786,10 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
    // Checked here for a clear error; the plotter resolves the names the same way.
    let sheets = p.get("layouts").map(|v| plot_sheets(cmd, s.doc()?, v)).transpose()?;

-    // `layout` and `layouts` must name the same sheet(s), or the reply would name one sheet and the render another.
-    if let (Some(n), Some(names)) = (str_param(p, "layout"), sheets.as_deref())
-        && !matches!(names, [only] if only.eq_ignore_ascii_case(n))
-    {
-        return Err(bad(cmd, "`layout` and `layouts` name different sheets; give only one of them"));
-    }
-    let is_image = p.get("output").and_then(Value::as_str).is_some_and(|o| o.eq_ignore_ascii_case("png") || o.eq_ignore_ascii_case("svg"));
    let space = match str_param(p, "layout") {
        Some(n) if n.eq_ignore_ascii_case("model") => Space::Model,
        Some(n) => Space::Paper(layout_name(cmd, s.doc()?, n)?),
-        // A PNG or SVG holds one render: a single `layouts` entry names the sheet to draw (the PDF
-        // path resolves `layouts` itself), not whatever space the session happens to show.
-        None => match sheets.as_deref() {
-            Some([only]) if is_image => {
-                if only.eq_ignore_ascii_case("model") {
-                    Space::Model
-                } else {
-                    Space::Paper(only.clone())
-                }
-            }
-            _ => s.space(),
-        },
+        None => s.space(),
    };
    let mut opts = if p.is_object() { p.clone() } else { json!({}) };
    if let Some(raw) = p.get("offset") {
@@ -846,17 +828,12 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
            None => o.remove("plotTransparency"),
        };
    }
-    // A PNG or SVG holds one render: several sheets would report `pages: N` but write only one.
-    if is_image && sheets.as_ref().is_some_and(|names| names.len() > 1) {
-        return Err(bad(cmd, "`layouts` with several sheets needs PDF output; PNG and SVG hold one sheet, so plot each layout separately"));
-    }
    let bytes = hook(s.doc()?, &space, &opts).map_err(|e| bad(cmd, e))?;
    let layout = match &sheets {
        Some(names) => names.first().cloned().unwrap_or_default(),
        None => space.tab_name().to_string(),
    };
    let pages = sheets.as_ref().map_or(1, Vec::len);
-    let format = opts.get("output").and_then(Value::as_str).map(str::to_ascii_lowercase).unwrap_or_else(|| "pdf".into());
    match str_param(p, "path") {
        Some(_path) => {
            #[cfg(not(target_arch = "wasm32"))]
@@ -866,17 +843,17 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
                // `<path>.cadcraft-tmp` symlink cannot redirect the plot write (CWE-59).
                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, "format": format });
+                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")]
            {
                super::exchange::deliver_file(cmd, _path, &bytes, super::file::deliver())?;
-                Ok(json!({ "path": _path, "bytes": bytes.len(), "layout": layout, "pages": pages, "format": format }))
+                Ok(json!({ "path": _path, "bytes": bytes.len(), "layout": layout, "pages": pages }))
            }
        }
-        None => Ok(json!({ "data": base64_encode(&bytes), "bytes": bytes.len(), "layout": layout, "pages": pages, "format": format })),
+        None => Ok(json!({ "data": base64_encode(&bytes), "bytes": bytes.len(), "layout": layout, "pages": pages })),
    }
 }

@@ -303,9 +303,11 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
                (None, Some(_path)) => {
                    #[cfg(not(target_arch = "wasm32"))]
                    {
-                        let bytes = crate::capped_read::read_capped(std::path::Path::new(_path), cadcraft_doc::MAX_TABLE_FILE)
-                            .map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
-                        String::from_utf8(bytes).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
+                        let meta = std::fs::metadata(_path).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
+                        if meta.len() > cadcraft_doc::MAX_TABLE_FILE as u64 {
+                            return Err(bad(cmd, format!("{_path}: the plot style table file is too large")));
+                        }
+                        std::fs::read_to_string(_path).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
                    }
                    #[cfg(target_arch = "wasm32")]
                    return Err(bad(cmd, "files can't be read here: pass `text`"));
@@ -26,30 +26,11 @@ const MAX_PURGE_PASSES: usize = 64;

 /// The file a SAveas typed at the command line suggests: `<layout>.dwt` beside the drawing.
 pub(super) fn default_path(s: &Session, layout: &str) -> String {
-    // A layout name from a file may hold path separators or `..`; the suggestion is one file name
-    // beside the drawing, so those become `_`.
-    let name: String = layout.chars().map(|c| if matches!(c, '/' | '\\' | ':') || c.is_control() { '_' } else { c }).collect();
-    // Windows reserves device names (`CON`, `NUL`, `COM1`...) with any extension, so prefix them.
-    let base = name.split('.').next().unwrap_or("").trim_end().to_ascii_uppercase();
-    let reserved = matches!(base.as_str(), "CON" | "PRN" | "AUX" | "NUL")
-        || (base.len() == 4 && (base.starts_with("COM") || base.starts_with("LPT")) && base.ends_with(|c: char| ('1'..='9').contains(&c)));
-    let file = if reserved { format!("_{name}.dwt") } else { format!("{name}.dwt") };
-    let candidate = match s.state().ok().and_then(|st| st.path.clone()) {
-        Some(p) => std::path::Path::new(&p).with_file_name(&file),
-        None => std::path::PathBuf::from(file),
-    };
-    if !candidate.exists() {
-        return candidate.to_string_lossy().into_owned();
+    let file = format!("{layout}.dwt");
+    match s.state().ok().and_then(|st| st.path.clone()) {
+        Some(p) => std::path::Path::new(&p).with_file_name(&file).to_string_lossy().into_owned(),
+        None => file,
    }
-    let stem = candidate.file_stem().and_then(|s| s.to_str()).unwrap_or("layout");
-    let extension = candidate.extension().and_then(|e| e.to_str()).unwrap_or("dwt");
-    let parent = candidate.parent().unwrap_or_else(|| std::path::Path::new(""));
-    // The suffix range never ends in practice; the fallback only keeps the code panic-free.
-    let alternative = (2u64..)
-        .map(|suffix| parent.join(format!("{stem}-{suffix}.{extension}")))
-        .find(|alternative| !alternative.exists())
-        .unwrap_or(candidate.clone());
-    alternative.to_string_lossy().into_owned()
 }

 /// `path` with `.dwt` added when it has no extension; an error for any other file type.
@@ -152,32 +133,3 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
        super::super::exchange::deliver_file("layout.saveas", path, bytes, super::super::file::deliver())
    }
 }
-
-#[cfg(test)]
-mod default_path_tests {
-    use super::*;
-
-    /// A layout name with separators suggests a file beside the drawing, not a path elsewhere.
-    #[test]
-    fn layout_name_is_one_file_name() {
-        let s = Session::empty();
-        for name in ["../../etc/x", "a/b", "a\\b", "C:x"] {
-            let p = default_path(&s, name);
-            assert!(!p.contains('/') && !p.contains('\\') && !p.contains(':'), "{p}");
-            assert!(p.ends_with(".dwt"));
-        }
-        assert_eq!(default_path(&s, "Layout1"), "Layout1.dwt");
-    }
-
-    /// Windows device names are prefixed so the suggestion is never a device.
-    #[test]
-    fn reserved_device_names_are_prefixed() {
-        let s = Session::empty();
-        for name in ["CON", "nul", "Com1", "LPT9", "aux.x"] {
-            assert_eq!(default_path(&s, name), format!("_{name}.dwt"));
-        }
-        for name in ["COM0", "CONSOLE", "COM10"] {
-            assert_eq!(default_path(&s, name), format!("{name}.dwt"));
-        }
-    }
-}
@@ -230,24 +230,6 @@ fn plot_goes_through_the_hook() {
    assert!(s.execute("plot", &json!({"layout": "Model", "plotArea": "window"})).is_err(), "window needs corners");
    assert!(s.execute("plot", &json!({"layout": "Layout1", "plotArea": "display"})).is_err(), "layouts plot their sheet");
    assert!(s.execute("plot", &json!({"layout": "Model", "scale": -1})).is_err());
-    // Image output holds one sheet: several `layouts` would report pages:N but write one render.
-    for out in ["x.png", "x.svg"] {
-        let e = s.execute("plot", &json!({"path": out, "layouts": ["Layout1", "Layout2"]})).unwrap_err();
-        assert!(e.to_string().contains("layouts"), "{e}");
-    }
-    assert!(s.execute("plot", &json!({"output": "png", "layouts": ["Layout1", "Layout2"]})).is_err());
-    // `layout` and `layouts` naming different sheets are refused (the reply would name one sheet and the render another); agreeing ones pass.
-    for p in
-        [json!({"output": "png", "layout": "Model", "layouts": ["Layout1"]}), json!({"output": "pdf", "layout": "Layout1", "layouts": ["Model"]})]
-    {
-        let e = s.execute("plot", &p).unwrap_err().to_string();
-        assert!(e.contains("different"), "{e}");
-    }
-    assert_eq!(s.execute("plot", &json!({"output": "png", "layout": "layout1", "layouts": ["Layout1"]})).unwrap()["layout"], "Layout1");
-    let one = s.execute("plot", &json!({"output": "png", "layouts": ["Layout1"]})).unwrap();
-    assert_eq!(one["layout"], "Layout1");
-    let text = String::from_utf8(super::super::file::base64_decode(one["data"].as_str().unwrap()).unwrap()).unwrap();
-    assert!(text.contains("Paper(\"Layout1\")"), "one sheet renders that layout, not the session space: {text}");
    #[cfg(not(target_arch = "wasm32"))]
    {
        let path = std::env::temp_dir().join(format!("cadcraft-plot-test-{}.pdf", std::process::id()));
@@ -325,50 +307,3 @@ fn plot_help_names_the_device_and_the_built_in_devices() {
        assert!(help.contains(name), "plot help lacks {name}");
    }
 }
-
-/// The path's extension picks the plot format as EXPORT does, in any case; one that names no
-/// format (or none) is refused instead of writing a PDF under that name, and a device that writes
-/// another format is refused.
-#[cfg(not(target_arch = "wasm32"))]
-#[test]
-fn plot_path_extension_picks_the_format_like_export() {
-    super::super::file::set_io(super::super::file::IoHooks {
-        read: |_, _| Err("no reader in tests".into()),
-        write: |_, _| Err("no writer in tests".into()),
-        plot: Some(fake_plot),
-    });
-    if io().and_then(|h| h.plot).is_none() {
-        return; // another test installed hooks without a plotter first
-    }
-    let mut s = session_with_model();
-    let dir = std::env::temp_dir().join(format!("cadcraft-plot-ext-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let path = |n: &str| dir.join(n).to_string_lossy().to_string();
-    let upper = s.execute("plot", &json!({"path": path("X.PNG")})).unwrap();
-    assert_eq!(upper["format"], "png", "an upper-case extension still picks png");
-    let e = s.execute("plot", &json!({"path": path("x.txt")})).unwrap_err().to_string();
-    assert!(e.contains("png") && e.contains("svg") && e.contains("pdf"), "{e}");
-    assert!(!dir.join("x.txt").exists(), "nothing written under an unknown extension");
-    let e = s.execute("plot", &json!({"path": path("noext")})).unwrap_err().to_string();
-    assert!(e.contains("png") && e.contains("svg") && e.contains("pdf"), "{e}");
-    assert!(!dir.join("noext").exists());
-    let e = s.execute("plot", &json!({"path": path("y.png"), "device": "CADCraft PDF"})).unwrap_err().to_string();
-    assert!(e.contains("writes pdf") && e.contains("png"), "{e}");
-    // A device that resolves to none, or a null/unknown `output`, names no format: the refusal stands.
-    for p in [
-        json!({"path": path("x.txt"), "device": "None"}),
-        json!({"path": path("x.txt"), "output": null}),
-        json!({"path": path("x.txt"), "output": "bogus"}),
-    ] {
-        let e = s.execute("plot", &p).unwrap_err().to_string();
-        assert!(e.contains("png") && e.contains("svg") && e.contains("pdf"), "{e}");
-        assert!(!dir.join("x.txt").exists(), "nothing written under an unknown extension");
-    }
-    // An explicit output still decides for an odd name.
-    assert_eq!(s.execute("plot", &json!({"path": path("z.txt"), "output": "pdf"})).unwrap()["format"], "pdf");
-    // But one that contradicts the extension is refused, as a device that does is (#2585 review).
-    let e = s.execute("plot", &json!({"path": path("w.png"), "output": "svg"})).unwrap_err().to_string();
-    assert!(e.contains("svg") && e.contains("png"), "{e}");
-    assert!(!dir.join("w.png").exists(), "nothing written when `output` and the path disagree");
-    std::fs::remove_dir_all(&dir).ok();
-}
@@ -35,7 +35,7 @@ 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::{holds_ole_frame, ole_refusal, refuse_ole_frames, transform_entities};
+pub(crate) use transform::transform_entities;
 use transform::{run_copy, run_erase, run_mirror, run_move, run_rotate, run_scale};
 pub(crate) use trim::{Edges, extend, trim};

@@ -86,7 +86,7 @@ pub fn specs() -> Vec<CommandSpec> {
            .menu(&["Modify", "Trim"])
            .alias(&["tr"])
            .params(
-                "{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\"} → {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing)",
+                "{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\"}",
            )
            .interactive(|_| Ok(Box::new(TrimM::new(false)))),
        CommandSpec::new("extend", "Extend", trimextend::run_extend)
@@ -112,9 +112,9 @@ pub fn specs() -> Vec<CommandSpec> {
        CommandSpec::new("break", "Break", run_break)
            .menu(&["Modify", "Break"])
            .alias(&["br"])
-            .params("{handle, p1, p2} → {handles: the object (kept, reshaped) then the new pieces; none when nothing is left}")
+            .params("{handle, p1, p2}")
            .interactive(|_| Ok(Box::new(BreakM::default()))),
-        CommandSpec::new("breakatpoint", "Break At Point", run_breakat).menu(&["Modify", "Break At Point"]).params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}"),
+        CommandSpec::new("breakatpoint", "Break At Point", run_breakat).menu(&["Modify", "Break At Point"]).params("{handle, at}"),
        CommandSpec::new("join", "Join", run_join)
            .menu(&["Modify", "Join"])
            .alias(&["j"])
@@ -1,4 +1,4 @@
-use super::trim::{param_on, replace_with_pieces, sub_polyline};
+use super::trim::{param_on, sub_polyline};
 use super::{
    Accept, Arc, EngineError, Entity, EntityKind, Handle, Input, Interactive, Line, PolyVertex, Polyline, Prompt, Result, Segment, Session, Step,
    Value, Vec2, arc, bad, json, lwpoly, norm_angle, point_param, point_req, targets,
@@ -105,7 +105,19 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
        }
        _ => return Err(EngineError::Other("Cannot break that object.".into())),
    };
-    replace_with_pieces(s, h, pieces)
+    let common = e.common.clone();
+    let space = s.space();
+    let d = s.doc_mut()?;
+    d.remove_entity(h);
+    let mut out = Vec::new();
+    for k in pieces {
+        let nh = d.new_handle();
+        if let Some(st) = d.space_mut(&space) {
+            st.push(Entity { handle: nh, common: common.clone(), kind: k });
+            out.push(nh);
+        }
+    }
+    Ok(out)
 }

 pub(super) fn run_break(s: &mut Session, p: &Value) -> Result<Value> {
@@ -21,17 +21,14 @@ impl StretchArea {
    }
 }

-/// Add to `hs` the multilines in the edit space that a selection can take there (visible, and
-/// inside an MSPACE viewport not on a layer frozen in it) with a control vertex inside `area`. A
-/// crossing selection tests the drawn element lines, which sit away from the control vertices by
-/// the multiline's scale, so a small area around a vertex alone would miss them.
-fn add_mline_vertex_hits(s: &Session, area: &StretchArea, hs: &mut Vec<Handle>) {
-    let Ok(d) = s.doc() else { return };
-    let Some(store) = d.space(&s.space()) else { return };
-    let frozen = s.viewport_frozen();
+/// Add to `hs` the visible multilines in `space` with a control vertex inside `area`. A crossing
+/// selection tests the drawn element lines, which sit away from the control vertices by the
+/// multiline's scale, so a small area around a vertex alone would miss them.
+fn add_mline_vertex_hits(d: &cadcraft_doc::Drawing, space: &cadcraft_doc::Space, area: &StretchArea, hs: &mut Vec<Handle>) {
+    let Some(store) = d.space(space) else { return };
    for e in store.iter() {
        if let EntityKind::MLine(m) = &e.kind
-            && crate::select::selectable(d, e, frozen)
+            && d.is_visible(e)
            && !hs.contains(&e.handle)
            && m.vertices.iter().any(|v| area.contains(v.p.xy()))
        {
@@ -97,19 +94,19 @@ pub(super) fn run_stretch(s: &mut Session, p: &Value) -> Result<Value> {
    };
    // A fence marks no area: the objects it crosses move whole.
    if let Some(fence) = listed("fence", 2)? {
-        let hs = crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &fence);
+        let hs = crate::select::select_fence(s.doc()?, &space, &fence);
        let moved = transform_entities(s, &hs, &Mat3::translate(d), false)?;
        return Ok(json!({ "stretched": moved.len() }));
    }
    let (mut hs, area) = if let Some(poly) = listed("polygon", 3)? {
-        (crate::select::select_polygon_in(s.doc()?, &space, s.viewport_frozen(), &poly, true), StretchArea::Polygon(poly))
+        (crate::select::select_polygon(s.doc()?, &space, &poly, true), StretchArea::Polygon(poly))
    } else {
        let w = points_param(p, "window").ok_or_else(|| bad("stretch", "`window` [[x,y],[x,y]], `polygon` or `fence` is required"))?;
        let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("stretch", "window needs 2 corners")) };
        let bx = cadcraft_geom::Bounds2::new(*a, *b);
-        (crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, true), StretchArea::Box(bx))
+        (crate::select::select_window(s.doc()?, &space, bx, true), StretchArea::Box(bx))
    };
-    add_mline_vertex_hits(s, &area, &mut hs);
+    add_mline_vertex_hits(s.doc()?, &space, &area, &mut hs);
    hs.retain(|h| !crate::cmd::curves::is_locked(s, *h));
    let doc = s.doc_mut()?;
    let areas = [area];
@@ -176,7 +173,7 @@ impl StretchM {
    /// of two) the mode is dropped.
    fn finish_mode(&mut self, s: &mut Session, m: SelectMode) -> Result<()> {
        let space = s.space();
-        let Some(mut hs) = m.select_in(s.doc()?, &space, s.viewport_frozen()) else { return Ok(()) };
+        let Some(mut hs) = m.select(s.doc()?, &space) else { return Ok(()) };
        let crossing = match (m.kind, m.pts.first().zip(m.pts.get(1))) {
            (SelectKind::Crossing | SelectKind::CPolygon, _) => true,
            (SelectKind::Box, Some((a, b))) => b.x < a.x,
@@ -192,7 +189,7 @@ impl StretchM {
        };
        let whole = area.is_none();
        if let (Some(a), true, false) = (&area, crossing, self.removing) {
-            add_mline_vertex_hits(s, a, &mut hs);
+            add_mline_vertex_hits(s.doc()?, &space, a, &mut hs);
        }
        if let (Some(a), false) = (area, self.removing) {
            self.windows.push(a);
@@ -231,10 +228,10 @@ impl StretchM {
                Some(c) => {
                    let bx = cadcraft_geom::Bounds2::new(c, p);
                    let space = s.space();
-                    let mut hs = crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, p.x < c.x);
+                    let mut hs = crate::select::select_window(s.doc()?, &space, bx, p.x < c.x);
                    if !self.removing {
                        if p.x < c.x {
-                            add_mline_vertex_hits(s, &StretchArea::Box(bx), &mut hs);
+                            add_mline_vertex_hits(s.doc()?, &space, &StretchArea::Box(bx), &mut hs);
                        }
                        self.windows.push(StretchArea::Box(bx));
                    }
@@ -243,7 +240,7 @@ impl StretchM {
                None => {
                    let aperture = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
                    let space = s.space();
-                    match crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), p, aperture) {
+                    match crate::select::pick(s.doc()?, &space, p, aperture) {
                        Some(h) => self.add(s, vec![h], true),
                        None => self.corner = Some(p),
                    }
@@ -254,7 +251,6 @@ impl StretchM {
                self.corner = None;
                let d = s.doc()?;
                let store = d.space(&s.space());
-                let frozen = s.viewport_frozen();
                let word = t.trim().to_ascii_lowercase();
                // `_C`, `_L`: the English name, as scripts write it.
                let word = word.strip_prefix('_').unwrap_or(&word).to_string();
@@ -271,14 +267,9 @@ impl StretchM {
                        self.removing = false;
                        None
                    }
-                    "all" => Some(
-                        store.map(|st| st.iter().filter(|e| crate::select::selectable(d, e, frozen)).map(|e| e.handle).collect()).unwrap_or_default(),
-                    ),
-                    "l" | "last" => Some(store.and_then(|st| crate::select::last_in(st, frozen)).map(|h| vec![h]).unwrap_or_default()),
-                    "p" | "previous" => {
-                        let st = s.state()?;
-                        Some(st.drawn_in_viewport(&st.previous_selection))
-                    }
+                    "all" => Some(store.map(|st| st.iter().filter(|e| d.is_visible(e)).map(|e| e.handle).collect()).unwrap_or_default()),
+                    "l" | "last" => Some(store.and_then(|st| st.last()).map(|e| vec![e.handle]).unwrap_or_default()),
+                    "p" | "previous" => Some(s.state()?.previous_selection.clone()),
                    _ => {
                        s.echo("*Invalid selection*");
                        None
@@ -5,7 +5,6 @@ use super::{Entity, Handle, Mat3, Result, Session, Value, Vec2, bad, bool_or, er
 // ---------------- core operations ----------------

 pub(crate) fn transform_entities(s: &mut Session, hs: &[Handle], m: &Mat3, copy: bool) -> Result<Vec<Handle>> {
-    refuse_ole_frames(s, hs, m, copy)?;
    edit_entities(s, hs, copy, |e| e.kind.transform(m))
 }

@@ -13,7 +12,6 @@ pub(crate) fn transform_entities(s: &mut Session, hs: &[Handle], m: &Mat3, copy:
 /// 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);
-    refuse_ole_frames(s, hs, &m, copy)?;
    edit_entities(s, hs, copy, |e| {
        e.kind.transform(&m);
        e.kind.scale_heights(base.z, f);
@@ -21,34 +19,6 @@ pub(crate) fn scale_entities(s: &mut Session, hs: &[Handle], base: Vec3, f: f64,
    })
 }

-/// An OLE2FRAME only translates or scales uniformly (its corners stay axis aligned): refuse any other `m` before anything
-/// changes, instead of reporting success and leaving the frame where it was.
-pub(crate) fn refuse_ole_frames(s: &Session, hs: &[Handle], m: &Mat3, copy: bool) -> Result<()> {
-    if cadcraft_doc::ole_frame_accepts(m) || !holds_ole_frame(s, hs, copy)? {
-        return Ok(());
-    }
-    Err(ole_refusal())
-}
-
-/// The refusal for a transform an OLE2FRAME cannot take.
-pub(crate) fn ole_refusal() -> crate::EngineError {
-    crate::EngineError::Other(
-        "An OLE object can only be moved, copied or scaled uniformly; other transforms (rotation, mirroring, non-uniform scale, alignment) are not supported.".into(),
-    )
-}
-
-/// Whether `hs` holds an OLE2FRAME a transform would touch. An in-place edit (`copy` false) skips
-/// an object on a locked layer (see edit_entities), so such a frame cannot be refused.
-pub(crate) fn holds_ole_frame(s: &Session, hs: &[Handle], copy: bool) -> Result<bool> {
-    let d = s.doc()?;
-    Ok(hs.iter().any(|h| {
-        d.entity(*h).is_some_and(|e| {
-            let locked = !copy && d.layer(&e.common.layer).is_some_and(|l| l.locked);
-            !locked && matches!(&e.kind, cadcraft_doc::EntityKind::Unknown(u) if u.is_ole_frame())
-        })
-    }))
-}
-
 /// `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());
@@ -170,46 +170,18 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
        EntityKind::LwPolyline(p) => trim_polyline(p, &cut, pick)?,
        k => crate::cmd::modify2::trim_other(k, &cut, pick)?,
    };
-    replace_with_pieces(s, h, pieces)
-}
-
-/// Put `pieces` in place of object `h` as AutoCAD 2024's BREAK and TRIM leave them: the first
-/// piece (the one holding the object's start, or the only piece of a circle or closed polyline)
-/// is the object itself, keeping its handle, its place in the drawing order, its groups and its
-/// extended data; the others are new objects with its properties, added at the end of its space
-/// (`entlast`); with no pieces the object is erased. Returns the pieces' handles. (A line broken
-/// in its middle keeps its handle on the piece from its start point, the piece to its end point is
-/// new; a circle broken or trimmed becomes an arc with the circle's handle.)
-///
-/// Dimensions attached to the object follow [`crate::assoc::follow_pieces`]. Its parametric
-/// constraints are removed: its new shape no longer meets them, and solving them again would move
-/// the objects they tie it to.
-pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<EntityKind>) -> Result<Vec<Handle>> {
+    let common = e.common.clone();
+    let space = s.space();
    let d = s.doc_mut()?;
-    let mut pieces = pieces.into_iter();
-    let Some(first) = pieces.next() else {
-        d.remove_entity(h);
-        return Ok(Vec::new());
-    };
-    let (Some(space), Some(old)) = (d.space_of(h), d.entity(h).cloned()) else {
-        return Err(EngineError::Other("no such object".into()));
-    };
-    d.modify_entity(h, |e| e.kind = first)?;
-    let mut out = vec![h];
-    for kind in pieces {
-        let handle = d.new_handle();
+    d.remove_entity(h);
+    let mut out = Vec::new();
+    for k in pieces {
+        let nh = d.new_handle();
        if let Some(st) = d.space_mut(&space) {
-            st.push(Entity { handle, common: old.common.clone(), kind });
-            out.push(handle);
+            st.push(Entity { handle: nh, common: common.clone(), kind: k });
+            out.push(nh);
        }
    }
-    crate::assoc::follow_pieces(d, &old.kind, &out);
-    let n = d.constraints.len();
-    d.constraints.retain(|c| c.refs.iter().all(|r| r.handle != h));
-    let removed = n - d.constraints.len();
-    if removed > 0 {
-        s.echo(format!("{removed} constraint(s) of the broken or trimmed object removed."));
-    }
    Ok(out)
 }

@@ -65,7 +65,7 @@ pub fn specs() -> Vec<CommandSpec> {
            .params("{handle (block reference), pick?: [x,y] (nearest nested object; default all), delta? | from,to}")
            .interactive(|_| Ok(Box::new(NcopyM::default()))),
        CommandSpec::new("mocoro", "Move/Copy/Rotate", mocoro::run_mocoro)
-            .menu(&["Tools", "Additional Tools", "Move/Copy/Rotate"])
+            .menu(&["Tools", "Express Tools", "Move/Copy/Rotate"])
            .params("{handles?, base: [x,y], ops: [{move: [x,y]} | {copy: [x,y]} | {rotate: degrees} | {scale: factor} | {base: [x,y]}]} → {handles (copies)}")
            .interactive(|_| Ok(Box::new(mocoro::MocoroM::default()))),
        CommandSpec::new("chspace", "Change Space", run_chspace)
@@ -16,7 +16,7 @@ use super::other;
 use crate::cmd::curves::KW;
 use crate::cmd::helpers::line;
 use crate::cmd::machines::{SelOutcome, SelectPhase, number};
-use crate::cmd::modify::{refuse_ole_frames, transform_entities};
+use crate::cmd::modify::transform_entities;
 use crate::cmd::{bad, point_req, point_value, targets};
 use crate::prompt::Drag;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
@@ -108,21 +108,6 @@ pub(super) fn run_mocoro(s: &mut Session, p: &Value) -> Result<Value> {
    }
    // Every option is checked before the drawing changes.
    let ops = list.iter().enumerate().map(|(i, v)| parse_op(i, v)).collect::<Result<Vec<_>>>()?;
-    // An OLE frame only translates or scales uniformly: a rotate step (or any step) that would refuse it must do so before an
-    // earlier move or copy changes the drawing (a refused command is not rolled back).
-    for op in &ops {
-        match *op {
-            Op::Rotate(a) => refuse_ole_frames(s, &objs, &Mat3::rotate_about(base, a), false)?,
-            Op::Scale(f) => refuse_ole_frames(s, &objs, &Mat3::scale_about(base, f), false)?,
-            _ => {}
-        }
-    }
-    // Each Copy clones every selected object: the copies together stay within MAXARRAY, as an array's do.
-    // Erased handles are skipped by `apply`, so only live objects count (none: nothing is copied).
-    let live = counts(s, &objs)?.0;
-    if live > 0 {
-        crate::cmd::array::check_size(s, ops.iter().filter(|o| matches!(o, Op::Copy(_))).count() as u64, live)?;
-    }
    let mut copies = Vec::new();
    for op in ops {
        copies.extend(apply(s, &objs, &mut base, op)?);
@@ -156,12 +141,6 @@ pub(super) struct MocoroM {

 impl MocoroM {
    fn run(&mut self, s: &mut Session, op: Op) -> Result<Step> {
-        if matches!(op, Op::Copy(_)) {
-            let live = counts(s, &self.objs)?.0;
-            if live > 0 {
-                crate::cmd::array::check_size(s, 1, live)?;
-            }
-        }
        let before = s.state()?.doc.clone();
        let base = self.base;
        apply(s, &self.objs, &mut self.base, op)?;
@@ -34,26 +34,15 @@ pub(crate) fn arraypath(
        _ => (6, if c.closed { l / 6.0 } else { l / 5.0 }),
    };
    crate::cmd::array::check_size(s, n as u64, objs.len())?;
-    // Segment end lengths once: each sample is then a binary search, not a scan from the start.
-    let ends = c.end_lengths();
-    let Some((p0, t0)) = c.at_length_in(&ends, 0.0) else { return Ok(Vec::new()) };
-    let mut mats = Vec::new();
+    let Some((p0, t0)) = c.at_length(0.0) else { return Ok(Vec::new()) };
+    let mut out = Vec::new();
    for i in 1..n {
-        let Some((p, t)) = c.at_length_in(&ends, step * i as f64) else { continue };
+        let Some((p, t)) = c.at_length(step * i as f64) else { continue };
        let mut m = Mat3::translate(p - p0);
        if align {
            m = Mat3::rotate_about(p, t.angle() - t0.angle()).then_before(m);
        }
-        mats.push(m);
-    }
-    // Every copy is checked before the first is made: a refusal part way would leave the copies
-    // already added in the drawing (a failed command is not rolled back).
-    if mats.iter().any(|m| !cadcraft_doc::ole_frame_accepts(m)) && crate::cmd::modify::holds_ole_frame(s, &objs, true)? {
-        return Err(crate::cmd::modify::ole_refusal());
-    }
-    let mut out = Vec::new();
-    for m in &mats {
-        out.extend(crate::cmd::modify::transform_entities(s, &objs, m, true)?);
+        out.extend(crate::cmd::modify::transform_entities(s, &objs, &m, true)?);
    }
    Ok(out)
 }
@@ -11,8 +11,6 @@ fn text_of(k: &EntityKind) -> Option<String> {
        EntityKind::Text(t) => Some(t.value.clone()),
        EntityKind::AttDef(a) => Some(a.text.value.clone()),
        EntityKind::MText(t) => Some(t.contents.replace("\\P", "\n")),
-        // A multileader's text (one with a block instead has none, #1081).
-        EntityKind::MLeader(m) => m.text.as_ref().map(|t| t.contents.replace("\\P", "\n")),
        EntityKind::Dimension(d) => Some(if d.text.is_empty() { "<>".into() } else { d.text.clone() }),
        _ => None,
    }
@@ -27,16 +25,11 @@ pub(crate) fn set_text(s: &mut Session, h: Handle, text: &str) -> Result<()> {
        EntityKind::Text(t) => t.value = text.to_string(),
        EntityKind::AttDef(a) => a.text.value = text.to_string(),
        EntityKind::MText(t) => t.contents = text.replace('\n', "\\P"),
-        EntityKind::MLeader(m) if m.text.is_some() => {
-            if let Some(t) = &mut m.text {
-                t.contents = text.replace('\n', "\\P");
-            }
-        }
        EntityKind::Dimension(d) => {
            d.text = if text == "<>" { String::new() } else { text.to_string() };
            d.block = None;
        }
-        _ => return Err(other("Select a text, mtext, multileader, attribute definition or dimension.")),
+        _ => return Err(other("Select a text, mtext, attribute definition or dimension.")),
    }
    set_kind(s, h, k)
 }
@@ -60,18 +53,12 @@ pub(super) struct TextEditM {
    single: bool,
    /// Asking for the edit mode.
    mode: bool,
-    /// The MTEXT being edited, for the in-place editor (#842).
-    mtext: Option<cadcraft_doc::MText>,
 }

 impl Interactive for TextEditM {
    fn name(&self) -> &'static str {
        "TEXTEDIT"
    }
-    /// An MTEXT asking for its new text opens in the in-place editor with its contents.
-    fn editing_mtext(&self) -> Option<cadcraft_doc::MText> {
-        self.h.as_ref().and(self.mtext.clone())
-    }
    fn prompt(&self, _s: &Session) -> Prompt {
        if self.mode {
            let current = if self.single { "Single" } else { "Multiple" };
@@ -96,24 +83,7 @@ impl Interactive for TextEditM {
        match (&self.h, i) {
            (None, Input::Point(p)) => {
                let h = curves::pick_at(s, p).ok_or_else(|| other("*Invalid selection*"))?;
-                // Refused when picked, not after the new text has been typed.
-                if curves::is_locked(s, h) {
-                    return Err(other("The object is on a locked layer."));
-                }
-                let kind = curves::entity(s, h)?.kind;
-                let old = text_of(&kind).ok_or_else(|| other("Select a text, mtext, multileader, attribute definition or dimension."))?;
-                self.mtext = match kind {
-                    EntityKind::MText(m) => Some(m),
-                    // A multileader's text opens in the same editor (#1081).
-                    EntityKind::MLeader(m) => m.text,
-                    _ => None,
-                };
-                // The editor would drop part of a text this long, and saving would lose it: the
-                // command line asks for it instead.
-                if self.mtext.as_ref().is_some_and(|m| !crate::mtext_edit::Formatted::fits(&m.contents)) {
-                    self.mtext = None;
-                    s.echo("This text is too long for the editor; enter the new text at the command line.");
-                }
+                let old = text_of(&curves::entity(s, h)?.kind).ok_or_else(|| other("Select a text, mtext, attribute definition or dimension."))?;
                self.h = Some((h, old));
                Ok(Step::Continue)
            }
@@ -123,12 +93,10 @@ impl Interactive for TextEditM {
                set_text(s, h, &t)?;
                self.edits.push((h, before));
                self.h = None;
-                self.mtext = None;
                Ok(if self.single { Step::Done } else { Step::Continue })
            }
            (Some(_), Input::Enter) => {
                self.h = None;
-                self.mtext = None;
                Ok(if self.single { Step::Done } else { Step::Continue })
            }
            (None, Input::Enter) => Ok(Step::Done),
@@ -265,11 +265,6 @@ pub fn page_device(cmd: &str, p: &Value, page: &mut PageSetup) -> Result<bool> {
    Ok(false)
 }

-/// The output a path's extension (any case) asks for: png, svg or pdf; other extensions ask for none.
-fn path_output(path: &str) -> Option<PlotOutput> {
-    PlotOutput::parse(&std::path::Path::new(path).extension()?.to_string_lossy())
-}
-
 /// The options PLOT / EXPORTPDF hand the plotter with `device` and the device's papers
 /// resolved: `device` (else the layout's page setup device) picks the output (`output`: pdf,
 /// png or svg; EXPORTPDF always writes PDF) and `resolution`; a paper of the device becomes
@@ -291,42 +286,9 @@ pub(crate) fn plot_options(s: &Session, p: &Value, cmd: &str) -> Result<Value> {
        None => layout.as_ref().and_then(|pg| find_device(&pg.device)),
    };
    let mut out = if p.is_object() { p.clone() } else { json!({}) };
-    // The path's extension names the format, like EXPORT, unless a device is given; a given
-    // device that writes another format is refused. EXPORTPDF always writes PDF.
-    let by_path = if cmd == "exportpdf" { None } else { str_param(p, "path").and_then(path_output) };
-    // A path whose extension names no format (or has none) would hold a PDF under that name:
-    // refuse it, as EXPORT does, unless `output` or a device says what to write.
-    if cmd == "plot"
-        && by_path.is_none()
-        && !p.get("output").and_then(Value::as_str).is_some_and(|o| PlotOutput::parse(o).is_some())
-        && !(dev.is_some() && given.is_some_and(|n| !n.is_empty()))
-        && let Some(path) = str_param(p, "path")
-    {
-        return Err(bad(
-            cmd,
-            format!("can't tell the format of `{path}`: give a path ending in .png, .svg or .pdf, or set `output` to png, svg or pdf"),
-        ));
-    }
-    if let (Some(want), Some(dev), true) = (by_path, &dev, given.is_some_and(|n| !n.is_empty()))
-        && dev.output != want
-    {
-        return Err(bad(cmd, format!("plotter `{}` writes {}, but the path asks for {}", dev.name, dev.output.as_str(), want.as_str())));
-    }
-    // An `output` that says another format than the path's extension is refused too, as a device
-    // that does is: either way the file would not hold what its name says.
-    if let (Some(want), Some(asked)) = (by_path, p.get("output").and_then(Value::as_str).and_then(PlotOutput::parse))
-        && asked != want
-    {
-        return Err(bad(cmd, format!("`output` is {}, but the path asks for {}", asked.as_str(), want.as_str())));
-    }
-    let (Some(dev), Some(o)) = (dev, out.as_object_mut()) else {
-        if let (Some(want), Some(o)) = (by_path, out.as_object_mut()) {
-            o.insert("output".into(), json!(want.as_str()));
-        }
-        return Ok(out);
-    };
+    let (Some(dev), Some(o)) = (dev, out.as_object_mut()) else { return Ok(out) };
    o.remove("device");
-    let output = if cmd == "exportpdf" { PlotOutput::Pdf } else { by_path.unwrap_or(dev.output) };
+    let output = if cmd == "exportpdf" { PlotOutput::Pdf } else { dev.output };
    o.insert("output".into(), json!(output.as_str()));
    o.insert("resolution".into(), json!(dev.resolution));
    let paper = match str_param(p, "paper") {
@@ -10,7 +10,7 @@ mod rename;
 pub use matchprop::MatchProps;

 use cadcraft_color::Color;
-use cadcraft_doc::{EntityKind, Handle, Lineweight, Transparency};
+use cadcraft_doc::{EntityKind, Lineweight, Transparency};
 use cadcraft_geom::Vec3;
 use serde_json::{Value, json};

@@ -21,9 +21,9 @@ use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 pub fn specs() -> Vec<CommandSpec> {
    vec![
        CommandSpec::new("properties", "Properties", run_get).menu(&["Modify", "Properties"]).alias(&["pr", "props", "ch"]).params("{handles?} → properties of the selection").noundo(),
-        CommandSpec::new("properties.set", "Set Properties", run_set).params("{handles?, layer?, color?, linetype?, lineweight?, ltscale?, thickness?, transparency?: \"ByLayer\" | \"ByBlock\" | 0..90, visible?, <geometry fields: radius, center, start, end, text, height, rotation…>; dimensions: textOverride, dimStyle, textHeight, arrowSize, dimScale, precision (per-dimension overrides)} → {changed, locked, message?}: objects on locked layers (and, during REFEDIT, outside the working set) are left out, and `message` says how many"),
-        CommandSpec::new("chprop", "Change Properties", run_set)
-            .params("as properties.set, leaving out objects on locked layers (and, during REFEDIT, outside the working set) → {changed, locked, message?} (the command line asks Color, LAyer, LType, ltScale, LWeight, Thickness and TRansparency in turn)")
+        CommandSpec::new("properties.set", "Set Properties", run_set).params("{handles?, layer?, color?, linetype?, lineweight?, ltscale?, thickness?, transparency?: \"ByLayer\" | \"ByBlock\" | 0..90, visible?, <geometry fields: radius, center, start, end, text, height, rotation…>; dimensions: textOverride, dimStyle, textHeight, arrowSize, dimScale, precision (per-dimension overrides)}"),
+        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"])
@@ -196,74 +196,11 @@ fn set_xy(p: &mut Vec3, v: &Value) {
    }
 }

-/// The objects `properties.set` leaves alone, as CHPROP, MATCHPROP and MOVE do: those on locked
-/// layers and, while a reference is edited in place, those outside the working set.
-#[derive(Default)]
-struct LeftOut {
-    locked: usize,
-    outside: usize,
-}
-
-impl LeftOut {
-    /// `hs` without the objects that can't be edited, each object once, and how many those were. A
-    /// handle that names no object is an error, before anything changes.
-    fn split(s: &Session, hs: Vec<Handle>) -> Result<(Vec<Handle>, LeftOut)> {
-        let d = s.doc()?;
-        // The working set, once: `RefEdit::is_working` searches a list.
-        let working: Option<std::collections::HashSet<Handle>> = d.refedit.as_ref().map(|r| r.items.iter().map(|i| i.copy).collect());
-        let mut seen = std::collections::HashSet::new();
-        let mut out = LeftOut::default();
-        let mut free = Vec::new();
-        for h in hs {
-            let Some(e) = d.entity(h) else {
-                return Err(cadcraft_doc::DocError::NoEntity(h).into());
-            };
-            if !seen.insert(h) {
-                continue;
-            }
-            if working.as_ref().is_some_and(|w| !w.contains(&h)) {
-                out.outside += 1;
-            } else if d.layer(&e.common.layer).is_some_and(|l| l.locked) {
-                out.locked += 1;
-            } else {
-                free.push(h);
-            }
-        }
-        Ok((free, out))
-    }
-
-    /// `{changed, locked}`, and a message saying how many were left out when any were.
-    fn result(&self, changed: usize) -> Value {
-        let mut notes = Vec::new();
-        match self.locked {
-            0 => {}
-            1 => notes.push("1 object was on a locked layer.".to_string()),
-            n => notes.push(format!("{n} objects were on a locked layer.")),
-        }
-        match self.outside {
-            0 => {}
-            1 => notes.push("1 object was not in the working set.".to_string()),
-            n => notes.push(format!("{n} objects were not in the working set.")),
-        }
-        if changed == 0 && !notes.is_empty() {
-            notes.push("Nothing was changed.".to_string());
-        }
-        let mut r = json!({ "changed": changed, "locked": self.locked + self.outside });
-        if !notes.is_empty()
-            && let Some(o) = r.as_object_mut()
-        {
-            o.insert("message".into(), json!(notes.join(" ")));
-        }
-        r
-    }
-}
-
 fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
    let hs = targets(s, p)?;
    if hs.is_empty() {
        return Err(bad("properties.set", "nothing selected"));
    }
-    let (hs, left_out) = LeftOut::split(s, hs)?;
    let color = p.get("color").map(|c| parse_color(c).ok_or_else(|| bad("properties.set", "bad colour"))).transpose()?;
    let transparency = p
        .get("transparency")
@@ -274,7 +211,7 @@ fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
        .map(|v| v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("properties.set", "thickness must be a finite number")))
        .transpose()?;
    let lw = p.get("lineweight").map(|v| super::layer::parse_lw(v).ok_or_else(|| bad("properties.set", "bad lineweight"))).transpose()?;
-    let d = s.doc()?;
+    let d = s.doc_mut()?;
    // An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
    let linetype = str_param(p, "linetype")
        .map(|n| {
@@ -285,18 +222,13 @@ fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
            }
        })
        .transpose()?;
+    if let Some(l) = str_param(p, "layer") {
+        d.ensure_layer(l);
+    }
    let dim_style = str_param(p, "dimStyle")
        .map(|n| d.dim_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("dimension style `{n}` not found"))))
        .transpose()?;
    let dim_over = dim_overrides(p)?;
-    if hs.is_empty() {
-        // Every object was left out: the drawing stays as it was, with no undo step.
-        return Ok(left_out.result(0));
-    }
-    let d = s.doc_mut()?;
-    if let Some(l) = str_param(p, "layer") {
-        d.ensure_layer(l);
-    }
    let anno_scale = d.current_anno_scale();
    let common = CommonEntityProperties { anno_scale: &anno_scale, color, linetype: linetype.as_deref(), lineweight: lw, transparency, thickness };
    for h in &hs {
@@ -305,7 +237,7 @@ fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
            apply_kind_properties(e, p, dim_style.as_ref(), &dim_over);
        })?;
    }
-    Ok(left_out.result(hs.len()))
+    Ok(json!({ "changed": hs.len() }))
 }

 fn apply_kind_properties(
@@ -402,17 +334,6 @@ fn apply_kind_properties(
                t.rotation = x.to_radians();
            }
        }
-        // A multileader's text: its contents (#1081) and height.
-        EntityKind::MLeader(m) => {
-            if let Some(t) = &mut m.text {
-                if let Some(v) = str_param(params, "text") {
-                    t.contents = v.replace('\n', "\\P");
-                }
-                if let Some(x) = num("height").filter(|x| *x > 0.0) {
-                    t.height = x;
-                }
-            }
-        }
        EntityKind::LwPolyline(pl) => {
            if let Some(x) = num("width").filter(|x| *x >= 0.0) {
                pl.const_width = x;
@@ -23,6 +23,7 @@ use serde_json::{Value, json};

 use super::super::curves::{KW, is_locked};
 use super::super::machines::{SelOutcome, SelectPhase, number};
+use super::super::targets;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};

 const PROPERTIES: [&str; 7] = ["Color", "LAyer", "LType", "ltScale", "LWeight", "Thickness", "TRansparency"];
@@ -89,18 +90,13 @@ impl ChpropM {
        if vals.all(|v| v == first) { first } else { "varies".into() }
    }

-    /// Apply `props` to the selection through `properties.set`, saying what it left out: objects
-    /// this command moved onto a locked layer, say.
+    /// Apply `props` to the selection through `properties.set`.
    fn apply(&self, s: &mut Session, props: Value) -> Result<()> {
        let mut p = json!({ "handles": self.handles.iter().map(|h| h.hex()).collect::<Vec<_>>() });
        if let (Some(p), Value::Object(props)) = (p.as_object_mut(), props) {
            p.extend(props);
        }
-        let r = super::run_set(s, &p)?;
-        if let Some(m) = r.get("message").and_then(Value::as_str) {
-            s.echo(m.to_string());
-        }
-        Ok(())
+        super::run_set(s, &p).map(|_| ())
    }

    /// Take an answer to `ask`; `false` when it was refused (the prompt comes again).
@@ -241,6 +237,33 @@ pub(super) fn feed_unlocked(select: &mut SelectPhase, s: &mut Session, i: Input)
    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> {
+    let hs = targets(s, p)?;
+    let locked = locked(s, &hs);
+    if locked.is_empty() {
+        return super::run_set(s, p).map(|r| with_locked(r, 0));
+    }
+    let free: Vec<Handle> = hs.into_iter().filter(|h| !locked.contains(h)).collect();
+    let r = if free.is_empty() {
+        json!({ "changed": 0 })
+    } else {
+        let mut q = p.as_object().cloned().unwrap_or_default();
+        q.insert("handles".into(), json!(free.iter().map(|h| h.hex()).collect::<Vec<_>>()));
+        super::run_set(s, &Value::Object(q))?
+    };
+    Ok(with_locked(r, locked.len()))
+}
+
+/// `r` with how many objects were left out on locked layers.
+fn with_locked(mut r: Value, n: usize) -> Value {
+    if let Some(o) = r.as_object_mut() {
+        o.insert("locked".into(), json!(n));
+    }
+    r
+}
+
 /// A colour typed at CHPROP: 1–255, a name, BYLAYER or BYBLOCK (not 0 or 256, which COLOR takes).
 fn color(t: &str) -> Option<Color> {
    if t.bytes().all(|b| b.is_ascii_digit()) {
@@ -108,9 +108,8 @@ fn property(d: &Drawing, e: &Entity, name: &str) -> Option<Value> {

 /// Glob match, case-insensitive: `*` any run, `?` one character, `#` one digit.
 pub fn wildcard(pat: &str, text: &str) -> bool {
-    // Only the characters that can match are lower-cased, so a huge text isn't copied whole.
-    let p: Vec<char> = pat.chars().take(1024).flat_map(char::to_lowercase).collect();
-    let t: Vec<char> = text.chars().take(4096).flat_map(char::to_lowercase).collect();
+    let p: Vec<char> = pat.to_lowercase().chars().take(1024).collect();
+    let t: Vec<char> = text.to_lowercase().chars().take(4096).collect();
    // Iterative matcher with single back-track point (linear-ish, no recursion).
    let (mut pi, mut ti) = (0usize, 0usize);
    let mut star: Option<(usize, usize)> = None;
@@ -176,14 +175,8 @@ pub fn compare(prop: &Value, op: Op, value: &Value) -> bool {
            if ptxt.eq_ignore_ascii_case(vtxt.trim()) {
                return true;
            }
-            // Colours: `red` = `1` = `Red`; `bylayer` = `ByLayer`. No colour spelling is long, so a
-            // long text (a layer name from a file) isn't parsed, copied and split per entity.
-            const MAX_COLOR_TEXT: usize = 64;
-            let (pc, vc) = (ptxt.trim(), vtxt.trim());
-            if pc.len() > MAX_COLOR_TEXT || vc.len() > MAX_COLOR_TEXT {
-                return false;
-            }
-            match (Color::parse(pc), Color::parse(vc)) {
+            // Colours: `red` = `1` = `Red`; `bylayer` = `ByLayer`.
+            match (Color::parse(&ptxt), Color::parse(vtxt.trim())) {
                (Some(a), Some(b)) => a == b,
                _ => false,
            }
@@ -280,7 +273,7 @@ fn run_qselect(s: &mut Session, p: &Value) -> Result<Value> {
    let sel = match mode.as_str() {
        "exclude" => excluded,
        "append" => {
-            let mut cur = s.stored_selection();
+            let mut cur = s.selection();
            for h in matched {
                if !cur.contains(&h) {
                    cur.push(h);
@@ -407,26 +400,3 @@ mod tests {
        assert!(!wildcard(&"*a".repeat(500), &"b".repeat(4000)));
    }
 }
-
-#[cfg(test)]
-mod long_text_tests {
-    use super::*;
-
-    /// A long string property is compared as text only, and a colour name still equals its index.
-    #[test]
-    fn long_values_skip_colour_parsing() {
-        let long = Value::String("x".repeat(100_000));
-        assert!(compare(&long, Op::Eq, &long));
-        assert!(!compare(&long, Op::Eq, &Value::String("red".into())));
-        assert!(compare(&Value::String("red".into()), Op::Eq, &Value::String("1".into())));
-    }
-
-    /// Padding is trimmed before the length limit, so a padded colour still matches.
-    #[test]
-    fn padded_colours_still_match() {
-        let padded = |c: &str| Value::String(format!("{}{c}{}", " ".repeat(100), " ".repeat(100)));
-        assert!(compare(&padded("red"), Op::Eq, &Value::String("1".into())));
-        assert!(compare(&Value::String("red".into()), Op::Eq, &padded("1")));
-        assert!(!compare(&padded("red"), Op::Ne, &padded("1")));
-    }
-}
@@ -99,21 +99,14 @@ pub(crate) fn similar(e: &Entity, r: &Entity, mode: u32) -> bool {
        && (mode & NAME == 0 || same_text(object_name(e), object_name(r)))
 }

-/// The objects of the current space like any of `refs` that a selection can take there: visible,
-/// and inside an MSPACE viewport not on a layer frozen in it.
+/// The visible objects of the current space like any of `refs`.
 fn similar_objects(s: &Session, d: &Drawing, refs: &[Handle], mode: u32) -> Vec<Handle> {
    let refs: Vec<&Entity> = refs.iter().filter_map(|h| d.entity(*h).map(|e| e.as_ref())).collect();
    if refs.is_empty() {
        return Vec::new();
    }
    let Some(store) = d.space(&s.space()) else { return Vec::new() };
-    let frozen = s.viewport_frozen();
-    store
-        .iter()
-        .take(MAX_SCAN)
-        .filter(|e| crate::select::selectable(d, e, frozen) && refs.iter().any(|r| similar(e, r, mode)))
-        .map(|e| e.handle)
-        .collect()
+    store.iter().take(MAX_SCAN).filter(|e| d.is_visible(e) && refs.iter().any(|r| similar(e, r, mode))).map(|e| e.handle).collect()
 }

 fn mode_param(s: &Session, p: &Value) -> Result<u32> {
@@ -12,7 +12,7 @@ use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};

 /// Largest linked file read (bytes).
 #[cfg(not(target_arch = "wasm32"))]
-const MAX_LINK_BYTES: usize = 8 << 20;
+const MAX_LINK_BYTES: u64 = 8 << 20;

 pub fn specs() -> Vec<CommandSpec> {
    vec![
@@ -238,9 +238,11 @@ fn read_link(id: &str, file: &std::path::Path) -> Result<String> {
    let path = file.display();
    #[cfg(not(target_arch = "wasm32"))]
    {
-        // The limit is enforced on the bytes read, not on reported metadata, so a device or FIFO
-        // that misreports its length can't be buffered to EOF.
-        let bytes = crate::capped_read::read_capped(file, MAX_LINK_BYTES).map_err(|e| bad(id, format!("{path}: {e}")))?;
+        let meta = std::fs::metadata(file).map_err(|e| bad(id, format!("{path}: {e}")))?;
+        if meta.len() > MAX_LINK_BYTES {
+            return Err(bad(id, format!("{path}: larger than {} MB", MAX_LINK_BYTES >> 20)));
+        }
+        let bytes = std::fs::read(file).map_err(|e| bad(id, format!("{path}: {e}")))?;
        let text = String::from_utf8_lossy(&bytes);
        Ok(text.strip_prefix('\u{feff}').unwrap_or(&text).to_owned())
    }
@@ -368,16 +370,6 @@ fn run_update(s: &mut Session, p: &Value) -> Result<Value> {
 mod tests {
    use super::*;

-    /// A linked path naming an endless device is refused instead of buffered to EOF.
-    #[cfg(all(unix, not(target_arch = "wasm32")))]
-    #[test]
-    fn link_to_endless_device_is_rejected() {
-        let dev = std::path::Path::new("/dev/zero");
-        if dev.exists() {
-            assert!(read_link("datalink", dev).is_err());
-        }
-    }
-
    #[test]
    fn csv_parsing() {
        assert_eq!(parse_csv("a,b\r\n\"c,d\",\"e\"\"f\"\n", ','), vec![vec!["a", "b"], vec!["c,d", "e\"f"]]);
@@ -36,7 +36,7 @@ fn misses_edges(e: &EngineError) -> bool {
 }

 /// Trim or extend `h` at `at`. A Quick-mode (`quick`) trim of an object no cutting edge crosses
-/// erases it. Returns what `h` became: its pieces, `h` itself first (none when it was erased).
+/// erases it. Returns the handles that replace `h` (none when it was erased).
 fn apply(s: &mut Session, h: Handle, at: Vec2, extending: bool, edges: Edges, quick: bool) -> Result<Vec<Handle>> {
    if extending {
        extend(s, h, at, edges)?;
@@ -59,7 +59,7 @@ fn fence(s: &mut Session, pts: &[Vec2], extending: bool, edges: Edges, quick: bo
    let fb = Bounds2::from_points(pts.iter().copied());
    let tol = crate::select::window_tol(&fb);
    let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
-    for h in crate::select::select_fence_in(d, &space, s.viewport_frozen(), pts) {
+    for h in crate::select::select_fence(d, &space, pts) {
        let Some(e) = d.entity(h) else { continue };
        let polys = crate::select::hit_polylines(d, e, tol);
        let mut xs: Vec<Vec2> = Vec::new();
@@ -96,7 +96,7 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu
    ];
    let inside = |p: Vec2| bx.expand(tol).contains(p);
    let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
-    for h in crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, true) {
+    for h in crate::select::select_window(d, &space, bx, true) {
        let Some(e) = d.entity(h) else { continue };
        let mut best: Option<Vec2> = None;
        for pl in crate::select::hit_polylines(d, e, tol) {
@@ -118,8 +118,8 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu
    run_picks(s, work, extending, edges, quick, tol)
 }

-/// Trim (or extend) each object at its pick points. A trim leaves the object in pieces, so later
-/// picks go to the piece within `tol` of the point (none: that part is already gone).
+/// Trim (or extend) each object at its pick points. A trim replaces the object with pieces, so
+/// later picks go to the piece within `tol` of the point (none: that part is already gone).
 fn run_picks(s: &mut Session, work: Vec<(Handle, Vec<Vec2>)>, extending: bool, edges: Edges, quick: bool, tol: f64) -> Result<usize> {
    let mut n = 0;
    let mut last_err = None;
@@ -18,7 +18,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
 pub fn specs() -> Vec<CommandSpec> {
    vec![
        CommandSpec::new("txt2mtxt", "Convert Text to Mtext", run_txt2mtxt)
-            .menu(&["Tools", "Additional Tools", "Convert Text to Mtext"])
+            .menu(&["Tools", "Express Tools", "Convert Text to Mtext"])
            .params(
                "{handles? (default the selection; TEXT, and MTEXT when combining), combine? (default true: one MTEXT; false: one per TEXT), \
                 sort?: \"topdown\" (default) | \"selection\", wrap? (default false: one line per text)} → {handles}",
@@ -8,12 +8,6 @@ pub struct Snapshot {
    pub selection: Vec<Handle>,
 }

-/// [`DocState::drawn_in_viewport`] looks its handles up one by one while there is fewer than one
-/// of them for every `LOOKUP_COST` objects of model space, and passes over model space once
-/// otherwise. Timed on drawings of 40,000 and of 200,000 lines, the two cost the same at about
-/// one handle for every 47 and for every 18 objects.
-const LOOKUP_COST: usize = 32;
-
 /// One open drawing.
 #[derive(Clone, Debug)]
 pub struct DocState {
@@ -125,65 +119,13 @@ impl DocState {
    }
    /// The active MSPACE viewport, if it still exists in the current layout.
    pub fn active_viewport(&self) -> Option<(Handle, cadcraft_doc::Viewport)> {
-        self.active_viewport_ref().map(|(h, v)| (h, v.clone()))
-    }
-    /// [`DocState::active_viewport`] without copying the viewport.
-    fn active_viewport_ref(&self) -> Option<(Handle, &cadcraft_doc::Viewport)> {
        let h = self.mspace?;
        let e = self.doc.space(&self.space)?.get(h)?;
        match &e.kind {
-            cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v)),
+            cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v.clone())),
            _ => None,
        }
    }
-    /// The layers frozen in the active MSPACE viewport (VPLAYER, "VP Freeze"): that viewport does
-    /// not draw their objects, so picks, selections and grips made through it leave them out.
-    /// Empty in paper space and on the Model tab.
-    pub fn viewport_frozen(&self) -> &[String] {
-        match self.active_viewport_ref() {
-            Some((_, v)) => &v.frozen_layers,
-            None => &[],
-        }
-    }
-    /// Whether `e` is a model-space object the active MSPACE viewport does not draw: it is on a
-    /// layer frozen in that viewport ([`DocState::viewport_frozen`]). Objects on the sheet are not
-    /// drawn through the viewport, so its frozen layers do not hide them.
-    pub fn hidden_in_viewport(&self, e: &cadcraft_doc::Entity) -> bool {
-        crate::select::on_frozen_layer(self.viewport_frozen(), e) && self.doc.model.contains(e.handle)
-    }
-    /// Whether the view being edited shows `e`: the drawing shows it ([`Drawing::is_visible`]),
-    /// and the active MSPACE viewport, if there is one, draws it
-    /// ([`DocState::hidden_in_viewport`]).
-    pub fn shows(&self, e: &cadcraft_doc::Entity) -> bool {
-        self.doc.is_visible(e) && !self.hidden_in_viewport(e)
-    }
-    /// `handles` without the objects the active MSPACE viewport does not draw
-    /// ([`DocState::hidden_in_viewport`]): a set of objects made earlier (the selection, the
-    /// Previous set) as that viewport takes it. All of them anywhere else.
-    pub(crate) fn drawn_in_viewport(&self, handles: &[Handle]) -> Vec<Handle> {
-        let frozen = self.viewport_frozen();
-        if frozen.is_empty() || handles.is_empty() {
-            return handles.to_vec();
-        }
-        let model = &self.doc.model;
-        let hidden = |e: &Arc<cadcraft_doc::Entity>| crate::select::on_frozen_layer(frozen, e);
-        // The UI asks for the selection several times a frame. A few handles are looked up one
-        // by one; beyond that, one pass over model space costs less than the lookups.
-        if handles.len().saturating_mul(LOOKUP_COST) < model.len() {
-            return handles.iter().copied().filter(|h| !model.get(*h).is_some_and(hidden)).collect();
-        }
-        let mut gone: Vec<Handle> = model.iter().filter(|e| hidden(e)).map(|e| e.handle).collect();
-        gone.sort_unstable();
-        handles.iter().copied().filter(|h| gone.binary_search(h).is_err()).collect()
-    }
-    /// The selection as the view being edited has it: [`DocState::selection`] without the objects
-    /// the active MSPACE viewport does not draw. Those stay in [`DocState::selection`] until the
-    /// selection is replaced or cleared, and count as selected again once that viewport draws
-    /// them; until then nothing that starts from the selection (a command, a grip, a palette)
-    /// edits them through that viewport.
-    pub fn shown_selection(&self) -> Vec<Handle> {
-        self.drawn_in_viewport(&self.selection)
-    }
    pub fn paper_view(&self) -> View {
        self.views.iter().find(|(s, _)| *s == self.space).map(|(_, v)| *v).unwrap_or_default()
    }
@@ -1,186 +0,0 @@
-//! Words typed on a Greek keyboard layout.
-//!
-//! With the Greek layout active, the keys that type LINE produce ΛΙΝΕ. Command names, aliases and
-//! prompt keywords are Latin, so a Greek speaker would have to switch layouts for every command.
-//! [`latin_keys`] reads a word as the Latin keys that produced it (the layout puts each Greek
-//! letter on the key of the Latin letter it sounds like): the command line then accepts ΛΙΝΕ and
-//! ΣΤΡΕΤΨΗ as LINE and STRETCH. Accents (the layout's dead key) are ignored.
-
-/// The Latin key a Greek letter is typed on (lower case, accents removed).
-fn key_of(c: char) -> Option<char> {
-    Some(match c {
-        'α' | 'ά' => 'a',
-        'β' => 'b',
-        'γ' => 'g',
-        'δ' => 'd',
-        'ε' | 'έ' => 'e',
-        'ζ' => 'z',
-        'η' | 'ή' => 'h',
-        'θ' => 'u',
-        'ι' | 'ί' | 'ϊ' | 'ΐ' => 'i',
-        'κ' => 'k',
-        'λ' => 'l',
-        'μ' => 'm',
-        'ν' => 'n',
-        'ξ' => 'j',
-        'ο' | 'ό' => 'o',
-        'π' => 'p',
-        'ρ' => 'r',
-        'σ' => 's',
-        // The W key types the final sigma.
-        'ς' => 'w',
-        'τ' => 't',
-        'υ' | 'ύ' | 'ϋ' | 'ΰ' => 'y',
-        'φ' => 'f',
-        'χ' => 'x',
-        'ψ' => 'c',
-        'ω' | 'ώ' => 'v',
-        // The Q key types the semicolon, which Greek text writes as ";" or U+037E.
-        ';' | '\u{37e}' => 'q',
-        _ => return None,
-    })
-}
-
-/// Whether `c` is a Greek letter (the basic and accented ranges the layout types).
-fn is_greek_letter(c: char) -> bool {
-    matches!(c, '\u{386}'..='\u{3ce}') && c != '\u{387}'
-}
-
-/// `word` read as the Latin keys of a Greek-layout keyboard, lower case: `Some` only when the word
-/// has a Greek letter and every character is a Greek letter the layout types, the semicolon on
-/// the Q key, or ASCII (itself, in lower case). A combining tonos or dialytika, the accent of
-/// decomposed text, is ignored like the accent of a precomposed letter, but only straight after
-/// the Greek letter it accents and once each: anywhere else the word is not Greek-layout typing.
-pub fn latin_keys(word: &str) -> Option<String> {
-    let mut greek = false;
-    // What the previous Greek letter already carries (tonos, dialytika); `None` when the previous
-    // character is not a Greek letter, which leaves a combining mark nothing to accent.
-    let mut marks: Option<(bool, bool)> = None;
-    let mut out = String::with_capacity(word.len());
-    for c in word.chars() {
-        if matches!(c, '\u{301}' | '\u{308}') {
-            let (tonos, dialytika) = marks.as_mut()?;
-            if std::mem::replace(if c == '\u{301}' { tonos } else { dialytika }, true) {
-                return None;
-            }
-            continue;
-        }
-        if c.is_ascii() {
-            // The Q key types the ASCII semicolon in the Greek layout; every other ASCII character is itself.
-            out.push(if c == ';' { 'q' } else { c.to_ascii_lowercase() });
-            marks = None;
-            continue;
-        }
-        let lower = c.to_lowercase().next().unwrap_or(c);
-        out.push(key_of(lower)?);
-        let letter = is_greek_letter(lower);
-        greek |= letter;
-        marks = letter.then_some((false, false));
-    }
-    greek.then_some(out)
-}
-
-/// `word` with its case, accents and final sigma folded away, when it is Greek-layout typing: every
-/// spelling of one Greek word gives the same string. It is the word's keys, with the final sigma
-/// read as the letter sigma instead of the W key.
-pub fn greek_fold(word: &str) -> Option<String> {
-    latin_keys(&word.replace('ς', "σ"))
-}
-
-/// Whether `a` and `b` are one Greek word, whatever their case, accents or final sigma.
-pub fn same_greek_word(a: &str, b: &str) -> bool {
-    same_greek_word_as(b).is_some_and(|same| same(a))
-}
-
-/// A test for "is the Greek word `word`, whatever the case, accents or final sigma", or `None`
-/// when `word` is not Greek-layout typing. `word` is folded here, once: looking a typed word up
-/// among many names costs its length once, not once for every name.
-pub fn same_greek_word_as(word: &str) -> Option<impl Fn(&str) -> bool> {
-    let fold = greek_fold(word)?;
-    Some(move |name: &str| greek_fold(name).as_deref() == Some(fold.as_str()))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{latin_keys, same_greek_word};
-
-    /// One Greek word compares equal in any case, accent or final sigma; another word, or a Latin
-    /// one, does not.
-    #[test]
-    fn one_greek_word_is_the_same_in_any_case_accent_or_final_sigma() {
-        for (a, b) in [("ΣΟΛΙΔ", "σολιδ"), ("ΣΟΛΙΔ", "σολίδ"), ("ΛΑΣ", "λας"), ("ΛΑΣ", "λασ"), ("ΛΙ\u{301}ΝΕ", "λινε")]
-        {
-            assert!(same_greek_word(a, b), "{a} {b}");
-        }
-        for (a, b) in [("ΣΟΛΙΔ", "ΣΟΛΙ"), ("ΣΟΛΙΔ", "solid"), ("solid", "SOLID")] {
-            assert!(!same_greek_word(a, b), "{a} {b}");
-        }
-    }
-
-    /// A character the layout does not type is never taken for the Greek letter Unicode upper-cases
-    /// it to: the micro sign is not μ, the long s and the sharp s are not σ, an alpha with an iota
-    /// subscript is not αι, the theta symbol is not θ.
-    #[test]
-    fn a_character_the_layout_does_not_type_is_no_spelling_of_a_greek_letter() {
-        let pairs = [("\u{b5}", "μ"), ("Λ\u{17f}", "ΛΣ"), ("Λ\u{df}", "ΛΣΣ"), ("\u{1fb3}", "αι"), ("\u{3d1}", "θ")];
-        let same: Vec<_> = pairs.iter().filter(|(a, b)| same_greek_word(a, b) || same_greek_word(b, a)).collect();
-        assert!(same.is_empty(), "{same:?}");
-    }
-
-    /// Greek-layout typing reads as its Latin keys: plain, accented and decomposed letters, the Q
-    /// and W keys, ASCII prefixes.
-    #[test]
-    fn greek_layout_commands_read_as_their_latin_keys() {
-        assert_eq!(latin_keys("ΛΙΝΕ").as_deref(), Some("line"));
-        assert_eq!(latin_keys("λινε").as_deref(), Some("line"));
-        assert_eq!(latin_keys("ΣΤΡΕΤΨΗ").as_deref(), Some("stretch"));
-        assert_eq!(latin_keys("ΜΙΡΡΟΡ").as_deref(), Some("mirror"));
-        assert_eq!(latin_keys("ΘΝΔΟ").as_deref(), Some("undo"));
-        // The Q key types ";", the W key the final sigma.
-        assert_eq!(latin_keys(";ΣΑΩΕ").as_deref(), Some("qsave"));
-        assert_eq!(latin_keys("ςΒΛΟΨΚ").as_deref(), Some("wblock"));
-        // Accented letters (the layout's dead key) read as the plain letter.
-        assert_eq!(latin_keys("ΛΊΝΕ").as_deref(), Some("line"));
-        assert_eq!(latin_keys("ΆΡΡΑΥ").as_deref(), Some("array"));
-        // The same accents written as a combining mark after the letter (decomposed text).
-        assert_eq!(latin_keys("ΛΙ\u{301}ΝΕ").as_deref(), Some("line"));
-        assert_eq!(latin_keys("ΛΙΝΕ\u{301}").as_deref(), Some("line"));
-        assert_eq!(latin_keys("ΛΙ\u{308}ΝΕ").as_deref(), Some("line"));
-        assert_eq!(latin_keys("ΛΙ\u{308}\u{301}ΝΕ").as_deref(), Some("line"), "dialytika and tonos on one letter");
-        // Prefixes and digits are kept.
-        assert_eq!(latin_keys("-ΛΑΥΕΡ").as_deref(), Some("-layer"));
-        assert_eq!(latin_keys("_ΛΙΝΕ").as_deref(), Some("_line"));
-    }
-
-    /// A word with no Greek letter, or with a character the layout does not type, is not read.
-    #[test]
-    fn words_that_are_not_greek_layout_typing_are_left_alone() {
-        assert_eq!(latin_keys("line"), None, "no Greek letter");
-        assert_eq!(latin_keys(""), None);
-        assert_eq!(latin_keys(";"), None, "a semicolon alone is not a word");
-        assert_eq!(latin_keys("ΛΙΝΕ Ж"), None, "a letter the layout does not type");
-        assert_eq!(latin_keys("ΛΙΝΕ 日本"), None);
-        assert_eq!(latin_keys("\u{387}"), None, "the ano teleia is punctuation, not a letter");
-    }
-
-    /// A combining tonos or dialytika counts only straight after a Greek letter, and once each.
-    #[test]
-    fn a_combining_mark_must_follow_the_greek_letter_it_accents() {
-        assert_eq!(latin_keys("\u{301}ΛΙΝΕ"), None, "no letter before the mark");
-        assert_eq!(latin_keys("\u{308}ΛΙΝΕ"), None);
-        assert_eq!(latin_keys("ΛΙΝΕ-\u{301}"), None, "after punctuation");
-        assert_eq!(latin_keys("a\u{301}ΛΙΝΕ"), None, "after a Latin letter");
-        assert_eq!(latin_keys("Λ\u{301}\u{301}ΙΝΕ"), None, "a second tonos on one letter");
-        assert_eq!(latin_keys("Λ\u{308}\u{308}ΙΝΕ"), None, "a second dialytika on one letter");
-    }
-
-    /// A 100 000-letter word and odd code points are read or refused; nothing panics.
-    #[test]
-    fn hostile_text_never_panics() {
-        let long = "Ω".repeat(100_000);
-        assert_eq!(latin_keys(&long).map(|s| s.len()), Some(100_000));
-        for s in ["\u{0}", "\u{301}", "ΛΙΝΕ\u{301}", "\u{10ffff}", "ς\u{3c2}\u{3a3}"] {
-            let _ = latin_keys(s);
-        }
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dylan M. Taylor	a54d694f4f	Release 0.17.1	2026-11-04 19:50:38 -05:00
Dylan M. Taylor	d12f592d80	Release 0.17.1	2026-11-04 19:48:04 -05:00
Dylan M. Taylor	567dfd49ed	Run the signed release from the release environment	2026-11-04 19:35:54 -05:00
Dylan M. Taylor	8d90dec9ec	Release 0.17.1	2026-11-04 18:50:12 -05:00