#618: move the OFFSET canvas test into the ui-egui test binary

Main now builds one integration-test binary per crate (#1989); only tests that install process-wide state stay separate. This test only drives its own session, so it joins tests/it.

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
     uses: storytold/craft-common-actions/.github/workflows/gate.yml@main
     with:
       # Same craft-fonts commit as release.yml.
-      craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
+      craft-fonts-ref: 3d9ab3a132ed0eff457e424226a435a901da30d3
       timeout-minutes: 90
       packages: >-
         pkg-config libxkbcommon-dev libwayland-dev libx11-dev libxcb1-dev libxcursor-dev

.github/workflows/freebsd.yml

@@ -29,4 +29,4 @@ 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/freebsd.yml@main
     with:
-      craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
+      craft-fonts-ref: 3d9ab3a132ed0eff457e424226a435a901da30d3

.github/workflows/nix.yml

@@ -21,41 +21,3 @@ jobs:
   nix:
     # 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/nix.yml@main
-
-  git-sources:
-    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

.github/workflows/release.yml

@@ -11,63 +11,20 @@ on:
         default: ""
 
 permissions:
-  contents: read
+  contents: write
 
 concurrency:
   group: release-${{ github.ref }}
   cancel-in-progress: false
 
 jobs:
-  git-sources:
-    name: Git dependencies come from storytold
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    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: git-sources
-    permissions:
-      # The reusable release workflow tags and uploads the draft release.
-      contents: write
     # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
     uses: storytold/craft-common-actions/.github/workflows/release.yml@main
     with:
       app-name: cadcraft
       app-title: CADCraft
-      craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
+      craft-fonts-ref: 3d9ab3a132ed0eff457e424226a435a901da30d3
       version: ${{ inputs.version }}
     secrets:
       APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}

.github/workflows/sonarcloud.yml

@@ -11,8 +11,7 @@ permissions:
 
 concurrency:
   group: sonarcloud-${{ github.ref }}
-  # A push to main is the run that publishes coverage; superseded runs there would never finish.
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+  cancel-in-progress: true
 
 jobs:
   sonarcloud:

ATTRIBUTION.md

@@ -23,11 +23,6 @@ Generated-in-code assets are original and have no file to list:
 
 | Asset | Author | Source | Licence | Notes |
 |---|---|---|---|---|
-| `epaint_default_fonts::EGUI_ICONS`, `epaint_default_fonts::EMOJI_ICON` (dependency font inputs) | John Slegers | [egui 173cc737](https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts), [emoji-icon-font](https://github.com/jslegers/emoji-icon-font) | MIT (Copyright (c) 2014 John Slegers; full upstream text in `NOTICE`) | egui-icons.ttf is the five-glyph subset; emoji-icon-font.ttf is the full monochrome fallback. Registered by the production default font definitions; dependency assets unmodified here, no font file copied into this repository. |
-| `krilla 0.8.2 / icc/sGrey-v2-magic.icc` (dependency-embedded) | Clinton Ingram | [craft-libs a091680 vendor/krilla/icc/sGrey-v2-magic.icc](https://github.com/storytold/craft-libs/blob/a0916808f7d78bed8c7b90cdf937176015454a7f/vendor/krilla/icc/sGrey-v2-magic.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `4110169287e5f1b5149ca9f1da1814d32943905bba8030e849d1a3b729a19481`. |
-| `krilla 0.8.2 / icc/sGrey-v4.icc` (dependency-embedded) | Clinton Ingram | [craft-libs a091680 vendor/krilla/icc/sGrey-v4.icc](https://github.com/storytold/craft-libs/blob/a0916808f7d78bed8c7b90cdf937176015454a7f/vendor/krilla/icc/sGrey-v4.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `00c0f94e09127520a17dc0e1d9264b5702081d96dbdb1549ee88e3631ce42a9d`. |
-| `krilla 0.8.2 / icc/sRGB-v2-magic.icc` (dependency-embedded) | Clinton Ingram | [craft-libs a091680 vendor/krilla/icc/sRGB-v2-magic.icc](https://github.com/storytold/craft-libs/blob/a0916808f7d78bed8c7b90cdf937176015454a7f/vendor/krilla/icc/sRGB-v2-magic.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `af4efe28f6d311799865f325ba39184a2e978b113ca74124d60af7de22b105f4`. |
-| `krilla 0.8.2 / icc/sRGB-v4.icc` (dependency-embedded) | Clinton Ingram | [craft-libs a091680 vendor/krilla/icc/sRGB-v4.icc](https://github.com/storytold/craft-libs/blob/a0916808f7d78bed8c7b90cdf937176015454a7f/vendor/krilla/icc/sRGB-v4.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `c56e1685d888f5edb92fe07f2750f387f8fe8e91b32ff8fb0b56bfbbb9458353`. |
 | `assets/app-icon/hicolor/128x128/apps/ai.storyteller.cadcraft.png` | CADCraft contributors | generated from `assets/app-icon/cadcraft-1024.png` | MIT OR Apache-2.0 | Linux hicolor icon |
 | `assets/app-icon/hicolor/16x16/apps/ai.storyteller.cadcraft.png` | CADCraft contributors | generated from `assets/app-icon/cadcraft-1024.png` | MIT OR Apache-2.0 | Linux hicolor icon |
 | `assets/app-icon/hicolor/24x24/apps/ai.storyteller.cadcraft.png` | CADCraft contributors | generated from `assets/app-icon/cadcraft-1024.png` | MIT OR Apache-2.0 | Linux hicolor icon |

Cargo.toml

@@ -4,10 +4,10 @@ members = ["crates/*", "apps/*", "xtask"]
 # default-members
 
 [workspace.package]
-version = "0.13.0"
+version = "0.12.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
-rust-version = "1.95"
+rust-version = "1.90"
 repository = "https://github.com/storytold/cadcraft"
 
 [workspace.dependencies]
@@ -25,10 +25,7 @@ cadcraft-engine = { path = "crates/engine" }
 cadcraft-ui-egui = { path = "crates/ui-egui" }
 cadcraft-mcp = { path = "crates/mcp" }
 # 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 = "a0916808f7d78bed8c7b90cdf937176015454a7f" }
-# PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
-# craft-pdf's patched backends to the same revision (Cargo ignores dependency-local patches).
-craft-pdf = { version = "=0.1.0", git = "https://github.com/storytold/craft-libs", rev = "a0916808f7d78bed8c7b90cdf937176015454a7f", default-features = false }
+craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "82a24b006eefa036b43c09a67fb9a3fbd17ffe63" }
 
 # foundation
 thiserror = "2"
@@ -53,14 +50,11 @@ encoding_rs = "0.8.35"
 quick-xml = "0.42"
 
 # ui
-craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "a0916808f7d78bed8c7b90cdf937176015454a7f", features = ["serde"] }
-egui = { version = "0.37", default-features = false, features = ["default_fonts", "monochrome_emoji_fonts"] }
-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 = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "495e5971bc024aa96e6ed318cb6e7cd3a0103184", features = ["egui"] }
+craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5c874d51eeb3de70e735c8ce87a59a7dedd47675", features = ["serde"] }
+egui = "0.36"
+egui_kittest = "0.36"
+eframe = { version = "0.36", default-features = false }
+egui-wgpu = "0.36"
 rfd = "0.17"
 arboard = { version = "3.6", default-features = false }
 
@@ -86,27 +80,3 @@ opt-level = 3
 lto = "thin"
 codegen-units = 16
 debug = 0
-
-# PDF backends for craft-pdf: pinned to the same reviewed craft-libs revision as craft-pdf itself
-# (Cargo ignores dependency-local patches).
-[patch.crates-io]
-krilla = { version = "=0.8.2", git = "https://github.com/storytold/craft-libs", rev = "a0916808f7d78bed8c7b90cdf937176015454a7f" }
-hayro-syntax = { git = "https://github.com/storytold/craft-libs", rev = "a0916808f7d78bed8c7b90cdf937176015454a7f" }
-hayro-jbig2 = { git = "https://github.com/storytold/craft-libs", rev = "a0916808f7d78bed8c7b90cdf937176015454a7f" }
-
-# Keep the complete egui family and native event bridge on reviewed fork commits.
-ecolor = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-emath = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-epaint = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-epaint_default_fonts = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-egui = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-egui-winit = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-egui-wgpu = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
-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" }

NOTICE

@@ -15,36 +15,10 @@ Mozilla Public License 2.0 and is used unmodified as a separate library (crates/
 is available from crates.io and the repository above.
 
 
-CADCraft's icons, drafting font, hatch patterns and linetypes are drawn or defined in code.
-The UI also bundles the egui font inputs described below. The per-file list is in ATTRIBUTION.md.
-Builds made with the optional craft-fonts input (CRAFT_FONTS_DIR) embed the fonts listed in its
-ATTRIBUTION.md, each under the SIL Open Font License 1.1.
+None: every bundled asset is original to CADCraft (icons, drafting font, hatch patterns and
+linetypes are drawn or defined in code). The per-file list is in ATTRIBUTION.md. Builds made with
+the optional craft-fonts input (CRAFT_FONTS_DIR) embed the fonts listed in its ATTRIBUTION.md,
+each under the SIL Open Font License 1.1.
 
 CADCraft is an independent project and is not affiliated with, sponsored by or endorsed by
 Autodesk, Inc. AutoCAD and DWG are trademarks of Autodesk, Inc.
-
-
-The PDF writer in the pinned craft-pdf 0.1.0 / Krilla 0.8.2 dependency embeds four Compact ICC
-Profiles by Clinton Ingram, under CC0-1.0. They are unmodified dependency assets; no profile file
-is copied into this repository. Per-file sources and SHA-256 hashes are in ATTRIBUTION.md.
-Source: https://github.com/LaurenzV/krilla/tree/3ffdf0588cf98050aad6edba51ca70162e1fb5b5/crates/krilla/icc
-(pinned through https://github.com/storytold/craft-libs/tree/a0916808f7d78bed8c7b90cdf937176015454a7f/vendor/krilla/icc).
-CC0 1.0 Universal: https://creativecommons.org/publicdomain/zero/1.0/
-Pinned licence text: https://github.com/storytold/craft-libs/blob/a0916808f7d78bed8c7b90cdf937176015454a7f/vendor/krilla/icc/LICENSE
-
-The UI's egui-icons.ttf subset and emoji-icon-font.ttf fallback are provided by epaint_default_fonts
-and registered through egui's default font definitions. They derive from emoji-icon-font by
-John Slegers, under the MIT License. The subset and full face share the following upstream notice.
-Source: https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts
-Original: https://github.com/jslegers/emoji-icon-font
-The following text is reproduced verbatim from emoji-icon-font-mit-license.txt:
-
-MIT License
-
-Copyright (c) 2014 John Slegers
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -123,7 +123,8 @@ numbers):
 
 ## Quick start
 
-CADCraft requires Rust 1.95 or later.
+Desktop and web UI builds require Rust 1.95 or later. The core workspace's declared minimum
+remains Rust 1.90.
 
 ```sh
 git clone https://github.com/storytold/cadcraft
@@ -140,7 +141,7 @@ offset 0.25                     then pick the circle and a side
 zoom e                          zoom to extents
 ```
 
-The web build: `cd apps/cadcraft-web && trunk serve` (needs [trunk](https://github.com/trunk-rs/trunk)).
+The web build: `cd apps/cadcraft-web && trunk serve` (needs [trunk](https://trunkrs.dev)).
 
 ### Fonts
 
@@ -218,10 +219,6 @@ cadcraft-cli convert drawing.dxf drawing.svg
 cadcraft-cli convert drawing.dwg detail.png --window 0,0,20000,15000
 cadcraft-cli run drawing.dwg --cmd 'zoom {"mode":"window","p1":[0,0],"p2":[20000,15000]}' --export detail.png
 cadcraft-cli run drawing.dwg --cmd 'select {"window":[[0,0],[20000,15000]]}' --cmd 'zoom {"mode":"object"}' --export sel.png
-
-# Act on what an earlier --cmd made: {last} is the last handle it returned.
-cadcraft-cli run --metric --cmd 'layout.set {"name":"Layout1"}' \
-  --cmd 'mview {"p1":[20,20],"p2":[200,150]}' --cmd 'viewport.set {"handle":"{last}","scale":1}'
 ```
 
 How image exports (PNG 2400×1600, SVG, PDF) are framed: `convert` fits the model-space extents.

ROADMAP.md

@@ -2,7 +2,7 @@
 
 **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-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
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** 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
@@ -119,7 +119,6 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
 
 | Date | Entry |
 |---|---|
-| 2026-10-21 | DXF save keeps each proxy object's and proxy entity's class: its class number (group 91) is renumbered to the rewritten CLASSES instead of naming another class, so AutoCAD's visual styles in an R14 file no longer come back as SCALE or MLEADERSTYLE (#1812) |
 | 2026-10-14 | HATCHEDIT adds boundaries from internal points or closed objects and removes selected loops in the dialog, command line and JSON command; associative links and undo are covered by tests. |
 | 2026-10-12 | TRIM: a pick after a closed polyline's last cut keeps only the complementary run instead of an extra circuit of the outline (#726) |
 | 2026-10-12 | HATCHEDIT refuses an explicit bad `scale` or `angle` before it edits anything, so a rejected request leaves the drawing, undo and redo as they were (#724) |
@@ -136,7 +135,6 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
 
 | Date | Change | Summary |
 |---|---|---|
-| 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) |
 | 2026-10-12 | trivial | Progress log: HATCHEDIT numeric validation (#724) |

apps/cadcraft-cli/src/main.rs

@@ -28,7 +28,7 @@ macro_rules! outln {
 
 use std::process::ExitCode;
 
-use cadcraft_engine::doc::{Handle, Space};
+use cadcraft_engine::doc::Space;
 use cadcraft_engine::geom::{Bounds2, Vec2};
 use cadcraft_engine::{Session, View};
 use serde_json::{Value, json};
@@ -73,15 +73,7 @@ image framing (png 2400x1600, svg, pdf; always model space):
                            scaled to fit the image without distortion.
   --view extents           always fit the drawing extents.
   --view current           the current view (as last set by zoom/pan/view.set; a freshly
-                           opened drawing's view is its extents plus a 10% margin).
-
---cmd chaining (run):
-  A --cmd parameter value of exactly \"{last}\" is replaced with the last object handle an
-  earlier --cmd in the same run returned, so a command can act on what the previous one made:
-    --cmd 'mview {\"p1\":[20,20],\"p2\":[200,150]}'        prints {\"viewports\":[\"100\"]}
-    --cmd 'viewport.set {\"handle\":\"{last}\",\"scale\":1}' changes viewport 100
-  It works in any parameter, at any depth (e.g. \"handles\":[\"{last}\"]); every other string is
-  passed unchanged. With no earlier returned handle the run fails and says so.";
+                           opened drawing's view is its extents plus a 10% margin).";
 
 /// What part of model space an image export shows.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -226,12 +218,6 @@ fn info(path: &str) -> Result<(), String> {
     Ok(())
 }
 
-/// Write `bytes` to `out` through the engine's atomic writer (an exclusively created sibling file
-/// renamed over `out`), so a failed or interrupted write leaves the previous file untouched.
-fn write_atomic(out: &str, bytes: &[u8]) -> std::io::Result<()> {
-    cadcraft_engine::atomic_write::write_atomic(std::path::Path::new(out), bytes)
-}
-
 fn export(s: &Session, out: &str) -> Result<(), String> {
     export_framed(s, out, None)
 }
@@ -239,7 +225,7 @@ fn export(s: &Session, out: &str) -> Result<(), String> {
 fn export_framed(s: &Session, out: &str, window: Option<Bounds2>) -> Result<(), String> {
     let d = s.doc().map_err(|e| e.to_string())?;
     let bytes = cadcraft_io::write_framed(d, out, window).map_err(|e| e.to_string())?;
-    write_atomic(out, &bytes).map_err(|e| format!("{out}: {e}"))?;
+    std::fs::write(out, &bytes).map_err(|e| format!("{out}: {e}"))?;
     eprintln!("wrote {out} ({} bytes)", bytes.len());
     if cadcraft_engine::cmd::file::drops_unknown(out) {
         let lost = cadcraft_engine::cmd::file::not_saved(d);
@@ -258,7 +244,7 @@ fn sample(args: &[String]) -> Result<(), String> {
         other => return Err(format!("unknown sample `{other}` (bracket, floorplan)")),
     };
     let bytes = cadcraft_io::write(&d, out).map_err(|e| e.to_string())?;
-    write_atomic(out, &bytes).map_err(|e| format!("{out}: {e}"))?;
+    std::fs::write(out, &bytes).map_err(|e| format!("{out}: {e}"))?;
     eprintln!("wrote {out} ({} bytes)", bytes.len());
     Ok(())
 }
@@ -328,133 +314,6 @@ fn skipped_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option<Stri
     Some(format!("{path}: {n} {records} could not be read and are left out ({})", list.join(", ")))
 }
 
-/// A `--cmd` parameter value of exactly `{last}` is filled in with the last object handle an
-/// earlier `--cmd` in the same run returned: `mview` answers `{"viewports":["100"]}`, so
-/// `viewport.set {"handle":"{last}","scale":1}` changes viewport 100. Any other string is passed
-/// through unchanged, and `--script` text is never rewritten.
-const LAST_HANDLE: &str = "{last}";
-
-/// How deep [`result_handles`] walks a command result (results are the engine's own JSON).
-const RESULT_DEPTH: usize = 16;
-
-/// Result keys whose values are object references: the engine's result convention for handles.
-/// A handle can be a string (`handle`, `viewport`, `insert`…) or a list of them (`handles`,
-/// `viewports`, `members`…). Every other field may hold a user-defined name, a message or a
-/// count, and is never read as a handle — a group named `100` is a name, not object `100`.
-fn handle_field(key: &str) -> bool {
-    matches!(
-        key,
-        "handle"
-            | "handles"
-            | "viewport"
-            | "viewports"
-            | "boundary"
-            | "clip"
-            | "insert"
-            | "members"
-            | "source"
-            | "objects"
-            | "entities"
-            | "selection"
-            | "parts"
-            | "refs"
-            | "matches"
-            | "line"
-            | "arc"
-            | "blocks"
-    )
-}
-
-/// Collect the handles of `v`, a value under a handle field: a handle string, an array of them,
-/// or objects that carry handle fields of their own (`entities`, `parts`).
-fn collect_result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec<Handle>) {
-    if depth > RESULT_DEPTH {
-        return;
-    }
-    match v {
-        Value::String(t) => {
-            if let Some(h) = Handle::parse_hex(t)
-                && s.doc().is_ok_and(|d| d.entity(h).is_some())
-            {
-                out.push(h);
-            }
-        }
-        Value::Array(a) => a.iter().for_each(|x| collect_result_handles(s, x, depth + 1, out)),
-        Value::Object(m) => {
-            for (k, x) in m {
-                if handle_field(k) {
-                    collect_result_handles(s, x, depth + 1, out);
-                } else {
-                    find_result_handles(s, x, depth + 1, out);
-                }
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Find handle fields nested in containers that are not handles themselves (`groups` in
-/// `groups.list`, whose members are handles): strings here are names, never references.
-fn find_result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec<Handle>) {
-    if depth > RESULT_DEPTH {
-        return;
-    }
-    match v {
-        Value::Array(a) => a.iter().for_each(|x| find_result_handles(s, x, depth + 1, out)),
-        Value::Object(m) => {
-            for (k, x) in m {
-                if handle_field(k) {
-                    collect_result_handles(s, x, depth + 1, out);
-                } else {
-                    find_result_handles(s, x, depth + 1, out);
-                }
-            }
-        }
-        _ => {}
-    }
-}
-
-/// The object handles a command result mentions, in the order it lists them. A handle-only result
-/// (a handle string or an array of them) counts as it is; otherwise only handle fields do.
-fn result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec<Handle>) {
-    match v {
-        Value::String(_) => collect_result_handles(s, v, depth, out),
-        Value::Array(a) if a.iter().all(Value::is_string) => collect_result_handles(s, v, depth, out),
-        Value::Array(_) | Value::Object(_) => find_result_handles(s, v, depth, out),
-        _ => {}
-    }
-}
-
-/// The last handle `r` returned: what a later `{last}` stands for.
-fn returned_handle(s: &Session, r: &Value) -> Option<Handle> {
-    let mut hs = Vec::new();
-    result_handles(s, r, 0, &mut hs);
-    hs.last().copied()
-}
-
-/// The active drawing's identity ([`cadcraft_engine::DocState::uid`]): a handle is only meaningful
-/// in the drawing it came from, and `new`, `open`, `document.switch` and `close` can make another
-/// drawing current.
-fn active_drawing(s: &Session) -> Option<u64> {
-    s.docs.get(s.active).map(|st| st.uid)
-}
-
-/// Every `{last}` in `p`, at any depth, replaced by `h`. With no handle to fill in it is an
-/// error, never a token reaching the command as a (bad) handle.
-fn fill_last(p: &Value, h: Option<Handle>) -> Result<Value, String> {
-    match p {
-        Value::String(t) if t.as_str() == LAST_HANDLE => match h {
-            Some(h) => Ok(Value::String(h.hex())),
-            None => Err(format!("`{LAST_HANDLE}` needs an earlier --cmd in this run to have returned a handle")),
-        },
-        Value::Array(a) => a.iter().map(|x| fill_last(x, h)).collect::<Result<Vec<_>, _>>().map(Value::Array),
-        Value::Object(m) => {
-            m.iter().map(|(k, x)| Ok((k.clone(), fill_last(x, h)?))).collect::<Result<serde_json::Map<String, Value>, _>>().map(Value::Object)
-        }
-        other => Ok(other.clone()),
-    }
-}
-
 fn run(args: &[String]) -> Result<(), String> {
     let mut s = Session::empty();
     let mut it = args.iter();
@@ -490,31 +349,13 @@ fn run(args: &[String]) -> Result<(), String> {
     }
     check_framed_output(framing, exp.as_deref())?;
     let before = model_views(&s);
-    let mut last_handle: Option<Handle> = None;
     for (kind, body) in steps {
-        // A handle belongs to the drawing that returned it: if this step makes another drawing
-        // current (`new`, `open`, `document.switch`, `close`, or a script running one of them),
-        // the remembered handle is stale. A handle the step itself returns is taken afterwards,
-        // so it is a handle of the drawing it made current.
-        let drawing = active_drawing(&s);
         match kind.as_str() {
-            "script" => {
-                s.script(&body).map_err(|e| e.to_string())?;
-                if active_drawing(&s) != drawing {
-                    last_handle = None;
-                }
-            }
+            "script" => s.script(&body).map_err(|e| e.to_string())?,
             _ => {
                 let (id, json) = body.split_once(' ').unwrap_or((&body, "{}"));
                 let params: Value = serde_json::from_str(json).map_err(|e| format!("--cmd {id}: {e}"))?;
-                let params = fill_last(&params, last_handle).map_err(|e| format!("--cmd {id}: {e}"))?;
                 let r = s.execute(id, &params).map_err(|e| e.to_string())?;
-                if active_drawing(&s) != drawing {
-                    last_handle = None;
-                }
-                if let Some(h) = returned_handle(&s, &r) {
-                    last_handle = Some(h);
-                }
                 if !r.is_null() {
                     outln!("{r}");
                 }
@@ -868,37 +709,6 @@ fn cli() -> ExitCode {
 mod tests {
     use super::*;
 
-    fn scratch_dir(tag: &str) -> std::path::PathBuf {
-        let dir = std::env::temp_dir().join(format!("cadcraft-cli-{tag}-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).expect("create scratch dir");
-        dir
-    }
-
-    #[test]
-    fn write_atomic_replaces_file_and_leaves_no_staging_files() {
-        let dir = scratch_dir("replace");
-        let out = dir.join("a.dxf");
-        let out = out.to_str().expect("utf-8 path");
-        write_atomic(out, b"old").expect("create");
-        write_atomic(out, b"new").expect("overwrite");
-        assert_eq!(std::fs::read(out).expect("read"), b"new");
-        assert_eq!(std::fs::read_dir(&dir).expect("list").count(), 1);
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn write_atomic_failure_keeps_destination_and_cleans_up() {
-        let dir = scratch_dir("fail");
-        let out = dir.join("target");
-        std::fs::create_dir(&out).expect("dir as destination");
-        std::fs::write(out.join("keep"), b"x").expect("seed");
-        assert!(write_atomic(out.to_str().expect("utf-8 path"), b"new").is_err());
-        assert_eq!(std::fs::read(out.join("keep")).expect("kept"), b"x");
-        assert_eq!(std::fs::read_dir(&dir).expect("list").count(), 1);
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
     fn b(x0: f64, y0: f64, x1: f64, y1: f64) -> Bounds2 {
         Bounds2::new(Vec2::new(x0, y0), Vec2::new(x1, y1))
     }
@@ -970,40 +780,6 @@ mod tests {
         assert!(check_framed_output(Framing::Auto, Some("a.dxf")).is_ok());
     }
 
-    #[test]
-    fn last_placeholder_takes_the_previous_handle() {
-        let mut s = sample_session();
-        let r = s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap();
-        let h = returned_handle(&s, &r).expect("LINE returns its handle");
-        assert_eq!(fill_last(&json!({"handle": "{last}"}), Some(h)), Ok(json!({"handle": h.hex()})));
-        // Nested, as in a selection list.
-        assert_eq!(fill_last(&json!({"handles": ["{last}", "1"]}), Some(h)), Ok(json!({"handles": [h.hex(), "1"]})));
-        // Only the exact token: a name or a sentence that merely contains it stays as written.
-        for p in [json!("last"), json!("{last} "), json!({"name": "last"})] {
-            assert_eq!(fill_last(&p, Some(h)), Ok(p.clone()));
-        }
-        // Nothing returned yet: an error, not a token passed to the command as a bad handle.
-        assert!(fill_last(&json!({"handle": "{last}"}), None).unwrap_err().contains("{last}"));
-    }
-
-    /// Handles are read from a result by looking the strings up in the drawing: counts and names
-    /// are not mistaken for handles, and `mview`'s `viewports` works like `handle`/`handles`.
-    #[test]
-    fn returned_handle_reads_only_real_handles() {
-        let mut s = Session::empty();
-        s.new_drawing(false);
-        s.execute("layout.set", &json!({"name": "Layout1"})).unwrap();
-        let r = s.execute("mview", &json!({"p1": [20, 20], "p2": [200, 150]})).unwrap();
-        let h = returned_handle(&s, &r).expect("mview returns its viewport handle");
-        assert!(r["viewports"].as_array().is_some_and(|a| a.iter().any(|v| v.as_str() == Some(h.hex().as_str()))), "{r}");
-        assert_eq!(returned_handle(&s, &json!({"changed": 3, "name": "A1"})), None);
-        // The most recent of several.
-        let a = s.execute("line", &json!({"points": [[0, 0], [1, 0]]})).unwrap();
-        let b = s.execute("line", &json!({"points": [[0, 0], [2, 0]]})).unwrap();
-        let (ha, hb) = (returned_handle(&s, &a).unwrap(), returned_handle(&s, &b).unwrap());
-        assert_eq!(returned_handle(&s, &json!({"handles": [ha.hex(), hb.hex()]})), Some(hb));
-    }
-
     #[test]
     fn default_framing_is_extents() {
         // convert: nothing ran, always the extents.

apps/cadcraft-cli/tests/handle_chaining.rs

@@ -1,225 +0,0 @@
-//! A `--cmd` can act on a handle an earlier `--cmd` in the same run returned (#1663).
-//!
-//! `mview` answers `{"viewports":["100"]}`, but a following `viewport.set` could not use that
-//! handle: it had to be guessed, selected by point, or activated with `mspace`. A `--cmd` parameter
-//! value of exactly `{last}` is now filled in with the last handle an earlier `--cmd` returned.
-
-use std::process::{Command, Output};
-
-fn run(args: &[&str]) -> Output {
-    Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
-        .args(args)
-        .stdout(std::process::Stdio::piped())
-        .stderr(std::process::Stdio::piped())
-        .output()
-        .expect("run cadcraft-cli")
-}
-
-/// The issue's sequence: `viewport.set` straight after `mview`, addressing the new viewport by the
-/// handle the runner remembers.
-#[test]
-fn viewport_set_after_mview_uses_the_returned_handle() {
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"layout.set {"name":"Layout1"}"#,
-        "--cmd",
-        r#"mview {"p1":[20,20],"p2":[200,150]}"#,
-        "--cmd",
-        r#"viewport.set {"handle":"{last}","scale":1}"#,
-    ]);
-    let stdout = String::from_utf8_lossy(&out.stdout);
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert!(out.status.success(), "exit {:?}\nstdout: {stdout}\nstderr: {stderr}", out.status);
-    let mview = stdout.lines().find(|l| l.contains("\"viewports\"")).unwrap_or_else(|| panic!("no mview result in {stdout:?}"));
-    let created: serde_json::Value = serde_json::from_str(mview).expect("mview result is JSON");
-    let handle = created["viewports"].as_array().and_then(|a| a.first()).and_then(|h| h.as_str()).expect("a viewport handle");
-    assert!(handle.eq_ignore_ascii_case("100"), "{mview}");
-    let set = stdout.lines().find(|l| l.contains("\"viewHeight\"")).unwrap_or_else(|| panic!("no viewport.set result in {stdout:?}"));
-    let vp: serde_json::Value = serde_json::from_str(set).expect("viewport.set result is JSON");
-    assert_eq!(vp[0]["handle"].as_str(), Some(handle), "viewport.set changed the viewport `{handle}`: {set}");
-    assert_eq!(vp[0]["scale"].as_f64(), Some(1.0), "{set}");
-}
-
-/// `{last}` with no handle to fill in is a clear error, not the token reaching the command.
-#[test]
-fn last_without_an_earlier_handle_is_an_error() {
-    let out = run(&["run", "--metric", "--cmd", r#"viewport.set {"handle":"{last}","scale":1}"#]);
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert_eq!(out.status.code(), Some(1), "stdout: {:?}\nstderr: {stderr}", String::from_utf8_lossy(&out.stdout));
-    assert!(stderr.contains("{last}"), "the error names the placeholder: {stderr}");
-    assert!(!stderr.contains("panicked"), "{stderr}");
-}
-
-/// The last JSON value a run printed: command results are one JSON value a line (`null` is not
-/// printed).
-fn last_json(stdout: &str) -> serde_json::Value {
-    let line = stdout
-        .lines()
-        .rev()
-        .find(|l| {
-            let t = l.trim_start();
-            t.starts_with('{') || t.starts_with('[')
-        })
-        .unwrap_or_else(|| panic!("no JSON result in {stdout:?}"));
-    serde_json::from_str(line).expect("command result is JSON")
-}
-
-/// `{last}` was not replaced: the error names the placeholder, and the run fails cleanly.
-fn assert_needs_an_earlier_handle(out: &Output) {
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert_eq!(out.status.code(), Some(1), "stdout: {:?}\nstderr: {stderr}", String::from_utf8_lossy(&out.stdout));
-    assert!(stderr.contains("{last}"), "the error names the placeholder: {stderr}");
-    assert!(!stderr.contains("panicked"), "{stderr}");
-}
-
-/// A user-defined name that happens to look like a handle is not a returned handle. `group`
-/// answers `{"name":"100","members":1}`: `100` is the first line's handle, but the name is not an
-/// object reference and must not replace the last handle the `line` command returned (`101`).
-#[test]
-fn a_group_name_that_looks_like_a_handle_is_not_last() {
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"line {"points":[[0,0],[10,0]]}"#,
-        "--cmd",
-        r#"line {"points":[[0,10],[10,10]]}"#,
-        "--cmd",
-        r#"group {"name":"100","handles":["101"]}"#,
-        "--cmd",
-        r#"erase {"handles":["{last}"]}"#,
-        "--cmd",
-        r#"entities {"type":"LINE"}"#,
-    ]);
-    let stdout = String::from_utf8_lossy(&out.stdout);
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert!(out.status.success(), "exit {:?}\nstdout: {stdout}\nstderr: {stderr}", out.status);
-    let r = last_json(&stdout);
-    assert_eq!(r["count"].as_u64(), Some(1), "one line is left: {stdout}");
-    let left: Vec<&str> = r["entities"].as_array().into_iter().flatten().filter_map(|e| e["handle"].as_str()).collect();
-    assert_eq!(left, ["100"], "the group name 100 did not replace the handle 101 the line command returned: {stdout}");
-}
-
-/// `new` makes another drawing current: the handle an earlier `--cmd` returned in the old drawing
-/// is not a handle of the new one.
-#[test]
-fn last_is_cleared_when_new_switches_drawings() {
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"line {"points":[[0,0],[10,0]]}"#,
-        "--cmd",
-        r#"new {"metric":true}"#,
-        "--cmd",
-        r#"erase {"handles":["{last}"]}"#,
-    ]);
-    assert_needs_an_earlier_handle(&out);
-}
-
-/// `open` makes the opened file the current drawing: a handle from the drawing before it is stale.
-#[test]
-fn last_is_cleared_when_open_switches_drawings() {
-    let dir = std::env::temp_dir().join(format!("cc-cli-last-open-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).expect("temp dir");
-    let dxf = dir.join("opened.dxf");
-    let sample = run(&["sample", "bracket", dxf.to_str().expect("temp path")]);
-    assert!(sample.status.success(), "sample failed: {}", String::from_utf8_lossy(&sample.stderr));
-    let open = format!(r#"open {{"path":{}}}"#, serde_json::to_string(dxf.to_str().expect("temp path")).expect("path JSON"));
-    let out = run(&["run", "--metric", "--cmd", r#"line {"points":[[0,0],[10,0]]}"#, "--cmd", &open, "--cmd", r#"erase {"handles":["{last}"]}"#]);
-    assert_needs_an_earlier_handle(&out);
-    let _ = std::fs::remove_dir_all(&dir);
-}
-
-/// `document.switch` changes the current drawing without adding one: a handle remembered from the
-/// drawing left behind must not be used in the one switched to.
-#[test]
-fn last_is_cleared_when_document_switch_changes_drawings() {
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"line {"points":[[0,0],[10,0]]}"#,
-        "--cmd",
-        r#"new {"metric":true}"#,
-        "--cmd",
-        r#"line {"points":[[0,10],[10,10]]}"#,
-        "--cmd",
-        r#"document.switch {"index":0}"#,
-        "--cmd",
-        r#"erase {"handles":["{last}"]}"#,
-    ]);
-    assert_needs_an_earlier_handle(&out);
-}
-
-/// A handle a command returns after a switch belongs to the drawing now current, so it is kept.
-#[test]
-fn a_handle_returned_after_a_switch_is_last() {
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"line {"points":[[0,0],[10,0]]}"#,
-        "--cmd",
-        r#"new {"metric":true}"#,
-        "--cmd",
-        r#"document.switch {"index":0}"#,
-        "--cmd",
-        r#"line {"points":[[0,10],[10,10]]}"#,
-        "--cmd",
-        r#"erase {"handles":["{last}"]}"#,
-        "--cmd",
-        r#"entities {"type":"LINE"}"#,
-    ]);
-    let stdout = String::from_utf8_lossy(&out.stdout);
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert!(out.status.success(), "exit {:?}\nstdout: {stdout}\nstderr: {stderr}", out.status);
-    let r = last_json(&stdout);
-    assert_eq!(r["count"].as_u64(), Some(1), "one line is left: {stdout}");
-    let left: Vec<&str> = r["entities"].as_array().into_iter().flatten().filter_map(|e| e["handle"].as_str()).collect();
-    assert_eq!(left, ["100"], "the line created after the switch was erased: {stdout}");
-}
-
-/// A script can change the current drawing too (`new {"metric":true}` at a script line), so the
-/// remembered handle is cleared after a script that changed it.
-#[test]
-fn last_is_cleared_by_a_script_that_changes_drawings() {
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"line {"points":[[0,0],[10,0]]}"#,
-        "--script",
-        r#"new {"metric":true}"#,
-        "--cmd",
-        r#"erase {"handles":["{last}"]}"#,
-    ]);
-    assert_needs_an_earlier_handle(&out);
-}
-
-/// Only the exact token is a placeholder: ordinary JSON strings are left alone.
-#[test]
-fn ordinary_values_are_not_placeholders() {
-    let dir = std::env::temp_dir().join(format!("cc-cli-last-placeholder-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).expect("temp dir");
-    let out_dxf = dir.join("text.dxf");
-    let out = run(&[
-        "run",
-        "--metric",
-        "--cmd",
-        r#"layout.set {"name":"Layout1"}"#,
-        "--cmd",
-        r#"mview {"p1":[20,20],"p2":[200,150]}"#,
-        "--cmd",
-        r#"text {"at":[0,0],"height":2,"text":"last and {last}"}"#,
-        "--save",
-        out_dxf.to_str().expect("temp path"),
-    ]);
-    let stderr = String::from_utf8_lossy(&out.stderr);
-    assert!(out.status.success(), "exit {:?}\nstderr: {stderr}", out.status);
-    let saved = std::fs::read_to_string(&out_dxf).expect("saved DXF");
-    assert!(saved.contains("last and {last}"), "the text is stored literally");
-    let _ = std::fs::remove_dir_all(&dir);
-}

apps/cadcraft-web/Cargo.toml

@@ -4,7 +4,6 @@ description = "CADCraft in the browser (eframe web runner, WebGPU with WebGL2 fa
 version.workspace = true
 edition.workspace = true
 license.workspace = true
-rust-version = "1.95"
 publish = false
 
 [lints]
@@ -27,7 +26,7 @@ serde_json = { workspace = true }
 web-sys = { version = "0.3", features = ["HtmlInputElement", "FileList", "File"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-eframe = { workspace = true, features = ["persistence", "wgpu", "accesskit"] }
+eframe = { workspace = true, features = ["persistence", "default_fonts", "wgpu", "accesskit"] }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Location", "Navigator", "Blob", "BlobPropertyBag", "Url", "MessageEvent", "UrlSearchParams", "MediaQueryList"] }

apps/cadcraft-web/src/host.rs

@@ -95,8 +95,7 @@ impl Bridge {
         }
     }
 
-    /// 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.
+    /// After each frame: tell the parent when unsaved changes appear or go away.
     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())]) {

apps/cadcraft-web/src/main.rs

@@ -24,39 +24,22 @@ 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
-    /// 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, crate::host::DirtyReport)>,
-        Option<web_sys::MediaQueryList>,
-        Option<String>,
-    );
+    /// page embedding it (`?host=parent`), and the browser's `prefers-reduced-motion` (it stays
+    /// live, so View ▸ Accessibility ▸ Animation Effects ▸ Use System Setting follows a change).
+    struct Shell(CadApp, crate::upload::Inbox, Option<(crate::host::Bridge, crate::host::DirtyReport)>, Option<web_sys::MediaQueryList>);
 
     impl eframe::App for Shell {
-        /// Runs one frame: takes in files dropped on or picked for the page, drains the background
-        /// uploads, follows the browser's reduced-motion setting, runs the app, writes the browser
-        /// document title when it changed (so the tab and an embedding page name the open
-        /// drawing), and reports unsaved changes to that page.
         fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-            // Background reads are consume-based and run on hidden ticks too. Dropped files are
-            // input and are read from `ui` only.
+            self.1.take_dropped(ctx);
             self.1.drain(&mut self.0);
             self.0.system_animations = self.3.as_ref().map(|reduced| !reduced.matches());
             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);
-            // `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, reported)) = &self.2 {
                 bridge.report_dirty(&self.0, reported);
             }
         }
-        /// Forward raw input to the web `CadApp` and capture Tab at the command line.
         fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
-            self.0.raw_input_hook(ctx, raw);
+            self.0.raw_input_hook(raw);
             cadcraft_ui_egui::cmdline::capture_tab(ctx, raw);
         }
         /// Preferences (interface theme and language) survive reloads; egui state is not kept.
@@ -67,25 +50,11 @@ mod web {
         fn persist_egui_memory(&self) -> bool {
             false
         }
-        /// On the first pass consume files dropped on the page, then delegate drawing to `CadApp::ui`.
         fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-            let first_pass = ui.ctx().current_pass_index() == 0;
-            if first_pass {
-                // `take_dropped` consumes the raw list; a second pass or hidden tick cannot
-                // re-read the same file.
-                self.1.take_dropped(ui.ctx());
-            }
             self.0.ui(ui);
-        }
-    }
-
-    /// Writes the browser's document title, which names the tab and is what an embedding page
-    /// (`?host=parent`) reads. eframe's web runner ignores [`egui::ViewportCommand::Title`], so
-    /// the title has to reach the DOM directly.
-    fn set_page_title(title: &str) {
-        match web_sys::window().and_then(|window| window.document()) {
-            Some(document) => document.set_title(title),
-            None => log::warn!("cannot set the page title to {title:?}: there is no document"),
+            if let Some((bridge, reported)) = &self.2 {
+                bridge.report_dirty(&self.0, reported);
+            }
         }
     }
 
@@ -98,11 +67,9 @@ mod web {
     }
 
     /// No file picker on the web: Save / Save As from the menu (and the close prompt) download the
-    /// drawing under its current name; `saveas {"path": "name.dxf"}` picks another name. There is
-    /// no file system either, so a dropped file is opened from its contents and APPLOAD says to
-    /// drop a `.lsp` file rather than asking for a name it cannot read.
+    /// drawing under its current name; `saveas {"path": "name.dxf"}` picks another name.
     fn services() -> Services {
-        Services { pick_save: Some(Box::new(|name: &str| Some(name.to_string()))), no_file_system: true, ..Services::default() }
+        Services { pick_save: Some(Box::new(|name: &str| Some(name.to_string()))), ..Services::default() }
     }
 
     pub fn start() {
@@ -185,7 +152,7 @@ mod web {
                             (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)))
+                        Ok(Box::new(Shell(app, inbox, host, reduced_motion)))
                     }),
                 )
                 .await;
@@ -210,44 +177,6 @@ fn wants_cpu(query: &str) -> bool {
     query.trim_start_matches('?').split('&').any(|p| p == "cpu" || p.starts_with("cpu="))
 }
 
-/// The browser tab title: the open drawing's file name, a bullet once it has unsaved changes,
-/// and the app name (`drawing.dwg • — CADCraft`), or just the app name with no drawing. An
-/// embedding page (`?host=parent`) reads it to tell which drawing opened and whether it is dirty.
-#[cfg(any(target_arch = "wasm32", test))]
-fn document_title(name: Option<&str>, dirty: bool) -> String {
-    match name.filter(|n| !n.trim().is_empty()) {
-        Some(name) => format!("{name}{} — CADCraft", if dirty { " •" } else { "" }),
-        None => "CADCraft".to_string(),
-    }
-}
-
-/// The title to write this frame, or `None` while the page already shows it: the browser needs
-/// the document title only when it changes, not on every frame.
-#[cfg(any(target_arch = "wasm32", test))]
-fn title_to_send(sent: &mut Option<String>, name: Option<&str>, dirty: bool) -> Option<String> {
-    let title = document_title(name, dirty);
-    if sent.as_deref() == Some(title.as_str()) {
-        return None;
-    }
-    *sent = Some(title.clone());
-    Some(title)
-}
-
-/// Writes a changed title through `write` (on the web, the browser's document title) and reports
-/// whether it wrote one. Split from [`title_to_send`] so the change decision and the write are
-/// both testable: eframe's web backend ignores `egui::ViewportCommand::Title`, so a title that is
-/// computed but not written leaves the tab on `CADCraft`.
-#[cfg(any(target_arch = "wasm32", test))]
-fn push_title(sent: &mut Option<String>, name: Option<&str>, dirty: bool, write: impl FnOnce(&str)) -> bool {
-    match title_to_send(sent, name, dirty) {
-        Some(title) => {
-            write(&title);
-            true
-        }
-        None => false,
-    }
-}
-
 #[cfg(target_arch = "wasm32")]
 mod upload;
 
@@ -263,10 +192,8 @@ fn main() {
 
 #[cfg(test)]
 mod tests {
-    use super::{document_title, push_title, title_to_send, wants_cpu};
+    use super::wants_cpu;
 
-    /// Guards the `?cpu` URL flag: only a whole `cpu` query parameter (bare or with a value)
-    /// selects the CPU canvas, so `?sample` and `?gpucpu` stay on the GPU path.
     #[test]
     fn cpu_flag_is_detected() {
         assert!(wants_cpu("?cpu"));
@@ -277,52 +204,4 @@ mod tests {
         assert!(!wants_cpu("?webgl&sample"));
         assert!(!wants_cpu("?gpucpu"));
     }
-
-    /// Guards the tab title text: a drawing contributes its name and, when dirty, a trailing
-    /// bullet; a blank or missing name leaves the app name alone and never shows a bullet.
-    #[test]
-    fn viewport_title_names_the_document_and_marks_unsaved_changes() {
-        assert_eq!(document_title(Some("drawing.dwg"), false), "drawing.dwg — CADCraft");
-        assert_eq!(document_title(Some("drawing.dwg"), true), "drawing.dwg • — CADCraft");
-        assert_eq!(document_title(Some("Drawing1"), false), "Drawing1 — CADCraft");
-        assert_eq!(document_title(None, false), "CADCraft");
-        assert_eq!(document_title(None, true), "CADCraft");
-        assert_eq!(document_title(Some("   "), true), "CADCraft");
-    }
-
-    /// Guards the change signal: a title is sent on open, rename, dirty change and close, but
-    /// never twice in a row, so an idle tab is not repainted by a repeated title command.
-    #[test]
-    fn viewport_title_follows_open_rename_and_dirty_changes_only() {
-        let mut sent = None;
-        assert_eq!(title_to_send(&mut sent, Some("drawing.dwg"), false).as_deref(), Some("drawing.dwg — CADCraft"));
-        // The page already has it: send nothing.
-        assert_eq!(title_to_send(&mut sent, Some("drawing.dwg"), false), None);
-        // Unsaved changes add the bullet.
-        assert_eq!(title_to_send(&mut sent, Some("drawing.dwg"), true).as_deref(), Some("drawing.dwg • — CADCraft"));
-        // A rename shows the new name.
-        assert_eq!(title_to_send(&mut sent, Some("plan.dwg"), true).as_deref(), Some("plan.dwg • — CADCraft"));
-        // Saving clears it again.
-        assert_eq!(title_to_send(&mut sent, Some("plan.dwg"), false).as_deref(), Some("plan.dwg — CADCraft"));
-        // Closing the last drawing leaves the app name only.
-        assert_eq!(title_to_send(&mut sent, None, false).as_deref(), Some("CADCraft"));
-        assert_eq!(title_to_send(&mut sent, None, false), None);
-    }
-
-    /// Guards the title write: every changed title reaches the writer (on the web, the browser
-    /// document title) exactly once, and an unchanged one is not written again. Without the write
-    /// the tab and an embedding page stay on `CADCraft` however the drawing changes.
-    #[test]
-    fn changed_title_reaches_the_document_title_writer_once() {
-        let mut sent = None;
-        let mut written: Vec<String> = Vec::new();
-        assert!(push_title(&mut sent, Some("drawing.dwg"), false, |title| written.push(title.to_owned())));
-        // Unchanged: nothing is written again.
-        assert!(!push_title(&mut sent, Some("drawing.dwg"), false, |title| written.push(title.to_owned())));
-        // Unsaved changes are written.
-        assert!(push_title(&mut sent, Some("drawing.dwg"), true, |title| written.push(title.to_owned())));
-        // Closing the drawing writes the app name.
-        assert!(push_title(&mut sent, None, false, |title| written.push(title.to_owned())));
-        assert_eq!(written, ["drawing.dwg — CADCraft", "drawing.dwg • — CADCraft", "CADCraft"]);
-    }
 }

apps/cadcraft-web/src/upload.rs

@@ -68,9 +68,8 @@ impl Inbox {
     }
 
     /// Read the files dropped on the page this frame (eframe hands them over unread on the web).
-    /// The list is taken, not cloned: a later pass or hidden tick must not read the same drop.
     pub fn take_dropped(&self, ctx: &egui::Context) {
-        for f in ctx.input_mut(|i| std::mem::take(&mut i.raw.dropped_files)) {
+        for f in ctx.input(|i| i.raw.dropped_files.clone()) {
             if let Some(file) = f.web_file() {
                 self.read(file.clone());
             }

apps/cadcraft/Cargo.toml

@@ -4,7 +4,6 @@ description = "CADCraft desktop app"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
-rust-version = "1.95"
 publish = false
 default-run = "cadcraft"
 
@@ -17,7 +16,7 @@ cadcraft-ui-egui = { workspace = true }
 cadcraft-io = { workspace = true }
 # For the shared per-session control-token helper (control_server.rs authentication).
 cadcraft-mcp = { workspace = true }
-eframe = { workspace = true, features = ["clipboard", "wgpu", "accesskit", "wayland", "x11", "links", "persistence"] }
+eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11", "links", "persistence"] }
 egui = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
@@ -34,7 +33,6 @@ winit = { version = "0.30", default-features = false, features = ["x11"] }
 zbus = { version = "=5.19.0", default-features = false, features = ["async-io", "blocking-api"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-craft-update = { workspace = true }
 rfd = { workspace = true }
 sys-locale = "0.3"
 

apps/cadcraft/src/main.rs

@@ -65,47 +65,37 @@ fn follow_desktop(raw: &mut egui::RawInput, desktop: Option<egui::Theme>) {
 }
 
 impl eframe::App for App {
-    /// eframe logic callback: syncs the OS animation setting and runs `CadApp::logic`; when the pass index is 0 (the first pass or a hidden tick) it also installs/polls the macOS native menu, polls the spacemouse and persists the workspace; a quit request closes the viewport.
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        self.cad.system_animations = self.system_animations.current();
-        // Consume control/open/screenshot queues and time-based autosave, including hidden ticks.
-        self.cad.logic(ctx);
-        // Host frame work runs here, once per frame, and so also on a hidden logic-only tick (which
-        // never reaches `App::ui`): native menus stay current, the spacemouse still navigates and a
-        // workspace changed while hidden is persisted. `current_pass_index()` is zero on the first
-        // pass and on every hidden tick, and non-zero on later passes of a multi-pass frame.
-        if ctx.current_pass_index() == 0 {
-            #[cfg(target_os = "macos")]
-            {
-                if self.native_menu.is_none() && std::env::var_os("CADCRAFT_NO_NATIVE_MENU").is_none() {
-                    self.native_menu = Some(native_menu::NativeMenu::install(&mut self.cad, ctx));
-                }
-                if let Some(m) = &mut self.native_menu {
-                    m.poll(&mut self.cad, ctx);
-                }
+        #[cfg(target_os = "macos")]
+        {
+            if self.native_menu.is_none() && std::env::var_os("CADCRAFT_NO_NATIVE_MENU").is_none() {
+                self.native_menu = Some(native_menu::NativeMenu::install(&mut self.cad));
+            }
+            if let Some(m) = &mut self.native_menu {
+                m.poll(&mut self.cad, ctx);
             }
-            self.spacemouse.poll(&mut self.cad, ctx);
-            // After `cad.logic`, so a control command's workspace change is saved in the same frame.
-            self.persist_workspace(false);
         }
+        self.cad.system_animations = self.system_animations.current();
+        self.cad.logic(ctx);
+        self.spacemouse.poll(&mut self.cad, ctx);
+        self.persist_workspace(false);
         if std::mem::take(&mut self.cad.quit_requested) {
             ctx.send_viewport_cmd(egui::ViewportCommand::Close);
         }
     }
-    /// Apply the desktop-theme fallback, forward raw input to `CadApp`, and capture Tab at the command line.
     fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
         follow_desktop(raw, self.desktop_theme.current());
-        self.cad.raw_input_hook(ctx, raw);
+        self.cad.raw_input_hook(raw);
         cadcraft_ui_egui::cmdline::capture_tab(ctx, raw);
     }
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
         self.cad.ui(ui);
+        self.persist_workspace(false);
     }
     /// A normal exit: the workspace is saved, and this run's autosave files are not needed (a
     /// crash leaves them for recovery).
     fn on_exit(&mut self) {
         self.persist_workspace(true);
-        self.cad.cancel_screenshots();
         self.cad.shutdown_autosave();
     }
     /// Preferences (the interface theme) survive restarts; window and egui state are not kept.
@@ -153,13 +143,6 @@ fn services() -> Services {
                 .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,
     }
 }
 
@@ -242,19 +225,9 @@ fn control_flag(current: Option<u16>, value: Option<String>) -> Option<u16> {
     current
 }
 
-/// Parse CLI options (`--control`, `--sample`, files, `--version`), install logging and I/O hooks, build the services and app, and run eframe.
 fn main() -> eframe::Result {
     // First, so every start-up record is captured; see `logging`.
     let logger = logging::install();
-    // The update helper relaunches this binary after a self-update; it runs and exits here.
-    #[cfg(not(target_arch = "wasm32"))]
-    if let Some(done) = craft_update::self_update::finish(&craft_update::suite::CADCRAFT, &std::env::args_os().skip(1).collect::<Vec<_>>()) {
-        if let Err(e) = done {
-            eprintln!("CADCraft update helper failed: {e}");
-            std::process::exit(1);
-        }
-        return Ok(());
-    }
     // lossy, so a value that is not Unicode is reported like any other bad port instead of ignored
     let mut control_port =
         control_port_from("CADCRAFT_CONTROL_PORT", std::env::var_os("CADCRAFT_CONTROL_PORT").map(|p| p.to_string_lossy().into_owned()));
@@ -300,9 +273,6 @@ fn main() -> eframe::Result {
             .with_title_shown(false)
             .with_app_id(APP_ID),
         persist_window: false,
-        // CADCraft installs its own capped font chain (`theme::install_fonts`); never run
-        // system-font discovery as a hidden fallback.
-        system_font_fallback: false,
         // A stencil buffer clips the contents of clipped layout viewports on the GPU.
         stencil_buffer: STENCIL_BITS,
         ..Default::default()
@@ -361,7 +331,6 @@ fn main() -> eframe::Result {
             // Autosave files (SAVEFILEPATH) default to `<settings dir>/autosave`.
             if let Some(dir) = config_dir() {
                 app.enable_autosave(&dir.join("autosave"));
-                app.enable_update_check();
                 // Startup LISP (acad.lsp, acaddoc.lsp) is read from `<settings>/support`; the
                 // folder is made so it is there to put them in.
                 let support = dir.join("support");
@@ -388,9 +357,7 @@ fn main() -> eframe::Result {
                 app.open_path(f);
             }
             if app.session.docs.is_empty() {
-                // In the units the profile asks for (MEASUREINIT, restored above).
-                let metric = app.session.settings.measureinit;
-                app.session.new_drawing(metric);
+                app.session.new_drawing(false);
             }
             let ctx = cc.egui_ctx.clone();
             let desktop_theme = desktop_theme::DesktopTheme::start(move || ctx.request_repaint());

apps/cadcraft/src/native_menu.rs

@@ -3,7 +3,6 @@
 
 use std::collections::HashMap;
 use std::str::FromStr;
-use std::sync::mpsc;
 
 use cadcraft_ui_egui::menus::{self, Entry};
 use cadcraft_ui_egui::{CadApp, i18n};
@@ -16,14 +15,10 @@ pub struct NativeMenu {
     submenus: Vec<(String, Submenu)>,
     predefined: Vec<(&'static str, PredefinedMenuItem)>,
     language: &'static str,
-    /// Monotonic time of the last enablement refresh. `NEG_INFINITY` makes the first poll refresh
-    /// immediately: `now_ms` starts near zero, so the old `0.0` sentinel suppressed the first
-    /// ~300 ms of menu enablement.
     last_refresh: f64,
     /// The recent files File ▸ Open Recent lists now (it is rebuilt when they change).
     recent: Vec<String>,
     counter: usize,
-    events: mpsc::Receiver<MenuEvent>,
 }
 
 /// Accelerator for "Cmd+Shift+S" (modifier-less shortcuts stay in the app so typing works).
@@ -35,16 +30,7 @@ fn accel(sc: &str) -> Option<Accelerator> {
 }
 
 impl NativeMenu {
-    /// Build and register the macOS menu (app menu, Settings and the translated command tree); returns the state holding item ids and submenus.
-    pub fn install(app: &mut CadApp, ctx: &egui::Context) -> Self {
-        // A menu choice (or its shortcut, such as Cmd+W) is no window event, so winit would not
-        // wake the app for it: the handler does, and the choice runs in the next frame.
-        let (sender, events) = mpsc::channel();
-        let wake = ctx.clone();
-        MenuEvent::set_event_handler(Some(move |event| {
-            let _ = sender.send(event);
-            wake.request_repaint();
-        }));
+    pub fn install(app: &mut CadApp) -> Self {
         let menu = Menu::new();
         let mut items = HashMap::new();
         let language = app.language();
@@ -80,17 +66,7 @@ impl NativeMenu {
             submenus.push((title, sub));
         }
         menu.init_for_nsapp();
-        Self {
-            _menu: menu,
-            items,
-            submenus,
-            predefined,
-            language,
-            last_refresh: f64::NEG_INFINITY,
-            recent: app.ui.recent_files.clone(),
-            counter,
-            events,
-        }
+        Self { _menu: menu, items, submenus, predefined, language, last_refresh: 0.0, recent: app.ui.recent_files.clone(), counter }
     }
 
     /// Rebuild File ▸ Open Recent after a drawing was opened or the list was cleared: the native
@@ -111,9 +87,8 @@ impl NativeMenu {
         build(&sub, &menus::recent_entries(app), &mut self.items, &mut self.submenus, &mut self.counter, self.language);
     }
 
-    /// Drain queued menu events into commands (Discord opens externally), rebuild Open Recent, retranslate on a language change and refresh enablement when 300 ms have elapsed.
     pub fn poll(&mut self, app: &mut CadApp, ctx: &egui::Context) {
-        while let Ok(ev) = self.events.try_recv() {
+        while let Ok(ev) = MenuEvent::receiver().try_recv() {
             if let Some((cmd, _, _)) = self.items.get(ev.id.as_ref()) {
                 if cmd == "ui.discord" {
                     ctx.open_url(egui::OpenUrl::new_tab("https://discord.gg/artcraft"));
@@ -138,7 +113,7 @@ impl NativeMenu {
             }
         }
         let now = cadcraft_ui_egui::now_ms();
-        if !refresh_due(now, self.last_refresh) {
+        if now - self.last_refresh < 300.0 {
             return;
         }
         self.last_refresh = now;
@@ -149,13 +124,6 @@ impl NativeMenu {
     }
 }
 
-/// The periodic enablement refresh is due every 300 ms. Split out so the first-poll sentinel is
-/// testable without a macOS menu: `now_ms` starts near zero, so a `0.0` initial value would
-/// suppress the first refresh for 300 ms.
-fn refresh_due(now: f64, last_refresh: f64) -> bool {
-    now - last_refresh >= 300.0
-}
-
 fn build(
     parent: &Submenu,
     entries: &[Entry],
@@ -182,17 +150,3 @@ fn build(
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::refresh_due;
-
-    /// `refresh_due` treats `NEG_INFINITY` as due at any finite time and `0.0` as due once 300 ms have elapsed; `install` initializes a fresh menu with `last_refresh = NEG_INFINITY`.
-    #[test]
-    fn the_first_poll_refreshes_immediately() {
-        assert!(refresh_due(0.5, f64::NEG_INFINITY), "a fresh menu refreshes on its first poll");
-        assert!(!refresh_due(0.5, 0.0), "the old 0.0 sentinel delayed the first refresh");
-        assert!(!refresh_due(299.9, 0.0));
-        assert!(refresh_due(300.0, 0.0));
-    }
-}

apps/cadcraft/src/spacemouse/motion.rs

@@ -107,23 +107,6 @@ impl Filter {
         *self = Self::default();
     }
 
-    fn update_drift(&mut self, complete: bool, now: Instant, bias: &mut [f64; 6]) {
-        if !complete {
-            return;
-        }
-        if self.raw.iter().zip(*bias).all(|(raw, b)| (*raw - b).abs() <= FULL_SCALE * DEADZONE) {
-            let since = *self.idle_since.get_or_insert(now);
-            if now.saturating_duration_since(since) >= Duration::from_secs(2) {
-                for (b, raw) in bias.iter_mut().zip(self.raw) {
-                    *b += (raw - *b) * 0.01;
-                }
-                self.bias = Some(*bias);
-            }
-        } else {
-            self.idle_since = None;
-        }
-    }
-
     pub fn update(&mut self, values: [i16; 6], mask: u8, now: Instant) -> Motion {
         for (index, seen) in self.seen.iter_mut().enumerate() {
             if mask & (1 << index) != 0 {
@@ -145,7 +128,19 @@ impl Filter {
         }
         let Some(mut bias) = self.bias else { return Motion::default() };
         // Follow small resting drift only after two seconds entirely inside the deadzone.
-        self.update_drift(complete, now, &mut bias);
+        if complete {
+            if self.raw.iter().zip(bias).all(|(raw, bias)| (*raw - bias).abs() <= FULL_SCALE * DEADZONE) {
+                let since = *self.idle_since.get_or_insert(now);
+                if now.saturating_duration_since(since) >= Duration::from_secs(2) {
+                    for (bias, raw) in bias.iter_mut().zip(self.raw) {
+                        *bias += (raw - *bias) * 0.01;
+                    }
+                    self.bias = Some(bias);
+                }
+            } else {
+                self.idle_since = None;
+            }
+        }
         let mut axes = [0.0; 6];
         for ((axis, raw), bias) in axes.iter_mut().zip(self.raw).zip(bias) {
             let value = ((raw - bias) / FULL_SCALE).clamp(-1.0, 1.0);
@@ -161,77 +156,3 @@ impl Filter {
         Motion { pan: [tx, ty], zoom: (tz + rz).clamp(-1.0, 1.0) }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn decode_reports() {
-        assert_eq!(decode(&[]), None);
-        assert_eq!(decode(&[3]), None);
-        assert_eq!(decode(&[3, 5]), Some(Report::Buttons(5)));
-        let values = [1_i16, -2, 3, 4, -5, 6];
-        let mut bytes = vec![1_u8];
-        for v in values {
-            bytes.extend_from_slice(&v.to_le_bytes());
-        }
-        assert_eq!(decode(&bytes), Some(Report::Axes { values, mask: 3 }));
-        bytes[0] = 2;
-        assert_eq!(decode(&bytes), Some(Report::Axes { values: [0, 0, 0, 1, -2, 3], mask: 2 }));
-        assert_eq!(decode(&[2, 1, 2, 3]), None, "too short for a rotation report");
-    }
-
-    /// Sixteen complete reports at rest, spread over more than CALIBRATION_TIME, all stamped
-    /// on a made-up point in time big enough that they sit in the past of later updates.
-    fn calibrated(t0: Instant) -> Filter {
-        let mut f = Filter::default();
-        for i in 0..17 {
-            let at = t0 + Duration::from_millis(50 * i);
-            assert_eq!(f.update([0; 6], 1, at), Motion::default());
-            assert_eq!(f.update([0; 6], 2, at), Motion::default());
-        }
-        assert!(f.calibrated());
-        f
-    }
-
-    #[test]
-    fn axes_deflect_and_expire() {
-        let t0 = Instant::now();
-        let mut f = calibrated(t0);
-        let at = t0 + Duration::from_secs(2);
-        let ms = Duration::from_millis;
-        let m = f.update([500, 500, 0, 0, 0, 0], 1, at);
-        assert!((m.pan[0] - 1.0).abs() < 1e-9);
-        assert!((m.pan[1] - 1.0).abs() < 1e-9);
-        assert_eq!(m.zoom, 0.0, "no rotation input");
-        // A fresh rotation report drives the zoom.
-        let m = f.update([0, 0, 0, 0, 0, 500], 2, at + ms(100));
-        assert!((m.zoom - 1.0).abs() < 1e-9);
-        // The rotation axes went quiet for over 250 ms while translations still arrive.
-        let m = f.update([500, 500, 0, 0, 0, 0], 1, at + ms(400));
-        assert_eq!(m.zoom, 0.0);
-        // A fresh rotation report puts the zoom back.
-        let m = f.update([500, 500, 0, 0, 0, 500], 2, at + ms(500));
-        assert!((m.zoom - 1.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn drift_tracks_rest_after_two_idle_seconds() {
-        // Five axes units of drift sit inside the deadzone (FULL_SCALE * DEADZONE = 20).
-        let mut f = Filter { raw: [5.0; 6], bias: Some([0.0; 6]), ..Filter::default() };
-        let t0 = Instant::now();
-        let mut b = [0.0; 6];
-        f.update_drift(true, t0, &mut b); // starts the idle window: no shift yet
-        assert_eq!(b, [0.0; 6]);
-        f.update_drift(true, t0 + Duration::from_secs(3), &mut b);
-        assert!((b[0] - 0.05).abs() < 1e-12, "bias follows resting drift");
-        assert_eq!(f.bias, Some(b));
-        // Motion outside the deadzone resets the idle window.
-        f.raw = [100.0; 6];
-        f.update_drift(true, t0 + Duration::from_secs(4), &mut b);
-        assert_eq!(f.idle_since, None);
-        f.update_drift(true, t0 + Duration::from_secs(5), &mut b);
-        assert!((b[0] - 0.05).abs() < 1e-12, "no shift before two seconds at rest");
-    }
-}

apps/cadcraft/src/workspace.rs

@@ -32,7 +32,7 @@ fn config_dir_from(platform: &str, get: impl Fn(&str) -> Option<OsString>) -> Op
 }
 
 fn snapshot(ui: &UiState) -> Result<Value, String> {
-    cadcraft_ui_egui::docking::validate(&ui.docking)?;
+    ui.docking.validate()?;
     if !matches!(ui.toolset_tab.as_str(), "Drafting" | "Modeling") {
         return Err("toolsetTab must be Drafting or Modeling".into());
     }
@@ -85,7 +85,7 @@ fn read(path: &Path) -> Result<Option<UiState>, String> {
     let mut ui: UiState = serde_json::from_value(fields).map_err(|error| format!("{}: invalid workspace: {error}", path.display()))?;
     if let Some(docking) = docking
         && let Ok(docking) = serde_json::from_value::<cadcraft_ui_egui::docking::Workspace>(docking)
-        && cadcraft_ui_egui::docking::validate(&docking).is_ok()
+        && docking.validate().is_ok()
     {
         ui.docking = docking;
     }
@@ -236,7 +236,7 @@ mod tests {
 
     #[test]
     fn docked_floating_and_hidden_panels_survive_native_workspace_file_reload() {
-        use cadcraft_ui_egui::docking::{Panel, permissions};
+        use cadcraft_ui_egui::docking::Panel;
         let directory = temp_dir();
         let path = directory.join("workspace.json");
         let (mut store, _, _) = Workspace::at(Some(path.clone()));
@@ -244,58 +244,19 @@ mod tests {
         let mut app = cadcraft_ui_egui::CadApp::new(cadcraft_engine::Session::default(), Default::default());
         app.run("ui.dock", json!({"operation":"float", "panel":"layers", "rect":[120,90,340,410]})).unwrap();
         ui.docking = app.ui.docking;
-        ui.docking.set_visible(Panel::ToolSets, false, None, permissions).unwrap();
+        ui.docking.set_visible(Panel::ToolSets, false).unwrap();
         ui.show_toolsets = false;
         store.save_if_changed(&ui).unwrap();
         let (_, reloaded, error) = Workspace::at(Some(path));
         assert!(error.is_none());
         let mut reloaded = reloaded.unwrap();
         assert_eq!(serde_json::to_value(&reloaded.docking).unwrap(), serde_json::to_value(&ui.docking).unwrap());
-        reloaded.docking.set_visible(Panel::ToolSets, true, None, permissions).unwrap();
+        reloaded.docking.set_visible(Panel::ToolSets, true).unwrap();
         assert!(reloaded.docking.layout.contains(&Panel::ToolSets));
         assert_eq!(reloaded.docking.layout.floating[0].rect, [120.0, 90.0, 340.0, 410.0]);
         fs::remove_dir_all(directory).unwrap();
     }
 
-    #[test]
-    fn version_one_docking_file_still_loads() {
-        use cadcraft_ui_egui::docking::{Panel, reveal_panel};
-        // Written as CADCraft 0.7 writes it: craft-ui's v1 layout with no docking version, a
-        // floating window as one `{panels, active, rect}` group, Tool Sets closed.
-        let file = r#"{"version":1,"workspace":{
-            "docking":{
-                "layout":{
-                    "root":{"Split":{"axis":"Horizontal","size":{"FixedSecond":300.0},
-                        "first":{"Tabs":{"panels":["canvas"],"active":0}},
-                        "second":{"Stack":{"entries":[{"panel":"properties","open":false,"height":null}]}}}},
-                    "floating":[{"panels":["layers","externalReferences"],"active":1,"rect":[120.0,90.0,340.0,410.0]}]},
-                "hidden":[["toolSets",{"floating":null,"anchor":"canvas","placement":{"Split":"Left"},
-                    "size":{"FixedFirst":220.0},"stack":null,"sibling":["canvas","properties"]}]]},
-            "showToolsets":false,"showPalettes":true,"toolsetTab":"Modeling","historyLines":4}}"#;
-        let directory = temp_dir();
-        let path = directory.join("workspace.json");
-        fs::write(&path, file).unwrap();
-        let (_, restored, error) = Workspace::at(Some(path));
-        assert!(error.is_none(), "{error:?}");
-        let mut ui = restored.unwrap();
-        assert_eq!(ui.toolset_tab, "Modeling");
-        let docking = &ui.docking;
-        assert_eq!(docking.layout.floating.len(), 1);
-        let window = &docking.layout.floating[0];
-        assert_eq!(window.rect, [120.0, 90.0, 340.0, 410.0]);
-        assert_eq!(serde_json::to_value(&window.root).unwrap(), json!({"Tabs":{"panels":["layers","externalReferences"],"active":1}}));
-        assert_eq!(
-            serde_json::to_value(&docking.layout.root).unwrap()["Split"]["second"],
-            json!({"Stack":{"entries":[{"panel":"properties","open":false,"height":null}]}})
-        );
-        assert!(!docking.layout.contains(&Panel::ToolSets));
-        reveal_panel(&mut ui.docking, Panel::ToolSets).unwrap();
-        let tools = ui.docking.layout.location(&Panel::ToolSets).unwrap();
-        assert_eq!(tools.anchor, Some(Panel::Canvas));
-        assert_eq!(serde_json::to_value((&tools.placement, &tools.size)).unwrap(), json!([{"Split":"Left"}, {"FixedFirst":220.0}]));
-        fs::remove_dir_all(directory).unwrap();
-    }
-
     #[test]
     fn malformed_oversized_and_newer_state_are_reported_and_preserved() {
         let directory = temp_dir();

contributors/people.toml

@@ -73,21 +73,3 @@ sync_github_name = false
 
 [people.gurparvez]
 real_name = "Gurparvez"
-
-[people.nicholasgower]
-sync_github_name = true
-
-[people.ffishman]
-real_name = "Rodrigo Gressler"
-display_name = "Rodrigo"
-sync_github_name = false
-
-[people.aussieboer61]
-real_name = "Richard Sauer"
-display_name = "Richard Sauer"
-sync_github_name = false
-
-[people.dotCooCoo]
-real_name = "Robert Lee"
-sync_github_name = true
-

crates/color/src/lib.rs

@@ -21,8 +21,7 @@ impl Rgb {
         format!("#{:02x}{:02x}{:02x}", self.0, self.1, self.2)
     }
     pub fn parse_hex(s: &str) -> Option<Rgb> {
-        let s = s.trim();
-        let s = s.strip_prefix('#').unwrap_or(s);
+        let s = s.trim().trim_start_matches('#');
         if s.len() != 6 || !s.chars().all(|c| c.is_ascii_hexdigit()) {
             return None;
         }
@@ -111,9 +110,9 @@ impl Color {
             _ => {}
         }
         if let Some(rest) = t.strip_prefix("color ") {
-            return parse_digits::<u8>(rest.trim()).filter(|i| *i >= 1).map(Color::Index);
+            return rest.trim().parse::<u8>().ok().filter(|i| *i >= 1).map(Color::Index);
         }
-        if let Some(i) = parse_digits::<u16>(&t) {
+        if let Ok(i) = t.parse::<u16>() {
             return match i {
                 0 => Some(Color::ByBlock),
                 256 => Some(Color::ByLayer),
@@ -124,22 +123,14 @@ impl Color {
         if t.starts_with('#') {
             return Rgb::parse_hex(&t).map(Color::True);
         }
-        let parts: Vec<_> = t.split(',').map(|p| parse_digits::<u8>(p.trim())).collect();
-        if let [Some(r), Some(g), Some(b)] = parts.as_slice() {
+        let parts: Vec<_> = t.split(',').map(|p| p.trim().parse::<u8>()).collect();
+        if let [Ok(r), Ok(g), Ok(b)] = parts.as_slice() {
             return Some(Color::True(Rgb(*r, *g, *b)));
         }
         None
     }
 }
 
-/// Parse an unsigned integer made of ASCII digits only (no sign, unlike `str::parse`).
-fn parse_digits<T: std::str::FromStr>(s: &str) -> Option<T> {
-    if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
-        return None;
-    }
-    s.parse().ok()
-}
-
 /// The RGB of ACI `i` (0 and out-of-range map to white/7).
 pub fn aci_rgb(i: u8) -> Rgb {
     PALETTE.get(usize::from(i)).copied().unwrap_or(Rgb(255, 255, 255))
@@ -165,7 +156,7 @@ fn build_palette() -> [Rgb; 256] {
     for (slot, c) in p.iter_mut().zip(base) {
         *slot = c;
     }
-    let values = [255.0, 204.0, 153.0, 127.0, 76.0];
+    let values = [255.0, 165.0, 127.0, 76.0, 38.0];
     for i in 10..250usize {
         let hue = (i - 10) / 10; // 0..24, 15° each
         let sub = i % 10;
@@ -242,39 +233,13 @@ mod tests {
         assert_eq!(Rgb::parse_hex("#012345"), Some(Rgb(1, 35, 69)));
     }
 
-    #[test]
-    fn parse_rejects_plus_sign() {
-        assert_eq!(Color::parse("+5"), None);
-        assert_eq!(Color::parse(" +256"), None);
-        assert_eq!(Color::parse("color +5"), None);
-        assert_eq!(Color::parse("+1,+2,+3"), None);
-        assert_eq!(Color::parse("1,+2,3"), None);
-        assert_eq!(Color::parse("5"), Some(Color::Index(5)));
-        assert_eq!(Color::parse("256"), Some(Color::ByLayer));
-        assert_eq!(Color::parse("color 5"), Some(Color::Index(5)));
-        assert_eq!(Color::parse("1, 2, 3"), Some(Color::True(Rgb(1, 2, 3))));
-    }
-
-    #[test]
-    fn parse_hex_rejects_repeated_hash() {
-        assert_eq!(Rgb::parse_hex("##ff0000"), None);
-        assert_eq!(Rgb::parse_hex("###ff0000"), None);
-        assert_eq!(Color::parse("##ff0000"), None);
-        assert_eq!(Rgb::parse_hex("#ff0000"), Some(Rgb(255, 0, 0)));
-        assert_eq!(Rgb::parse_hex("ff0000"), Some(Rgb(255, 0, 0)));
-    }
-
     #[test]
     fn palette_known_entries() {
         assert_eq!(aci_rgb(1), Rgb(255, 0, 0));
         assert_eq!(aci_rgb(10), Rgb(255, 0, 0));
         assert_eq!(aci_rgb(11), Rgb(255, 127, 127));
-        assert_eq!(aci_rgb(12), Rgb(204, 0, 0));
-        assert_eq!(aci_rgb(13), Rgb(204, 102, 102));
-        assert_eq!(aci_rgb(14), Rgb(153, 0, 0));
-        assert_eq!(aci_rgb(15), Rgb(153, 76, 76));
-        assert_eq!(aci_rgb(16), Rgb(127, 0, 0));
-        assert_eq!(aci_rgb(18), Rgb(76, 0, 0));
+        assert_eq!(aci_rgb(12), Rgb(165, 0, 0));
+        assert_eq!(aci_rgb(13), Rgb(165, 82, 82));
         assert_eq!(aci_rgb(20), Rgb(255, 63, 0));
         assert_eq!(aci_rgb(30), Rgb(255, 127, 0));
         assert_eq!(aci_rgb(50), Rgb(255, 255, 0));

crates/constraints/src/dof.rs

@@ -235,7 +235,7 @@ mod budget_tests {
             aux_init: Vec::new(),
             aux: 0,
         };
-        let comp = Comp { model, built: vec![endpoint], weights: vec![1.0; 2], held: Vec::new(), tol: 1e-9 };
+        let comp = Comp { model, built: vec![endpoint], weights: vec![1.0; 2], tol: 1e-9 };
         assert!(analyse(&comp).dof.is_none());
     }
 }

crates/constraints/src/expr.rs

@@ -5,7 +5,7 @@ use std::collections::BTreeMap;
 
 /// Longest expression accepted (characters).
 pub const MAX_LEN: usize = 1024;
-/// Deepest syntax tree and combined expression/parameter evaluation path.
+/// Deepest nesting (parentheses, unary minus) and parameter reference chain.
 pub const MAX_DEPTH: usize = 64;
 
 #[derive(Clone, Debug, PartialEq, thiserror::Error)]
@@ -49,7 +49,7 @@ struct Parser<'a> {
 
 impl Parser<'_> {
     fn ws(&mut self) {
-        while self.s.get(self.i).is_some_and(u8::is_ascii_whitespace) {
+        while self.s.get(self.i).is_some_and(|c| c.is_ascii_whitespace()) {
             self.i += 1;
         }
     }
@@ -165,20 +165,6 @@ pub fn parse(text: &str) -> Result<Expr, ExprError> {
     if p.peek().is_some() {
         return Err(ExprError::Syntax(format!("unexpected `{}`", text.get(p.i..).unwrap_or("").trim())));
     }
-    let mut pending = vec![(&e, 1)];
-    while let Some((node, depth)) = pending.pop() {
-        if depth > MAX_DEPTH {
-            return Err(ExprError::TooDeep);
-        }
-        match node {
-            Expr::Neg(a) => pending.push((a, depth + 1)),
-            Expr::Bin(_, a, b) => {
-                pending.push((a, depth + 1));
-                pending.push((b, depth + 1));
-            }
-            _ => {}
-        }
-    }
     Ok(e)
 }
 
@@ -238,19 +224,12 @@ pub fn rename(text: &str, old: &str, new: &str) -> String {
 
 /// Evaluate with a variable lookup.
 pub fn eval_with(e: &Expr, lookup: &mut dyn FnMut(&str) -> Result<f64, ExprError>) -> Result<f64, ExprError> {
-    eval_at_depth(e, &mut |n, _| lookup(n), 0)
-}
-
-fn eval_at_depth(e: &Expr, lookup: &mut dyn FnMut(&str, usize) -> Result<f64, ExprError>, depth: usize) -> Result<f64, ExprError> {
-    if depth >= MAX_DEPTH {
-        return Err(ExprError::TooDeep);
-    }
     let v = match e {
         Expr::Num(v) => *v,
-        Expr::Var(n) => lookup(n, depth + 1)?,
-        Expr::Neg(a) => -eval_at_depth(a, lookup, depth + 1)?,
+        Expr::Var(n) => lookup(n)?,
+        Expr::Neg(a) => -eval_with(a, lookup)?,
         Expr::Bin(op, a, b) => {
-            let (x, y) = (eval_at_depth(a, lookup, depth + 1)?, eval_at_depth(b, lookup, depth + 1)?);
+            let (x, y) = (eval_with(a, lookup)?, eval_with(b, lookup)?);
             match op {
                 '+' => x + y,
                 '-' => x - y,
@@ -294,12 +273,9 @@ impl Env {
     /// Value of a named parameter.
     pub fn value(&mut self, name: &str) -> Result<f64, ExprError> {
         let mut stack = Vec::new();
-        self.value_inner(name, &mut stack, 0)
+        self.value_inner(name, &mut stack)
     }
-    fn value_inner(&mut self, name: &str, stack: &mut Vec<String>, depth: usize) -> Result<f64, ExprError> {
-        if depth >= MAX_DEPTH {
-            return Err(ExprError::TooDeep);
-        }
+    fn value_inner(&mut self, name: &str, stack: &mut Vec<String>) -> Result<f64, ExprError> {
         if let Some(v) = self.cache.get(name) {
             return Ok(*v);
         }
@@ -312,7 +288,7 @@ impl Env {
         let text = self.exprs.get(name).cloned().ok_or_else(|| ExprError::Unknown(name.to_string()))?;
         let e = parse(&text)?;
         stack.push(name.to_string());
-        let r = eval_at_depth(&e, &mut |n, depth| self.value_inner(n, stack, depth), depth);
+        let r = eval_with(&e, &mut |n| self.value_inner(n, stack));
         stack.pop();
         let v = r?;
         self.cache.insert(name.to_string(), v);
@@ -322,7 +298,7 @@ impl Env {
     pub fn eval(&mut self, text: &str) -> Result<f64, ExprError> {
         let e = parse(text)?;
         let mut stack = Vec::new();
-        eval_at_depth(&e, &mut |n, depth| self.value_inner(n, &mut stack, depth), 0)
+        eval_with(&e, &mut |n| self.value_inner(n, &mut stack))
     }
 }
 
@@ -375,31 +351,6 @@ mod tests {
         assert!(chain.value("p0").is_err());
     }
 
-    #[test]
-    fn expression_and_parameter_depth_share_a_limit_on_a_small_stack() {
-        std::thread::Builder::new()
-            .stack_size(1024 * 1024)
-            .spawn(|| {
-                for op in ["+", "-", "*", "/"] {
-                    let within = vec!["1"; MAX_DEPTH].join(op);
-                    assert!(eval_const(&within).is_ok());
-                    assert_eq!(parse(&format!("{within}{op}1")), Err(ExprError::TooDeep));
-                }
-                let mut env = Env::new();
-                for i in 0..MAX_DEPTH {
-                    env.insert(&format!("p{i}"), &format!("p{}+{}", i + 1, vec!["0"; 30].join("+")));
-                }
-                env.insert(&format!("p{MAX_DEPTH}"), "1");
-                assert_eq!(env.value("p0"), Err(ExprError::TooDeep));
-                assert_eq!(env.eval("p0+1"), Err(ExprError::TooDeep));
-                env.insert("safe", "2*3");
-                assert_eq!(env.eval("safe+1"), Ok(7.0));
-            })
-            .unwrap()
-            .join()
-            .unwrap();
-    }
-
     #[test]
     fn rename_replaces_whole_names_only() {
         assert_eq!(rename("d1+d10*d1 / (d1_x+2e1)", "d1", "w"), "w+d10*w / (d1_x+2e1)");

crates/constraints/src/lib.rs

@@ -81,12 +81,6 @@ pub struct SolveOptions {
     pub keep: Vec<Handle>,
     /// Entities that should take up the change.
     pub prefer_move: Vec<Handle>,
-    /// Points held where they are for this solve, as a Fix would hold them (the grip an edit
-    /// just put down): see [`edited_points`].
-    pub hold: Vec<GeomRef>,
-    /// Where a Fix on a derived point (by constraint id) holds it, instead of where the point is
-    /// now: see [`moved_anchors`].
-    pub anchors: Vec<(u32, Vec2)>,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize)]
@@ -211,19 +205,12 @@ pub(crate) struct Comp {
     pub(crate) model: Model,
     pub(crate) built: Vec<Built>,
     weights: Vec<f64>,
-    /// Parameters of the points held by [`SolveOptions::hold`].
-    held: Vec<usize>,
     tol: f64,
 }
 
 impl Comp {
     fn locks(&self, skip: Option<usize>) -> Vec<bool> {
         let mut locked = vec![false; self.model.x0.len()];
-        for &j in &self.held {
-            if let Some(l) = locked.get_mut(j) {
-                *l = true;
-            }
-        }
         for (i, b) in self.built.iter().enumerate() {
             if Some(i) == skip || b.form != Form::Lock {
                 continue;
@@ -258,30 +245,7 @@ impl Comp {
             return Err(SolveError::TooLarge);
         }
         let f = |x: &[f64], out: &mut Vec<f64>| self.eval(x, out, skip);
-        let mut o = lm::solve(&f, &self.model.x0, &free, &self.weights, self.tol, MAX_ITER);
-        // A solution the ellipses would be stored differently from (axes swapped, minor axis
-        // mirrored) holds only if the constraints still hold on the stored form: a constraint on
-        // an axis end by index does not.
-        if o.converged && !self.model.storable(&o.x) {
-            let mut out = Vec::new();
-            match self.model.stored_form(&o.x) {
-                Some(mut xc) => {
-                    // Contact parameters are positions along the curves: they follow the stored form.
-                    for b in self.built.iter().filter(|b| b.form == Form::Contact) {
-                        for (k, r) in b.refs.iter().enumerate() {
-                            if let (Some(&t), Some(slot)) = (o.x.get(b.aux + k), xc.get_mut(b.aux + k)) {
-                                *slot = self.model.stored_t(&o.x, r.handle, t);
-                            }
-                        }
-                    }
-                    self.eval(&xc, &mut out, skip);
-                    o.converged = lm::max_abs(&out) <= self.tol;
-                    o.x = xc;
-                }
-                None => o.converged = false,
-            }
-        }
-        Ok(o)
+        Ok(lm::solve(&f, &self.model.x0, &free, &self.weights, self.tol, MAX_ITER))
     }
     /// Constraint ids in conflict (each one whose removal makes the rest solvable).
     fn conflicts(&self, x_failed: &[f64]) -> Vec<u32> {
@@ -382,14 +346,7 @@ pub(crate) fn build_budgeted(
         for c in group {
             let target = if c.kind.is_dimensional() { constraint_value(&mut e, c)? } else { 0.0 };
             match interpret(c, &mut model, target) {
-                Ok(mut b) => {
-                    if let Form::Anchor(_) = b.form
-                        && let Some(&(_, a)) = opts.anchors.iter().find(|(id, _)| *id == c.id)
-                    {
-                        b.form = Form::Anchor(a);
-                    }
-                    built.push(b);
-                }
+                Ok(b) => built.push(b),
                 Err(msg) => skipped.push((c.id, msg)),
             }
         }
@@ -436,9 +393,8 @@ pub(crate) fn build_budgeted(
         for w in weights.iter_mut().skip(geo) {
             *w = 1e-3;
         }
-        let held = opts.hold.iter().filter_map(|r| model.lock_indices(r)).flatten().collect();
         let tol = scale_tol(&model.x0);
-        comps.push(Comp { model, built, weights, held, tol });
+        comps.push(Comp { model, built, weights, tol });
     }
     Ok((comps, skipped))
 }
@@ -489,9 +445,6 @@ pub fn residuals(d: &Drawing) -> Vec<(u32, Option<f64>)> {
 /// A Fix keeps no position of its own: the solver locks the parameters at their current values.
 /// Without this, an edit that moves a fixed point (a grip drag) would carry the lock along with
 /// it. Only Fixes that already existed in `before`, on objects of the same shape, are restored.
-/// An object held by a Fix on a derived point (a line's midpoint, an arc's end) has nothing to
-/// lock: when the edit only moved it (MOVE), it is put back whole, so it is not reshaped to bring
-/// the point back.
 pub fn restore_fixed(d: &mut Drawing, before: &Drawing) -> bool {
     let refs: Vec<GeomRef> = d
         .constraints
@@ -508,21 +461,10 @@ pub fn restore_fixed(d: &mut Drawing, before: &Drawing) -> bool {
     let mut changed = false;
     for r in &refs {
         let same_shape = matches!((now.slot(r.handle), old.slot(r.handle)), (Some(a), Some(b)) if a.shape == b.shape);
+        let (Some(i), Some(j)) = (now.lock_indices(r), old.lock_indices(r)) else { continue };
         if !same_shape {
             continue;
         }
-        let (Some(i), Some(j)) = (now.lock_indices(r), old.lock_indices(r)) else {
-            if let (Some(a), Some(b)) = (now.slot(r.handle), old.slot(r.handle))
-                && translated(&now, &old, r.handle)
-                && let (Some(dst), Some(src)) = (x.get_mut(a.off..a.off + a.len), old.x0.get(b.off..b.off + b.len))
-            {
-                for (v, &w) in dst.iter_mut().zip(src) {
-                    *v = w;
-                }
-                changed = true;
-            }
-            continue;
-        };
         for (i, j) in i.into_iter().zip(j) {
             if let (Some(slot), Some(&v)) = (x.get_mut(i), old.x0.get(j))
                 && *slot != v
@@ -538,88 +480,6 @@ pub fn restore_fixed(d: &mut Drawing, before: &Drawing) -> bool {
     changed
 }
 
-/// The parameters of `h`'s points (see [`Model::point_refs`]) in `m`, as (x, y) pairs.
-fn point_params(m: &Model, h: Handle) -> Vec<(usize, usize)> {
-    m.point_refs(h)
-        .iter()
-        .filter_map(|r| m.lock_indices(r))
-        .flat_map(|ix| ix.as_chunks::<2>().0.iter().map(|&[x, y]| (x, y)).collect::<Vec<_>>())
-        .collect()
-}
-
-/// Is `h` in `now` its shape in `old` moved by one vector, and nothing else?
-fn translated(now: &Model, old: &Model, h: Handle) -> bool {
-    let (Some(a), Some(b)) = (now.slot(h), old.slot(h)) else { return false };
-    let (Some(xa), Some(xb)) = (now.x0.get(a.off..a.off + a.len), old.x0.get(b.off..b.off + b.len)) else { return false };
-    let tol = scale_tol(xb) * 10.0;
-    let pts: Vec<(usize, usize)> =
-        point_params(old, h).into_iter().filter_map(|(i, j)| Some((i.checked_sub(b.off)?, j.checked_sub(b.off)?))).collect();
-    let delta = |(i, j): (usize, usize)| Some(Vec2::new(xa.get(i)? - xb.get(i)?, xa.get(j)? - xb.get(j)?));
-    let Some(v) = pts.first().and_then(|&p| delta(p)) else { return false };
-    if v.len() <= tol || !pts.iter().all(|&p| delta(p).is_some_and(|d| d.near(v, tol))) {
-        return false;
-    }
-    (0..xb.len())
-        .filter(|k| !pts.iter().any(|&(i, j)| *k == i || *k == j))
-        .all(|k| matches!((xa.get(k), xb.get(k)), (Some(p), Some(q)) if (p - q).abs() <= tol))
-}
-
-/// The points of `h` (its ends, centre or vertices) the edit from `before` to `d` moved, when it
-/// moved some of them but not all: the grip that was dragged, to pass as [`SolveOptions::hold`] so
-/// it stays where it was put and the rest of the object takes up the constraints. Empty when the
-/// object kept its points or moved them all.
-pub fn edited_points(d: &Drawing, before: &Drawing, h: Handle) -> Vec<GeomRef> {
-    let (now, old) = (Model::build(d, &[h]), Model::build(before, &[h]));
-    if !matches!((now.slot(h), old.slot(h)), (Some(a), Some(b)) if a.shape == b.shape) {
-        return Vec::new();
-    }
-    let tol = scale_tol(&old.x0) * 10.0;
-    let refs = now.point_refs(h);
-    let moved: Vec<GeomRef> = refs
-        .iter()
-        .filter(|r| matches!((now.lock_indices(r), old.lock_indices(r)), (Some(i), Some(j)) if i.iter().zip(&j).any(|(&i, &j)| matches!((now.x0.get(i), old.x0.get(j)), (Some(p), Some(q)) if (p - q).abs() > tol))))
-        .copied()
-        .collect();
-    if moved.len() == refs.len() { Vec::new() } else { moved }
-}
-
-/// Where `before` had each derived point held by a Fix (a line's midpoint, an arc's end), for the
-/// Fixes whose point has moved since, to pass as [`SolveOptions::anchors`].
-///
-/// A Fix on a derived point anchors it where it is when the system is built, and
-/// [`restore_fixed`] has no parameters to put back: without this, an edit that moves the point
-/// would leave the Fix satisfied at the new place.
-pub fn moved_anchors(d: &Drawing, before: &Drawing) -> Vec<(u32, Vec2)> {
-    let fixes: Vec<(u32, GeomRef)> = d
-        .constraints
-        .iter()
-        .filter(|c| c.kind == ConstraintKind::Fix && before.constraints.contains(c))
-        .filter_map(|c| match c.refs.as_slice() {
-            [r] => Some((c.id, *r)),
-            _ => None,
-        })
-        .collect();
-    if fixes.is_empty() {
-        return Vec::new();
-    }
-    let handles: Vec<Handle> = fixes.iter().map(|(_, r)| r.handle).collect();
-    let (now, old) = (Model::build(d, &handles), Model::build(before, &handles));
-    let tol = scale_tol(&old.x0);
-    let mut out = Vec::new();
-    for (id, r) in fixes {
-        let same_shape = matches!((now.slot(r.handle), old.slot(r.handle)), (Some(a), Some(b)) if a.shape == b.shape);
-        if !same_shape || now.lock_indices(&r).is_some() {
-            continue;
-        }
-        if let (Some(p), Some(a)) = (now.point(&now.x0, &r), old.point(&old.x0, &r))
-            && !p.near(a, tol)
-        {
-            out.push((id, a));
-        }
-    }
-    out
-}
-
 /// True when every interpretable constraint holds at the current geometry.
 pub fn all_satisfied(d: &Drawing) -> bool {
     let handles: Vec<Handle> = d.constraints.iter().flat_map(|c| c.refs.iter().map(|r| r.handle)).collect();

crates/constraints/src/model.rs

@@ -32,8 +32,6 @@ pub const MAX_RIGID_POINTS: usize = 256;
 const MAX_RIGID_MEMBERS: usize = 100_000;
 /// Shared across every model built for one analysis request.
 pub(crate) const MAX_RIGID_WORK: usize = 1_000_000;
-/// How far past 1 a solved ellipse ratio may land by rounding and still be stored as 1.
-const RATIO_TOL: f64 = 1e-9;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum Shape {
@@ -479,18 +477,6 @@ impl Model {
         }
     }
 
-    /// The points of an object a Fix locks directly (ends, centre, vertices, insertion point).
-    pub fn point_refs(&self, h: Handle) -> Vec<GeomRef> {
-        let Some(s) = self.slot(h) else { return Vec::new() };
-        let at = |sub: Sub| GeomRef { handle: h, sub };
-        match s.shape {
-            Shape::Line => vec![at(Sub::Start), at(Sub::End)],
-            Shape::Point => vec![at(Sub::Whole)],
-            Shape::Circle | Shape::Arc | Shape::Ellipse { .. } | Shape::Insert { .. } => vec![at(Sub::Center)],
-            Shape::Poly { n, .. } | Shape::Spline { n, .. } => (0..n).filter_map(|i| u32::try_from(i).ok()).map(|i| at(Sub::Vertex(i))).collect(),
-        }
-    }
-
     /// Parameters a Fix on this reference locks directly. `None` when the reference is a derived
     /// point (fixed through a residual instead).
     pub fn lock_indices(&self, r: &GeomRef) -> Option<Vec<usize>> {
@@ -518,57 +504,6 @@ impl Model {
         Some(v)
     }
 
-    /// Can `write_back` store `x` as it is? An ellipse keeps 0 < ratio <= 1, its major axis the
-    /// longer one: a solution past that is stored with its axes swapped or its minor axis
-    /// mirrored (see [`Model::stored_form`]), which renumbers the axis ends.
-    pub fn storable(&self, x: &[f64]) -> bool {
-        self.slots.iter().all(|s| match s.shape {
-            Shape::Ellipse { .. } => x.get(s.off + 4).is_some_and(|r| *r > 0.0 && *r <= 1.0 + RATIO_TOL),
-            _ => true,
-        })
-    }
-
-    /// `x` with every ellipse re-expressed as [`Model::write_back`] stores it (the same curve with
-    /// the major axis the longer one, a full ellipse's negative ratio made positive), so the
-    /// constraints can be checked against what would be stored. `None` when an elliptical arc has
-    /// a negative ratio or an ellipse a zero one.
-    pub fn stored_form(&self, x: &[f64]) -> Option<Vec<f64>> {
-        let mut xc = x.to_vec();
-        for s in &self.slots {
-            let Shape::Ellipse { arc } = s.shape else { continue };
-            let o = s.off;
-            let mut ratio = *x.get(o + 4)?;
-            if ratio < 0.0 && !arc {
-                ratio = -ratio;
-            }
-            if ratio <= 0.0 {
-                return None;
-            }
-            if ratio > 1.0 + RATIO_TOL {
-                let major = p2(x, o + 2)?.perp() * ratio;
-                *xc.get_mut(o + 2)? = major.x;
-                *xc.get_mut(o + 3)? = major.y;
-                ratio = 1.0 / ratio;
-                if arc {
-                    *xc.get_mut(o + 5)? -= std::f64::consts::FRAC_PI_2;
-                    *xc.get_mut(o + 6)? -= std::f64::consts::FRAC_PI_2;
-                }
-            }
-            *xc.get_mut(o + 4)? = ratio;
-        }
-        Some(xc)
-    }
-
-    /// The parameter `stored_form` gives the point at parameter `t` on ellipse `h` (unchanged for
-    /// any other object): `-t` where a negative ratio was made positive, a quarter turn back where
-    /// the axes were swapped.
-    pub fn stored_t(&self, x: &[f64], h: Handle, t: f64) -> f64 {
-        let Some(s) = self.slot(h) else { return t };
-        let (Shape::Ellipse { .. }, Some(&ratio)) = (s.shape, x.get(s.off + 4)) else { return t };
-        let (t, ratio) = if ratio < 0.0 { (-t, -ratio) } else { (t, ratio) };
-        if ratio > 1.0 + RATIO_TOL { t - std::f64::consts::FRAC_PI_2 } else { t }
-    }
-
     /// Write solved parameters back. Returns the handles that moved.
     pub fn write_back(&self, d: &mut Drawing, x: &[f64]) -> Vec<Handle> {
         let mut moved = Vec::new();
@@ -637,9 +572,8 @@ impl Model {
                             [a, b] if arc => (*a, *b),
                             _ => (el.start, el.end),
                         };
-                        // Keep the stored form: the major axis is the longer one. `storable` lets a
-                        // solved ratio exceed 1 only by rounding: that is a circle, not a swap.
-                        if ratio > 1.0 + RATIO_TOL {
+                        // Keep the stored form: the major axis is the longer one.
+                        if ratio > 1.0 {
                             major = major.perp() * ratio;
                             ratio = 1.0 / ratio;
                             if arc {

crates/constraints/src/tests.rs

@@ -305,7 +305,7 @@ fn keep_option_moves_the_other_entity() {
     let mut d = Drawing::default();
     let a = line(&mut d, (0.0, 0.0), (10.0, 0.0));
     let b = line(&mut d, (0.0, 2.0), (10.0, 4.0));
-    add(&mut d, con(ConstraintKind::Parallel, &[w(a), w(b)]), &SolveOptions { keep: vec![a], prefer_move: vec![b], ..Default::default() }).unwrap();
+    add(&mut d, con(ConstraintKind::Parallel, &[w(a), w(b)]), &SolveOptions { keep: vec![a], prefer_move: vec![b] }).unwrap();
     let (a0, a1) = ln(&d, a);
     assert!(a0.near(Vec2::new(0.0, 0.0), 1e-3) && a1.near(Vec2::new(10.0, 0.0), 1e-3), "{a0:?} {a1:?}");
 }
@@ -412,7 +412,7 @@ fn glyphs_and_residuals() {
     })
     .unwrap();
     assert!(!all_satisfied(&d));
-    let r = solve(&mut d, &SolveOptions::default()).unwrap();
+    let r = solve(&mut d, &SolveOptions { keep: vec![], prefer_move: vec![] }).unwrap();
     assert_eq!(r.moved, vec![a]);
     assert!(all_satisfied(&d));
 }

crates/constraints/tests/dof.rs

@@ -382,83 +382,3 @@ fn vertex_constraints_on_large_fit_spline_do_not_charge_reconstruction() {
     assert_eq!(report.status, DofStatus::Under);
     assert_eq!(report.dof, Some(1000));
 }
-
-/// Adds a constraint that the stored ellipse can only hold with its axes renumbered: refused,
-/// with the drawing unchanged.
-fn refused_on_minor_axis_end(p: (f64, f64)) {
-    let mut d = Drawing::default();
-    let e = ellipse(&mut d, (0.0, 0.0), (4.0, 0.0), 0.5, 0.0, std::f64::consts::TAU);
-    ok(&mut d, con(K::Fix, &[s(e, Sub::Center)]));
-    let p = point(&mut d, p);
-    ok(&mut d, con(K::Fix, &[w(p)]));
-    let before = d.clone();
-    let r = add(&mut d, con(K::Coincident, &[s(e, Sub::Vertex(1)), w(p)]), &SolveOptions::default());
-    assert!(matches!(r, Err(SolveError::Conflict { .. })), "{r:?}, ellipse {:?}", ell(&d, e));
-    assert_eq!(d, before);
-}
-
-/// Pulling a minor axis end past the major axis length would need a ratio above 1, which the
-/// stored ellipse holds only by swapping its axes (and so renumbering their ends).
-#[test]
-fn minor_axis_end_pulled_past_the_major_axis_is_refused() {
-    refused_on_minor_axis_end((0.0, 6.0));
-}
-
-/// Pulling a minor axis end through the centre would need a negative ratio, which the stored
-/// ellipse cannot hold: storing its absolute value would mirror the minor axis end.
-#[test]
-fn minor_axis_end_pulled_through_the_centre_is_refused() {
-    refused_on_minor_axis_end((0.0, -1.0));
-}
-
-/// A circle-like ellipse whose solution makes the minor axis the longer one: stored with its axes
-/// swapped, which constraints that name no axis end by index do not notice.
-fn round_ellipse(d: &mut Drawing, start: f64, end: f64) -> Handle {
-    let e = ellipse(d, (0.0, 0.0), (4.0, 0.0), 1.0, start, end);
-    ok(d, con(K::Fix, &[s(e, Sub::Center)]));
-    e
-}
-
-#[test]
-fn tangent_that_swaps_a_round_ellipse_axes_is_kept() {
-    let mut d = Drawing::default();
-    let e = round_ellipse(&mut d, 0.0, std::f64::consts::TAU);
-    let l = line(&mut d, (-10.0, 4.5), (10.0, 4.5));
-    ok(&mut d, con(K::Fix, &[w(l)]));
-    ok(&mut d, con(K::Tangent, &[w(l), w(e)]));
-    assert!(ell(&d, e).ratio <= 1.0);
-    assert!(all_satisfied(&d));
-}
-
-#[test]
-fn point_on_curve_that_swaps_a_round_ellipse_axes_is_kept() {
-    let mut d = Drawing::default();
-    let e = round_ellipse(&mut d, 0.0, std::f64::consts::TAU);
-    let p = point(&mut d, (0.0, 4.5));
-    ok(&mut d, con(K::Fix, &[w(p)]));
-    ok(&mut d, con(K::Coincident, &[w(p), w(e)]));
-    assert!(ell(&d, e).ratio <= 1.0);
-    assert!(all_satisfied(&d));
-}
-
-#[test]
-fn elliptical_arc_start_that_swaps_its_axes_is_kept() {
-    let mut d = Drawing::default();
-    let e = round_ellipse(&mut d, std::f64::consts::FRAC_PI_2, std::f64::consts::PI);
-    let p = point(&mut d, (0.0, 4.5));
-    ok(&mut d, con(K::Fix, &[w(p)]));
-    ok(&mut d, con(K::Coincident, &[s(e, Sub::Start), w(p)]));
-    assert!(ell(&d, e).ratio <= 1.0);
-    assert!(all_satisfied(&d));
-}
-
-#[test]
-fn tangent_circle_that_swaps_a_round_ellipse_axes_is_kept() {
-    let mut d = Drawing::default();
-    let e = round_ellipse(&mut d, 0.0, std::f64::consts::TAU);
-    let c = circle(&mut d, (0.0, 6.0), 1.5);
-    ok(&mut d, con(K::Fix, &[w(c)]));
-    ok(&mut d, con(K::Tangent, &[w(c), w(e)]));
-    assert!(ell(&d, e).ratio <= 1.0);
-    assert!(all_satisfied(&d));
-}

crates/doc/src/constraint.rs

@@ -208,7 +208,7 @@ impl Default for ParametricSettings {
             angle_tolerance: 1.0,
             auto_types: ["Coincident", "Collinear", "Parallel", "Perpendicular", "Horizontal", "Vertical", "Tangent", "Concentric", "Equal"]
                 .iter()
-                .map(ToString::to_string)
+                .map(|s| s.to_string())
                 .collect(),
             bars_visible: true,
             bar_exceptions: Vec::new(),

crates/doc/src/dynblock/apply.rs

@@ -29,21 +29,16 @@ fn tag(code: i32, value: impl Into<String>) -> RawTag {
     RawTag { code, value: value.into() }
 }
 
-/// The element tag (`AcDbBlockRepETag` 1071) in `x`, if it has one.
-fn etag_in(x: &[RawTag]) -> Option<i64> {
+/// The element tag (`AcDbBlockRepETag` 1071) of object `h`, if it has one.
+fn etag(d: &Drawing, h: Handle) -> Option<i64> {
+    let x = &d.foreign.entities.get(&h)?.xdata;
     let at = x.iter().position(|t| t.code == 1001 && t.value.eq_ignore_ascii_case(ETAG))?;
     x.iter().skip(at + 1).take_while(|t| t.code != 1001).find(|t| t.code == 1071).and_then(|t| t.value.trim().parse().ok())
 }
 
-/// The element tag of object `e`: its own xdata (where the importer keeps it), else any kept in the
-/// foreign data.
-fn etag(d: &Drawing, e: &Entity) -> Option<i64> {
-    etag_in(&e.common.xdata).or_else(|| etag_in(&d.foreign.entities.get(&e.handle)?.xdata))
-}
-
 /// Each object of `b` keyed by its element tag, or by its position when it has none.
 fn by_tag(d: &Drawing, b: &Block) -> Vec<(i64, Handle)> {
-    b.entities.iter().enumerate().map(|(i, e)| (etag(d, e).unwrap_or(i as i64 + 1_000_000), e.handle)).collect()
+    b.entities.iter().enumerate().map(|(i, e)| (etag(d, e.handle).unwrap_or(i as i64 + 1_000_000), e.handle)).collect()
 }
 
 /// The file handle of block `name`'s BLOCK_RECORD, as the kept data refers to it.
@@ -547,12 +542,6 @@ fn apply(
         let Some(nh) = copies.get(&e.handle).copied() else { continue };
         let mut c: Entity = (**e).clone();
         c.handle = nh;
-        // The copy's own xdata names the copy, not its original (as the kept data below does).
-        for t in &mut c.common.xdata {
-            if t.code == 1005 && Handle::parse_hex(&t.value) == Some(e.handle) {
-                t.value = nh.hex();
-            }
-        }
         if let Some(v) = shown_copy.get(&e.handle) {
             c.common.visible = *v;
         }
@@ -975,30 +964,3 @@ fn drop_if_unused(d: &mut Drawing, name: &str) {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn tagged(h: u64, tag_value: Option<&str>) -> Entity {
-        let mut e = Entity::new(Handle(h), EntityKind::Line(crate::Line { a: Vec3::ZERO, b: Vec3::ZERO }));
-        if let Some(v) = tag_value {
-            e.common.xdata = vec![tag(1001, ETAG), tag(1071, v)];
-        }
-        e
-    }
-
-    #[test]
-    fn element_tags_are_read_from_the_entitys_own_xdata() {
-        let d = Drawing::new_imperial();
-        let mut def = Block::new("DEF");
-        def.entities.push(tagged(1, Some("10")));
-        def.entities.push(tagged(2, Some("20")));
-        let mut anon = Block::new("*U1");
-        // Reordered, and the first object left out.
-        anon.entities.push(tagged(5, Some("20")));
-        anon.entities.push(tagged(6, None));
-        assert_eq!(by_tag(&d, &def), vec![(10, Handle(1)), (20, Handle(2))]);
-        assert_eq!(by_tag(&d, &anon), vec![(20, Handle(5)), (1_000_001, Handle(6))]);
-    }
-}

crates/doc/src/entity.rs

@@ -18,11 +18,7 @@ impl Handle {
         format!("{:X}", self.0)
     }
     pub fn parse_hex(s: &str) -> Option<Handle> {
-        let s = s.trim();
-        if !s.bytes().all(|b| b.is_ascii_hexdigit()) {
-            return None;
-        }
-        u64::from_str_radix(s, 16).ok().map(Handle)
+        u64::from_str_radix(s.trim(), 16).ok().map(Handle)
     }
 }
 
@@ -1481,15 +1477,6 @@ mod grip_tests {
     use super::*;
     use cadcraft_geom::PolyVertex;
 
-    #[test]
-    fn handle_parse_hex_accepts_only_hex_digits() {
-        assert_eq!(Handle::parse_hex("1a"), Some(Handle(0x1A)));
-        assert_eq!(Handle::parse_hex(" 1A "), Some(Handle(0x1A)));
-        for bad in ["+1A", "-1A", "", "+", "1 A"] {
-            assert_eq!(Handle::parse_hex(bad), None, "{bad}");
-        }
-    }
-
     #[test]
     fn polyline_grips_are_vertices_and_midpoints() {
         // Grips are each vertex plus the midpoint of each segment; the segment vector is computed

crates/doc/src/foreign.rs

@@ -66,10 +66,6 @@ pub struct Foreign {
     pub records: BTreeMap<ForeignKey, ForeignExtra>,
     /// The roles of the file handles the kept data refers to, for objects CADCraft rewrites.
     pub targets: BTreeMap<Handle, ForeignKey>,
-    /// The upper-case names of the file's classes in its CLASSES order, kept when the file has
-    /// proxy objects or entities: a proxy's class number (group 91) is 500 plus its class's place
-    /// here, and saving renumbers it to the written CLASSES (#1812).
-    pub class_order: Vec<String>,
     /// The file's data store section (ACDSDATA, AutoCAD 2013 and later), as read: its groups
     /// after the section name. It holds the ACIS geometry of 3D solids, regions, bodies and
     /// surfaces, which from 2013 on those entities don't carry themselves: each `ACDSRECORD`
@@ -85,7 +81,6 @@ impl Foreign {
             && self.records.is_empty()
             && self.classes.is_empty()
             && self.targets.is_empty()
-            && self.class_order.is_empty()
             && self.data_store.is_empty()
     }
 

crates/doc/src/lib.rs

@@ -98,9 +98,6 @@ pub struct Drawing {
     pub blocks: BTreeMap<String, std::sync::Arc<Block>>,
     pub model: EntityStore,
     pub layouts: Vec<Layout>,
-    /// The layout a file marks active (its block is `*Paper_Space`, the others `*Paper_SpaceN`),
-    /// written active again. `None`, or a layout that no longer exists: the first by tab order.
-    pub active_layout: Option<String>,
     pub views: Vec<NamedView>,
     /// Model space viewport configurations (VPORTS): the tiles shown and named ones.
     pub vports: Vec<VportConfig>,
@@ -174,7 +171,6 @@ impl Drawing {
             blocks: BTreeMap::new(),
             model: EntityStore::new(),
             layouts: vec![Layout::new("Layout1", 1), Layout::new("Layout2", 2)],
-            active_layout: None,
             views: Vec::new(),
             vports: Vec::new(),
             ucss: Vec::new(),
@@ -302,18 +298,6 @@ impl Drawing {
         true
     }
 
-    /// The layouts in the order their paper space blocks are named in a file: the active one
-    /// (`*Paper_Space`) first, then the others by tab order (`*Paper_Space0`, `*Paper_Space1`, …).
-    pub fn paper_space_layouts(&self) -> Vec<&Layout> {
-        let mut ls: Vec<&Layout> = self.layouts.iter().collect();
-        ls.sort_by_key(|l| l.tab_order);
-        if let Some(i) = self.active_layout.as_ref().and_then(|a| ls.iter().position(|l| l.name.eq_ignore_ascii_case(a))) {
-            let active = ls.remove(i);
-            ls.insert(0, active);
-        }
-        ls
-    }
-
     pub fn space(&self, space: &Space) -> Option<&EntityStore> {
         match space {
             Space::Model => Some(&self.model),

crates/doc/src/tables.rs

@@ -177,11 +177,6 @@ pub struct DimStyle {
     pub dim_line_color: Color,
     pub ext_line_color: Color,
     pub text_color: Color,
-    /// DIMTFILL, the background of the text: 0 none, 1 the drawing's background color,
-    /// 2 `text_fill_color`.
-    pub text_fill: u8,
-    /// DIMTFILLCLR: the text background color when `text_fill` is 2.
-    pub text_fill_color: Color,
     pub text_style: String,
     /// DIMPOST prefix/suffix "<>" template.
     pub post: String,
@@ -301,8 +296,6 @@ pub const DIMVARS: &[(&str, &str)] = &[
     ("DIMCLRD", "dimLineColor"),
     ("DIMCLRE", "extLineColor"),
     ("DIMCLRT", "textColor"),
-    ("DIMTFILL", "textFill"),
-    ("DIMTFILLCLR", "textFillColor"),
     ("DIMTXSTY", "textStyle"),
     ("DIMPOST", "post"),
     ("DIMCEN", "centerMark"),
@@ -374,8 +367,6 @@ impl Default for DimStyle {
             dim_line_color: Color::ByBlock,
             ext_line_color: Color::ByBlock,
             text_color: Color::ByBlock,
-            text_fill: 0,
-            text_fill_color: Color::ByBlock,
             text_style: "Standard".into(),
             post: String::new(),
             center_mark: 0.09,
@@ -485,19 +476,10 @@ impl DimStyle {
             let coerced = match (&old, &coerced) {
                 // Lineweights (i16): whole hundredths of a mm or -1/-2/-3.
                 (Value::Number(_), Value::Number(n)) if matches!(field, "dimLineweight" | "extLineweight") && !n.is_i64() => {
-                    serde_json::json!(n.as_f64().filter(|x| x.is_finite()).unwrap_or(0.0).round() as i64)
+                    serde_json::json!(n.as_f64().filter(|x| x.is_finite()).unwrap_or(0.0).round().clamp(-3.0, 211.0) as i64)
                 }
-                (Value::Number(_), Value::Number(_)) if matches!(field, "dimLineweight" | "extLineweight") => coerced,
-                // A value below 0 or one that rounds above 255 is refused; DIMADEC -1 reads as 0.
                 (Value::Number(o), Value::Number(n)) if o.is_u64() && !n.is_u64() => {
-                    let min = if field == "angularDecimals" { -1.0 } else { 0.0 };
-                    match n.as_f64().filter(|x| x.is_finite() && *x >= min).map(f64::round).filter(|x| *x <= 255.0) {
-                        Some(x) => serde_json::json!(x.max(0.0) as u64),
-                        None => {
-                            rejected.push(k.clone());
-                            continue;
-                        }
-                    }
+                    serde_json::json!(n.as_f64().filter(|x| x.is_finite()).unwrap_or(0.0).round().clamp(0.0, 255.0) as u64)
                 }
                 _ => coerced,
             };
@@ -507,7 +489,7 @@ impl DimStyle {
                 "textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
                 "scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
                 "fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
-                "textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
+                "textMove" | "tolJust" | "arcSymbol" => x.is_some_and(|x| x > 2.0),
                 "dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
                 "jogAngle" => x.is_some_and(|x| !(5.0..=90.0).contains(&x)),
                 _ => false,
@@ -875,7 +857,7 @@ pub struct VportConfig {
 
 impl VportConfig {
     /// The name of the configuration shown.
-    pub const ACTIVE: &str = "*Active";
+    pub const ACTIVE: &'static str = "*Active";
     pub fn is_active(&self) -> bool {
         self.name.eq_ignore_ascii_case(Self::ACTIVE)
     }

crates/doc/src/tables/cellstyle.rs

@@ -109,9 +109,9 @@ impl Default for CellStyle {
 }
 
 impl CellStyle {
-    pub const TITLE: &str = "Title";
-    pub const HEADER: &str = "Header";
-    pub const DATA: &str = "Data";
+    pub const TITLE: &'static str = "Title";
+    pub const HEADER: &'static str = "Header";
+    pub const DATA: &'static str = "Data";
 
     /// Whether `name` is one of the three styles every table style has.
     pub fn is_builtin(name: &str) -> bool {
@@ -190,7 +190,7 @@ impl TableStyle {
 
     /// The names of its cell styles: Title, Header, Data, then the custom ones.
     pub fn cell_style_names(&self) -> Vec<String> {
-        let mut out: Vec<String> = [CellStyle::TITLE, CellStyle::HEADER, CellStyle::DATA].iter().map(ToString::to_string).collect();
+        let mut out: Vec<String> = [CellStyle::TITLE, CellStyle::HEADER, CellStyle::DATA].iter().map(|s| s.to_string()).collect();
         out.extend(self.cell_styles.iter().filter(|c| !CellStyle::is_builtin(&c.name)).map(|c| c.name.clone()));
         out
     }

crates/dwg/src/lib.rs

@@ -541,80 +541,12 @@ mod native {
         dimension_flags(&mut doc);
         drop_unwritable(&mut doc);
         current_dimstyle(&mut doc);
-        add_variable_dictionary(&mut doc);
         current_text_style(&mut doc);
         std::panic::catch_unwind(AssertUnwindSafe(|| acadrust::DwgWriter::write_to_vec(&doc)))
             .map_err(|_| "the DWG writer failed on this drawing".to_string())?
             .map_err(|e| format!("DWG write: {e}"))
     }
 
-    /// AutoCAD's entry name for the drawing variables dictionary (the DXF Reference calls it the
-    /// ACDBVARIABLEDICTIONARY; dictionary keys are case-insensitive).
-    const VARIABLE_DICTIONARY: &str = "AcDbVariableDictionary";
-
-    /// A style or scale name, or `default` when the drawing has none.
-    fn name_or_default(name: &str, default: &str) -> String {
-        let name = name.trim();
-        if name.is_empty() { default.to_string() } else { name.to_string() }
-    }
-
-    /// A drawing variable's value as text, or `default` when the header holds a value the
-    /// variable doesn't accept (a hostile file can put any integer in it).
-    fn variable_value(value: i16, valid: &[i16], default: i16) -> String {
-        if valid.contains(&value) { value.to_string() } else { default.to_string() }
-    }
-
-    /// Add the drawing variables dictionary AutoCAD always writes into the named object
-    /// dictionary, with the variables it keeps there, when the drawing has none (#1813).
-    /// Vectric Aspire 10.5 reads a 2004 (AC1018) DWG without it as empty ("No data was imported
-    /// from the DXF / DWG file"), though it reads the same drawing as DXF — which has no such
-    /// dictionary either, as CADCraft's and ezdxf's writers don't make one. AutoCAD's AC1032 DWGs
-    /// read there without it, so newer output is left as it was, and a dictionary the drawing
-    /// does have keeps its own entries and values.
-    fn add_variable_dictionary(doc: &mut acadrust::CadDocument) {
-        use acadrust::objects::{Dictionary, DictionaryVariable, ObjectType};
-        if doc.version >= acadrust::DxfVersion::AC1032 {
-            return;
-        }
-        let root_handle = doc.header.named_objects_dict_handle;
-        match doc.objects.get(&root_handle) {
-            Some(ObjectType::Dictionary(root)) => {
-                if root.get(VARIABLE_DICTIONARY).is_some() {
-                    return;
-                }
-            }
-            _ => return,
-        }
-        // The variables AutoCAD writes for a drawing with default styles and a 1:1 annotation
-        // scale. DIMASSOC and HIDETEXT keep the drawing's own header values; LAYEREVAL and
-        // LAYERNOTIFY have no DXF header variable.
-        let variables = [
-            ("CMLEADERSTYLE", name_or_default(&doc.header.current_mleader_style_name, "Standard")),
-            ("CTABLESTYLE", name_or_default(&doc.header.current_table_style_name, "Standard")),
-            ("CANNOSCALE", name_or_default(&doc.header.current_annotation_scale, "1:1")),
-            ("DIMASSOC", variable_value(doc.header.dimension_associativity, &[0, 1, 2], 2)),
-            ("HIDETEXT", variable_value(doc.header.hide_text, &[0, 1], 1)),
-            ("LAYEREVAL", "0".to_string()),
-            ("LAYERNOTIFY", "0".to_string()),
-        ];
-        let dictionary_handle = doc.allocate_handle();
-        let mut dictionary = Dictionary::new();
-        dictionary.handle = dictionary_handle;
-        dictionary.owner = root_handle;
-        for (name, value) in variables {
-            let handle = doc.allocate_handle();
-            let mut variable = DictionaryVariable::new(name, &value);
-            variable.handle = handle;
-            variable.owner_handle = dictionary_handle;
-            dictionary.add_entry(name, handle);
-            doc.objects.insert(handle, ObjectType::DictionaryVariable(variable));
-        }
-        doc.objects.insert(dictionary_handle, ObjectType::Dictionary(dictionary));
-        if let Some(ObjectType::Dictionary(root)) = doc.objects.get_mut(&root_handle) {
-            root.add_entry(VARIABLE_DICTIONARY, dictionary_handle);
-        }
-    }
-
     /// Entities of a layout other than the one in `*Paper_Space` are written owned by their block
     /// (entity mode 0, with its handle). acadrust writes every paper-space entity with mode 1,
     /// "paper space", which AutoCAD reads as the `*Paper_Space` block's: everything drawn on a

crates/dxf/src/lib.rs

@@ -413,7 +413,8 @@ pub fn write_ascii_as(tags: &[Tag], utf8: bool) -> String {
     for t in tags {
         let _ = write!(out, "{:>3}\r\n", t.code);
         match &t.value {
-            Value::Str(s) => escape_unicode(s, utf8, &mut out),
+            Value::Str(s) if utf8 => out.extend(s.chars().map(|c| if matches!(c, '\r' | '\n') { ' ' } else { c })),
+            Value::Str(s) => escape_unicode(s, &mut out),
             Value::Real(r) => out.push_str(&format_real(*r)),
             Value::Int(i) => out.push_str(&i.to_string()),
             Value::Bool(b) => out.push_str(&i64::from(*b).to_string()),
@@ -445,7 +446,11 @@ pub fn write_binary(tags: &[Tag], utf8: bool) -> Vec<u8> {
                     v => v.as_str(),
                 };
                 let mut text = String::with_capacity(s.len());
-                escape_unicode(&s, utf8, &mut text);
+                if utf8 {
+                    text.extend(s.chars().map(|c| if matches!(c, '\r' | '\n') { ' ' } else { c }));
+                } else {
+                    escape_unicode(&s, &mut text);
+                }
                 out.extend(text.bytes().filter(|&b| b != 0));
                 out.push(0);
             }
@@ -502,16 +507,12 @@ pub fn is_binary(bytes: &[u8]) -> bool {
 
 /// Escape a string for a pre-R2007 DXF, whose text is in the `$DWGCODEPAGE` code page: ASCII
 /// stays as it is and every other character becomes `\U+XXXX` (a surrogate pair of escapes
-/// above U+FFFF), so the bytes are valid in any code page; with `utf8` they stay as they are.
-/// A backslash that would start a `\U+` or `\M+` sequence is written as `\U+005C` so the reader
-/// gives back the literal text. Line breaks become spaces.
-fn escape_unicode(s: &str, utf8: bool, out: &mut String) {
-    let chars: Vec<char> = s.chars().collect();
-    for (i, &c) in chars.iter().enumerate() {
+/// above U+FFFF), so the bytes are valid in any code page. Line breaks become spaces.
+fn escape_unicode(s: &str, out: &mut String) {
+    for c in s.chars() {
         match c {
             '\r' | '\n' => out.push(' '),
-            '\\' if matches!(chars.get(i + 1), Some('U' | 'M')) && chars.get(i + 2) == Some(&'+') => out.push_str("\\U+005C"),
-            c if utf8 || c.is_ascii() => out.push(c),
+            c if c.is_ascii() => out.push(c),
             c => {
                 let mut units = [0u16; 2];
                 for u in c.encode_utf16(&mut units) {
@@ -568,19 +569,6 @@ pub fn records(tags: &[Tag]) -> Vec<(String, Vec<Tag>)> {
 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 ascii_roundtrip() {
         let tags = vec![

crates/engine/src/autosave.rs

@@ -208,12 +208,6 @@ impl Autosaver {
             if minutes == 0 || dir.trim().is_empty() || (!urgent && now - since < f64::from(minutes) * 60.0) {
                 continue;
             }
-            // In the Block Editor: the drawing with the editor's unsaved changes in the block. When
-            // they can't be put there, nothing is written and nothing is marked as covered, so the
-            // next pass tries again instead of keeping the host without them.
-            let Ok(doc) = st.recovery_drawing() else {
-                continue;
-            };
             let path = t
                 .file
                 .clone()
@@ -222,7 +216,8 @@ impl Autosaver {
             t.written = Some(Arc::downgrade(&st.doc));
             t.host = Some(Arc::downgrade(st.drawing()));
             t.since = None;
-            jobs.push(Job::Write { uid: st.uid, path, doc });
+            // In the Block Editor: the drawing with the editor's unsaved changes in the block.
+            jobs.push(Job::Write { uid: st.uid, path, doc: st.recovery_drawing() });
         }
         jobs
     }
@@ -307,7 +302,7 @@ mod native {
     /// files of stopped apps that have no files left. Only an autosave file is deleted: a path
     /// whose name doesn't parse as one ([`parse_file_name`]) is left alone.
     pub fn discard(path: &str) {
-        let ours = Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).is_some_and(|n| parse_file_name(n).is_some());
+        let ours = Path::new(path).file_name().and_then(|n| n.to_str()).is_some_and(|n| parse_file_name(n).is_some());
         if !ours {
             log::warn!("autosave: not deleting {path}: not an autosave file");
             return;
@@ -339,22 +334,10 @@ mod native {
 
     type WriteHook = fn(&Drawing, &str) -> std::result::Result<Vec<u8>, String>;
 
-    /// Create the autosave folder `dir` and any missing parents. On Unix the folders made here are
-    /// owner-only (`0o700`): autosave files are unsaved drawings, and with the default mode other
-    /// accounts on the machine could read them. A folder that already exists keeps its mode, since
-    /// SAVEFILEPATH can be any folder the user picked.
-    fn create_folder(dir: &Path) -> std::io::Result<()> {
-        let mut builder = std::fs::DirBuilder::new();
-        builder.recursive(true);
-        #[cfg(unix)]
-        std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o700);
-        builder.create(dir)
-    }
-
     fn write_file(write: WriteHook, doc: &Drawing, path: &str) -> std::result::Result<(), String> {
         let bytes = write(doc, "autosave.dxf")?;
         if let Some(dir) = Path::new(path).parent() {
-            create_folder(dir).map_err(|e| e.to_string())?;
+            std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
         }
         // Create a fresh temporary file exclusively and rename it into place, so a planted
         // `<path>.tmp` symlink in a shared autosave directory cannot redirect the write (CWE-59).
@@ -451,7 +434,7 @@ mod native {
             }
             self.last_beat = Some(now);
             let dir = Path::new(dir);
-            let r = create_folder(dir).and_then(|()| std::fs::write(lock_path(dir, &self.instance), std::process::id().to_string()));
+            let r = std::fs::create_dir_all(dir).and_then(|()| std::fs::write(lock_path(dir, &self.instance), std::process::id().to_string()));
             if let Err(e) = r {
                 log::warn!("autosave: lock file in {}: {e}", dir.display());
             }

crates/engine/src/blockedit.rs

@@ -195,13 +195,12 @@ impl DocState {
         self.block_edit.as_ref().is_some_and(|b| !Arc::ptr_eq(&b.saved, &self.doc))
     }
     /// The drawing to keep for recovery (autosave): with the Block Editor's unsaved changes in the
-    /// block, so a crash doesn't lose them. An error when the editor's changes can't be put in the
-    /// block (it would contain itself): the host drawing alone would lose them.
-    pub fn recovery_drawing(&self) -> Result<Arc<Drawing>> {
+    /// block, so a crash doesn't lose them.
+    pub fn recovery_drawing(&self) -> Arc<Drawing> {
         match &self.block_edit {
-            Some(be) if self.block_unsaved() => be.compose(&self.doc, &be.name).map(Arc::new),
-            Some(be) => Ok(be.host.doc.clone()),
-            None => Ok(self.doc.clone()),
+            Some(be) if self.block_unsaved() => be.compose(&self.doc, &be.name).map(Arc::new).unwrap_or_else(|_| be.host.doc.clone()),
+            Some(be) => be.host.doc.clone(),
+            None => self.doc.clone(),
         }
     }
 

crates/engine/src/cmd/annoscale.rs

@@ -7,8 +7,7 @@ use cadcraft_doc::{AnnoScale, Drawing, EntityKind, Handle, MAX_SCALES, is_annota
 use serde_json::{Value, json};
 
 use super::machines::{SelOutcome, SelectPhase, SelectRun};
-use super::{CommandSpec, bad, f64_req, targets};
-
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/annotate.rs

@@ -9,8 +9,7 @@ use serde_json::{Value, json};
 
 use super::helpers::v3;
 use super::machines::{SelOutcome, SelectPhase, SelectRun};
-use super::{CommandSpec, bad, point_param, point_req, points_param, str_param, targets};
-
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, LeaderOrder, MLeaderOptions, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {
@@ -120,7 +119,7 @@ fn style(s: &Session) -> String {
     s.doc().map(|d| d.header.str("DIMSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into())
 }
 
-fn dim(s: &Session, kind: DimKind, defpt: Vec2, p13: Vec2, p14: Vec2, p15: Vec2, text: &str) -> EntityKind {
+fn dim(s: &Session, kind: DimKind, defpt: Vec2, p13: Vec2, p14: Vec2, p15: Vec2, p16: Vec2, text: &str) -> EntityKind {
     EntityKind::Dimension(Dimension {
         kind,
         defpt: v3(defpt),
@@ -128,7 +127,7 @@ fn dim(s: &Session, kind: DimKind, defpt: Vec2, p13: Vec2, p14: Vec2, p15: Vec2,
         p13: v3(p13),
         p14: v3(p14),
         p15: v3(p15),
-        p16: v3(Vec2::ZERO),
+        p16: v3(p16),
         text: text.into(),
         style: style(s),
         measurement: 0.0,
@@ -183,7 +182,7 @@ fn with_assoc(k: EntityKind, assoc: Vec<DimAssoc>) -> EntityKind {
     }
 }
 
-/// Two-line angular dimension (type 2) between two lines, attached to them.
+/// Angular dimension between two lines, attached to them (vertex = their intersection).
 fn angular_from_lines(s: &Session, h1: Handle, h2: Handle, at: Vec2) -> Option<EntityKind> {
     let d = s.doc().ok()?;
     let line = |h: Handle| match &d.entity(h)?.kind {
@@ -201,21 +200,13 @@ fn angular_from_lines(s: &Session, h1: Handle, h2: Handle, at: Vec2) -> Option<E
     };
     let (p1, s1) = pick(a1, a2, AssocSnap::Start, AssocSnap::End);
     let (p2, s2) = pick(b1, b2, AssocSnap::Start, AssocSnap::End);
-    // A two-line angular dimension (type 2): line 1 is p13 -> p14, line 2 is defpt -> p15, p16 is on the arc.
-    // The picked leg end goes last in each pair, so the renderer measures between p14 and p15.
-    let (o1, t1) = if s1 == AssocSnap::Start { (a2, AssocSnap::End) } else { (a1, AssocSnap::Start) };
-    let (o2, t2) = if s2 == AssocSnap::Start { (b2, AssocSnap::End) } else { (b1, AssocSnap::Start) };
-    let mut k = dim(s, DimKind::Angular, o2, o1, p1, p2, "");
-    if let EntityKind::Dimension(d) = &mut k {
-        d.p16 = v3(at);
-    }
+    let k = dim(s, DimKind::Angular3P, at, p1, p2, v, Vec2::ZERO, "");
     let mut assoc = Vec::new();
     if assoc_enabled(s) {
         assoc = vec![
-            DimAssoc { point: "p13".into(), handle: h1, snap: t1 },
-            DimAssoc { point: "p14".into(), handle: h1, snap: s1 },
-            DimAssoc { point: "defpt".into(), handle: h2, snap: t2 },
-            DimAssoc { point: "p15".into(), handle: h2, snap: s2 },
+            DimAssoc { point: "p13".into(), handle: h1, snap: s1 },
+            DimAssoc { point: "p14".into(), handle: h2, snap: s2 },
+            DimAssoc { point: "p15".into(), handle: h1, snap: AssocSnap::Intersection { other: h2 } },
         ];
     }
     Some(with_assoc(k, assoc))
@@ -228,7 +219,7 @@ fn run_linear(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let at = point_req("dimlinear", p, "at")?;
     let rot = p.get("rotation").and_then(Value::as_f64).map(f64::to_radians);
-    let k = dim(s, linear_kind(a, b, at, rot, false), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
+    let k = dim(s, linear_kind(a, b, at, rot, false), at, a, b, Vec2::ZERO, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
     Ok(json!({ "handle": add_dim(s, k)?.hex() }))
 }
 
@@ -236,7 +227,7 @@ fn run_aligned(s: &mut Session, p: &Value) -> Result<Value> {
     let a = point_req("dimaligned", p, "p1")?;
     let b = point_req("dimaligned", p, "p2")?;
     let at = point_req("dimaligned", p, "at")?;
-    let k = dim(s, DimKind::Aligned, at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
+    let k = dim(s, DimKind::Aligned, at, a, b, Vec2::ZERO, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
     Ok(json!({ "handle": add_dim(s, k)?.hex() }))
 }
 
@@ -264,9 +255,9 @@ fn radial(s: &mut Session, p: &Value, diameter: bool) -> Result<Value> {
         return Err(bad(id, "`point` must differ from `center`"));
     }
     let k = if diameter {
-        dim(s, DimKind::Diameter, c + (c - pt), Vec2::ZERO, Vec2::ZERO, pt, "")
+        dim(s, DimKind::Diameter, c + (c - pt), Vec2::ZERO, Vec2::ZERO, pt, Vec2::ZERO, "")
     } else {
-        dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, pt, "")
+        dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, pt, Vec2::ZERO, "")
     };
     let k = match at {
         Some(at) => text_at(k, at),
@@ -311,7 +302,7 @@ fn run_angular(s: &mut Session, p: &Value) -> Result<Value> {
             _ => return Err(bad("dimangular", "object is not an arc")),
         };
         let g = cadcraft_geom::Arc::new(a.center.xy(), a.radius, a.start, a.end);
-        let k = dim(s, DimKind::Angular3P, at, g.start_point(), g.end_point(), g.center, "");
+        let k = dim(s, DimKind::Angular3P, at, g.start_point(), g.end_point(), g.center, Vec2::ZERO, "");
         return Ok(json!({ "handle": add_dim(s, k)?.hex() }));
     }
     let v = point_req("dimangular", p, "vertex")?;
@@ -321,7 +312,7 @@ fn run_angular(s: &mut Session, p: &Value) -> Result<Value> {
     if v.near(a, 1e-12) || v.near(b, 1e-12) {
         return Err(bad("dimangular", "`p1` and `p2` must differ from `vertex`"));
     }
-    let k = dim(s, DimKind::Angular3P, at, a, b, v, "");
+    let k = dim(s, DimKind::Angular3P, at, a, b, v, Vec2::ZERO, "");
     Ok(json!({ "handle": add_dim(s, k)?.hex() }))
 }
 
@@ -333,7 +324,7 @@ fn run_arclen(s: &mut Session, p: &Value) -> Result<Value> {
         _ => return Err(bad("dimarc", "object is not an arc")),
     };
     let ga = cadcraft_geom::Arc::new(a.center.xy(), a.radius, a.start, a.end);
-    let k = dim(s, DimKind::ArcLength, at, ga.start_point(), ga.end_point(), ga.center, "");
+    let k = dim(s, DimKind::ArcLength, at, ga.start_point(), ga.end_point(), ga.center, Vec2::ZERO, "");
     Ok(json!({ "handle": add_dim(s, k)?.hex() }))
 }
 
@@ -341,7 +332,7 @@ fn run_ordinate(s: &mut Session, p: &Value) -> Result<Value> {
     let f = point_req("dimordinate", p, "feature")?;
     let l = point_req("dimordinate", p, "leader")?;
     let xtype = p.get("xtype").and_then(Value::as_bool).unwrap_or((l - f).y.abs() > (l - f).x.abs());
-    let k = dim(s, DimKind::Ordinate { x_type: xtype }, Vec2::ZERO, f, l, Vec2::ZERO, "");
+    let k = dim(s, DimKind::Ordinate { x_type: xtype }, Vec2::ZERO, f, l, Vec2::ZERO, Vec2::ZERO, "");
     Ok(json!({ "handle": add_dim(s, k)?.hex() }))
 }
 
@@ -901,7 +892,7 @@ fn pick_at(s: &Session, p: Vec2) -> Option<Handle> {
 }
 
 /// The straight or curved piece of `h` picked at `p`: a line, an arc, or the polyline segment nearest `p`.
-pub(super) fn segment_at(s: &Session, h: Handle, p: Vec2) -> Option<Segment> {
+fn segment_at(s: &Session, h: Handle, p: Vec2) -> Option<Segment> {
     match &s.doc().ok()?.entity(h)?.kind {
         EntityKind::Line(l) => Some(Segment::Line(cadcraft_geom::Line::new(l.a.xy(), l.b.xy()))),
         EntityKind::Arc(a) => Some(Segment::Arc { arc: cadcraft_geom::Arc::new(a.center.xy(), a.radius, a.start, a.end), ccw: true }),
@@ -1063,7 +1054,7 @@ impl Interactive for LinearM {
             }
             (_, Input::Point(at)) => {
                 let (Some(&a), Some(&b)) = (self.pts.first(), self.pts.get(1)) else { return Ok(Step::Continue) };
-                let k = self.text.apply(dim(s, linear_kind(a, b, at, self.rotation, self.aligned), at, a, b, Vec2::ZERO, ""));
+                let k = self.text.apply(dim(s, linear_kind(a, b, at, self.rotation, self.aligned), at, a, b, Vec2::ZERO, Vec2::ZERO, ""));
                 add_dim(s, k)?;
                 if let Some(EntityKind::Dimension(d)) = s.last_dim.and_then(|h| s.doc().ok()?.entity(h).map(|e| e.kind.clone())) {
                     let st = s.doc()?.dim_style(&d.style).cloned().unwrap_or_default();
@@ -1090,7 +1081,7 @@ impl Interactive for LinearM {
     fn preview(&self, s: &Session, c: Vec2) -> Vec<EntityKind> {
         match self.pts.as_slice() {
             [a] => vec![super::helpers::line(*a, c)],
-            [a, b] => vec![self.text.apply(dim(s, linear_kind(*a, *b, c, self.rotation, self.aligned), c, *a, *b, Vec2::ZERO, ""))],
+            [a, b] => vec![self.text.apply(dim(s, linear_kind(*a, *b, c, self.rotation, self.aligned), c, *a, *b, Vec2::ZERO, Vec2::ZERO, ""))],
             _ => Vec::new(),
         }
     }
@@ -1109,9 +1100,9 @@ impl RadialM {
     fn kind(&self, s: &Session, c: Vec2, r: f64, at: Vec2) -> EntityKind {
         let pt = c + (at - c).normalized() * r;
         let k = self.text.apply(if self.diameter {
-            dim(s, DimKind::Diameter, c + (c - pt), Vec2::ZERO, Vec2::ZERO, pt, "")
+            dim(s, DimKind::Diameter, c + (c - pt), Vec2::ZERO, Vec2::ZERO, pt, Vec2::ZERO, "")
         } else {
-            dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, pt, "")
+            dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, pt, Vec2::ZERO, "")
         });
         text_at(k, at)
     }
@@ -1244,7 +1235,7 @@ impl Interactive for AngularM {
                         ([h1, h2], None) => angular_from_lines(s, *h1, *h2, at),
                         _ => None,
                     };
-                    let k = k.unwrap_or_else(|| dim(s, DimKind::Angular3P, at, a, b, v, ""));
+                    let k = k.unwrap_or_else(|| dim(s, DimKind::Angular3P, at, a, b, v, Vec2::ZERO, ""));
                     add_dim(s, self.text.apply(k))?;
                     Ok(Step::Done)
                 }
@@ -1310,7 +1301,9 @@ impl Interactive for AngularM {
         }
     }
     fn preview(&self, s: &Session, c: Vec2) -> Vec<EntityKind> {
-        self.geometry().map(|(v, a, b)| vec![self.text.apply(dim(s, DimKind::Angular3P, self.located(v, c), a, b, v, ""))]).unwrap_or_default()
+        self.geometry()
+            .map(|(v, a, b)| vec![self.text.apply(dim(s, DimKind::Angular3P, self.located(v, c), a, b, v, Vec2::ZERO, ""))])
+            .unwrap_or_default()
     }
 }
 
@@ -1386,7 +1379,7 @@ impl Interactive for ArcLenM {
                 Ok(Step::Continue)
             }
             (Some(g), Input::Point(at)) => {
-                add_dim(s, self.text.apply(dim(s, DimKind::ArcLength, at, g.start_point(), g.end_point(), g.center, "")))?;
+                add_dim(s, self.text.apply(dim(s, DimKind::ArcLength, at, g.start_point(), g.end_point(), g.center, Vec2::ZERO, "")))?;
                 Ok(Step::Done)
             }
             (Some(_), Input::Keyword(k)) => {
@@ -1405,7 +1398,9 @@ impl Interactive for ArcLenM {
         if self.partial.is_some() {
             return Vec::new();
         }
-        self.arc.map(|g| vec![self.text.apply(dim(s, DimKind::ArcLength, c, g.start_point(), g.end_point(), g.center, ""))]).unwrap_or_default()
+        self.arc
+            .map(|g| vec![self.text.apply(dim(s, DimKind::ArcLength, c, g.start_point(), g.end_point(), g.center, Vec2::ZERO, ""))])
+            .unwrap_or_default()
     }
 }
 
@@ -1420,7 +1415,7 @@ struct OrdinateM {
 impl OrdinateM {
     fn kind(&self, s: &Session, f: Vec2, l: Vec2) -> EntityKind {
         let x = self.xtype.unwrap_or((l - f).y.abs() > (l - f).x.abs());
-        self.text.apply(dim(s, DimKind::Ordinate { x_type: x }, Vec2::ZERO, f, l, Vec2::ZERO, ""))
+        self.text.apply(dim(s, DimKind::Ordinate { x_type: x }, Vec2::ZERO, f, l, Vec2::ZERO, Vec2::ZERO, ""))
     }
 }
 

crates/engine/src/cmd/annotate_dimedit.rs

@@ -5,11 +5,8 @@ use cadcraft_doc::{DimBreak, DimKind, Dimension, EntityKind, Handle, Inspection,
 use cadcraft_geom::{Segment, Vec2};
 use serde_json::{Value, json};
 
-use super::super::helpers::v3;
-use super::super::machines::{SelOutcome, SelectPhase};
-use super::super::{CommandSpec, bad, bool_or, point_param, point_req, size_param, str_param, targets};
-use super::{DimText, add_dim, circle_of, dim, dims_of, pick_at};
-
+use super::machines::{SelOutcome, SelectPhase};
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 /// Most objects DIMBREAK Auto looks at, and most breaks it adds to one dimension.
@@ -283,7 +280,7 @@ fn jogged_kind(s: &Session, c: Vec2, r: f64, center: Vec2, at: Vec2, jog: Option
     }
     let tip = c + dir * r;
     let jog = jog.unwrap_or_else(|| center.mid(tip));
-    let mut k = dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, tip, text);
+    let mut k = dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, tip, Vec2::ZERO, text);
     if let EntityKind::Dimension(dm) = &mut k {
         dm.marks.jogged = Some(JoggedRadius { center: v3(center), jog: v3(jog) });
         if at.dist(c) > r + 1e-9 {

crates/engine/src/cmd/annotate_qdim.rs

@@ -6,10 +6,8 @@ use cadcraft_doc::{DimKind, EntityKind, Handle, Prim};
 use cadcraft_geom::{Segment, Vec2};
 use serde_json::{Value, json};
 
-use super::super::machines::{SelOutcome, SelectPhase};
-use super::super::{bad, point_param, point_req, points_param, str_param, targets};
-use super::{MAX_CHAIN, assoc_enabled, dim};
-
+use super::machines::{SelOutcome, SelectPhase};
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 pub(super) const PARAMS: &str = "{handles?, at: [x,y] (dimension line position), mode?: continuous|staggered|baseline|ordinate|radius|diameter (default continuous), vertical?: bool (default: from `at`), datum?: [x,y] (baseline and ordinate; default the first point, or the origin for ordinate), add?: [[x,y]], remove?: [[x,y]] (dimension points; removes those within `tolerance`)}";
@@ -96,9 +94,9 @@ fn plan(
             let dir = if dir == Vec2::ZERO || !dir.is_finite() { Vec2::from_angle(std::f64::consts::FRAC_PI_4) } else { dir };
             let p = *c + dir * *r;
             out.push(if mode == Mode::Diameter {
-                dim(s, DimKind::Diameter, *c - dir * *r, Vec2::ZERO, Vec2::ZERO, p, "")
+                dim(s, DimKind::Diameter, *c - dir * *r, Vec2::ZERO, Vec2::ZERO, p, Vec2::ZERO, "")
             } else {
-                dim(s, DimKind::Radius, *c, Vec2::ZERO, Vec2::ZERO, p, "")
+                dim(s, DimKind::Radius, *c, Vec2::ZERO, Vec2::ZERO, p, Vec2::ZERO, "")
             });
         }
         if out.is_empty() {
@@ -131,7 +129,7 @@ fn plan(
             .iter()
             .map(|p| {
                 let end = if vertical { Vec2::new(at.x, p.y) } else { Vec2::new(p.x, at.y) };
-                dim(s, DimKind::Ordinate { x_type: !vertical }, origin, *p, end, Vec2::ZERO, "")
+                dim(s, DimKind::Ordinate { x_type: !vertical }, origin, *p, end, Vec2::ZERO, Vec2::ZERO, "")
             })
             .collect());
     }
@@ -147,7 +145,8 @@ fn plan(
     let mid = bounds.center();
     let out_dir =
         if vertical { Vec2::new(if at.x >= mid.x { 1.0 } else { -1.0 }, 0.0) } else { Vec2::new(0.0, if at.y >= mid.y { 1.0 } else { -1.0 }) };
-    let lin = |a: Vec2, b: Vec2, k: usize| dim(s, DimKind::Linear { rotation: rot }, at + out_dir * (step * k as f64), a, b, Vec2::ZERO, "");
+    let lin =
+        |a: Vec2, b: Vec2, k: usize| dim(s, DimKind::Linear { rotation: rot }, at + out_dir * (step * k as f64), a, b, Vec2::ZERO, Vec2::ZERO, "");
     Ok(match mode {
         Mode::Baseline => {
             // From the datum (the point nearest it, by default the first) to every other point.

crates/engine/src/cmd/annotate_tests.rs

@@ -1,4 +1,4 @@
-use cadcraft_doc::{DimKind, Dimension, EntityKind, Handle};
+use cadcraft_doc::{AssocSnap, DimKind, Dimension, EntityKind, Handle};
 use cadcraft_geom::Vec2;
 use serde_json::{Value, json};
 
@@ -136,9 +136,7 @@ fn angular_between_lines_follows_rotation() {
     let b = line(&mut s, [0.0, 0.0], [0.0, 10.0]);
     let d = h(&s.execute("dimangular", &json!({ "lines": [a.hex(), b.hex()], "at": [3, 3] })).unwrap());
     let dm = dim(&s, d);
-    // Two picked lines make a two-line angular dimension (type 2), tied to both lines at all four points.
-    assert_eq!(dm.kind, DimKind::Angular);
-    assert_eq!(dm.assoc.len(), 4);
+    assert!(dm.assoc.iter().any(|x| matches!(x.snap, AssocSnap::Intersection { .. })));
     assert_eq!(cadcraft_render::dimension_in(s.doc().unwrap(), &dm).value, "90°");
     // Swing the second line to 45°.
     s.execute("properties.set", &json!({ "handles": [b.hex()], "end": [10, 10] })).unwrap();

crates/engine/src/cmd/array.rs

@@ -17,8 +17,7 @@ use serde_json::{Value, json};
 use super::helpers::{line, v3};
 use super::machines::{SelOutcome, SelectPhase, number};
 use super::modify::transform_entities;
-use super::{CommandSpec, bad, bool_or, f64_or, find_command, point_param, point_req, str_param, targets};
-
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
 mod edit;

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

@@ -16,8 +16,7 @@ use serde_json::{Value, json};
 
 use super::super::helpers::v3;
 use super::super::machines::{SelOutcome, SelectPhase, number};
-use super::super::{CommandSpec, bad, bool_or, point_param, targets};
-
+use super::super::*;
 use super::{KEYWORDS, angle, check_size, count, fmt, nesting, other, yes, yes_no};
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 

crates/engine/src/cmd/audit.rs

@@ -5,9 +5,7 @@ use std::sync::Arc;
 
 use serde_json::{Value, json};
 
-use super::{CommandSpec, bad, bool_or, file, str_param};
-
-use super::always;
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/blocks.rs

@@ -2,7 +2,7 @@
 //! Block Editor.
 
 pub(crate) mod bedit;
-pub(in crate::cmd) mod purge;
+mod purge;
 
 use std::sync::Arc;
 
@@ -12,9 +12,7 @@ use serde_json::{Value, json};
 
 use super::helpers::v3;
 use super::machines::{SelOutcome, SelectPhase, number};
-use super::{CommandSpec, bad, bool_or, f64_or, find_command, ok, point_param, point_req, point_value, str_param, targets};
-
-use super::has_doc;
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
 mod attedit;
@@ -76,36 +74,27 @@ pub fn specs() -> Vec<CommandSpec> {
         attribs::attdisp_spec(),
         attribs::attsync_spec(),
         burst::burst_spec(),
-        blockreplace::blockreplace_spec(),
         extract::dataextraction_spec(),
         extract::eattext_spec(),
     ]
     .into_iter()
-    .chain(attribs::attdisp_menu_specs())
     .chain(xref::specs())
     .chain(refedit::specs())
     .chain(bedit::specs())
     .collect()
 }
 
-pub(crate) fn valid_block_name(n: &str) -> bool {
+fn valid_block_name(n: &str) -> bool {
     !n.trim().is_empty() && n.len() <= 255 && !n.starts_with('*') && !n.chars().any(|c| "<>/\\\":;?*|,=`".contains(c))
 }
 
-/// The block an entity draws, if any: a block reference's block, a dimension's block or a
-/// multileader's block content.
+/// The block an entity references, when it is a block reference.
 fn referenced_block(e: &Entity) -> Option<String> {
-    match &e.kind {
-        EntityKind::Insert(i) => Some(i.block.clone()),
-        EntityKind::Dimension(dm) => dm.block.clone(),
-        EntityKind::MLeader(m) => m.block.as_ref().map(|b| b.block.clone()),
-        _ => None,
-    }
+    if let EntityKind::Insert(i) = &e.kind { Some(i.block.clone()) } else { None }
 }
 
-/// Whether any of `ents` refers to block `name`, directly or through nested block references,
-/// dimension blocks and multileader block content.
-pub(crate) fn references_block(d: &cadcraft_doc::Drawing, ents: &[Entity], name: &str) -> bool {
+/// Whether any of `ents` refers to block `name`, directly or through nested block references.
+fn references_block(d: &cadcraft_doc::Drawing, ents: &[Entity], name: &str) -> bool {
     let mut todo: Vec<String> = ents.iter().filter_map(referenced_block).collect();
     let mut seen = std::collections::HashSet::new();
     while let Some(b) = todo.pop() {
@@ -889,4 +878,3 @@ impl Interactive for AttdefM {
 
 mod attribs;
 mod battman;
-mod blockreplace;

crates/engine/src/cmd/blocks/attribs.rs

@@ -16,22 +16,6 @@ pub(super) fn attdisp_spec() -> CommandSpec {
     CommandSpec::new("attdisp", "Attribute Display", run_attdisp)
         .params("{mode: \"normal\" | \"on\" | \"off\"} (sets ATTMODE to 1 / 2 / 0) → {attmode}")
         .interactive(|_| Ok(Box::new(AttdispM)))
-        .transparent()
-}
-
-/// Returns the View > Attribute Display > Normal, On and Off commands, which set ATTMODE as the matching ATTDISP option does.
-pub(super) fn attdisp_menu_specs() -> Vec<CommandSpec> {
-    vec![
-        CommandSpec::new("attdisp.normal", "Normal", |s, _| set_attmode(s, 1))
-            .menu(&["View", "Attribute Display", "Normal"])
-            .params("{} (ATTDISP Normal: ATTMODE 1) → {attmode}"),
-        CommandSpec::new("attdisp.on", "On", |s, _| set_attmode(s, 2))
-            .menu(&["View", "Attribute Display", "On"])
-            .params("{} (ATTDISP ON: ATTMODE 2) → {attmode}"),
-        CommandSpec::new("attdisp.off", "Off", |s, _| set_attmode(s, 0))
-            .menu(&["View", "Attribute Display", "Off"])
-            .params("{} (ATTDISP OFF: ATTMODE 0) → {attmode}"),
-    ]
 }
 
 pub(super) fn attsync_spec() -> CommandSpec {
@@ -100,7 +84,7 @@ impl Interactive for AttdispM {
 /// The attributes `ins` gets from the definitions `defs` of its block `blk`: placed, styled and
 /// shown as defined, keeping the values of attributes whose tag (any case) is still defined.
 /// Properties set on single attributes (layer, colour, …) go back to the definitions', as in AutoCAD.
-pub(super) fn synced(blk: &Block, defs: &[&Attrib], ins: &Insert) -> Vec<Attrib> {
+fn synced(blk: &Block, defs: &[&Attrib], ins: &Insert) -> Vec<Attrib> {
     let m = ins.transform(blk.base.xy());
     defs.iter()
         .map(|ad| {
@@ -135,16 +119,12 @@ fn references<'a>(ents: impl Iterator<Item = &'a Arc<Entity>>, name: &str) -> Ve
 /// Apply `f` to every reference of block `name` (in model space, layouts and other blocks);
 /// returns how many references there were.
 fn update_references(d: &mut cadcraft_doc::Drawing, name: &str, mut f: impl FnMut(&mut Insert)) -> usize {
-    update_reference_entities(d, name, |e| {
+    let mut n = 0;
+    let mut update = |e: &mut Entity| {
         if let EntityKind::Insert(ins) = &mut e.kind {
             f(ins);
         }
-    })
-}
-
-/// [`update_references`], with `f` given the whole object.
-pub(super) fn update_reference_entities(d: &mut cadcraft_doc::Drawing, name: &str, mut update: impl FnMut(&mut Entity)) -> usize {
-    let mut n = 0;
+    };
     let spaces: Vec<cadcraft_doc::Space> =
         std::iter::once(cadcraft_doc::Space::Model).chain(d.layouts.iter().map(|l| cadcraft_doc::Space::Paper(l.name.clone()))).collect();
     for sp in spaces {
@@ -189,22 +169,18 @@ pub(super) fn rename_tag(s: &mut Session, name: &str, old: &str, new: &str) -> R
     }))
 }
 
-/// The attribute definitions of `blk` that references carry (constant ones are not).
-pub(super) fn attdefs(blk: &Block) -> Vec<&Attrib> {
-    blk.entities
+/// Synchronize every reference of block `name` (in model space, layouts and other blocks).
+/// Returns the block's name as defined and how many references were updated.
+pub(super) fn sync(s: &mut Session, name: &str) -> Result<(String, usize)> {
+    let blk = s.doc()?.block(name).cloned().ok_or_else(|| EngineError::Other(format!("Block \"{name}\" not found.")))?;
+    let defs: Vec<&Attrib> = blk
+        .entities
         .iter()
         .filter_map(|e| match &e.kind {
             EntityKind::AttDef(a) if !a.constant => Some(a),
             _ => None,
         })
-        .collect()
-}
-
-/// Synchronize every reference of block `name` (in model space, layouts and other blocks).
-/// Returns the block's name as defined and how many references were updated.
-pub(super) fn sync(s: &mut Session, name: &str) -> Result<(String, usize)> {
-    let blk = s.doc()?.block(name).cloned().ok_or_else(|| EngineError::Other(format!("Block \"{name}\" not found.")))?;
-    let defs = attdefs(&blk);
+        .collect();
     let d = s.doc_mut()?;
     let n = update_references(d, &blk.name, |ins| ins.attribs = synced(&blk, &defs, ins));
     Ok((blk.name.clone(), n))

crates/engine/src/cmd/blocks/blockreplace.rs

@@ -1,236 +0,0 @@
-//! BLOCKREPLACE and -BLOCKREPLACE (Express Tools): every reference of one block, in model space,
-//! the layouts and other blocks, becomes a reference of another block at the same insertion
-//! point, scale and rotation. The unreferenced block definition can then be purged.
-
-use cadcraft_doc::{Drawing, Entity, EntityKind};
-use serde_json::{Value, json};
-
-use super::attribs::{attdefs, synced, update_reference_entities};
-use super::purge::{override_arrows, used_blocks};
-use super::references_block;
-use crate::cmd::curves::KW;
-use crate::cmd::machines::{SelOutcome, SelectPhase};
-use crate::cmd::{CommandSpec, bad, str_param};
-use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
-
-pub(super) fn blockreplace_spec() -> CommandSpec {
-    CommandSpec::new("blockreplace", "Replace Block...", run_blockreplace)
-        .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())))
-}
-
-/// The defined name of block `name` (names are case-insensitive), when it is a named block of
-/// this drawing: not anonymous and not one an xref brings in (`X|A`), which is never saved.
-fn named_block(d: &Drawing, name: &str) -> Option<String> {
-    d.block(name.trim()).filter(|b| !b.anonymous && !b.name.starts_with('*') && !b.name.contains('|')).map(|b| b.name.clone())
-}
-
-/// Why the references of block `old` cannot be replaced: a dynamic block's references keep their
-/// property values in data that names the block.
-fn not_replaceable(d: &Drawing, old: &str) -> Option<String> {
-    cadcraft_doc::dynblock::dynamic_block(d, old).map(|_| format!("Block \"{old}\" is a dynamic block; its references cannot be replaced."))
-}
-
-/// Why block `new` cannot replace block `old`: references of `old` inside `new` would make `new`
-/// reference itself.
-fn cannot_replace_with(d: &Drawing, old: &str, new: &str) -> Option<String> {
-    let blk = d.block(new)?;
-    references_block(d, &blk.entities.iter().map(|e| (**e).clone()).collect::<Vec<_>>(), old)
-        .then(|| format!("Block \"{new}\" references \"{old}\", so it cannot replace it."))
-}
-
-/// Replace every reference of `old` by a reference of `new`; with `purge`, remove `old`'s
-/// definition when nothing references it afterwards. Returns (references replaced, purged).
-fn replace(s: &mut Session, old: &str, new: &str, purge: bool) -> Result<(usize, bool)> {
-    let cmd = "blockreplace";
-    if s.state()?.block_edit.is_some() {
-        return Err(bad(cmd, "the Block Editor is open; close it with BCLOSE first"));
-    }
-    let d = s.doc()?;
-    if d.refedit.is_some() {
-        return Err(bad(cmd, "a block is being edited in place; finish with REFCLOSE first"));
-    }
-    if let Some(n) = [old, new].into_iter().find(|n| n.contains('|')) {
-        return Err(bad(cmd, format!("Block \"{}\" comes from an xref; bind the xref first.", n.trim())));
-    }
-    let old = named_block(d, old).ok_or_else(|| bad(cmd, format!("Block \"{}\" not found.", old.trim())))?;
-    let new = named_block(d, new).ok_or_else(|| bad(cmd, format!("Block \"{}\" not found.", new.trim())))?;
-    if old.eq_ignore_ascii_case(&new) {
-        return Err(bad(cmd, "the replacement block must be a different block"));
-    }
-    if let Some(why) = not_replaceable(d, &old).or_else(|| cannot_replace_with(d, &old, &new)) {
-        return Err(bad(cmd, why));
-    }
-    let blk = d.block(&new).cloned().ok_or_else(|| bad(cmd, format!("Block \"{new}\" not found.")))?;
-    let defs = attdefs(&blk);
-    let scale = d.current_anno_scale();
-    let d = s.doc_mut()?;
-    let n = update_reference_entities(d, &old, |e| {
-        if let EntityKind::Insert(ins) = &mut e.kind {
-            ins.block.clone_from(&blk.name);
-            ins.attribs = synced(&blk, &defs, ins);
-        }
-        // A reference of an annotative block is annotative, as INSERT makes it.
-        if !blk.annotative {
-            e.common.anno_scales.clear();
-        } else if e.common.anno_scales.is_empty() {
-            e.common.anno_scales = vec![scale.clone()];
-        }
-    });
-    let key = d.blocks.keys().find(|k| k.eq_ignore_ascii_case(&old)).cloned();
-    let purged = purge && !referenced(d, &old) && key.is_some_and(|k| d.blocks.remove(&k).is_some());
-    Ok((n, purged))
-}
-
-/// Whether anything still names block `name`: what PURGE counts as in use, and the dimensions,
-/// multileaders and block references of every other block definition, used or not.
-fn referenced(d: &Drawing, name: &str) -> bool {
-    if used_blocks(d).contains(&name.to_ascii_uppercase()) {
-        return true;
-    }
-    let names = |e: &Entity| -> Vec<String> {
-        match &e.kind {
-            EntityKind::Insert(i) => vec![i.block.clone()],
-            EntityKind::Dimension(dm) => dm.block.iter().cloned().chain(override_arrows(dm)).collect(),
-            EntityKind::MLeader(m) => m.block.iter().map(|b| b.block.clone()).collect(),
-            _ => Vec::new(),
-        }
-    };
-    d.blocks
-        .values()
-        .filter(|b| !b.name.eq_ignore_ascii_case(name))
-        .flat_map(|b| b.entities.iter())
-        .any(|e| names(e).iter().any(|n| n.trim().eq_ignore_ascii_case(name)))
-}
-
-fn run_blockreplace(s: &mut Session, p: &Value) -> Result<Value> {
-    let cmd = "blockreplace";
-    let old = str_param(p, "block").ok_or_else(|| bad(cmd, "`block` (the block to replace) is required"))?;
-    let new = str_param(p, "with").ok_or_else(|| bad(cmd, "`with` (the replacement block) is required"))?;
-    let purge = match p.get("purge") {
-        None | Some(Value::Null) => false,
-        Some(Value::Bool(b)) => *b,
-        Some(v) => return Err(bad(cmd, format!("`purge` must be true or false, not {v}"))),
-    };
-    let (old, new) = (old.to_string(), new.to_string());
-    let (n, purged) = replace(s, &old, &new, purge)?;
-    let d = s.doc()?;
-    let defined = |name: &str| named_block(d, name).unwrap_or_else(|| name.trim().to_string());
-    Ok(json!({ "block": defined(&old), "with": defined(&new), "replaced": n, "purged": purged }))
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-enum Stage {
-    #[default]
-    Old,
-    New,
-    Select,
-    Purge,
-}
-
-#[derive(Default)]
-struct BlockreplaceM {
-    stage: Stage,
-    /// The stage a picked reference answers.
-    back: Stage,
-    sel: SelectPhase,
-    old: String,
-    new: String,
-}
-
-impl BlockreplaceM {
-    /// Take `name` as the answer to the current name prompt. A block that cannot take part is
-    /// refused here, so the prompt asks again.
-    fn take(&mut self, s: &Session, stage: Stage, name: &str) -> Result<()> {
-        let d = s.doc()?;
-        let name = named_block(d, name).ok_or_else(|| EngineError::Other(format!("Block \"{}\" not found.", name.trim())))?;
-        if stage == Stage::Old {
-            if let Some(why) = not_replaceable(d, &name) {
-                return Err(EngineError::Other(why));
-            }
-            self.old = name;
-            self.stage = Stage::New;
-        } else {
-            if name.eq_ignore_ascii_case(&self.old) {
-                return Err(EngineError::Other("The replacement block must be a different block.".into()));
-            }
-            if let Some(why) = cannot_replace_with(d, &self.old, &name) {
-                return Err(EngineError::Other(why));
-            }
-            self.new = name;
-            self.stage = Stage::Purge;
-        }
-        Ok(())
-    }
-
-    fn finish(&mut self, s: &mut Session, purge: bool) -> Result<Step> {
-        let (n, purged) = replace(s, &self.old, &self.new, purge)?;
-        s.echo(format!(
-            "{n} reference{} of block {} replaced with {}.{}",
-            if n == 1 { "" } else { "s" },
-            self.old,
-            self.new,
-            if purged { format!(" Block {} purged.", self.old) } else { String::new() }
-        ));
-        Ok(Step::Done)
-    }
-}
-
-impl Interactive for BlockreplaceM {
-    fn name(&self) -> &'static str {
-        "BLOCKREPLACE"
-    }
-    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"]),
-            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"),
-        }
-    }
-    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
-        match self.stage {
-            stage @ (Stage::Old | Stage::New) => match &i {
-                Input::Keyword(k) if k == "?" => {
-                    let d = s.doc()?;
-                    let mut names: Vec<String> = d.blocks.keys().filter_map(|k| named_block(d, k)).collect();
-                    names.sort_by_key(|n| n.to_ascii_lowercase());
-                    s.echo(if names.is_empty() { "No blocks defined.".to_string() } else { format!("Blocks: {}", names.join(", ")) });
-                }
-                Input::Keyword(k) if k == "Select" => {
-                    self.back = stage;
-                    self.sel = SelectPhase::single();
-                    self.stage = Stage::Select;
-                }
-                Input::Text(t) if !t.trim().is_empty() => self.take(s, stage, t)?,
-                Input::Enter | Input::Cancel => return Ok(Step::Done),
-                _ => {}
-            },
-            Stage::Select => match self.sel.feed(s, &i)? {
-                SelOutcome::More => {}
-                SelOutcome::Empty => self.stage = self.back,
-                SelOutcome::Done(hs) => {
-                    s.set_selection(Vec::new());
-                    self.sel = SelectPhase::single();
-                    let block = hs.iter().find_map(|h| match s.doc().ok()?.entity(*h).map(|e| &e.kind) {
-                        Some(EntityKind::Insert(ins)) => Some(ins.block.clone()),
-                        _ => None,
-                    });
-                    match block {
-                        Some(b) => self.take(s, self.back, &b)?,
-                        None => return Err(EngineError::Other("That object is not a block reference.".into())),
-                    }
-                }
-            },
-            Stage::Purge => match &i {
-                Input::Keyword(k) if k == "No" => return self.finish(s, false),
-                Input::Keyword(_) | Input::Enter => return self.finish(s, true),
-                Input::Cancel => return Ok(Step::Done),
-                _ => return Err(EngineError::Other("Invalid option keyword.".into())),
-            },
-        }
-        Ok(Step::Continue)
-    }
-}

crates/engine/src/cmd/blocks/insert_file.rs

@@ -149,7 +149,6 @@ fn merge_tables(d: &mut Drawing, src: &Drawing) {
     merge(&mut d.dim_styles, &src.dim_styles, |t| &t.name);
     merge(&mut d.mleader_styles, &src.mleader_styles, |t| &t.name);
     merge(&mut d.table_styles, &src.table_styles, |t| &t.name);
-    merge(&mut d.mline_styles, &src.mline_styles, |t| &t.name);
 }
 
 /// Which source blocks to copy, and under which name: new names keep theirs, generated
@@ -256,17 +255,4 @@ mod tests {
         assert_eq!(file_ref(&s, "C:\\parts\\bolt.dxf").map(|f| f.name), Some("bolt".into()));
         assert!(file_ref(&s, "BOLT").is_none());
     }
-
-    #[test]
-    fn inserted_file_brings_its_mline_styles() {
-        let mut src = Drawing::default();
-        src.mline_styles.push(cadcraft_doc::MLineStyle { name: "WALL".into(), ..Default::default() });
-        let mut d = Drawing::default();
-        merge_tables(&mut d, &src);
-        assert!(d.mline_styles.iter().any(|m| m.name == "WALL"));
-        // A style this drawing already has keeps its own definition.
-        let before = d.mline_styles.len();
-        merge_tables(&mut d, &src);
-        assert_eq!(d.mline_styles.len(), before);
-    }
 }

crates/engine/src/cmd/blocks/purge.rs

@@ -13,9 +13,8 @@ use super::super::qselect::wildcard;
 use super::super::{bad, find_command, str_param};
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
-/// The named objects PURGE can remove. `USAGE` runs the same scan.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(in crate::cmd) enum Kind {
+enum Kind {
     Blocks,
     Dimstyles,
     Groups,
@@ -118,35 +117,14 @@ fn entities(d: &Drawing) -> impl Iterator<Item = &std::sync::Arc<cadcraft_doc::E
     d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).chain(d.blocks.values().flat_map(|b| b.entities.iter())).take(5_000_000)
 }
 
-/// The arrowhead block names a dimension's overrides set.
-pub(in crate::cmd) fn override_arrows(dm: &cadcraft_doc::Dimension) -> impl Iterator<Item = String> + '_ {
-    dm.overrides
-        .iter()
-        .filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k).is_some_and(|f| f.starts_with("arrowBlock") || f == "leaderArrowBlock"))
-        .filter_map(|(_, v)| v.as_str().map(|n| n.trim().to_string()))
-        .filter(|n| !n.is_empty())
-}
-
-/// Upper-case names of blocks reachable from model space, the layouts and dimensions, and the
-/// arrowhead blocks dimension styles and dimension overrides name.
-pub(in crate::cmd) fn used_blocks(d: &Drawing) -> HashSet<String> {
+/// Upper-case names of blocks reachable from model space, the layouts and dimensions.
+fn used_blocks(d: &Drawing) -> HashSet<String> {
     let mut used = HashSet::new();
     let mut frontier: Vec<String> = Vec::new();
-    for st in &d.dim_styles {
-        frontier.extend(
-            [&st.arrow_block, &st.arrow_block1, &st.arrow_block2, &st.leader_arrow_block]
-                .into_iter()
-                .map(|n| n.trim().to_string())
-                .filter(|n| !n.is_empty()),
-        );
-    }
     for e in d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())) {
         match &e.kind {
             EntityKind::Insert(i) => frontier.push(i.block.clone()),
-            EntityKind::Dimension(dm) => {
-                frontier.extend(dm.block.clone());
-                frontier.extend(override_arrows(dm));
-            }
+            EntityKind::Dimension(dm) => frontier.extend(dm.block.clone()),
             EntityKind::MLeader(m) => frontier.extend(m.block.as_ref().map(|b| b.block.clone())),
             _ => {}
         }
@@ -161,10 +139,7 @@ pub(in crate::cmd) fn used_blocks(d: &Drawing) -> HashSet<String> {
             for e in b.entities.iter() {
                 match &e.kind {
                     EntityKind::Insert(i) => frontier.push(i.block.clone()),
-                    EntityKind::Dimension(dm) => {
-                        frontier.extend(dm.block.clone());
-                        frontier.extend(override_arrows(dm));
-                    }
+                    EntityKind::Dimension(dm) => frontier.extend(dm.block.clone()),
                     EntityKind::MLeader(m) => frontier.extend(m.block.as_ref().map(|b| b.block.clone())),
                     _ => {}
                 }
@@ -178,9 +153,8 @@ fn is(name: &str, list: &[&str]) -> bool {
     list.iter().any(|n| n.eq_ignore_ascii_case(name))
 }
 
-/// Names of the unused objects of a named kind, in table order. This is PURGE's scan; `USAGE`
-/// reads it too, without purging anything.
-pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
+/// Names of the unused objects of a named kind, in table order.
+fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
     let lower = |it: &mut dyn Iterator<Item = String>| it.map(|n| n.to_ascii_lowercase()).collect::<HashSet<String>>();
     match kind {
         Kind::Blocks => {

crates/engine/src/cmd/blocks/xref/load.rs

@@ -420,17 +420,6 @@ fn import(d: &mut Drawing, key: &str, x: &Drawing, cx: &mut Ctx) -> Result<(), S
         nb.anonymous = b.anonymous;
         nb.explodable = b.explodable;
         nb.units = b.units;
-        // Array parameters keep their kind and spacing; block names follow the block renaming, and
-        // a source edit in progress in the referenced file is not carried over.
-        nb.array = b.array.as_ref().map(|a| {
-            let mut a = a.clone();
-            a.source = dep(Sym::Block, &a.source).unwrap_or(a.source);
-            for r in &mut a.replaced {
-                r.block = dep(Sym::Block, &r.block).unwrap_or_else(|| r.block.clone());
-            }
-            a.editing = None;
-            a
-        });
         for e in b.entities.iter() {
             let e = adopt(d, e);
             nb.entities.push(e);
@@ -543,35 +532,4 @@ mod tests {
         assert!(!has_prefix("SITE", "site|"));
         assert!(!has_prefix("é", "ab"));
     }
-
-    #[test]
-    fn imported_array_blocks_keep_their_parameters() {
-        use cadcraft_doc::{ArrayKind, ArrayParams, Block, RectArray, ReplacedItem};
-        let rect = RectArray { cols: 3, rows: 2, col_spacing: 5.0, row_spacing: 4.0, axis_angle: 0.0, row_elevation: 0.0 };
-        let params = ArrayParams {
-            source: "*U1".into(),
-            kind: ArrayKind::Rect(rect),
-            levels: 1,
-            level_spacing: 0.0,
-            replaced: vec![ReplacedItem { i: 1, j: 0, level: 0, block: "ALT".into() }],
-            editing: Some(Default::default()),
-        };
-        let mut arr = Block::new("*U2");
-        arr.array = Some(params);
-        let mut x = Drawing::default();
-        x.blocks.insert("*U2".into(), Arc::new(arr));
-
-        let mut d = Drawing::default();
-        d.blocks.insert("SITE".into(), Arc::new(Block::new("SITE")));
-        let mut cx = Ctx { chain: Vec::new(), objects: 0, files: 0, bytes: 0, notes: Vec::new() };
-        assert!(import(&mut d, "SITE", &x, &mut cx).is_ok());
-
-        let got = d.blocks.get("SITE|*U2").and_then(|b| b.array.clone());
-        let Some(got) = got else { panic!("array parameters were dropped") };
-        assert_eq!(got.source, "SITE|*U1");
-        assert_eq!(got.replaced[0].block, "SITE|ALT");
-        assert!(got.editing.is_none());
-        let ArrayKind::Rect(r) = got.kind else { panic!("not a rectangular array") };
-        assert_eq!((r.cols, r.rows), (3, 2));
-    }
 }

crates/engine/src/cmd/constraints.rs

@@ -14,8 +14,7 @@ use cadcraft_geom::{Line, Vec2};
 use serde_json::{Value, json};
 
 use super::machines::{SelOutcome, SelectPhase};
-use super::{CommandSpec, bad, bool_or, f64_or, point_value, str_param, targets};
-
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
 macro_rules! gc {
@@ -328,7 +327,7 @@ fn add_constraint(s: &mut Session, c: Constraint) -> Result<u32> {
     let keep: Vec<Handle> = c.refs.first().map(|r| r.handle).into_iter().collect();
     let prefer_move: Vec<Handle> = c.refs.iter().skip(1).map(|r| r.handle).filter(|h| !keep.contains(h)).collect();
     let mut d = s.doc()?.clone();
-    let id = cs::add(&mut d, c, &cs::SolveOptions { keep, prefer_move, ..Default::default() }).map_err(err)?;
+    let id = cs::add(&mut d, c, &cs::SolveOptions { keep, prefer_move }).map_err(err)?;
     *s.doc_mut()? = d;
     Ok(id)
 }
@@ -1120,7 +1119,7 @@ fn infer_after(s: &mut Session, before: &Drawing) {
         return;
     }
     let mut nd = d.clone();
-    let opts = cs::SolveOptions { keep: others, prefer_move: placed, ..Default::default() };
+    let opts = cs::SolveOptions { keep: others, prefer_move: placed };
     let added = cands.into_iter().take(200).filter(|c| cs::add(&mut nd, c.clone(), &opts).is_ok()).count();
     if added > 0
         && let Ok(st) = s.state_mut()
@@ -1149,8 +1148,7 @@ pub fn after_command(s: &mut Session, before: Option<&Arc<Drawing>>, ok: bool) {
     let mut d = (*st.doc).clone();
     let purged = cs::purge_invalid(&mut d);
     let restored = cs::restore_fixed(&mut d, before);
-    let anchors = cs::moved_anchors(&d, before);
-    let satisfied = anchors.is_empty() && cs::all_satisfied(&d);
+    let satisfied = cs::all_satisfied(&d);
     if purged.is_empty() && !restored && satisfied {
         return;
     }
@@ -1169,25 +1167,9 @@ pub fn after_command(s: &mut Session, before: Option<&Arc<Drawing>>, ok: bool) {
                 keep.push(h);
             }
         }
-        // A grip drag moved some of an object's points: they stay where they were put, and the
-        // edited objects still move least. When that cannot be solved, the edited objects are
-        // only kept as a whole, as for any other edit.
-        let hold: Vec<GeomRef> = keep.iter().flat_map(|&h| cs::edited_points(&d, before, h)).collect();
-        let mut solved = None;
-        if !hold.is_empty() {
-            let mut trial = d.clone();
-            let opts = cs::SolveOptions { keep: keep.clone(), prefer_move: Vec::new(), hold, anchors: anchors.clone() };
-            solved = cs::solve(&mut trial, &opts).ok().map(|_| trial);
-        }
-        let solved = match solved {
-            Some(t) => Ok(t),
-            None => {
-                let mut trial = d.clone();
-                cs::solve(&mut trial, &cs::SolveOptions { keep, anchors, ..Default::default() }).map(|_| trial)
-            }
-        };
-        match solved {
-            Ok(t) => d = t,
+        let mut trial = d.clone();
+        match cs::solve(&mut trial, &cs::SolveOptions { keep, prefer_move: Vec::new() }) {
+            Ok(_) => d = trial,
             Err(e) => msg.push(format!("Constraints could not be satisfied: {e}")),
         }
     }

crates/engine/src/cmd/draw.rs

@@ -5,19 +5,12 @@ use cadcraft_doc::{EntityKind, HAlign, MText, Point, RayLine, Text, VAlign};
 use cadcraft_geom::{Arc, Circle, Ellipse, PolyVertex, Polyline, Spline, Vec2, arc_to_bulge, bulge_to_arc};
 use serde_json::{Value, json};
 
-use super::helpers::{arc, circle, line, lwpoly, polygon_from_edge, polygon_typed_radius_point, polygon_vertices, v3};
-
+use super::helpers::*;
 use super::machines::number;
 use super::pline_opts::{Outcome, PlineAsk};
-use super::{
-    CommandSpec, bad, bool_or, distinct_points, f64_or, f64_req, find_command, point_param, point_req, point_value, points_param, size_param,
-    str_param,
-};
-
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step, snap};
 
-/// Every draw command's spec: JSON parameters, menu path, aliases and the interactive prompt
-/// machine each command starts.
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         CommandSpec::new("line", "Line", run_line)
@@ -43,7 +36,7 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("rectang", "Rectangle", super::draw2::run_rectang2)
             .menu(&["Draw", "Rectangle"])
             .alias(&["rec", "rectangle"])
-            .params("{p1, p2 | dimensions: [l, w] (p2 picks the quadrant) | area + length|breadth, rotation? (deg), fillet?, chamfer?: [d1, d2], width?, elevation?, thickness?, center?: bool (p1 is the centre, not a corner; the size spans it evenly)}")
+            .params("{p1, p2 | dimensions: [l, w] (p2 picks the quadrant) | area + length|breadth, rotation? (deg), fillet?, chamfer?: [d1, d2], width?, elevation?, thickness?}")
             .interactive(|_| Ok(Box::new(super::draw2::RectM2::default()))),
         CommandSpec::new("polygon", "Polygon", run_polygon)
             .menu(&["Draw", "Polygon"])

crates/engine/src/cmd/draw2.rs

@@ -7,11 +7,9 @@ use cadcraft_geom::{Arc, Circle, Ellipse, Line, PolyVertex, Polyline, Spline, TA
 use serde_json::{Value, json};
 
 use super::curves::{self, Chain, MAX_GEN, TanObj};
-use super::helpers::{arc, circle, line, lwpoly, rect_vertices, rect_with_corners, v3};
-
+use super::helpers::*;
 use super::machines::number;
-use super::{CommandSpec, bad, bool_or, f64_or, f64_req, point_param, point_req, point_value, points_param, size_param, str_param, targets};
-
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
 pub(crate) mod breakline;
@@ -1085,9 +1083,7 @@ impl Interactive for RevcloudM {
         let first_kw: &[&str] = &["Arc length", "Object", "Rectangular", "Polygonal", "Freehand", "Style"];
         match (self.kind, self.pts.len()) {
             (CloudKind::Rect, 0) => Prompt::new("Specify first corner point", Accept::POINT).kw(first_kw).default("Object"),
-            (CloudKind::Rect, _) => {
-                Prompt { corner: true, ..Prompt::new("Specify opposite corner", Accept::POINT).base_opt(self.pts.first().copied()) }
-            }
+            (CloudKind::Rect, _) => Prompt::new("Specify opposite corner", Accept::POINT).base_opt(self.pts.first().copied()),
             (CloudKind::Poly, 0) => Prompt::new("Specify start point", Accept::POINT).kw(first_kw).default("Object"),
             (CloudKind::Poly, 1) => Prompt::new("Specify next point", Accept::POINT).base_opt(self.pts.last().copied()),
             (CloudKind::Poly, _) => Prompt::new("Specify next point", Accept::POINT).kw(&["Undo"]).base_opt(self.pts.last().copied()),
@@ -1574,7 +1570,7 @@ impl Interactive for XlineM2 {
 // RECTANG with Area / Dimensions / Rotation / Width / Elevation / Thickness
 // =====================================================================================
 
-fn rect_kind(first: Vec2, (w, h): (f64, f64), rot: f64, fillet: f64, chamfer: (f64, f64), width: f64, elevation: f64) -> EntityKind {
+fn rect_kind(first: Vec2, w: f64, h: f64, rot: f64, fillet: f64, chamfer: (f64, f64), width: f64, elevation: f64) -> EntityKind {
     let local = rect_with_corners(Vec2::ZERO, Vec2::new(w, h), fillet, chamfer);
     let vs = local.into_iter().map(|v| PolyVertex { p: first + v.p.rotate(rot), ..v }).collect();
     let mut k = lwpoly(vs, true);
@@ -1585,12 +1581,8 @@ fn rect_kind(first: Vec2, (w, h): (f64, f64), rot: f64, fillet: f64, chamfer: (f
     k
 }
 
-/// Draws a rectangle from the JSON form: `p1` is a corner, or the centre when `center` is
-/// true, and the size comes from `p2`, `dimensions` or `area` plus `length`/`breadth`.
 pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
     let a = point_req("rectang", p, "p1")?;
-    // Centre mode: `p1` is the rectangle's centre, so the rectangle spans it evenly.
-    let centered = bool_or(p, "center", false);
     let rot = f64_or(p, "rotation", 0.0).to_radians();
     let ch = p
         .get("chamfer")
@@ -1626,18 +1618,17 @@ pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
     } else {
         let b = point_req("rectang", p, "p2")?;
         let loc = (b - a).rotate(-rot);
-        // In centre mode the picked point is one corner, mirrored across the centre.
-        if centered { (2.0 * loc.x, 2.0 * loc.y) } else { (loc.x, loc.y) }
+        (loc.x, loc.y)
     };
     if w.abs() < 1e-12 || h.abs() < 1e-12 || !w.is_finite() || !h.is_finite() {
         return Err(bad("rectang", "rectangle has no area"));
     }
-    let first = if centered { a - Vec2::new(w / 2.0, h / 2.0).rotate(rot) } else { a };
-    let k = rect_kind(first, (w, h), rot, fillet, ch, width, f64_or(p, "elevation", 0.0));
+    let k = rect_kind(a, w, h, rot, fillet, ch, width, f64_or(p, "elevation", 0.0));
     let hd = s.add_entity(k)?;
-    // A rectangle has its own thickness option and does not take THICKNESS.
     let th = f64_or(p, "thickness", 0.0);
-    s.doc_mut()?.modify_entity(hd, |e| e.common.thickness = th)?;
+    if th != 0.0 {
+        s.doc_mut()?.modify_entity(hd, |e| e.common.thickness = th)?;
+    }
     added(hd)
 }
 
@@ -1663,8 +1654,6 @@ enum RAsk {
 #[derive(Default)]
 pub(crate) struct RectM2 {
     first: Option<Vec2>,
-    /// The first point is the rectangle's centre (the `Center` option), not a corner.
-    center: bool,
     fillet: f64,
     chamfer: (f64, f64),
     width: f64,
@@ -1677,36 +1666,23 @@ pub(crate) struct RectM2 {
 }
 
 impl RectM2 {
-    /// Adds the rectangle of full size `w` × `h` with the collected options, drawing it from
-    /// the centre when centre mode is on, then applies the requested thickness.
     fn make(&self, s: &mut Session, w: f64, h: f64) -> Result<Step> {
         let Some(a) = self.first else { return Ok(Step::Cancel) };
         if w.abs() < 1e-12 || h.abs() < 1e-12 {
             return Err(other("The rectangle has no area."));
         }
-        let first = self.origin(w, h).unwrap_or(a);
-        let hd = s.add_entity(rect_kind(first, (w, h), self.rotation, self.fillet, self.chamfer, self.width, self.elevation))?;
-        // A rectangle has its own thickness option and does not take THICKNESS.
-        let t = self.thickness;
-        s.doc_mut()?.modify_entity(hd, |e| e.common.thickness = t)?;
+        let hd = s.add_entity(rect_kind(a, w, h, self.rotation, self.fillet, self.chamfer, self.width, self.elevation))?;
+        if self.thickness != 0.0 {
+            let t = self.thickness;
+            s.doc_mut()?.modify_entity(hd, |e| e.common.thickness = t)?;
+        }
         Ok(Step::Done)
     }
-    /// The rectangle's local origin (the corner `rect_kind` draws from) for a size: the first
-    /// point itself as a corner, or the first point less half the size around the centre.
-    fn origin(&self, w: f64, h: f64) -> Option<Vec2> {
-        let a = self.first?;
-        Some(if self.center { a - Vec2::new(w / 2.0, h / 2.0).rotate(self.rotation) } else { a })
-    }
-    /// The rectangle's signed full size implied by the picked point `p`: explicit `dims` only
-    /// take their quadrant from `p`, otherwise `p` is a corner, doubled about the centre in
-    /// centre mode.
     fn other_corner(&self, p: Vec2) -> Option<(f64, f64)> {
         let a = self.first?;
         let loc = (p - a).rotate(-self.rotation);
         Some(match self.dims {
             Some((l, w)) => (if loc.x < 0.0 { -l } else { l }, if loc.y < 0.0 { -w } else { w }),
-            // In centre mode the picked point is one corner, mirrored across the centre.
-            None if self.center => (2.0 * loc.x, 2.0 * loc.y),
             None => (loc.x, loc.y),
         })
     }
@@ -1716,8 +1692,6 @@ impl Interactive for RectM2 {
     fn name(&self) -> &'static str {
         "RECTANG"
     }
-    /// Asks for the pending option's value, or for the first and second points; in centre mode
-    /// the first prompt asks for the centre instead of a corner.
     fn prompt(&self, _s: &Session) -> Prompt {
         let num = |m: &str, d: f64| Prompt::new(m, Accept::NUMBER).default(format!("{d:.4}"));
         if let Some(a) = self.asking {
@@ -1743,15 +1717,10 @@ impl Interactive for RectM2 {
             };
         }
         match self.first {
-            None => {
-                let msg = if self.center { "Specify center point for rectangle" } else { "Specify first corner point" };
-                Prompt::new(msg, Accept::POINT).kw(&["Chamfer", "CEnter", "Elevation", "Fillet", "Thickness", "Width"])
-            }
+            None => Prompt::new("Specify first corner point", Accept::POINT).kw(&["Chamfer", "Elevation", "Fillet", "Thickness", "Width"]),
             Some(p) => Prompt::new("Specify other corner point", Accept::POINT).kw(&["Area", "Dimensions", "Rotation"]).corner(p),
         }
     }
-    /// Consumes one input: option keywords (`Center` only switches the first point's meaning
-    /// to the centre and asks nothing), option values, and the points that size the rectangle.
     fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
         if let Some(a) = self.asking {
             let val = |i: &Input, default: f64| -> Result<f64> {
@@ -1825,11 +1794,6 @@ impl Interactive for RectM2 {
         }
         match i {
             Input::Keyword(k) => {
-                // `Center` only switches the first point's meaning; it asks nothing.
-                if k == "CEnter" {
-                    self.center = true;
-                    return Ok(Step::Continue);
-                }
                 self.asking = Some(match k.as_str() {
                     "Chamfer" => RAsk::Chamfer1,
                     "Elevation" => RAsk::Elevation,
@@ -1856,15 +1820,13 @@ impl Interactive for RectM2 {
             _ => Ok(Step::Continue),
         }
     }
-    /// The rubber-band rectangle for the cursor at `c`, mapped through the same size-and-origin
-    /// rules as the committed entity so centre mode previews where it will land.
     fn preview(&self, _s: &Session, c: Vec2) -> Vec<EntityKind> {
         if self.asking.is_some() {
             return Vec::new();
         }
-        match self.other_corner(c).and_then(|(w, h)| self.origin(w, h).map(|a| (a, w, h))) {
-            Some((a, w, h)) if w.abs() > 1e-12 && h.abs() > 1e-12 => {
-                vec![rect_kind(a, (w, h), self.rotation, self.fillet, self.chamfer, self.width, self.elevation)]
+        match (self.first, self.other_corner(c)) {
+            (Some(a), Some((w, h))) if w.abs() > 1e-12 && h.abs() > 1e-12 => {
+                vec![rect_kind(a, w, h, self.rotation, self.fillet, self.chamfer, self.width, self.elevation)]
             }
             _ => Vec::new(),
         }

crates/engine/src/cmd/draw2/breakline.rs

@@ -9,11 +9,10 @@ use cadcraft_doc::{Drawing, EntityKind};
 use cadcraft_geom::{PolyVertex, Vec2};
 use serde_json::Value;
 
-use super::super::machines::number;
 use super::added;
 use super::curves::MAX_GEN;
-use super::{CommandSpec, line, lwpoly, point_param, point_req, size_param, str_param};
-
+use super::machines::number;
+use super::*;
 use crate::cmd::modify2::as_lwpoly;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 

crates/engine/src/cmd/draw2/mline.rs

@@ -9,11 +9,9 @@ use cadcraft_doc::{
 use cadcraft_geom::{Line, Vec2, line_line_infinite};
 use serde_json::{Value, json};
 
-use super::super::machines::number;
-use super::super::{distinct_points, ok};
 use super::curves::{self, MAX_GEN};
-use super::{CommandSpec, bad, bool_or, f64_or, point_req, points_param, str_param};
-
+use super::machines::number;
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/draw2_tests.rs

@@ -566,7 +566,6 @@ fn xline_options_command_line() {
 
 // ---------------- RECTANG ----------------
 
-/// The corners of the rectangle just added, so a test can assert its bounds.
 fn rect_pts(s: &Session) -> Vec<Vec2> {
     match last(s) {
         EntityKind::LwPolyline(p) => p.vertices.iter().map(|v| v.p).collect(),
@@ -623,111 +622,6 @@ fn rectang_options_command_line() {
     }
 }
 
-/// Guards the JSON `center: true` form for every sizing route: a picked corner mirrored about
-/// the centre, full-size `dimensions`, full `area`, rotation about the centre, that the default
-/// corner mode is untouched, and that centre mode without a size is rejected.
-#[test]
-fn rectang_center_mode_json() {
-    let mut s = Session::new();
-    // The first point is the centre; the second is a corner mirrored about it.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "p2": [14, 16]})).unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Dimensions are the rectangle's full size, still centred on the first point.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "dimensions": [8, 12]})).unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // A second point only picks the quadrant.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "dimensions": [8, 12], "p2": [0, 0]})).unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // The area is the full area, centred too.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "area": 96, "length": 8})).unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Rotation is about the centre.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "dimensions": [8, 12], "rotation": 90})).unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 4.0, 6.0) && near(b.max, 16.0, 14.0), "{b:?}");
-    // The default corner mode is unchanged.
-    s.execute("rectang", &json!({"p1": [10, 10], "p2": [14, 16]})).unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 10.0, 10.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Centre mode still needs a size.
-    assert!(s.execute("rectang", &json!({"center": true, "p1": [10, 10]})).is_err());
-}
-
-/// Guards that fillet, chamfer, width and thickness still apply in centre mode, and that an
-/// oversized fillet falls back to sharp corners without moving the rectangle off centre.
-#[test]
-fn rectang_center_mode_honours_options() {
-    let mut s = Session::new();
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "p2": [14, 16], "fillet": 1, "width": 0.25, "thickness": 2})).unwrap();
-    match &s.doc().unwrap().model.last().unwrap().kind {
-        EntityKind::LwPolyline(p) => assert!(p.vertices.len() == 8 && p.const_width == 0.25),
-        k => panic!("{k:?}"),
-    }
-    assert_eq!(s.doc().unwrap().model.last().unwrap().common.thickness, 2.0);
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Chamfer, still centred.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "p2": [14, 16], "chamfer": [1, 1]})).unwrap();
-    assert_eq!(rect_pts(&s).len(), 8);
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // A fillet too large for the rectangle falls back to sharp corners, still centred.
-    s.execute("rectang", &json!({"center": true, "p1": [10, 10], "p2": [14, 16], "fillet": 5})).unwrap();
-    assert_eq!(rect_pts(&s).len(), 4);
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-}
-
-/// Guards the `Center` keyword at the command line, before or after other options, with
-/// dimensions and area still centred, the prompt wording and centred rubber band, and that the
-/// default corner mode is unchanged.
-#[test]
-fn rectang_center_mode_command_line() {
-    let mut s = Session::new();
-    s.cmdline("rectang ce 10,10 14,16").unwrap();
-    assert!(s.running.is_none(), "{}", s.prompt_text());
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Options before the centre point, and the centre picked after them.
-    s.cmdline("rectang center f 1 w 0.1 10,10 14,16").unwrap();
-    match &s.doc().unwrap().model.last().unwrap().kind {
-        EntityKind::LwPolyline(p) => assert!(p.vertices.len() == 8 && p.const_width == 0.1),
-        k => panic!("{k:?}"),
-    }
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Dimensions after the centre: the pick only chooses the quadrant.
-    s.cmdline("rectang ce 10,10 d 8 12 14,16").unwrap();
-    assert!(s.running.is_none(), "{}", s.prompt_text());
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // Area too: the rectangle of that area is centred on the first point.
-    s.cmdline("rectang ce 10,10 a 96 l 8").unwrap();
-    assert!(s.running.is_none(), "{}", s.prompt_text());
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 6.0, 4.0) && near(b.max, 14.0, 16.0), "{b:?}");
-    // The rubber band is centred while the second point is picked.
-    s.start("rectang").unwrap();
-    s.cmdline("ce").unwrap();
-    assert!(s.prompt_text().contains("Specify center point for rectangle"), "{}", s.prompt_text());
-    s.cmdline("10,10").unwrap();
-    let pv = s.preview(Vec2::new(14.0, 16.0));
-    let pb = match pv.first().map(|e| &e.kind) {
-        Some(EntityKind::LwPolyline(p)) => cadcraft_geom::Bounds2::from_points(p.vertices.iter().map(|v| v.p).collect::<Vec<_>>()),
-        k => panic!("{k:?}"),
-    };
-    assert!(near(pb.min, 6.0, 4.0) && near(pb.max, 14.0, 16.0), "{pb:?}");
-    s.cancel();
-    // The default corner mode is unchanged.
-    s.cmdline("rectang 10,10 14,16").unwrap();
-    let b = cadcraft_geom::Bounds2::from_points(rect_pts(&s));
-    assert!(near(b.min, 10.0, 10.0) && near(b.max, 14.0, 16.0), "{b:?}");
-}
-
 // ---------------- 3DPOLY / MLINE / HELIX / SPLINE CV ----------------
 
 #[test]

crates/engine/src/cmd/draworder.rs

@@ -8,8 +8,7 @@ use cadcraft_doc::{EntityKind, Handle};
 use serde_json::{Value, json};
 
 use super::machines::{SelOutcome, SelectPhase, SelectRun};
-use super::{CommandSpec, EngineError, bad, ok, targets};
-
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/edit.rs

@@ -5,8 +5,7 @@ use cadcraft_geom::{Bounds2, Mat3, Vec2};
 use serde_json::{Value, json};
 
 use super::machines::{SelOutcome, SelectPhase, SelectRun};
-use super::{CommandSpec, EngineError, bad, bool_or, clipboard, f64_or, has_selection, point_param, point_req, points_param, str_param, targets};
-
+use super::*;
 use crate::undoctl::Control;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
@@ -27,10 +26,6 @@ pub fn specs() -> Vec<CommandSpec> {
             .key("Cmd+X")
             .params("{handles?}")
             .interactive(|_| Ok(Box::new(SelectRun::new("cutclip", "CUTCLIP")))),
-        CommandSpec::new("cutbase", "Cut with Base Point", run_cutbase)
-            .menu(&["Edit", "Cut with Base Point"])
-            .params("{handles?, base: [x,y]}")
-            .interactive(|_| Ok(Box::new(CopyBaseM { cut: true, ..CopyBaseM::default() }))),
         CommandSpec::new("copyclip", "Copy", run_copyclip)
             .menu(&["Edit", "Copy"])
             .key("Cmd+C")
@@ -439,11 +434,9 @@ impl Interactive for MredoM {
     }
 }
 
-/// Copy the objects of `hs` to the clipboard, each once however often `hs` lists it.
 fn copy_to_clip(s: &mut Session, hs: &[Handle], base: Option<Vec2>) -> Result<usize> {
     let d = s.doc()?;
-    let mut seen = std::collections::HashSet::new();
-    let ents: Vec<Entity> = hs.iter().filter(|h| seen.insert(**h)).filter_map(|h| d.entity(*h).map(|e| (**e).clone())).collect();
+    let ents: Vec<Entity> = hs.iter().filter_map(|h| d.entity(*h).map(|e| (**e).clone())).collect();
     let b = ents.iter().fold(Bounds2::EMPTY, |acc, e| acc.union(&entity_bounds(d, e, 0)));
     let base = base.unwrap_or(if b.min.is_finite() { b.min } else { Vec2::ZERO });
     let n = ents.len();
@@ -458,59 +451,22 @@ fn run_copyclip(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn run_copybase(s: &mut Session, p: &Value) -> Result<Value> {
-    let base = point_req("copybase", p, "base")?;
     let hs = targets(s, p)?;
-    let n = copy_to_clip(s, &hs, Some(base))?;
+    let base = point_param(p, "base");
+    let n = copy_to_clip(s, &hs, base)?;
     Ok(json!({ "copied": n }))
 }
 
-/// Copy the objects that are not on locked layers to the clipboard and erase them. Returns how
-/// many were cut and the message to show: how many were on a locked layer, and that nothing was
-/// cut when that is all of them (the clipboard then keeps what it held).
-fn cut_to_clip(s: &mut Session, hs: &[Handle], base: Option<Vec2>) -> Result<(usize, Option<String>)> {
-    let mut seen = std::collections::HashSet::new();
-    let live: Vec<Handle> = {
-        let d = s.doc()?;
-        hs.iter().copied().filter(|h| seen.insert(*h) && d.entity(*h).is_some()).collect()
-    };
-    let (hs, locked): (Vec<Handle>, Vec<Handle>) = live.into_iter().partition(|h| !super::curves::is_locked(s, *h));
-    let note = match locked.len() {
-        0 => None,
-        1 => Some("1 object was on a locked layer.".to_string()),
-        n => Some(format!("{n} objects were on a locked layer.")),
-    };
-    if hs.is_empty() {
-        let msg = note.map_or_else(|| "Nothing was cut.".to_string(), |m| format!("{m} Nothing was cut."));
-        return Ok((0, Some(msg)));
-    }
-    let n = copy_to_clip(s, &hs, base)?;
+fn run_cut(s: &mut Session, p: &Value) -> Result<Value> {
+    let mut hs = targets(s, p)?;
+    hs.retain(|h| !super::curves::is_locked(s, *h));
+    let n = copy_to_clip(s, &hs, None)?;
     let d = s.doc_mut()?;
     for h in &hs {
         d.remove_entity(*h);
     }
     s.set_selection(Vec::new());
-    Ok((n, note))
-}
-
-fn cut_result(n: usize, msg: Option<String>) -> Value {
-    let mut r = json!({ "cut": n });
-    if let Some(m) = msg {
-        r["message"] = json!(m);
-    }
-    r
-}
-
-fn run_cut(s: &mut Session, p: &Value) -> Result<Value> {
-    let hs = targets(s, p)?;
-    let (n, msg) = cut_to_clip(s, &hs, None)?;
-    Ok(cut_result(n, msg))
-}
-
-fn run_cutbase(s: &mut Session, p: &Value) -> Result<Value> {
-    let base = point_req("cutbase", p, "base")?;
-    let hs = targets(s, p)?;
-    let (n, msg) = cut_to_clip(s, &hs, Some(base))?;
-    Ok(cut_result(n, msg))
+    Ok(json!({ "cut": n }))
 }
 
 /// Paste the clipboard moved by `offset` (the clipboard brings the layers, styles and blocks its
@@ -693,31 +649,23 @@ impl Interactive for SelectM {
     }
 }
 
-/// COPYBASE and CUTBASE: base point first, then "Select objects:" (skipped with a pickfirst
-/// selection). CUTBASE also erases the objects it copies.
+/// COPYBASE: base point first, then "Select objects:" (skipped with a pickfirst selection).
 #[derive(Default)]
 struct CopyBaseM {
     base: Option<Vec2>,
     sel: SelectPhase,
-    cut: bool,
 }
 
 impl CopyBaseM {
     fn copy(&self, s: &mut Session, hs: &[Handle]) -> Result<Step> {
-        if self.cut {
-            if let (_, Some(m)) = cut_to_clip(s, hs, self.base)? {
-                s.echo(m);
-            }
-        } else {
-            copy_to_clip(s, hs, self.base)?;
-        }
+        copy_to_clip(s, hs, self.base)?;
         Ok(Step::Done)
     }
 }
 
 impl Interactive for CopyBaseM {
     fn name(&self) -> &'static str {
-        if self.cut { "CUTBASE" } else { "COPYBASE" }
+        "COPYBASE"
     }
     fn begin(&mut self, s: &mut Session) -> Result<Step> {
         self.sel = SelectPhase::begin(s);

crates/engine/src/cmd/exchange.rs

@@ -18,8 +18,7 @@ use cadcraft_render::raster::{RasterOptions, View};
 use serde_json::{Value, json};
 
 use super::file::{base64_decode, base64_encode, io};
-use super::{CommandSpec, bad, point_value, str_param};
-
+use super::*;
 use crate::{EngineError, Result, Session};
 
 /// Formats EXPORT writes (the io layer picks the writer from the extension).
@@ -86,25 +85,11 @@ fn write_file(cmd: &str, path: &str, bytes: &[u8]) -> Result<()> {
     }
     #[cfg(target_arch = "wasm32")]
     {
-        deliver_file(cmd, path, bytes, super::file::deliver())
+        let _ = (path, bytes);
+        Err(bad(cmd, "paths are not available on the web; omit `path` to get the file as base64 `data`"))
     }
 }
 
-/// No file system on the web: hand the bytes to the host's delivery hook (a browser download)
-/// named after `path`, like SAVE and TABLEEXPORT do. EXPORT and PLOT (PUBLISH, EXPORTPDF) use it.
-#[cfg(any(test, target_arch = "wasm32"))]
-pub(super) fn deliver_file(cmd: &str, path: &str, bytes: &[u8], hook: Option<super::file::DeliverHook>) -> Result<()> {
-    let name = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());
-    let mime = match extension(&name).as_str() {
-        "svg" => "image/svg+xml",
-        "png" => "image/png",
-        "pdf" => "application/pdf",
-        _ => "application/octet-stream",
-    };
-    let deliver = hook.ok_or_else(|| bad(cmd, "files can't be written in this build; omit `path` to get the file as base64 `data`"))?;
-    deliver(&name, mime, bytes).map_err(|e| bad(cmd, format!("{name}: {e}")))
-}
-
 // ---------- EXPORT ----------
 
 fn run_export(s: &mut Session, p: &Value) -> Result<Value> {
@@ -558,27 +543,7 @@ mod tests {
     use cadcraft_geom::Vec3;
 
     use super::super::file::{IoHooks, set_io};
-
-    use super::super::resolve_alias;
     use super::*;
-    use serde_json::json;
-
-    static DELIVERED: std::sync::Mutex<Vec<(String, String, usize)>> = std::sync::Mutex::new(Vec::new());
-
-    fn record(name: &str, mime: &str, bytes: &[u8]) -> std::result::Result<(), String> {
-        DELIVERED.lock().map_err(|e| e.to_string())?.push((name.into(), mime.into(), bytes.len()));
-        Ok(())
-    }
-
-    #[test]
-    fn web_export_delivers_a_download_instead_of_writing_a_path() {
-        deliver_file("export", "Drawing1.svg", b"<svg/>", Some(record)).unwrap();
-        deliver_file("export", "dir/Plan.pdf", b"%PDF", Some(record)).unwrap();
-        let got = DELIVERED.lock().unwrap().clone();
-        assert_eq!(got, [("Drawing1.svg".to_string(), "image/svg+xml".to_string(), 6), ("Plan.pdf".to_string(), "application/pdf".to_string(), 4)]);
-        let e = deliver_file("export", "a.svg", b"x", None).unwrap_err().to_string();
-        assert!(e.contains("base64"), "{e}");
-    }
 
     fn fake_plot(_: &Drawing, space: &Space, opts: &Value) -> std::result::Result<Vec<u8>, String> {
         // Same output as the layout tests' stand-in: whichever test installs first wins.

crates/engine/src/cmd/file.rs

@@ -11,8 +11,7 @@ use cadcraft_doc::Drawing;
 pub use cadcraft_dxf::Version;
 use serde_json::{Value, json};
 
-use super::{CommandSpec, EngineError, Interactive, always, bad, bool_or, find_command, ok, str_param};
-
+use super::*;
 use crate::{Accept, Input, Prompt, Result, Session, Step};
 
 /// The rules the Command Aliases dialog checks before it sends an alias to ALIASEDIT.
@@ -164,7 +163,7 @@ pub fn specs() -> Vec<CommandSpec> {
             .menu(&["File", "New Drawing..."])
             .key("Cmd+N")
             .alias(&["qnew"])
-            .params("{metric?: bool (default MEASUREINIT), template?: path to a .dwt/.dxf template (\".\" for none; default QNEWTEMPLATE)}")
+            .params("{metric?: bool, template?: path to a .dwt/.dxf template (\".\" for none; default QNEWTEMPLATE)}")
             .enabled(always)
             .noundo(),
         CommandSpec::new("open", "Open...", run_open)
@@ -253,8 +252,7 @@ fn run_new(s: &mut Session, p: &Value) -> Result<Value> {
     if let Some(r) = template::run_new(s, p)? {
         return Ok(r);
     }
-    let metric = s.settings.measureinit;
-    let i = s.new_drawing(bool_or(p, "metric", metric));
+    let i = s.new_drawing(bool_or(p, "metric", false));
     Ok(json!({ "index": i, "title": s.docs.get(i).map(|d| d.title.clone()) }))
 }
 
@@ -363,7 +361,6 @@ fn run_open(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(opened(s, i, false))
 }
 
-/// `close [index]`: cancel the running command, remove the drawing (default: active), keep the active index valid, and bump the document epoch; an unknown index is an error.
 fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
     let i = p.get("index").and_then(Value::as_u64).map(|i| i as usize).unwrap_or(s.active);
     if i >= s.docs.len() {
@@ -378,16 +375,13 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
     if s.active >= s.docs.len() {
         s.active = s.docs.len().saturating_sub(1);
     }
-    s.bump_doc_epoch();
     ok()
 }
 
-/// `closeall`: cancel the running command, remove every drawing, reset the active index to 0 and bump the document epoch.
 fn run_closeall(s: &mut Session, _p: &Value) -> Result<Value> {
     s.cancel();
     s.docs.clear();
     s.active = 0;
-    s.bump_doc_epoch();
     ok()
 }
 
@@ -492,7 +486,6 @@ fn drawing_version(s: &Session, path: &str) -> Version {
     if is_dxf(path) { v } else { v.max(Version::R2004) }
 }
 
-/// `document.switch index`: require the index, cancel the running command, activate that drawing and bump the epoch even if it was already active (screenshot identity).
 fn run_switch(s: &mut Session, p: &Value) -> Result<Value> {
     let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad("document.switch", "`index` is required"))? as usize;
     if i >= s.docs.len() {
@@ -500,11 +493,6 @@ fn run_switch(s: &mut Session, p: &Value) -> Result<Value> {
     }
     s.cancel();
     s.active = i;
-    // Bump even when `i` is already active. This is intentionally conservative: the command
-    // cancels the active command, and a screenshot client can only see observed state, not
-    // whether the switch was a no-op. Rejecting an outstanding capture is safer than returning
-    // an image whose queueing identity the client cannot distinguish from a real switch.
-    s.bump_doc_epoch();
     ok()
 }
 
@@ -732,7 +720,6 @@ mod tests {
 #[cfg(test)]
 mod pr193_tests {
     use super::*;
-    use crate::Session;
 
     #[test]
     fn failed_store_keeps_unsaved_changes_and_delivered_save_clears_them() {

crates/engine/src/cmd/file/compare.rs

@@ -2,7 +2,7 @@
 //! drawing). Objects are matched by geometry and properties first (preferring the same handle),
 //! then by handle: the same handle with other geometry or properties is a change. What is left
 //! is only in this drawing or only in the other. The comparison stays on the session for the
-//! canvas overlay, next/previous navigation and COMPAREEXPORT until COMPARECLOSE.
+//! canvas overlay and next/previous navigation until COMPARECLOSE.
 
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
@@ -12,13 +12,10 @@ use cadcraft_doc::{Drawing, Entity, EntityKind, Handle, MAX_BLOCK_DEPTH, Space,
 use cadcraft_geom::{Bounds2, Vec2};
 use serde_json::{Value, json};
 
-use super::super::{CommandSpec, bad, str_param};
-
+use super::super::*;
 use super::{base64_decode, io};
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
-mod export;
-
 /// Objects compared per drawing; more are left out (and the result says so).
 pub const MAX_OBJECTS: usize = 200_000;
 /// Objects listed per kind of difference in the JSON result.
@@ -39,9 +36,6 @@ pub struct Comparison {
     pub other_name: String,
     /// The other drawing (its objects are drawn where they differ).
     pub other: Arc<Drawing>,
-    /// The other drawing's file, when it has one: COMPAREEXPORT resolves its relative xref
-    /// paths from that file's folder.
-    pub other_path: Option<String>,
     /// Only in this drawing (handles here).
     pub added: Vec<Handle>,
     /// Only in the other drawing (handles there).
@@ -77,7 +71,6 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("compare.next", "Next Change", |s, _| step(s, 1)).params("→ {region, of}: zoom to the next area with changes").noundo(),
         CommandSpec::new("compare.previous", "Previous Change", |s, _| step(s, -1)).params("→ {region, of}").noundo(),
         CommandSpec::new("compareclose", "Close Comparison", run_close).params("{}: end the comparison and its overlay").noundo(),
-        export::spec(),
     ]
 }
 
@@ -140,23 +133,11 @@ struct Signer<'a> {
     d: &'a Drawing,
     blocks: HashMap<String, u64>,
     work: usize,
-    /// When set, a block's signature also covers its base point, units, annotative and overlay
-    /// flags and xref file, with relative xref, image and data link paths taken from the folder
-    /// given, and the
-    /// signatures of a multileader and a dimension cover their blocks'. Each object in a block
-    /// then also counts with its visibility, transparency, thickness and extrusion, and an
-    /// anonymous block's signature leaves out its name (a dimension also leaves its block's name
-    /// out of its own geometry; an INSERT or MLEADER keeps it).
-    frames: Option<Option<&'a std::path::Path>>,
 }
 
 impl<'a> Signer<'a> {
     fn new(d: &'a Drawing) -> Self {
-        Signer { d, blocks: HashMap::new(), work: 0, frames: None }
-    }
-    /// A signer whose block signatures also cover what changes how a reference draws the block.
-    fn with_frames(d: &'a Drawing, folder: Option<&'a std::path::Path>) -> Self {
-        Signer { frames: Some(folder), ..Signer::new(d) }
+        Signer { d, blocks: HashMap::new(), work: 0 }
     }
     fn geometry(&mut self, k: &EntityKind, depth: usize) -> u64 {
         let mut h = std::collections::hash_map::DefaultHasher::new();
@@ -175,18 +156,6 @@ impl<'a> Signer<'a> {
         if let EntityKind::Insert(i) = k {
             self.block(&i.block, depth).hash(&mut h);
         }
-        if self.frames.is_some()
-            && let EntityKind::MLeader(m) = k
-            && let Some(b) = &m.block
-        {
-            self.block(&b.block, depth).hash(&mut h);
-        }
-        if self.frames.is_some()
-            && let EntityKind::Dimension(dm) = k
-            && let Some(b) = &dm.block
-        {
-            self.block(b, depth).hash(&mut h);
-        }
         h.finish()
     }
     fn block(&mut self, name: &str, depth: usize) -> u64 {
@@ -195,42 +164,17 @@ impl<'a> Signer<'a> {
             return *v;
         }
         let mut h = std::collections::hash_map::DefaultHasher::new();
-        let block = self.d.block(name);
-        // With frames, an anonymous block (`*D3`, `*U7`) is signed by its contents only: the
-        // same block can have another generated name in another drawing. Only a dimension's
-        // geometry leaves the name out, so this matches renamed `*D` blocks, not `*U` references.
-        if !(self.frames.is_some() && block.is_some_and(|b| b.anonymous)) {
-            key.hash(&mut h);
-        }
+        key.hash(&mut h);
         if depth < MAX_BLOCK_DEPTH
-            && let Some(b) = block
+            && let Some(b) = self.d.block(name)
         {
-            if let Some(folder) = self.frames {
-                let mut xref = b.xref_path.clone();
-                if let Some(x) = xref.as_mut() {
-                    export::rebase_path(x, folder);
-                }
-                (format!("{:?}", b.base), b.units, b.annotative, b.xref_overlay, xref).hash(&mut h);
-            }
             for e in b.entities.iter() {
                 if self.work >= MAX_BLOCK_WORK {
                     break;
                 }
                 self.work += 1;
-                match self.frames {
-                    // An image's file and a table's data link, from the folder given.
-                    Some(folder) if matches!(e.kind, EntityKind::Image(_) | EntityKind::Table(_)) => {
-                        let mut k = e.kind.clone();
-                        export::rebase(&mut k, folder);
-                        self.geometry(&k, depth + 1).hash(&mut h);
-                    }
-                    _ => self.geometry(&e.kind, depth + 1).hash(&mut h),
-                }
+                self.geometry(&e.kind, depth + 1).hash(&mut h);
                 properties(e).hash(&mut h);
-                if self.frames.is_some() {
-                    let c = &e.common;
-                    format!("{:?}|{}|{}|{:?}", c.transparency, c.visible, (c.thickness * 1e6).round(), c.extrusion).hash(&mut h);
-                }
             }
         }
         let v = h.finish();
@@ -367,7 +311,6 @@ fn listed(d: &Drawing, hs: &[Handle]) -> Vec<Value> {
 
 fn run_compare(s: &mut Session, p: &Value) -> Result<Value> {
     let (other, name) = other_drawing(s, p)?;
-    let other_path = export::source_path(s, p, &other);
     let st = s.state()?;
     let (uid, space, cur) = (st.uid, st.space.clone(), st.doc.clone());
     if Arc::ptr_eq(&cur, &other) {
@@ -418,7 +361,7 @@ fn run_compare(s: &mut Session, p: &Value) -> Result<Value> {
         "message": message,
     });
     let changed = changed.into_iter().map(|(a, b, _, _)| (a, b)).collect();
-    s.compare = Some(Comparison { uid, space, other_name: name, other, other_path, added, removed, changed, common, truncated, regions, at: None });
+    s.compare = Some(Comparison { uid, space, other_name: name, other, added, removed, changed, common, truncated, regions, at: None });
     s.touch();
     Ok(out)
 }

crates/engine/src/cmd/file/compare/export.rs

@@ -1,684 +0,0 @@
-//! COMPAREEXPORT: the comparison as a new drawing (a snapshot). The drawings are compared again
-//! when the command runs, so edits made since COMPARE count. The new drawing's model space holds
-//! copies of the other drawing's objects that differ, then copies of the current drawing's
-//! objects in the compared tab, as two groups, `COMPARE_COMPARED` and `COMPARE_CURRENT`. Objects
-//! only in this drawing or changed in it are drawn in the overlay's green, objects only in the
-//! other drawing or changed there in its red, and objects in both in gray (color 8). A block
-//! reference, dimension or multileader refers to a copy of its block whose objects all have that
-//! color (`COMPARE_CURRENT_<name>`, `COMPARE_COMPARED_<name>`, `COMPARE_COMMON_<name>`; for a
-//! dimension's `*D` block, another `*D` block), and a table or tolerance uses a recolored copy
-//! of its style; xrefs keep their own colors. The new
-//! drawing has this drawing's layers, styles and blocks, plus the layers and styles of the other
-//! drawing that this one lacks and the blocks its copied objects refer to; an anonymous block of
-//! the other drawing whose name this one uses is copied under a free name. Relative xref, image
-//! and data link paths become absolute paths from the folder of the drawing they came from. It
-//! opens untitled as `compare_<this> vs <other>.dwg`, with unsaved changes; saving it asks for a
-//! file name.
-
-use std::collections::{HashMap, HashSet};
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
-use cadcraft_doc::color::{Color, Rgb};
-use cadcraft_doc::{Block, CellStyle, DimStyle, Drawing, Entity, EntityKind, EntityStore, Group, Handle, MAX_BLOCK_DEPTH, TableStyle};
-use serde_json::{Value, json};
-
-use super::super::super::{CommandSpec, bad};
-use super::{Comparison, MAX_OBJECTS};
-use crate::{Result, Session};
-
-/// Only in this drawing, or changed in it (the overlay's color).
-const THIS: Color = Color::True(Rgb(0x4c, 0xd9, 0x7b));
-/// Only in the other drawing, or changed there.
-const OTHER: Color = Color::True(Rgb(0xff, 0x5c, 0x5c));
-/// In both drawings.
-const COMMON: Color = Color::Index(8);
-/// Block definitions copied from the other drawing (the ones they reference included), and
-/// recolored copies of blocks and styles, per export.
-const MAX_BLOCKS: usize = 10_000;
-/// Objects copied into block definitions (the other drawing's blocks and the recolored
-/// copies), per export.
-const MAX_COPIED: usize = 1_000_000;
-
-pub(super) fn spec() -> CommandSpec {
-    CommandSpec::new("compareexport", "Export Comparison", run)
-        .params(
-            "{} → {index, title, current, compared: group names, counts: {current, compared}, truncated, message}: the comparison \
-             as a new drawing, opened untitled",
-        )
-        .noundo()
-}
-
-/// What [`snapshot`] made: the drawing, the two group names, how many objects each holds,
-/// whether a drawing had more objects than were compared, whether the other drawing had more
-/// blocks to copy than [`MAX_BLOCKS`], and whether a block was left in its own colors.
-struct Snapshot {
-    drawing: Drawing,
-    current: String,
-    compared: String,
-    counts: (usize, usize),
-    truncated: bool,
-    blocks_left_out: bool,
-    uncolored: bool,
-}
-
-fn run(s: &mut Session, _p: &Value) -> Result<Value> {
-    let st = s.state()?;
-    let (uid, cur, title, cur_folder) = (st.uid, st.doc.clone(), st.title.clone(), folder_of(st.path.as_deref()));
-    let c = s.compare.as_ref().filter(|c| c.uid == uid).ok_or_else(|| bad("compareexport", "no comparison: run COMPARE first"))?;
-    let name = format!("compare_{} vs {}.dwg", stem(&title), stem(&c.other_name));
-    let folders = Folders { here: cur_folder, there: folder_of(c.other_path.as_deref()) };
-    let Snapshot { drawing, current, compared, counts, truncated, blocks_left_out, uncolored } = snapshot(&cur, c, &folders);
-    let i = s.open_drawing(drawing, &name, None);
-    // Not saved yet: closing it asks to save it under a name.
-    let st = s.state_mut()?;
-    st.saved = Arc::new((*st.doc).clone());
-    let mut notes = Vec::new();
-    if truncated {
-        notes.push(format!("only the first {MAX_OBJECTS} objects of each drawing were compared"));
-    }
-    if blocks_left_out {
-        notes.push("some blocks of the other drawing were too many or too large to copy".to_string());
-    }
-    if uncolored {
-        notes.push("some blocks keep their own colors".to_string());
-    }
-    let notes = if notes.is_empty() { String::new() } else { format!(" ({})", notes.join("; ")) };
-    Ok(json!({
-        "index": i,
-        "title": name,
-        "current": current,
-        "compared": compared,
-        "counts": { "current": counts.0, "compared": counts.1 },
-        "truncated": truncated || blocks_left_out || uncolored,
-        "message": format!("The comparison was exported to the new drawing {name}{notes}."),
-    }))
-}
-
-/// The file of the drawing COMPARE compares with: the `path` it was read from, or the open
-/// drawing's own file. `None` for `{data}` and for an open drawing never saved.
-pub(super) fn source_path(s: &Session, p: &Value, other: &Arc<Drawing>) -> Option<String> {
-    match p.get("path").and_then(Value::as_str) {
-        Some(path) if p.get("document").is_none_or(Value::is_null) => Some(path.to_string()),
-        _ => s.docs.iter().find(|d| Arc::ptr_eq(&d.doc, other)).and_then(|d| d.path.clone()),
-    }
-}
-
-/// The folders of the two drawings' files. The snapshot has no folder of its own, so the
-/// relative file paths it copies (xrefs, images, table data links) become absolute paths from
-/// the folder of the drawing they came from.
-struct Folders {
-    here: Option<PathBuf>,
-    there: Option<PathBuf>,
-}
-
-/// The absolute folder of the file at `path`.
-fn folder_of(path: Option<&str>) -> Option<PathBuf> {
-    let parent = Path::new(path?).parent()?;
-    let parent = if parent.as_os_str().is_empty() { Path::new(".") } else { parent };
-    Some(std::path::absolute(parent).unwrap_or_else(|_| parent.to_path_buf()))
-}
-
-/// `p` as an absolute path from `folder` when it is relative.
-pub(super) fn rebase_path(p: &mut String, folder: Option<&Path>) {
-    if let Some(folder) = folder
-        && !p.trim().is_empty()
-        && Path::new(p.as_str()).is_relative()
-    {
-        let joined = folder.join(p.as_str());
-        *p = std::path::absolute(&joined).unwrap_or(joined).to_string_lossy().to_string();
-    }
-}
-
-/// Rebase the file an object refers to: an image's file, a table's data link.
-pub(super) fn rebase(k: &mut EntityKind, folder: Option<&Path>) {
-    match k {
-        EntityKind::Image(i) => rebase_path(&mut i.path, folder),
-        EntityKind::Table(t) => {
-            if let Some(l) = t.data_link.as_mut() {
-                rebase_path(&mut l.path, folder);
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Rebase a block's xref path and the files its objects refer to.
-fn rebase_block(b: &mut Block, folder: Option<&Path>) {
-    if let Some(x) = b.xref_path.as_mut() {
-        rebase_path(x, folder);
-    }
-    let mut store = EntityStore::new();
-    for e in b.entities.iter() {
-        let mut e = (**e).clone();
-        rebase(&mut e.kind, folder);
-        store.push(e);
-    }
-    b.entities = store;
-}
-
-/// Whether a block holds a relative file path that [`rebase_block`] would change.
-fn has_relative_paths(b: &Block) -> bool {
-    let rel = |p: &str| !p.trim().is_empty() && Path::new(p).is_relative();
-    b.xref_path.as_deref().is_some_and(rel)
-        || b.entities.iter().any(|e| match &e.kind {
-            EntityKind::Image(i) => rel(&i.path),
-            EntityKind::Table(t) => t.data_link.as_ref().is_some_and(|l| rel(&l.path)),
-            _ => false,
-        })
-}
-
-/// A drawing title without its file extension.
-fn stem(title: &str) -> String {
-    std::path::Path::new(title).file_stem().map(|n| n.to_string_lossy().to_string()).filter(|n| !n.is_empty()).unwrap_or_else(|| title.to_string())
-}
-
-fn snapshot(cur: &Drawing, c: &Comparison, folders: &Folders) -> Snapshot {
-    let other: &Drawing = &c.other;
-    let mut d = cur.clone();
-    if folders.here.is_some() {
-        for b in d.blocks.values_mut().filter(|b| has_relative_paths(b)) {
-            rebase_block(Arc::make_mut(b), folders.here.as_deref());
-        }
-    }
-    d.model = EntityStore::new();
-    for l in &mut d.layouts {
-        l.entities = EntityStore::new();
-    }
-    d.foreign = Arc::default();
-    d.groups.clear();
-    d.constraints.clear();
-    // The per-object constraint bar and dimension exceptions name objects the copy doesn't have.
-    d.parametric.settings.bar_exceptions.clear();
-    d.parametric.settings.dim_exceptions.clear();
-    d.hidden_objects.clear();
-    d.read_notes.clear();
-    d.refedit = None;
-    d.skipped_records.clear();
-    d.handseed = d.handseed.max(other.handseed);
-
-    merge(&mut d.layers, &other.layers, |t| &t.name);
-    merge(&mut d.linetypes, &other.linetypes, |t| &t.name);
-    merge(&mut d.text_styles, &other.text_styles, |t| &t.name);
-    merge(&mut d.dim_styles, &other.dim_styles, |t| &t.name);
-    merge(&mut d.mleader_styles, &other.mleader_styles, |t| &t.name);
-    merge(&mut d.table_styles, &other.table_styles, |t| &t.name);
-    merge(&mut d.mline_styles, &other.mline_styles, |t| &t.name);
-
-    // Compared again, so edits made since COMPARE ran are classified as they are now.
-    let diff = super::diff(cur, other, &c.space);
-    let ours: HashSet<Handle> = diff.added.iter().copied().chain(diff.changed.iter().map(|(a, ..)| *a)).collect();
-    let here: Vec<(&Entity, Color)> = cur
-        .space(&c.space)
-        .into_iter()
-        .flat_map(EntityStore::iter)
-        .filter(|e| !matches!(e.kind, EntityKind::Viewport(_)))
-        .take(MAX_OBJECTS)
-        .map(|e| (e.as_ref(), if ours.contains(&e.handle) { THIS } else { COMMON }))
-        .collect();
-    // In the other drawing's draw order.
-    let theirs: HashSet<Handle> = diff.removed.iter().copied().chain(diff.changed.iter().map(|(_, b, ..)| *b)).collect();
-    let there: Vec<(&Entity, Color)> = other
-        .space(&c.space)
-        .into_iter()
-        .flat_map(EntityStore::iter)
-        .filter(|e| theirs.contains(&e.handle) && !matches!(e.kind, EntityKind::Viewport(_)))
-        .map(|e| (e.as_ref(), OTHER))
-        .collect();
-    let mut tinted = Tinted::default();
-    let (renames, blocks_left_out) = copy_blocks(&mut d, other, there.iter().map(|(e, _)| *e), folders.there.as_deref(), &mut tinted);
-
-    // The other drawing's objects first, so this drawing's are drawn over them.
-    let compared = add_group(&mut d, "COMPARE_COMPARED", &there, &renames, folders.there.as_deref(), &mut tinted);
-    let current = add_group(&mut d, "COMPARE_CURRENT", &here, &Renames::new(), folders.here.as_deref(), &mut tinted);
-    let uncolored = tinted.uncolored;
-    Snapshot { drawing: d, current, compared, counts: (here.len(), there.len()), truncated: diff.truncated, blocks_left_out, uncolored }
-}
-
-/// Add the entries of `from` whose names `to` lacks (compared without letter case).
-fn merge<T: Clone>(to: &mut Vec<T>, from: &[T], name: impl Fn(&T) -> &String) {
-    for t in from {
-        if !to.iter().any(|x| name(x).eq_ignore_ascii_case(name(t))) {
-            to.push(t.clone());
-        }
-    }
-}
-
-/// Add copies of `objs` to model space with new handles, their block references renamed by
-/// `renames` and their files rebased on `folder`, each painted in its comparison color, and
-/// group them as `name` (or `name_2`… when that group name is taken). Returns the group's name.
-fn add_group(d: &mut Drawing, name: &str, objs: &[(&Entity, Color)], renames: &Renames, folder: Option<&Path>, tinted: &mut Tinted) -> String {
-    let mut members = Vec::new();
-    for (e, color) in objs {
-        d.ensure_layer(&e.common.layer);
-        let h = d.new_handle();
-        let mut copy = Entity { handle: h, ..(*e).clone() };
-        detach(&mut copy.kind);
-        rebase(&mut copy.kind, folder);
-        rename_refs(&mut copy.kind, renames);
-        paint(d, &mut copy, *color, tinted, 0);
-        d.model.push(copy);
-        members.push(h);
-    }
-    let name = free_name(name, d.groups.len(), |n| d.groups.iter().any(|g| g.name.eq_ignore_ascii_case(n)));
-    if !members.is_empty() {
-        d.groups.push(Group { name: name.clone(), description: String::new(), selectable: true, members });
-    }
-    name
-}
-
-/// Drop the links of an associative dimension or hatch to the objects it follows: the copies
-/// have new handles, so the links would name objects the snapshot does not have.
-fn detach(k: &mut EntityKind) {
-    match k {
-        EntityKind::Dimension(dm) => dm.assoc.clear(),
-        EntityKind::Hatch(h) => {
-            h.associative = false;
-            h.loops.iter_mut().for_each(|l| l.sources.clear());
-        }
-        _ => {}
-    }
-}
-
-/// The block names an object refers to.
-fn block_refs(k: &EntityKind) -> Vec<String> {
-    match k {
-        EntityKind::Insert(i) => vec![i.block.clone()],
-        EntityKind::Dimension(dm) => dm.block.iter().cloned().collect(),
-        EntityKind::MLeader(m) => m.block.iter().map(|b| b.block.clone()).collect(),
-        _ => Vec::new(),
-    }
-}
-
-/// Call `f` on each block name an object refers to.
-fn each_ref(k: &mut EntityKind, mut f: impl FnMut(&mut String)) {
-    match k {
-        EntityKind::Insert(i) => f(&mut i.block),
-        EntityKind::Dimension(dm) => {
-            if let Some(n) = dm.block.as_mut() {
-                f(n);
-            }
-        }
-        EntityKind::MLeader(m) => {
-            if let Some(b) = m.block.as_mut() {
-                f(&mut b.block);
-            }
-        }
-        _ => {}
-    }
-}
-
-/// Point the block references of an object at the names its blocks were copied under.
-fn rename_refs(k: &mut EntityKind, renames: &Renames) {
-    each_ref(k, |n| {
-        if let Some(new) = renames.get(&n.to_ascii_uppercase()) {
-            n.clone_from(new);
-        }
-    });
-}
-
-/// Recolored copies of blocks and styles made so far, and whether a block was left in its own
-/// colors because the nesting or copy limit was reached.
-#[derive(Default)]
-struct Tinted {
-    /// (comparison tag, "block", "table style" or "dimension style", upper-case name) → the
-    /// copy's name.
-    names: HashMap<(&'static str, &'static str, String), String>,
-    uncolored: bool,
-    /// Objects copied into block definitions so far, counted against [`MAX_COPIED`].
-    copied: usize,
-    next: NextFree,
-    /// The drawing's block names in upper case, filled on the first block copy. Only
-    /// [`tinted_block`] adds blocks after that, and it adds their names here too.
-    blocks: Option<HashSet<String>>,
-}
-
-/// The next index to try for each name base. Names are only added while a snapshot is built,
-/// so an index found taken stays taken, and each search starts where the last one for the same
-/// base stopped: a name costs O(1) amortised instead of a scan from 1.
-#[derive(Default)]
-struct NextFree(HashMap<(&'static str, String), usize>);
-
-impl NextFree {
-    /// The first of `name(i)` for `i` from 1 that `taken` doesn't hold, skipping the indices
-    /// earlier searches for `base` in namespace `kind` passed. `n` is how many names there are,
-    /// so one of `name(1)`…`name(n + 1)` is free. The caller adds the returned name.
-    fn find(&mut self, kind: &'static str, base: &str, n: usize, name: impl Fn(usize) -> String, taken: impl Fn(&str) -> bool) -> String {
-        let key = (kind, base.to_ascii_uppercase());
-        let start = self.0.get(&key).copied().unwrap_or(1);
-        let i = (start..=n.saturating_add(1)).find(|&i| !taken(&name(i))).unwrap_or_else(|| n.saturating_add(2).max(start));
-        self.0.insert(key, i.saturating_add(1));
-        name(i)
-    }
-}
-
-/// `base` for 1, `base_2`, `base_3`… after it.
-fn suffixed(base: &str, i: usize) -> String {
-    if i == 1 { base.to_string() } else { format!("{base}_{i}") }
-}
-
-/// The word a comparison color adds to the names of its recolored copies.
-fn tag(color: Color) -> &'static str {
-    if color == THIS {
-        "CURRENT"
-    } else if color == OTHER {
-        "COMPARED"
-    } else {
-        "COMMON"
-    }
-}
-
-/// `base`, or `base_2`, `base_3`… when `taken` holds that name. `n` is how many names there are.
-fn free_name(base: &str, n: usize, taken: impl Fn(&str) -> bool) -> String {
-    (1..=n + 1).map(|i| suffixed(base, i)).find(|c| !taken(c)).unwrap_or_else(|| suffixed(base, n + 2))
-}
-
-/// Give an object its comparison color: its own color, its attributes' colors, and, through
-/// recolored copies of the blocks and styles it refers to, the color of everything they draw.
-fn paint(d: &mut Drawing, e: &mut Entity, color: Color, tinted: &mut Tinted, depth: usize) {
-    e.common.color = color;
-    let attribs = match &mut e.kind {
-        EntityKind::Insert(i) => Some(&mut i.attribs),
-        EntityKind::MLeader(m) => m.block.as_mut().map(|b| &mut b.attribs),
-        _ => None,
-    };
-    for a in attribs.into_iter().flatten() {
-        a.props.color = Some(color);
-        if let Some(ml) = a.multiline.as_mut() {
-            ml.mtext.contents = without_color_codes(&ml.mtext.contents);
-        }
-    }
-    // Colors an object carries apart from its own: inline MTEXT colors (in multiline attributes
-    // too), a dimension style's DIMCLRD, DIMCLRE and DIMCLRT, gradient colors, multiline element
-    // colors, the style colors of a table or a tolerance (through a recolored copy of the style)
-    // and inline cell colors. Hatch backgrounds, multiline fills and table cell fills are left out.
-    match &mut e.kind {
-        EntityKind::MText(t) => t.contents = without_color_codes(&t.contents),
-        EntityKind::AttDef(a) => {
-            if let Some(ml) = a.multiline.as_mut() {
-                ml.mtext.contents = without_color_codes(&ml.mtext.contents);
-            }
-        }
-        EntityKind::MLeader(m) => {
-            if let Some(t) = m.text.as_mut() {
-                t.contents = without_color_codes(&t.contents);
-            }
-        }
-        EntityKind::Dimension(dm) => {
-            if let Ok(by_block) = serde_json::to_value(Color::ByBlock) {
-                for var in ["DIMCLRD", "DIMCLRE", "DIMCLRT"] {
-                    dm.overrides.retain(|k, _| DimStyle::field_name(k) != DimStyle::field_name(var));
-                    dm.overrides.insert(var.into(), by_block.clone());
-                }
-            }
-        }
-        EntityKind::Tolerance(t) => {
-            if let Some(style) = tinted_dim_style(d, &t.style, color, tinted) {
-                t.style = style;
-            }
-        }
-        EntityKind::Hatch(h) => {
-            if let Some(g) = h.gradient.as_mut() {
-                (g.color1, g.color2) = (color, color);
-            }
-            h.background = None;
-        }
-        EntityKind::MLine(m) => {
-            for el in &mut m.def.elements {
-                el.color = Color::ByBlock;
-            }
-            m.def.fill = None;
-        }
-        EntityKind::Table(t) => {
-            for cell in t.cells.iter_mut().flatten() {
-                cell.text = without_color_codes(&cell.text);
-            }
-            if let Some(style) = tinted_table_style(d, &t.style, color, tinted) {
-                t.style = style;
-            }
-        }
-        _ => {}
-    }
-    if let EntityKind::Dimension(dm) = &mut e.kind {
-        // A dimension whose block can't be copied (past the limits) is drawn again from its
-        // geometry: its DIMCLR* overrides are ByBlock, so the original block would keep its colors.
-        dm.block = dm.block.take().and_then(|n| tinted_block(d, &n, color, tinted, depth));
-        return;
-    }
-    each_ref(&mut e.kind, |n| {
-        if let Some(copy) = tinted_block(d, n, color, tinted, depth) {
-            *n = copy;
-        }
-    });
-}
-
-/// The name of a copy of dimension style `name` that draws lines and text in the object's
-/// color, made on first use. `None` when the drawing has no such style.
-fn tinted_dim_style(d: &mut Drawing, name: &str, color: Color, tinted: &mut Tinted) -> Option<String> {
-    let key = (tag(color), "dimension style", name.to_ascii_uppercase());
-    if let Some(n) = tinted.names.get(&key) {
-        return Some(n.clone());
-    }
-    let st = d.dim_styles.iter().find(|s| s.name.eq_ignore_ascii_case(name))?.clone();
-    let base = format!("COMPARE_{}_{}", tag(color), st.name);
-    let new = tinted.next.find(
-        "dimension style",
-        &base,
-        d.dim_styles.len(),
-        |i| suffixed(&base, i),
-        |n| d.dim_styles.iter().any(|s| s.name.eq_ignore_ascii_case(n)),
-    );
-    d.dim_styles.push(DimStyle {
-        name: new.clone(),
-        dim_line_color: Color::ByBlock,
-        ext_line_color: Color::ByBlock,
-        text_color: Color::ByBlock,
-        ..st
-    });
-    tinted.names.insert(key, new.clone());
-    Some(new)
-}
-
-/// The name of a copy of table style `name` whose cell styles draw text and borders in the
-/// table's color and fill no cells, made on first use. `None` when the drawing has no such style.
-fn tinted_table_style(d: &mut Drawing, name: &str, color: Color, tinted: &mut Tinted) -> Option<String> {
-    let key = (tag(color), "table style", name.to_ascii_uppercase());
-    if let Some(n) = tinted.names.get(&key) {
-        return Some(n.clone());
-    }
-    let st = d.table_styles.iter().find(|s| s.name.eq_ignore_ascii_case(name))?.clone();
-    let base = format!("COMPARE_{}_{}", tag(color), st.name);
-    let new = tinted.next.find(
-        "table style",
-        &base,
-        d.table_styles.len(),
-        |i| suffixed(&base, i),
-        |n| d.table_styles.iter().any(|s| s.name.eq_ignore_ascii_case(n)),
-    );
-    let names =
-        [CellStyle::TITLE, CellStyle::HEADER, CellStyle::DATA].into_iter().map(str::to_string).chain(st.cell_styles.iter().map(|c| c.name.clone()));
-    let mut cell_styles: Vec<CellStyle> = Vec::new();
-    for n in names {
-        if cell_styles.iter().any(|c| c.name.eq_ignore_ascii_case(&n)) {
-            continue;
-        }
-        let mut cs = st.cell_style(&n);
-        cs.name = n;
-        cs.text_color = Color::ByBlock;
-        cs.fill = None;
-        let b = &mut cs.borders;
-        for border in [&mut b.top, &mut b.inside_h, &mut b.bottom, &mut b.left, &mut b.inside_v, &mut b.right] {
-            border.color = Color::ByBlock;
-        }
-        cell_styles.push(cs);
-    }
-    d.table_styles.push(TableStyle { name: new.clone(), cell_styles, ..st });
-    tinted.names.insert(key, new.clone());
-    Some(new)
-}
-
-/// MTEXT contents without inline color codes (`\C1;`, `\c255;`), so the text takes the
-/// object's color. An escaped backslash (`\\`) stays.
-fn without_color_codes(s: &str) -> String {
-    let mut out = String::with_capacity(s.len());
-    let mut it = s.chars().peekable();
-    while let Some(c) = it.next() {
-        if c != '\\' {
-            out.push(c);
-            continue;
-        }
-        match it.peek().copied() {
-            Some('C' | 'c') => {
-                for d in it.by_ref() {
-                    if d == ';' {
-                        break;
-                    }
-                }
-            }
-            Some(n) => {
-                out.push('\\');
-                out.push(n);
-                it.next();
-            }
-            None => out.push('\\'),
-        }
-    }
-    out
-}
-
-/// The name of a copy of block `name` whose objects all have `color`, made on first use. `None`
-/// (the reference keeps the original block) for an xref, a missing block, or past the nesting
-/// and copy limits.
-fn tinted_block(d: &mut Drawing, name: &str, color: Color, tinted: &mut Tinted, depth: usize) -> Option<String> {
-    let key = (tag(color), "block", name.to_ascii_uppercase());
-    if let Some(n) = tinted.names.get(&key) {
-        return Some(n.clone());
-    }
-    let b = d.block(name)?.clone();
-    if b.xref_path.is_some() {
-        return None;
-    }
-    if depth >= MAX_BLOCK_DEPTH || tinted.names.len() >= MAX_BLOCKS || tinted.copied.saturating_add(b.entities.len()) > MAX_COPIED {
-        tinted.uncolored = true;
-        return None;
-    }
-    tinted.copied += b.entities.len();
-    // A dimension's block copy stays a `*D` block, so saving keeps its geometry instead of
-    // drawing the dimension again.
-    let dim_block = b.anonymous && b.name.get(..2).is_some_and(|p| p.eq_ignore_ascii_case("*D"));
-    let Tinted { next, blocks, .. } = tinted;
-    let taken = blocks.get_or_insert_with(|| d.blocks.keys().map(|k| k.to_ascii_uppercase()).collect());
-    let is_taken = |n: &str| taken.contains(&n.to_ascii_uppercase());
-    let new = if dim_block {
-        next.find("block", "*D", d.blocks.len(), |i| format!("*D{i}"), is_taken)
-    } else {
-        let base = format!("COMPARE_{}_{}", tag(color), b.name.trim_start_matches('*'));
-        next.find("block", &base, d.blocks.len(), |i| suffixed(&base, i), is_taken)
-    };
-    taken.insert(new.to_ascii_uppercase());
-    tinted.names.insert(key, new.clone());
-    // Hold the name while the nested copies pick theirs.
-    d.blocks.insert(new.clone(), Arc::new(Block::new(&new)));
-    let mut copy = Block { name: new.clone(), anonymous: dim_block, entities: EntityStore::new(), ..(*b).clone() };
-    for e in b.entities.iter() {
-        let h = d.new_handle();
-        let mut e = Entity { handle: h, ..(**e).clone() };
-        detach(&mut e.kind);
-        paint(d, &mut e, color, tinted, depth + 1);
-        copy.entities.push(e);
-    }
-    d.blocks.insert(new.clone(), Arc::new(copy));
-    Some(new)
-}
-
-/// The name each block copied from the other drawing has in the snapshot, by its upper-case
-/// name there.
-type Renames = HashMap<String, String>;
-
-/// Copy into `d` the blocks of `other` that `objs` refer to, directly or through other blocks.
-/// A named block `d` already has keeps `d`'s definition when it draws the same thing there (the
-/// same objects, base point, units, flags and xref file, in it and in the blocks it refers to);
-/// otherwise the other drawing's block is copied as `PART_2` (or `PART_3`…). An anonymous block
-/// (`*D3`, `*U7`…) whose name `d` already uses is copied under the next free name with the same
-/// prefix. Copied
-/// objects get new handles, and relative file paths are rebased on `folder`. The flag is true
-/// when more than [`MAX_BLOCKS`] blocks or [`MAX_COPIED`] objects were needed and the rest were
-/// left out.
-fn copy_blocks<'a>(
-    d: &mut Drawing,
-    other: &Drawing,
-    objs: impl Iterator<Item = &'a Entity>,
-    folder: Option<&Path>,
-    tinted: &mut Tinted,
-) -> (Renames, bool) {
-    let mut frontier: Vec<String> = objs.flat_map(|e| block_refs(&e.kind)).collect();
-    let mut seen = HashSet::new();
-    let mut needed: Vec<Arc<Block>> = Vec::new();
-    let mut left_out = false;
-    // `d`'s relative paths were made absolute from its own folder before the copy.
-    let (mut mine, mut theirs) = (super::Signer::with_frames(d, None), super::Signer::with_frames(other, folder));
-    // Whether `d`'s block `n` draws what `other`'s block `b` draws. Past the signers' work limit
-    // the signatures no longer cover every object, so the blocks count as different.
-    let mut same = |n: &str, b: &Block| {
-        !b.anonymous
-            && d.block(n).is_some()
-            && mine.block(n, 0) == theirs.block(n, 0)
-            && mine.work < super::MAX_BLOCK_WORK
-            && theirs.work < super::MAX_BLOCK_WORK
-    };
-    while let Some(n) = frontier.pop() {
-        let key = n.to_ascii_uppercase();
-        if seen.contains(&key) {
-            continue;
-        }
-        if seen.len() >= MAX_BLOCKS {
-            left_out |= other.block(&n).is_some_and(|b| !same(&n, b));
-            continue;
-        }
-        seen.insert(key);
-        let Some(b) = other.block(&n) else { continue };
-        if same(&n, b) {
-            continue;
-        }
-        if tinted.copied.saturating_add(b.entities.len()) > MAX_COPIED {
-            left_out = true;
-            continue;
-        }
-        tinted.copied += b.entities.len();
-        frontier.extend(b.entities.iter().flat_map(|e| block_refs(&e.kind)));
-        needed.push(b.clone());
-    }
-    // Names `d` does not use stay; the others get free names, avoiding the kept ones.
-    let mut renames = Renames::new();
-    let mut taken: HashSet<String> = d.blocks.keys().map(|k| k.to_ascii_uppercase()).collect();
-    let mut next = NextFree::default();
-    for b in needed.iter().filter(|b| d.block(&b.name).is_none()) {
-        taken.insert(b.name.to_ascii_uppercase());
-        renames.insert(b.name.to_ascii_uppercase(), b.name.clone());
-    }
-    for b in needed.iter().filter(|b| d.block(&b.name).is_some()) {
-        let is_taken = |n: &str| taken.contains(&n.to_ascii_uppercase());
-        let free = if b.anonymous {
-            let prefix: String = b.name.chars().take_while(|c| *c == '*' || c.is_ascii_alphabetic()).collect();
-            next.find("anonymous block", &prefix, taken.len(), |i| format!("{prefix}{i}"), is_taken)
-        } else {
-            next.find("block", &b.name, taken.len(), |i| suffixed(&b.name, i), is_taken)
-        };
-        taken.insert(free.to_ascii_uppercase());
-        renames.insert(b.name.to_ascii_uppercase(), free);
-    }
-    for b in needed {
-        let Some(name) = renames.get(&b.name.to_ascii_uppercase()).cloned() else { continue };
-        let mut copy = Block { name: name.clone(), entities: EntityStore::new(), ..(*b).clone() };
-        for e in b.entities.iter() {
-            let h = d.new_handle();
-            let mut e = Entity { handle: h, ..(**e).clone() };
-            detach(&mut e.kind);
-            rename_refs(&mut e.kind, &renames);
-            copy.entities.push(e);
-        }
-        rebase_block(&mut copy, folder);
-        d.blocks.insert(name, Arc::new(copy));
-    }
-    (renames, left_out)
-}

crates/engine/src/cmd/file/pgp.rs

@@ -12,9 +12,8 @@ use std::sync::{Mutex, MutexGuard, OnceLock, PoisonError};
 
 use serde_json::{Value, json};
 
-use super::super::always;
 use super::super::helpers::support_text;
-use super::{CommandSpec, Result, Session, bad, bool_or, find_command};
+use super::*;
 
 /// Most user aliases held.
 pub const MAX_ALIASES: usize = 10_000;

crates/engine/src/cmd/file/template.rs

@@ -10,7 +10,7 @@ use std::sync::{Mutex, MutexGuard, OnceLock, PoisonError};
 use cadcraft_doc::Drawing;
 use serde_json::{Value, json};
 
-use super::{Result, Session, bad, io};
+use super::*;
 
 /// The default template (profile setting, process-wide like FONTALT): empty = none.
 fn default_template() -> MutexGuard<'static, String> {

crates/engine/src/cmd/gripcmds.rs

@@ -5,8 +5,7 @@ use cadcraft_geom::{Mat3, Vec2};
 use serde_json::{Value, json};
 
 use super::curves;
-use super::{CommandSpec, bad, bool_or, point_param, point_req, str_param, targets};
-
+use super::*;
 use crate::grips::{GripAction, GripMode, grip_action, mode_matrix, stretch_grip};
 use crate::{EngineError, Result, Session};
 

crates/engine/src/cmd/groups.rs

@@ -11,8 +11,7 @@ use cadcraft_doc::{Drawing, Group, Handle};
 use serde_json::{Value, json};
 
 use super::machines::{SelOutcome, SelectPhase};
-use super::{CommandSpec, bad, bool_or, str_param, targets};
-
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 mod dash;

crates/engine/src/cmd/groups/dash.rs

@@ -7,8 +7,7 @@ use serde_json::{Value, json};
 
 use super::super::machines::{SelOutcome, SelectPhase, number};
 use super::super::qselect::wildcard;
-use super::super::{CommandSpec, bad, bool_or, str_param, targets};
-
+use super::super::*;
 use super::{add_members, create, echo_list, find, remove_members, rename, ungroup, valid_name};
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 

crates/engine/src/cmd/groups/pick.rs

@@ -7,9 +7,7 @@ use std::collections::{HashMap, HashSet};
 use cadcraft_doc::Handle;
 use serde_json::{Value, json};
 
-use super::super::{CommandSpec, bad};
-
-use super::super::always;
+use super::super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/hatch.rs

@@ -11,19 +11,17 @@ use serde_json::{Value, json};
 
 use super::helpers::lwpoly;
 use super::*;
-
 use crate::{Accept, EngineError, Input, Interactive, Picker, Prompt, Result, Session, Step};
 
 mod assoc;
 mod edit;
 mod pick;
-use super::has_doc;
 pub(crate) use assoc::update as refill_associative;
 pub use pick::{HatchPicks, PickMode};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        CommandSpec::new("hatch", "Hatch...", run_hatch).menu(&["Draw", "Hatch..."]).alias(&["h", "bh", "-hatch"]).params("{points?: [[x,y]] (internal points) and/or handles?: [hex] (closed objects), pattern?: \"ANSI31\" (built in, or defined by patternFile | patternText), patternFile?: path to a .pat file | patternText?: its contents (loads the patterns it defines), scale?, angle? (degrees), associative? (HPASSOC), separate? (HPSEPARATE: a hatch per point/object), origin?: [x,y] (HPORIGIN) | originMode?: \"current\"|\"bottomLeft\"|\"bottomRight\"|\"topLeft\"|\"topRight\"|\"center\" (HPORIGINMODE), style?: \"normal\"|\"outer\"|\"ignore\" (HPISLANDDETECTION)} — gaps up to HPGAPTOL close").interactive(|s| Ok(Box::new(HatchM::new(s, false)))),
+        CommandSpec::new("hatch", "Hatch...", run_hatch).menu(&["Draw", "Hatch..."]).alias(&["h", "bh", "-hatch"]).params("{points?: [[x,y]] (internal points) and/or handles?: [hex] (closed objects), pattern?: \"ANSI31\", scale?, angle? (degrees), associative? (HPASSOC), separate? (HPSEPARATE: a hatch per point/object), origin?: [x,y] (HPORIGIN) | originMode?: \"current\"|\"bottomLeft\"|\"bottomRight\"|\"topLeft\"|\"topRight\"|\"center\" (HPORIGINMODE), style?: \"normal\"|\"outer\"|\"ignore\" (HPISLANDDETECTION)} — gaps up to HPGAPTOL close").interactive(|s| Ok(Box::new(HatchM::new(s, false)))),
         CommandSpec::new("gradient", "Gradient...", run_gradient).menu(&["Draw", "Gradient..."]).alias(&["gd"]).params("{points? and/or handles?, name?: \"LINEAR\"|\"CYLINDER\"|\"CURVED\"|\"SPHERICAL\"|\"HEMISPHERICAL\" or INV… (colours swapped), color1?, color2?, angle? (degrees), centered? (default true)}").interactive(|s| Ok(Box::new(HatchM::new(s, true)))),
         CommandSpec::new("boundary", "Boundary...", run_boundary).menu(&["Draw", "Boundary..."]).alias(&["bo", "bpoly"]).params("{points: [[x,y]]}").interactive(|_| Ok(Box::new(BoundaryM { region: false }))),
         CommandSpec::new("region", "Region", run_region).menu(&["Draw", "Region"]).alias(&["reg"]).params("{handles?}"),
@@ -36,17 +34,12 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-/// The tolerance curves are flattened with for boundary tracing, in a space with extents `ext`.
-pub(super) fn outline_tol(ext: Bounds2) -> f64 {
-    (ext.width() + ext.height()).max(1e-9) / 20000.0
-}
-
 /// Tessellated outlines of every visible curve in the space (hatch boundary candidates), each
 /// with the handle of the object it came from.
 fn outlines(d: &Drawing, space: &Space, near: Option<Bounds2>) -> (Vec<Vec<Vec2>>, Vec<Handle>) {
     let Some(store) = d.space(space) else { return (Vec::new(), Vec::new()) };
     let ext = d.extents(space);
-    let tol = outline_tol(ext);
+    let tol = (ext.width() + ext.height()).max(1e-9) / 20000.0;
     let mut out = Vec::new();
     let mut owners = Vec::new();
     for e in store.iter() {
@@ -120,8 +113,7 @@ fn closed_loop(d: &Drawing, e: &Entity) -> Option<Vec<PolyVertex>> {
 }
 
 /// Open curves that can make up an island together (a square drawn as four LINEs, two ARCs
-/// forming a circle, the inner lines of multiline walls around a room). Closed objects are
-/// islands on their own (see `closed_loop`).
+/// forming a circle). Closed objects are islands on their own (see `closed_loop`).
 fn island_curve(d: &Drawing, e: &Entity) -> bool {
     matches!(
         e.kind,
@@ -131,7 +123,6 @@ fn island_curve(d: &Drawing, e: &Entity) -> bool {
             | EntityKind::LwPolyline(_)
             | EntityKind::Polyline3d(_)
             | EntityKind::Spline(_)
-            | EntityKind::MLine(_)
     ) && closed_loop(d, e).is_none()
 }
 
@@ -213,8 +204,6 @@ pub(crate) fn loops_at(s: &Session, p: Vec2) -> Result<Vec<HatchLoop>> {
     let ext = d.extents(&space);
     let tol = ((ext.width() + ext.height()) * 1e-9).max(1e-9);
     let (polys, owners) = outlines(d, &space, None);
-    // A line that ends on a flattened curve (an ellipse) can stop short of its chords.
-    let polys = cadcraft_geom::region::snap_ends(&polys, outline_tol(ext), tol);
     let found = cadcraft_geom::region::boundary_at_gap(&polys, p, tol, gap_tolerance(d))
         .ok_or_else(|| EngineError::Other("Valid hatch boundary not found.".into()))?;
     let outer = found.outer;
@@ -469,7 +458,7 @@ fn run_hatch(s: &mut Session, p: &Value) -> Result<Value> {
         && cadcraft_doc::library::pattern(&up).is_none()
         && patfile::user_pattern(&up).is_none()
     {
-        return Err(bad("hatch", format!("unknown pattern {up}: not built in; load it with patternFile or patternText (a .pat file)")));
+        return Err(bad("hatch", format!("unknown pattern {up}")));
     }
     make(s, p, false)
 }
@@ -851,16 +840,6 @@ mod tests {
         assert!(s.current_prompt().unwrap().picker.is_none());
     }
 
-    #[test]
-    fn unknown_pattern_error_and_catalog_name_the_pat_file_route() {
-        let mut s = Session::new();
-        s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
-        let e = s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": "GRAVEL" })).unwrap_err();
-        assert!(e.to_string().contains("patternFile"), "{e}");
-        let spec = specs().into_iter().find(|c| c.id == "hatch").unwrap();
-        assert!(spec.params.contains("patternFile") && spec.params.contains("patternText"), "{}", spec.params);
-    }
-
     #[test]
     fn json_hatch_refuses_an_undefined_pattern() {
         let mut s = Session::new();

crates/engine/src/cmd/hatch/assoc.rs

@@ -86,10 +86,9 @@ fn refill(before: &Drawing, after: &Drawing, l: &HatchLoop) -> Refill {
     if nb.is_empty() {
         return Refill::Open;
     }
-    let tol = super::outline_tol(nb);
-    let snap = ((nb.width() + nb.height()) * 1e-9).max(1e-9);
+    let tol = (nb.width() + nb.height()).max(1e-9) / 20000.0;
     let polys: Vec<Vec<Vec2>> = live.iter().filter_map(|h| after.entity(*h)).flat_map(|e| object_polys(after, e, tol, nb)).collect();
-    let polys = region::snap_ends(&polys, tol, snap);
+    let snap = ((nb.width() + nb.height()) * 1e-9).max(1e-9);
     let gap = gap_tolerance(after);
     let found = if l.outer {
         // The face around a point inside the old loop, carried along with the objects.

crates/engine/src/cmd/hatch/patfile.rs

@@ -13,7 +13,7 @@ use cadcraft_doc::library::{PatternLine, pattern, standard_patterns};
 use serde_json::{Value, json};
 
 use super::super::helpers::support_text;
-use super::{Result, Session, bad, bool_or};
+use super::*;
 
 /// Most user patterns held at once.
 pub const MAX_USER_PATTERNS: usize = 4096;

crates/engine/src/cmd/inquiry.rs

@@ -1,23 +1,16 @@
 //! Inquiry: DIST, ID, LIST, AREA, drawing inspection for agents.
 
-use std::collections::{BTreeMap, BTreeSet};
-
 use cadcraft_doc::{Entity, EntityKind, Handle};
 use cadcraft_geom::{Polyline, Vec2, Vec3};
 use serde_json::{Value, json};
 
-use super::{CommandSpec, bad, bool_or, f64_req, point_req, point_value, points_param, targets};
-
+use super::*;
 use crate::units::{format_angle, format_distance};
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
-mod loops;
 mod regions;
 mod shapes;
-mod usage;
 
-/// The inquiry commands: distances, points, listing, area, time and status, the drawing and
-/// entity queries an agent reads, SHAPES, USAGE, LOOPS, COUNT and the region commands.
 pub fn specs() -> Vec<CommandSpec> {
     let mut v = vec![
         CommandSpec::new("dist", "Distance", run_dist)
@@ -52,8 +45,6 @@ pub fn specs() -> Vec<CommandSpec> {
             .params("{type?, layer?, selected?: bool (default false; true = current selection in active space), window?: [[x,y],[x,y]], crossing?: bool (default true; false = entirely inside), limit?, offset?} → {count (all matches), returned, offset, entities}")
             .noundo(),
         CommandSpec::new("shapes", "Analyze Shapes", shapes::run).params(shapes::PARAMS).noundo(),
-        CommandSpec::new("usage", "Analyze Usage", usage::run).params(usage::PARAMS).noundo(),
-        CommandSpec::new("loops", "Implied Loops", loops::run).params(loops::PARAMS).noundo(),
         CommandSpec::new("texts", "Query Texts", run_texts)
             .params("{contains?: text (any case), layer?, window?: [[x,y],[x,y]] (by insertion point), limit? (default 200), offset?} → {count (all matches), returned, offset, texts: [{handle, type, layer, text, at, height, rotation (degrees), style, tag? (attributes)}]}: the readable text of TEXT, MTEXT (formatting removed), block attributes and multileaders")
             .noundo(),
@@ -73,119 +64,15 @@ pub fn specs() -> Vec<CommandSpec> {
     v
 }
 
-/// Format a distance with the drawing's `LUNITS` and `LUPREC` (decimal units, four places by
-/// default).
 fn fmt_d(s: &Session, v: f64) -> String {
     let h = s.doc().map(|d| (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4))).unwrap_or((2, 4));
     format_distance(v, h.0, h.1)
 }
-/// Format an angle with the drawing's `AUNITS` and `AUPREC` (decimal degrees, whole degrees by
-/// default).
 fn fmt_a(s: &Session, v: f64) -> String {
     let h = s.doc().map(|d| (d.header.i64("AUNITS", 0), d.header.i64("AUPREC", 0))).unwrap_or((0, 0));
     format_angle(v, h.0, h.1)
 }
 
-/// Schema of the analysis self-check block (#1440). Fields may be added within a version; a
-/// rename or a changed meaning bumps it.
-pub(super) const SELF_CHECK_SCHEMA: u64 = 1;
-
-/// How far past its bound a value may be before it is implausible: a relative slack for the
-/// rounding of two ways of measuring the same thing.
-const IMPLAUSIBLE_TOLERANCE: f64 = 1e-9;
-
-/// How many objects of one type an analysis skipped, and every distinct reason it gave.
-#[derive(Default)]
-struct SkipTally {
-    count: u64,
-    reasons: BTreeSet<String>,
-}
-
-/// The self-check every analysis result carries (#1440): how many objects it found, how many it
-/// analysed, what it skipped and why, the caps it hit with their values, and values so
-/// implausible that they point at a bug rather than at the drawing.
-#[derive(Default)]
-pub(super) struct SelfCheck {
-    found: u64,
-    analyzed: u64,
-    skipped: BTreeMap<String, SkipTally>,
-    caps: BTreeMap<String, u64>,
-    implausible: Vec<Value>,
-}
-
-impl SelfCheck {
-    /// An empty self-check: nothing found, analysed or skipped yet.
-    pub(super) fn new() -> Self {
-        Self::default()
-    }
-
-    /// Count objects the analysis found (matched its filters).
-    pub(super) fn found(&mut self, n: u64) {
-        self.found = self.found.saturating_add(n);
-    }
-
-    /// Count objects the analysis actually analysed.
-    pub(super) fn analyzed(&mut self, n: u64) {
-        self.analyzed = self.analyzed.saturating_add(n);
-    }
-
-    /// Count `n` objects of `ty` skipped, with the reason.
-    pub(super) fn skip(&mut self, ty: &str, reason: &str, n: u64) {
-        let skip = self.skipped.entry(ty.to_string()).or_default();
-        skip.count = skip.count.saturating_add(n);
-        skip.reasons.insert(reason.to_string());
-    }
-
-    /// Record a cap the analysis hit, with its value (e.g. `limit`, 200).
-    pub(super) fn cap(&mut self, name: &str, value: u64) {
-        self.caps.insert(name.to_string(), value);
-    }
-
-    /// Flag `value` as implausible when it is past `bound`, with the rule that makes it so. A
-    /// non-finite `bound` means no bound applies (an empty drawing has no extents). Values within
-    /// `IMPLAUSIBLE_TOLERANCE` of the bound are not flagged: they are the rounding of two ways
-    /// of measuring the same thing (a border rectangle's shoelace area against the extents'
-    /// `width * height`), not a bug.
-    pub(super) fn implausible(&mut self, handle: Handle, ty: &str, field: &str, value: f64, bound: f64, rule: &str) {
-        if value.is_finite() && bound.is_finite() && value > bound + bound.abs() * IMPLAUSIBLE_TOLERANCE {
-            self.implausible.push(json!({
-                "handle": handle.hex(),
-                "type": ty,
-                "field": field,
-                "value": value,
-                "bound": bound,
-                "reason": rule,
-            }));
-        }
-    }
-
-    /// The skip map in the shape analyses have always reported: type → {count, reason}.
-    pub(super) fn skipped_json(&self) -> Value {
-        Value::Object(
-            self.skipped
-                .iter()
-                .map(|(ty, skip)| {
-                    let reason = skip.reasons.iter().map(String::as_str).collect::<Vec<_>>().join("; ");
-                    (ty.clone(), json!({ "count": skip.count, "reason": reason }))
-                })
-                .collect(),
-        )
-    }
-
-    /// The self-check as the JSON object every analysis returns: schema, counts, skip map, caps
-    /// and implausible values.
-    pub(super) fn to_json(&self) -> Value {
-        json!({
-            "schema": SELF_CHECK_SCHEMA,
-            "found": self.found,
-            "analyzed": self.analyzed,
-            "skipped": self.skipped_json(),
-            "caps": self.caps,
-            "implausible": self.implausible,
-        })
-    }
-}
-
 /// The angle of `d` up from the XY plane.
 fn angle_from_xy(d: Vec3) -> f64 {
     d.z.atan2(d.xy().len())
@@ -402,17 +289,8 @@ pub(super) fn area_of(pts: &[Vec2]) -> (f64, f64) {
     (a, per)
 }
 
-/// `points` as given, `None` when it is absent; a `points` that is not a list of points is an
-/// error, never a fall back to the selection.
-fn given_points(p: &Value, cmd: &str) -> Result<Option<Vec<Vec2>>> {
-    match p.get("points") {
-        None | Some(Value::Null) => Ok(None),
-        Some(_) => points_param(p, "points").map(Some).ok_or_else(|| bad(cmd, "`points` must be a list of [x, y] points")),
-    }
-}
-
 fn run_area(s: &mut Session, p: &Value) -> Result<Value> {
-    let (a, per) = if let Some(pts) = given_points(p, "area")? {
+    let (a, per) = if let Some(pts) = points_param(p, "points") {
         area_of(&pts)
     } else {
         let h = targets(s, p)?.first().copied().ok_or_else(|| bad("area", "`points` or `handle` is required"))?;
@@ -425,37 +303,6 @@ fn area_text(s: &Session, a: f64, per: f64) -> String {
     format!("Area = {}, Perimeter = {}", fmt_d(s, a), fmt_d(s, per))
 }
 
-/// MEASUREGEOM's Volume option: the area of a polygon of three or more points, or of a 2D object
-/// as AREA measures it (an open polyline as if closed), times the absolute value of a height.
-pub(super) fn run_volume(s: &mut Session, p: &Value) -> Result<Value> {
-    let a = if let Some(pts) = given_points(p, "volume.measure")? {
-        if pts.len() < 3 {
-            return Err(bad("volume.measure", "`points` needs 3 or more [x,y] points"));
-        }
-        area_of(&pts).0
-    } else {
-        let h = targets(s, p)?.first().copied().ok_or_else(|| bad("volume.measure", "`points` or `handle` is required"))?;
-        object_area(s, h)?.0
-    };
-    let height = f64_req("volume.measure", p, "height")?;
-    let v = a * height.abs();
-    if !v.is_finite() {
-        return Err(bad("volume.measure", "the volume is too large"));
-    }
-    Ok(json!({ "volume": v, "area": a, "height": height, "message": volume_text(s, v) }))
-}
-
-fn volume_text(s: &Session, v: f64) -> String {
-    format!("Volume = {}", fmt_volume(s, v))
-}
-
-/// Format a volume as a number in the drawing's `LUPREC`. Engineering and architectural units
-/// show it as a decimal number, not in feet and inches.
-fn fmt_volume(s: &Session, v: f64) -> String {
-    let (u, p) = s.doc().map(|d| (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4))).unwrap_or((2, 4));
-    format_distance(v, if matches!(u, 3 | 4) { 2 } else { u }, p)
-}
-
 /// Area and perimeter of a closed object (AREA's Object option).
 pub(super) fn object_area(s: &Session, h: Handle) -> Result<(f64, f64)> {
     let d = s.doc()?;
@@ -930,19 +777,9 @@ pub(super) struct AreaM {
     object: bool,
     /// Asking for the length of a segment (the Length option).
     length: bool,
-    /// Measuring volumes (MEASUREGEOM's Volume option): each area is multiplied by the absolute value of a height.
-    volume: bool,
-    /// Areas measured in volume mode that still wait for their height, oldest first.
-    pending: Vec<f64>,
-    /// The first point of a height given by two points.
-    height_from: Option<Vec2>,
 }
 
 impl AreaM {
-    /// MEASUREGEOM's Volume option: AREA's prompts, then a height for each area.
-    pub(super) fn volume() -> Self {
-        AreaM { volume: true, ..AreaM::default() }
-    }
     fn mode_prefix(&self) -> &'static str {
         match self.mode {
             AreaMode::Single => "",
@@ -950,49 +787,8 @@ impl AreaM {
             AreaMode::Subtract => "(SUBTRACT mode) ",
         }
     }
-    /// The Add and Subtract keywords: "Add area" and "Subtract area", or "Add volume" and
-    /// "Subtract volume".
-    fn mode_keywords(&self) -> (&'static str, &'static str) {
-        if self.volume { ("Add volume", "Subtract volume") } else { ("Add area", "Subtract area") }
-    }
-    /// The running total with `v` added or subtracted; in single mode, the total as it is.
-    fn total_with(&self, v: f64) -> f64 {
-        match self.mode {
-            AreaMode::Single => self.total,
-            AreaMode::Add => self.total + v,
-            AreaMode::Subtract => self.total - v,
-        }
-    }
-    /// Measure the oldest pending area's volume with height `h`.
-    fn height(&mut self, s: &mut Session, h: f64) -> Step {
-        match self.pending.first().map(|a| a * h.abs()) {
-            Some(v) if v.is_finite() && self.total_with(v).is_finite() => {
-                self.pending.remove(0);
-                self.volume_measured(s, v)
-            }
-            _ => {
-                s.echo("The volume is too large.");
-                Step::Continue
-            }
-        }
-    }
-    /// Report a volume (and the running total in add/subtract mode); ends the command in single mode.
-    fn volume_measured(&mut self, s: &mut Session, v: f64) -> Step {
-        s.echo(volume_text(s, v));
-        if self.mode == AreaMode::Single {
-            return Step::Done;
-        }
-        self.total = self.total_with(v);
-        s.echo(format!("Total volume = {}", fmt_volume(s, self.total)));
-        Step::Continue
-    }
     /// Report an area (and the running total in add/subtract mode); ends the command in single mode.
-    /// In volume mode the area waits for its height instead.
     fn measured(&mut self, s: &mut Session, a: f64, per: f64) -> Step {
-        if self.volume {
-            self.pending.push(a);
-            return Step::Continue;
-        }
         s.echo(area_text(s, a, per));
         match self.mode {
             AreaMode::Single => return Step::Done,
@@ -1015,15 +811,9 @@ impl AreaM {
 
 impl Interactive for AreaM {
     fn name(&self) -> &'static str {
-        if self.volume { "MEASUREGEOM" } else { "AREA" }
+        "AREA"
     }
     fn prompt(&self, _s: &Session) -> Prompt {
-        if !self.pending.is_empty() {
-            return match self.height_from {
-                Some(p) => Prompt::new("Specify second point", Accept::POINT).base(p),
-                None => Prompt::new(format!("{}Specify height", self.mode_prefix()), Accept::POINT_OR_NUMBER),
-            };
-        }
         if self.object {
             return Prompt::new(format!("{}Select objects", self.mode_prefix()), Accept::SELECT);
         }
@@ -1031,35 +821,17 @@ impl Interactive for AreaM {
             return length_prompt();
         }
         let next = format!("{}Specify next point", self.mode_prefix());
-        let (add, subtract) = self.mode_keywords();
         match (self.pts.len(), self.mode) {
-            (0, AreaMode::Single) => Prompt::new("Specify first corner point", Accept::POINT).kw(&["Object", add, subtract]).default("Object"),
-            (0, AreaMode::Add) => Prompt::new("Specify first corner point", Accept::POINT).kw(&["Object", subtract]),
-            (0, AreaMode::Subtract) => Prompt::new("Specify first corner point", Accept::POINT).kw(&["Object", add]),
+            (0, AreaMode::Single) => {
+                Prompt::new("Specify first corner point", Accept::POINT).kw(&["Object", "Add area", "Subtract area"]).default("Object")
+            }
+            (0, AreaMode::Add) => Prompt::new("Specify first corner point", Accept::POINT).kw(&["Object", "Subtract area"]),
+            (0, AreaMode::Subtract) => Prompt::new("Specify first corner point", Accept::POINT).kw(&["Object", "Add area"]),
             (1, _) => Prompt::new(next, Accept::POINT).kw(&["Arc", "Length", "Undo"]).base_opt(self.pts.last().copied()),
             _ => Prompt::new(next, Accept::POINT).kw(&["Arc", "Length", "Undo", "Total"]).default("Total").base_opt(self.pts.last().copied()),
         }
     }
     fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
-        if !self.pending.is_empty() {
-            // A height is typed, or given by two points (their distance).
-            match (i, self.height_from) {
-                (Input::Point(p), None) => self.height_from = Some(p),
-                (Input::Point(p), Some(from)) => {
-                    self.height_from = None;
-                    return Ok(self.height(s, p.dist(from)));
-                }
-                (Input::Text(t), None) => match crate::units::parse_distance(&t).filter(|v| v.is_finite()) {
-                    Some(h) => return Ok(self.height(s, h)),
-                    None => s.echo("Requires a distance."),
-                },
-                (Input::Enter, None) => s.echo("Requires a height."),
-                (Input::Enter, Some(_)) => s.echo("Requires a second point."),
-                (Input::Text(_), Some(_)) => s.echo("Requires a point."),
-                _ => {}
-            }
-            return Ok(Step::Continue);
-        }
         if self.object {
             match i {
                 Input::Pick(hs) => {
@@ -1069,10 +841,6 @@ impl Interactive for AreaM {
                                 if self.measured(s, a, per) == Step::Done {
                                     return Ok(Step::Done);
                                 }
-                                // A single volume takes the first object with an area.
-                                if self.volume && self.mode == AreaMode::Single {
-                                    break;
-                                }
                             }
                             Err(_) => s.echo("The selected object has no area."),
                         }
@@ -1100,8 +868,8 @@ impl Interactive for AreaM {
             Input::Point(p) => self.pts.push(p),
             Input::Keyword(k) => match k.as_str() {
                 "Object" => self.object = true,
-                "Add area" | "Add volume" => self.mode = AreaMode::Add,
-                "Subtract area" | "Subtract volume" => self.mode = AreaMode::Subtract,
+                "Add area" => self.mode = AreaMode::Add,
+                "Subtract area" => self.mode = AreaMode::Subtract,
                 "Undo" => {
                     self.pts.pop();
                 }
@@ -1128,30 +896,3 @@ impl Interactive for AreaM {
         vec![super::helpers::lwpoly(v, true)]
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use cadcraft_doc::Handle;
-
-    use super::*;
-
-    /// #1440 review: a value one ulp past its bound (a border rectangle's shoelace area against
-    /// the extents' `width * height`) is rounding, not a bug; a value clearly past it still is.
-    #[test]
-    fn implausible_allows_rounding_but_not_a_real_excess() {
-        let bound: f64 = 100.0;
-
-        let mut check = SelfCheck::new();
-        check.implausible(Handle::default(), "Polyline", "area", bound.next_up(), bound, "past the bound");
-        assert!(check.implausible.is_empty(), "one ulp past the bound is rounding: {}", check.to_json());
-
-        let mut check = SelfCheck::new();
-        check.implausible(Handle::default(), "Polyline", "area", bound * (1.0 + 1e-6), bound, "past the bound");
-        assert_eq!(check.implausible.len(), 1, "a real excess is still flagged: {}", check.to_json());
-
-        // A bound that is not finite means no bound applies: the value is not flagged.
-        let mut check = SelfCheck::new();
-        check.implausible(Handle::default(), "Region", "area", 1e9, f64::INFINITY, "past the bound");
-        assert!(check.implausible.is_empty(), "an infinite bound applies to nothing: {}", check.to_json());
-    }
-}

crates/engine/src/cmd/inquiry/count.rs

@@ -9,9 +9,7 @@ use cadcraft_doc::{Drawing, Entity, EntityKind, Handle, Insert, MAX_BLOCK_DEPTH,
 use cadcraft_geom::{Mat3, Vec2};
 use serde_json::{Value, json};
 
-use super::super::{bad, bool_or, point_req, str_param, targets};
-
-use super::SelfCheck;
+use super::super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 /// Merges done while expanding nested references; a hostile file stops here (and says so).
@@ -22,15 +20,12 @@ const MAX_HANDLES: usize = 100_000;
 /// COUNT's JSON parameters.
 pub(super) const PARAMS: &str = "{block?, object?: handle (count objects like this one), space?: current|model|all|<layout> (default current), \
      handles?: [...] (count in these objects), nested?: bool (default true), highlight?: bool} → \
-     {blocks: {name: n}, nested: {name: n}, spaces: {space: {name: n}}, total} | {block, count, nested, handles}, plus `message` and \
-     `selfCheck` (found/analyzed/skipped counts with reasons, and the caps hit: work, handles, blockDepth)";
+     {blocks: {name: n}, nested: {name: n}, spaces: {space: {name: n}}, total} | {block, count, nested, handles}, plus `message`";
 
-/// COUNT's interactive command-line prompt machine.
 pub(super) fn machine() -> Box<dyn Interactive> {
     Box::new(CountM)
 }
 
-/// COUNTTABLE's interactive command-line prompt machine (it asks for the insertion point).
 pub(super) fn table_machine() -> Box<dyn Interactive> {
     Box::new(CountTableM)
 }
@@ -114,14 +109,11 @@ struct Expander<'a> {
     memo: HashMap<(String, usize), Rc<BTreeMap<String, u64>>>,
     work: u64,
     truncated: bool,
-    /// A block at the end of the depth cap still held references.
-    depth_capped: bool,
 }
 
 impl<'a> Expander<'a> {
-    /// An expander that has not traversed any block yet.
     fn new(d: &'a Drawing) -> Self {
-        Expander { d, memo: HashMap::new(), work: 0, truncated: false, depth_capped: false }
+        Expander { d, memo: HashMap::new(), work: 0, truncated: false }
     }
     /// The definition's own name for a referenced block (names are case-insensitive).
     fn canonical(&self, name: &str) -> String {
@@ -133,17 +125,10 @@ impl<'a> Expander<'a> {
         if let Some(m) = self.memo.get(&key) {
             return m.clone();
         }
-        if levels == 0 {
-            // More references than MAX_BLOCK_DEPTH covers: say so rather than silently stop.
-            if self.d.block(name).is_some_and(|b| b.entities.iter().any(|e| matches!(&e.kind, EntityKind::Insert(_)))) {
-                self.depth_capped = true;
-            }
-            let out = Rc::new(BTreeMap::new());
-            self.memo.insert(key, out.clone());
-            return out;
-        }
         let mut out: BTreeMap<String, u64> = BTreeMap::new();
-        if let Some(b) = self.d.block(name) {
+        if levels > 0
+            && let Some(b) = self.d.block(name)
+        {
             let b = b.clone();
             for e in b.entities.iter() {
                 let EntityKind::Insert(i) = &e.kind else { continue };
@@ -188,14 +173,6 @@ struct Tally {
     /// Top-level objects holding `want` (when one block is asked for).
     handles: Vec<Handle>,
     truncated: bool,
-    /// Top-level objects scanned, and the block references among them.
-    found: u64,
-    analyzed: u64,
-    /// Top-level objects that are not block references, by type.
-    skipped: BTreeMap<&'static str, u64>,
-    /// More top-level objects held the block than `MAX_HANDLES`.
-    handles_capped: bool,
-    depth_capped: bool,
 }
 
 /// Count block references in `scope`; with `want`, also collect the top-level objects holding it.
@@ -203,13 +180,7 @@ fn tally(d: &Drawing, scope: &Scope, nested: bool, want: Option<&str>) -> Tally
     let mut x = Expander::new(d);
     let mut t = Tally::default();
     for (space, e) in scope.objects(d) {
-        t.found = t.found.saturating_add(1);
-        let EntityKind::Insert(i) = &e.kind else {
-            let n = t.skipped.entry(e.kind.type_name()).or_default();
-            *n = n.saturating_add(1);
-            continue;
-        };
-        t.analyzed = t.analyzed.saturating_add(1);
+        let EntityKind::Insert(i) = &e.kind else { continue };
         let name = x.canonical(&i.block);
         let m = copies(i);
         let mut holds = want.is_some_and(|w| w.eq_ignore_ascii_case(&name));
@@ -228,41 +199,15 @@ fn tally(d: &Drawing, scope: &Scope, nested: bool, want: Option<&str>) -> Tally
                 holds |= want.is_some_and(|w| w.eq_ignore_ascii_case(k));
             }
         }
-        if holds {
-            if t.handles.len() < MAX_HANDLES {
-                t.handles.push(e.handle);
-            } else {
-                t.handles_capped = true;
-            }
+        if holds && t.handles.len() < MAX_HANDLES {
+            t.handles.push(e.handle);
         }
     }
     t.spaces.retain(|_, m| !m.is_empty());
     t.truncated = x.truncated;
-    t.depth_capped = x.depth_capped;
     t
 }
 
-/// The self-check for a COUNT-style result: what was scanned, counted and skipped, and the caps
-/// that stopped it.
-fn self_check(t: &Tally) -> Value {
-    let mut check = SelfCheck::new();
-    check.found(t.found);
-    check.analyzed(t.analyzed);
-    for (ty, n) in &t.skipped {
-        check.skip(ty, "not a block reference", *n);
-    }
-    if t.truncated {
-        check.cap("work", MAX_WORK);
-    }
-    if t.handles_capped {
-        check.cap("handles", u64::try_from(MAX_HANDLES).unwrap_or(u64::MAX));
-    }
-    if t.depth_capped {
-        check.cap("blockDepth", u64::try_from(MAX_BLOCK_DEPTH).unwrap_or(u64::MAX));
-    }
-    check.to_json()
-}
-
 /// A translation-free signature of an object's geometry: objects with equal keys are copies of
 /// each other (moved, not rotated or scaled). Coordinates are rounded to 1e-6.
 fn shape_key(k: &EntityKind) -> Option<String> {
@@ -317,15 +262,7 @@ fn list(t: &Tally, scope: &Scope) -> Value {
         m
     };
     let total = t.blocks.values().fold(0u64, |a, b| a.saturating_add(*b));
-    json!({
-        "blocks": t.blocks,
-        "nested": t.nested,
-        "spaces": t.spaces,
-        "total": total,
-        "truncated": t.truncated,
-        "selfCheck": self_check(t),
-        "message": message,
-    })
+    json!({ "blocks": t.blocks, "nested": t.nested, "spaces": t.spaces, "total": total, "truncated": t.truncated, "message": message })
 }
 
 /// Count block `b` (its references, nested ones included) in `scope`.
@@ -336,15 +273,7 @@ fn count_block(d: &Drawing, scope: &Scope, nested: bool, b: &str) -> Value {
     let k = t.nested.get(&name).copied().unwrap_or(0);
     let wh = scope.label();
     let message = if k > 0 { format!("Block {name}: {n} in {wh} ({k} nested).") } else { format!("Block {name}: {n} in {wh}.") };
-    json!({
-        "block": name,
-        "count": n,
-        "nested": k,
-        "handles": hex(&t.handles),
-        "truncated": t.truncated,
-        "selfCheck": self_check(&t),
-        "message": message,
-    })
+    json!({ "block": name, "count": n, "nested": k, "handles": hex(&t.handles), "truncated": t.truncated, "message": message })
 }
 
 /// Count the objects in `scope` shaped like `h` (a block reference: references of its block).
@@ -355,35 +284,18 @@ fn count_like(d: &Drawing, scope: &Scope, nested: bool, h: Handle) -> Result<Val
     }
     let ty = e.kind.type_name();
     let key = shape_key(&e.kind).ok_or_else(|| bad("count", format!("a {ty} can't be counted by shape")))?;
-    let mut check = SelfCheck::new();
-    let mut hs: Vec<Handle> = Vec::new();
-    let mut capped = false;
-    for (_, o) in scope.objects(d) {
-        check.found(1);
-        if o.kind.type_name() != ty {
-            check.skip(o.kind.type_name(), "a different type", 1);
-            continue;
-        }
-        check.analyzed(1);
-        if shape_key(&o.kind).as_deref() == Some(key.as_str()) {
-            if hs.len() < MAX_HANDLES {
-                hs.push(o.handle);
-            } else {
-                capped = true;
-            }
-        }
-    }
-    if capped {
-        check.cap("handles", u64::try_from(MAX_HANDLES).unwrap_or(u64::MAX));
-    }
+    let hs: Vec<Handle> = scope
+        .objects(d)
+        .into_iter()
+        .filter(|(_, o)| o.kind.type_name() == ty && shape_key(&o.kind).as_deref() == Some(key.as_str()))
+        .map(|(_, o)| o.handle)
+        .take(MAX_HANDLES)
+        .collect();
     let n = hs.len();
     let message = format!("{ty}: {n} like the selected one in {}.", scope.label());
-    Ok(json!({ "object": ty, "count": n, "handles": hex(&hs), "selfCheck": check.to_json(), "message": message }))
+    Ok(json!({ "object": ty, "count": n, "handles": hex(&hs), "message": message }))
 }
 
-/// The body of COUNT and COUNTLIST: list the blocks in scope, count one block, or count the
-/// objects shaped like a picked one. `default_all` makes an omitted `space` mean every space
-/// (COUNTLIST) instead of the current one (COUNT).
 fn run(s: &mut Session, cmd: &str, p: &Value, default_all: bool) -> Result<Value> {
     let scope = Scope::parse(s, cmd, p, default_all)?;
     let nested = bool_or(p, "nested", true);
@@ -424,8 +336,6 @@ fn table_style(s: &Session) -> cadcraft_doc::TableStyle {
     d.table_styles.iter().find(|t| t.name.eq_ignore_ascii_case(&cur)).or(d.table_styles.first()).cloned().unwrap_or_default()
 }
 
-/// COUNTTABLE: insert a table of the block counts in scope at `at`, and report what the tally
-/// covered (and refused: no block references in scope is an error, not an empty table).
 pub(super) fn run_counttable(s: &mut Session, p: &Value) -> Result<Value> {
     const CMD: &str = "counttable";
     let at = point_req(CMD, p, "at")?;
@@ -438,15 +348,9 @@ pub(super) fn run_counttable(s: &mut Session, p: &Value) -> Result<Value> {
     let header = Some(vec!["Name".to_string(), "Count".to_string()]);
     let table = super::super::table::make_table(&table_style(s), at, cells.len(), 2, None, None, Some("Block Count"), header, &cells);
     let h = s.add_entity(EntityKind::Table(table))?;
-    Ok(json!({
-        "handle": h.hex(),
-        "rows": cells.len(),
-        "selfCheck": self_check(&t),
-        "message": format!("Table of {} block(s) inserted.", cells.len()),
-    }))
+    Ok(json!({ "handle": h.hex(), "rows": cells.len(), "message": format!("Table of {} block(s) inserted.", cells.len()) }))
 }
 
-/// Echo a result's `message` at the command line, one line at a time.
 fn echo_lines(s: &mut Session, r: &Value) {
     if let Some(m) = r.get("message").and_then(Value::as_str) {
         for l in m.lines() {

crates/engine/src/cmd/inquiry/loops.rs

@@ -1,440 +0,0 @@
-//! LOOPS: implied closed loops from loose LINE and ARC chains — perimeter, area and winding for
-//! each closed loop, the gap and its location for each open chain, and branch junctions (three or
-//! more ends meeting) reported but not resolved. Read-only.
-//!
-//! Boundaries are often drawn as separate LINEs and ARCs rather than one polyline, so an agent
-//! cannot tell whether they form a closed loop or by how much a "closed" outline is open. The
-//! endpoint chaining is quadratic in the number of endpoints; past `maxPairs` it reports `capped`
-//! and analyzes nothing rather than guess from a partial pairing.
-
-use std::collections::{BTreeMap, BTreeSet};
-
-use cadcraft_doc::{EntityKind, Handle};
-use cadcraft_geom::{Arc as GeoArc, EPS, Vec2};
-use serde_json::{Value, json};
-
-use super::super::bad;
-
-use crate::{Result, Session};
-
-const CMD: &str = "loops";
-
-/// Endpoint pairs compared before the quadratic chaining gives up (reported as `capped`).
-const DEFAULT_PAIR_LIMIT: usize = 1_000_000;
-/// The most pairs a caller may ask for: a bounded amount of work however large the drawing.
-const MAX_PAIR_LIMIT: usize = 100_000_000;
-/// Loops returned, and open chains and junctions kept, by default.
-const DEFAULT_LIMIT: usize = 200;
-/// The smallest default tolerance, for a drawing at the origin.
-const MIN_TOLERANCE: f64 = 1e-12;
-
-pub const PARAMS: &str = "{tolerance?: positive number (default 1e-9 × the extents diagonal), maxPairs? (endpoint pairs compared, default 1000000, at most 100000000), limit? (default 200), offset?} → \
-     {schema: 1, tolerance, pairTests, pairTestsNeeded, pairLimit, capped, count (all closed loops), returned, offset, truncated, \
-     loops: [{members: [handle], perimeter, area, winding: ccw|cw}], \
-     openChains: {count, truncated, chains: [{members, gap, at: [x, y], ends: [[x, y], [x, y]], length}]}, \
-     junctions: {count, truncated, junctions: [{at: [x, y], ends, members}]}, skipped: {<type>: {count, reason}}}: \
-     chains LINE and ARC endpoints that meet within the tolerance; junctions (three or more ends meeting) are reported, not resolved";
-
-/// Why a LINE or ARC cannot take part in a chain.
-type Skipped = BTreeMap<&'static str, (usize, BTreeSet<&'static str>)>;
-
-/// One chainable entity, oriented as drawn (a line a→b, an arc CCW start→end).
-struct Piece {
-    handle: Handle,
-    start: Vec2,
-    end: Vec2,
-    /// The arc, when the piece is one.
-    arc: Option<GeoArc>,
-}
-
-impl Piece {
-    fn at(&self, which: usize) -> Vec2 {
-        if which == 0 { self.start } else { self.end }
-    }
-    fn length(&self) -> f64 {
-        match self.arc {
-            Some(a) => a.radius * a.sweep(),
-            None => self.start.dist(self.end),
-        }
-    }
-}
-
-/// An entity endpoint in the chain graph. Each piece has one at index `2 * piece` and one at
-/// `2 * piece + 1`.
-#[derive(Clone, Copy)]
-struct End {
-    piece: usize,
-    at: Vec2,
-}
-
-/// A piece traversed one way round a chain.
-struct Traversed {
-    start: Vec2,
-    end: Vec2,
-    /// The arc and whether the traversal follows its CCW direction.
-    arc: Option<(GeoArc, bool)>,
-}
-
-pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
-    let given = |k: &str| p.get(k).filter(|v| !v.is_null());
-    let count = |k: &str, default: usize| -> Result<usize> {
-        given(k).map_or(Ok(default), |v| {
-            v.as_u64().map(|n| usize::try_from(n).unwrap_or(usize::MAX)).ok_or_else(|| bad(CMD, format!("`{k}` must be a whole number, 0 or more")))
-        })
-    };
-    let limit = count("limit", DEFAULT_LIMIT)?;
-    let offset = count("offset", 0)?;
-    let pair_limit = count("maxPairs", DEFAULT_PAIR_LIMIT)?.min(MAX_PAIR_LIMIT);
-    let tolerance = given("tolerance")
-        .map(|v| v.as_f64().filter(|t| t.is_finite() && *t > 0.0).ok_or_else(|| bad(CMD, "`tolerance` must be a positive number")))
-        .transpose()?;
-    let s: &Session = s;
-    let st = s.state()?;
-    let d = &st.doc;
-    let tol = tolerance.unwrap_or_else(|| {
-        let ext = d.extents(&st.space);
-        if ext.is_empty() {
-            return MIN_TOLERANCE;
-        }
-        let diag = ext.min.dist(ext.max);
-        if diag.is_finite() { (diag * 1e-9).max(MIN_TOLERANCE) } else { MIN_TOLERANCE }
-    });
-    let mut skipped: Skipped = BTreeMap::new();
-    let Some(store) = d.space(&st.space) else {
-        return Ok(empty_report(offset, tol, 0, 0, pair_limit, false, skipped));
-    };
-    let pieces: Vec<Piece> = store.iter().filter_map(|e| chainable(e.handle, &e.kind, &mut skipped)).collect();
-    let mut ends: Vec<End> = Vec::with_capacity(pieces.len().saturating_mul(2));
-    for (i, piece) in pieces.iter().enumerate() {
-        ends.push(End { piece: i, at: piece.start });
-        ends.push(End { piece: i, at: piece.end });
-    }
-    let n = ends.len();
-    let needed = n.saturating_mul(n.saturating_sub(1)) / 2;
-    if needed > pair_limit {
-        return Ok(empty_report(offset, tol, 0, needed, pair_limit, true, skipped));
-    }
-
-    // Endpoints closer than the tolerance meet. Transitive components of three or more ends are
-    // branch junctions; a component of exactly two is a simple joint.
-    let mut parent: Vec<usize> = (0..n).collect();
-    for i in 0..n {
-        let Some(a) = ends.get(i) else { continue };
-        for j in (i + 1)..n {
-            let Some(b) = ends.get(j) else { continue };
-            if a.at.dist(b.at) <= tol {
-                let (ra, rb) = (find(&mut parent, i), find(&mut parent, j));
-                if ra != rb
-                    && let Some(slot) = parent.get_mut(ra)
-                {
-                    *slot = rb;
-                }
-            }
-        }
-    }
-    let mut groups: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
-    for i in 0..n {
-        let root = find(&mut parent, i);
-        groups.entry(root).or_default().push(i);
-    }
-
-    // Junctions are reported and their pieces left out of the chains: not resolved.
-    let mut excluded = vec![false; pieces.len()];
-    let mut junctions: Vec<Value> = Vec::new();
-    let mut joints: Vec<(usize, usize)> = Vec::new();
-    for group in groups.values() {
-        match group.as_slice() {
-            &[a, b] => joints.push((a, b)),
-            [_, _, ..] => {
-                let scale = group.len() as f64;
-                let mut at = Vec2::ZERO;
-                let mut members: Vec<Handle> = Vec::new();
-                for &e in group {
-                    let Some(end) = ends.get(e) else { continue };
-                    at += end.at / scale;
-                    let Some(piece) = pieces.get(end.piece) else { continue };
-                    if !members.contains(&piece.handle) {
-                        members.push(piece.handle);
-                    }
-                    if let Some(slot) = excluded.get_mut(end.piece) {
-                        *slot = true;
-                    }
-                }
-                junctions.push(json!({
-                    "at": [at.x, at.y],
-                    "ends": group.len(),
-                    "members": members.iter().map(|h| h.hex()).collect::<Vec<_>>(),
-                }));
-            }
-            _ => {}
-        }
-    }
-
-    // A joint links the two ends for the walk. A joint into an excluded piece is not a link, and
-    // a line whose own ends meet within a huge tolerance is a spur, not a zero-area loop.
-    let mut link: Vec<Option<usize>> = vec![None; n];
-    for (a, b) in joints {
-        let (Some(ea), Some(eb)) = (ends.get(a), ends.get(b)) else { continue };
-        if ea.piece == eb.piece && pieces.get(ea.piece).is_some_and(|p| p.arc.is_none()) {
-            continue;
-        }
-        if excluded.get(ea.piece).copied().unwrap_or(true) || excluded.get(eb.piece).copied().unwrap_or(true) {
-            continue;
-        }
-        if let Some(slot) = link.get_mut(a) {
-            *slot = Some(b);
-        }
-        if let Some(slot) = link.get_mut(b) {
-            *slot = Some(a);
-        }
-    }
-
-    let mut visited = vec![false; pieces.len()];
-    let mut loops: Vec<Value> = Vec::new();
-    let mut open: Vec<Value> = Vec::new();
-    // Paths first: a free end marks a chain. What is left with both ends linked is a cycle.
-    open_chains(&pieces, &excluded, &link, &mut visited, &mut open);
-    closed_loops(&pieces, &excluded, &link, &mut visited, &mut loops);
-
-    let total = loops.len();
-    let page: Vec<Value> = loops.into_iter().skip(offset).take(limit).collect();
-    let returned = page.len();
-    let truncated = returned < total.saturating_sub(offset);
-    let open_total = open.len();
-    let open_page: Vec<Value> = open.into_iter().take(limit).collect();
-    let open_truncated = open_page.len() < open_total;
-    let junction_total = junctions.len();
-    let junction_page: Vec<Value> = junctions.into_iter().take(limit).collect();
-    let junction_truncated = junction_page.len() < junction_total;
-    Ok(json!({
-        "schema": 1,
-        "tolerance": tol,
-        "pairTests": needed,
-        "pairTestsNeeded": needed,
-        "pairLimit": pair_limit,
-        "capped": false,
-        "count": total,
-        "returned": returned,
-        "offset": offset,
-        "truncated": truncated,
-        "loops": page,
-        "openChains": { "count": open_total, "truncated": open_truncated, "chains": open_page },
-        "junctions": { "count": junction_total, "truncated": junction_truncated, "junctions": junction_page },
-        "skipped": skipped_json(skipped),
-    }))
-}
-
-/// A report with nothing analyzed: an empty drawing, or one past the pair cap.
-fn empty_report(offset: usize, tol: f64, pair_tests: usize, pair_tests_needed: usize, pair_limit: usize, capped: bool, skipped: Skipped) -> Value {
-    json!({
-        "schema": 1,
-        "tolerance": tol,
-        "pairTests": pair_tests,
-        "pairTestsNeeded": pair_tests_needed,
-        "pairLimit": pair_limit,
-        "capped": capped,
-        "count": 0,
-        "returned": 0,
-        "offset": offset,
-        "truncated": false,
-        "loops": [],
-        "openChains": { "count": 0, "truncated": false, "chains": [] },
-        "junctions": { "count": 0, "truncated": false, "junctions": [] },
-        "skipped": skipped_json(skipped),
-    })
-}
-
-fn skipped_json(skipped: Skipped) -> Value {
-    let m: BTreeMap<&str, Value> =
-        skipped.into_iter().map(|(k, (n, why))| (k, json!({ "count": n, "reason": why.into_iter().collect::<Vec<_>>().join("; ") }))).collect();
-    json!(m)
-}
-
-fn skip(skipped: &mut Skipped, ty: &'static str, why: &'static str) {
-    let entry = skipped.entry(ty).or_default();
-    entry.0 += 1;
-    entry.1.insert(why);
-}
-
-/// The piece for a LINE or ARC, or `None` when the entity is not chainable.
-fn chainable(handle: Handle, kind: &EntityKind, skipped: &mut Skipped) -> Option<Piece> {
-    match kind {
-        EntityKind::Line(l) => {
-            let (a, b) = (l.a.xy(), l.b.xy());
-            if !a.is_finite() || !b.is_finite() || a.dist(b) <= EPS {
-                skip(skipped, "Line", "zero length");
-                return None;
-            }
-            Some(Piece { handle, start: a, end: b, arc: None })
-        }
-        EntityKind::Arc(a) => {
-            let (c, r) = (a.center.xy(), a.radius.abs());
-            if !c.is_finite() || !a.radius.is_finite() || r <= EPS || !a.start.is_finite() || !a.end.is_finite() {
-                skip(skipped, "Arc", "degenerate");
-                return None;
-            }
-            let arc = GeoArc::new(c, r, a.start, a.end);
-            let (start, end) = (arc.start_point(), arc.end_point());
-            if !start.is_finite() || !end.is_finite() {
-                skip(skipped, "Arc", "degenerate");
-                return None;
-            }
-            Some(Piece { handle, start, end, arc: Some(arc) })
-        }
-        _ => None,
-    }
-}
-
-fn find(parent: &mut [usize], mut x: usize) -> usize {
-    while let Some(&p) = parent.get(x) {
-        if p == x {
-            return x;
-        }
-        let gp = parent.get(p).copied().unwrap_or(p);
-        if let Some(slot) = parent.get_mut(x) {
-            *slot = gp;
-        }
-        x = gp;
-    }
-    x
-}
-
-/// Walk the cycles left after the open paths from a free end, and report their geometry.
-fn closed_loops(pieces: &[Piece], excluded: &[bool], link: &[Option<usize>], visited: &mut [bool], out: &mut Vec<Value>) {
-    for i in 0..pieces.len() {
-        if visited.get(i).copied().unwrap_or(true) || excluded.get(i).copied().unwrap_or(true) {
-            continue;
-        }
-        // Only a piece linked at both ends can be in a cycle.
-        if link.get(i * 2).copied().flatten().is_none() || link.get(i * 2 + 1).copied().flatten().is_none() {
-            continue;
-        }
-        let mut members: Vec<usize> = Vec::new();
-        let mut forward: Vec<bool> = Vec::new();
-        let (mut cur, mut entry) = (i, 0usize);
-        let mut closed = false;
-        loop {
-            if visited.get(cur).copied().unwrap_or(true) || members.len() >= pieces.len() {
-                break;
-            }
-            if let Some(slot) = visited.get_mut(cur) {
-                *slot = true;
-            }
-            members.push(cur);
-            forward.push(entry == 0);
-            let exit = 1 - entry;
-            let Some(q) = link.get(cur * 2 + exit).copied().flatten() else { break };
-            let (next, which) = (q / 2, q % 2);
-            if next == i && which == 0 {
-                closed = true;
-                break;
-            }
-            if visited.get(next).copied().unwrap_or(true) {
-                break;
-            }
-            cur = next;
-            entry = which;
-        }
-        if !closed || members.is_empty() {
-            continue;
-        }
-        let segs = traversed(pieces, &members, &forward);
-        let (perimeter, area, signed) = facts(&segs);
-        out.push(json!({
-            "members": members.iter().filter_map(|&m| pieces.get(m)).map(|p| p.handle.hex()).collect::<Vec<_>>(),
-            "perimeter": perimeter,
-            "area": area,
-            "winding": if signed < 0.0 { "cw" } else { "ccw" },
-        }));
-    }
-}
-
-/// Walk paths from every free end: an open chain, with the gap between its two ends.
-fn open_chains(pieces: &[Piece], excluded: &[bool], link: &[Option<usize>], visited: &mut [bool], out: &mut Vec<Value>) {
-    for i in 0..pieces.len() {
-        if visited.get(i).copied().unwrap_or(true) || excluded.get(i).copied().unwrap_or(true) {
-            continue;
-        }
-        let Some(entry0) = [0usize, 1].into_iter().find(|w| link.get(i * 2 + w).copied().flatten().is_none()) else { continue };
-        let mut members: Vec<usize> = Vec::new();
-        let mut forward: Vec<bool> = Vec::new();
-        let (mut cur, mut entry) = (i, entry0);
-        let mut exit = entry0;
-        loop {
-            if visited.get(cur).copied().unwrap_or(true) || members.len() >= pieces.len() {
-                break;
-            }
-            if let Some(slot) = visited.get_mut(cur) {
-                *slot = true;
-            }
-            members.push(cur);
-            forward.push(entry == 0);
-            exit = 1 - entry;
-            let Some(q) = link.get(cur * 2 + exit).copied().flatten() else { break };
-            let (next, which) = (q / 2, q % 2);
-            if visited.get(next).copied().unwrap_or(true) {
-                break;
-            }
-            cur = next;
-            entry = which;
-        }
-        let (Some(first_piece), Some(last_piece)) = (pieces.get(i), members.last().and_then(|&m| pieces.get(m))) else { continue };
-        let (first, last) = (first_piece.at(entry0), last_piece.at(exit));
-        let gap = first.dist(last);
-        let at = first * 0.5 + last * 0.5;
-        let length: f64 = members.iter().filter_map(|&m| pieces.get(m)).map(Piece::length).sum();
-        out.push(json!({
-            "members": members.iter().filter_map(|&m| pieces.get(m)).map(|p| p.handle.hex()).collect::<Vec<_>>(),
-            "gap": gap,
-            "at": [at.x, at.y],
-            "ends": [[first.x, first.y], [last.x, last.y]],
-            "length": length,
-        }));
-    }
-}
-
-fn traversed(pieces: &[Piece], members: &[usize], forward: &[bool]) -> Vec<Traversed> {
-    members
-        .iter()
-        .zip(forward)
-        .filter_map(|(&m, &fwd)| {
-            let p = pieces.get(m)?;
-            Some(Traversed { start: if fwd { p.start } else { p.end }, end: if fwd { p.end } else { p.start }, arc: p.arc.map(|a| (a, fwd)) })
-        })
-        .collect()
-}
-
-/// Perimeter, unsigned area and signed area (CCW positive, as SHAPES reports winding) of a closed
-/// chain of lines and arcs. The closing chord between the last end and the first is the chain's gap
-/// and counts in the perimeter, as an open polyline with matching ends does in SHAPES.
-fn facts(segs: &[Traversed]) -> (f64, f64, f64) {
-    let Some(first) = segs.first() else { return (0.0, 0.0, 0.0) };
-    let perimeter: f64 = segs.iter().map(seg_len).sum::<f64>() + segs.last().map_or(0.0, |last| last.end.dist(first.start));
-    let signed = signed_area(segs, first.start);
-    (perimeter, signed.abs(), signed)
-}
-
-fn seg_len(t: &Traversed) -> f64 {
-    match t.arc {
-        Some((a, _)) => a.radius * a.sweep(),
-        None => t.start.dist(t.end),
-    }
-}
-
-/// Green's theorem over the closed path, measured about its first point so a small loop far from
-/// the origin keeps its area. An arc contributes its exact circular integral, not a tessellation.
-fn signed_area(segs: &[Traversed], origin: Vec2) -> f64 {
-    let mut twice = 0.0;
-    for t in segs {
-        match t.arc {
-            None => twice += (t.start - origin).cross(t.end - origin),
-            Some((a, forward)) => {
-                let sweep = a.sweep();
-                let (from, to, d) = if forward { (a.start, a.start + sweep, sweep) } else { (a.end, a.end - sweep, -sweep) };
-                let c = a.center - origin;
-                twice += a.radius * a.radius * d + a.radius * (c.x * (to.sin() - from.sin()) - c.y * (to.cos() - from.cos()));
-            }
-        }
-    }
-    twice / 2.0
-}

crates/engine/src/cmd/inquiry/regions.rs

@@ -11,12 +11,9 @@ use cadcraft_geom::{Line, Vec2, line_line, point_in_polygon};
 use serde_json::{Value, json};
 
 use super::super::machines::{SelOutcome, SelectPhase, SelectRun};
-use super::super::{CommandSpec, bad, targets};
-
-use super::SelfCheck;
+use super::super::*;
 use crate::{EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
-/// The region commands: UNION, SUBTRACT and INTERSECT combine regions, MASSPROP measures them.
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         CommandSpec::new("union", "Union", run_union)
@@ -36,7 +33,7 @@ pub fn specs() -> Vec<CommandSpec> {
             .interactive(|_| Ok(Box::new(SelectRun::new("intersect", "INTERSECT")))),
         CommandSpec::new("massprop", "Region/Mass Properties", run_massprop)
             .menu(&["Tools", "Inquiry", "Region/Mass Properties"])
-            .params("{handles?} (regions) → properties of each, plus `selfCheck` (found/analyzed/skipped with reasons, caps, implausible values)")
+            .params("{handles?} (regions) → properties of each")
             .noundo()
             .interactive(|_| Ok(Box::new(SelectRun::new("massprop", "MASSPROP")))),
     ]
@@ -214,16 +211,13 @@ impl Interactive for SubtractM {
     fn name(&self) -> &'static str {
         "SUBTRACT"
     }
-    /// Tell the user what to select first: the regions to subtract from.
     fn begin(&mut self, s: &mut Session) -> Result<Step> {
         s.echo("Select regions to subtract from ..");
         Ok(Step::Continue)
     }
-    /// Prompt for the current selection phase (regions to subtract from, then regions to remove).
     fn prompt(&self, _s: &Session) -> Prompt {
         self.sel.prompt()
     }
-    /// The first selection is the regions to subtract from; the second is subtracted from them.
     fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
         match self.sel.feed(s, &i)? {
             SelOutcome::More => Ok(Step::Continue),
@@ -249,38 +243,18 @@ impl Interactive for SubtractM {
     }
 }
 
-/// MASSPROP: area, perimeter, bounding box, centroid, moments of inertia and principal directions
-/// for each selected region, plus a self-check of what was measured, skipped and found
-/// implausible.
 fn run_massprop(s: &mut Session, p: &Value) -> Result<Value> {
     let hs = targets(s, p)?;
     let rs = regions(s, &hs)?;
     if rs.is_empty() {
         return Err(other("Select one or more regions."));
     }
-    let mut check = SelfCheck::new();
-    let d = s.doc()?;
-    let extents = d.extents(&s.space());
-    // No visible extents means no bound to compare an area against (`implausible` skips an
-    // infinite bound).
-    let extents_area = if extents.is_empty() { f64::INFINITY } else { extents.width() * extents.height() };
-    for h in &hs {
-        check.found(1);
-        match d.entity(*h).map(|e| &e.kind) {
-            Some(EntityKind::Region(_)) => check.analyzed(1),
-            Some(kind) => check.skip(kind.type_name(), "not a region", 1),
-            None => check.skip("Missing", "no such object", 1),
-        }
-    }
     let f = |v: f64| super::fmt_d(s, v);
     let mut out = Vec::new();
     let mut lines = Vec::new();
     for (h, r) in &rs {
         let m = r.props();
         let c = m.centroid;
-        let diagonal = if m.bounds.is_empty() { 0.0 } else { m.bounds.min.dist(m.bounds.max) };
-        check.implausible(*h, "Region", "perimeter", m.perimeter, diagonal * 10.0, "perimeter is more than 10 x the bounding-box diagonal");
-        check.implausible(*h, "Region", "area", m.area, extents_area, "area is larger than the drawing extents");
         // Moments about the centroid, and the principal moments and directions.
         let [ixc, iyc, ixyc] = m.centroid_moments;
         let mid = (ixc + iyc) / 2.0;
@@ -318,5 +292,5 @@ fn run_massprop(s: &mut Session, p: &Value) -> Result<Value> {
             ang.cos(),
         ));
     }
-    Ok(json!({ "regions": out, "selfCheck": check.to_json(), "message": lines.join("\n") }))
+    Ok(json!({ "regions": out, "message": lines.join("\n") }))
 }

crates/engine/src/cmd/inquiry/shapes.rs

@@ -2,39 +2,26 @@
 //! winding, the first self-intersection and coincident vertices — for agents that read a drawing.
 //! Read-only.
 
+use std::collections::{BTreeMap, BTreeSet};
+
 use cadcraft_doc::{Entity, EntityKind};
 use cadcraft_geom::{Bounds2, Polyline, Vec2, intersect_segments};
 use serde_json::{Value, json};
 
-use super::super::bad;
-
-use super::super::point_value;
-use super::{SelfCheck, area_of, object_area};
+use super::super::*;
+use super::{area_of, object_area};
 use crate::{Result, Session};
 
 const CMD: &str = "shapes";
 
-pub const PARAMS: &str = "{type?, layer?, window?: [[x,y],[x,y]], crossing?: bool (default true; false = entirely inside), limit? (default 200), offset?, tolerance?: positive number (default 1e-9 × the extents diagonal; near-duplicate vertices and a first vertex equal to the last)} → {schema: 1, count (all closed shapes), returned, offset, truncated, shapes: [{handle, type, layer, perimeter, area (≥ 0), winding: ccw|cw, centroid: [x,y] | null (zero area), selfIntersection: [x,y] | null (the first crossing of two non-adjacent edges; null past 4000 edges), duplicateVertices: [{index, distance} (vertices index and index+1, wrapping)]}], skipped: {<type>: {count, reason}} (the other matches), selfCheck: {schema, found, analyzed, skipped: {<type>: {count, reason}}, caps: {<name>: <value>}, implausible: [{handle, type, field, value, bound, reason}]} (what the analysis covered, the caps it hit, and values that point at a bug)}: closed polylines, circles, full ellipses and closed splines, arcs and bulges exact";
+pub const PARAMS: &str = "{type?, layer?, window?: [[x,y],[x,y]], crossing?: bool (default true; false = entirely inside), limit? (default 200), offset?, tolerance?: positive number (default 1e-9 × the extents diagonal; near-duplicate vertices and a first vertex equal to the last)} → {schema: 1, count (all closed shapes), returned, offset, truncated, shapes: [{handle, type, layer, perimeter, area (≥ 0), winding: ccw|cw, centroid: [x,y] | null (zero area), selfIntersection: [x,y] | null (the first crossing of two non-adjacent edges; null past 4000 edges), duplicateVertices: [{index, distance} (vertices index and index+1, wrapping)]}], skipped: {<type>: {count, reason}} (the other matches)}: closed polylines, circles, full ellipses and closed splines, arcs and bulges exact";
 
 /// The facts SHAPES reports for one closed shape, or why an entity is not one.
 enum Facts {
-    Shape {
-        perimeter: f64,
-        area: f64,
-        signed: f64,
-        centroid: Option<Vec2>,
-        cross: Option<Vec2>,
-        /// The shape had more edges than the self-intersection cap checks.
-        cross_capped: bool,
-        dups: Vec<(usize, f64)>,
-        bounds: Bounds2,
-    },
+    Shape { perimeter: f64, area: f64, signed: f64, centroid: Option<Vec2>, cross: Option<Vec2>, dups: Vec<(usize, f64)> },
     Skip(&'static str),
 }
 
-/// SHAPES: geometry facts for every closed shape that matches the filters in the current space,
-/// paged by `offset`/`limit`, with the self-check of what was found, analysed, skipped and
-/// flagged.
 pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
     let given = |k: &str| p.get(k).filter(|v| !v.is_null());
     let text = |k: &str| -> Result<Option<String>> {
@@ -65,29 +52,15 @@ pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
     let s: &Session = s;
     let st = s.state()?;
     let d = &st.doc;
-    let empty = || {
-        json!({
-            "schema": 1,
-            "count": 0,
-            "returned": 0,
-            "offset": offset,
-            "truncated": false,
-            "shapes": [],
-            "skipped": {},
-            "selfCheck": SelfCheck::new().to_json(),
-        })
-    };
+    let empty = || json!({ "schema": 1, "count": 0, "returned": 0, "offset": offset, "truncated": false, "shapes": [], "skipped": {} });
     let Some(store) = d.space(&st.space) else { return Ok(empty()) };
-    let extents = d.extents(&st.space);
-    // No visible extents means no bound to compare an area against (`implausible` skips an
-    // infinite bound).
-    let extents_area = if extents.is_empty() { f64::INFINITY } else { extents.width() * extents.height() };
     let tol = tolerance.unwrap_or_else(|| {
-        let diag = if extents.is_empty() { 0.0 } else { extents.min.dist(extents.max) };
+        let ext = d.extents(&st.space);
+        let diag = if ext.is_empty() { 0.0 } else { ext.min.dist(ext.max) };
         (diag * 1e-9).max(1e-12)
     });
     let wtol = window.as_ref().map(crate::select::window_tol).unwrap_or(0.0);
-    let mut check = SelfCheck::new();
+    let mut skipped: BTreeMap<&str, (usize, BTreeSet<&str>)> = BTreeMap::new();
     let mut shapes: Vec<(&Entity, Facts)> = Vec::new();
     for e in store
         .iter()
@@ -95,51 +68,31 @@ pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
         .filter(|e| layer.as_ref().is_none_or(|l| e.common.layer.to_ascii_lowercase() == *l))
         .filter(|e| window.as_ref().is_none_or(|w| crate::select::in_window(d, e, None, w, crossing, wtol)))
     {
-        check.found(1);
         match facts(s, e, tol)? {
-            Facts::Skip(why) => check.skip(e.kind.type_name(), why, 1),
-            f => {
-                check.analyzed(1);
-                if let Facts::Shape { perimeter, area, cross_capped, bounds, .. } = &f {
-                    if *cross_capped {
-                        check.cap("crossingSegments", MAX_CROSSING_SEGMENTS as u64);
-                    }
-                    let diagonal = if bounds.is_empty() { 0.0 } else { bounds.min.dist(bounds.max) };
-                    check.implausible(
-                        e.handle,
-                        e.kind.type_name(),
-                        "perimeter",
-                        *perimeter,
-                        diagonal * 10.0,
-                        "perimeter is more than 10 x the bounding-box diagonal",
-                    );
-                    check.implausible(e.handle, e.kind.type_name(), "area", *area, extents_area, "area is larger than the drawing extents");
-                }
-                shapes.push((e, f));
+            Facts::Skip(why) => {
+                let entry = skipped.entry(e.kind.type_name()).or_default();
+                entry.0 += 1;
+                entry.1.insert(why);
             }
+            f => shapes.push((e, f)),
         }
     }
     let page: Vec<Value> = shapes.iter().skip(offset).take(limit).map(|(e, f)| shape_json(e, f)).collect();
-    let truncated = page.len() < shapes.len().saturating_sub(offset);
-    if truncated {
-        check.cap("limit", u64::try_from(limit).unwrap_or(u64::MAX));
-    }
-    let skipped = check.skipped_json();
+    let skipped: BTreeMap<&str, Value> =
+        skipped.into_iter().map(|(k, (n, why))| (k, json!({ "count": n, "reason": why.into_iter().collect::<Vec<_>>().join("; ") }))).collect();
     Ok(json!({
         "schema": 1,
         "count": shapes.len(),
         "returned": page.len(),
         "offset": offset,
-        "truncated": truncated,
+        "truncated": page.len() < shapes.len().saturating_sub(offset),
         "shapes": page,
         "skipped": skipped,
-        "selfCheck": check.to_json(),
     }))
 }
 
-/// One analysed shape as the JSON object the command reports (null if `f` is not a shape).
 fn shape_json(e: &Entity, f: &Facts) -> Value {
-    let Facts::Shape { perimeter, area, signed, centroid, cross, dups, .. } = f else { return Value::Null };
+    let Facts::Shape { perimeter, area, signed, centroid, cross, dups } = f else { return Value::Null };
     json!({
         "handle": e.handle.hex(),
         "type": e.kind.type_name(),
@@ -153,24 +106,11 @@ fn shape_json(e: &Entity, f: &Facts) -> Value {
     })
 }
 
-/// The facts SHAPES reports for one entity, or the reason it is not a closed shape: circles,
-/// full ellipses, closed or self-closing polylines and splines are measured, arcs and everything
-/// else are skipped.
 fn facts(s: &Session, e: &Entity, tol: f64) -> Result<Facts> {
     Ok(match &e.kind {
         EntityKind::Circle(c) => {
             let (area, perimeter) = object_area(s, e.handle)?;
-            let r = Vec2::new(c.radius, c.radius);
-            Facts::Shape {
-                perimeter,
-                area,
-                signed: area,
-                centroid: Some(c.center.xy()),
-                cross: None,
-                cross_capped: false,
-                dups: Vec::new(),
-                bounds: Bounds2::new(c.center.xy() - r, c.center.xy() + r),
-            }
+            Facts::Shape { perimeter, area, signed: area, centroid: Some(c.center.xy()), cross: None, dups: Vec::new() }
         }
         EntityKind::Ellipse(el) => {
             let geom = cadcraft_geom::Ellipse { center: el.center.xy(), major: el.major.xy(), ratio: el.ratio, start: el.start, end: el.end };
@@ -178,16 +118,7 @@ fn facts(s: &Session, e: &Entity, tol: f64) -> Result<Facts> {
                 return Ok(Facts::Skip("open"));
             }
             let (area, perimeter) = object_area(s, e.handle)?;
-            Facts::Shape {
-                perimeter,
-                area,
-                signed: area,
-                centroid: Some(geom.center),
-                cross: None,
-                cross_capped: false,
-                dups: Vec::new(),
-                bounds: geom.bounds(),
-            }
+            Facts::Shape { perimeter, area, signed: area, centroid: Some(geom.center), cross: None, dups: Vec::new() }
         }
         EntityKind::LwPolyline(pl) => {
             let mut vertices = pl.vertices.clone();
@@ -214,8 +145,7 @@ fn facts(s: &Session, e: &Entity, tol: f64) -> Result<Facts> {
                     (dist <= tol).then_some((i, dist))
                 })
                 .collect();
-            let (cross, cross_capped) = first_crossing(&g);
-            Facts::Shape { perimeter: g.len(), area: signed.abs(), signed, centroid: g.centroid(), cross, cross_capped, dups, bounds: g.bounds() }
+            Facts::Shape { perimeter: g.len(), area: signed.abs(), signed, centroid: g.centroid(), cross: first_crossing(&g), dups }
         }
         EntityKind::Spline(sp) => {
             let mut pts = sp.tessellate(1e-3);
@@ -232,11 +162,9 @@ fn facts(s: &Session, e: &Entity, tol: f64) -> Result<Facts> {
             if pts.len() < 3 {
                 return Ok(Facts::Skip("degenerate"));
             }
-            let bounds = Bounds2::from_points(pts.iter().copied());
             let (area, perimeter) = area_of(&pts);
             let g = Polyline::from_points(&pts, true);
-            let (cross, cross_capped) = first_crossing(&g);
-            Facts::Shape { perimeter, area, signed: g.area(), centroid: g.centroid(), cross, cross_capped, dups: Vec::new(), bounds }
+            Facts::Shape { perimeter, area, signed: g.area(), centroid: g.centroid(), cross: first_crossing(&g), dups: Vec::new() }
         }
         EntityKind::Arc(_) => Facts::Skip("open"),
         _ => Facts::Skip("not a closed shape"),
@@ -246,14 +174,13 @@ fn facts(s: &Session, e: &Entity, tol: f64) -> Result<Facts> {
 /// Shapes with more edges than this report no selfIntersection.
 const MAX_CROSSING_SEGMENTS: usize = 4_000;
 
-/// The first crossing between two non-adjacent edges, in edge order, and whether the shape was
-/// too large to check (the cap applies even if a crossing lies among the first edges).
-fn first_crossing(g: &Polyline) -> (Option<Vec2>, bool) {
+/// The first crossing between two non-adjacent edges, in edge order.
+fn first_crossing(g: &Polyline) -> Option<Vec2> {
     let segs = g.segments();
     let n = segs.len();
     // The pairwise test is quadratic: past this many edges the answer is null, not a hang.
     if n > MAX_CROSSING_SEGMENTS {
-        return (None, true);
+        return None;
     }
     for (i, a) in segs.iter().enumerate() {
         for (j, b) in segs.iter().enumerate().skip(i + 2) {
@@ -261,9 +188,9 @@ fn first_crossing(g: &Polyline) -> (Option<Vec2>, bool) {
                 continue;
             }
             if let Some(x) = intersect_segments(a, b).first() {
-                return (Some(*x), false);
+                return Some(*x);
             }
         }
     }
-    (None, false)
+    None
 }

crates/engine/src/cmd/inquiry/usage.rs

@@ -1,436 +0,0 @@
-//! USAGE: a read-only cross-reference of the named objects a drawing uses — for each layer,
-//! block, text style and linetype, how many objects use it, whether they are only inside block
-//! definitions, and which are empty or unused. The unused lists are PURGE's scan (see
-//! `cmd::blocks::purge`); nothing here changes or deletes anything.
-
-use std::collections::{HashMap, HashSet};
-
-use cadcraft_doc::{Drawing, Entity, EntityKind};
-use serde_json::{Value, json};
-
-use super::super::bad;
-use super::super::blocks::purge;
-
-use crate::{Result, Session};
-
-const CMD: &str = "usage";
-/// Names listed per kind in `unused`; the counts are complete unless the scan was cut short
-/// (`incomplete`).
-const MAX_NAMES: usize = 5_000;
-/// The most objects one scan reads, across model space, the layouts and the block definitions. A
-/// drawing with more is reported as `incomplete` instead of with counts that look complete. This
-/// is USAGE's own limit; PURGE's scan limit is separate and unchanged.
-const MAX_SCAN: usize = 5_000_000;
-
-pub const PARAMS: &str = "{type?: layers|blocks|textstyles|linetypes|all (default all), limit? (default 200), offset?} → \
-    {schema: 1, count (all items of the type), returned, offset, truncated, incomplete (true when the drawing has more \
-    objects than one scan reads, so every count, status and summary is partial), incompleteReason? (why), \
-    items: [{type: layer|block|textStyle|linetype, name, entities (objects in model space and layouts that use it), \
-    blockEntities (objects in block definitions that use it), references (named objects that use it: a layer's linetype, \
-    a text style's dimension and multileader styles), used (for a block: reachable from model space, a layout or a dimension), \
-    insideBlocksOnly (used, but by block definitions only), empty (nothing refers to it), unused (PURGE would offer it), \
-    current? (the current layer, text style or linetype)}], \
-    summary: {<kind>: {total, used, insideBlocksOnly, empty, unused}}, \
-    unused: {<kind>: {count, returned, truncated, names}} (PURGE's scan, in table order)}";
-
-/// The four kinds of named object USAGE reports.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Category {
-    Layer,
-    Block,
-    TextStyle,
-    Linetype,
-}
-
-impl Category {
-    const ALL: [Category; 4] = [Category::Layer, Category::Block, Category::TextStyle, Category::Linetype];
-
-    /// The singular JSON `type` value of this kind (`layer`, `block`, `textStyle`, `linetype`).
-    fn key(self) -> &'static str {
-        match self {
-            Category::Layer => "layer",
-            Category::Block => "block",
-            Category::TextStyle => "textStyle",
-            Category::Linetype => "linetype",
-        }
-    }
-    /// The JSON key under which this kind's objects are grouped (`layers`, `blocks`,
-    /// `textStyles`, `linetypes`).
-    fn plural(self) -> &'static str {
-        match self {
-            Category::Layer => "layers",
-            Category::Block => "blocks",
-            Category::TextStyle => "textStyles",
-            Category::Linetype => "linetypes",
-        }
-    }
-    /// The capitalised plural noun used in the human-readable message.
-    fn label(self) -> &'static str {
-        match self {
-            Category::Layer => "Layers",
-            Category::Block => "Blocks",
-            Category::TextStyle => "Text styles",
-            Category::Linetype => "Linetypes",
-        }
-    }
-    /// The PURGE kind whose scan answers whether this kind's objects are unused.
-    fn purge(self) -> purge::Kind {
-        match self {
-            Category::Layer => purge::Kind::Layers,
-            Category::Block => purge::Kind::Blocks,
-            Category::TextStyle => purge::Kind::TextStyles,
-            Category::Linetype => purge::Kind::Linetypes,
-        }
-    }
-    /// `None` for an unknown name, `Some(None)` for all kinds.
-    fn parse(s: &str) -> Option<Option<Category>> {
-        match s.trim().to_ascii_lowercase().as_str() {
-            "" | "all" => Some(None),
-            "layer" | "layers" => Some(Some(Category::Layer)),
-            "block" | "blocks" => Some(Some(Category::Block)),
-            "style" | "styles" | "textstyle" | "textstyles" | "text_style" | "text_styles" => Some(Some(Category::TextStyle)),
-            "linetype" | "linetypes" | "ltype" | "ltypes" => Some(Some(Category::Linetype)),
-            _ => None,
-        }
-    }
-}
-
-/// Objects in model space and the layouts (`false`), and in block definitions (`true`), up to
-/// `limit` — the USAGE scan limit, past which later objects are not read.
-fn each_entity(d: &Drawing, limit: usize) -> impl Iterator<Item = (&Entity, bool)> {
-    let top = d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).map(|e| (&**e, false));
-    let blocks = d.blocks.values().flat_map(|b| b.entities.iter()).map(|e| (&**e, true));
-    top.chain(blocks).take(limit)
-}
-
-/// Objects in model space, the layouts and the block definitions — everything one scan reads.
-fn entity_total(d: &Drawing) -> usize {
-    d.blocks.values().fold(d.entity_count(), |n, b| n.saturating_add(b.entities.len()))
-}
-
-/// A scan that stopped at its limit: the drawing holds `total` objects but only the first
-/// `scanned` were read, so objects after the limit are missing from the counts, verdicts and
-/// summary. Present in the report as `incomplete`/`incompleteReason`, never silently.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-struct Incomplete {
-    scanned: usize,
-    total: usize,
-}
-
-impl Incomplete {
-    /// Why the report is partial, naming both counts so a caller can judge it.
-    fn reason(self) -> String {
-        format!(
-            "USAGE read the first {} of {} objects (model space, layouts and block definitions); \
-             references after the limit are missing, so counts, statuses and summaries are partial",
-            self.scanned, self.total
-        )
-    }
-}
-
-/// Uses per lower-case name: (in model space and layouts, in block definitions).
-type Uses = HashMap<String, (usize, usize)>;
-
-/// Counts one use of a named object, separately for model space and the layouts (`in_block`
-/// false) and for block definitions (`in_block` true); names compare case-insensitively.
-fn bump(map: &mut Uses, name: &str, in_block: bool) {
-    let slot = map.entry(name.to_ascii_lowercase()).or_default();
-    if in_block {
-        slot.1 = slot.1.saturating_add(1);
-    } else {
-        slot.0 = slot.0.saturating_add(1);
-    }
-}
-
-/// Counts one named table entry that refers to `name`: a layer's linetype, or a dimension or
-/// multileader style's text style. Names compare case-insensitively.
-fn bump_reference(map: &mut HashMap<String, usize>, name: &str) {
-    let slot = map.entry(name.to_ascii_lowercase()).or_default();
-    *slot = slot.saturating_add(1);
-}
-
-/// `ByLayer` and `ByBlock` name a value, not the linetype table's entries.
-fn linetype_value(name: &str) -> bool {
-    name.eq_ignore_ascii_case("ByLayer") || name.eq_ignore_ascii_case("ByBlock")
-}
-
-/// Every use of the drawing's layers, blocks, text styles and linetypes, in one pass over the
-/// objects (plus the block reachability PURGE already computes).
-#[derive(Default)]
-struct Scan {
-    layers: Uses,
-    blocks: Uses,
-    styles: Uses,
-    linetypes: Uses,
-    /// Dimension and multileader styles that name a text style.
-    style_refs: HashMap<String, usize>,
-    /// Layers that name a linetype.
-    linetype_refs: HashMap<String, usize>,
-    /// Upper-case names of blocks reachable from model space, the layouts and dimensions.
-    used_blocks: HashSet<String>,
-    /// Set when the scan stopped at its limit, so every count and verdict is partial.
-    incomplete: Option<Incomplete>,
-}
-
-impl Scan {
-    /// Scans the drawing once, reading at most `limit` objects: counts each entity's layer,
-    /// explicit linetype, block, text style and attribute style, plus the table references, and
-    /// borrows block reachability from PURGE. Records whether the limit cut the drawing short.
-    fn new(d: &Drawing, limit: usize) -> Scan {
-        let total = entity_total(d);
-        let scanned = total.min(limit);
-        let mut sc = Scan { used_blocks: purge::used_blocks(d), ..Scan::default() };
-        sc.incomplete = (scanned < total).then_some(Incomplete { scanned, total });
-        for (e, in_block) in each_entity(d, scanned) {
-            bump(&mut sc.layers, &e.common.layer, in_block);
-            if !linetype_value(&e.common.linetype) {
-                bump(&mut sc.linetypes, &e.common.linetype, in_block);
-            }
-            match &e.kind {
-                EntityKind::Insert(i) => {
-                    bump(&mut sc.blocks, &i.block, in_block);
-                    for a in &i.attribs {
-                        bump(&mut sc.styles, &a.text.style, in_block);
-                    }
-                }
-                EntityKind::Dimension(dm) => {
-                    if let Some(b) = &dm.block {
-                        bump(&mut sc.blocks, b, in_block);
-                    }
-                }
-                EntityKind::MLeader(m) => {
-                    if let Some(b) = &m.block {
-                        bump(&mut sc.blocks, &b.block, in_block);
-                    }
-                    if let Some(t) = &m.text {
-                        bump(&mut sc.styles, &t.style, in_block);
-                    }
-                }
-                EntityKind::Text(t) => bump(&mut sc.styles, &t.style, in_block),
-                EntityKind::MText(t) => bump(&mut sc.styles, &t.style, in_block),
-                EntityKind::AttDef(a) => bump(&mut sc.styles, &a.text.style, in_block),
-                _ => {}
-            }
-        }
-        for st in &d.dim_styles {
-            bump_reference(&mut sc.style_refs, &st.text_style);
-        }
-        for st in &d.mleader_styles {
-            bump_reference(&mut sc.style_refs, &st.text_style);
-        }
-        for l in &d.layers {
-            if !linetype_value(&l.linetype) {
-                bump_reference(&mut sc.linetype_refs, &l.linetype);
-            }
-        }
-        sc
-    }
-}
-
-/// PURGE's unused lists, kept once so each item can say whether PURGE would offer it.
-struct Unused {
-    lists: Vec<(Category, Vec<String>, HashSet<String>)>,
-}
-
-impl Unused {
-    /// Runs PURGE's unused scan for all four kinds, keeping each list in table order plus a
-    /// lower-case set for fast membership checks.
-    fn new(d: &Drawing) -> Unused {
-        let lists = Category::ALL
-            .into_iter()
-            .map(|c| {
-                let names = purge::candidates(d, c.purge());
-                let lower = names.iter().map(|n| n.to_ascii_lowercase()).collect();
-                (c, names, lower)
-            })
-            .collect();
-        Unused { lists }
-    }
-    /// Whether PURGE would offer `name` of kind `c` as unused (case-insensitive).
-    fn has(&self, c: Category, name: &str) -> bool {
-        self.lists.iter().find(|(k, ..)| *k == c).is_some_and(|(_, _, lower)| lower.contains(&name.to_ascii_lowercase()))
-    }
-    /// How many objects of kind `c` PURGE would offer — the full count, even when the name list
-    /// in the JSON output is truncated.
-    fn count(&self, c: Category) -> usize {
-        self.lists.iter().find(|(k, ..)| *k == c).map_or(0, |(_, names, _)| names.len())
-    }
-    /// The `unused` member: per kind, the total count, the returned page of names capped at
-    /// `MAX_NAMES`, and whether that page is truncated.
-    fn json(&self) -> Value {
-        let mut out = serde_json::Map::new();
-        for (c, names, _) in &self.lists {
-            let page: Vec<&String> = names.iter().take(MAX_NAMES).collect();
-            out.insert(
-                c.plural().into(),
-                json!({
-                    "count": names.len(),
-                    "returned": page.len(),
-                    "truncated": page.len() < names.len(),
-                    "names": page,
-                }),
-            );
-        }
-        Value::Object(out)
-    }
-}
-
-/// One report item: the use counts, the caller's `used`/`empty` verdicts, `insideBlocksOnly`
-/// derived from those counts and PURGE's `unused` answer. `current` is emitted only for the kinds
-/// that have a current entry (layers, text styles and linetypes).
-fn item_json(
-    c: Category,
-    name: &str,
-    (entities, block_entities): (usize, usize),
-    references: usize,
-    (used, empty): (bool, bool),
-    current: Option<bool>,
-    unused: &Unused,
-) -> Value {
-    let mut v = json!({
-        "type": c.key(),
-        "name": name,
-        "entities": entities,
-        "blockEntities": block_entities,
-        "references": references,
-        "used": used,
-        "insideBlocksOnly": used && entities == 0 && block_entities > 0 && references == 0,
-        "empty": empty,
-        "unused": unused.has(c, name),
-    });
-    if let (Some(cur), Some(o)) = (current, v.as_object_mut()) {
-        o.insert("current".into(), json!(cur));
-    }
-    v
-}
-
-/// Builds one item per named object in table order — layers, blocks, text styles, linetypes —
-/// reading the scanned use counts and adding the current-object flag where the drawing has one.
-fn items(scan: &Scan, unused: &Unused, d: &Drawing) -> Vec<Value> {
-    let mut out = Vec::new();
-    let current_layer = d.header.str("CLAYER", "0");
-    for l in &d.layers {
-        let (e, b) = scan.layers.get(&l.name.to_ascii_lowercase()).copied().unwrap_or_default();
-        let uses = e.saturating_add(b);
-        let cur = l.name.eq_ignore_ascii_case(&current_layer);
-        out.push(item_json(Category::Layer, &l.name, (e, b), 0, (uses > 0, uses == 0), Some(cur), unused));
-    }
-    for b in d.blocks.values() {
-        let (e, n) = scan.blocks.get(&b.name.to_ascii_lowercase()).copied().unwrap_or_default();
-        // A definition is used when a reference to it is reachable, as PURGE counts it.
-        let used = scan.used_blocks.contains(&b.name.to_ascii_uppercase());
-        out.push(item_json(Category::Block, &b.name, (e, n), 0, (used, e.saturating_add(n) == 0), None, unused));
-    }
-    let current_style = d.header.str("TEXTSTYLE", "Standard");
-    for t in &d.text_styles {
-        let (e, b) = scan.styles.get(&t.name.to_ascii_lowercase()).copied().unwrap_or_default();
-        let r = scan.style_refs.get(&t.name.to_ascii_lowercase()).copied().unwrap_or(0);
-        let uses = e.saturating_add(b).saturating_add(r);
-        let cur = t.name.eq_ignore_ascii_case(&current_style);
-        out.push(item_json(Category::TextStyle, &t.name, (e, b), r, (uses > 0, uses == 0), Some(cur), unused));
-    }
-    let current_linetype = d.header.str("CELTYPE", "ByLayer");
-    for t in &d.linetypes {
-        let (e, b) = scan.linetypes.get(&t.name.to_ascii_lowercase()).copied().unwrap_or_default();
-        let r = scan.linetype_refs.get(&t.name.to_ascii_lowercase()).copied().unwrap_or(0);
-        let uses = e.saturating_add(b).saturating_add(r);
-        let cur = t.name.eq_ignore_ascii_case(&current_linetype);
-        out.push(item_json(Category::Linetype, &t.name, (e, b), r, (uses > 0, uses == 0), Some(cur), unused));
-    }
-    out
-}
-
-/// Totals per kind over every item — total, used, inside blocks only, empty — plus how many
-/// objects of that kind PURGE would offer.
-fn summary(items: &[Value], unused: &Unused) -> Value {
-    let mut out = serde_json::Map::new();
-    for c in Category::ALL {
-        let mut total = 0usize;
-        let mut used = 0usize;
-        let mut inside = 0usize;
-        let mut empty = 0usize;
-        for it in items.iter().filter(|i| i["type"] == c.key()) {
-            total = total.saturating_add(1);
-            used = used.saturating_add(usize::from(it["used"].as_bool() == Some(true)));
-            inside = inside.saturating_add(usize::from(it["insideBlocksOnly"].as_bool() == Some(true)));
-            empty = empty.saturating_add(usize::from(it["empty"].as_bool() == Some(true)));
-        }
-        out.insert(c.plural().into(), json!({ "total": total, "used": used, "insideBlocksOnly": inside, "empty": empty, "unused": unused.count(c) }));
-    }
-    Value::Object(out)
-}
-
-/// The human-readable summary, one line per kind, plus a note when the filter matched no named
-/// objects at all and a note when the scan was cut short.
-fn message(items: &[&Value], summary: &Value, incomplete: Option<Incomplete>) -> String {
-    let mut lines = Vec::new();
-    for c in Category::ALL {
-        let s = &summary[c.plural()];
-        lines.push(format!(
-            "{}: {} total, {} used, {} inside blocks only, {} empty, {} unused.",
-            c.label(),
-            s["total"].as_u64().unwrap_or(0),
-            s["used"].as_u64().unwrap_or(0),
-            s["insideBlocksOnly"].as_u64().unwrap_or(0),
-            s["empty"].as_u64().unwrap_or(0),
-            s["unused"].as_u64().unwrap_or(0),
-        ));
-    }
-    if items.is_empty() {
-        lines.push("There are no named objects of this type.".into());
-    }
-    if let Some(inc) = incomplete {
-        lines.push(format!("Scan incomplete: read the first {} of {} objects; the counts above are partial.", inc.scanned, inc.total));
-    }
-    lines.join("\n")
-}
-
-/// Runs `USAGE`: validates `type`, `limit` and `offset` (rejecting bad input without touching the
-/// drawing), scans read-only, and returns the paged items with the per-kind summary, PURGE's
-/// unused lists and the message.
-pub fn run(s: &mut Session, p: &Value) -> Result<Value> {
-    let given = |k: &str| p.get(k).filter(|v| !v.is_null());
-    let count = |k: &str, default: usize| -> Result<usize> {
-        given(k).map_or(Ok(default), |v| {
-            v.as_u64().map(|n| usize::try_from(n).unwrap_or(usize::MAX)).ok_or_else(|| bad(CMD, format!("`{k}` must be a whole number, 0 or more")))
-        })
-    };
-    let ty = match given("type") {
-        None => None,
-        Some(Value::String(t)) => {
-            Category::parse(t).ok_or_else(|| bad(CMD, format!("`type` must be layers, blocks, textstyles, linetypes or all, got \"{t}\"")))?
-        }
-        Some(v) => return Err(bad(CMD, format!("`type` must be a string, got {v}"))),
-    };
-    let limit = count("limit", 200)?;
-    let offset = count("offset", 0)?;
-    let st = s.state()?;
-    let d = &st.doc;
-    let scan = Scan::new(d, MAX_SCAN);
-    let unused = Unused::new(d);
-    let all = items(&scan, &unused, d);
-    let matched: Vec<&Value> = all.iter().filter(|i| ty.is_none_or(|c| i["type"] == c.key())).collect();
-    let total = matched.len();
-    let page: Vec<&Value> = matched.iter().skip(offset).take(limit).copied().collect();
-    let summary = summary(&all, &unused);
-    let mut out = json!({
-        "schema": 1,
-        "count": total,
-        "returned": page.len(),
-        "offset": offset,
-        "truncated": page.len() < total.saturating_sub(offset),
-        "incomplete": scan.incomplete.is_some(),
-        "items": page,
-        "summary": summary,
-        "unused": unused.json(),
-        "message": message(&matched, &summary, scan.incomplete),
-    });
-    if let (Some(inc), Some(o)) = (scan.incomplete, out.as_object_mut()) {
-        o.insert("incompleteReason".into(), json!(inc.reason()));
-    }
-    Ok(out)
-}
-
-#[cfg(test)]
-#[path = "usage_tests.rs"]
-mod tests;

crates/engine/src/cmd/inquiry/usage_tests.rs

@@ -1,59 +0,0 @@
-//! Unit tests for USAGE's scan limit (#1439): a scan cut at its limit must say so. A drawing with
-//! more than 5,000,000 objects is impractical to build in a test, so the limit is a parameter and
-//! these tests cut a tiny drawing instead.
-
-use std::sync::Arc;
-
-use cadcraft_doc::{Block, Common, Drawing, Entity, EntityKind, Handle, Line};
-use cadcraft_geom::Vec3;
-
-use super::{Incomplete, Scan, entity_total};
-
-/// A LINE on `layer`, one unit long.
-fn line(handle: u64, layer: &str) -> Entity {
-    let mut e = Entity::new(Handle(handle), EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(1.0, 0.0, 0.0) }));
-    e.common = Common { layer: layer.into(), ..Common::default() };
-    e
-}
-
-/// A drawing with `top` lines on layer Used in model space and `held` lines on layer Held in the
-/// block HELD, so the block's objects come last in the scan, exactly as they do in a real drawing.
-fn drawing(top: usize, held: usize) -> Drawing {
-    let mut d = Drawing::new_metric();
-    for i in 0..top {
-        d.model.push(line(0x100 + i as u64, "Used"));
-    }
-    let mut b = Block::new("HELD");
-    for i in 0..held {
-        b.entities.push(line(0x200 + i as u64, "Held"));
-    }
-    d.blocks.insert("HELD".into(), Arc::new(b));
-    d
-}
-
-/// Guards the detector's boundary: a drawing holding exactly the limit is read whole and is not
-/// reported as cut short, so `incomplete` never cries wolf on the last readable object.
-#[test]
-fn a_drawing_at_the_limit_is_complete() {
-    let d = drawing(2, 1);
-    assert_eq!(entity_total(&d), 3);
-    let sc = Scan::new(&d, 3);
-    assert_eq!(sc.incomplete, None);
-    assert_eq!(sc.layers.get("used").copied(), Some((2, 0)));
-    assert_eq!(sc.layers.get("held").copied(), Some((0, 1)));
-}
-
-/// Guards that a scan stopped one object early reports what it omitted and why: HELD's line is
-/// past the limit, so its layer looks unused — the miscount the `incomplete` signal exists to
-/// prevent a caller from trusting.
-#[test]
-fn a_cut_scan_reports_the_objects_it_omitted() {
-    let d = drawing(2, 1);
-    let sc = Scan::new(&d, 2);
-    let inc = sc.incomplete.expect("a cut scan must report it");
-    assert_eq!(inc, Incomplete { scanned: 2, total: 3 });
-    assert_eq!(sc.layers.get("held").copied(), None);
-    let reason = inc.reason();
-    assert!(reason.contains("first 2 of 3 objects"), "{reason}");
-    assert!(reason.contains("partial"), "{reason}");
-}

crates/engine/src/cmd/layer.rs

@@ -7,8 +7,7 @@ use cadcraft_doc::{Layer, Lineweight};
 use serde_json::{Value, json};
 
 use super::machines::SelectRun;
-use super::{CommandSpec, bad, bool_or, ok, str_param, targets};
-
+use super::*;
 use crate::{Result, Session};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/layout.rs

@@ -10,7 +10,6 @@ use serde_json::{Value, json};
 
 use super::file::{base64_encode, io};
 use super::*;
-
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 use viewports::MviewM;
 
@@ -271,13 +270,9 @@ fn run_rename(s: &mut Session, p: &Value) -> Result<Value> {
     let from = layout_name("layout.rename", s.doc()?, &from)?;
     let to = str_param(p, "to").ok_or_else(|| bad("layout.rename", "`to` is required"))?;
     let to = check_name("layout.rename", s.doc()?, to, Some(&from))?;
-    let d = s.doc_mut()?;
-    if let Some(l) = d.layouts.iter_mut().find(|l| l.name == from) {
+    if let Some(l) = s.doc_mut()?.layouts.iter_mut().find(|l| l.name == from) {
         l.name = to.clone();
     }
-    if d.active_layout.as_ref().is_some_and(|a| a.eq_ignore_ascii_case(&from)) {
-        d.active_layout = Some(to.clone());
-    }
     let (old, new) = (Space::Paper(from.clone()), Space::Paper(to.clone()));
     let st = s.state_mut()?;
     for (sp, _) in st.views.iter_mut() {
@@ -837,10 +832,7 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
                 Ok(json!({ "path": path, "bytes": bytes.len(), "layout": layout, "pages": pages }))
             }
             #[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 }))
-            }
+            Err(bad(cmd, "paths are not available on the web; omit `path` to get the PDF as base64 `data`"))
         }
         None => Ok(json!({ "data": base64_encode(&bytes), "bytes": bytes.len(), "layout": layout, "pages": pages })),
     }
@@ -933,14 +925,6 @@ mod tests {
         assert!(s.doc().unwrap().layout("Layout3").is_none());
     }
 
-    #[test]
-    fn rename_keeps_the_active_layout_whatever_its_case() {
-        let mut s = session_with_model();
-        s.doc_mut().unwrap().active_layout = Some("layout1".into());
-        s.execute("layout.rename", &json!({"from": "Layout1", "to": "Sheet A"})).unwrap();
-        assert_eq!(s.doc().unwrap().active_layout.as_deref(), Some("Sheet A"));
-    }
-
     #[test]
     fn rename_copy_delete() {
         let mut s = session_with_model();

crates/engine/src/cmd/layout/plotstyle.rs

@@ -8,8 +8,7 @@
 use cadcraft_doc::{Drawing, PlotStyle, PlotStyleKind, PlotStyleTable};
 use serde_json::{Value, json};
 
-use super::super::targets;
-use super::{CommandSpec, Result, Session, bad, str_param};
+use super::*;
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![

crates/engine/src/cmd/layout/viewports.rs

@@ -637,13 +637,13 @@ impl Interactive for MviewM {
             Stage::Arrange => Prompt::new("Enter viewport arrangement", curves::KW)
                 .kw(&["Horizontal", "Vertical", "Above", "Below", "Left", "Right"])
                 .default("Right"),
-            Stage::Opposite(a) => Prompt::new("Specify opposite corner", Accept::POINT).corner(*a),
+            Stage::Opposite(a) => Prompt::new("Specify opposite corner", Accept::POINT).base(*a),
             Stage::Polygon(pi) => pi.prompt(),
             Stage::Object => Prompt::new("Select object to clip viewport", Accept::POINT),
             Stage::Lock => Prompt::new("Lock the view of viewports?", curves::KW).kw(&["ON", "OFF"]),
             Stage::RestoreName => Prompt::new("Enter viewport configuration name", Accept::TEXT).kw(&["?"]).default(VportConfig::ACTIVE),
             Stage::RestoreCorner(_) => Prompt::new("Specify first corner", Accept::POINT).kw(&["Fit"]).default("Fit"),
-            Stage::RestoreOpposite(_, a) => Prompt::new("Specify opposite corner", Accept::POINT).corner(*a),
+            Stage::RestoreOpposite(_, a) => Prompt::new("Specify opposite corner", Accept::POINT).base(*a),
             Stage::Select { .. } => Prompt::new("Select viewports", Accept::POINT),
         }
     }

crates/engine/src/cmd/lisp.rs

@@ -12,7 +12,7 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("appload", "Load Application...", run_appload)
             .menu(&["Tools", "Load Application..."])
             .alias(&["ap"])
-            .params("{path: .lsp file} | {name, data: base64 | text} → {value?, commands: [commands the file defined], error?}")
+            .params("{path: .lsp file} | {name, data: base64 | text} → {value?, error?}")
             .noundo()
             .interactive(|_| Ok(Box::new(ApploadM))),
         CommandSpec::new("lisp", "Evaluate LISP", run_lisp)
@@ -23,11 +23,6 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-/// Whether `path` names an AutoLISP routine: APPLOAD loads `.lsp` files only, in any case.
-fn is_lisp_path(path: &str) -> bool {
-    std::path::Path::new(path).extension().is_some_and(|e| e.eq_ignore_ascii_case("lsp"))
-}
-
 /// The text of a LISP file from `{path}` or `{name, data | text}`, and its name.
 fn source(p: &Value) -> Result<(String, String)> {
     if let Some(text) = str_param(p, "text") {
@@ -37,14 +32,7 @@ fn source(p: &Value) -> Result<(String, String)> {
         let bytes = super::file::base64_decode(data).ok_or_else(|| bad("appload", "invalid base64"))?;
         return Ok((str_param(p, "name").unwrap_or("untitled.lsp").to_string(), String::from_utf8_lossy(&bytes).into_owned()));
     }
-    // The path is read as it is given (a JSON caller may name a file or folder with spaces);
-    // only a path of blanks alone is refused.
-    let path = str_param(p, "path")
-        .filter(|p| !p.trim().is_empty())
-        .ok_or_else(|| bad("appload", "`path`, or `name` with `data` (base64) or `text`, is required"))?;
-    if !is_lisp_path(path) {
-        return Err(bad("appload", format!("{path}: not an AutoLISP file (APPLOAD loads .lsp files)")));
-    }
+    let path = str_param(p, "path").ok_or_else(|| bad("appload", "`path`, or `name` with `data` (base64) or `text`, is required"))?;
     let text = crate::lisp::builtins::read_text_file(path).ok_or_else(|| bad("appload", format!("{path}: can't read the file")))?;
     Ok((path.to_string(), text))
 }
@@ -61,14 +49,9 @@ fn report(s: &Session, from_log: usize, r: Option<std::result::Result<Lv, String
 
 fn run_appload(s: &mut Session, p: &Value) -> Result<Value> {
     let (name, text) = source(p)?;
-    let before = s.lisp_commands();
     let from = s.log.len();
     let r = s.lisp_load(&name, &text, true)?;
-    let mut out = report(s, from, r);
-    // The commands the file defined, so a caller can run them next (a failed file may still
-    // have defined some before the error).
-    out["commands"] = json!(s.lisp_commands().into_iter().filter(|c| !before.contains(c)).collect::<Vec<_>>());
-    Ok(out)
+    Ok(report(s, from, r))
 }
 
 /// A JSON input as a LISP value: numbers, strings, `[x, y(, z)]` points, null for Enter.

crates/engine/src/cmd/mleader_edit.rs

@@ -9,8 +9,7 @@ use serde_json::{Value, json};
 
 use super::helpers::v3;
 use super::machines::{SelOutcome, SelectPhase};
-use super::{CommandSpec, bad, point_req, points_param, str_param, targets};
-
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 /// Most arrowheads added by one call, and most multileaders aligned / collected by one call.
@@ -311,67 +310,6 @@ fn segment_dir(m: &MLeader) -> Option<Vec2> {
     (v.len() > 1e-12).then(|| v.normalized())
 }
 
-fn align_parallel(items: &[(Handle, MLeader)], reference: Option<&MLeader>) -> Result<Vec<(Handle, Vec2)>> {
-    let rdir = reference.and_then(segment_dir).ok_or_else(|| bad("mleaderalign", "the reference multileader has no leader"))?;
-    let mut moves = Vec::new();
-    for (h, m) in items {
-        let Some(arrow) = m.leaders.first().and_then(|l| l.last()) else { continue };
-        let len = (m.landing.xy() - arrow.xy()).len();
-        moves.push((*h, arrow.xy() + rdir * len - m.landing.xy()));
-    }
-    Ok(moves)
-}
-
-fn align_distribute(mut items: Vec<(Handle, MLeader)>, line: Option<(Vec2, Vec2)>) -> Result<Vec<(Handle, Vec2)>> {
-    let (a, b) = line.ok_or_else(|| bad("mleaderalign", "`points` (first and last position) are required"))?;
-    let d = b - a;
-    if d.len() < 1e-12 {
-        return Err(bad("mleaderalign", "the two points coincide"));
-    }
-    let u = d.normalized();
-    items.sort_by(|x, y| (x.1.landing.xy() - a).dot(u).total_cmp(&(y.1.landing.xy() - a).dot(u)));
-    let n = items.len();
-    let mut moves = Vec::new();
-    for (i, (h, m)) in items.iter().enumerate() {
-        let f = if n > 1 { i as f64 / (n - 1) as f64 } else { 0.0 };
-        moves.push((*h, a + d * f - m.landing.xy()));
-    }
-    Ok(moves)
-}
-
-fn align_directional(
-    items: &[(Handle, MLeader)],
-    reference: Option<&MLeader>,
-    line: Option<(Vec2, Vec2)>,
-    spacing: Spacing,
-) -> Result<Vec<(Handle, Vec2)>> {
-    let (a, b) = line.ok_or_else(|| bad("mleaderalign", "`direction` (two points or an angle) is required"))?;
-    let d = b - a;
-    if d.len() < 1e-12 {
-        return Err(bad("mleaderalign", "the direction is zero"));
-    }
-    let u = d.normalized();
-    let origin = reference.map(|r| r.landing.xy()).unwrap_or(a);
-    let t_of = |m: &MLeader| (m.landing.xy() - origin).dot(u);
-    let mut moves = Vec::new();
-    if let Spacing::Value(sp) = spacing {
-        let (mut pos, mut neg): (Vec<_>, Vec<_>) = items.iter().partition(|(_, m)| t_of(m) >= 0.0);
-        pos.sort_by(|x, y| t_of(&x.1).total_cmp(&t_of(&y.1)));
-        neg.sort_by(|x, y| t_of(&y.1).total_cmp(&t_of(&x.1)));
-        for (k, (h, m)) in pos.iter().enumerate() {
-            moves.push((*h, origin + u * (sp * (k + 1) as f64) - m.landing.xy()));
-        }
-        for (k, (h, m)) in neg.iter().enumerate() {
-            moves.push((*h, origin - u * (sp * (k + 1) as f64) - m.landing.xy()));
-        }
-    } else {
-        for (h, m) in items {
-            moves.push((*h, origin + u * t_of(m) - m.landing.xy()));
-        }
-    }
-    Ok(moves)
-}
-
 fn align(s: &mut Session, hs: &[Handle], to: Option<Handle>, spacing: Spacing, line: Option<(Vec2, Vec2)>) -> Result<usize> {
     let mut items: Vec<(Handle, MLeader)> = Vec::new();
     for h in hs {
@@ -393,11 +331,56 @@ fn align(s: &mut Session, hs: &[Handle], to: Option<Handle>, spacing: Spacing, l
         (_, Some(t)) => Some(get_mleader(s, t).ok_or_else(|| bad("mleaderalign", "`to` is not a multileader"))?),
         (_, None) => return Err(bad("mleaderalign", "`to` (the multileader to align to) is required")),
     };
-    let moves = match spacing {
-        Spacing::Parallel => align_parallel(&items, reference.as_ref())?,
-        Spacing::Distribute => align_distribute(items, line)?,
-        Spacing::Current | Spacing::Value(_) => align_directional(&items, reference.as_ref(), line, spacing)?,
-    };
+    let mut moves: Vec<(Handle, Vec2)> = Vec::new();
+    match spacing {
+        Spacing::Parallel => {
+            let rdir = reference.as_ref().and_then(segment_dir).ok_or_else(|| bad("mleaderalign", "the reference multileader has no leader"))?;
+            for (h, m) in &items {
+                let Some(arrow) = m.leaders.first().and_then(|l| l.last()) else { continue };
+                let len = (m.landing.xy() - arrow.xy()).len();
+                moves.push((*h, arrow.xy() + rdir * len - m.landing.xy()));
+            }
+        }
+        Spacing::Distribute => {
+            let (a, b) = line.ok_or_else(|| bad("mleaderalign", "`points` (first and last position) are required"))?;
+            let d = b - a;
+            if d.len() < 1e-12 {
+                return Err(bad("mleaderalign", "the two points coincide"));
+            }
+            let u = d.normalized();
+            items.sort_by(|x, y| (x.1.landing.xy() - a).dot(u).total_cmp(&(y.1.landing.xy() - a).dot(u)));
+            let n = items.len();
+            for (i, (h, m)) in items.iter().enumerate() {
+                let f = if n > 1 { i as f64 / (n - 1) as f64 } else { 0.0 };
+                moves.push((*h, a + d * f - m.landing.xy()));
+            }
+        }
+        Spacing::Current | Spacing::Value(_) => {
+            let (a, b) = line.ok_or_else(|| bad("mleaderalign", "`direction` (two points or an angle) is required"))?;
+            let d = b - a;
+            if d.len() < 1e-12 {
+                return Err(bad("mleaderalign", "the direction is zero"));
+            }
+            let u = d.normalized();
+            let origin = reference.as_ref().map(|r| r.landing.xy()).unwrap_or(a);
+            let t_of = |m: &MLeader| (m.landing.xy() - origin).dot(u);
+            if let Spacing::Value(sp) = spacing {
+                let (mut pos, mut neg): (Vec<_>, Vec<_>) = items.iter().partition(|(_, m)| t_of(m) >= 0.0);
+                pos.sort_by(|x, y| t_of(&x.1).total_cmp(&t_of(&y.1)));
+                neg.sort_by(|x, y| t_of(&y.1).total_cmp(&t_of(&x.1)));
+                for (k, (h, m)) in pos.iter().enumerate() {
+                    moves.push((*h, origin + u * (sp * (k + 1) as f64) - m.landing.xy()));
+                }
+                for (k, (h, m)) in neg.iter().enumerate() {
+                    moves.push((*h, origin - u * (sp * (k + 1) as f64) - m.landing.xy()));
+                }
+            } else {
+                for (h, m) in &items {
+                    moves.push((*h, origin + u * t_of(m) - m.landing.xy()));
+                }
+            }
+        }
+    }
     move_content(s, &moves)?;
     Ok(moves.len())
 }

crates/engine/src/cmd/mleader_edit_tests.rs

@@ -120,88 +120,3 @@ fn hostile_mleader_edit_params_never_panic() {
     }
     let _ = cadcraft_render::build(s.doc().unwrap(), &cadcraft_doc::Space::Model, &cadcraft_render::Options::default());
 }
-
-mod units {
-    use super::super::{Spacing, align_directional, align_distribute, align_parallel};
-    use cadcraft_doc::{Handle, MLeader};
-    use cadcraft_geom::{Vec2, Vec3};
-
-    fn unit_ml(arrow: [f64; 2], land: [f64; 2]) -> MLeader {
-        MLeader {
-            leaders: vec![vec![Vec3::new(arrow[0], arrow[1], 0.0)]],
-            landing: Vec3::new(land[0], land[1], 0.0),
-            dogleg: 0.0,
-            text: None,
-            style: String::new(),
-            arrow_size: 1.0,
-            spline: false,
-            block: None,
-        }
-    }
-
-    fn no_leader(land: [f64; 2]) -> MLeader {
-        MLeader {
-            leaders: vec![],
-            landing: Vec3::new(land[0], land[1], 0.0),
-            dogleg: 0.0,
-            text: None,
-            style: String::new(),
-            arrow_size: 1.0,
-            spline: false,
-            block: None,
-        }
-    }
-
-    /// A five-unit-long leader whose direction differs from the reference's `+y`: moving the
-    /// arrow onto `y` plus `5` (a five-unit parallel push) and back along the landing gives
-    /// `(-3, 1)`.
-    #[test]
-    fn parallel_requires_a_reference_and_skips_leaders() {
-        assert!(align_parallel(&[(Handle(1), unit_ml([0.0, 0.0], [3.0, 4.0]))], None).is_err());
-        let d = align_parallel(
-            &[(Handle(2), no_leader([1.0, 1.0])), (Handle(3), unit_ml([0.0, 0.0], [3.0, 4.0]))],
-            Some(&unit_ml([0.0, 0.0], [0.0, 4.0])),
-        )
-        .unwrap();
-        assert_eq!(d.len(), 1, "a multileader without a leader line is skipped");
-        assert_eq!(d[0].0, Handle(3));
-        assert!((d[0].1.x + 3.0).abs() < 1e-9);
-        assert!((d[0].1.y - 1.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn distribute_orders_landings_along_the_line() {
-        let mk = |h: u64, land: [f64; 2]| (Handle(h), unit_ml([0.0, 0.0], land));
-        assert!(align_distribute(vec![mk(1, [2.0, 0.0])], None).is_err(), "needs two points");
-        assert!(align_distribute(Vec::new(), Some((Vec2::new(0.0, 0.0), Vec2::new(0.0, 0.0)))).is_err(), "coinciding points give no direction");
-        let items = vec![mk(1, [2.0, 0.0]), mk(2, [0.0, 0.0])];
-        let d = align_distribute(items, Some((Vec2::new(0.0, 0.0), Vec2::new(4.0, 0.0)))).unwrap();
-        assert_eq!(d[0].0, Handle(2), "sorted by projection onto the line");
-        assert!((d[0].1.x - 0.0).abs() < 1e-9 && (d[0].1.y - 0.0).abs() < 1e-9, "first fraction is 0");
-        assert_eq!(d[1].0, Handle(1));
-        assert!((d[1].1.x - 2.0).abs() < 1e-9 && (d[1].1.y - 0.0).abs() < 1e-9, "last fraction is 1");
-    }
-
-    #[test]
-    fn directional_projects_landings_and_supports_spacing() {
-        let line = Some((Vec2::new(0.0, 0.0), Vec2::new(1.0, 0.0)));
-        assert!(align_directional(&[], None, None, Spacing::Current).is_err(), "needs a direction");
-        assert!(
-            align_directional(&[], None, Some((Vec2::new(0.0, 0.0), Vec2::new(0.0, 0.0))), Spacing::Current).is_err(),
-            "a zero direction is an error"
-        );
-        // Without a reference the origin is the first point: the landing is projected onto it.
-        let d = align_directional(&[(Handle(7), unit_ml([0.0, 0.0], [1.0, 5.0]))], None, line, Spacing::Current).unwrap();
-        assert_eq!(d.len(), 1);
-        assert!((d[0].1.x - 0.0).abs() < 1e-9);
-        assert!((d[0].1.y + 5.0).abs() < 1e-9);
-        // With a reference as origin, given spacing counts outward on both sides of it.
-        let items = vec![(Handle(1), unit_ml([0.0, 0.0], [4.0, 0.0])), (Handle(2), unit_ml([0.0, 0.0], [-4.0, 0.0]))];
-        let d = align_directional(&items, Some(&unit_ml([0.0, 0.0], [0.0, 4.0])), line, Spacing::Value(2.0)).unwrap();
-        assert_eq!(d.len(), 2);
-        assert_eq!(d[0].0, Handle(1));
-        assert!((d[0].1.x + 2.0).abs() < 1e-9 && (d[0].1.y - 4.0).abs() < 1e-9);
-        assert_eq!(d[1].0, Handle(2));
-        assert!((d[1].1.x - 2.0).abs() < 1e-9 && (d[1].1.y - 4.0).abs() < 1e-9);
-    }
-}

crates/engine/src/cmd/mod.rs

@@ -33,7 +33,6 @@ pub mod plotters;
 mod props;
 pub use draw2::breakline::BreaklineOptions;
 pub use props::MatchProps;
-pub(crate) use props::{current_color_value, set_current_color_value};
 mod qselect;
 mod selecttools;
 mod settings;

crates/engine/src/cmd/modify.rs

@@ -7,12 +7,10 @@ use cadcraft_geom::{
 };
 use serde_json::{Value, json};
 
-use super::helpers::{arc, circle, line, lwpoly, v3};
-
+use super::helpers::*;
 use super::machines::{SelOutcome, SelectPhase, number};
 use super::trimextend::{self, TrimM};
-use super::{CommandSpec, bad, bool_or, f64_or, f64_req, point_param, point_req, points_param, str_param, targets};
-
+use super::*;
 use crate::select::{SelectKind, SelectMode};
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
@@ -221,22 +219,6 @@ impl StretchArea {
     }
 }
 
-/// 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
-            && d.is_visible(e)
-            && !hs.contains(&e.handle)
-            && m.vertices.iter().any(|v| area.contains(v.p.xy()))
-        {
-            hs.push(e.handle);
-        }
-    }
-}
-
 /// Move the vertices of `e` that lie inside any of the areas `wins` by `d` (STRETCH).
 fn stretch_entity(e: &mut Entity, wins: &[StretchArea], d: Vec2) {
     let inside = |p: Vec2| wins.iter().any(|a| a.contains(p));
@@ -258,7 +240,6 @@ fn stretch_entity(e: &mut Entity, wins: &[StretchArea], d: Vec2) {
                 }
             }
         }
-        EntityKind::MLine(m) => m.vertices.iter_mut().for_each(|v| mv(&mut v.p)),
         EntityKind::Arc(a) => {
             // Arcs keep their shape: move when the centre is inside.
             if inside(a.center.xy()) {
@@ -306,7 +287,6 @@ fn run_stretch(s: &mut Session, p: &Value) -> Result<Value> {
         let bx = cadcraft_geom::Bounds2::new(*a, *b);
         (crate::select::select_window(s.doc()?, &space, bx, true), StretchArea::Box(bx))
     };
-    add_mline_vertex_hits(s.doc()?, &space, &area, &mut hs);
     hs.retain(|h| !super::curves::is_locked(s, *h));
     let doc = s.doc_mut()?;
     let areas = [area];
@@ -373,12 +353,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(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,
-            _ => false,
-        };
+        let Some(hs) = m.select(s.doc()?, &space) else { return Ok(()) };
         let area = match (m.kind, m.pts.first().zip(m.pts.get(1))) {
             (SelectKind::WPolygon | SelectKind::CPolygon, _) => Some(StretchArea::Polygon(m.pts)),
             (SelectKind::Window | SelectKind::Crossing | SelectKind::Box, Some((a, b))) => {
@@ -388,9 +363,6 @@ impl StretchM {
             _ => None,
         };
         let whole = area.is_none();
-        if let (Some(a), true, false) = (&area, crossing, self.removing) {
-            add_mline_vertex_hits(s.doc()?, &space, a, &mut hs);
-        }
         if let (Some(a), false) = (area, self.removing) {
             self.windows.push(a);
         }
@@ -428,11 +400,8 @@ impl StretchM {
                 Some(c) => {
                     let bx = cadcraft_geom::Bounds2::new(c, p);
                     let space = s.space();
-                    let mut hs = crate::select::select_window(s.doc()?, &space, bx, p.x < c.x);
+                    let 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.doc()?, &space, &StretchArea::Box(bx), &mut hs);
-                        }
                         self.windows.push(StretchArea::Box(bx));
                     }
                     self.add(s, hs, false);
@@ -519,7 +488,7 @@ impl Interactive for StretchM {
             return m.prompt();
         }
         match (self.phase, self.corner) {
-            (StretchPhase::Select, Some(c)) => Prompt::new("Specify opposite corner", Accept::POINT).corner(c),
+            (StretchPhase::Select, Some(c)) => Prompt::new("Specify opposite corner", Accept::POINT).base(c),
             (StretchPhase::Select, None) => Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT),
             (StretchPhase::Base, _) => Prompt::new("Specify base point", Accept::POINT).kw(&["Displacement"]).default("Displacement"),
             (StretchPhase::Displacement, _) => Prompt::new("Specify displacement", Accept::POINT).default("0,0"),
@@ -595,21 +564,6 @@ impl Interactive for StretchM {
     }
 }
 
-/// Whether OFFSET can work on this kind of object at all.
-fn offsettable(k: &EntityKind) -> bool {
-    matches!(
-        k,
-        EntityKind::Line(_)
-            | EntityKind::Circle(_)
-            | EntityKind::Arc(_)
-            | EntityKind::Ellipse(_)
-            | EntityKind::LwPolyline(_)
-            | EntityKind::Spline(_)
-            | EntityKind::XLine(_)
-            | EntityKind::Ray(_)
-    )
-}
-
 /// Offset an entity by `dist` towards `side`. Returns the new geometry.
 pub(crate) fn offset_kind(k: &EntityKind, dist: f64, side: Vec2) -> Option<EntityKind> {
     match k {
@@ -1399,17 +1353,21 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
             // The dimension as drawn: its overrides, DIMSCALE (0 = the drawing's) and text font.
             let style = d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides);
             let g = cadcraft_render::dimension_in(d, dm);
-            let line_entity = |l: &Vec<Vec2>| {
-                if l.len() == 2 {
-                    Some(Entity { handle: Handle(0), common: e.common.clone(), kind: line(*l.first()?, *l.get(1)?) })
-                } else {
-                    Some(Entity { handle: Handle(0), common: e.common.clone(), kind: lwpoly(l.iter().map(|p| PolyVertex::new(*p)).collect(), false) })
-                }
-            };
-            // The text's marks (arc length symbol, DIMINSPECT frame) go after the text background.
-            let text_marks = &g.text_marks;
-            let marks = |want: bool| g.lines.iter().enumerate().filter(move |(i, _)| text_marks.contains(i) == want).map(|(_, l)| l);
-            let mut v: Vec<Entity> = marks(false).filter_map(&line_entity).collect();
+            let mut v: Vec<Entity> = g
+                .lines
+                .iter()
+                .filter_map(|l| {
+                    if l.len() == 2 {
+                        Some(Entity { handle: Handle(0), common: e.common.clone(), kind: line(*l.first()?, *l.get(1)?) })
+                    } else {
+                        Some(Entity {
+                            handle: Handle(0),
+                            common: e.common.clone(),
+                            kind: lwpoly(l.iter().map(|p| PolyVertex::new(*p)).collect(), false),
+                        })
+                    }
+                })
+                .collect();
             for t in &g.fills {
                 if let [a, b, c] = t.as_slice() {
                     v.push(Entity {
@@ -1419,20 +1377,6 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
                     });
                 }
             }
-            // DIMTFILL 2: the text background as a SOLID in DIMTFILLCLR, over the lines and
-            // arrowheads, under the text and its marks (SOLID corners go 1, 2, 4, 3).
-            if style.text_fill == 2
-                && let [p0, p1, p2, p3] = g.text_fill.as_slice()
-            {
-                let fill = style.text_fill_color;
-                let color = if fill == cadcraft_doc::color::Color::ByBlock { e.common.color } else { fill };
-                v.push(Entity {
-                    handle: Handle(0),
-                    common: cadcraft_doc::Common { color, ..e.common.clone() },
-                    kind: EntityKind::Solid(cadcraft_doc::Solid { corners: [v3(*p0), v3(*p1), v3(*p3), v3(*p2)] }),
-                });
-            }
-            v.extend(marks(true).filter_map(&line_entity));
             if !g.value.is_empty() {
                 v.push(Entity {
                     handle: Handle(0),
@@ -1444,7 +1388,7 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
                         attach: 5,
                         rotation: g.text_angle,
                         style: style.text_style.clone(),
-                        contents: g.mtext_contents(),
+                        contents: g.value.clone(),
                         line_spacing: 1.0,
                         line_spacing_exact: false,
                         columns: None,
@@ -2295,24 +2239,8 @@ impl Interactive for OffsetM {
     fn name(&self) -> &'static str {
         "OFFSET"
     }
-    /// Starts OFFSET, keeping a single preselected offsettable object (issue #1610) so the prompt
-    /// sequence goes distance then side instead of asking for the object again; any other
-    /// selection is cleared and the object loop asks for it. With PICKFIRST off the selection is
-    /// likewise ignored and cleared.
     fn begin(&mut self, s: &mut Session) -> Result<Step> {
-        // Exactly one offsettable object selected before the command is taken at once, so only the
-        // side is asked for; the object loop stays for the ones after it (issue #1610). A multiple
-        // selection is left for the select prompt, as AutoCAD does.
-        let pre = s.selection();
-        if s.settings.pickfirst
-            && let [h] = pre[..]
-            && s.doc()?.entity(h).is_some_and(|e| offsettable(&e.kind))
-        {
-            self.picked = Some(h);
-            s.set_selection(vec![h]);
-        } else {
-            s.set_selection(Vec::new());
-        }
+        s.set_selection(Vec::new());
         let (erase, current) = offset_options(s);
         s.echo(format!(
             "Current settings: Erase source={}  Layer={}  OFFSETGAPTYPE=0",

crates/engine/src/cmd/modify2.rs

@@ -9,11 +9,9 @@ use cadcraft_geom::{
 use serde_json::{Value, json};
 
 use super::curves::{self, Chain, MAX_GEN, TanObj};
-use super::helpers::{arc, line, lwpoly, v3};
-
+use super::helpers::*;
 use super::machines::{SelOutcome, SelectPhase, number};
-use super::{CommandSpec, bad, bool_or, f64_or, f64_req, point_param, point_req, str_param, targets};
-
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
 
 mod curve_edits;

crates/engine/src/cmd/modify2/fillet_pline.rs

@@ -80,7 +80,8 @@ fn same_polyline(
     s: &mut Session,
     h: Handle,
     pl: &LwPolyline,
-    (p1, p2): (Vec2, Vec2),
+    p1: Vec2,
+    p2: Vec2,
     r: f64,
     chamfer: Option<ChamferDistances>,
     trim: bool,
@@ -222,7 +223,7 @@ pub(crate) fn fillet_pline(
         _ => None,
     };
     let made = match (&e1.kind, &e2.kind) {
-        (EntityKind::LwPolyline(pl), _) if h1 == h2 => same_polyline(s, h1, pl, (p1, p2), r, chamfer, trim)?,
+        (EntityKind::LwPolyline(pl), _) if h1 == h2 => same_polyline(s, h1, pl, p1, p2, r, chamfer, trim)?,
         (EntityKind::LwPolyline(pl), k) if as_line(k).is_some() => {
             let ln = as_line(k).ok_or_else(|| other("Select a line."))?;
             polyline_and_line(s, (h1, pl, p1), (h2, ln, p2), true, r, chamfer, trim)?

crates/engine/src/cmd/modify2/pedit_vertex.rs

@@ -1,10 +1,7 @@
 //! PEDIT Edit vertex: Break and Straighten between two marked vertices, Tangent directions
 //! that Fit honours, and Regen.
 
-use super::super::point_value;
-use super::{
-    EntityKind, Handle, Input, LwPolyline, PPhase, PeditM, PolyVertex, Result, Session, Value, Vec2, bad, curves, json, other, push_entity, set_kind,
-};
+use super::*;
 
 fn ordered(pl: &LwPolyline, i: usize, j: usize) -> Result<(usize, usize)> {
     let n = pl.vertices.len();

crates/engine/src/cmd/modify2/splinedit.rs

@@ -6,11 +6,7 @@
 //! parametrisation, end tangents and fit tolerance. Control-point edits change the curve
 //! directly and drop the fit data, as the curve no longer follows it.
 
-use super::super::{point_value, points_param};
-use super::{
-    Accept, Entity, EntityKind, Handle, Input, Interactive, LwPolyline, MAX_GEN, PolyVertex, Prompt, Result, SelOutcome, SelectPhase, Session, Space,
-    Spline, Step, Value, Vec2, bad, bool_or, curves, f64_req, json, line, number, other, point_req, set_kind, str_param, targets,
-};
+use super::*;
 
 /// The spline after a JSON SPLINEDIT option (`option` plus that option's parameters).
 pub(super) fn run_splinedit(s: &mut Session, p: &Value) -> Result<Value> {

crates/engine/src/cmd/options.rs

@@ -52,7 +52,6 @@ pub const PROFILE_VARS: &[&str] = &[
     "PICKADD",
     "PICKDRAG",
     "MAXARRAY",
-    "MEASUREINIT",
 ];
 
 /// The most profile entries [`restore`] reads (a saved profile is untrusted input).

crates/engine/src/cmd/overkill.rs

@@ -13,8 +13,7 @@ use cadcraft_geom::{TAU, Vec2, Vec3, ccw_sweep, norm_angle};
 use serde_json::{Value, json};
 
 use super::machines::{SelOutcome, SelectPhase, number};
-use super::{CommandSpec, bad, targets};
-
+use super::*;
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
 
 pub fn specs() -> Vec<CommandSpec> {

crates/engine/src/cmd/plotters.rs

@@ -14,8 +14,7 @@ use cadcraft_doc::{DevicePaper, Orientation, PageSetup, PlotOutput, PlotterConfi
 use cadcraft_geom::{Bounds2, Vec2};
 use serde_json::{Value, json};
 
-use super::{CommandSpec, Result, always, bad, has_doc, point_req, str_param};
-
+use super::*;
 use crate::{Accept, EngineError, Input, Interactive, Prompt, Session, Step};
 
 /// Where plotter configuration files live. Names are file names ending in
@@ -363,12 +362,10 @@ impl Interactive for PlotWindowM {
     fn name(&self) -> &'static str {
         "PLOTWINDOW"
     }
-    /// Ask for the first corner, then for the opposite one marked as a rectangle corner
-    /// (`Prompt::corner`), so ORTHO does not bend the pick and the window keeps its area.
     fn prompt(&self, _s: &Session) -> Prompt {
         match self.first {
             None => Prompt::new("Specify first corner", Accept::POINT),
-            Some(a) => Prompt::new("Specify opposite corner", Accept::POINT).corner(a),
+            Some(a) => Prompt::new("Specify opposite corner", Accept::POINT).base(a),
         }
     }
     fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {

crates/engine/src/cmd/props.rs

@@ -10,14 +10,13 @@ use cadcraft_doc::{EntityKind, Lineweight, Transparency};
 use cadcraft_geom::Vec3;
 use serde_json::{Value, json};
 
-use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, point_value, str_param, targets};
-
+use super::*;
 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)}"),
+        CommandSpec::new("properties.set", "Set Properties", run_set).params("{handles?, layer?, color?, linetype?, lineweight?, ltscale?, 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("matchprop", "Match Properties", matchprop::run_matchprop)
             .menu(&["Modify", "Match Properties"])
             .alias(&["ma", "painter"])
@@ -33,11 +32,6 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("lweight", "Lineweight...", run_lweight).menu(&["Format", "Lineweight..."]).alias(&["lw", "lineweight"]).params("{lineweight: mm | ByLayer}"),
         CommandSpec::new("ltscale", "Linetype Scale", run_ltscale).alias(&["lts"]).params("{scale}").interactive(|_| Ok(Box::new(LtscaleM))),
         CommandSpec::new("units", "Units...", run_units).menu(&["Format", "Units..."]).alias(&["un"]).params("{lunits?: 1..5, luprec?: 0..8, aunits?: 0..4, auprec?: 0..8, insunits?}"),
-        CommandSpec::new("thickness", "Thickness", run_thickness)
-            .menu(&["Format", "Thickness"])
-            .params("{thickness} (THICKNESS: the 3D thickness given to new lines, arcs, circles, points and polylines; may be negative) → {thickness}")
-            .transparent()
-            .interactive(|_| Ok(Box::new(ThicknessM))),
         CommandSpec::new("limits", "Drawing Limits", run_limits).menu(&["Format", "Drawing Limits"]).params("{min: [x,y], max: [x,y]}"),
         CommandSpec::new("style", "Text Style...", run_style)
             .menu(&["Format", "Text Style..."])
@@ -88,7 +82,6 @@ pub(super) fn entity_props(d: &cadcraft_doc::Drawing, e: &cadcraft_doc::Entity)
         "lineweight": e.common.lineweight.name(),
         "ltscale": e.common.ltscale,
         "transparency": transparency_value(e.common.transparency),
-        "thickness": e.common.thickness,
         "visible": e.common.visible,
     });
     if cadcraft_doc::can_be_annotative(&e.kind)
@@ -192,10 +185,6 @@ fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
         .get("transparency")
         .map(|v| parse_transparency(v).ok_or_else(|| bad("properties.set", "transparency must be ByLayer, ByBlock or a percentage from 0 to 90")))
         .transpose()?;
-    let thickness = p
-        .get("thickness")
-        .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_mut()?;
     // An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
@@ -240,9 +229,6 @@ fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
             if let Some(t) = transparency {
                 e.common.transparency = t;
             }
-            if let Some(th) = thickness {
-                e.common.thickness = th;
-            }
             if let Some(v) = p.get("visible").and_then(Value::as_bool) {
                 e.common.visible = v;
             }
@@ -424,43 +410,7 @@ fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn run_color(s: &mut Session, p: &Value) -> Result<Value> {
     let c = p.get("color").and_then(parse_color).ok_or_else(|| bad("color", "`color` is required"))?;
-    set_current_color(s.doc_mut()?, c);
-    ok()
-}
-
-/// `setvar CECOLOR`: the same input as the `color` command, stored the same way.
-pub(crate) fn set_current_color_value(s: &mut Session, v: &Value) -> Option<()> {
-    // An out-of-range index is refused here, where `color` folds it to ByLayer.
-    let c = match v {
-        // "RGB:r,g,b" is how `getvar` reads a true colour back, so a saved value can be restored.
-        Value::String(t) => match t.trim().get(..4).filter(|p| p.eq_ignore_ascii_case("rgb:")).and_then(|_| t.trim().get(4..)) {
-            Some(triple) => Color::parse(triple).filter(|c| matches!(c, Color::True(_))),
-            None => Color::parse(t),
-        },
-        Value::Number(n) => n.as_i64().and_then(|i| Color::parse(&i.to_string())),
-        _ => None,
-    }?;
-    set_current_color(s.doc_mut().ok()?, c);
-    Some(())
-}
-
-/// `getvar CECOLOR` as AutoCAD gives it, always text: "BYLAYER", "BYBLOCK", the index ("1" for
-/// red) or "RGB:r,g,b".
-pub(crate) fn current_color_value(d: &cadcraft_doc::Drawing) -> String {
-    if let Some(rgb) = d.header.get("CECOLOR_RGB").and_then(|v| v.as_i64()).and_then(|v| u32::try_from(v).ok()) {
-        let cadcraft_color::Rgb(r, g, b) = cadcraft_color::Rgb::from_u32(rgb);
-        return format!("RGB:{r},{g},{b}");
-    }
-    match Color::from_aci(d.header.i64("CECOLOR", 256) as i16) {
-        Color::ByLayer => "BYLAYER".into(),
-        Color::ByBlock => "BYBLOCK".into(),
-        other => other.to_aci().to_string(),
-    }
-}
-
-/// A true colour keeps its RGB in CECOLOR_RGB (which wins for new objects); any other colour must
-/// clear a stale one.
-fn set_current_color(d: &mut cadcraft_doc::Drawing, c: Color) {
+    let d = s.doc_mut()?;
     match c {
         Color::True(rgb) => {
             d.header.set_i64("CECOLOR", i64::from(cadcraft_color::nearest_aci(rgb)));
@@ -471,6 +421,7 @@ fn set_current_color(d: &mut cadcraft_doc::Drawing, c: Color) {
             d.header.vars.remove("CECOLOR_RGB");
         }
     }
+    ok()
 }
 
 mod linfile;
@@ -558,56 +509,6 @@ impl Interactive for LtscaleM {
     }
 }
 
-/// The largest THICKNESS, either way.
-const MAX_THICKNESS: f64 = 1e12;
-
-fn thickness_in_range(t: f64) -> bool {
-    t.is_finite() && t.abs() <= MAX_THICKNESS
-}
-
-fn run_thickness(s: &mut Session, p: &Value) -> Result<Value> {
-    let t = f64_req("thickness", p, "thickness")?;
-    if !thickness_in_range(t) {
-        return Err(bad("thickness", "thickness is out of range (-1e12 to 1e12)"));
-    }
-    s.doc_mut()?.header.set_f64("THICKNESS", t);
-    Ok(json!({ "thickness": t }))
-}
-
-/// Format > Thickness and typed THICKNESS: "Enter new value for THICKNESS <0.0000>:".
-struct ThicknessM;
-
-impl Interactive for ThicknessM {
-    fn name(&self) -> &'static str {
-        "THICKNESS"
-    }
-    fn prompt(&self, s: &Session) -> Prompt {
-        let cur = s.doc().map(|d| d.header.f64("THICKNESS", 0.0)).unwrap_or(0.0);
-        Prompt::new("Enter new value for THICKNESS", Accept::NUMBER).default(format!("{cur:.4}"))
-    }
-    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
-        let text = match i {
-            Input::Enter | Input::Cancel => return Ok(Step::Done),
-            Input::Text(t) => t,
-            _ => return Ok(Step::Continue),
-        };
-        match super::machines::number(&text) {
-            Some(t) if thickness_in_range(t) => {
-                run_thickness(s, &json!({ "thickness": t }))?;
-                Ok(Step::Done)
-            }
-            Some(_) => {
-                s.echo("Requires a value between -1e12 and 1e12.");
-                Ok(Step::Continue)
-            }
-            None => {
-                s.echo("Requires a number.");
-                Ok(Step::Continue)
-            }
-        }
-    }
-}
-
 fn run_units(s: &mut Session, p: &Value) -> Result<Value> {
     let d = s.doc_mut()?;
     for (k, lo, hi) in [("lunits", 1, 5), ("luprec", 0, 8), ("aunits", 0, 4), ("auprec", 0, 8), ("insunits", 0, 24)] {
@@ -1178,9 +1079,10 @@ fn run_rename(s: &mut Session, p: &Value) -> Result<Value> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::json;
 
+    use crate::Session;
+
     #[test]
     fn properties_set_rejects_unloaded_linetype() {
         let mut s = Session::new();