Pass the Linux signing key to the release workflow (#2798)

XCLIP and XCLIPFRAME; invert flag as AutoCAD's group 290 (#2354)

.github/workflows/release.yml

@@ -85,3 +85,4 @@ jobs:
       AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
       AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
       AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
+      LINUX_SIGNING_KEY: ${{ secrets.LINUX_SIGNING_KEY }}

Cargo.lock

@@ -729,6 +729,7 @@ name = "cadcraft-fonts"
 version = "0.17.0"
 dependencies = [
  "cadcraft-geom",
+ "encoding_rs",
  "harfrust 0.14.0",
  "icu_segmenter",
  "skrifa 0.48.0",
@@ -755,6 +756,7 @@ dependencies = [
  "cadcraft-geom",
  "cadcraft-render",
  "craft-pdf",
+ "image",
  "miniz_oxide 0.9.1",
  "quick-xml 0.42.0",
  "serde",
@@ -821,6 +823,7 @@ name = "cadcraft-web"
 version = "0.17.0"
 dependencies = [
  "cadcraft-engine",
+ "cadcraft-fonts",
  "cadcraft-io",
  "cadcraft-ui-egui",
  "eframe",

Cargo.toml

@@ -54,7 +54,7 @@ unicode-bidi = "0.3.18"
 # Line-break opportunities between Thai words for MTEXT word wrap (Thai writes no spaces between
 # words): UAX #14 with ICU4X's compiled-in LSTM word model (not its dictionaries).
 icu_segmenter = { version = "~2.3", default-features = false, features = ["compiled_data", "lstm"] }
-image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
+image = { version = "0.25", default-features = false, features = ["png", "jpeg", "bmp", "tiff"] }
 encoding_rs = "0.8.35"
 # XML for the SVG reader (streaming parser, no entity expansion beyond the five predefined ones)
 quick-xml = "0.42"

apps/cadcraft-cli/src/args.rs

@@ -81,6 +81,7 @@ pub(crate) enum Command {
     Mcp(McpArgs),
     Perf(PerfArgs),
     Sample(SampleArgs),
+    Roundtrip(RoundtripArgs),
 }
 
 /// Print a drawing's summary as JSON
@@ -308,6 +309,40 @@ fn perf_target(p: PathBuf) -> PerfTarget {
     }
 }
 
+/// Open each DXF/DWG, save it as DXF and DWG, reopen and compare; writes report.md and report.json
+///
+/// FOLDER defaults to $CADCRAFT_CORPUS_DIR. With CADCRAFT_CORPUS_STRICT=1 it fails when a file
+/// doesn't open, save or reopen, or loses records on save.
+#[derive(Args)]
+pub(crate) struct RoundtripArgs {
+    /// A drawing, or a folder of them
+    #[arg(value_name = "FILE|FOLDER")]
+    pub(crate) path: Option<PathBuf>,
+    /// Where the report goes (default: `report` beside the files)
+    #[arg(long, value_name = "DIR")]
+    pub(crate) out: Option<PathBuf>,
+    /// Keep the saved files, in `saved` under the report folder
+    #[arg(long)]
+    pub(crate) keep_saved: bool,
+    /// Save only in each file's own format
+    #[arg(long)]
+    pub(crate) same_format: bool,
+    /// Don't count what each file holds (faster; no "read lost" column)
+    #[arg(long)]
+    pub(crate) no_census: bool,
+    /// How far numbers may move and still count as equal
+    #[arg(long, value_name = "T", default_value_t = cadcraft_io::roundtrip::Options::default().abs_tol, value_parser = tolerance)]
+    pub(crate) tolerance: f64,
+}
+
+/// `--tolerance`: a finite number, 0 or more.
+fn tolerance(v: &str) -> Result<f64, ValueError> {
+    match v.parse::<f64>() {
+        Ok(t) if t.is_finite() && t >= 0.0 => Ok(t),
+        _ => Err(ValueError::Tolerance(v.to_string())),
+    }
+}
+
 /// Write a built-in sample drawing
 #[derive(Args)]
 pub(crate) struct SampleArgs {
@@ -360,6 +395,8 @@ pub(crate) enum ValueError {
     CmdId,
     #[error(transparent)]
     CmdJson(#[from] serde_json::Error),
+    #[error("expected a number of 0 or more, got `{0}`")]
+    Tolerance(String),
 }
 
 /// Why `parse` refuses flags clap accepted: clap prints it as a usage error (exit 2).

apps/cadcraft-cli/src/error.rs

@@ -1,5 +1,6 @@
 use crate::output::OutputError;
 use crate::perf::PerfError;
+use crate::roundtrip::RoundtripError;
 use crate::run::RunError;
 
 /// Why a subcommand failed: printed as `error: {e}`, exit 1.
@@ -19,6 +20,8 @@ pub(crate) enum CliError {
     Output(#[from] OutputError),
     #[error(transparent)]
     Perf(#[from] PerfError),
+    #[error(transparent)]
+    Roundtrip(#[from] RoundtripError),
     /// The engine and io crates take file names as text.
     #[error("{}: the file name is not valid Unicode", .0.display())]
     NotUnicode(std::path::PathBuf),

apps/cadcraft-cli/src/lib.rs

@@ -16,6 +16,7 @@ mod info;
 mod mcp;
 mod output;
 mod perf;
+mod roundtrip;
 mod run;
 mod sample;
 
@@ -32,6 +33,7 @@ use output::Streams;
 #[cfg(test)]
 use output::{export_window, model_views, write_atomic};
 use perf::perf;
+use roundtrip::roundtrip;
 use run::run_cmds;
 #[cfg(test)]
 use run::{fill_last, returned_handle};
@@ -43,6 +45,7 @@ fn install_io() {
         write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()),
         plot: Some(|d, space, opts| cadcraft_io::plotter::plot(d, space, opts).map_err(|e| e.to_string())),
     });
+    cadcraft_engine::cmd::file::set_image_decoder(|b| cadcraft_io::raster::decode(b).map_err(|e| e.to_string()));
     cadcraft_engine::cmd::file::set_write_as(|d, name, o| {
         cadcraft_io::write_with(d, name, &cadcraft_io::SaveOptions { version: o.version, binary: o.binary }).map_err(|e| e.to_string())
     });
@@ -99,7 +102,7 @@ where
         Command::Run(a) => a.settings.apply(),
         Command::Mcp(a) => a.settings.apply(),
         Command::Sample(a) => a.settings.apply(),
-        Command::Info(_) | Command::Commands(_) | Command::Perf(_) => {}
+        Command::Info(_) | Command::Commands(_) | Command::Perf(_) | Command::Roundtrip(_) => {}
     }
     let mut io = Streams::new(out, err);
     let result = match &cli.command {
@@ -110,6 +113,7 @@ where
         Command::Mcp(a) => mcp(a),
         Command::Perf(a) => perf(a.target.as_ref(), &mut io),
         Command::Sample(a) => sample(a, &mut io),
+        Command::Roundtrip(a) => roundtrip(a, &mut io),
     };
     let mut code = 0;
     if let Err(e) = result {

apps/cadcraft-cli/src/roundtrip.rs

@@ -0,0 +1,93 @@
+//! `roundtrip`: the corpus harness of `cadcraft_io::roundtrip::corpus` over a file or folder.
+
+use super::args::RoundtripArgs;
+use super::error::{CliError, Result};
+use super::output::Streams;
+
+/// Why `roundtrip` stopped.
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum RoundtripError {
+    #[error("roundtrip: give a FILE or FOLDER, or set CADCRAFT_CORPUS_DIR")]
+    NoPath,
+    #[error("roundtrip: no such file or folder: {}", .0.display())]
+    Missing(std::path::PathBuf),
+    #[error("roundtrip: no DXF or DWG files in {}", .0.display())]
+    Empty(std::path::PathBuf),
+    #[error("roundtrip: can't write the report to {}: {source}", .path.display())]
+    Report { path: std::path::PathBuf, source: std::io::Error },
+    #[error("roundtrip: {} strict failures:\n{}", .0.len(), .0.join("\n"))]
+    Strict(Vec<String>),
+}
+
+/// What the walk couldn't look at, so the report isn't taken for the whole corpus: said on
+/// stderr, and failures of a strict run.
+fn left_out(w: &cadcraft_io::roundtrip::corpus::Walk) -> Vec<String> {
+    let mut out: Vec<String> = w.unreadable.iter().map(|u| format!("not read: {u}")).collect();
+    if w.truncated {
+        out.push("left out: files or folders past the harness limits".to_string());
+    }
+    out
+}
+
+pub(crate) fn roundtrip(a: &RoundtripArgs, io: &mut Streams) -> Result {
+    use cadcraft_io::roundtrip::corpus;
+    let path = a.path.clone().or_else(|| std::env::var_os("CADCRAFT_CORPUS_DIR").map(Into::into)).ok_or(RoundtripError::NoPath)?;
+    let mut missed = Vec::new();
+    let (root, files, out) = if path.is_dir() {
+        let out = a.out.clone().unwrap_or_else(|| path.join("report"));
+        // The report folder, and the saved copies in it, are never read back as corpus files.
+        let walk = corpus::walk(&path, &[out.clone(), out.join("saved")]);
+        missed = left_out(&walk);
+        for m in &missed {
+            io.errln(format_args!("roundtrip: {m}"));
+        }
+        (path, walk.files, out)
+    } else if path.is_file() {
+        let root = path.parent().map(std::path::Path::to_path_buf).unwrap_or_default();
+        let out = a.out.clone().unwrap_or_else(|| root.join("report"));
+        (root, vec![path], out)
+    } else {
+        return Err(RoundtripError::Missing(path).into());
+    };
+    if files.is_empty() {
+        // A folder it couldn't read isn't an empty one.
+        return Err(if missed.is_empty() { RoundtripError::Empty(root) } else { RoundtripError::Strict(missed) }.into());
+    }
+    let mut opts = corpus::CorpusOptions { cross_format: !a.same_format, census: !a.no_census, ..Default::default() };
+    opts.compare.abs_tol = a.tolerance;
+    if a.keep_saved {
+        opts.keep_saved = Some(out.join("saved"));
+    }
+    let report = corpus::run(&root, &files, &opts, &mut |i, n, rel| eprintln!("[{}/{n}] {rel}", i + 1));
+    for f in &report.files {
+        let routes: Vec<String> = f
+            .routes
+            .iter()
+            .map(|r| match (&r.save_error, &r.reopen_error) {
+                (Some(_), _) => format!("{}: save failed", r.route),
+                (None, Some(_)) => format!("{}: reopen failed", r.route),
+                (None, None) => {
+                    let t = r.comparison.total();
+                    format!("{}: {} lost, {} added, {} changed", r.route, t.lost, t.added, t.changed)
+                }
+            })
+            .collect();
+        match &f.open_error {
+            Some(e) => io.outln(format_args!("{}: open failed: {e}", f.path)),
+            None => io.outln(format_args!("{}: opened; {}", f.path, routes.join("; "))),
+        }
+    }
+    let (md, json) = report.write(&out).map_err(|source| RoundtripError::Report { path: out.clone(), source })?;
+    io.outln(format_args!("report: {}", md.display()));
+    io.outln(format_args!("        {}", json.display()));
+    // CADCRAFT_CORPUS_STRICT=1: a file that doesn't open, save or reopen, or records a writer
+    // leaves out, fail the run (the report is written first).
+    if std::env::var("CADCRAFT_CORPUS_STRICT").is_ok_and(|v| v == "1") {
+        let mut failed = report.strict_failures();
+        failed.extend(missed);
+        if !failed.is_empty() {
+            return Err(CliError::from(RoundtripError::Strict(failed)));
+        }
+    }
+    Ok(())
+}

apps/cadcraft-cli/tests/man_and_completions.rs

@@ -20,7 +20,7 @@ fn the_example_writes_the_files_the_packages_install() {
     let mut written: Vec<String> = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name().into_string().unwrap()).collect();
     written.sort();
     let completions = ["cadcraft-cli.bash", "_cadcraft-cli", "cadcraft-cli.fish", "cadcraft-cli.elv", "_cadcraft-cli.ps1"];
-    let subcommands = ["info", "convert", "run", "commands", "mcp", "perf", "sample"];
+    let subcommands = ["info", "convert", "run", "commands", "mcp", "perf", "sample", "roundtrip"];
     let mut expected: Vec<String> = completions.map(String::from).into();
     expected.push("cadcraft-cli.1".into());
     expected.extend(subcommands.iter().map(|s| format!("cadcraft-cli-{s}.1")));

apps/cadcraft-web/Cargo.toml

@@ -18,6 +18,7 @@ path = "src/main.rs"
 cadcraft-engine = { workspace = true }
 cadcraft-ui-egui = { workspace = true }
 cadcraft-io = { workspace = true }
+cadcraft-fonts = { workspace = true }
 egui = { workspace = true }
 log = { workspace = true }
 serde_json = { workspace = true }

apps/cadcraft-web/src/main.rs

@@ -119,6 +119,7 @@ mod web {
             write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()),
             plot: Some(|d, space, opts| cadcraft_io::plotter::plot(d, space, opts).map_err(|e| e.to_string())),
         });
+        cadcraft_engine::cmd::file::set_image_decoder(|b| cadcraft_io::raster::decode(b).map_err(|e| e.to_string()));
         cadcraft_engine::cmd::file::set_write_as(|d, name, o| {
             cadcraft_io::write_with(d, name, &cadcraft_io::SaveOptions { version: o.version, binary: o.binary }).map_err(|e| e.to_string())
         });

apps/cadcraft-web/src/upload.rs

@@ -2,6 +2,11 @@
 //! a path from, so the picker is a hidden `<input type="file">`; the chosen file (or one dropped on
 //! the page) is read in the background and handed to the app on its next frame, which opens it
 //! with OPEN `{data, name}` ([`CadApp::open_bytes`]).
+//!
+//! SHX fonts (text fonts, big fonts, shape files) chosen or dropped with a drawing are the web
+//! build's font folder: they are registered with the font table
+//! ([`cadcraft_fonts::shx::register`]) under their file name, so the styles and linetypes that
+//! name them draw with them, and the drawings are regenerated.
 
 use std::cell::Cell;
 use std::rc::Rc;
@@ -12,8 +17,14 @@ use web_sys::js_sys;
 
 /// The hidden file input (one at a time; a cancelled pick leaves it until the next one).
 const INPUT_ID: &str = "cadcraft_open_input";
-/// What the picker offers: the formats OPEN reads.
-const ACCEPT: &str = ".dxf,.dwg";
+/// What the picker offers: the formats OPEN reads, and the SHX fonts drawings name.
+const ACCEPT: &str = ".dxf,.dwg,.shx";
+
+/// Most files taken from one pick.
+const MAX_PICKED: u32 = 64;
+/// Most bytes being read at once, all files together: a large pick must not exhaust the page's
+/// memory (each file is copied once more into the app).
+const MAX_READING_BYTES: u64 = 512 << 20;
 
 /// A file read in the browser (name, contents), or why it couldn't be read.
 type Upload = Result<(String, Vec<u8>), String>;
@@ -22,12 +33,14 @@ type Upload = Result<(String, Vec<u8>), String>;
 #[derive(Clone)]
 pub struct Inbox {
     files: Rc<Cell<Vec<Upload>>>,
+    /// Bytes of the files being read now.
+    reading: Rc<Cell<u64>>,
     ctx: egui::Context,
 }
 
 impl Inbox {
     pub fn new(ctx: &egui::Context) -> Self {
-        Inbox { files: Rc::default(), ctx: ctx.clone() }
+        Inbox { files: Rc::default(), reading: Rc::default(), ctx: ctx.clone() }
     }
 
     /// Show the browser's file picker and return at once. A chosen file arrives through
@@ -51,13 +64,23 @@ impl Inbox {
             .map_err(|_| "could not create a file input".to_string())?;
         input.set_type("file");
         input.set_accept(ACCEPT);
+        // A drawing and the fonts it uses can be chosen together.
+        input.set_multiple(true);
         input.set_id(INPUT_ID);
         input.set_attribute("style", "display:none").map_err(js_error)?;
         let (inbox, chosen) = (self.clone(), input.clone());
-        // Called once, when a file was chosen (browsers don't fire `change` on cancel).
+        // Called once, when files were chosen (browsers don't fire `change` on cancel).
         let on_change = wasm_bindgen::closure::Closure::once_into_js(move || {
-            if let Some(file) = chosen.files().and_then(|f| f.get(0)) {
-                inbox.read(file);
+            if let Some(files) = chosen.files() {
+                for i in 0..files.length().min(MAX_PICKED) {
+                    if let Some(file) = files.get(i) {
+                        inbox.read(file);
+                    }
+                }
+                let skipped: Vec<String> = (MAX_PICKED..files.length()).filter_map(|i| files.get(i)).map(|f| f.name()).collect();
+                if !skipped.is_empty() {
+                    inbox.push(Err(format!("Open: at most {MAX_PICKED} files at a time; not opened: {}", skipped.join(", "))));
+                }
             }
             chosen.remove();
         });
@@ -87,12 +110,18 @@ impl Inbox {
         if let Some(e) = CadApp::open_size_error(&name, len) {
             return self.push(Err(e));
         }
+        let reading = self.reading.get();
+        if reading.saturating_add(len) > MAX_READING_BYTES {
+            return self.push(Err(format!("Open: {name} was not read: the files being read together are too large; open it on its own")));
+        }
+        self.reading.set(reading.saturating_add(len));
         let inbox = self.clone();
         wasm_bindgen_futures::spawn_local(async move {
             let r = match wasm_bindgen_futures::JsFuture::from(file.array_buffer()).await {
                 Ok(buf) => Ok((name, js_sys::Uint8Array::new(&buf).to_vec())),
                 Err(e) => Err(format!("Open: could not read {name}: {}", js_error(e))),
             };
+            inbox.reading.set(inbox.reading.get().saturating_sub(len));
             inbox.push(r);
         });
     }
@@ -118,9 +147,21 @@ impl Inbox {
         self.ctx.request_repaint();
     }
 
-    /// Open what arrived since the last frame (or report why it couldn't be read).
+    /// Open what arrived since the last frame (or report why it couldn't be read). Fonts are
+    /// registered first, so drawings opened with them draw with them.
     pub fn drain(&self, app: &mut CadApp) {
-        for upload in self.files.take() {
+        let (fonts, files): (Vec<Upload>, Vec<Upload>) = self.files.take().into_iter().partition(|u| u.as_ref().is_ok_and(|(n, _)| is_shx(n)));
+        let mut registered = false;
+        for (name, bytes) in fonts.into_iter().flatten() {
+            match cadcraft_fonts::shx::register(&name, &bytes) {
+                Ok(()) => registered = true,
+                Err(e) => app.open_failed(format!("{name}: {e}")),
+            }
+        }
+        if registered {
+            let _ = app.run("regenall", serde_json::json!({}));
+        }
+        for upload in files {
             match upload {
                 Ok((name, bytes)) => app.open_bytes(&name, &bytes),
                 Err(e) => app.open_failed(e),
@@ -129,6 +170,11 @@ impl Inbox {
     }
 }
 
+/// Whether `name` is an SHX font or shape file.
+fn is_shx(name: &str) -> bool {
+    name.to_ascii_lowercase().ends_with(".shx")
+}
+
 fn js_error(e: wasm_bindgen::JsValue) -> String {
     e.as_string().unwrap_or_else(|| format!("{e:?}"))
 }

apps/cadcraft/src/main.rs

@@ -146,6 +146,7 @@ pub fn install_io() {
         write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()),
         plot: Some(|d, space, opts| cadcraft_io::plotter::plot(d, space, opts).map_err(|e| e.to_string())),
     });
+    cadcraft_engine::cmd::file::set_image_decoder(|b| cadcraft_io::raster::decode(b).map_err(|e| e.to_string()));
     cadcraft_engine::cmd::file::set_write_as(|d, name, o| {
         cadcraft_io::write_with(d, name, &cadcraft_io::SaveOptions { version: o.version, binary: o.binary }).map_err(|e| e.to_string())
     });

crates/constraints/src/model.rs

@@ -800,6 +800,7 @@ mod budget_tests {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         }
     }
 

crates/constraints/tests/dof.rs

@@ -302,6 +302,7 @@ fn block_reference_moves_rigidly() {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         }),
     );
     assert_eq!(obj_dof(&d, ins), Some(3));
@@ -343,6 +344,7 @@ fn hostile_new_geometry_never_panics() {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         }),
     );
     let l = line(&mut d, (0.0, 0.0), (0.0, 0.0));

crates/doc/src/array.rs

@@ -228,6 +228,7 @@ impl ArrayParams {
                 rows: 1,
                 col_spacing: 0.0,
                 row_spacing: 0.0,
+                clip: None,
             };
             out.push(Entity { handle: d.new_handle(), common: common.clone(), kind: EntityKind::Insert(ins) });
         }

crates/doc/src/entity.rs

@@ -362,9 +362,13 @@ impl EntityKind {
                 i.scale.y *= s;
                 i.scale.z *= s;
                 i.rotation = cadcraft_geom::norm_angle(i.rotation + rot);
+                // Mirrored as AutoCAD 2024 mirrors a block reference: the X scale factor
+                // negated, the rotation 180 degrees plus twice the mirror line's angle less the
+                // old one, and a MINSERT grid's columns running the other way.
                 if mirror {
-                    i.scale.y = -i.scale.y;
-                    i.rotation = cadcraft_geom::norm_angle(rot - (i.rotation - rot));
+                    i.scale.x = -i.scale.x;
+                    i.rotation = cadcraft_geom::norm_angle(std::f64::consts::PI + rot - (i.rotation - rot));
+                    i.col_spacing = -i.col_spacing;
                 }
                 for a in &mut i.attribs {
                     transform_text(&mut a.text, m, s, rot, false);

crates/doc/src/entity/block.rs

@@ -161,6 +161,25 @@ pub struct Insert {
     pub col_spacing: f64,
     #[serde(default)]
     pub row_spacing: f64,
+    /// XCLIP boundary of this reference (other references to the block are not clipped).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub clip: Option<crate::ClipBoundary>,
+}
+impl Default for Insert {
+    fn default() -> Self {
+        Insert {
+            block: String::new(),
+            insert: Vec3::ZERO,
+            scale: unit_scale(),
+            rotation: 0.0,
+            attribs: Vec::new(),
+            cols: 1,
+            rows: 1,
+            col_spacing: 0.0,
+            row_spacing: 0.0,
+            clip: None,
+        }
+    }
 }
 
 fn unit_scale() -> Vec3 {

crates/doc/src/entity/layout.rs

@@ -1,3 +1,5 @@
+use cadcraft_geom::Mat3;
+
 use super::common::Handle;
 use super::{Color, Deserialize, Serialize, Vec2, Vec3, standard, yes};
 
@@ -25,6 +27,39 @@ pub struct Viewport {
     /// Display on (MVIEW ON/OFF). An off viewport shows its border but no model space.
     #[serde(default = "yes")]
     pub on: bool,
+    /// The view twist (DVIEW TWist inside the viewport; DXF group 51): radians counterclockwise,
+    /// the model view seen through the viewport is turned on the sheet by it. 0 is untwisted.
+    #[serde(default, skip_serializing_if = "is_zero_twist")]
+    pub twist: f64,
+}
+fn is_zero_twist(v: &f64) -> bool {
+    *v == 0.0
+}
+impl Viewport {
+    /// The view twist, usable: 0 when it isn't finite.
+    pub fn view_twist(&self) -> f64 {
+        if self.twist.is_finite() { self.twist } else { 0.0 }
+    }
+    /// Paper units per model unit.
+    pub fn scale(&self) -> f64 {
+        self.height / self.view_height
+    }
+    /// Where model point `m` is on the sheet: `center + scale · R(twist)(m − view_center)`.
+    pub fn model_to_paper(&self, m: Vec2) -> Vec2 {
+        self.center.xy() + (m - self.view_center).rotate(self.view_twist()) * self.scale()
+    }
+    /// The model point at sheet point `p` (the inverse of [`Viewport::model_to_paper`]).
+    pub fn paper_to_model(&self, p: Vec2) -> Vec2 {
+        self.view_center + ((p - self.center.xy()) / self.scale()).rotate(-self.view_twist())
+    }
+    /// [`Viewport::model_to_paper`] as a matrix.
+    pub fn model_to_paper_matrix(&self) -> Mat3 {
+        let s = self.scale();
+        Mat3::translate(self.center.xy())
+            .then_before(Mat3::scale(s, s))
+            .then_before(Mat3::rotate(self.view_twist()))
+            .then_before(Mat3::translate(-self.view_center))
+    }
 }
 
 impl Default for Viewport {
@@ -41,6 +76,7 @@ impl Default for Viewport {
             layer_colors: Vec::new(),
             clip: None,
             on: true,
+            twist: 0.0,
         }
     }
 }
@@ -59,8 +95,9 @@ pub struct Image {
     /// The image definition's name (its key in the drawing's image dictionary).
     #[serde(default, skip_serializing_if = "String::is_empty")]
     pub name: String,
-    /// Clip boundary in pixel coordinates (origin at the top-left corner of the image, y down):
-    /// two opposite corners of a rectangle, or a polygon's vertices. Empty: the whole image.
+    /// Clip boundary in pixel coordinates (y down, counted from pixel centres: the centre of the
+    /// top-left pixel is the origin, so the whole image is -0.5 to size - 0.5): two opposite
+    /// corners of a rectangle, or a polygon's vertices. Empty: the whole image.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub clip: Vec<Vec2>,
     /// The clip boundary is applied.

crates/doc/src/extents.rs

@@ -179,6 +179,13 @@ fn bounds_in<'a>(d: &'a Drawing, e: &Entity, depth: usize, blocks: &mut HashMap<
                     }
                 };
                 b = if inner.is_empty() { Bounds2::EMPTY } else { Bounds2::from_points(inner.corners().map(|c| m.apply(c))) };
+                // XCLIP: the reference app takes the boundary's box, also where it reaches past the
+                // block or misses it (an inverted clip can show anything, so it keeps the block's).
+                if let Some(c) = ins.clip.as_ref().filter(|c| c.active() && !c.inverted)
+                    && !b.is_empty()
+                {
+                    b = Bounds2::from_points(c.polygon().into_iter().map(|p| m.apply(p)));
+                }
                 if ins.cols > 1 || ins.rows > 1 {
                     let off =
                         Vec2::new(ins.col_spacing * f64::from(ins.cols.saturating_sub(1)), ins.row_spacing * f64::from(ins.rows.saturating_sub(1)))
@@ -486,6 +493,7 @@ mod tests {
                     rows: 1,
                     col_spacing: 0.0,
                     row_spacing: 0.0,
+                    clip: None,
                 }),
             )
         };

crates/doc/src/lib.rs

@@ -16,9 +16,11 @@ mod header;
 pub mod library;
 mod plotstyle;
 mod plotter;
+mod raster;
 mod refedit;
 mod store;
 mod tables;
+mod xclip;
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -33,9 +35,11 @@ pub use gdt::*;
 pub use header::{HVal, Header};
 pub use plotstyle::*;
 pub use plotter::*;
+pub use raster::{Raster, Rasters};
 pub use refedit::{RefEdit, WorkItem};
 pub use store::EntityStore;
 pub use tables::*;
+pub use xclip::{ClipBoundary, MAX_CLIP_VERTICES};
 
 /// File data CADCraft doesn't model, kept for saving (#528).
 pub mod dynblock;
@@ -136,6 +140,8 @@ pub struct Drawing {
     /// for the Linux fonts of text styles, and each style keeps its own in CADCraft xdata, so the
     /// drawing reopens with it. Never set on an open drawing.
     pub portable_fonts: bool,
+    /// The pixels of the raster images that are loaded (IMAGE). Never written to a file.
+    pub rasters: Rasters,
 }
 
 impl Default for Drawing {
@@ -196,6 +202,7 @@ impl Drawing {
             refedit: None,
             skipped_records: BTreeMap::new(),
             portable_fonts: false,
+            rasters: Rasters::default(),
         }
     }
 

crates/doc/src/raster.rs

@@ -0,0 +1,93 @@
+//! Decoded raster image pixels (IMAGE entities). The drawing keeps them for the session only:
+//! they are loaded from the image files after a drawing opens and are never written to a file.
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+/// The pixels of a raster image: 8-bit RGBA, not premultiplied, rows from the top.
+#[derive(Clone, PartialEq)]
+pub struct Raster {
+    width: u32,
+    height: u32,
+    rgba: Vec<u8>,
+    opaque: bool,
+}
+
+impl Raster {
+    /// `None` unless both sides are at least one pixel and `rgba` holds exactly four bytes per pixel.
+    pub fn new(width: u32, height: u32, rgba: Vec<u8>) -> Option<Raster> {
+        let pixels = usize::try_from(width).ok()?.checked_mul(usize::try_from(height).ok()?)?;
+        if pixels == 0 || rgba.len() != pixels.checked_mul(4)? {
+            return None;
+        }
+        let opaque = rgba.as_chunks::<4>().0.iter().all(|[_, _, _, alpha]| *alpha == u8::MAX);
+        Some(Raster { width, height, rgba, opaque })
+    }
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+    /// Four bytes per pixel (red, green, blue, alpha), `width * height` pixels.
+    pub fn rgba(&self) -> &[u8] {
+        &self.rgba
+    }
+    /// No pixel is transparent.
+    pub fn opaque(&self) -> bool {
+        self.opaque
+    }
+    /// The pixel in column `x` of row `y` (from the top): red, green, blue, alpha.
+    pub fn pixel(&self, x: u32, y: u32) -> Option<[u8; 4]> {
+        if x >= self.width || y >= self.height {
+            return None;
+        }
+        let (x, y, width) = (usize::try_from(x).ok()?, usize::try_from(y).ok()?, usize::try_from(self.width).ok()?);
+        let pixels = self.rgba.as_chunks::<4>().0;
+        pixels.get(y.checked_mul(width)?.checked_add(x)?).copied()
+    }
+}
+
+impl std::fmt::Debug for Raster {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Raster({}x{})", self.width, self.height)
+    }
+}
+
+/// The loaded pixels of a drawing's raster images, by image file path ([`crate::Image::path`]).
+/// Session data: two drawings are equal whatever images they have loaded, and copying a drawing
+/// (undo) shares the pixels.
+#[derive(Clone, Default)]
+pub struct Rasters(Arc<BTreeMap<String, Arc<Raster>>>);
+
+impl Rasters {
+    pub fn get(&self, path: &str) -> Option<&Arc<Raster>> {
+        self.0.get(path)
+    }
+    pub fn insert(&mut self, path: &str, raster: Arc<Raster>) {
+        Arc::make_mut(&mut self.0).insert(path.to_string(), raster);
+    }
+    pub fn remove(&mut self, path: &str) {
+        if self.0.contains_key(path) {
+            Arc::make_mut(&mut self.0).remove(path);
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl PartialEq for Rasters {
+    fn eq(&self, _: &Rasters) -> bool {
+        true
+    }
+}
+
+impl std::fmt::Debug for Rasters {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rasters({})", self.0.len())
+    }
+}

crates/doc/src/tables.rs

@@ -863,7 +863,7 @@ pub struct NamedView {
     /// The layer state restored with the view (its layer snapshot).
     #[serde(default)]
     pub layer_state: Option<String>,
-    /// View twist (radians, counterclockwise); kept for files, not applied to the 2D display.
+    /// View twist (radians, counterclockwise); VIEW Restore applies it to the model space view.
     #[serde(default)]
     pub twist: f64,
     /// The layout a paper space view belongs to (`None`: a model space view; an empty name: a
@@ -884,6 +884,9 @@ pub struct VportTile {
     /// Width / height of the tile on screen when it was saved (0: unknown).
     #[serde(default)]
     pub aspect: f64,
+    /// The tile's view twist (radians, counterclockwise; DXF VPORT group 51 in degrees).
+    #[serde(default)]
+    pub twist: f64,
 }
 
 /// A model space viewport configuration (VPORTS): `*Active` is the one shown, other names are

crates/doc/src/tests.rs

@@ -189,6 +189,7 @@ fn inserts_of_missing_or_empty_blocks_do_not_stretch_extents() {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         })
     };
     d.blocks.insert("Empty".into(), std::sync::Arc::new(Block::new("Empty")));
@@ -242,6 +243,7 @@ fn visible_attributes_of_a_missing_block_still_count() {
                 rows: 1,
                 col_spacing: 0.0,
                 row_spacing: 0.0,
+                clip: None,
             }),
         )
     };
@@ -285,6 +287,7 @@ fn insert_bounds_with_cyclic_block_terminate() {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         }),
     ));
     b.entities.push(Entity::new(Handle(2), line((0.0, 0.0), (1.0, 1.0))));
@@ -303,6 +306,7 @@ fn insert_bounds_with_cyclic_block_terminate() {
                 rows: 1,
                 col_spacing: 0.0,
                 row_spacing: 0.0,
+                clip: None,
             }),
         )
         .unwrap();
@@ -420,6 +424,7 @@ fn plain_insert(block: &str) -> EntityKind {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     })
 }
 

crates/doc/src/xclip.rs

@@ -0,0 +1,85 @@
+//! XCLIP: the clipping boundary of one block or xref reference.
+//!
+//! The boundary is kept in the referenced block's coordinates, so it moves, rotates and scales
+//! with its reference; the block definition and other references to it are untouched. In a file
+//! it is the reference's `ACAD_FILTER` / `SPATIAL` extension-dictionary entry (a SPATIAL_FILTER
+//! object, DXF Reference), read and written by the io crate.
+
+use cadcraft_geom::Vec2;
+use serde::{Deserialize, Serialize};
+
+/// Most boundary vertices a clip keeps (hostile files and parameters are capped to this).
+pub const MAX_CLIP_VERTICES: usize = 4096;
+
+/// A reference's clipping boundary.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClipBoundary {
+    /// Vertices in the block's coordinates: two opposite corners for a rectangle, three or more
+    /// for a closed polygon (not repeating the first vertex).
+    pub points: Vec<Vec2>,
+    /// Whether clipping is on (XCLIP ON/OFF); an off boundary is kept but nothing is clipped.
+    #[serde(default = "on")]
+    pub enabled: bool,
+    /// Inverted clip: what is inside the boundary is hidden, what is outside shows.
+    #[serde(default)]
+    pub inverted: bool,
+}
+
+fn on() -> bool {
+    true
+}
+
+impl ClipBoundary {
+    /// A boundary from `points` (block coordinates), on and not inverted.
+    pub fn new(points: Vec<Vec2>) -> Self {
+        ClipBoundary { points, enabled: true, inverted: false }
+    }
+
+    /// The closed outline in block coordinates: a rectangle's four corners or the polygon's
+    /// vertices. Empty when the boundary has fewer than two vertices, more than
+    /// [`MAX_CLIP_VERTICES`] or a non-finite one.
+    pub fn polygon(&self) -> Vec<Vec2> {
+        if self.points.len() > MAX_CLIP_VERTICES || !self.points.iter().all(|p| p.is_finite()) {
+            return Vec::new();
+        }
+        match self.points.as_slice() {
+            [a, b] => vec![
+                Vec2::new(a.x.min(b.x), a.y.min(b.y)),
+                Vec2::new(a.x.max(b.x), a.y.min(b.y)),
+                Vec2::new(a.x.max(b.x), a.y.max(b.y)),
+                Vec2::new(a.x.min(b.x), a.y.max(b.y)),
+            ],
+            [_, _, _, ..] => self.points.clone(),
+            _ => Vec::new(),
+        }
+    }
+
+    /// Whether the boundary is a rectangle given by two corners.
+    pub fn is_rectangle(&self) -> bool {
+        self.points.len() == 2
+    }
+
+    /// Whether drawing the reference is clipped by it now (on, with a usable outline).
+    pub fn active(&self) -> bool {
+        self.enabled && self.polygon().len() >= 3
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rectangle_and_polygon_outlines() {
+        let r = ClipBoundary::new(vec![Vec2::new(2.0, 3.0), Vec2::new(0.0, 0.0)]);
+        assert_eq!(r.polygon(), vec![Vec2::new(0.0, 0.0), Vec2::new(2.0, 0.0), Vec2::new(2.0, 3.0), Vec2::new(0.0, 3.0)]);
+        assert!(r.active() && r.is_rectangle());
+        let bad = ClipBoundary::new(vec![Vec2::new(f64::NAN, 0.0), Vec2::new(1.0, 1.0)]);
+        assert!(bad.polygon().is_empty() && !bad.active());
+        let one = ClipBoundary::new(vec![Vec2::ZERO]);
+        assert!(!one.active());
+        let off = ClipBoundary { enabled: false, ..r };
+        assert!(!off.active());
+    }
+}

crates/dwg/src/lib.rs

@@ -65,7 +65,7 @@ fn mb(n: u64) -> String {
 #[cfg(not(no_dwg_bridge))]
 pub mod worker;
 #[cfg(not(no_dwg_bridge))]
-pub use worker::{WORKER_ARG, crash_worker_for_test, decode, encode_as, serve_if_asked, use_own_worker, use_worker};
+pub use worker::{WORKER_ARG, crash_worker_for_test, decode, encode_as, encode_noted, serve_if_asked, use_own_worker, use_worker};
 
 #[cfg(not(no_dwg_bridge))]
 mod native {
@@ -544,15 +544,22 @@ mod native {
     /// Leave out what acadrust can't write as this DWG version: other programs' custom entities
     /// and objects without raw DWG data of that version. acadrust 0.6.4 refuses the whole file
     /// for one of them (0.6.3 left them out); CADCraft already tells the user which entity types
-    /// a DWG doesn't keep (`not_saved`), so the rest of the drawing is written. Returns how many.
-    fn drop_unwritable(doc: &mut acadrust::CadDocument) -> usize {
+    /// a DWG doesn't keep (`not_saved`), so the rest of the drawing is written. Returns how many
+    /// records of each DXF type were left out, so a save can say so.
+    fn drop_unwritable(doc: &mut acadrust::CadDocument) -> super::Unwritten {
         let version = doc.version;
+        let mut dropped = super::Unwritten::new();
+        let mut count = |name: &str| {
+            let n = dropped.entry(name.trim().to_ascii_uppercase()).or_insert(0);
+            *n = n.saturating_add(1);
+        };
         let unwritable: Vec<acadrust::Handle> = doc
             .entities()
             .filter_map(|e| match e {
                 acadrust::entities::EntityType::Unknown(u)
                     if u.raw_dwg_data.is_none() || u.dwg_source_version.is_some_and(|v| v != version) || version == acadrust::DxfVersion::AC1009 =>
                 {
+                    count(&u.dxf_name);
                     Some(u.common.handle)
                 }
                 _ => None,
@@ -565,9 +572,10 @@ mod native {
             .objects
             .iter()
             .filter_map(|(h, o)| match o {
-                acadrust::objects::ObjectType::Unknown { raw_dwg_data, raw_dwg_version, .. }
+                acadrust::objects::ObjectType::Unknown { type_name, raw_dwg_data, raw_dwg_version, .. }
                     if raw_dwg_data.is_none() || raw_dwg_version.is_some_and(|v| v != version) || version == acadrust::DxfVersion::AC1009 =>
                 {
+                    count(type_name);
                     Some(*h)
                 }
                 _ => None,
@@ -576,7 +584,7 @@ mod native {
         for h in &objects {
             doc.objects.remove(h);
         }
-        unwritable.len() + objects.len()
+        dropped
     }
 
     /// Header variables the DWG reader fills in but acadrust's DXF writer (0.6.3) leaves out of
@@ -644,12 +652,19 @@ mod native {
     /// Convert DXF bytes into a DWG file of the DXF's version, and at least AutoCAD 2004
     /// (AC1018).
     pub fn dxf_to_dwg(dxf: &[u8]) -> Result<Vec<u8>, String> {
-        convert(dxf, None)
+        convert(dxf, None).map(|(dwg, _)| dwg)
     }
 
     /// Convert DXF bytes into a DWG file of `version`, a code from [`super::VERSIONS`] ("AC1032"),
     /// whatever version the DXF declares.
     pub fn dxf_to_dwg_as(dxf: &[u8], version: &str) -> Result<Vec<u8>, String> {
+        dxf_to_dwg_noted(dxf, version).map(|(dwg, _)| dwg)
+    }
+
+    /// [`dxf_to_dwg_as`], also returning what the DWG writer left out: how many records of each
+    /// DXF type it can't write (other programs' custom entities and objects that the DWG reader
+    /// didn't read from a DWG of this version), empty when the DWG keeps everything.
+    pub fn dxf_to_dwg_noted(dxf: &[u8], version: &str) -> Result<(Vec<u8>, super::Unwritten), String> {
         let v = match version.trim().to_ascii_uppercase().as_str() {
             "AC1015" => acadrust::DxfVersion::AC1015,
             "AC1018" => acadrust::DxfVersion::AC1018,
@@ -707,7 +722,7 @@ mod native {
         }
     }
 
-    fn convert(dxf: &[u8], version: Option<acadrust::DxfVersion>) -> Result<Vec<u8>, String> {
+    fn convert(dxf: &[u8], version: Option<acadrust::DxfVersion>) -> Result<(Vec<u8>, super::Unwritten), String> {
         // Reject a pathologically large DXF before handing it to the third-party decoder, which
         // allocates tables and section buffers from the input's declared sizes and cannot be
         // interrupted once it starts (CWE-789). This bounds the large-input variant; the decoder
@@ -732,21 +747,23 @@ mod native {
             None => {}
         }
         // The fix-ups run on the third-party reader's document, so a panic in one is an error, not a crash.
-        guarded(AssertUnwindSafe(|| {
+        let unwritten = guarded(AssertUnwindSafe(|| {
             super::fail_in_test("convert");
             other_layout_owners(&mut doc);
             table_style_rows(&mut doc, true);
             dimension_flags(&mut doc);
-            drop_unwritable(&mut doc);
+            let unwritten = drop_unwritable(&mut doc);
             current_dimstyle(&mut doc);
             add_variable_dictionary(&mut doc);
             current_text_style(&mut doc);
             current_layer(&mut doc);
+            unwritten
         }))
         .map_err(|_| "the DXF to DWG conversion failed on this file".to_string())?;
-        std::panic::catch_unwind(AssertUnwindSafe(|| acadrust::DwgWriter::write_to_vec(&doc)))
+        let dwg = 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}"))
+            .map_err(|e| format!("DWG write: {e}"))?;
+        Ok((dwg, unwritten))
     }
 
     /// AutoCAD's entry name for the drawing variables dictionary (the DXF Reference calls it the
@@ -903,7 +920,11 @@ mod native {
 }
 
 #[cfg(not(no_dwg_bridge))]
-pub use native::{dwg_to_dxf, dwg_to_dxf_noted, dwg_to_dxf_with, dxf_to_dwg, dxf_to_dwg_as};
+pub use native::{dwg_to_dxf, dwg_to_dxf_noted, dwg_to_dxf_with, dxf_to_dwg, dxf_to_dwg_as, dxf_to_dwg_noted};
+
+/// What saving as DWG left out: how many records of each DXF type (upper case) the DWG writer
+/// can't write.
+pub type Unwritten = std::collections::BTreeMap<String, usize>;
 
 // Test-only: the stage ("post_process" or "convert") whose guard the current test checks. The
 // stage then panics on entry, so a test through the public API shows whether it is guarded.
@@ -950,6 +971,10 @@ pub fn decode(bytes: &[u8], limits: Limits) -> Result<(Vec<u8>, Vec<String>), St
 pub fn encode_as(dxf: &[u8], version: &str) -> Result<Vec<u8>, String> {
     dxf_to_dwg_as(dxf, version)
 }
+#[cfg(no_dwg_bridge)]
+pub fn encode_noted(dxf: &[u8], version: &str) -> Result<(Vec<u8>, Unwritten), String> {
+    dxf_to_dwg_noted(dxf, version)
+}
 
 #[cfg(no_dwg_bridge)]
 pub fn dwg_to_dxf(_bytes: &[u8]) -> Result<Vec<u8>, String> {
@@ -971,6 +996,10 @@ pub fn dxf_to_dwg(_dxf: &[u8]) -> Result<Vec<u8>, String> {
 pub fn dxf_to_dwg_as(_dxf: &[u8], _version: &str) -> Result<Vec<u8>, String> {
     Err(format!("DWG files can't be written in the {NO_BRIDGE_BUILD} build yet; save as DXF"))
 }
+#[cfg(no_dwg_bridge)]
+pub fn dxf_to_dwg_noted(_dxf: &[u8], _version: &str) -> Result<(Vec<u8>, Unwritten), String> {
+    Err(format!("DWG files can't be written in the {NO_BRIDGE_BUILD} build yet; save as DXF"))
+}
 
 #[cfg(test)]
 mod tests {
@@ -1302,4 +1331,47 @@ mod tests {
             assert_eq!(read.dwg_tail_byte, 0, "{version}");
         }
     }
+
+    /// Saving says what the DWG writer left out, per type: entities of types acadrust's DXF
+    /// reader doesn't model (another program's custom entity) can't be written; a drawing the DWG
+    /// keeps whole reports nothing.
+    #[cfg(not(no_dwg_bridge))]
+    #[test]
+    fn saving_lists_the_types_the_dwg_writer_leaves_out() {
+        let line = "  0\nLINE\n  8\n0\n100\nAcDbEntity\n100\nAcDbLine\n 10\n0.0\n 20\n0.0\n 30\n0.0\n 11\n10.0\n 21\n0.0\n 31\n0.0\n";
+        let widget = "  0\nACME_WIDGET\n  8\n0\n100\nAcDbEntity\n100\nAcmeWidget\n 10\n1.0\n 20\n2.0\n 30\n0.0\n";
+        let dxf = |body: &str| {
+            format!("  0\nSECTION\n  2\nHEADER\n  9\n$ACADVER\n  1\nAC1032\n  0\nENDSEC\n  0\nSECTION\n  2\nENTITIES\n{body}  0\nENDSEC\n  0\nEOF\n")
+        };
+        for version in ["AC1015", "AC1018", "AC1032"] {
+            let (dwg, unwritten) = dxf_to_dwg_noted(dxf(&format!("{line}{widget}{widget}")).as_bytes(), version).unwrap();
+            assert!(is_dwg(&dwg), "{version}");
+            assert_eq!(unwritten, [("ACME_WIDGET".to_string(), 2)].into_iter().collect::<Unwritten>(), "{version}");
+        }
+        let (_, unwritten) = dxf_to_dwg_noted(dxf(line).as_bytes(), "AC1032").unwrap();
+        assert!(unwritten.is_empty(), "{unwritten:?}");
+    }
+
+    /// An OLE2FRAME, which CADCraft keeps as its DXF groups without modelling it, is written to
+    /// the DWG with its data: it isn't in the list of what the writer left out.
+    #[cfg(not(no_dwg_bridge))]
+    #[test]
+    fn ole_frames_are_written_with_their_data() {
+        let ole = "  0\nOLE2FRAME\n  8\n0\n100\nAcDbEntity\n100\nAcDbOle2Frame\n 70\n2\n 10\n1.0\n 20\n9.0\n 30\n0.0\n 11\n8.0\n 21\n2.0\n 31\n0.0\n 71\n2\n 72\n0\n 73\n1\n 90\n4\n310\nDEADBEEF\n  1\nOLE\n";
+        let dxf =
+            format!("  0\nSECTION\n  2\nHEADER\n  9\n$ACADVER\n  1\nAC1032\n  0\nENDSEC\n  0\nSECTION\n  2\nENTITIES\n{ole}  0\nENDSEC\n  0\nEOF\n");
+        for version in ["AC1015", "AC1018", "AC1032"] {
+            let (dwg, unwritten) = dxf_to_dwg_noted(dxf.as_bytes(), version).unwrap();
+            assert!(unwritten.is_empty(), "{version} {unwritten:?}");
+            let back = acadrust::DwgReader::from_stream(std::io::Cursor::new(dwg)).read().unwrap();
+            let frames: Vec<Vec<u8>> = back
+                .entities()
+                .filter_map(|e| match e {
+                    acadrust::entities::EntityType::Ole2Frame(o) => Some(o.encoded_payload()),
+                    _ => None,
+                })
+                .collect();
+            assert_eq!(frames, [vec![0xDE, 0xAD, 0xBE, 0xEF]], "{version}");
+        }
+    }
 }

crates/dwg/src/worker.rs

@@ -82,15 +82,31 @@ pub fn decode(bytes: &[u8], limits: Limits) -> Result<(Vec<u8>, Vec<String>), St
 
 /// [`super::dxf_to_dwg_as`] in the worker, when there is one.
 pub fn encode_as(dxf: &[u8], version: &str) -> Result<Vec<u8>, String> {
+    encode_noted(dxf, version).map(|(dwg, _)| dwg)
+}
+
+/// [`super::dxf_to_dwg_noted`] in the worker, when there is one. What the writer left out comes
+/// back as notes of `TYPE<tab>count`.
+pub fn encode_noted(dxf: &[u8], version: &str) -> Result<(Vec<u8>, super::Unwritten), String> {
     if u8::try_from(version.len()).is_err() {
         return Err(super::unsupported(version));
     }
     match call(&request(ENCODE, Limits::DEFAULT, version), dxf, MAX_DWG_REPLY, "writing this file") {
-        Some(reply) => reply?.map(|(dwg, _)| dwg),
-        None => super::dxf_to_dwg_as(dxf, version),
+        Some(reply) => reply?.map(|(dwg, notes)| (dwg, unwritten_from(&notes))),
+        None => super::dxf_to_dwg_noted(dxf, version),
     }
 }
 
+fn unwritten_from(notes: &[String]) -> super::Unwritten {
+    notes.iter().filter_map(|n| n.split_once('\t')).filter_map(|(kind, n)| Some((kind.to_string(), n.parse::<usize>().ok()?))).fold(
+        super::Unwritten::new(),
+        |mut m, (kind, n)| {
+            *m.entry(kind).or_insert(0) = n;
+            m
+        },
+    )
+}
+
 /// Make the worker abort, as the third-party code can: what the tests prove isolation with.
 #[doc(hidden)]
 pub fn crash_worker_for_test() -> Result<(), String> {
@@ -241,7 +257,7 @@ fn handle(mut b: &[u8]) -> Reply {
     let version = take(&mut b, usize::from(version_len)).and_then(|v| std::str::from_utf8(v).ok()).ok_or_else(bad)?;
     match op {
         DECODE => super::dwg_to_dxf_noted(b, Limits { max_dwg_bytes, max_dxf_bytes }),
-        ENCODE => super::dxf_to_dwg_as(b, version).map(|dwg| (dwg, Vec::new())),
+        ENCODE => super::dxf_to_dwg_noted(b, version).map(|(dwg, left_out)| (dwg, left_out.iter().map(|(kind, n)| format!("{kind}\t{n}")).collect())),
         CRASH => std::process::abort(),
         _ => Err(bad()),
     }
@@ -267,6 +283,12 @@ mod tests {
         out
     }
 
+    #[test]
+    fn what_the_writer_left_out_survives_the_reply() {
+        let notes = vec!["ACME_WIDGET\t2".to_string(), "not a count".to_string(), "X\tmany".to_string()];
+        assert_eq!(unwritten_from(&notes), [("ACME_WIDGET".to_string(), 2)].into_iter().collect());
+    }
+
     #[test]
     fn replies_round_trip() {
         let ok: Reply = Ok((b"bytes".to_vec(), vec!["one".into(), "two é".into()]));

crates/engine/src/audit.rs

@@ -234,9 +234,10 @@ fn tables(d: &mut Drawing, out: &mut Vec<Issue>) {
         missing("table style", "Standard", out);
         d.table_styles.insert(0, TableStyle::default());
     }
-    let linetypes: Vec<String> = d.linetypes.iter().map(|l| l.name.clone()).collect();
+    // Name sets built once: both tables come from the drawing, so a scan per reference is quadratic.
+    let linetypes: HashSet<String> = d.linetypes.iter().map(|l| l.name.to_ascii_lowercase()).collect();
     for l in &mut d.layers {
-        if !linetypes.iter().any(|n| n.eq_ignore_ascii_case(&l.linetype)) {
+        if !linetypes.contains(&l.linetype.to_ascii_lowercase()) {
             out.push(issue(
                 "missingLinetype",
                 "tables",
@@ -247,8 +248,8 @@ fn tables(d: &mut Drawing, out: &mut Vec<Issue>) {
             l.linetype = "Continuous".into();
         }
     }
-    let styles: Vec<String> = d.text_styles.iter().map(|s| s.name.clone()).collect();
-    let known = |n: &str| styles.iter().any(|s| s.eq_ignore_ascii_case(n));
+    let styles: HashSet<String> = d.text_styles.iter().map(|s| s.name.to_ascii_lowercase()).collect();
+    let known = |n: &str| styles.contains(&n.to_ascii_lowercase());
     for s in &mut d.dim_styles {
         if !known(&s.text_style) {
             out.push(issue(

crates/engine/src/autosave.rs

@@ -405,10 +405,11 @@ mod native {
     pub fn prune_locks(dir: &Path) {
         let Ok(entries) = std::fs::read_dir(dir) else { return };
         let names: Vec<String> = entries.flatten().take(10_000).map(|e| e.file_name().to_string_lossy().to_string()).collect();
+        // The instances that own autosave files, parsed once rather than once per lock file.
+        let with_files: std::collections::HashSet<&str> = names.iter().filter_map(|f| parse_file_name(f)).map(|(_, i, _)| i).collect();
         for n in &names {
             let Some(instance) = parse_lock_name(n) else { continue };
-            let has_files = names.iter().any(|f| parse_file_name(f).is_some_and(|(_, i, _)| i == instance));
-            if !has_files && !owner_alive(dir, instance) {
+            if !with_files.contains(instance) && !owner_alive(dir, instance) {
                 let _ = std::fs::remove_file(dir.join(n));
             }
         }
@@ -435,7 +436,22 @@ mod native {
         }
         // 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).
-        crate::atomic_write::write_atomic(Path::new(path), &bytes).map_err(|e| e.to_string())
+        // The file holds unsaved work: owner-only from its creation, whatever the umask.
+        crate::atomic_write::write_atomic_with(Path::new(path), private_mode(), |f| f.write_all(&bytes)).map_err(|e| e.to_string())
+    }
+
+    /// Owner read/write only (`None` where file modes don't exist).
+    fn private_mode() -> Option<std::fs::Permissions> {
+        #[cfg(unix)]
+        return Some(std::os::unix::fs::PermissionsExt::from_mode(0o600));
+        #[cfg(not(unix))]
+        None
+    }
+
+    /// Write this app's lock file at `path` without following a link planted there: the file is
+    /// replaced (exclusive temporary file, then rename), never written through (CWE-59).
+    fn write_lock(path: &Path, id: u32) -> std::io::Result<()> {
+        crate::atomic_write::write_atomic_with(path, private_mode(), |f| f.write_all(id.to_string().as_bytes()))
     }
 
     impl Autosaver {
@@ -586,7 +602,7 @@ mod native {
             for (held, file) in &self.locks {
                 let refreshed = match file {
                     Some(file) => file.set_modified(SystemTime::now()),
-                    None => std::fs::write(held, id.to_string()),
+                    None => write_lock(held, id),
                 };
                 if held == path {
                     current = Some(refreshed);
@@ -595,10 +611,22 @@ mod native {
             if let Some(refreshed) = current {
                 return refreshed;
             }
-            let mut file = OpenOptions::new().write(true).create(true).truncate(false).open(path)?;
+            let mut options = OpenOptions::new();
+            options.write(true).create(true).truncate(false);
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::OpenOptionsExt;
+                // A symlink planted at the lock path must not be opened (and truncated) through,
+                // nor a FIFO wait for a reader.
+                options.custom_flags(libc::O_NOFOLLOW | libc::O_NONBLOCK).mode(0o600);
+            }
+            let mut file = options.open(path)?;
+            if !file.metadata()?.is_file() {
+                return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "the lock file is not a plain file"));
+            }
             if file.try_lock().is_err() {
                 self.locks.push((path.to_path_buf(), None));
-                return std::fs::write(path, id.to_string());
+                return write_lock(path, id);
             }
             file.set_len(0)?;
             file.write_all(format!("{id}{LOCK_HELD}").as_bytes())?;
@@ -627,6 +655,30 @@ mod native {
             }
         }
     }
+
+    #[cfg(all(test, unix))]
+    mod tests {
+        use super::*;
+
+        /// A symlink planted at the lock path is neither opened through nor written through.
+        #[test]
+        fn lock_writes_do_not_follow_a_planted_link() {
+            let dir = std::env::temp_dir().join(format!("cadcraft-lock-link-{}", std::process::id()));
+            std::fs::create_dir_all(&dir).unwrap();
+            let victim = dir.join("victim.txt");
+            std::fs::write(&victim, b"precious").unwrap();
+            let link = dir.join("1-a.lock");
+            std::os::unix::fs::symlink(&victim, &link).unwrap();
+            let mut a = Autosaver::new("1-a");
+            assert!(a.refresh_lock(&link).is_err());
+            assert_eq!(std::fs::read(&victim).unwrap(), b"precious");
+            write_lock(&link, 42).unwrap();
+            assert_eq!(std::fs::read(&victim).unwrap(), b"precious");
+            assert!(!std::fs::symlink_metadata(&link).unwrap().file_type().is_symlink());
+            assert_eq!(std::fs::read(&link).unwrap(), b"42");
+            std::fs::remove_dir_all(dir).unwrap();
+        }
+    }
 }
 
 #[cfg(test)]

crates/engine/src/cmd.rs

@@ -18,10 +18,12 @@ mod gripcmds;
 mod griphot;
 pub(crate) mod groups;
 pub(crate) mod hatch;
+mod image;
 mod inquiry;
 mod layer;
 mod layout;
 mod lisp;
+mod merge;
 mod mleader_content;
 mod mleader_edit;
 mod modify;
@@ -199,6 +201,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(layer::specs());
         v.extend(layout::specs());
         v.extend(exchange::specs());
+        v.extend(image::specs());
         v.extend(props::specs());
         v.extend(inquiry::specs());
         v.extend(settings::specs());

crates/engine/src/cmd/array.rs

@@ -159,6 +159,7 @@ pub(crate) fn make_assoc(s: &mut Session, objs: &[Handle], base: Vec2, mut p: Ar
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     }))
 }
 

crates/engine/src/cmd/blocks.rs

@@ -25,6 +25,7 @@ mod dyngrip;
 mod extract;
 pub(crate) mod refedit;
 mod wblock;
+mod xclip;
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
@@ -43,6 +44,9 @@ pub fn specs() -> Vec<CommandSpec> {
             .alias(&["i", "-insert", "ddinsert"])
             .params("{name (\"*NAME\": exploded), file?: DXF/DWG path (defines or redefines block `name`, default the file name, from its model space; base point $INSBASE), at: [x,y], scale?: number | [x, y], rotation? (degrees), basePoint?: [x,y] (block coordinates), attribs?: {TAG: value}, explode?: bool}")
             .interactive(|_| Ok(Box::new(InsertM::default()))),
+        CommandSpec::new("minsert", "Multiple Insert", run_minsert)
+            .params("{name, file?: DXF/DWG path (as INSERT), at: [x,y], scale?: number | [x, y], rotation? (degrees), basePoint?: [x,y], attribs?: {TAG: value}, rows?: 1..32767 (default 1), columns?: 1..32767 (default 1), rowSpacing?, columnSpacing? (along the reference's own axes, not scaled with it)}")
+            .interactive(|_| Ok(Box::new(InsertM { minsert: true, ..InsertM::default() }))),
         CommandSpec::new("attdef", "Define Attributes...", run_attdef)
             .menu(&["Draw", "Block", "Define Attributes..."])
             .alias(&["att", "-attdef"])
@@ -89,6 +93,7 @@ pub fn specs() -> Vec<CommandSpec> {
     .chain(attribs::attdisp_menu_specs())
     .chain(xref::specs())
     .chain(refedit::specs())
+    .chain(xclip::specs())
     .chain(bedit::specs())
     .collect()
 }
@@ -225,6 +230,7 @@ fn insert_entity(blk: &Block, at: Vec2, scale: Vec3, rotation: f64, base: Option
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     };
     if let Some(b) = base {
         let landed = ins.transform(blk.base.xy()).apply(b);
@@ -233,6 +239,33 @@ fn insert_entity(blk: &Block, at: Vec2, scale: Vec3, rotation: f64, base: Option
     ins
 }
 
+/// MINSERT's rectangular array of a block reference: rows and columns, and the distances between
+/// them along the reference's rotated axes (not scaled with it). One row and one column is a plain
+/// reference.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Grid {
+    rows: u32,
+    cols: u32,
+    row_spacing: f64,
+    col_spacing: f64,
+}
+
+impl Grid {
+    const ONE: Grid = Grid { rows: 1, cols: 1, row_spacing: 0.0, col_spacing: 0.0 };
+    /// The most rows or columns MINSERT takes, as AutoCAD 2024 asks for them.
+    const MAX: u32 = 32767;
+
+    /// A distance is kept only along an axis with more than one copy: AutoCAD 2024 asks for no
+    /// other and stores 0 for it (one row of three columns: 44 = 20, 45 = 0).
+    fn new(rows: u32, cols: u32, row_spacing: f64, col_spacing: f64) -> Grid {
+        Grid { rows, cols, row_spacing: if rows > 1 { row_spacing } else { 0.0 }, col_spacing: if cols > 1 { col_spacing } else { 0.0 } }
+    }
+
+    fn apply(self, ins: &mut Insert) {
+        (ins.rows, ins.cols, ins.row_spacing, ins.col_spacing) = (self.rows, self.cols, self.row_spacing, self.col_spacing);
+    }
+}
+
 /// [`insert`] with separate X/Y scale factors (Z as X) and an optional base point (see
 /// [`insert_entity`]).
 pub(crate) fn insert_with(
@@ -244,10 +277,12 @@ pub(crate) fn insert_with(
     base: Option<Vec2>,
     values: &serde_json::Map<String, Value>,
 ) -> Result<Handle> {
-    insert_scaled(s, name, at, Vec3::new(scale.x, scale.y, scale.x), rotation, base, values)
+    insert_scaled(s, name, at, Vec3::new(scale.x, scale.y, scale.x), rotation, base, values, Grid::ONE)
 }
 
-/// [`insert_with`] with a Z scale factor of its own.
+/// [`insert_with`] with a Z scale factor of its own, and MINSERT's grid. A grid has the one set
+/// of attributes (AutoCAD 2024 asks for their values once).
+#[allow(clippy::too_many_arguments)]
 fn insert_scaled(
     s: &mut Session,
     name: &str,
@@ -256,9 +291,11 @@ fn insert_scaled(
     rotation: f64,
     base: Option<Vec2>,
     values: &serde_json::Map<String, Value>,
+    grid: Grid,
 ) -> Result<Handle> {
     let blk = s.doc()?.block(name).cloned().ok_or_else(|| EngineError::Other(format!("Block \"{name}\" not found.")))?;
     let mut ins = insert_entity(&blk, at, scale, rotation, base);
+    grid.apply(&mut ins);
     let m = ins.transform(blk.base.xy());
     for e in blk.entities.iter() {
         if let EntityKind::AttDef(ad) = &e.kind {
@@ -310,24 +347,52 @@ fn run_block(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn run_insert(s: &mut Session, p: &Value) -> Result<Value> {
+    insert_json(s, p, "insert", Grid::ONE)
+}
+
+/// MINSERT's JSON form: INSERT's parameters and the grid.
+fn run_minsert(s: &mut Session, p: &Value) -> Result<Value> {
+    let count = |key: &str| -> Result<u32> {
+        match p.get(key) {
+            None | Some(Value::Null) => Ok(1),
+            Some(v) => v
+                .as_f64()
+                .filter(|n| n.fract() == 0.0 && *n >= 1.0 && *n <= f64::from(Grid::MAX))
+                .map(|n| n as u32)
+                .ok_or_else(|| bad("minsert", format!("`{key}` must be an integer between 1 and {}", Grid::MAX))),
+        }
+    };
+    // A distance given must be a number: `"15"` is refused, not taken as 0.
+    let spacing = |key: &str| -> Result<f64> {
+        match p.get(key) {
+            None | Some(Value::Null) => Ok(0.0),
+            Some(v) => v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("minsert", format!("`{key}` must be a number"))),
+        }
+    };
+    let grid = Grid::new(count("rows")?, count("columns")?, spacing("rowSpacing")?, spacing("columnSpacing")?);
+    insert_json(s, p, "minsert", grid)
+}
+
+/// INSERT's and MINSERT's JSON form.
+fn insert_json(s: &mut Session, p: &Value, cmd: &str, grid: Grid) -> Result<Value> {
     let p = &insert_file::json_params(s, p)?;
-    let name = str_param(p, "name").ok_or_else(|| bad("insert", "`name` is required"))?.to_string();
-    let at = point_req("insert", p, "at")?;
+    let name = str_param(p, "name").ok_or_else(|| bad(cmd, "`name` is required"))?.to_string();
+    let at = point_req(cmd, p, "at")?;
     // `scale`: one factor, or [x, y] for different X and Y scale factors.
     let scale = match p.get("scale") {
-        Some(v) if v.is_array() => point_value(v).ok_or_else(|| bad("insert", "`scale` must be a number or [x, y]"))?,
+        Some(v) if v.is_array() => point_value(v).ok_or_else(|| bad(cmd, "`scale` must be a number or [x, y]"))?,
         _ => {
             let f = f64_or(p, "scale", 1.0);
             Vec2::new(f, f)
         }
     };
     if scale.x == 0.0 || scale.y == 0.0 {
-        return Err(bad("insert", "scale cannot be 0"));
+        return Err(bad(cmd, "scale cannot be 0"));
     }
     let rot = f64_or(p, "rotation", 0.0).to_radians();
     let vals = p.get("attribs").and_then(Value::as_object).cloned().unwrap_or_default();
-    let h = insert_with(s, &name, at, scale, rot, point_param(p, "basePoint"), &vals)?;
-    if bool_or(p, "explode", false) {
+    let h = insert_scaled(s, &name, at, Vec3::new(scale.x, scale.y, scale.x), rot, point_param(p, "basePoint"), &vals, grid)?;
+    if cmd == "insert" && bool_or(p, "explode", false) {
         // The EXPLODE command body, not `execute`: INSERT records the one undo step.
         let explode = find_command("explode").ok_or_else(|| EngineError::UnknownCommand("explode".into()))?;
         return (explode.run)(s, &json!({ "handles": [h.hex()] }));
@@ -560,6 +625,15 @@ enum InsStage {
     /// XYZ: the Z scale factor, after X and Y.
     ZScale,
     Rotation,
+    /// MINSERT: the number of rows, then of columns.
+    Rows,
+    Cols,
+    /// MINSERT: the distance between rows, or a unit cell's first corner.
+    RowSpacing,
+    /// MINSERT: the unit cell's opposite corner (its width between columns, its height between
+    /// rows).
+    Cell(Vec2),
+    ColSpacing,
     Attribs,
     /// A Verify attribute asked again.
     Verify,
@@ -592,6 +666,12 @@ struct InsertM {
     explode: bool,
     /// The file waiting for the Redefine answer.
     file: Option<insert_file::FileRef>,
+    /// MINSERT: after the rotation, the grid's rows and columns and the distances between them.
+    minsert: bool,
+    rows: Option<u32>,
+    cols: Option<u32>,
+    row_spacing: Option<f64>,
+    col_spacing: Option<f64>,
 }
 
 impl InsertM {
@@ -601,6 +681,8 @@ impl InsertM {
             if self.explode { InsStage::PresetScale } else { InsStage::XScale }
         } else if self.rotation.is_none() {
             InsStage::Rotation
+        } else if let Some(g) = self.grid_stage() {
+            g
         } else {
             InsStage::Attribs
         };
@@ -619,7 +701,7 @@ impl InsertM {
             && self.values.len() >= self.attdefs.len()
             && let (Some(n), Some(a), Some(sc), Some(r)) = (self.name.clone(), self.at, self.scale, self.rotation)
         {
-            let h = insert_scaled(s, &n, a, self.scale3(sc), r, self.base, &self.values)?;
+            let h = insert_scaled(s, &n, a, self.scale3(sc), r, self.base, &self.values, self.grid())?;
             if self.explode {
                 insert_file::explode_insert(s, h)?;
             }
@@ -628,6 +710,30 @@ impl InsertM {
         Ok(Step::Continue)
     }
 
+    /// MINSERT's next grid prompt, if any is left (as AutoCAD 2024 asks them): the rows, the
+    /// columns, then the distance between rows when there is more than one row and between
+    /// columns when there is more than one column. A unit cell gives both distances.
+    fn grid_stage(&self) -> Option<InsStage> {
+        if !self.minsert {
+            return None;
+        }
+        let (Some(rows), Some(cols)) = (self.rows, self.cols) else {
+            return Some(if self.rows.is_none() { InsStage::Rows } else { InsStage::Cols });
+        };
+        if rows > 1 && self.row_spacing.is_none() {
+            Some(InsStage::RowSpacing)
+        } else if cols > 1 && self.col_spacing.is_none() {
+            Some(InsStage::ColSpacing)
+        } else {
+            None
+        }
+    }
+
+    /// The grid answered so far (one copy for INSERT).
+    fn grid(&self) -> Grid {
+        Grid::new(self.rows.unwrap_or(1), self.cols.unwrap_or(1), self.row_spacing.unwrap_or(0.0), self.col_spacing.unwrap_or(0.0))
+    }
+
     /// The Verify attributes asked for.
     fn verifying(&self) -> Vec<&(String, String, String, bool)> {
         self.attdefs.iter().filter(|a| a.3).collect()
@@ -698,13 +804,18 @@ impl InsertM {
     }
 }
 
+/// A distance typed at MINSERT's grid prompts: any finite number, negative or 0 too.
+fn distance(t: &str) -> Result<f64> {
+    number(t).filter(|v| v.is_finite()).ok_or_else(|| EngineError::Other("Requires a distance.".into()))
+}
+
 fn nonzero(t: &str) -> Result<f64> {
     number(t).filter(|v| *v != 0.0).ok_or_else(|| EngineError::Other("Requires a non-zero number.".into()))
 }
 
 impl Interactive for InsertM {
     fn name(&self) -> &'static str {
-        "INSERT"
+        if self.minsert { "MINSERT" } else { "INSERT" }
     }
     fn prompt(&self, s: &Session) -> Prompt {
         let at = self.at.unwrap_or_default();
@@ -731,9 +842,16 @@ impl Interactive for InsertM {
             InsStage::YScale => Prompt::new("Enter Y scale factor", Accept::NUMBER).default("use X scale factor"),
             InsStage::ZScale => Prompt::new("Specify Z scale factor or", Accept::NUMBER).default("use X scale factor"),
             InsStage::Rotation => Prompt::new("Specify rotation angle", Accept::POINT_OR_NUMBER).default("0").base(at),
+            InsStage::Rows => Prompt::new("Enter number of rows (---)", Accept::NUMBER).default("1"),
+            InsStage::Cols => Prompt::new("Enter number of columns (|||)", Accept::NUMBER).default("1"),
+            InsStage::RowSpacing => Prompt::new("Enter distance between rows or specify unit cell (---)", Accept::POINT_OR_NUMBER),
+            InsStage::Cell(a) => Prompt::new("Specify opposite corner", Accept::POINT).corner(a),
+            InsStage::ColSpacing => Prompt::new("Specify distance between columns (|||)", Accept::NUMBER),
             InsStage::Attribs => {
                 let (_, prompt, default, _) = self.attdefs.get(self.values.len()).cloned().unwrap_or_default();
-                Prompt::new(if prompt.is_empty() { "Enter attribute value".into() } else { prompt }, Accept::TEXT).default(default)
+                let p = Prompt::new(if prompt.is_empty() { "Enter attribute value".into() } else { prompt }, Accept::TEXT);
+                // No default shown when there is none ("Value:", AutoCAD 2024), not "<>".
+                if default.is_empty() { p } else { p.default(default) }
             }
             InsStage::Verify => {
                 let (tag, prompt) = self.verifying().get(self.verified).map(|a| (a.0.clone(), a.1.clone())).unwrap_or_default();
@@ -755,9 +873,9 @@ impl Interactive for InsertM {
                     s.echo(format!("Defined blocks: {}", names.join(", ")));
                     return Ok(Step::Continue);
                 }
-                // `*name`: insert exploded.
-                self.explode = n.starts_with('*');
-                let n = n.strip_prefix('*').map_or(n.as_str(), str::trim).to_string();
+                // `*name`: insert exploded (INSERT only: a grid has no exploded form).
+                self.explode = !self.minsert && n.starts_with('*');
+                let n = if self.explode { n.strip_prefix('*').map_or(n.as_str(), str::trim).to_string() } else { n };
                 match insert_file::file_ref(s, &n) {
                     Some(f) if f.ask_redefine(s) => {
                         self.file = Some(f);
@@ -897,6 +1015,45 @@ impl Interactive for InsertM {
                 });
                 return self.advance(s);
             }
+            InsStage::Rows | InsStage::Cols => {
+                let n = match i {
+                    Input::Text(t) => t
+                        .trim()
+                        .parse::<f64>()
+                        .ok()
+                        .filter(|v| v.fract() == 0.0 && *v >= 1.0 && *v <= f64::from(Grid::MAX))
+                        .map(|v| v as u32)
+                        .ok_or_else(|| EngineError::Other(format!("Requires an integer between 1 and {}.", Grid::MAX)))?,
+                    Input::Enter => 1,
+                    _ => return Ok(Step::Continue),
+                };
+                if self.stage == InsStage::Rows {
+                    self.rows = Some(n);
+                } else {
+                    self.cols = Some(n);
+                }
+                return self.advance(s);
+            }
+            InsStage::RowSpacing => match i {
+                Input::Point(a) => self.stage = InsStage::Cell(a),
+                Input::Text(t) => {
+                    self.row_spacing = Some(distance(&t)?);
+                    return self.advance(s);
+                }
+                _ => {}
+            },
+            InsStage::Cell(a) => {
+                if let Input::Point(b) = i {
+                    (self.col_spacing, self.row_spacing) = (Some(b.x - a.x), Some(b.y - a.y));
+                    return self.advance(s);
+                }
+            }
+            InsStage::ColSpacing => {
+                if let Input::Text(t) = i {
+                    self.col_spacing = Some(distance(&t)?);
+                    return self.advance(s);
+                }
+            }
             InsStage::Attribs => {
                 let (tag, _, default, _) = self.attdefs.get(self.values.len()).cloned().unwrap_or_default();
                 let v = match i {
@@ -937,7 +1094,9 @@ impl Interactive for InsertM {
             _ => Vec2::new(1.0, 1.0),
         });
         let rot = self.rotation.unwrap_or(if self.stage == InsStage::Rotation { at.angle_to(c) } else { 0.0 });
-        vec![EntityKind::Insert(insert_entity(b, at, self.scale3(scale), rot, self.base))]
+        let mut ins = insert_entity(b, at, self.scale3(scale), rot, self.base);
+        self.grid().apply(&mut ins);
+        vec![EntityKind::Insert(ins)]
     }
 }
 

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

@@ -6,7 +6,7 @@
 //! (names this drawing already has keep this drawing's definitions). The file is read through the
 //! host's io hooks like OPEN, so the engine stays I/O-agnostic.
 
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use cadcraft_doc::{Block, Drawing, Entity, EntityKind, Handle};
@@ -102,7 +102,7 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
     // Redefining keeps the existing definition's name (block names are case-insensitive).
     let name = d.blocks.keys().find(|k| k.eq_ignore_ascii_case(name)).cloned().unwrap_or_else(|| name.to_string());
     merge_tables(&mut d, src);
-    let renames = block_names(&d, src, &name);
+    let renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
     for (from, to) in &renames {
         let Some(b) = src.blocks.get(from) else { continue };
         let mut nb = (**b).clone();
@@ -136,13 +136,7 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
 /// Add the source's layers, linetypes and styles that this drawing doesn't have (a name that
 /// exists keeps this drawing's definition).
 fn merge_tables(d: &mut Drawing, src: &Drawing) {
-    fn merge<T: Clone>(ours: &mut Vec<T>, theirs: &[T], name: fn(&T) -> &str) {
-        for t in theirs {
-            if !ours.iter().any(|o| name(o).eq_ignore_ascii_case(name(t))) {
-                ours.push(t.clone());
-            }
-        }
-    }
+    use crate::cmd::merge::merge_named as merge;
     merge(&mut d.layers, &src.layers, |l| &l.name);
     merge(&mut d.linetypes, &src.linetypes, |l| &l.name);
     merge(&mut d.text_styles, &src.text_styles, |t| &t.name);
@@ -152,35 +146,6 @@ fn merge_tables(d: &mut Drawing, src: &Drawing) {
     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
-/// (anonymous `*…`) blocks that collide get a fresh generated name, and a named block this drawing
-/// already has (or the block being defined) keeps this drawing's definition (not copied).
-fn block_names(d: &Drawing, src: &Drawing, defining: &str) -> BTreeMap<String, String> {
-    let mut out = BTreeMap::new();
-    let mut taken: BTreeSet<String> = d.blocks.keys().map(|k| k.to_ascii_uppercase()).collect();
-    taken.insert(defining.to_ascii_uppercase());
-    for (name, b) in &src.blocks {
-        let upper = name.to_ascii_uppercase();
-        if upper.starts_with("*MODEL_SPACE") || upper.starts_with("*PAPER_SPACE") {
-            continue;
-        }
-        let to = if !taken.contains(&upper) {
-            name.clone()
-        } else if b.anonymous || name.starts_with('*') {
-            let prefix: String = name.chars().take_while(|c| !c.is_ascii_digit()).collect();
-            match (1..=1_000_000).map(|i| format!("{prefix}{i}")).find(|n| !taken.contains(&n.to_ascii_uppercase())) {
-                Some(n) => n,
-                None => continue,
-            }
-        } else {
-            continue;
-        };
-        taken.insert(to.to_ascii_uppercase());
-        out.insert(name.clone(), to);
-    }
-    out
-}
-
 /// A copy of a source entity for this drawing: a fresh handle, block references renamed, and
 /// links to other source objects (associative dimension points) dropped.
 fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {

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

@@ -0,0 +1,484 @@
+//! XCLIP and XCLIPFRAME: clip block and xref references to a boundary.
+//!
+//! A boundary belongs to one reference ([`cadcraft_doc::Insert::clip`]), in the block's own
+//! coordinates, so it moves, rotates and scales with the reference and other references of the
+//! block stay whole. It is a rectangle, a polygon or the outline of a closed polyline, can hide
+//! what is inside instead of what is outside (Invert clip), and can be turned off, deleted or
+//! turned into a polyline. Clip depth (front and back clipping planes) has no meaning in a 2D
+//! drawing and is ignored. XCLIPFRAME says whether the boundary is drawn and plotted.
+
+use cadcraft_doc::{ClipBoundary, EntityKind, Handle, MAX_CLIP_VERTICES};
+use cadcraft_geom::{PolyVertex, Vec2};
+use serde_json::{Value, json};
+
+use super::super::machines::{SelOutcome, SelectPhase};
+use crate::cmd::{CommandSpec, bad, bool_or, has_doc, point_value, str_param, targets};
+use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
+
+pub(super) fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("xclip", "Clip Xref", run)
+            .menu(&["Modify", "Clip", "Xref"])
+            .alias(&["xc"])
+            .params("{handles? | handle? (block or xref references, default the selection), option?: new|on|off|delete|polyline|clipdepth|query (default new with a boundary, else query), rectangle?: [[x,y],[x,y]] | points?: [[x,y],…] (3 to 4096, drawing coordinates) | polyline?: handle of a closed polyline, invert?: bool (hide what is inside)} → {handles, option} (query: {clips: [{handle, boundary, enabled, inverted}]}; polyline: {polylines})")
+            .enabled(has_doc)
+            .interactive(|_| Ok(Box::new(XclipM::default()))),
+        CommandSpec::new("xclipframe", "Xref Clip Frame", run_frame)
+            .params("{value?: 0 (frames hidden) | 1 (shown and plotted) | 2 (shown, not plotted; the default)} → {XCLIPFRAME}")
+            .enabled(has_doc)
+            .interactive(|_| Ok(Box::new(FrameM))),
+    ]
+}
+
+/// The block references among `hs` (other objects are ignored, as XCLIP's selection does).
+fn references(s: &Session, hs: &[Handle]) -> Vec<Handle> {
+    let Ok(d) = s.doc() else { return Vec::new() };
+    hs.iter().copied().filter(|h| d.entity(*h).is_some_and(|e| matches!(e.kind, EntityKind::Insert(_)))).collect()
+}
+
+/// A rectangle's two corners as a closed outline.
+fn rectangle(a: Vec2, b: Vec2) -> Vec<Vec2> {
+    vec![
+        Vec2::new(a.x.min(b.x), a.y.min(b.y)),
+        Vec2::new(a.x.max(b.x), a.y.min(b.y)),
+        Vec2::new(a.x.max(b.x), a.y.max(b.y)),
+        Vec2::new(a.x.min(b.x), a.y.max(b.y)),
+    ]
+}
+
+/// The boundary a JSON call gives, in drawing coordinates, and whether it is a rectangle.
+fn world_boundary(s: &Session, p: &Value) -> Result<(Vec<Vec2>, bool)> {
+    if let Some(r) = p.get("rectangle") {
+        let pts: Vec<Vec2> = r.as_array().map(|a| a.iter().filter_map(point_value).collect()).unwrap_or_default();
+        let [a, b] = pts.as_slice() else { return Err(bad("xclip", "`rectangle` needs two finite corners [[x,y],[x,y]]")) };
+        if (a.x - b.x).abs() <= 1e-12 || (a.y - b.y).abs() <= 1e-12 {
+            return Err(bad("xclip", "the clipping rectangle must have a width and a height"));
+        }
+        return Ok((vec![*a, *b], true));
+    }
+    if let Some(v) = p.get("polyline") {
+        let h = v
+            .as_str()
+            .and_then(Handle::parse_hex)
+            .or_else(|| v.as_u64().map(Handle))
+            .ok_or_else(|| bad("xclip", "`polyline` must be an object handle"))?;
+        let d = s.doc()?;
+        let e = d.entity(h).ok_or_else(|| bad("xclip", format!("no object {}", h.hex())))?;
+        let closed = matches!(&e.kind, EntityKind::LwPolyline(pl) if pl.closed) || matches!(&e.kind, EntityKind::Polyline3d(pl) if pl.closed);
+        if !closed {
+            return Err(bad("xclip", "select a closed polyline"));
+        }
+        let pts = cadcraft_render::clip::boundary_polygon(&e.kind).ok_or_else(|| bad("xclip", "the polyline does not enclose an area"))?;
+        return Ok((pts, false));
+    }
+    let pts = p.get("points").and_then(Value::as_array).ok_or_else(|| bad("xclip", "a boundary is required: `rectangle`, `points` or `polyline`"))?;
+    if !(3..=MAX_CLIP_VERTICES).contains(&pts.len()) {
+        return Err(bad("xclip", format!("a polygonal boundary needs 3 to {MAX_CLIP_VERTICES} points")));
+    }
+    let pts: Vec<Vec2> =
+        pts.iter().map(|v| point_value(v).ok_or_else(|| bad("xclip", "every boundary point must be a finite [x, y]"))).collect::<Result<_>>()?;
+    Ok((pts, false))
+}
+
+fn run(s: &mut Session, p: &Value) -> Result<Value> {
+    let hs = references(s, &targets(s, p)?);
+    if hs.is_empty() {
+        return Err(bad("xclip", "select block or xref references"));
+    }
+    let has_boundary = ["rectangle", "points", "polyline"].iter().any(|k| p.get(*k).is_some());
+    let option = str_param(p, "option").map(str::to_ascii_lowercase).unwrap_or_else(|| if has_boundary { "new".into() } else { "query".into() });
+    match option.as_str() {
+        "new" | "n" => {
+            let (world, rect) = world_boundary(s, p)?;
+            let outline = if rect { world.first().zip(world.get(1)).map(|(a, b)| rectangle(*a, *b)).unwrap_or_default() } else { world.clone() };
+            if cadcraft_render::clip::PolyClip::new(&outline).is_none() {
+                return Err(bad("xclip", "the clipping boundary encloses no area"));
+            }
+            let invert = bool_or(p, "invert", false);
+            let mut clips = Vec::with_capacity(hs.len());
+            {
+                let d = s.doc()?;
+                for h in &hs {
+                    let Some(EntityKind::Insert(ins)) = d.entity(*h).map(|e| &e.kind) else { continue };
+                    let base = d.block(&ins.block).map(|b| b.base.xy()).ok_or_else(|| bad("xclip", format!("block \"{}\" is missing", ins.block)))?;
+                    let inv = ins.transform(base).inverse().ok_or_else(|| bad("xclip", "a reference with a zero scale can't be clipped"))?;
+                    let points: Vec<Vec2> = world.iter().map(|q| inv.apply(*q)).collect();
+                    // A rotated or skewed reference sees the rectangle as a polygon.
+                    let r = ins.rotation.rem_euclid(std::f64::consts::FRAC_PI_2);
+                    let square = r < 1e-9 || std::f64::consts::FRAC_PI_2 - r < 1e-9;
+                    let points = if rect && !square { outline.iter().map(|q| inv.apply(*q)).collect() } else { points };
+                    clips.push((*h, ClipBoundary { points, enabled: true, inverted: invert }));
+                }
+            }
+            for (h, c) in clips {
+                set_clip(s, h, Some(c))?;
+            }
+        }
+        "on" | "off" => {
+            let on = option == "on";
+            // Every reference is checked before any changes: an error leaves the drawing as it was.
+            let d = s.doc()?;
+            if !hs.iter().all(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Insert(i)) if i.clip.is_some())) {
+                return Err(bad("xclip", "no clipping boundary on the selected reference"));
+            }
+            // Only the flag changes, once per reference (a selection may name one many times).
+            let mut seen = std::collections::HashSet::new();
+            for h in hs.iter().filter(|h| seen.insert(**h)) {
+                s.doc_mut()?
+                    .modify_entity(*h, |e| {
+                        if let EntityKind::Insert(i) = &mut e.kind
+                            && let Some(c) = &mut i.clip
+                        {
+                            c.enabled = on;
+                        }
+                    })
+                    .map_err(|e| bad("xclip", e.to_string()))?;
+            }
+        }
+        "delete" | "d" => {
+            for h in &hs {
+                set_clip(s, *h, None)?;
+            }
+        }
+        "polyline" | "p" | "generate" => {
+            let mut made = Vec::new();
+            for h in &hs {
+                let Some(world) = world_outline(s, *h) else { continue };
+                let vertices = world.into_iter().map(|p| PolyVertex { p, bulge: 0.0, start_width: 0.0, end_width: 0.0 }).collect();
+                let pl = cadcraft_doc::LwPolyline { vertices, closed: true, const_width: 0.0, elevation: 0.0, plinegen: false };
+                made.push(s.add_entity(EntityKind::LwPolyline(pl))?.hex());
+            }
+            if made.is_empty() {
+                return Err(bad("xclip", "no clipping boundary on the selected references"));
+            }
+            return Ok(json!({ "handles": hexes(&hs), "option": "polyline", "polylines": made }));
+        }
+        // Front and back clipping planes have no meaning in 2D: nothing changes.
+        "clipdepth" | "c" => return Ok(json!({ "handles": hexes(&hs), "option": "clipdepth", "ignored": true })),
+        "query" | "?" => {
+            let clips: Vec<Value> = hs
+                .iter()
+                .map(|h| {
+                    let c = clip_of(s, *h);
+                    json!({
+                        "handle": h.hex(),
+                        "boundary": world_outline(s, *h).map(|w| w.iter().map(|p| [p.x, p.y]).collect::<Vec<_>>()),
+                        "enabled": c.as_ref().is_some_and(|c| c.enabled),
+                        "inverted": c.as_ref().is_some_and(|c| c.inverted),
+                    })
+                })
+                .collect();
+            return Ok(json!({ "clips": clips }));
+        }
+        o => return Err(bad("xclip", format!("unknown option \"{o}\" (new, on, off, delete, polyline, clipdepth or query)"))),
+    }
+    Ok(json!({ "handles": hexes(&hs), "option": option }))
+}
+
+fn hexes(hs: &[Handle]) -> Vec<String> {
+    hs.iter().map(|h| h.hex()).collect()
+}
+
+fn clip_of(s: &Session, h: Handle) -> Option<ClipBoundary> {
+    match &s.doc().ok()?.entity(h)?.kind {
+        EntityKind::Insert(i) => i.clip.clone(),
+        _ => None,
+    }
+}
+
+/// Reference `h`'s boundary outline in drawing coordinates.
+fn world_outline(s: &Session, h: Handle) -> Option<Vec<Vec2>> {
+    let d = s.doc().ok()?;
+    let EntityKind::Insert(i) = &d.entity(h)?.kind else { return None };
+    let c = i.clip.as_ref()?;
+    let m = i.transform(d.block(&i.block)?.base.xy());
+    let poly = c.polygon();
+    (poly.len() >= 3).then(|| poly.into_iter().map(|p| m.apply(p)).collect())
+}
+
+fn set_clip(s: &mut Session, h: Handle, c: Option<ClipBoundary>) -> Result<()> {
+    s.doc_mut()?
+        .modify_entity(h, |e| {
+            if let EntityKind::Insert(i) = &mut e.kind {
+                i.clip = c;
+            }
+        })
+        .map_err(|e| bad("xclip", e.to_string()))
+}
+
+// ---------------- XCLIPFRAME ----------------
+
+fn run_frame(s: &mut Session, p: &Value) -> Result<Value> {
+    let v = match p.get("value").or_else(|| p.get("XCLIPFRAME")) {
+        None | Some(Value::Null) => return Ok(json!({ "XCLIPFRAME": s.doc()?.header.i64("XCLIPFRAME", 2) })),
+        Some(v) => v.as_i64().or_else(|| v.as_str().and_then(|t| t.trim().parse().ok())),
+    };
+    let v = v.filter(|v| (0..=2).contains(v)).ok_or_else(|| bad("xclipframe", "`value` must be 0, 1 or 2"))?;
+    s.doc_mut()?.header.set_i64("XCLIPFRAME", v);
+    Ok(json!({ "XCLIPFRAME": v }))
+}
+
+struct FrameM;
+
+impl Interactive for FrameM {
+    fn name(&self) -> &'static str {
+        "XCLIPFRAME"
+    }
+    fn prompt(&self, s: &Session) -> Prompt {
+        let cur = s.doc().map(|d| d.header.i64("XCLIPFRAME", 2)).unwrap_or(2);
+        Prompt::new("Enter new value for XCLIPFRAME", Accept::TEXT).kw(&["0", "1", "2"]).default(cur.to_string())
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        let t = match i {
+            Input::Cancel => return Ok(Step::Cancel),
+            Input::Enter => return Ok(Step::Done),
+            Input::Text(t) | Input::Keyword(t) => t,
+            _ => return Ok(Step::Continue),
+        };
+        match run_frame(s, &json!({ "value": t.trim() })) {
+            Ok(_) => Ok(Step::Done),
+            Err(_) => {
+                s.echo("Requires an integer between 0 and 2.");
+                Ok(Step::Continue)
+            }
+        }
+    }
+}
+
+// ---------------- interactive XCLIP ----------------
+
+#[derive(Default, Clone, Copy, PartialEq, Eq)]
+enum Stage {
+    #[default]
+    Select,
+    Option,
+    DeleteOld,
+    Boundary,
+    Corner1,
+    Corner2,
+    Polygon,
+    Polyline,
+}
+
+#[derive(Default)]
+struct XclipM {
+    stage: Stage,
+    sel: SelectPhase,
+    refs: Vec<Handle>,
+    invert: bool,
+    pts: Vec<Vec2>,
+}
+
+impl XclipM {
+    fn selected(&mut self, s: &mut Session, hs: &[Handle]) -> Result<Step> {
+        self.refs = references(s, hs);
+        if self.refs.is_empty() {
+            s.echo("No block or xref references selected.");
+            return Ok(Step::Done);
+        }
+        self.stage = Stage::Option;
+        Ok(Step::Continue)
+    }
+
+    fn apply(&mut self, s: &mut Session, mut p: Value) -> Result<Step> {
+        p["handles"] = json!(hexes(&self.refs));
+        let r = run(s, &p);
+        s.set_selection(Vec::new());
+        match r {
+            Ok(_) => Ok(Step::Done),
+            Err(e) => {
+                s.echo(e.to_string());
+                Ok(Step::Done)
+            }
+        }
+    }
+
+    /// Delete: as the reference app, with nothing to delete it says so and asks again.
+    fn delete(&mut self, s: &mut Session) -> Result<Step> {
+        if !self.any_clipped(s) {
+            s.echo("No clip boundary found.");
+            return Ok(Step::Continue);
+        }
+        self.apply(s, json!({ "option": "delete" }))
+    }
+
+    fn any_clipped(&self, s: &Session) -> bool {
+        self.refs.iter().any(|h| clip_of(s, *h).is_some())
+    }
+}
+
+fn kw(i: &Input) -> Option<String> {
+    match i {
+        Input::Keyword(k) | Input::Text(k) => Some(k.trim().to_ascii_lowercase()),
+        _ => None,
+    }
+}
+
+impl Interactive for XclipM {
+    fn name(&self) -> &'static str {
+        "XCLIP"
+    }
+
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        self.sel = SelectPhase::begin(s);
+        if self.sel.done {
+            let hs = self.sel.picked.clone();
+            return self.selected(s, &hs);
+        }
+        Ok(Step::Continue)
+    }
+
+    fn prompt(&self, _s: &Session) -> Prompt {
+        match self.stage {
+            Stage::Select => self.sel.prompt(),
+            Stage::Option => Prompt::new("Enter clipping option", Accept::TEXT)
+                .kw(&["ON", "OFF", "Clipdepth", "Delete", "generate Polyline", "New boundary"])
+                .default("New"),
+            Stage::DeleteOld => Prompt::new("Delete old boundary(s)?", Accept::TEXT).kw(&["Yes", "No"]).default("Yes"),
+            Stage::Boundary => Prompt::new("Specify clipping boundary or select invert option", Accept::POINT)
+                .kw(&["Select polyline", "Polygonal", "Rectangular", "Invert clip"])
+                .default("Rectangular"),
+            Stage::Corner1 => Prompt::new("Specify first corner", Accept::POINT),
+            Stage::Corner2 => {
+                let p = Prompt::new("Specify opposite corner", Accept::POINT);
+                match self.pts.first() {
+                    Some(a) => p.corner(*a),
+                    None => p,
+                }
+            }
+            Stage::Polygon => {
+                let msg = if self.pts.is_empty() { "Specify first point" } else { "Specify next point" };
+                let p = Prompt::new(msg, Accept::POINT).base_opt(self.pts.last().copied());
+                if self.pts.is_empty() { p } else { p.kw(&["Undo"]) }
+            }
+            Stage::Polyline => Prompt::new("Select polyline", Accept::SELECT),
+        }
+    }
+
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        if matches!(i, Input::Cancel) {
+            return Ok(Step::Cancel);
+        }
+        match self.stage {
+            Stage::Select => match self.sel.feed(s, &i)? {
+                SelOutcome::More => Ok(Step::Continue),
+                SelOutcome::Empty => Ok(Step::Done),
+                SelOutcome::Done(hs) => self.selected(s, &hs),
+            },
+            Stage::Option => {
+                let k = if matches!(i, Input::Enter) { Some("new".to_string()) } else { kw(&i) };
+                match k.as_deref() {
+                    Some("on") => self.apply(s, json!({ "option": "on" })),
+                    Some("off") => self.apply(s, json!({ "option": "off" })),
+                    Some(k) if k.starts_with('c') => {
+                        s.echo("Clip depth does not apply to a 2D drawing: front and back clipping planes are ignored.");
+                        Ok(Step::Done)
+                    }
+                    Some(k) if k.starts_with('d') => self.delete(s),
+                    Some(k) if k.starts_with('p') || k.starts_with('g') => self.apply(s, json!({ "option": "polyline" })),
+                    Some(k) if k.starts_with('n') => {
+                        self.stage = if self.any_clipped(s) { Stage::DeleteOld } else { Stage::Boundary };
+                        Ok(Step::Continue)
+                    }
+                    _ => {
+                        s.echo("Invalid option keyword.");
+                        Ok(Step::Continue)
+                    }
+                }
+            }
+            Stage::DeleteOld => match kw(&i).as_deref() {
+                None if matches!(i, Input::Enter) => {
+                    self.stage = Stage::Boundary;
+                    Ok(Step::Continue)
+                }
+                Some(k) if k.starts_with('y') => {
+                    self.stage = Stage::Boundary;
+                    Ok(Step::Continue)
+                }
+                Some(k) if k.starts_with('n') => Ok(Step::Done),
+                _ => Ok(Step::Continue),
+            },
+            Stage::Boundary => match (&i, kw(&i).as_deref()) {
+                (Input::Enter, _) => {
+                    self.stage = Stage::Corner1;
+                    Ok(Step::Continue)
+                }
+                (Input::Point(p), _) => {
+                    // A point starts the default rectangle.
+                    self.pts = vec![*p];
+                    self.stage = Stage::Corner2;
+                    Ok(Step::Continue)
+                }
+                (_, Some(k)) if k.starts_with('i') => {
+                    self.invert = !self.invert;
+                    s.echo(if self.invert {
+                        "Inside mode - Objects inside boundary will be hidden."
+                    } else {
+                        "Outside mode - Objects outside boundary will be hidden."
+                    });
+                    Ok(Step::Continue)
+                }
+                (_, Some(k)) if k.starts_with('s') => {
+                    self.stage = Stage::Polyline;
+                    Ok(Step::Continue)
+                }
+                (_, Some(k)) if k.starts_with('p') => {
+                    self.pts.clear();
+                    self.stage = Stage::Polygon;
+                    Ok(Step::Continue)
+                }
+                (_, Some(k)) if k.starts_with('r') => {
+                    self.stage = Stage::Corner1;
+                    Ok(Step::Continue)
+                }
+                _ => Ok(Step::Continue),
+            },
+            Stage::Corner1 => match i {
+                Input::Point(p) => {
+                    self.pts = vec![p];
+                    self.stage = Stage::Corner2;
+                    Ok(Step::Continue)
+                }
+                _ => Ok(Step::Continue),
+            },
+            Stage::Corner2 => match (i, self.pts.first().copied()) {
+                (Input::Point(b), Some(a)) => self.apply(s, json!({ "option": "new", "rectangle": [[a.x, a.y], [b.x, b.y]], "invert": self.invert })),
+                _ => Ok(Step::Continue),
+            },
+            Stage::Polygon => match i {
+                Input::Point(p) if self.pts.len() < MAX_CLIP_VERTICES => {
+                    self.pts.push(p);
+                    Ok(Step::Continue)
+                }
+                Input::Point(_) => {
+                    s.echo(format!("A boundary has at most {MAX_CLIP_VERTICES} points."));
+                    Ok(Step::Continue)
+                }
+                Input::Keyword(_) | Input::Text(_) => {
+                    self.pts.pop();
+                    Ok(Step::Continue)
+                }
+                Input::Enter if self.pts.len() >= 3 => {
+                    let pts: Vec<[f64; 2]> = self.pts.iter().map(|p| [p.x, p.y]).collect();
+                    self.apply(s, json!({ "option": "new", "points": pts, "invert": self.invert }))
+                }
+                Input::Enter => {
+                    s.echo("A polygonal boundary needs at least three points.");
+                    Ok(Step::Continue)
+                }
+                _ => Ok(Step::Continue),
+            },
+            Stage::Polyline => match i {
+                Input::Pick(hs) => match hs.first() {
+                    Some(h) => {
+                        let h = *h;
+                        self.apply(s, json!({ "option": "new", "polyline": h.hex(), "invert": self.invert }))
+                    }
+                    None => Ok(Step::Continue),
+                },
+                Input::Enter => Ok(Step::Done),
+                _ => Ok(Step::Continue),
+            },
+        }
+    }
+}

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

@@ -62,11 +62,20 @@ pub(crate) fn after_open(s: &mut Session, i: usize) {
     st.saved = st.doc.clone();
     let ext = st.doc.extents(&cadcraft_doc::Space::Model);
     if !ext.is_empty() {
-        st.set_view_quiet(crate::View { center: ext.center(), height: (ext.height().max(ext.width() * px.1 / px.0.max(1.0)) * 1.1).max(1e-6) });
+        // Fit in the frame of the saved twist, which open_drawing has restored.
+        let twist = st.view().twist;
+        let (center, w, h) = crate::View::twisted_box(ext, twist);
+        st.set_view_quiet(crate::View { center, height: (h.max(w * px.1 / px.0.max(1.0)) * 1.1).max(1e-6), twist });
     }
     echo_all(s, &out);
 }
 
+/// The file a reference saved as `path` in a drawing at `host` is read from, if there is one
+/// (xrefs and raster images look in the same places).
+pub(crate) fn find_file(path: &str, host: Option<&str>) -> Option<std::path::PathBuf> {
+    load::find(path, host.map(std::path::Path::new), false).ok()
+}
+
 /// The open drawing's path (xref paths are relative to its folder).
 fn host(s: &Session) -> Option<String> {
     s.state().ok().and_then(|st| st.path.clone())

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

@@ -10,6 +10,7 @@
 //! loaded further up (a circular reference) is not loaded again. Every failure leaves the xref's
 //! block empty with a status saying why; nothing here stops the host drawing from opening.
 
+use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
@@ -339,14 +340,15 @@ fn load_in(d: &mut Drawing, name: &str, host: Option<&Path>, chosen: bool, cx: &
     let (status, detail) = match fetch(&path, host, chosen, cx, depth) {
         Ok((x, file)) => match import(d, &key, &x, cx) {
             Ok(()) => (XrefStatus::Loaded, file.to_string_lossy().into_owned()),
-            Err(e) => (XrefStatus::Unresolved, e),
+            Err(e) => {
+                // Whatever made it in before the failure goes again. A fetch that failed imported
+                // nothing, so it doesn't pay for a second scan of the block table.
+                clear(d, &key);
+                (XrefStatus::Unresolved, e)
+            }
         },
         Err(e) => e,
     };
-    if status != XrefStatus::Loaded {
-        // Whatever made it in before the failure goes again.
-        clear(d, &key);
-    }
     set_status(d, &key, status);
     (status, detail)
 }
@@ -390,9 +392,15 @@ fn import(d: &mut Drawing, key: &str, x: &Drawing, cx: &mut Ctx) -> Result<(), S
         return Err(format!("more than {MAX_XREF_OBJECTS} objects"));
     }
     let dep = |sym: Sym, n: &str| (!shared(sym, n)).then(|| format!("{key}|{n}"));
+    // The host's names per table, looked up in a set built once: both drawings are hostile input,
+    // so a scan per imported record would be quadratic.
+    fn names<T>(all: &[T], name: fn(&T) -> &str) -> HashSet<String> {
+        all.iter().map(|t| name(t).to_ascii_uppercase()).collect()
+    }
+    let mut have = names(&d.layers, |l| &l.name);
     for l in &x.layers {
         if let Some(n) = dep(Sym::Layer, &l.name)
-            && d.layer(&n).is_none()
+            && have.insert(n.to_ascii_uppercase())
         {
             let mut l = l.clone();
             l.name = n;
@@ -400,39 +408,44 @@ fn import(d: &mut Drawing, key: &str, x: &Drawing, cx: &mut Ctx) -> Result<(), S
             d.layers.push(l);
         }
     }
+    let mut have = names(&d.linetypes, |t| &t.name);
     for t in &x.linetypes {
         if let Some(n) = dep(Sym::Linetype, &t.name)
-            && d.linetype(&n).is_none()
+            && have.insert(n.to_ascii_uppercase())
         {
             d.linetypes.push(cadcraft_doc::Linetype { name: n, ..t.clone() });
         }
     }
+    let mut have = names(&d.text_styles, |t| &t.name);
     for t in &x.text_styles {
         if let Some(n) = dep(Sym::Style, &t.name)
-            && d.text_style(&n).is_none()
+            && have.insert(n.to_ascii_uppercase())
         {
             d.text_styles.push(cadcraft_doc::TextStyle { name: n, ..t.clone() });
         }
     }
+    let mut have = names(&d.dim_styles, |t| &t.name);
     for t in &x.dim_styles {
         if let Some(n) = dep(Sym::DimStyle, &t.name)
-            && d.dim_style(&n).is_none()
+            && have.insert(n.to_ascii_uppercase())
         {
             let text_style = dep(Sym::Style, &t.text_style).unwrap_or_else(|| t.text_style.clone());
             d.dim_styles.push(cadcraft_doc::DimStyle { name: n, text_style, ..t.clone() });
         }
     }
+    let mut have = names(&d.mleader_styles, |t| &t.name);
     for t in &x.mleader_styles {
         if let Some(n) = dep(Sym::MLeaderStyle, &t.name)
-            && !d.mleader_styles.iter().any(|o| o.name.eq_ignore_ascii_case(&n))
+            && have.insert(n.to_ascii_uppercase())
         {
             let text_style = dep(Sym::Style, &t.text_style).unwrap_or_else(|| t.text_style.clone());
             d.mleader_styles.push(cadcraft_doc::MLeaderStyle { name: n, text_style, ..t.clone() });
         }
     }
+    let mut have = names(&d.table_styles, |t| &t.name);
     for t in &x.table_styles {
         if let Some(n) = dep(Sym::TableStyle, &t.name)
-            && !d.table_styles.iter().any(|o| o.name.eq_ignore_ascii_case(&n))
+            && have.insert(n.to_ascii_uppercase())
         {
             d.table_styles.push(cadcraft_doc::TableStyle { name: n, ..t.clone() });
         }

crates/engine/src/cmd/clipboard.rs

@@ -10,7 +10,7 @@
 //! The clipboard can also travel as DXF text ([`system_text`], [`load_system_text`]), so a front
 //! end can put it on the system clipboard and paste it into another CADCraft window.
 
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 
 use cadcraft_doc::{Block, Drawing, Entity, EntityKind, HVal, Handle};
@@ -279,20 +279,14 @@ fn defs_for(src: &Drawing, ents: &[Entity]) -> Drawing {
 /// Add `defs`' table records and blocks that `d` doesn't have. Returns the blocks copied, from
 /// their name in `defs` to their name in `d`.
 fn merge(d: &mut Drawing, defs: &Drawing) -> BTreeMap<String, String> {
-    fn add<T: Clone>(ours: &mut Vec<T>, theirs: &[T], name: fn(&T) -> &str) {
-        for t in theirs {
-            if !ours.iter().any(|o| name(o).eq_ignore_ascii_case(name(t))) {
-                ours.push(t.clone());
-            }
-        }
-    }
+    use crate::cmd::merge::merge_named as add;
     add(&mut d.layers, &defs.layers, |l| &l.name);
     add(&mut d.linetypes, &defs.linetypes, |l| &l.name);
     add(&mut d.text_styles, &defs.text_styles, |t| &t.name);
     add(&mut d.dim_styles, &defs.dim_styles, |t| &t.name);
     add(&mut d.mleader_styles, &defs.mleader_styles, |t| &t.name);
     add(&mut d.table_styles, &defs.table_styles, |t| &t.name);
-    let renames = block_names(d, defs);
+    let renames = crate::cmd::merge::block_renames(d, defs, None);
     for (from, to) in &renames {
         let Some(b) = defs.blocks.get(from) else { continue };
         let mut nb = (**b).clone();
@@ -308,34 +302,6 @@ fn merge(d: &mut Drawing, defs: &Drawing) -> BTreeMap<String, String> {
     renames
 }
 
-/// Which blocks of `defs` to copy, and under which name: a new name keeps its own, a generated
-/// (anonymous `*…`) block whose name is taken gets a fresh generated name, and a named block `d`
-/// already has keeps `d`'s definition (not copied).
-fn block_names(d: &Drawing, defs: &Drawing) -> BTreeMap<String, String> {
-    let mut out = BTreeMap::new();
-    let mut taken: BTreeSet<String> = d.blocks.keys().map(|k| up(k)).collect();
-    for (name, b) in &defs.blocks {
-        let upper = up(name);
-        if upper.starts_with("*MODEL_SPACE") || upper.starts_with("*PAPER_SPACE") {
-            continue;
-        }
-        let to = if !taken.contains(&upper) {
-            name.clone()
-        } else if b.anonymous || name.starts_with('*') {
-            let prefix: String = name.chars().take_while(|c| !c.is_ascii_digit()).collect();
-            match (1..=1_000_000).map(|i| format!("{prefix}{i}")).find(|n| !taken.contains(&up(n))) {
-                Some(n) => n,
-                None => continue,
-            }
-        } else {
-            continue;
-        };
-        taken.insert(up(&to));
-        out.insert(name.clone(), to);
-    }
-    out
-}
-
 /// A copy of a clipboard object for `d`: a fresh handle, block references renamed, and links to
 /// objects of the source drawing (associative dimension points) dropped.
 fn adopt(d: &mut Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {

crates/engine/src/cmd/exchange.rs

@@ -7,7 +7,7 @@
 //! stays I/O-agnostic; the JSON forms never open dialogs (the UI asks for files when these
 //! commands come from a menu, the tool bar or the command line).
 
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use cadcraft_color::Rgb;
@@ -55,11 +55,11 @@ pub fn specs() -> Vec<CommandSpec> {
             .alias(&["printpdf", "pdfb"])
             .params("{path?: \"DIR/NAME^NAME2.pdf\" (default: the drawing's file; a `^` splits the name into one book name per row of frames; else returns base64 `data` per book), names?: [book names], frameHeight?: mm (default 297), unit?: mm per drawing unit (default 1)} → {books: [{name, pages, bytes, path? | data}], skipped}: closed polylines of the frame height in model space are sheet frames; each row (same lower edge, bottom to top) is one PDF, its frames left to right one page each on the paper (ISO A-series, either orientation) they match")
             .noundo(),
-        CommandSpec::new("attach", "Attach", |_, _| {
-            Err(EngineError::Other("ATTACH is not available yet: raster images and PDF/DWF/DGN underlays can't be shown yet".into()))
+        CommandSpec::new("attach", "Attach", |s, p| match str_param(p, "path").map(extension) {
+            Some(e) if super::image::is_image_ext(&e) => super::image::run_imageattach(s, p),
+            _ => Err(EngineError::Other("ATTACH is not available yet for this file: only raster images (PNG, JPEG, BMP, TIFF; see IMAGEATTACH) can be attached, PDF/DWF/DGN underlays can't be shown yet".into())),
         })
-        .params("not available yet")
-        .noundo(),
+        .params("{path: image file, …} as IMAGEATTACH; other file types are not available yet"),
         CommandSpec::new("share", "Share", |_, _| {
             Err(EngineError::Other("SHARE is not available yet: there is no online service to share through; EXPORT or PUBLISH the drawing and send the file".into()))
         })
@@ -166,7 +166,7 @@ fn import_drawing(s: &mut Session, src: &Drawing, at: Vec2, scale: f64, file: &s
     let space = s.space();
     let d = s.doc_mut()?;
     let (layers, styles) = merge_tables(d, src);
-    let renames = block_names(d, src);
+    let renames = crate::cmd::merge::block_renames(d, src, None);
     for (from, to) in &renames {
         let Some(b) = src.blocks.get(from) else { continue };
         let mut nb = (**b).clone();
@@ -213,16 +213,7 @@ fn read_file(_path: &str) -> Result<Vec<u8>> {
 /// Add the source's layers, linetypes and styles that this drawing doesn't have (a name that
 /// exists keeps this drawing's definition). Returns how many layers and how many other records were added.
 fn merge_tables(d: &mut Drawing, src: &Drawing) -> (usize, usize) {
-    fn merge<T: Clone>(ours: &mut Vec<T>, theirs: &[T], name: fn(&T) -> &str) -> usize {
-        let mut n = 0;
-        for t in theirs {
-            if !ours.iter().any(|o| name(o).eq_ignore_ascii_case(name(t))) {
-                ours.push(t.clone());
-                n += 1;
-            }
-        }
-        n
-    }
+    use crate::cmd::merge::merge_named as merge;
     let layers = merge(&mut d.layers, &src.layers, |l| &l.name);
     let others = merge(&mut d.linetypes, &src.linetypes, |l| &l.name)
         + merge(&mut d.text_styles, &src.text_styles, |t| &t.name)
@@ -232,35 +223,6 @@ fn merge_tables(d: &mut Drawing, src: &Drawing) -> (usize, usize) {
     (layers, others)
 }
 
-/// Which source blocks to copy, and under which name: new names keep theirs, generated
-/// (anonymous `*…`) blocks that collide get a fresh generated name, and a named block this drawing
-/// already has keeps this drawing's definition (not copied).
-fn block_names(d: &Drawing, src: &Drawing) -> BTreeMap<String, String> {
-    let mut out = BTreeMap::new();
-    let mut taken: BTreeSet<String> = d.blocks.keys().map(|k| k.to_ascii_uppercase()).collect();
-    for (name, b) in &src.blocks {
-        let upper = name.to_ascii_uppercase();
-        if upper.starts_with("*MODEL_SPACE") || upper.starts_with("*PAPER_SPACE") {
-            continue;
-        }
-        let anonymous = b.anonymous || name.starts_with('*');
-        let to = if !taken.contains(&upper) {
-            name.clone()
-        } else if anonymous {
-            let prefix: String = name.chars().take_while(|c| !c.is_ascii_digit()).collect();
-            match (1..=1_000_000).map(|i| format!("{prefix}{i}")).find(|n| !taken.contains(&n.to_ascii_uppercase())) {
-                Some(n) => n,
-                None => continue,
-            }
-        } else {
-            continue;
-        };
-        taken.insert(to.to_ascii_uppercase());
-        out.insert(name.clone(), to);
-    }
-    out
-}
-
 /// A copy of a source entity for this drawing: a fresh handle, block references renamed, and
 /// links to other source objects (associative dimension points) dropped.
 fn adopt(d: &mut Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
@@ -680,6 +642,7 @@ mod tests {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         })
     }
 

crates/engine/src/cmd/file.rs

@@ -70,6 +70,19 @@ pub fn entity_codec() -> Option<&'static EntityCodec> {
 /// COMPARE (drawing comparison).
 pub mod compare;
 
+/// Decode a raster image file (PNG, JPEG, BMP, TIFF) to pixels: installed by the app with the
+/// image reader, a lower layer.
+pub type ImageHook = fn(&[u8]) -> std::result::Result<cadcraft_doc::Raster, String>;
+
+static IMAGE: OnceLock<ImageHook> = OnceLock::new();
+
+pub fn set_image_decoder(h: ImageHook) {
+    let _ = IMAGE.set(h);
+}
+pub fn image_decoder() -> Option<ImageHook> {
+    IMAGE.get().copied()
+}
+
 /// Hand finished file bytes to the user where there is no file system (the browser: a download).
 /// Arguments: file name, MIME type, bytes. `Ok` only once the delivery was actually started.
 pub type DeliverHook = fn(&str, &str, &[u8]) -> std::result::Result<(), String>;
@@ -311,6 +324,7 @@ pub fn finish_open(s: &mut Session, f: ReadFile) -> Result<Value> {
     let ReadFile { drawing, binary_dxf, name, path } = f;
     let i = add_read(s, drawing, binary_dxf, &name, path);
     super::blocks::xref::after_open(s, i);
+    super::image::after_open(s, i);
     Ok(opened(s, i, true))
 }
 
@@ -320,6 +334,12 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
     // A file that isn't a drawing (an imported SVG) gives the drawing no file name: QSAVE then
     // asks where to save instead of exporting over the original.
     let path = path.filter(|p| is_drawing_file(p));
+    // The SHX fonts its text styles name are looked for beside the drawing too.
+    if let Some(dir) = path.as_deref().and_then(|p| std::path::Path::new(p).parent()) {
+        // A bare file name is in the current folder.
+        let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
+        cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
+    }
     Ok(ReadFile { drawing, binary_dxf: cadcraft_dxf::is_binary(bytes), name: name.to_string(), path })
 }
 
@@ -363,6 +383,7 @@ fn run_open(s: &mut Session, p: &Value) -> Result<Value> {
                 crate::capped_read::read_capped(std::path::Path::new(path), MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{path}: {e}")))?;
             let i = open_bytes(s, &bytes, path, Some(path.to_string()))?;
             super::blocks::xref::after_open(s, i);
+            super::image::after_open(s, i);
             return Ok(opened(s, i, true));
         }
         #[cfg(target_arch = "wasm32")]
@@ -373,6 +394,7 @@ fn run_open(s: &mut Session, p: &Value) -> Result<Value> {
     let name = str_param(p, "name").unwrap_or("Drawing.dxf");
     let i = open_bytes(s, &bytes, name, None)?;
     super::blocks::xref::after_open(s, i);
+    super::image::after_open(s, i);
     Ok(opened(s, i, false))
 }
 

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

@@ -20,7 +20,7 @@ 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 cadcraft_doc::{Block, CellStyle, DimStyle, Drawing, Entity, EntityKind, EntityStore, Group, Handle, Layer, MAX_BLOCK_DEPTH, TableStyle};
 use serde_json::{Value, json};
 
 use super::super::super::{CommandSpec, bad};
@@ -197,6 +197,7 @@ fn snapshot(cur: &Drawing, c: &Comparison, folders: &Folders) -> Snapshot {
     d.skipped_records.clear();
     d.handseed = d.handseed.max(other.handseed);
 
+    use crate::cmd::merge::merge_named as merge;
     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);
@@ -235,22 +236,17 @@ fn snapshot(cur: &Drawing, c: &Comparison, folders: &Folders) -> Snapshot {
     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();
+    // The layers this drawing has, looked up once per object rather than scanned.
+    let mut layers: HashSet<String> = d.layers.iter().map(|l| l.name.to_ascii_uppercase()).collect();
     for (e, color) in objs {
-        d.ensure_layer(&e.common.layer);
+        if layers.insert(e.common.layer.to_ascii_uppercase()) {
+            d.layers.push(Layer::new(&e.common.layer));
+        }
         let h = d.new_handle();
         let mut copy = Entity { handle: h, ..(*e).clone() };
         detach(&mut copy.kind);

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

@@ -59,7 +59,8 @@ pub(super) fn run_new(s: &mut Session, p: &Value) -> Result<Option<Value>> {
         && hi.y > lo.y
     {
         let center = cadcraft_geom::Vec2::new((lo.x + hi.x) / 2.0, (lo.y + hi.y) / 2.0);
-        st.set_view_quiet(crate::View { center, height: (hi.y - lo.y).max(1e-6) });
+        let twist = st.view().twist;
+        st.set_view_quiet(crate::View { center, height: (hi.y - lo.y).max(1e-6), twist });
     }
     Ok(Some(json!({ "index": i, "title": title, "template": path })))
 }

crates/engine/src/cmd/image.rs

@@ -0,0 +1,353 @@
+//! Raster images (IMAGEATTACH, IMAGE). An IMAGE entity names its file; the pixels are decoded
+//! when the drawing opens or the image is attached and kept with the open drawing
+//! ([`Drawing::rasters`]), never in the file. An image whose file can't be found or read stays in
+//! the drawing as a crossed-out frame.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+
+use cadcraft_doc::{Drawing, EntityKind, Image, Raster};
+use cadcraft_geom::Vec2;
+use serde_json::{Value, json};
+
+use super::file::base64_decode;
+use super::{CommandSpec, bad, f64_or, point_param, str_param};
+use crate::{Result, Session};
+
+/// Most image files loaded per drawing.
+const MAX_IMAGE_FILES: usize = 1000;
+/// Largest image file read (bytes).
+#[cfg(not(target_arch = "wasm32"))]
+const MAX_IMAGE_BYTES: u64 = 256 << 20;
+/// Most decoded pixel bytes kept per drawing; images past it stay unloaded.
+const MAX_LOADED_BYTES: u64 = 2 << 30;
+/// Most image files decoded at the same time when a drawing opens.
+const MAX_LOADERS: usize = 4;
+/// Longest image path taken from a caller.
+const MAX_PATH: usize = 4096;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("imageattach", "Raster Image Reference...", run_imageattach).alias(&["iat"]).params(
+            "{path: PNG/JPEG/BMP/TIFF file (saved as given; a relative path is relative to this drawing's folder), data?: base64 file contents \
+             (instead of reading `path`), at?: [x,y] lower-left corner (default 0,0), scale?: number (default 1: the image is one drawing unit \
+             wide), width?: width in drawing units (instead of `scale`), rotation? (degrees), name? (default: the file name)} → {name, handle, \
+             path, pixels: [w, h], size: [w, h]}",
+        ),
+        CommandSpec::new("image", "Raster Images", run_image)
+            .alias(&["im"])
+            .params("{} → {images: [{name, path, foundAt, status: Loaded|Not Found|Not loaded, references, pixels?: [w, h]}]}")
+            .noundo(),
+    ]
+}
+
+/// Whether `ext` (lower case, no dot) is an image file type IMAGEATTACH reads.
+pub(crate) fn is_image_ext(ext: &str) -> bool {
+    matches!(ext, "png" | "jpg" | "jpeg" | "bmp" | "tif" | "tiff")
+}
+
+/// Every IMAGE entity of `d`: in model space, on the layouts and in the blocks.
+fn images(d: &Drawing) -> impl Iterator<Item = &Image> {
+    let model = std::iter::once(&d.model);
+    let layouts = d.layouts.iter().map(|l| &l.entities);
+    let blocks = d.blocks.values().map(|b| &b.entities);
+    model.chain(layouts).chain(blocks).flat_map(|store| store.iter()).filter_map(|e| match &e.kind {
+        EntityKind::Image(i) => Some(i),
+        _ => None,
+    })
+}
+
+/// The image files `d` names, each once, in the order they are first used.
+fn paths(d: &Drawing) -> Vec<String> {
+    let mut seen = BTreeSet::new();
+    let mut paths = Vec::new();
+    for i in images(d) {
+        if !i.path.trim().is_empty() && seen.insert(i.path.as_str()) {
+            paths.push(i.path.clone());
+        }
+    }
+    paths
+}
+
+/// The contents of the image file saved as `path` in a drawing at `host`.
+fn read_file(path: &str, host: Option<&str>) -> std::result::Result<Vec<u8>, String> {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let file = super::blocks::xref::find_file(path, host).ok_or("file not found")?;
+        let len = std::fs::metadata(&file).map_err(|e| e.to_string())?.len();
+        if len > MAX_IMAGE_BYTES {
+            return Err(format!("the file is larger than {} MB", MAX_IMAGE_BYTES >> 20));
+        }
+        // Read no more than the limit: the file can grow or change after the check above.
+        let limit = usize::try_from(MAX_IMAGE_BYTES).unwrap_or(usize::MAX);
+        crate::capped_read::read_capped(&file, limit).map_err(|e| {
+            if e.kind() == std::io::ErrorKind::InvalidData { format!("the file is larger than {} MB", MAX_IMAGE_BYTES >> 20) } else { e.to_string() }
+        })
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        let _ = (path, host);
+        Err("files are not available on the web".into())
+    }
+}
+
+/// Decode an image file. A decoder that panics on a damaged file fails this image only: the
+/// drawing it belongs to must still open.
+fn decode(bytes: &[u8]) -> std::result::Result<Raster, String> {
+    let hook = super::file::image_decoder().ok_or("image files can't be read in this build")?;
+    match std::panic::catch_unwind(|| hook(bytes)) {
+        Ok(r) => r,
+        Err(_) => Err("the file is damaged and can't be read".into()),
+    }
+}
+
+fn bytes_of(r: &Raster) -> u64 {
+    u64::try_from(r.rgba().len()).unwrap_or(u64::MAX)
+}
+
+/// Load the images of drawing `i`, just opened. Those that can't be loaded are reported and
+/// stay crossed-out frames; opening never fails over an image.
+pub(crate) fn after_open(s: &mut Session, i: usize) {
+    let Some(st) = s.docs.get_mut(i) else { return };
+    let paths = paths(&st.doc);
+    if paths.is_empty() {
+        return;
+    }
+    let mut rasters = st.doc.rasters.clone();
+    let notes = load_missing(&paths, st.path.as_deref(), &mut rasters);
+    if !rasters.is_empty() {
+        // Loading pixels is not a change to the drawing. A drawing counts as unchanged while
+        // it is the very one that was saved, so the saved one follows.
+        let unchanged = Arc::ptr_eq(&st.doc, &st.saved);
+        Arc::make_mut(&mut st.doc).rasters = rasters;
+        if unchanged {
+            st.saved = st.doc.clone();
+        }
+    }
+    for n in notes {
+        s.echo(n);
+    }
+}
+
+/// Read and decode into `rasters` the files of `paths` that are not in it yet, for a drawing at
+/// `host`. Returns one message per file that could not be loaded.
+fn load_missing(paths: &[String], host: Option<&str>, rasters: &mut cadcraft_doc::Rasters) -> Vec<String> {
+    let mut notes = Vec::new();
+    let mut missing: Vec<&str> = paths.iter().map(String::as_str).filter(|p| rasters.get(p).is_none()).collect();
+    if missing.len() > MAX_IMAGE_FILES {
+        missing.truncate(MAX_IMAGE_FILES);
+        notes.push(format!("Images: only the first {MAX_IMAGE_FILES} image files are loaded"));
+    }
+    let decoded = decode_files(&missing, host);
+    // Kept in the order the drawing uses them, up to the memory limit.
+    let mut kept_bytes = 0u64;
+    for (path, result) in missing.iter().zip(decoded) {
+        match result {
+            Ok(r) => {
+                kept_bytes = kept_bytes.saturating_add(bytes_of(&r));
+                if kept_bytes > MAX_LOADED_BYTES {
+                    notes.push(over_limit(path));
+                    break;
+                }
+                rasters.insert(path, Arc::new(r));
+            }
+            Err(e) => notes.push(format!("Image {path}: {e}")),
+        }
+    }
+    notes
+}
+
+fn over_limit(path: &str) -> String {
+    format!("Image {path}: not loaded (more than {} MB of images)", MAX_LOADED_BYTES >> 20)
+}
+
+/// Read and decode the image files `paths` of a drawing at `host`, a few at a time (decoding is
+/// what opening a drawing with large images waits for). The results are in the order of `paths`.
+fn decode_files(paths: &[&str], host: Option<&str>) -> Vec<std::result::Result<Raster, String>> {
+    // Decoded bytes so far, shared by the loaders: past the limit no further file is started.
+    let decoded_bytes = AtomicU64::new(0);
+    let load = |path: &str| -> std::result::Result<Raster, String> {
+        if decoded_bytes.load(Ordering::Relaxed) > MAX_LOADED_BYTES {
+            return Err(format!("not loaded (more than {} MB of images)", MAX_LOADED_BYTES >> 20));
+        }
+        let r = read_file(path, host).and_then(|bytes| decode(&bytes))?;
+        decoded_bytes.fetch_add(bytes_of(&r), Ordering::Relaxed);
+        Ok(r)
+    };
+    let mut results: Vec<Option<std::result::Result<Raster, String>>> = paths.iter().map(|_| None).collect();
+    let loaders = loader_count(paths.len());
+    if loaders > 1 {
+        // Each loader takes the next file nobody has started.
+        let next = AtomicUsize::new(0);
+        let work = || {
+            let mut done = Vec::new();
+            loop {
+                let index = next.fetch_add(1, Ordering::Relaxed);
+                let Some(path) = paths.get(index) else { break };
+                done.push((index, load(path)));
+            }
+            done
+        };
+        let finished: Vec<_> = std::thread::scope(|scope| {
+            let started: Vec<_> = (0..loaders).filter_map(|_| std::thread::Builder::new().spawn_scoped(scope, work).ok()).collect();
+            started.into_iter().filter_map(|loader| loader.join().ok()).flatten().collect()
+        });
+        for (index, result) in finished {
+            if let Some(slot) = results.get_mut(index) {
+                *slot = Some(result);
+            }
+        }
+    }
+    // One loader, or files a loader that could not start or finish left behind.
+    results.into_iter().zip(paths).map(|(result, path)| result.unwrap_or_else(|| load(path))).collect()
+}
+
+/// How many files are decoded at once: one per processor, at most [`MAX_LOADERS`] (each large
+/// image needs several hundred megabytes while it is decoded) and no more than there are files.
+fn loader_count(files: usize) -> usize {
+    #[cfg(not(target_arch = "wasm32"))]
+    let processors = std::thread::available_parallelism().map(std::num::NonZero::get).unwrap_or(1);
+    #[cfg(target_arch = "wasm32")]
+    let processors = 1;
+    processors.min(MAX_LOADERS).min(files)
+}
+
+/// The file name without folders and extension (either separator).
+fn stem(path: &str) -> String {
+    let file = path.rsplit(['/', '\\']).next().unwrap_or(path);
+    match file.rsplit_once('.') {
+        Some((stem, _)) if !stem.is_empty() => stem.to_string(),
+        _ => file.to_string(),
+    }
+}
+
+/// The definition name for a new image of `path`: the name that file already has in `d`, else
+/// `wanted`, numbered (`wanted_2`, `wanted_3`, …) when another file has taken it.
+fn def_name(d: &Drawing, path: &str, wanted: &str) -> String {
+    if let Some(i) = images(d).find(|i| i.path == path && !i.name.is_empty()) {
+        return i.name.clone();
+    }
+    // The names other files have, compared without regard to case.
+    let taken: BTreeSet<String> = images(d).filter(|i| i.path != path).map(|i| i.name.to_ascii_lowercase()).collect();
+    let free = |name: &str| !taken.contains(&name.to_ascii_lowercase());
+    if free(wanted) {
+        return wanted.to_string();
+    }
+    // One of these is free: there are more candidates than names taken.
+    let candidates = 2..taken.len().saturating_add(3);
+    candidates.map(|n| format!("{wanted}_{n}")).find(|name| free(name)).unwrap_or_else(|| wanted.to_string())
+}
+
+const ID: &str = "imageattach";
+
+pub(crate) fn run_imageattach(s: &mut Session, p: &Value) -> Result<Value> {
+    let path = str_param(p, "path").map(str::trim).filter(|x| !x.is_empty()).ok_or_else(|| bad(ID, "`path` is required"))?.to_string();
+    if path.len() > MAX_PATH {
+        return Err(bad(ID, "`path` is too long"));
+    }
+    let place = placement(p)?;
+    let raster = pixels(s, p, &path)?;
+    let (w, h) = (f64::from(raster.width()), f64::from(raster.height()));
+    // One pixel in drawing units, along the image's bottom edge (`u`) and its left edge (`v`).
+    let pixel = place.width / w;
+    let u = Vec2::from_angle(place.rotation) * pixel;
+    let v = u.perp();
+    if !(pixel.is_normal() && (pixel * h).is_normal() && u.x.is_finite() && u.y.is_finite()) {
+        return Err(bad(ID, "the image would be too small or too large to draw"));
+    }
+    let wanted = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).map(str::to_string).unwrap_or_else(|| stem(&path));
+    let name = def_name(s.doc()?, &path, &wanted);
+    let image = Image {
+        insert: place.at.to3(0.0),
+        u: u.to3(0.0),
+        v: v.to3(0.0),
+        size: Vec2::new(w, h),
+        path: path.clone(),
+        name: name.clone(),
+        ..Image::default()
+    };
+    s.doc_mut()?.rasters.insert(&path, raster);
+    let handle = s.add_entity(EntityKind::Image(image))?;
+    Ok(json!({ "name": name, "handle": handle.hex(), "path": path, "pixels": [w, h], "size": [place.width, pixel * h] }))
+}
+
+/// Where and how large IMAGEATTACH puts the image.
+struct Placement {
+    /// The lower-left corner.
+    at: Vec2,
+    /// Radians, counter-clockwise.
+    rotation: f64,
+    /// The image's width in drawing units.
+    width: f64,
+}
+
+/// `at`, `rotation` and the width (`width`, else `scale`: an image is one unit wide at scale 1).
+fn placement(p: &Value) -> Result<Placement> {
+    let at = point_param(p, "at").unwrap_or(Vec2::ZERO);
+    if !(at.x.is_finite() && at.y.is_finite()) {
+        return Err(bad(ID, "`at` must be a point"));
+    }
+    let width = match p.get("width") {
+        Some(v) => v.as_f64().filter(|w| w.is_finite()).ok_or_else(|| bad(ID, "`width` must be a number"))?,
+        None => f64_or(p, "scale", 1.0),
+    };
+    if !(width.is_finite() && width > 0.0) {
+        return Err(bad(ID, "`scale` and `width` must be greater than zero"));
+    }
+    Ok(Placement { at, rotation: f64_or(p, "rotation", 0.0).to_radians(), width })
+}
+
+/// The pixels of the image at `path`: decoded from `data` when the caller hands the file over,
+/// else the ones already loaded for that path, else read from the file.
+fn pixels(s: &Session, p: &Value, path: &str) -> Result<Arc<Raster>> {
+    let bytes = match p.get("data") {
+        Some(data) => {
+            let text = data.as_str().ok_or_else(|| bad(ID, "`data` must be base64 text"))?;
+            base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?
+        }
+        None => {
+            if let Some(loaded) = s.doc()?.rasters.get(path) {
+                return Ok(loaded.clone());
+            }
+            let host = s.state()?.path.clone();
+            read_file(path, host.as_deref()).map_err(|e| bad(ID, format!("{path}: {e}")))?
+        }
+    };
+    Ok(Arc::new(decode(&bytes).map_err(|e| bad(ID, format!("{path}: {e}")))?))
+}
+
+fn run_image(s: &mut Session, _p: &Value) -> Result<Value> {
+    let host = s.state()?.path.clone();
+    let d = s.doc()?;
+    // Per file: its definition name and how many images show it.
+    let mut uses: BTreeMap<&str, (&str, usize)> = BTreeMap::new();
+    for i in images(d) {
+        uses.entry(i.path.as_str()).or_insert((i.name.as_str(), 0)).1 += 1;
+    }
+    let rows: Vec<Value> = paths(d)
+        .iter()
+        .map(|path| {
+            let (name, references) = uses.get(path.as_str()).copied().unwrap_or_default();
+            let mut row = describe(d, path, host.as_deref());
+            row["name"] = json!(name);
+            row["references"] = json!(references);
+            row
+        })
+        .collect();
+    Ok(json!({ "images": rows }))
+}
+
+/// The state of image file `path` of drawing `d` (saved at `host`): where it is and whether its
+/// pixels are loaded.
+fn describe(d: &Drawing, path: &str, host: Option<&str>) -> Value {
+    let loaded = d.rasters.get(path);
+    let found_at = super::blocks::xref::find_file(path, host).map(|f| f.to_string_lossy().into_owned());
+    let status = match (loaded, &found_at) {
+        (Some(_), _) => "Loaded",
+        (None, None) => "Not Found",
+        // The file is there but could not be read as an image.
+        (None, Some(_)) => "Not loaded",
+    };
+    json!({ "path": path, "foundAt": found_at, "status": status, "pixels": loaded.map(|r| json!([r.width(), r.height()])) })
+}

crates/engine/src/cmd/layer.rs

@@ -408,12 +408,24 @@ fn run_state_restore(s: &mut Session, p: &Value) -> Result<Value> {
     let name = str_param(p, "name").ok_or_else(|| bad("layerstate.restore", "`name` is required"))?;
     let d = s.doc_mut()?;
     let st = d.layer_states.iter().find(|st| st.name == name).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
-    for saved in st.layers {
-        if let Some(l) = d.layer_mut(&saved.name) {
-            *l = saved;
+    restore_layers(d, st.layers);
+    ok()
+}
+
+/// Put the saved layers back over the drawing's layers of the same name (without regard to case);
+/// saved layers the drawing no longer has are skipped. Both lists can come from a file, so the
+/// drawing's layers are looked up in an index rather than scanned per saved layer.
+pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
+    let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::with_capacity(d.layers.len());
+    for (i, l) in d.layers.iter().enumerate() {
+        // The first of names that differ only in case, as `Drawing::layer_mut` finds it.
+        index.entry(l.name.to_ascii_lowercase()).or_insert(i);
+    }
+    for layer in saved {
+        if let Some(l) = index.get(&layer.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) {
+            *l = layer;
         }
     }
-    ok()
 }
 
 fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
@@ -461,6 +473,22 @@ mod tests {
 
     use crate::Session;
 
+    /// Restoring many saved layers, most of them missing, takes one pass and matches without case.
+    #[test]
+    fn restore_layers_matches_by_name_in_linear_time() {
+        let mut d = cadcraft_doc::Drawing::new_imperial();
+        d.layers = (0..20_000).map(|i| cadcraft_doc::Layer::new(&format!("L{i}"))).collect();
+        let mut saved: Vec<cadcraft_doc::Layer> = (0..20_000).map(|i| cadcraft_doc::Layer::new(&format!("missing{i}"))).collect();
+        let mut back = cadcraft_doc::Layer::new("l7");
+        back.frozen = true;
+        saved.push(back);
+        let started = std::time::Instant::now();
+        super::restore_layers(&mut d, saved);
+        assert!(started.elapsed() < std::time::Duration::from_secs(2));
+        assert!(d.layer("L7").is_some_and(|l| l.frozen));
+        assert_eq!(d.layers.len(), 20_000);
+    }
+
     #[test]
     fn layer_states_save_list_restore_delete() {
         let mut s = Session::new();

crates/engine/src/cmd/layout.rs

@@ -524,6 +524,7 @@ fn viewport_json(h: Handle, v: &Viewport) -> Value {
         "height": v.height,
         "viewCenter": [v.view_center.x, v.view_center.y],
         "viewHeight": v.view_height,
+        "twist": v.view_twist().to_degrees(),
         "scale": if v.view_height > 0.0 { v.height / v.view_height } else { 0.0 },
         "locked": v.locked,
         "on": v.on,

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

@@ -283,7 +283,7 @@ fn mspace_edits_model_through_viewport() {
     s.cmdline("circle 10,10 3").unwrap();
     assert_eq!(s.doc().unwrap().model.len(), before + 1);
     // Zooming changes the viewport's model view, not the sheet.
-    s.state_mut().unwrap().set_view(crate::View { center: v.center, height: v.height / 2.0 });
+    s.state_mut().unwrap().set_view(crate::View { center: v.center, height: v.height / 2.0, twist: v.twist });
     let vp2 = viewports(&s, "L").into_iter().find(|(x, _)| *x == h).unwrap().1;
     assert!((vp2.view_height - vp.view_height / 2.0).abs() < 1e-9);
     assert_eq!(s.state().unwrap().paper_view(), pv);

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

@@ -329,7 +329,7 @@ pub(super) fn run_vpclip(s: &mut Session, p: &Value) -> Result<Value> {
     let k = cur.view_height / cur.height.max(1e-12);
     let mut v = cur;
     let c = b.center();
-    let view_center = v.view_center + (c - v.center.xy()) * k;
+    let view_center = v.paper_to_model(c);
     let view_height = b.height() * k;
     if view_center.is_finite() && view_height.is_finite() && view_height > 0.0 {
         v.view_center = view_center;

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

@@ -109,7 +109,7 @@ fn parse_color(t: &str) -> Result<Color> {
 fn viewport_at(s: &Session, p: Vec2) -> Option<Handle> {
     let st = s.state().ok()?;
     let at = match st.active_viewport() {
-        Some((_, vp)) => vp.center.xy() + (p - vp.view_center) * (vp.height / vp.view_height),
+        Some((_, vp)) => vp.model_to_paper(p),
         None => p,
     };
     super::viewports::viewport_at(s, at)

crates/engine/src/cmd/merge.rs

@@ -0,0 +1,99 @@
+//! Bringing another drawing's symbol tables and blocks into this one (INSERT of a file, IMPORT,
+//! paste, COMPARE export).
+//!
+//! Both drawings are hostile input, so the work is linear in their sizes: names are looked up in a
+//! set built once per table, and a generated block name continues from the last one allocated for
+//! its prefix instead of probing every taken number again (CWE-407).
+
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+
+use cadcraft_doc::Drawing;
+
+/// Add the entries of `theirs` whose names `ours` lacks (compared without letter case; a name that
+/// exists keeps `ours`' definition). Returns how many were added.
+pub(crate) fn merge_named<T: Clone>(ours: &mut Vec<T>, theirs: &[T], name: fn(&T) -> &str) -> usize {
+    let mut have: HashSet<String> = ours.iter().map(|o| name(o).to_ascii_uppercase()).collect();
+    let mut added = 0;
+    for t in theirs {
+        if have.insert(name(t).to_ascii_uppercase()) {
+            ours.push(t.clone());
+            added += 1;
+        }
+    }
+    added
+}
+
+/// Which blocks of `src` to copy into `d`, and under which name: a new name keeps its own, a
+/// generated (anonymous `*…`) block whose name is taken gets a fresh generated name, and a named
+/// block `d` already has (or `defining`, the block being defined from `src`) keeps `d`'s
+/// definition (not copied).
+pub(crate) fn block_renames(d: &Drawing, src: &Drawing, defining: Option<&str>) -> BTreeMap<String, String> {
+    let mut out = BTreeMap::new();
+    let mut taken: BTreeSet<String> = d.blocks.keys().map(|k| k.to_ascii_uppercase()).collect();
+    taken.extend(defining.map(str::to_ascii_uppercase));
+    // The next number to try per generated prefix: numbers below it are taken.
+    let mut next: HashMap<String, usize> = HashMap::new();
+    for (name, b) in &src.blocks {
+        let upper = name.to_ascii_uppercase();
+        if upper.starts_with("*MODEL_SPACE") || upper.starts_with("*PAPER_SPACE") {
+            continue;
+        }
+        let to = if !taken.contains(&upper) {
+            name.clone()
+        } else if b.anonymous || name.starts_with('*') {
+            let prefix: String = name.chars().take_while(|c| !c.is_ascii_digit()).collect();
+            let cursor = next.entry(prefix.to_ascii_uppercase()).or_insert(1);
+            match (*cursor..=1_000_000).map(|i| (i, format!("{prefix}{i}"))).find(|(_, n)| !taken.contains(&n.to_ascii_uppercase())) {
+                Some((i, n)) => {
+                    *cursor = i + 1;
+                    n
+                }
+                None => continue,
+            }
+        } else {
+            continue;
+        };
+        taken.insert(to.to_ascii_uppercase());
+        out.insert(name.clone(), to);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use cadcraft_doc::{Block, Layer};
+
+    use super::*;
+
+    #[test]
+    fn merge_keeps_ours_and_adds_the_rest_without_regard_to_case() {
+        let mut ours = vec![Layer::new("Walls")];
+        let theirs = vec![Layer::new("WALLS"), Layer::new("Doors"), Layer::new("doors")];
+        assert_eq!(merge_named(&mut ours, &theirs, |l| &l.name), 1);
+        assert_eq!(ours.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["Walls", "Doors"]);
+    }
+
+    /// Many colliding anonymous blocks get consecutive names in one pass, not a rescan each.
+    #[test]
+    fn anonymous_collisions_take_consecutive_numbers() {
+        let mut d = Drawing::new_imperial();
+        let mut src = Drawing::new_imperial();
+        for i in 1..=5000 {
+            let mut b = Block::new(&format!("*U{i}"));
+            b.anonymous = true;
+            d.blocks.insert(b.name.clone(), Arc::new(b.clone()));
+            src.blocks.insert(b.name.clone(), Arc::new(b));
+        }
+        let started = std::time::Instant::now();
+        let renames = block_renames(&d, &src, None);
+        assert!(started.elapsed() < std::time::Duration::from_secs(2));
+        assert_eq!(renames.len(), 5000);
+        assert_eq!(renames.get("*U1").map(String::as_str), Some("*U5001"));
+        let distinct: HashSet<&String> = renames.values().collect();
+        assert_eq!(distinct.len(), 5000);
+        // Every new name is the next free number: nothing below 5001 is free, nothing above 10000 is needed.
+        assert!(renames.values().all(|n| n.strip_prefix("*U").and_then(|i| i.parse::<u32>().ok()).is_some_and(|i| (5001..=10000).contains(&i))));
+    }
+}

crates/engine/src/cmd/mleader_content.rs

@@ -54,6 +54,7 @@ pub(super) fn apply(s: &Session, k: EntityKind, c: &Content) -> Result<EntityKin
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         };
         if *center {
             // Move the block so the centre of its extents lands on the anchor.

crates/engine/src/cmd/modify/explode.rs

@@ -55,6 +55,10 @@ fn explode_block_ref(d: &cadcraft_doc::Drawing, e: &Entity, ins: &cadcraft_doc::
     if let Some(items) = crate::cmd::array::explode_array(d, e) {
         return Some(items);
     }
+    // A MINSERT grid stays whole, as in AutoCAD 2024 (see `explode`).
+    if minserted(ins) {
+        return None;
+    }
     let blk = d.block(&ins.block)?;
     let m = ins.transform(blk.base.xy());
     let stretched = m.similarity_scale().is_none();
@@ -223,9 +227,24 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
 }
 
 pub(super) fn explode(s: &mut Session, hs: &[Handle]) -> Result<Vec<Handle>> {
+    // AutoCAD 2024 refuses a MINSERT grid: "The object is minserted." (Locked ones are left
+    // without a word, as `explode_with` leaves them.)
+    let d = s.doc()?;
+    let grids = hs
+        .iter()
+        .filter(|h| !crate::cmd::curves::is_locked(s, **h) && d.entity(**h).is_some_and(|e| matches!(&e.kind, EntityKind::Insert(i) if minserted(i))))
+        .count();
+    for _ in 0..grids {
+        s.echo("The object is minserted.");
+    }
     explode_with(s, hs, explode_kind)
 }
 
+/// A block reference with more than one row or column (MINSERT).
+fn minserted(i: &cadcraft_doc::Insert) -> bool {
+    i.rows > 1 || i.cols > 1
+}
+
 /// Replace each of `hs` (off locked layers) by the pieces `pieces` gives for it; objects it gives
 /// none for are left alone. EXPLODE, and BURST with its own pieces for block references.
 pub(crate) fn explode_with(

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

@@ -182,8 +182,7 @@ fn chspace(s: &mut Session, hs: &[Handle], to: Option<&str>, vp: Option<Handle>)
     };
     let m = match viewport_of(s, &layout, vp) {
         Some(v) => {
-            let k = v.view_height / v.height;
-            let to_paper = Mat3::translate(v.center.xy()).then_before(Mat3::scale(1.0 / k, 1.0 / k)).then_before(Mat3::translate(-v.view_center));
+            let to_paper = v.model_to_paper_matrix();
             if target == Space::Model { to_paper.inverse().unwrap_or(Mat3::IDENTITY) } else { to_paper }
         }
         None => Mat3::IDENTITY,

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

@@ -411,6 +411,7 @@ fn chspace_json_and_command_line() {
         layer_colors: Vec::new(),
         clip: None,
         on: true,
+        twist: 0.0,
     };
     s.doc_mut().unwrap().add(&Space::Paper("Layout1".into()), Default::default(), EntityKind::Viewport(vp)).unwrap();
     let r = s.execute("chspace", &json!({"handles": [l]})).unwrap();

crates/engine/src/cmd/utility/calc.rs

@@ -1,6 +1,8 @@
 //! The CAL / QuickCalc evaluator: numbers and points (`[x,y]`, `[d<a]`), arithmetic and vector
 //! arithmetic, numeric and geometric functions; unit conversion; values picked from the drawing.
 
+use std::collections::HashMap;
+
 use cadcraft_geom::Vec2;
 use serde_json::{Map, Value, json};
 
@@ -67,6 +69,9 @@ struct Parser<'a> {
     s: &'a [u8],
     i: usize,
     vars: &'a Map<String, Value>,
+    /// `vars` by ASCII-lower-cased name (the first of names that differ only in case), so a
+    /// case-insensitive lookup is not a scan of the map per reference.
+    folded: HashMap<String, &'a Value>,
     depth: usize,
     unary_depth: usize,
 }
@@ -230,7 +235,7 @@ impl Parser<'_> {
                 match name.as_str() {
                     "pi" => Ok(Val::Num(std::f64::consts::PI)),
                     "e" => Ok(Val::Num(std::f64::consts::E)),
-                    _ => var(self.vars, &name).ok_or_else(|| format!("unknown name `{name}`")),
+                    _ => var(self.vars, &self.folded, &name).ok_or_else(|| format!("unknown name `{name}`")),
                 }
             }
             _ => Err("expected a number".into()),
@@ -239,8 +244,8 @@ impl Parser<'_> {
 }
 
 /// A variable: a number, or a point as `[x, y]`. Names are case-insensitive.
-fn var(vars: &Map<String, Value>, name: &str) -> Option<Val> {
-    let v = vars.get(name).or_else(|| vars.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v))?;
+fn var(vars: &Map<String, Value>, folded: &HashMap<String, &Value>, name: &str) -> Option<Val> {
+    let v = vars.get(name).or_else(|| folded.get(&name.to_ascii_lowercase()).copied())?;
     if let Some(n) = v.as_f64() {
         return Some(Val::Num(n));
     }
@@ -411,7 +416,11 @@ pub fn eval_val(expr: &str, vars: &Map<String, Value>) -> Result<Val, String> {
     if expr.len() > MAX_LEN {
         return Err("expression too long".into());
     }
-    let mut p = Parser { s: expr.as_bytes(), i: 0, vars, depth: 0, unary_depth: 0 };
+    let mut folded = HashMap::with_capacity(vars.len());
+    for (k, v) in vars {
+        folded.entry(k.to_ascii_lowercase()).or_insert(v);
+    }
+    let mut p = Parser { s: expr.as_bytes(), i: 0, vars, folded, depth: 0, unary_depth: 0 };
     let v = p.expr()?;
     if p.peek().is_some() {
         return Err(format!("unexpected `{}`", expr.get(p.i..).unwrap_or("")));
@@ -587,6 +596,21 @@ mod tests {
         eval_val(s, &Map::new())
     }
 
+    /// Variables are found without regard to case; an exact match wins over a case variant.
+    /// (Names are read lower-cased, so `X` finds `x` too.)
+    #[test]
+    fn variables_ignore_case_and_prefer_exact_names() {
+        let mut vars = Map::new();
+        for i in 0..10_000 {
+            vars.insert(format!("v{i}"), json!(i));
+        }
+        vars.insert("X".into(), json!(1));
+        vars.insert("x".into(), json!(2));
+        assert!(matches!(eval_val("V9999 + 1", &vars), Ok(Val::Num(n)) if n == 10_000.0));
+        assert!(matches!(eval_val("x", &vars), Ok(Val::Num(n)) if n == 2.0));
+        assert!(eval_val("nope", &vars).is_err());
+    }
+
     #[test]
     fn points_and_vectors() {
         assert_eq!(ev("[1,2]+[3,4]*2"), Ok(Val::Pt(Vec2::new(7.0, 10.0))));

crates/engine/src/cmd/view.rs

@@ -1,5 +1,5 @@
-//! View menu: ZOOM (with Realtime and Dynamic), PAN, REGEN, REDRAW, named views (VIEW), layout
-//! switching.
+//! View menu: ZOOM (with Realtime and Dynamic), PAN, REGEN, REDRAW, named views (VIEW), the view
+//! twist (DVIEW TWist), layout switching.
 
 use cadcraft_doc::{Space, entity_bounds};
 use cadcraft_geom::{Bounds2, Vec2};
@@ -10,6 +10,7 @@ use super::{CommandSpec, bad, bool_or, f64_or, f64_req, ok, point_param, point_r
 
 use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step, View};
 
+mod dview;
 mod named_views;
 mod vports;
 
@@ -95,10 +96,13 @@ pub fn specs() -> Vec<CommandSpec> {
         .alias(&["r"])
         .noundo()
         .transparent(),
-        CommandSpec::new("view.set", "Set View", run_view_set).params("{center: [x,y], height}").noundo(),
+        dview::spec(),
+        CommandSpec::new("view.set", "Set View", run_view_set)
+            .params("{center: [x,y], height, twist?: degrees (default: keep the current twist; in a layout viewport it is the viewport's twist, an undoable edit; not in Paper space)}")
+            .noundo(),
         CommandSpec::new("view.get", "Get View", |s, _| {
             let v = s.state()?.view();
-            Ok(json!({"center": [v.center.x, v.center.y], "height": v.height, "viewportPx": [s.viewport_px.0, s.viewport_px.1]}))
+            Ok(json!({"center": [v.center.x, v.center.y], "height": v.height, "twist": v.twist.to_degrees(), "viewportPx": [s.viewport_px.0, s.viewport_px.1]}))
         })
         .noundo(),
         CommandSpec::new("layout.set", "Switch Layout", run_layout_set).params("{name: \"Model\" | layout name}").noundo(),
@@ -120,8 +124,11 @@ fn fit(s: &mut Session, b: Bounds2) -> Result<()> {
     let (w, h) = s.viewport_px;
     let st = s.state_mut()?;
     let aspect = st.zoom_aspect(w / h.max(1.0));
-    let height = b.height().max(b.width() / aspect.max(1e-6)).max(1e-9);
-    st.set_zoom_frame(View { center: b.center(), height });
+    // A twisted view fits the box the bounds make on screen.
+    let twist = st.zoom_frame().twist;
+    let (center, bw, bh) = View::twisted_box(b, twist);
+    let height = bh.max(bw / aspect.max(1e-6)).max(1e-9);
+    st.set_zoom_frame(View { center, height, twist });
     Ok(())
 }
 
@@ -150,18 +157,18 @@ pub(crate) fn zoom(s: &mut Session, p: &Value) -> Result<Value> {
             let f = if mode == "in" { 2.0 } else { 0.5 };
             let st = s.state_mut()?;
             let v = st.zoom_frame();
-            st.set_zoom_frame(View { center: v.center, height: v.height / f });
+            st.set_zoom_frame(View { height: v.height / f, ..v });
         }
         "center" | "c" | "dynamic" | "d" => {
             let c = point_req("zoom", p, "center")?;
-            let cur = s.state()?.zoom_frame().height;
-            let h = if p.get("factor").is_some() { factor_height(s, p, cur)? } else { f64_or(p, "height", cur) };
-            s.state_mut()?.set_zoom_frame(View { center: c, height: h.max(1e-9) });
+            let cur = s.state()?.zoom_frame();
+            let h = if p.get("factor").is_some() { factor_height(s, p, cur.height)? } else { f64_or(p, "height", cur.height) };
+            s.state_mut()?.set_zoom_frame(View { center: c, height: h.max(1e-9), ..cur });
         }
         "scale" | "s" => {
             let v = s.state()?.zoom_frame();
             let height = factor_height(s, p, v.height)?;
-            s.state_mut()?.set_zoom_frame(View { center: v.center, height });
+            s.state_mut()?.set_zoom_frame(View { height, ..v });
         }
         "realtime" => {
             let v = s.state()?.zoom_frame();
@@ -169,7 +176,7 @@ pub(crate) fn zoom(s: &mut Session, p: &Value) -> Result<Value> {
             if f <= 0.0 {
                 return Err(bad("zoom", "factor must be positive"));
             }
-            s.state_mut()?.set_zoom_frame(View { center: v.center, height: (v.height / f).clamp(1e-9, 1e12) });
+            s.state_mut()?.set_zoom_frame(View { height: (v.height / f).clamp(1e-9, 1e12), ..v });
         }
         "object" | "o" => {
             let hs = targets(s, p)?;
@@ -242,7 +249,8 @@ fn pan_frac(s: &mut Session, f: Vec2) -> Result<Value> {
     let st = s.state_mut()?;
     let v = st.view();
     let ww = v.height * w / h.max(1.0);
-    st.set_view(View { center: v.center + Vec2::new(f.x * ww, f.y * v.height), height: v.height });
+    // Screen directions: in a twisted view the drawing is turned by the twist.
+    st.set_view(View { center: v.center + Vec2::new(f.x * ww, f.y * v.height).rotate(-v.twist), ..v });
     ok()
 }
 
@@ -258,7 +266,7 @@ fn run_pan(s: &mut Session, p: &Value) -> Result<Value> {
         let b = point_req("pan", p, "to")?;
         v.center - (b - a)
     };
-    st.set_view(View { center: c, height: v.height });
+    st.set_view(View { center: c, ..v });
     ok()
 }
 
@@ -268,9 +276,33 @@ fn run_view_set(s: &mut Session, p: &Value) -> Result<Value> {
     if h <= 0.0 {
         return Err(bad("view.set", "height must be positive"));
     }
-    if !s.state_mut()?.set_view(View { center: c, height: h }) {
+    let twist = match p.get("twist") {
+        Some(t) => t.as_f64().filter(|t| t.is_finite()).ok_or_else(|| bad("view.set", "twist must be a number of degrees"))?.to_radians(),
+        None => s.state()?.view().twist,
+    };
+    // As DVIEW TWist: the Model tab's view or the active layout viewport turns; a layout sheet
+    // (paper space) is never twisted.
+    let target = match dview::target(s) {
+        Ok(t) => Some(t),
+        Err(_) if twist == 0.0 => None,
+        Err(e) => return Err(e),
+    };
+    let before = (s.state()?.doc.clone(), s.state()?.selection.clone());
+    let twist = match target {
+        Some(t @ dview::Target::Viewport(_)) => {
+            dview::set_twist(s, t, twist)?;
+            s.state()?.view().twist
+        }
+        Some(dview::Target::Model) => cadcraft_geom::norm_angle(twist),
+        None => 0.0,
+    };
+    if !s.state_mut()?.set_view(View { center: c, height: h, twist }) {
+        s.state_mut()?.doc = before.0;
         return Err(bad("view.set", "the view is too large to show. Nothing was changed"));
     }
+    if let Some(dview::Target::Viewport(h)) = target {
+        dview::record_viewport_edit(s, before, h)?;
+    }
     ok()
 }
 
@@ -294,7 +326,7 @@ fn run_layout_set(s: &mut Session, p: &Value) -> Result<Value> {
         let page = st.doc.layout(n).map(|l| l.page.clone()).unwrap_or_default();
         let (w, h) = if page.landscape { (page.height_mm, page.width_mm) } else { (page.width_mm, page.height_mm) };
         let unit = if st.doc.header.i64("MEASUREMENT", 0) == 1 { 1.0 } else { 1.0 / 25.4 };
-        st.set_view_quiet(View { center: Vec2::new(w * unit / 2.0, h * unit / 2.0), height: h * unit * 1.15 });
+        st.set_view_quiet(View { center: Vec2::new(w * unit / 2.0, h * unit / 2.0), height: h * unit * 1.15, twist: 0.0 });
     }
     s.touch();
     ok()
@@ -441,7 +473,7 @@ impl Interactive for ZoomM {
                 if st.view_history.last() == Some(&b.screen) {
                     st.view_history.pop();
                 }
-                st.set_zoom_frame(View { center: b.center, height: b.height });
+                st.set_zoom_frame(View { center: b.center, height: b.height, twist: b.frame.twist });
                 return Ok(Step::Done);
             }
             (ZoomStage::Dynamic(mut b), Input::Point(p)) => {
@@ -565,7 +597,7 @@ impl Session {
         let f = 2f64.powf((-dy / half).clamp(-16.0, 16.0));
         let st = self.state_mut()?;
         let v = st.view();
-        st.set_view_quiet(View { center: v.center, height: (v.height / f).clamp(1e-9, 1e12) });
+        st.set_view_quiet(View { height: (v.height / f).clamp(1e-9, 1e12), ..v });
         self.touch();
         Ok(())
     }

crates/engine/src/cmd/view/dview.rs

@@ -0,0 +1,441 @@
+//! DVIEW: the dynamic view, on CADCraft's 2D plan views.
+//!
+//! It starts with "Select objects or <use DVIEWBLOCK>:": the objects
+//! picked are the preview set, and Enter with nothing picked previews the DVIEWBLOCK block (the
+//! drawing's own block of that name, else a built-in sample house). While DVIEW runs only the
+//! preview set is drawn ([`Interactive::display_only`]); the whole drawing is regenerated when it
+//! ends. Then it repeats "Enter option [CAmera/TArget/Distance/POints/PAn/Zoom/TWist/CLip/Hide/
+//! Off/Undo]:" until Enter. TWist, PAn, Zoom, Off and Undo work; the options that need a 3D
+//! camera say they are not available yet and stay at the option prompt.
+//!
+//! DVIEW works on the Model tab's view, or on the active (double-clicked) layout viewport; on a
+//! layout with no active viewport it is not available. A Model tab twist is a view change like
+//! ZOOM (view history, not undo). A layout viewport's twist belongs to the viewport entity, so a
+//! DVIEW that changed it is one undo step.
+
+use std::sync::Arc;
+
+use cadcraft_doc::{Entity, EntityKind, Handle, Insert, Line, Space};
+use cadcraft_geom::{Vec2, Vec3};
+use serde_json::{Value, json};
+
+use super::super::machines::{SelOutcome, SelectPhase, number};
+use super::super::{CommandSpec, bad, f64_req};
+use crate::{Accept, DisplayOnly, EngineError, Input, Interactive, Prompt, Result, Session, Snapshot, Step, View};
+
+/// What DVIEW (and a view twist asked for anywhere) says on a layout with no active viewport.
+pub(super) const PAPER_SPACE: &str = "This command is not available in Paper space.";
+
+/// The option prompt's keywords, in prompt order.
+const OPTIONS: &[&str] = &["CAmera", "TArget", "Distance", "POints", "PAn", "Zoom", "TWist", "CLip", "Hide", "Off", "Undo"];
+
+/// The block DVIEW previews when nothing is selected.
+const DVIEWBLOCK: &str = "DVIEWBLOCK";
+
+pub(super) fn spec() -> CommandSpec {
+    CommandSpec::new("dview", "DView", run_dview)
+        .alias(&["dv"])
+        .params("{twist: degrees counterclockwise} (DVIEW TWist: the Model tab's view twist, or the active layout viewport's, an undoable edit; not in Paper space)")
+        .noundo()
+        .interactive(|s| {
+            // Refused as it starts on a layout with no active viewport.
+            target(s)?;
+            Ok(Box::new(DviewM::default()))
+        })
+}
+
+/// The view DVIEW changes.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Target {
+    /// The Model tab's view.
+    Model,
+    /// The active (MSPACE) layout viewport: its own view twist.
+    Viewport(Handle),
+}
+
+/// The view DVIEW changes: the active layout viewport, else the Model tab's view. A layout with
+/// no active viewport has none.
+pub(super) fn target(s: &Session) -> Result<Target> {
+    let st = s.state()?;
+    if let Some((h, _)) = st.active_viewport() {
+        return Ok(Target::Viewport(h));
+    }
+    if st.space == Space::Model {
+        return Ok(Target::Model);
+    }
+    Err(EngineError::Other(PAPER_SPACE.into()))
+}
+
+/// A twist kept as files hold it: [0, 2π).
+fn normal(twist: f64) -> f64 {
+    cadcraft_geom::norm_angle(twist)
+}
+
+/// The active viewport's twist, if it is `h`.
+fn viewport_twist(s: &Session, h: Handle) -> Option<f64> {
+    s.state().ok()?.active_viewport().filter(|(vh, _)| *vh == h).map(|(_, vp)| vp.view_twist())
+}
+
+/// Turn `target`'s view to `twist` radians. The Model tab's twist is a view change (view
+/// history, like ZOOM); a viewport's is a change to the viewport entity, which the caller
+/// records as an undo step ([`record_viewport_edit`]).
+pub(super) fn set_twist(s: &mut Session, target: Target, twist: f64) -> Result<()> {
+    if !twist.is_finite() {
+        return Err(bad("dview", "the twist must be a finite angle"));
+    }
+    let twist = normal(twist);
+    match target {
+        Target::Model => {
+            let st = s.state_mut()?;
+            let v = st.view();
+            st.set_view(View { twist, ..v });
+        }
+        Target::Viewport(h) => {
+            if viewport_twist(s, h) == Some(twist) {
+                return Ok(());
+            }
+            // A locked viewport keeps its view, the twist with it.
+            if s.state()?.active_viewport().is_some_and(|(vh, vp)| vh == h && vp.locked) {
+                return Err(EngineError::Other("The viewport is locked.".into()));
+            }
+            let space = s.state()?.space.clone();
+            let d = s.doc_mut()?;
+            if let Some(store) = d.space_mut(&space) {
+                store.modify(h, |e| {
+                    if let EntityKind::Viewport(vp) = &mut e.kind {
+                        vp.twist = twist;
+                    }
+                });
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Record a layout viewport's twist change as one undo step, `before` being the drawing (and
+/// selection) before it. Nothing when the twist did not change, and nothing inside a LISP routine
+/// (its own single step holds it).
+pub(super) fn record_viewport_edit(s: &mut Session, before: (Arc<cadcraft_doc::Drawing>, Vec<Handle>), h: Handle) -> Result<()> {
+    let old = before.0.entity(h).and_then(|e| match &e.kind {
+        EntityKind::Viewport(vp) => Some(vp.view_twist()),
+        _ => None,
+    });
+    if old == viewport_twist(s, h) || s.lisp_groups_undo() {
+        return Ok(());
+    }
+    let st = s.state_mut()?;
+    if !Arc::ptr_eq(&before.0, &st.doc) {
+        st.push_undo(Snapshot { label: "DView".into(), doc: before.0, selection: before.1 });
+        st.revision += 1;
+    }
+    Ok(())
+}
+
+/// The drawing and selection now, for [`record_viewport_edit`].
+fn snapshot(s: &Session) -> Result<(Arc<cadcraft_doc::Drawing>, Vec<Handle>)> {
+    let st = s.state()?;
+    Ok((st.doc.clone(), st.selection.clone()))
+}
+
+fn run_dview(s: &mut Session, p: &Value) -> Result<Value> {
+    let t = target(s)?;
+    let deg = f64_req("dview", p, "twist")?;
+    let before = snapshot(s)?;
+    set_twist(s, t, deg.to_radians())?;
+    if let Target::Viewport(h) = t {
+        record_viewport_edit(s, before, h)?;
+    }
+    let v = s.state()?.view();
+    Ok(json!({ "twist": v.twist.to_degrees() }))
+}
+
+/// The built-in DVIEWBLOCK: a house front in the unit square, origin at the lower-left corner
+/// (the size and origin a DVIEWBLOCK of one's own is expected to have). CADCraft's own drawing.
+fn sample_house() -> Vec<(Vec2, Vec2)> {
+    let p = Vec2::new;
+    let mut lines = Vec::new();
+    let mut poly = |pts: &[Vec2], closed: bool| {
+        for w in pts.windows(2) {
+            lines.push((w[0], w[1]));
+        }
+        if closed && let (Some(a), Some(b)) = (pts.last(), pts.first()) {
+            lines.push((*a, *b));
+        }
+    };
+    // Walls.
+    poly(&[p(0.1, 0.0), p(0.9, 0.0), p(0.9, 0.6), p(0.1, 0.6)], true);
+    // Roof with eaves, and a chimney on its right slope.
+    poly(&[p(0.0, 0.55), p(0.5, 1.0), p(1.0, 0.55)], false);
+    poly(&[p(0.7, 0.82), p(0.7, 0.95), p(0.8, 0.95), p(0.8, 0.73)], false);
+    // Door.
+    poly(&[p(0.42, 0.0), p(0.42, 0.35), p(0.58, 0.35), p(0.58, 0.0)], false);
+    // Two windows with their bars.
+    for x in [0.17, 0.67] {
+        poly(&[p(x, 0.25), p(x + 0.16, 0.25), p(x + 0.16, 0.45), p(x, 0.45)], true);
+        poly(&[p(x + 0.08, 0.25), p(x + 0.08, 0.45)], false);
+        poly(&[p(x, 0.35), p(x + 0.16, 0.35)], false);
+    }
+    lines
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+enum Stage {
+    #[default]
+    Select,
+    Option,
+    Twist,
+    PanBase,
+    PanSecond(Vec2),
+    Zoom,
+}
+
+/// DVIEW, interactive.
+#[derive(Default)]
+struct DviewM {
+    stage: Stage,
+    sel: SelectPhase,
+    /// The preview set; empty with `sample` set: the DVIEWBLOCK.
+    preview: Vec<Handle>,
+    /// Where the DVIEWBLOCK preview stands: its lower-left corner and size (drawing units), fixed
+    /// as the options start so that PAn and Zoom move the view, not the house.
+    sample: Option<(Vec2, f64)>,
+    /// The views before each DVIEW action, for Undo.
+    undo: Vec<View>,
+    /// What DVIEW works on, and the drawing as it started (a viewport's twist change is one
+    /// undo step).
+    target: Option<Target>,
+    before: Option<(Arc<cadcraft_doc::Drawing>, Vec<Handle>)>,
+}
+
+impl DviewM {
+    fn target(&self, s: &Session) -> Result<Target> {
+        match self.target {
+            Some(t) => Ok(t),
+            None => target(s),
+        }
+    }
+    /// Start the options with this preview set (empty: the DVIEWBLOCK).
+    fn options(&mut self, s: &mut Session, picked: Vec<Handle>) -> Result<Step> {
+        // Objects picked at the prompt don't stay selected.
+        s.set_selection(Vec::new());
+        if picked.is_empty() {
+            let v = s.state()?.view();
+            let size = v.height * 0.5;
+            self.sample = Some((v.center - Vec2::new(size, size) * 0.5, size));
+        }
+        self.preview = picked;
+        self.stage = Stage::Option;
+        Ok(Step::Continue)
+    }
+    /// Show view `v` (centre, height and twist) on the target.
+    fn show(&self, s: &mut Session, v: View) -> Result<()> {
+        let t = self.target(s)?;
+        let before = s.state()?.doc.clone();
+        let twist = normal(v.twist);
+        if let Target::Viewport(_) = t {
+            // The twist is the viewport's; the view inside it then moves as asked.
+            set_twist(s, t, twist)?;
+        }
+        if !s.state_mut()?.set_view(View { twist, ..v }) {
+            s.state_mut()?.doc = before;
+            return Err(EngineError::Other("The view is too large to show.".into()));
+        }
+        Ok(())
+    }
+    /// Apply a view as one DVIEW action (Undo takes it back).
+    fn change(&mut self, s: &mut Session, f: impl FnOnce(View) -> View) -> Result<()> {
+        let v = s.state()?.view();
+        self.show(s, f(v))?;
+        self.undo.push(v);
+        Ok(())
+    }
+    /// The command ends: a viewport twist change becomes one undo step, and the whole drawing is
+    /// regenerated.
+    fn end(&mut self, s: &mut Session) -> Result<()> {
+        if let (Some(Target::Viewport(h)), Some(before)) = (self.target, self.before.take()) {
+            record_viewport_edit(s, before, h)?;
+        }
+        s.touch();
+        Ok(())
+    }
+}
+
+impl Interactive for DviewM {
+    fn name(&self) -> &'static str {
+        "DVIEW"
+    }
+    fn begin(&mut self, s: &mut Session) -> Result<Step> {
+        self.target = Some(target(s)?);
+        self.before = Some(snapshot(s)?);
+        Ok(Step::Continue)
+    }
+    fn prompt(&self, s: &Session) -> Prompt {
+        match self.stage {
+            Stage::Select if self.sel.removing => self.sel.prompt(),
+            Stage::Select => Prompt::new("Select objects or", Accept::SELECT).default("use DVIEWBLOCK"),
+            Stage::Option => Prompt::new("Enter option", Accept::TEXT).kw(OPTIONS),
+            Stage::Twist => {
+                let (au, ap) = s.doc().map(|d| (d.header.i64("AUNITS", 0), d.header.i64("AUPREC", 0))).unwrap_or((0, 0));
+                let cur = s.state().map(|st| st.view().twist).unwrap_or(0.0);
+                // Offered as it would be typed: clockwise is positive when ANGDIR is 1.
+                let cur = if s.angle_settings().clockwise { -cur } else { cur };
+                let center = s.state().map(|st| st.view().center).ok();
+                Prompt::new("Specify view twist angle", Accept::POINT_OR_NUMBER).default(crate::units::format_angle(cur, au, ap)).base_opt(center)
+            }
+            Stage::PanBase => Prompt::new("Specify displacement base point", Accept::POINT),
+            Stage::PanSecond(b) => Prompt::new("Specify second point", Accept::POINT).base(b),
+            Stage::Zoom => Prompt::new("Specify zoom scale factor", Accept::NUMBER).default("1"),
+        }
+    }
+    fn cancelled(&mut self, s: &mut Session) {
+        if let Err(e) = self.end(s) {
+            s.echo(e.to_string());
+        }
+    }
+    fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
+        match self.stage {
+            Stage::Select => match self.sel.feed(s, &i)? {
+                SelOutcome::More => Ok(Step::Continue),
+                SelOutcome::Empty => self.options(s, Vec::new()),
+                SelOutcome::Done(hs) => self.options(s, hs),
+            },
+            Stage::Option => {
+                let word = match &i {
+                    Input::Enter => {
+                        self.end(s)?;
+                        return Ok(Step::Done);
+                    }
+                    Input::Keyword(t) | Input::Text(t) => self.prompt(s).match_keyword(t),
+                    _ => None,
+                };
+                match word.as_deref() {
+                    Some("TWist") => self.stage = Stage::Twist,
+                    Some("PAn") => self.stage = Stage::PanBase,
+                    Some("Zoom") => self.stage = Stage::Zoom,
+                    // Perspective is never on in a 2D view: there is nothing to turn off.
+                    Some("Off") => {}
+                    Some("Undo") => {
+                        if let Some(v) = self.undo.pop() {
+                            self.show(s, v)?;
+                        }
+                    }
+                    // CAmera, TArget, Distance, POints, CLip and Hide need a 3D view.
+                    Some(other) => s.echo(format!("DVIEW {other} is not available yet.")),
+                    None => return Err(EngineError::Other("Invalid option keyword.".into())),
+                }
+                Ok(Step::Continue)
+            }
+            Stage::Twist => {
+                let twist = match &i {
+                    Input::Enter => None,
+                    Input::Point(p) => {
+                        let c = s.state()?.view().center;
+                        let d = *p - c;
+                        if d.len() < 1e-12 {
+                            return Err(EngineError::Other("Requires a valid angle.".into()));
+                        }
+                        Some(d.y.atan2(d.x))
+                    }
+                    Input::Text(t) | Input::Keyword(t) if t.trim().is_empty() => None,
+                    Input::Text(t) | Input::Keyword(t) => {
+                        Some(s.angle_settings().rotation(t).ok_or_else(|| EngineError::Other("Requires a valid angle.".into()))?)
+                    }
+                    _ => return Ok(Step::Continue),
+                };
+                if let Some(a) = twist {
+                    self.change(s, |v| View { twist: normal(a), ..v })?;
+                }
+                self.stage = Stage::Option;
+                Ok(Step::Continue)
+            }
+            Stage::PanBase => match i {
+                Input::Point(p) => {
+                    self.stage = Stage::PanSecond(p);
+                    Ok(Step::Continue)
+                }
+                Input::Enter => {
+                    self.stage = Stage::Option;
+                    Ok(Step::Continue)
+                }
+                _ => Err(EngineError::Other("Invalid point.".into())),
+            },
+            Stage::PanSecond(b) => match i {
+                Input::Point(p) => {
+                    self.change(s, |v| View { center: v.center - (p - b), ..v })?;
+                    self.stage = Stage::Option;
+                    Ok(Step::Continue)
+                }
+                Input::Enter => {
+                    self.stage = Stage::Option;
+                    Ok(Step::Continue)
+                }
+                _ => Err(EngineError::Other("Invalid point.".into())),
+            },
+            Stage::Zoom => {
+                let f = match &i {
+                    Input::Enter => None,
+                    Input::Text(t) | Input::Keyword(t) if t.trim().is_empty() => None,
+                    Input::Text(t) | Input::Keyword(t) => match number(t) {
+                        Some(f) if f.is_finite() && f > 0.0 => Some(f),
+                        _ => return Err(EngineError::Other("Requires a positive number.".into())),
+                    },
+                    _ => return Ok(Step::Continue),
+                };
+                if let Some(f) = f.filter(|f| *f != 1.0) {
+                    self.change(s, |v| View { height: v.height / f, ..v })?;
+                }
+                self.stage = Stage::Option;
+                Ok(Step::Continue)
+            }
+        }
+    }
+    fn display_only(&self, s: &Session) -> Option<DisplayOnly> {
+        if self.stage == Stage::Select {
+            return None;
+        }
+        let mut extra = Vec::new();
+        if let Some((corner, size)) = self.sample {
+            let common = s.current_common();
+            let d = s.doc().ok()?;
+            if d.block(DVIEWBLOCK).is_some() {
+                // The drawing's own DVIEWBLOCK, defined in a 1 by 1 unit area.
+                let ins = Insert {
+                    block: DVIEWBLOCK.into(),
+                    insert: corner.to3(0.0),
+                    scale: Vec3::new(size, size, size),
+                    rotation: 0.0,
+                    attribs: Vec::new(),
+                    cols: 1,
+                    rows: 1,
+                    col_spacing: 0.0,
+                    row_spacing: 0.0,
+                    clip: None,
+                };
+                extra.push(Entity { handle: Handle(0), common, kind: EntityKind::Insert(ins) });
+            } else {
+                extra.extend(sample_house().into_iter().map(|(a, b)| Entity {
+                    handle: Handle(0),
+                    common: common.clone(),
+                    kind: EntityKind::Line(Line { a: (corner + a * size).to3(0.0), b: (corner + b * size).to3(0.0) }),
+                }));
+            }
+        }
+        Some(DisplayOnly { handles: self.preview.clone(), extra })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_sample_house_fits_the_unit_square() {
+        let lines = sample_house();
+        assert!(lines.len() > 10);
+        for (a, b) in lines {
+            for q in [a, b] {
+                assert!((0.0..=1.0).contains(&q.x) && (0.0..=1.0).contains(&q.y), "{q:?}");
+            }
+        }
+    }
+}

crates/engine/src/cmd/view/named_views.rs

@@ -110,15 +110,25 @@ fn save(s: &mut Session, name: &str, window: Option<Bounds2>, snapshot: bool) ->
         (Space::Paper(l), false) => Some(l.clone()),
         _ => None,
     };
+    // The view this saves: the viewport's model view inside an MSPACE viewport, else the screen.
+    let frame = if in_viewport { st.zoom_frame() } else { st.view() };
+    // The view twist goes with the view (paper space has none).
+    let twist = if layout.is_some() { 0.0 } else { frame.twist };
     let (center, height, width) = match window {
         Some(b) => {
             if !(b.width() > 1e-12 && b.height() > 1e-12 && b.min.is_finite() && b.max.is_finite()) {
                 return Err(EngineError::Other("The window has no area.".into()));
             }
-            (b.center(), b.height(), b.width())
+            // In a twisted view the window's box on screen is larger than its world box.
+            let (center, width, height) = crate::View::twisted_box(b, twist);
+            // Turning corners near the number limit can overflow: save no view that can't be restored.
+            if !(center.is_finite() && width.is_finite() && height.is_finite() && width > 1e-12 && height > 1e-12) {
+                return Err(EngineError::Other("The window is too large for a twisted view.".into()));
+            }
+            (center, height, width)
         }
         None => {
-            let f = if in_viewport { st.zoom_frame() } else { st.view() };
+            let f = frame;
             let aspect = if in_viewport { st.zoom_aspect(w / h.max(1.0)) } else { w / h.max(1.0) };
             (f.center, f.height, f.height * aspect)
         }
@@ -139,7 +149,7 @@ fn save(s: &mut Session, name: &str, window: Option<Bounds2>, snapshot: bool) ->
         }
         d.views.retain(|v| !v.name.eq_ignore_ascii_case(old));
     }
-    d.views.push(NamedView { name: name.to_string(), center, height, width, layer_state, twist: 0.0, layout });
+    d.views.push(NamedView { name: name.to_string(), center, height, width, layer_state, twist, layout });
     let msg = if replaced.is_some() { format!("View \"{name}\" replaced.") } else { format!("View \"{name}\" saved.") };
     Ok(json!({ "name": name, "center": [center.x, center.y], "height": height, "width": width, "message": msg }))
 }
@@ -168,7 +178,7 @@ fn restore(s: &mut Session, name: &str) -> Result<Value> {
             let st = s.state_mut()?;
             st.mspace = None;
             let height = v.height.max(v.width / (w / h.max(1.0)).max(1e-9));
-            st.set_view(View { center: v.center, height });
+            st.set_view(View { center: v.center, height, twist: 0.0 });
         }
         None => {
             // A model space view: into the active MSPACE viewport, else on the Model tab.
@@ -177,21 +187,18 @@ fn restore(s: &mut Session, name: &str) -> Result<Value> {
             }
             let (w, h) = s.viewport_px;
             let st = s.state_mut()?;
+            // In an unlocked MSPACE viewport the saved twist turns the viewport (an edit of the
+            // viewport, recorded as the command's undo step).
             let aspect = st.zoom_aspect(w / h.max(1.0)).max(1e-9);
-            st.set_zoom_frame(View { center: v.center, height: v.height.max(v.width / aspect) });
+            let twist = cadcraft_geom::norm_angle(v.twist);
+            st.set_zoom_frame(View { center: v.center, height: v.height.max(v.width / aspect), twist });
         }
     }
     let mut msg = format!("View \"{}\" restored.", v.name);
     if let Some(state) = &v.layer_state {
         let d = s.doc_mut()?;
         match d.layer_states.iter().find(|l| l.name.eq_ignore_ascii_case(state)).cloned() {
-            Some(saved) => {
-                for layer in saved.layers {
-                    if let Some(l) = d.layer_mut(&layer.name) {
-                        *l = layer;
-                    }
-                }
-            }
+            Some(saved) => super::super::layer::restore_layers(d, saved.layers),
             None => msg.push_str(&format!(" Its layer snapshot \"{state}\" is missing.")),
         }
     }

crates/engine/src/cmd/view/vports.rs

@@ -104,7 +104,7 @@ fn rect(t: &VportTile) -> Rect {
 }
 
 fn view_of(t: &VportTile) -> View {
-    View { center: t.center, height: t.height }
+    View { center: t.center, height: t.height, twist: if t.twist.is_finite() { t.twist } else { 0.0 } }
 }
 
 fn active_config(d: &Drawing) -> Option<&VportConfig> {
@@ -117,7 +117,7 @@ fn live(st: &DocState, px: (f64, f64)) -> (Vec<VportTile>, usize) {
     let now = st.views.iter().find(|(sp, _)| *sp == Space::Model).map(|(_, v)| *v).unwrap_or_default();
     let Some(cfg) = active_config(&st.doc) else {
         let aspect = px.0 / px.1.max(1.0);
-        return (vec![VportTile { min: Vec2::ZERO, max: Vec2::new(1.0, 1.0), center: now.center, height: now.height, aspect }], 0);
+        return (vec![VportTile { min: Vec2::ZERO, max: Vec2::new(1.0, 1.0), center: now.center, height: now.height, aspect, twist: now.twist }], 0);
     };
     let mut tiles = cfg.tiles.clone();
     let synced =
@@ -125,11 +125,11 @@ fn live(st: &DocState, px: (f64, f64)) -> (Vec<VportTile>, usize) {
     let active = if synced { st.tiles.active.min(tiles.len() - 1) } else { 0 };
     if synced {
         for (t, v) in tiles.iter_mut().zip(&st.tiles.views) {
-            (t.center, t.height) = (v.center, v.height);
+            (t.center, t.height, t.twist) = (v.center, v.height, v.twist);
         }
     }
     if let Some(t) = tiles.get_mut(active) {
-        (t.center, t.height) = (now.center, now.height);
+        (t.center, t.height, t.twist) = (now.center, now.height, now.twist);
     }
     // Screen aspects from the current tile's size in pixels.
     if let Some(cur) = tiles.get(active).copied() {
@@ -171,7 +171,7 @@ fn summary(s: &Session) -> Result<Value> {
     let rows: Vec<Value> = tiles
         .iter()
         .enumerate()
-        .map(|(i, t)| json!({ "index": i + 1, "min": [t.min.x, t.min.y], "max": [t.max.x, t.max.y], "center": [t.center.x, t.center.y], "height": t.height, "current": i == active }))
+        .map(|(i, t)| json!({ "index": i + 1, "min": [t.min.x, t.min.y], "max": [t.max.x, t.max.y], "center": [t.center.x, t.center.y], "height": t.height, "twist": t.twist.to_degrees(), "current": i == active }))
         .collect();
     Ok(json!({ "tiles": rows }))
 }

crates/engine/src/doc_state.rs

@@ -1,5 +1,5 @@
 use super::view::{ModelTiles, View, usable_view};
-use super::{Arc, Drawing, Handle, Space, blockedit, undoctl};
+use super::{Arc, Drawing, Handle, Space, Vec2, blockedit, undoctl};
 
 #[derive(Clone, Debug)]
 pub struct Snapshot {
@@ -80,6 +80,7 @@ impl DocState {
     pub(crate) fn swap_in(&mut self, snap: Snapshot) -> Snapshot {
         let cur = Snapshot { label: snap.label, doc: std::mem::replace(&mut self.doc, snap.doc), selection: std::mem::take(&mut self.selection) };
         self.follow_layout(&cur.doc);
+        self.reconcile_untiled_twist();
         self.revision += 1;
         cur
     }
@@ -135,7 +136,8 @@ impl DocState {
         match self.active_viewport() {
             Some((_, vp)) => {
                 let k = vp.view_height / vp.height;
-                View { center: vp.view_center + (pv.center - vp.center.xy()) * k, height: pv.height * k }
+                // The viewport's twist turns the model view inside it.
+                View { center: vp.paper_to_model(pv.center), height: pv.height * k, twist: vp.view_twist() }
             }
             None => pv,
         }
@@ -150,16 +152,18 @@ impl DocState {
             if vp.locked {
                 // A locked viewport keeps its scale: pan/zoom the sheet instead.
                 let k0 = vp.view_height / vp.height;
-                let pc = vp.center.xy() + (v.center - vp.view_center) / k0;
-                let paper = View { center: pc, height: v.height / k0 };
+                let pc = vp.model_to_paper(v.center);
+                let paper = View { center: pc, height: v.height / k0, twist: pv.twist };
                 if !usable_view(&paper) {
                     return false;
                 }
                 self.put_paper_view(paper);
             } else {
-                let center = v.center - (pv.center - vp.center.xy()) * k;
+                // `v`'s twist is the one the viewport shows (a non-finite one keeps its own).
+                let twist = if v.twist.is_finite() { v.twist } else { vp.view_twist() };
+                let center = v.center - ((pv.center - vp.center.xy()) * k).rotate(-twist);
                 let height = vp.height * k;
-                if !usable_view(&View { center, height }) {
+                if !usable_view(&View { center, height, twist }) {
                     return false;
                 }
                 let doc = Arc::make_mut(&mut self.doc);
@@ -168,6 +172,7 @@ impl DocState {
                         if let cadcraft_doc::EntityKind::Viewport(x) = &mut e.kind {
                             x.view_center = center;
                             x.view_height = height;
+                            x.twist = twist;
                         }
                     });
                 }
@@ -182,6 +187,36 @@ impl DocState {
             Some((_, slot)) => *slot = v,
             None => self.views.push((self.space.clone(), v)),
         }
+        if self.space == Space::Model {
+            self.keep_untiled_twist(v);
+        }
+    }
+    /// An untiled Model tab keeps its view twist in the drawing as a lone `*Active` VPORT tile
+    /// (written as that record's group 51 and read back), so it survives save and reopen. Only a
+    /// change of twist touches the drawing; an untwisted view keeps no record.
+    /// After undo or redo has put back another drawing: its untiled-twist record follows the
+    /// Model tab's live view again (views are not part of the drawing's undo).
+    pub(crate) fn reconcile_untiled_twist(&mut self) {
+        if let Some(v) = self.views.iter().find(|(s, _)| *s == Space::Model).map(|(_, v)| *v) {
+            self.keep_untiled_twist(v);
+        }
+    }
+    fn keep_untiled_twist(&mut self, v: View) {
+        use cadcraft_doc::{VportConfig, VportTile};
+        let twist = cadcraft_geom::norm_angle(v.twist);
+        let active = self.doc.vports.iter().find(|c| c.is_active());
+        if active.is_some_and(|c| c.tiles.len() > 1) {
+            return;
+        }
+        if active.and_then(|c| c.tiles.first()).map_or(0.0, |t| t.twist) == twist {
+            return;
+        }
+        let d = Arc::make_mut(&mut self.doc);
+        d.vports.retain(|c| !c.is_active());
+        if twist != 0.0 {
+            let tile = VportTile { min: Vec2::ZERO, max: Vec2::new(1.0, 1.0), center: v.center, height: v.height, aspect: 1.0, twist };
+            d.vports.insert(0, VportConfig { name: VportConfig::ACTIVE.into(), tiles: vec![tile] });
+        }
     }
     /// Set the view, recording view history. Returns false, changing nothing, when the view (or,
     /// in MSPACE, the viewport view it maps to) isn't finite with a positive height.
@@ -210,7 +245,7 @@ impl DocState {
     /// The view ZOOM starts from: the model view of the active unlocked viewport, else [`Self::view`].
     pub fn zoom_frame(&self) -> View {
         match self.zoom_viewport() {
-            Some(v) => View { center: v.view_center, height: v.view_height },
+            Some(v) => View { center: v.view_center, height: v.view_height, twist: v.view_twist() },
             None => self.view(),
         }
     }
@@ -225,7 +260,9 @@ impl DocState {
             Some(vp) => {
                 let pv = self.paper_view();
                 let k = f.height / vp.height;
-                View { center: f.center + (pv.center - vp.center.xy()) * k, height: pv.height * k }
+                // The frame's twist turns the viewport (a non-finite one keeps the viewport's).
+                let twist = if f.twist.is_finite() { f.twist } else { vp.view_twist() };
+                View { center: f.center + ((pv.center - vp.center.xy()) * k).rotate(-twist), height: pv.height * k, twist }
             }
             None => f,
         };
@@ -233,7 +270,7 @@ impl DocState {
     }
     /// Set without recording view history (realtime pan/zoom frames).
     pub fn set_view_quiet(&mut self, v: View) {
-        if !(v.center.is_finite() && v.height.is_finite() && v.height > 1e-12) {
+        if !usable_view(&v) {
             return;
         }
         self.store_view(v);

crates/engine/src/guard.rs

@@ -66,6 +66,14 @@ impl Interactive for Guarded {
     fn begin(&mut self, s: &mut Session) -> Result<Step> {
         catch_unwind(AssertUnwindSafe(|| self.inner.begin(s))).unwrap_or_else(|p| Err(self.internal(&*p)))
     }
+    fn cancelled(&mut self, s: &mut Session) {
+        if self.broken.get().is_none()
+            && let Err(p) = catch_unwind(AssertUnwindSafe(|| self.inner.cancelled(s)))
+        {
+            let e = self.internal(&*p);
+            s.echo(e.to_string());
+        }
+    }
     fn preview(&self, s: &Session, cursor: Vec2) -> Vec<EntityKind> {
         if self.broken.get().is_some() {
             return Vec::new();
@@ -102,6 +110,15 @@ impl Interactive for Guarded {
             None
         })
     }
+    fn display_only(&self, s: &Session) -> Option<crate::prompt::DisplayOnly> {
+        if self.broken.get().is_some() {
+            return None;
+        }
+        catch_unwind(AssertUnwindSafe(|| self.inner.display_only(s))).unwrap_or_else(|_| {
+            self.broken.set(Some("panic in preview"));
+            None
+        })
+    }
 }
 
 #[cfg(test)]

crates/engine/src/lib.rs

@@ -49,7 +49,7 @@ pub use cadcraft_geom as geom;
 pub use cadcraft_render as render;
 pub use cmd::hatch::{HatchPicks, PatternChoice, PickMode, pattern_choices};
 pub use cmd::{CommandInfo, CommandSpec, command_specs, find_command};
-pub use prompt::{Accept, Drag, Input, Interactive, Picker, Prompt, Step};
+pub use prompt::{Accept, DisplayOnly, Drag, Input, Interactive, Picker, Prompt, Step};
 
 mod doc_state;
 mod error;

crates/engine/src/prompt.rs

@@ -31,7 +31,7 @@ impl Accept {
 /// [Truecolor/COlorbook] <BYLAYER>:". A prompt asking for something else besides its keywords has
 /// it: "Enter block name or [?]:", "Specify insertion base point or [Basepoint/…]:". Read from
 /// AutoCAD's command line over measured runs, where no prompt was written both ways.
-const NO_OR: [&str; 27] = [
+const NO_OR: [&str; 28] = [
     "Bring to front",
     "Calculate rectangle dimensions based on",
     "Choose mode for selected object conversion",
@@ -47,6 +47,7 @@ const NO_OR: [&str; 27] = [
     "Enter leader format option",
     "Enter line spacing type",
     "Enter object ordering option",
+    "Enter option",
     "Enter polyline linetype generation option",
     "Enter property to change",
     "Enter the type of array",
@@ -266,6 +267,9 @@ pub trait Interactive: Send {
     fn begin(&mut self, _s: &mut Session) -> Result<Step> {
         Ok(Step::Continue)
     }
+    /// Called when the command is cancelled from outside (Esc, or another command starting),
+    /// before it finishes: what it records on every exit path.
+    fn cancelled(&mut self, _s: &mut Session) {}
     /// Rubber-band geometry for the cursor position.
     fn preview(&self, _s: &Session, _cursor: Vec2) -> Vec<EntityKind> {
         Vec::new()
@@ -287,6 +291,22 @@ pub trait Interactive: Send {
     fn editing_mtext(&self) -> Option<cadcraft_doc::MText> {
         None
     }
+    /// What the drawing area shows in place of the drawing while the command runs (DVIEW draws
+    /// only its preview set); `None` shows the drawing.
+    fn display_only(&self, _s: &Session) -> Option<DisplayOnly> {
+        None
+    }
+}
+
+/// See [`Interactive::display_only`]: the only things drawn in the current view while a command
+/// runs. The whole drawing is drawn again when it ends.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct DisplayOnly {
+    /// Objects of the drawing, drawn as they are.
+    pub handles: Vec<Handle>,
+    /// Geometry that is not in the drawing (DVIEW's sample house, or an insert of the drawing's
+    /// DVIEWBLOCK block), with its own properties.
+    pub extra: Vec<cadcraft_doc::Entity>,
 }
 
 /// See [`Interactive::drag`].

crates/engine/src/select.rs

@@ -527,6 +527,7 @@ mod tests {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         };
         let h = d.add(&Space::Model, Common::default(), EntityKind::Insert(insert)).unwrap();
         (d, h)

crates/engine/src/session/files.rs

@@ -6,7 +6,7 @@ impl Session {
         self.untitled_counter += 1;
         let d = if metric { Drawing::new_metric() } else { Drawing::new_imperial() };
         let mut st = DocState::new(d, &format!("Drawing{}", self.untitled_counter), None);
-        st.set_view_quiet(if metric { View { center: Vec2::new(210.0, 148.5), height: 297.0 } } else { View::default() });
+        st.set_view_quiet(if metric { View { center: Vec2::new(210.0, 148.5), height: 297.0, twist: 0.0 } } else { View::default() });
         self.end_running();
         self.docs.push(st);
         self.active = self.docs.len() - 1;
@@ -18,11 +18,13 @@ impl Session {
     pub fn open_drawing(&mut self, d: Drawing, title: &str, path: Option<String>) -> usize {
         let mut st = DocState::new(d, title, path);
         let ext = st.doc.extents(&Space::Model);
-        if !ext.is_empty() {
-            st.set_view_quiet(View {
-                center: ext.center(),
-                height: (ext.height().max(ext.width() * self.viewport_px.1 / self.viewport_px.0.max(1.0)) * 1.1).max(1e-6),
-            });
+        // The current tile (the first), or the lone untiled view, keeps its saved twist.
+        let twist = cadcraft_geom::norm_angle(st.doc.vports.iter().find(|c| c.is_active()).and_then(|c| c.tiles.first()).map_or(0.0, |t| t.twist));
+        if ext.is_empty() {
+            st.set_view_quiet(View { twist, ..st.view() });
+        } else {
+            let (center, w, h) = View::twisted_box(ext, twist);
+            st.set_view_quiet(View { center, height: (h.max(w * self.viewport_px.1 / self.viewport_px.0.max(1.0)) * 1.1).max(1e-6), twist });
         }
         self.end_running();
         self.docs.push(st);

crates/engine/src/session/interactive.rs

@@ -1,3 +1,5 @@
+use crate::DisplayOnly;
+
 use super::{
     Arc, Bounds2, Drag, Drawing, EngineError, Entity, Handle, Input, PendingWindow, Prompt, Result, Running, Session, Snapshot, Step, Value, Vec2,
     assoc, cmd, find_command, guard, pointmod, select, snap, sysvars,
@@ -199,7 +201,7 @@ impl Session {
             Input::Point(p) => {
                 let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5;
                 if let Some(pw) = self.pending_window.take() {
-                    let crossing = p.x < pw.corner.x;
+                    let crossing = self.window_is_crossing(pw.corner, p);
                     let hs = select::select_window(self.doc()?, &space, Bounds2::new(pw.corner, p), crossing);
                     return Ok(Some(Input::Pick(cmd::groups::expand(self, hs))));
                 }
@@ -279,7 +281,10 @@ impl Session {
         let base = if matches!(input, Some(Input::Point(_))) { self.current_prompt().and_then(|p| p.base) } else { None };
         let Some(mut run) = self.running.take() else { return Ok(()) };
         let step = match input {
-            Some(Input::Cancel) => Ok(Step::Cancel),
+            Some(Input::Cancel) => {
+                run.machine.cancelled(self);
+                Ok(Step::Cancel)
+            }
             Some(i) => {
                 if let Input::Point(p) = &i {
                     self.last_point = *p;
@@ -438,7 +443,8 @@ impl Session {
         }
         if self.running.is_some() {
             if self.suspended.is_some() {
-                if let Some(nested) = self.running.take() {
+                if let Some(mut nested) = self.running.take() {
+                    nested.machine.cancelled(self);
                     self.finish(nested, true);
                 }
                 self.running = self.suspended.take();
@@ -523,6 +529,13 @@ impl Session {
         out
     }
 
+    /// What the drawing area shows in place of the drawing while a command runs (DVIEW's preview
+    /// set, see [`Interactive::display_only`]), also while a transparent command interrupts it.
+    /// `None`: the drawing.
+    pub fn display_only(&self) -> Option<DisplayOnly> {
+        [&self.running, &self.suspended].into_iter().flatten().find_map(|r| r.machine.display_only(self))
+    }
+
     /// The active command's preview as a transform of existing objects (see
     /// [`Interactive::drag`]), with its extra rubber-band geometry as entities.
     pub fn drag(&self, cursor: Vec2) -> Option<(Drag, Vec<Entity>)> {

crates/engine/src/session/picking.rs

@@ -16,6 +16,13 @@ impl Session {
         true
     }
 
+    /// Whether a selection window from `corner` to `p` is a crossing window: it was dragged
+    /// leftwards on screen (in a twisted view, not along the drawing's X axis).
+    pub fn window_is_crossing(&self, corner: Vec2, p: Vec2) -> bool {
+        let twist = self.state().map_or(0.0, |st| st.view().twist);
+        (p - corner).rotate(twist).x < 0.0
+    }
+
     /// A click with no command running: pick/toggle objects or start a selection window.
     ///
     /// PICKADD on (the default): picks add to the selection and Shift removes. PICKADD off: each pick
@@ -24,7 +31,7 @@ impl Session {
         let space = self.space();
         let pickadd = self.settings.pickadd;
         if let Some(pw) = self.pending_window.take() {
-            let crossing = p.x < pw.corner.x;
+            let crossing = self.window_is_crossing(pw.corner, p);
             let hs = select::select_window(self.doc()?, &space, Bounds2::new(pw.corner, p), crossing);
             let hs = cmd::groups::expand(self, hs);
             let mut sel = if pickadd || shift { self.selection() } else { Vec::new() };

crates/engine/src/session/zoom.rs

@@ -23,8 +23,10 @@ impl Session {
         let ext = if ext.is_empty() { self.zoom_limits()? } else { ext };
         let st = self.state_mut()?;
         let aspect = st.zoom_aspect(w / h.max(1.0));
-        let height = ext.height().max(ext.width() / aspect.max(1e-6)).max(1e-6) * 1.05;
-        st.set_zoom_frame(View { center: ext.center(), height });
+        let twist = st.zoom_frame().twist;
+        let (center, bw, bh) = View::twisted_box(ext, twist);
+        let height = bh.max(bw / aspect.max(1e-6)).max(1e-6) * 1.05;
+        st.set_zoom_frame(View { center, height, twist });
         Ok(())
     }
 
@@ -38,7 +40,7 @@ impl Session {
         let h = (v.height / factor).clamp(1e-9, 1e12);
         let k = h / v.height;
         let c = about + (v.center - about) * k;
-        st.set_view_quiet(View { center: c, height: h });
+        st.set_view_quiet(View { center: c, height: h, twist: v.twist });
         Ok(())
     }
 }

crates/engine/src/snap.rs

@@ -714,6 +714,7 @@ impl Sink<'_> {
                     rows: 1,
                     col_spacing: 0.0,
                     row_spacing: 0.0,
+                    clip: None,
                 };
                 block_leaves(d, &ins, &Mat3::IDENTITY, 0, budget, frozen, &mut |k, m| self.object(k, Some(m)));
             }

crates/engine/src/snap/viewport.rs

@@ -40,7 +40,8 @@ impl<'a> Projection<'a> {
         }
         let half = Vec2::new(viewport.width / 2.0, viewport.height / 2.0);
         let paper_clip = Bounds2::new(center - half, center + half);
-        let model_clip = Bounds2::new(viewport.view_center - half / scale, viewport.view_center + half / scale);
+        // The model box the viewport shows (turned, with a view twist).
+        let model_clip = Bounds2::from_points(paper_clip.corners().map(|p| viewport.paper_to_model(p)));
         if ![paper_clip.min, paper_clip.max, model_clip.min, model_clip.max].into_iter().all(Vec2::is_finite) {
             return None;
         }
@@ -48,11 +49,11 @@ impl<'a> Projection<'a> {
     }
 
     pub fn to_model(&self, point: Vec2) -> Vec2 {
-        self.viewport.view_center + (point - self.viewport.center.xy()) / self.scale
+        self.viewport.paper_to_model(point)
     }
 
     fn to_paper(&self, point: Vec2) -> Vec2 {
-        self.viewport.center.xy() + (point - self.viewport.view_center) * self.scale
+        self.viewport.model_to_paper(point)
     }
 
     pub fn hit(&self, mut hit: SnapHit) -> Option<SnapHit> {
@@ -76,7 +77,9 @@ impl<'a> Projection<'a> {
                     if !(center.is_finite() && radius.is_finite() && radius > 0.0) {
                         return None;
                     }
-                    SnapCurve::Arc { center, radius, start, end }
+                    // The arc turns on the sheet with the viewport's twist.
+                    let twist = self.viewport.view_twist();
+                    SnapCurve::Arc { center, radius, start: start + twist, end: end + twist }
                 }
                 SnapCurve::Line { a, b } => {
                     let (a, b) = (self.to_paper(a), self.to_paper(b));

crates/engine/src/spatial.rs

@@ -364,6 +364,7 @@ mod tests {
                     rows: 1,
                     col_spacing: 0.0,
                     row_spacing: 0.0,
+                    clip: None,
                 }),
                 8 if i % 40 == 8 => EntityKind::XLine(cadcraft_doc::RayLine { base: v3(x, y), dir: v3(r.r(-1.0, 1.0), 1.0) }),
                 8 if i % 40 == 18 => EntityKind::Ray(cadcraft_doc::RayLine { base: v3(x, y), dir: v3(1.0, r.r(-1.0, 1.0)) }),
@@ -546,6 +547,7 @@ mod tests {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         };
         let h = d.add(&Space::Model, Common::default(), EntityKind::Insert(insert)).unwrap();
         let small = Bounds2::new(Vec2::new(-2.0, -2.0), Vec2::new(2.0, 2.0));

crates/engine/src/sysvars.rs

@@ -184,6 +184,8 @@ pub fn get(s: &Session, name: &str) -> Option<Value> {
             json!([v.center.x, v.center.y, 0.0])
         }
         "VIEWSIZE" => json!(s.state().ok()?.view().height),
+        // The view twist (DVIEW TWist), in degrees counterclockwise.
+        "VIEWTWIST" => json!(s.state().ok()?.view().twist.to_degrees()),
         "EXTMIN" | "EXTMAX" => {
             let d = s.doc().ok()?;
             let e = d.extents(&s.space());
@@ -260,6 +262,7 @@ const READ_ONLY: &[&str] = &[
     "DISTANCE",
     "VIEWCTR",
     "VIEWSIZE",
+    "VIEWTWIST",
     "EXTMIN",
     "EXTMAX",
     "UNDOCTL",

crates/engine/src/sysvars/table.rs

@@ -74,6 +74,8 @@ const HEADER: &[(&str, Kind, Def)] = &[
     ("TRIMEXTENDMODE", Kind::Choice(&[0, 1]), Def::Int(1)),
     ("TRIMMODE", Kind::Choice(&[0, 1]), Def::Int(1)),
     ("WIPEOUTFRAME", Kind::Choice(&[0, 1, 2]), Def::Int(1)),
+    // XCLIP boundaries: 0 hidden, 1 shown and plotted, 2 shown but not plotted.
+    ("XCLIPFRAME", Kind::Choice(&[0, 1, 2]), Def::Int(2)),
 ];
 
 /// The standard lineweights in hundredths of a millimetre.

crates/engine/src/tests.rs

@@ -185,7 +185,7 @@ fn move_with_pickfirst_and_window_selection() {
     s.execute("line", &json!({"points": [[0, 0], [1, 0]]})).unwrap();
     s.execute("line", &json!({"points": [[5, 5], [6, 5]]})).unwrap();
     s.viewport_px = (1000.0, 1000.0);
-    s.state_mut().unwrap().set_view(View { center: Vec2::new(3.0, 3.0), height: 10.0 });
+    s.state_mut().unwrap().set_view(View { center: Vec2::new(3.0, 3.0), height: 10.0, twist: 0.0 });
     // Window selection from left to right picks only the first line.
     s.cmdline("move").unwrap();
     s.input(Input::Point(Vec2::new(-1.0, -1.0))).unwrap();

crates/engine/src/view.rs

@@ -1,20 +1,38 @@
+use cadcraft_geom::Bounds2;
+
 use super::{Deserialize, Serialize, Vec2};
 
-/// A 2D view of a space: world centre and visible height in drawing units.
+/// A 2D view of a space: world centre and visible height in drawing units, and the view twist
+/// (VIEWTWIST, DVIEW TWist): how far the view is turned on screen, in radians counterclockwise
+/// (the drawing appears turned by `twist`; 0 is the plain plan view).
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
 pub struct View {
     pub center: Vec2,
     pub height: f64,
+    #[serde(default)]
+    pub twist: f64,
 }
 
 impl Default for View {
     fn default() -> Self {
-        View { center: Vec2::new(6.0, 4.5), height: 10.0 }
+        View { center: Vec2::new(6.0, 4.5), height: 10.0, twist: 0.0 }
+    }
+}
+
+impl View {
+    /// Box `b` (world) as a view turned by `twist` shows it: the world centre of the box it
+    /// makes on screen, and that box's width and height (`b`'s own when there is no twist).
+    pub fn twisted_box(b: Bounds2, twist: f64) -> (Vec2, f64, f64) {
+        if twist == 0.0 || !twist.is_finite() {
+            return (b.center(), b.width(), b.height());
+        }
+        let r = Bounds2::from_points(b.corners().map(|p| p.rotate(twist)));
+        (r.center().rotate(-twist), r.width(), r.height())
     }
 }
 
 pub(crate) fn usable_view(v: &View) -> bool {
-    v.center.is_finite() && v.height.is_finite() && v.height > 1e-12
+    v.center.is_finite() && v.height.is_finite() && v.height > 1e-12 && v.twist.is_finite()
 }
 
 /// Tiled model viewports (VPORTS): the session side of the drawing's `*Active` configuration.

crates/engine/tests/audit.rs

@@ -24,6 +24,7 @@ fn insert(block: &str) -> EntityKind {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     })
 }
 

crates/engine/tests/autosave.rs

@@ -487,6 +487,7 @@ fn a_block_editor_that_cannot_be_composed_is_not_autosaved_as_the_old_host() {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     });
     d.model.push(Entity::new(h, kind));
     assert!(s.state().unwrap().recovery_drawing().is_err());

crates/engine/tests/clipboard.rs

@@ -28,6 +28,7 @@ fn insert(d: &mut Drawing, block: &str, at: (f64, f64)) -> Entity {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     });
     Entity { handle: d.new_handle(), common: Common::default(), kind }
 }

crates/engine/tests/compare.rs

@@ -124,6 +124,7 @@ fn hooks() {
                 rows: 1,
                 col_spacing: 0.0,
                 row_spacing: 0.0,
+                clip: None,
             };
             d.add(&Space::Model, Common::default(), EntityKind::Insert(insert)).map_err(|e| e.to_string())?;
             return Ok(d);
@@ -175,6 +176,7 @@ fn hostile_inputs_are_errors() {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     };
     b.entities.push(Entity::new(cadcraft_engine::doc::Handle(0x900), EntityKind::Insert(ins.clone())));
     let d = s.doc_mut().unwrap();

crates/engine/tests/dview.rs

@@ -0,0 +1,381 @@
+//! DVIEW starts with "Select objects or <use DVIEWBLOCK>:", then the option prompt;
+//! TWist, PAn, Zoom, Off and Undo on a 2D view; the 3D options not available yet. It works on the
+//! Model tab and inside an active layout viewport (whose twist is an undoable edit of the
+//! viewport), and not on a layout sheet.
+
+use cadcraft_doc::{EntityKind, Handle, Viewport};
+use cadcraft_engine::geom::Vec2;
+use cadcraft_engine::{Input, Session, View};
+use serde_json::json;
+
+const SELECT: &str = "Select objects or <use DVIEWBLOCK>:";
+const OPTION: &str = "Enter option [CAmera/TArget/Distance/POints/PAn/Zoom/TWist/CLip/Hide/Off/Undo]:";
+const PAPER: &str = "This command is not available in Paper space.";
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.viewport_px = (1200.0, 800.0);
+    s.execute("line", &json!({ "points": [[0, 0], [100, 50]] })).unwrap();
+    s.execute("view.set", &json!({ "center": [10, 10], "height": 20 })).unwrap();
+    s
+}
+
+fn prompt(s: &Session) -> String {
+    s.current_prompt().map(|p| p.display()).unwrap_or_default()
+}
+
+fn view(s: &Session) -> View {
+    s.state().unwrap().view()
+}
+
+fn near(a: f64, b: f64) -> bool {
+    (a - b).abs() < 1e-9
+}
+
+fn twist_deg(s: &Session) -> f64 {
+    view(s).twist.to_degrees()
+}
+
+fn logged(s: &Session, m: &str) -> bool {
+    s.log.iter().any(|l| l == m)
+}
+
+#[test]
+fn every_prompt_step_on_the_model_tab() {
+    let mut s = session();
+    let undo = s.state().unwrap().undo.len();
+    s.cmdline("dview").unwrap();
+    assert_eq!(prompt(&s), SELECT);
+    // The whole drawing shows while objects are picked.
+    assert!(s.display_only().is_none());
+    // Enter with nothing selected: the DVIEWBLOCK sample (a house of lines) is the preview set.
+    s.cmdline("").unwrap();
+    assert_eq!(prompt(&s), OPTION);
+    let only = s.display_only().unwrap();
+    assert!(only.handles.is_empty());
+    assert!(only.extra.len() > 10 && only.extra.iter().all(|e| matches!(e.kind, EntityKind::Line(_))));
+    twist_pan_and_zoom(&mut s);
+    // The sample house stays where it was put: the view moves over it.
+    assert_eq!(s.display_only().unwrap(), only);
+    off_and_unavailable_options(&mut s);
+    undo_steps(&mut s);
+
+    // An unknown option is refused and asked again.
+    assert!(s.cmdline("bogus").is_ok());
+    assert_eq!(prompt(&s), OPTION);
+
+    // Enter ends DVIEW; the whole drawing shows again, and a Model tab twist is no undo step.
+    s.cmdline("tw").unwrap();
+    s.cmdline("45").unwrap();
+    s.cmdline("").unwrap();
+    assert!(s.current_prompt().is_none());
+    assert!(s.display_only().is_none());
+    assert!(near(twist_deg(&s), 45.0));
+    assert_eq!(s.state().unwrap().undo.len(), undo);
+}
+
+/// DVIEW's TWist, PAn and Zoom steps from the option prompt of a fresh Model tab session.
+fn twist_pan_and_zoom(s: &mut Session) {
+    // TWist: the current twist is the default; a typed angle turns the view.
+    s.cmdline("tw").unwrap();
+    assert_eq!(prompt(s), "Specify view twist angle <0>:");
+    s.cmdline("30").unwrap();
+    assert!(near(twist_deg(s), 30.0));
+    assert_eq!(prompt(s), OPTION);
+    s.cmdline("TWist").unwrap();
+    assert_eq!(prompt(s), "Specify view twist angle <30>:");
+    // Enter keeps it.
+    s.cmdline("").unwrap();
+    assert!(near(twist_deg(s), 30.0));
+
+    // PAn: base point, second point.
+    s.cmdline("pa").unwrap();
+    assert_eq!(prompt(s), "Specify displacement base point:");
+    s.cmdline("0,0").unwrap();
+    assert_eq!(prompt(s), "Specify second point:");
+    s.cmdline("4,0").unwrap();
+    assert_eq!(view(s).center, Vec2::new(6.0, 10.0));
+    assert_eq!(prompt(s), OPTION);
+
+    // Zoom: a scale factor of the current view.
+    s.cmdline("z").unwrap();
+    assert_eq!(prompt(s), "Specify zoom scale factor <1>:");
+    s.cmdline("2").unwrap();
+    assert!(near(view(s).height, 10.0));
+}
+
+/// DVIEW's Off option and the options that need a 3D camera.
+fn off_and_unavailable_options(s: &mut Session) {
+    // Off: perspective is never on in a 2D view, so nothing changes.
+    let before = view(s);
+    s.cmdline("o").unwrap();
+    assert_eq!(prompt(s), OPTION);
+    assert_eq!(view(s), before);
+
+    // The options that need a 3D camera are not available yet and stay at the option prompt.
+    for (typed, name) in [("ca", "CAmera"), ("ta", "TArget"), ("d", "Distance"), ("po", "POints"), ("cl", "CLip"), ("h", "Hide")] {
+        s.cmdline(typed).unwrap();
+        assert!(logged(s, &format!("DVIEW {name} is not available yet.")), "{name}: {:?}", s.log);
+        assert_eq!(prompt(s), OPTION);
+    }
+    assert!(!s.log.iter().any(|l| l.contains("Only the view twist")));
+}
+
+/// DVIEW's Undo after [`twist_pan_and_zoom`].
+fn undo_steps(s: &mut Session) {
+    // Undo takes back one DVIEW action at a time: zoom, pan, twist.
+    s.cmdline("u").unwrap();
+    assert!(near(view(s).height, 20.0));
+    s.cmdline("u").unwrap();
+    assert_eq!(view(s).center, Vec2::new(10.0, 10.0));
+    assert!(near(twist_deg(s), 30.0));
+    s.cmdline("u").unwrap();
+    assert_eq!(view(s).twist, 0.0);
+    // Nothing left to undo: still at the option prompt.
+    s.cmdline("u").unwrap();
+    assert_eq!(prompt(s), OPTION);
+}
+
+#[test]
+fn selected_objects_are_the_preview_set() {
+    let mut s = session();
+    let line = s.doc().unwrap().model.iter().next().map(|e| e.handle).unwrap();
+    s.execute("line", &json!({ "points": [[0, 10], [10, 10]] })).unwrap();
+    s.cmdline("dview").unwrap();
+    s.input(Input::Pick(vec![line])).unwrap();
+    assert_eq!(prompt(&s), SELECT);
+    s.cmdline("").unwrap();
+    assert_eq!(prompt(&s), OPTION);
+    let only = s.display_only().unwrap();
+    assert_eq!(only.handles, vec![line]);
+    assert!(only.extra.is_empty(), "no sample house with a selection");
+    // Picked at the prompt, the objects don't stay selected.
+    assert!(s.selection().is_empty());
+    // Escape ends it too, and the drawing shows again.
+    s.input(Input::Cancel).unwrap();
+    assert!(s.current_prompt().is_none());
+    assert!(s.display_only().is_none());
+}
+
+#[test]
+fn a_dviewblock_of_the_drawings_own_is_previewed() {
+    let mut s = session();
+    s.execute("circle", &json!({ "center": [0.5, 0.5], "radius": 0.5 })).unwrap();
+    let c = s.doc().unwrap().model.iter().last().map(|e| e.handle).unwrap();
+    s.execute("block", &json!({ "name": "DVIEWBLOCK", "base": [0, 0], "handles": [c.hex()], "keep": "delete" })).unwrap();
+    s.cmdline("dview").unwrap();
+    s.cmdline("").unwrap();
+    let only = s.display_only().unwrap();
+    assert_eq!(only.extra.len(), 1);
+    match &only.extra[0].kind {
+        EntityKind::Insert(i) => {
+            assert_eq!(i.block, "DVIEWBLOCK");
+            // Scaled from its 1 by 1 unit area to half the view's height.
+            assert!(near(i.scale.x, 10.0) && near(i.scale.y, 10.0));
+        }
+        k => panic!("{k:?}"),
+    }
+    s.cmdline("").unwrap();
+}
+
+/// A layout with one viewport, `(session, viewport handle)`.
+fn layout_session() -> (Session, Handle) {
+    let mut s = session();
+    s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap();
+    let r = s.execute("mview", &json!({ "p1": [20, 20], "p2": [220, 120] })).unwrap();
+    let h = Handle::parse_hex(r["viewports"][0].as_str().unwrap()).unwrap();
+    (s, h)
+}
+
+fn vp(s: &Session, h: Handle) -> Viewport {
+    match &s.doc().unwrap().entity(h).unwrap().kind {
+        EntityKind::Viewport(v) => v.clone(),
+        _ => panic!("not a viewport"),
+    }
+}
+
+#[test]
+fn on_a_layout_sheet_it_is_not_available() {
+    let (mut s, _) = layout_session();
+    assert_eq!(s.execute("dview", &json!({ "twist": 10 })).unwrap_err().to_string(), PAPER);
+    assert_eq!(s.cmdline("dview").unwrap_err().to_string(), PAPER);
+    assert!(s.current_prompt().is_none());
+    // view.set can't turn the sheet either; an untwisted view is fine.
+    assert_eq!(s.execute("view.set", &json!({ "center": [0, 0], "height": 5, "twist": 15 })).unwrap_err().to_string(), PAPER);
+    s.execute("view.set", &json!({ "center": [0, 0], "height": 5 })).unwrap();
+}
+
+#[test]
+fn inside_an_active_viewport_it_twists_that_viewport_as_one_undo_step() {
+    let (mut s, h) = layout_session();
+    s.execute("mspace", &json!({ "handle": h.hex() })).unwrap();
+    let undo = s.state().unwrap().undo.len();
+    let pv = s.state().unwrap().paper_view();
+    s.cmdline("dview").unwrap();
+    assert_eq!(prompt(&s), SELECT);
+    s.cmdline("").unwrap();
+    s.cmdline("tw").unwrap();
+    s.cmdline("30").unwrap();
+    // The viewport entity carries the twist, and the model view inside it is turned by it.
+    assert!(near(vp(&s, h).twist.to_degrees(), 30.0));
+    assert!(near(twist_deg(&s), 30.0));
+    // The sheet itself is not turned.
+    assert_eq!(s.state().unwrap().paper_view(), pv);
+    s.cmdline("tw").unwrap();
+    s.cmdline("50").unwrap();
+    s.cmdline("").unwrap();
+    assert!(s.current_prompt().is_none());
+    assert!(near(vp(&s, h).twist.to_degrees(), 50.0));
+    // One undo step for the whole DVIEW, which turns the viewport back.
+    assert_eq!(s.state().unwrap().undo.len(), undo + 1);
+    s.execute("undo", &json!({})).unwrap();
+    assert_eq!(vp(&s, h).twist, 0.0);
+
+    // The JSON form and view.set twist the viewport the same way, each one undo step.
+    s.execute("dview", &json!({ "twist": -90 })).unwrap();
+    assert!(near(vp(&s, h).twist.to_degrees(), 270.0));
+    assert_eq!(s.state().unwrap().undo.len(), undo + 1);
+    let v = view(&s);
+    s.execute("view.set", &json!({ "center": [v.center.x, v.center.y], "height": v.height, "twist": 15 })).unwrap();
+    assert!(near(vp(&s, h).twist.to_degrees(), 15.0));
+    assert_eq!(s.state().unwrap().undo.len(), undo + 2);
+    // Setting a view without a twist keeps the viewport's.
+    s.execute("view.set", &json!({ "center": [v.center.x, v.center.y], "height": v.height })).unwrap();
+    assert!(near(vp(&s, h).twist.to_degrees(), 15.0));
+    assert_eq!(s.state().unwrap().undo.len(), undo + 2);
+
+    // Back on the sheet, DVIEW is not available again.
+    s.execute("pspace", &json!({})).unwrap();
+    assert_eq!(s.cmdline("dview").unwrap_err().to_string(), PAPER);
+}
+
+#[test]
+fn a_locked_viewport_keeps_its_twist() {
+    let (mut s, h) = layout_session();
+    s.doc_mut()
+        .unwrap()
+        .modify_entity(h, |e| {
+            if let EntityKind::Viewport(v) = &mut e.kind {
+                v.locked = true;
+            }
+        })
+        .unwrap();
+    s.execute("mspace", &json!({ "handle": h.hex() })).unwrap();
+    let undo = s.state().unwrap().undo.len();
+    assert!(s.execute("dview", &json!({ "twist": 30 })).is_err());
+    let v = view(&s);
+    assert!(s.execute("view.set", &json!({ "center": [v.center.x, v.center.y], "height": v.height, "twist": 30 })).is_err());
+    assert_eq!(vp(&s, h).twist, 0.0);
+    assert_eq!(s.state().unwrap().undo.len(), undo);
+    // A view with the twist it already has is fine.
+    s.execute("view.set", &json!({ "center": [v.center.x, v.center.y], "height": v.height })).unwrap();
+}
+
+#[test]
+fn escape_inside_an_active_viewport_keeps_the_twist_as_one_undo_step() {
+    let (mut s, h) = layout_session();
+    s.execute("mspace", &json!({ "handle": h.hex() })).unwrap();
+    let undo = s.state().unwrap().undo.len();
+    for l in ["dview", "", "tw", "30"] {
+        s.cmdline(l).unwrap();
+    }
+    s.input(Input::Cancel).unwrap();
+    assert!(s.current_prompt().is_none());
+    assert!(near(vp(&s, h).twist.to_degrees(), 30.0));
+    assert_eq!(s.state().unwrap().undo.len(), undo + 1);
+    s.execute("undo", &json!({})).unwrap();
+    assert_eq!(vp(&s, h).twist, 0.0);
+}
+
+#[test]
+fn the_view_inside_a_twisted_viewport_maps_the_screen_like_the_sheet() {
+    let (mut s, h) = layout_session();
+    s.execute("mspace", &json!({ "handle": h.hex() })).unwrap();
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    let st = s.state().unwrap();
+    let (vpe, pv, v) = (vp(&s, h), st.paper_view(), st.view());
+    // The model view's centre is the model point at the sheet's view centre.
+    assert!((vpe.model_to_paper(v.center) - pv.center).len() < 1e-9);
+    assert!(near(v.twist, vpe.twist));
+    // Panning the view inside the viewport moves its model view, keeping the twist.
+    let moved = View { center: v.center + Vec2::new(5.0, -2.0), ..v };
+    s.state_mut().unwrap().set_view(moved);
+    let after = view(&s);
+    assert!((after.center - moved.center).len() < 1e-9, "{after:?}");
+    assert!(near(after.twist, vpe.twist));
+    assert_eq!(s.state().unwrap().paper_view(), pv);
+    // ZOOM Extents fits the turned box of the drawing in the viewport.
+    s.execute("zoom", &json!({ "mode": "extents" })).unwrap();
+    assert!(near(view(&s).twist, vpe.twist));
+}
+
+#[test]
+fn a_viewport_twist_survives_a_dxf_round_trip() {
+    let (mut s, h) = layout_session();
+    s.execute("mspace", &json!({ "handle": h.hex() })).unwrap();
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    let dxf = cadcraft_io::write_dxf(s.doc().unwrap());
+    let back = cadcraft_io::read_dxf(dxf.as_bytes()).unwrap();
+    let twists: Vec<f64> = back
+        .layouts
+        .iter()
+        .flat_map(|l| l.entities.iter())
+        .filter_map(|e| match &e.kind {
+            EntityKind::Viewport(v) if v.id != 1 => Some(v.twist.to_degrees()),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(twists.len(), 1);
+    assert!((twists[0] - 30.0).abs() < 1e-9, "{twists:?}");
+}
+
+#[test]
+fn a_view_saved_in_a_twisted_viewport_restores_its_twist_as_one_undo_step() {
+    let (mut s, h) = layout_session();
+    s.execute("mspace", &json!({ "handle": h.hex() })).unwrap();
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    s.execute("view", &json!({ "option": "save", "name": "Turned" })).unwrap();
+    let saved = s.doc().unwrap().views.iter().find(|v| v.name == "Turned").map(|v| v.twist.to_degrees()).unwrap();
+    assert!(near(saved, 30.0), "saved twist {saved}");
+    let center = vp(&s, h).view_center;
+    s.execute("dview", &json!({ "twist": 0 })).unwrap();
+    s.execute("view.set", &json!({ "center": [80, 40], "height": 3 })).unwrap();
+    let undo = s.state().unwrap().undo.len();
+    s.execute("view", &json!({ "option": "restore", "name": "Turned" })).unwrap();
+    assert!(near(vp(&s, h).twist.to_degrees(), 30.0), "viewport twist {}", vp(&s, h).twist.to_degrees());
+    assert!(near(twist_deg(&s), 30.0));
+    assert!((vp(&s, h).view_center - center).len() < 1e-6, "{:?} vs {center:?}", vp(&s, h).view_center);
+    // The viewport's twist changed: one undo step, which turns it back.
+    assert_eq!(s.state().unwrap().undo.len(), undo + 1);
+    s.execute("undo", &json!({})).unwrap();
+    assert_eq!(vp(&s, h).twist, 0.0);
+}
+
+#[test]
+fn undoing_a_drawing_change_keeps_the_untiled_twist_saved() {
+    let mut s = session();
+    s.execute("line", &json!({ "points": [[0, 10], [5, 10]] })).unwrap();
+    // A Model tab twist is a view change, not an undo step.
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    s.execute("undo", &json!({})).unwrap();
+    assert!(near(twist_deg(&s), 30.0));
+    let saved = |s: &Session| s.doc().unwrap().vports.iter().find(|c| c.is_active()).and_then(|c| c.tiles.first()).map(|t| t.twist.to_degrees());
+    assert!(saved(&s).is_some_and(|t| near(t, 30.0)), "{:?}", saved(&s));
+    s.execute("redo", &json!({})).unwrap();
+    assert!(saved(&s).is_some_and(|t| near(t, 30.0)), "{:?}", saved(&s));
+}
+
+#[test]
+fn a_leftward_drag_on_a_turned_screen_is_a_crossing_window() {
+    let mut s = session();
+    let r = s.execute("line", &json!({ "points": [[200, 0], [260, 0]] })).unwrap();
+    let line = Handle::parse_hex(r["handles"][0].as_str().unwrap()).unwrap();
+    s.execute("dview", &json!({ "twist": 180 })).unwrap();
+    // Turned half way round, a drag towards +X in the drawing runs leftwards on screen.
+    assert!(s.window_is_crossing(Vec2::new(210.0, -5.0), Vec2::new(230.0, 5.0)));
+    assert!(!s.window_is_crossing(Vec2::new(230.0, -5.0), Vec2::new(210.0, 5.0)));
+    // A crossing window takes the line it only partly covers.
+    s.idle_click(Vec2::new(210.0, -5.0), false).unwrap();
+    s.idle_click(Vec2::new(230.0, 5.0), false).unwrap();
+    assert_eq!(s.selection(), vec![line]);
+}

crates/engine/tests/image_attach.rs

@@ -0,0 +1,376 @@
+//! Raster images (#956): IMAGEATTACH from a file and from handed-over bytes, the pixels loaded
+//! again when the drawing is reopened, a missing file left as a frame, and bad input refused.
+
+use std::path::{Path, PathBuf};
+
+use cadcraft_engine::Session;
+use cadcraft_engine::cmd::file::{IoHooks, base64_encode, set_image_decoder, set_io};
+use cadcraft_engine::doc::{Drawing, EntityKind, Image, Raster};
+use serde_json::{Value, json};
+
+fn hooks() {
+    set_io(IoHooks {
+        read: |b, name| cadcraft_io::read(b, name).map_err(|e| e.to_string()),
+        write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()),
+        plot: None,
+    });
+    set_image_decoder(|b| cadcraft_io::raster::decode(b).map_err(|e| e.to_string()));
+}
+
+/// A fresh folder for one test.
+fn folder(tag: &str) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!("cadcraft-image-{}-{tag}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+/// A PNG file of 4 x 2 pixels.
+fn png() -> Vec<u8> {
+    let px: Vec<u8> = (0..8u8).flat_map(|i| [i * 30, 255 - i * 30, 7, 255]).collect();
+    cadcraft_io::raster::encode_png(&Raster::new(4, 2, px).unwrap()).unwrap()
+}
+
+fn images(s: &Session) -> Vec<Image> {
+    let d = s.doc().unwrap();
+    d.model.iter().filter_map(|e| if let EntityKind::Image(i) = &e.kind { Some(i.clone()) } else { None }).collect()
+}
+
+fn open(s: &mut Session, path: &Path) {
+    s.execute("open", &json!({ "path": path.to_string_lossy() })).unwrap();
+}
+
+fn listed(s: &mut Session) -> Value {
+    s.execute("image", &json!({})).unwrap()["images"].clone()
+}
+
+#[test]
+fn attach_from_bytes_places_the_image() {
+    hooks();
+    let mut s = Session::new();
+    let r = s.execute("imageattach", &json!({ "path": "maps/site.png", "data": base64_encode(&png()), "at": [10, 20], "width": 100 })).unwrap();
+    assert_eq!((r["name"].as_str(), r["pixels"].clone(), r["size"].clone()), (Some("site"), json!([4.0, 2.0]), json!([100.0, 50.0])));
+    let i = images(&s).pop().unwrap();
+    assert_eq!((i.insert.x, i.insert.y, i.u.x, i.u.y, i.v.x, i.v.y), (10.0, 20.0, 25.0, 0.0, 0.0, 25.0));
+    assert_eq!((i.size.x, i.size.y, i.path.as_str(), i.name.as_str()), (4.0, 2.0, "maps/site.png", "site"));
+    assert_eq!(s.doc().unwrap().rasters.get("maps/site.png").map(|r| (r.width(), r.height())), Some((4, 2)));
+    let l = listed(&mut s);
+    assert_eq!((l[0]["status"].as_str(), l[0]["references"].as_u64(), l[0]["pixels"].clone()), (Some("Loaded"), Some(1), json!([4, 2])));
+
+    // A second reference to the same file shares the definition and the pixels; another file
+    // with the same file name gets its own name.
+    s.execute("imageattach", &json!({ "path": "maps/site.png", "at": [200, 0], "rotation": 90, "scale": 8 })).unwrap();
+    let r = s.execute("attach", &json!({ "path": "other/site.png", "data": base64_encode(&png()) })).unwrap();
+    assert_eq!(r["name"], "site_2");
+    let all = images(&s);
+    assert_eq!(all.len(), 3);
+    assert_eq!(all[1].name, "site");
+    assert!((all[1].u.x).abs() < 1e-12 && (all[1].u.y - 2.0).abs() < 1e-12 && (all[1].v.x + 2.0).abs() < 1e-12, "{:?}", all[1]);
+    assert_eq!(listed(&mut s)[0]["references"], 2);
+
+    // Undo takes the reference away; the drawing draws with its pixels.
+    s.execute("undo", &json!({})).unwrap();
+    assert_eq!(images(&s).len(), 2);
+    let list = cadcraft_engine::render::build(s.doc().unwrap(), &cadcraft_engine::doc::Space::Model, &cadcraft_engine::render::Options::default());
+    assert_eq!(list.images.len(), 2);
+}
+
+#[test]
+fn a_file_is_found_next_to_the_drawing_and_loaded_again_on_open() {
+    hooks();
+    let dir = folder("file");
+    std::fs::write(dir.join("map.png"), png()).unwrap();
+    let host = dir.join("host.dxf");
+    std::fs::write(&host, cadcraft_io::write(&Drawing::new_metric(), "host.dxf").unwrap()).unwrap();
+    let mut s = Session::new();
+    open(&mut s, &host);
+    let r = s.execute("imageattach", &json!({ "path": "map.png" })).unwrap();
+    assert_eq!(r["size"], json!([1.0, 0.5]), "one drawing unit wide by default");
+    s.execute("qsave", &json!({})).unwrap();
+
+    // Reopened: the pixels come back from the file.
+    let mut s = Session::new();
+    open(&mut s, &host);
+    assert_eq!(images(&s).len(), 1);
+    assert!(s.doc().unwrap().rasters.get("map.png").is_some());
+    assert!(!s.state().unwrap().is_dirty(), "loading images is not a change");
+    let l = listed(&mut s);
+    assert_eq!(l[0]["status"], "Loaded");
+    assert!(l[0]["foundAt"].as_str().is_some_and(|f| f.ends_with("map.png")));
+
+    // The file gone: the drawing still opens, says so, and keeps the reference.
+    std::fs::remove_file(dir.join("map.png")).unwrap();
+    let mut s = Session::new();
+    open(&mut s, &host);
+    assert_eq!(images(&s).len(), 1);
+    assert!(s.doc().unwrap().rasters.get("map.png").is_none());
+    assert!(s.log.iter().any(|l| l.contains("map.png") && l.contains("file not found")), "{:?}", s.log);
+    assert_eq!(listed(&mut s)[0]["status"], "Not Found");
+
+    // A file that is not an image is reported the same way.
+    std::fs::write(dir.join("map.png"), b"not an image").unwrap();
+    let mut s = Session::new();
+    open(&mut s, &host);
+    assert!(s.doc().unwrap().rasters.get("map.png").is_none());
+    assert!(s.log.iter().any(|l| l.contains("map.png")), "{:?}", s.log);
+    assert_eq!(listed(&mut s)[0]["status"], "Not loaded");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn bad_input_is_refused_and_changes_nothing() {
+    hooks();
+    let mut s = Session::new();
+    let data = base64_encode(&png());
+    for p in [
+        json!({}),
+        json!({ "path": "  " }),
+        json!({ "path": "nowhere/missing.png" }),
+        json!({ "path": "a.png", "data": "***" }),
+        json!({ "path": "a.png", "data": 5 }),
+        json!({ "path": "a.png", "data": base64_encode(b"plain text") }),
+        json!({ "path": "a.png", "data": data, "scale": 0 }),
+        json!({ "path": "a.png", "data": data, "width": -3 }),
+        json!({ "path": "a.png", "data": data, "width": "wide" }),
+        json!({ "path": "a.png", "data": data, "width": 1e-320 }),
+        json!({ "path": "x".repeat(5000), "data": data }),
+    ] {
+        assert!(s.execute("imageattach", &p).is_err(), "{p}");
+    }
+    assert!(images(&s).is_empty());
+    assert!(s.execute("attach", &json!({ "path": "plan.pdf" })).unwrap_err().to_string().contains("not available yet"));
+    assert_eq!(listed(&mut s), json!([]));
+}
+
+#[test]
+fn an_image_among_many_objects_keeps_its_pixels() {
+    // More objects than one build task takes: the display list is built in parts and joined,
+    // and the image must still point at its own pixels.
+    hooks();
+    let mut s = Session::new();
+    for i in 0..700 {
+        s.execute("line", &json!({ "points": [[i, 0], [i, 1]] })).unwrap();
+    }
+    s.execute("imageattach", &json!({ "path": "a.png", "data": base64_encode(&png()), "at": [0, 5], "width": 4 })).unwrap();
+    for i in 0..700 {
+        s.execute("line", &json!({ "points": [[i, 2], [i, 3]] })).unwrap();
+    }
+    s.execute("imageattach", &json!({ "path": "b.png", "data": base64_encode(&png()), "at": [10, 5], "width": 8 })).unwrap();
+    let list = cadcraft_engine::render::build(s.doc().unwrap(), &cadcraft_engine::doc::Space::Model, &cadcraft_engine::render::Options::default());
+    let widths: Vec<f64> = list
+        .prims
+        .iter()
+        .filter_map(|p| match p.kind {
+            cadcraft_engine::render::Kind::Image { index } => list.images.get(index as usize).map(|i| i.right.x * 4.0),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(widths, [4.0, 8.0]);
+}
+
+fn drawn_images(s: &Session) -> usize {
+    cadcraft_engine::render::build(s.doc().unwrap(), &cadcraft_engine::doc::Space::Model, &cadcraft_engine::render::Options::default()).images.len()
+}
+
+#[test]
+fn editing_commands_work_on_images_and_undo_keeps_the_pixels() {
+    hooks();
+    let mut s = Session::new();
+    let r = s.execute("imageattach", &json!({ "path": "a.png", "data": base64_encode(&png()), "at": [10, 0], "width": 4 })).unwrap();
+    let h = r["handle"].as_str().unwrap().to_string();
+
+    // Move, then a quarter turn about the origin: the corner and both axes follow.
+    s.execute("move", &json!({ "handles": [h], "delta": [0, 5] })).unwrap();
+    s.execute("rotate", &json!({ "handles": [h], "base": [0, 0], "angle": 90 })).unwrap();
+    let i = images(&s).pop().unwrap();
+    let close = |a: f64, b: f64| (a - b).abs() < 1e-9;
+    assert!(close(i.insert.x, -5.0) && close(i.insert.y, 10.0), "{i:?}");
+    assert!(close(i.u.x, 0.0) && close(i.u.y, 1.0) && close(i.v.x, -1.0) && close(i.v.y, 0.0), "{i:?}");
+    assert_eq!(drawn_images(&s), 1);
+
+    // A copy is a second reference to the same file.
+    s.execute("copy", &json!({ "handles": [h], "delta": [20, 0] })).unwrap();
+    assert_eq!((images(&s).len(), drawn_images(&s)), (2, 2));
+    assert_eq!(listed(&mut s)[0]["references"], 2);
+    assert_eq!(listed(&mut s).as_array().map(Vec::len), Some(1));
+
+    // Scaled about its corner: twice the size, still the same pixels.
+    s.execute("scale", &json!({ "handles": [h], "base": [-5, 10], "factor": 2 })).unwrap();
+    let i = images(&s).into_iter().find(|i| close(i.insert.x, -5.0)).unwrap();
+    assert!(close(i.u.y, 2.0) && close(i.size.x, 4.0), "{i:?}");
+
+    // Erased, then brought back by undo, with its picture; redo erases again.
+    s.execute("erase", &json!({ "handles": [h] })).unwrap();
+    assert_eq!((images(&s).len(), drawn_images(&s)), (1, 1));
+    s.execute("undo", &json!({})).unwrap();
+    assert_eq!((images(&s).len(), drawn_images(&s)), (2, 2));
+    s.execute("redo", &json!({})).unwrap();
+    assert_eq!(images(&s).len(), 1);
+
+    // Everything undone: no image, and nothing left to draw.
+    for _ in 0..10 {
+        let _ = s.execute("undo", &json!({}));
+    }
+    assert!(images(&s).is_empty());
+    assert_eq!(drawn_images(&s), 0);
+    assert_eq!(listed(&mut s), json!([]));
+}
+
+#[test]
+fn the_alias_and_the_command_line_reach_the_command() {
+    hooks();
+    assert_eq!(cadcraft_engine::cmd::resolve_alias("IAT"), "imageattach");
+    assert_eq!(cadcraft_engine::cmd::resolve_alias("im"), "image");
+    let spec = |id: &str| cadcraft_engine::cmd::command_specs().iter().find(|c| c.id == id).unwrap();
+    assert!(!spec("imageattach").params.is_empty() && !spec("image").params.is_empty());
+    // Typed without a file it has nothing to attach: an error, not a crash or a stuck prompt.
+    let mut s = Session::new();
+    let _ = s.cmdline("imageattach");
+    let _ = s.cmdline("");
+    s.cancel();
+    assert!(s.running.is_none() && images(&s).is_empty());
+}
+
+#[test]
+fn images_in_blocks_and_layouts_are_loaded_on_open() {
+    use cadcraft_engine::doc::geom::{Vec2, Vec3};
+    use cadcraft_engine::doc::{Block, Common, Entity, Space};
+    hooks();
+    let dir = folder("spaces");
+    std::fs::create_dir_all(dir.join("maps")).unwrap();
+    std::fs::write(dir.join("maps").join("a.png"), png()).unwrap();
+    std::fs::write(dir.join("b.png"), png()).unwrap();
+    let image = |path: &str, name: &str| {
+        EntityKind::Image(Image {
+            u: Vec3::new(1.0, 0.0, 0.0),
+            v: Vec3::new(0.0, 1.0, 0.0),
+            size: Vec2::new(4.0, 2.0),
+            path: path.into(),
+            name: name.into(),
+            ..Image::default()
+        })
+    };
+    let mut d = Drawing::new_metric();
+    // The same file in model space, in a block and on a layout; another only on the layout,
+    // saved with a folder that no longer exists (found by its name next to the drawing); and
+    // one that is nowhere.
+    d.add(&Space::Model, Common::default(), image("maps/a.png", "a")).unwrap();
+    let mut blk = Block::new("MAP");
+    let bh = d.new_handle();
+    blk.entities.push(Entity::new(bh, image("maps/a.png", "a")));
+    d.blocks.insert("MAP".into(), std::sync::Arc::new(blk));
+    let layout = Space::Paper("Layout1".into());
+    d.add(&layout, Common::default(), image("maps/a.png", "a")).unwrap();
+    d.add(&layout, Common::default(), image("C:\\old\\place\\b.png", "b")).unwrap();
+    d.add(&layout, Common::default(), image("gone.png", "gone")).unwrap();
+    let host = dir.join("host.dxf");
+    std::fs::write(&host, cadcraft_io::write(&d, "host.dxf").unwrap()).unwrap();
+
+    let mut s = Session::new();
+    open(&mut s, &host);
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.rasters.len(), 2, "each file once");
+    assert!(doc.rasters.get("maps/a.png").is_some() && doc.rasters.get("C:\\old\\place\\b.png").is_some());
+    assert!(!s.state().unwrap().is_dirty());
+    assert_eq!(s.log.iter().filter(|l| l.starts_with("Image ")).count(), 1, "{:?}", s.log);
+    let l = listed(&mut s);
+    let row = |name: &str| l.as_array().unwrap().iter().find(|r| r["name"] == name).cloned().unwrap();
+    assert_eq!((row("a")["status"].clone(), row("a")["references"].clone()), (json!("Loaded"), json!(3)));
+    assert_eq!(row("b")["status"], "Loaded");
+    assert_eq!(row("gone")["status"], "Not Found");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn a_drawing_opened_from_bytes_gets_its_pixels_handed_over() {
+    // The web app's way: no file system, the drawing arrives as bytes and so do the images.
+    use cadcraft_engine::doc::geom::{Vec2, Vec3};
+    use cadcraft_engine::doc::{Common, Space};
+    hooks();
+    let mut d = Drawing::new_metric();
+    let i = Image {
+        u: Vec3::new(1.0, 0.0, 0.0),
+        v: Vec3::new(0.0, 1.0, 0.0),
+        size: Vec2::new(4.0, 2.0),
+        path: "no-such-folder/web.png".into(),
+        name: "web".into(),
+        ..Image::default()
+    };
+    d.add(&Space::Model, Common::default(), EntityKind::Image(i)).unwrap();
+    let dxf = cadcraft_io::write(&d, "plan.dxf").unwrap();
+
+    let mut s = Session::new();
+    s.execute("open", &json!({ "data": base64_encode(&dxf), "name": "plan.dxf" })).unwrap();
+    assert_eq!(images(&s).len(), 1, "opened with its image reference");
+    assert!(s.doc().unwrap().rasters.is_empty());
+    assert!(s.log.iter().any(|l| l.contains("web.png")), "{:?}", s.log);
+    assert_eq!(listed(&mut s)[0]["status"], "Not Found");
+    assert_eq!(drawn_images(&s), 0);
+
+    // The same file handed over as bytes: the reference that was there draws too.
+    s.execute("imageattach", &json!({ "path": "no-such-folder/web.png", "data": base64_encode(&png()), "at": [10, 0] })).unwrap();
+    assert_eq!((images(&s).len(), drawn_images(&s)), (2, 2));
+    let l = listed(&mut s);
+    assert_eq!((l[0]["status"].clone(), l[0]["references"].clone(), l[0]["name"].clone()), (json!("Loaded"), json!(2), json!("web")));
+
+    // Saved and read back: the references are kept, the pixels are not in the file.
+    let bytes = cadcraft_io::write(s.doc().unwrap(), "plan.dxf").unwrap();
+    let back = cadcraft_io::read(&bytes, "plan.dxf").unwrap();
+    assert!(back.rasters.is_empty());
+    assert_eq!(back.model.iter().filter(|e| matches!(e.kind, EntityKind::Image(_))).count(), 2);
+}
+
+#[test]
+fn many_files_are_loaded_together_and_reported_in_order() {
+    // More files than loaders, with missing and unreadable ones among them: each good file is
+    // loaded, each bad one reported once, in the order the drawing uses them.
+    use cadcraft_engine::doc::geom::{Vec2, Vec3};
+    use cadcraft_engine::doc::{Common, Space};
+    hooks();
+    let dir = folder("many");
+    let mut d = Drawing::new_metric();
+    let mut expected_notes = Vec::new();
+    for n in 0..60u32 {
+        let name = format!("tile{n:02}.png");
+        match n % 10 {
+            3 => expected_notes.push(format!("Image {name}: file not found")),
+            7 => {
+                std::fs::write(dir.join(&name), b"not an image").unwrap();
+                expected_notes.push(format!("Image {name}: "));
+            }
+            _ => {
+                // A different width per file, so a mix-up would show.
+                let px = vec![200u8; (n as usize + 1) * 4];
+                std::fs::write(dir.join(&name), cadcraft_io::raster::encode_png(&Raster::new(n + 1, 1, px).unwrap()).unwrap()).unwrap();
+            }
+        }
+        let i = Image {
+            insert: Vec3::new(f64::from(n) * 3.0, 0.0, 0.0),
+            u: Vec3::new(1.0, 0.0, 0.0),
+            v: Vec3::new(0.0, 1.0, 0.0),
+            size: Vec2::new(f64::from(n + 1), 1.0),
+            path: name.clone(),
+            name: format!("tile{n:02}"),
+            ..Image::default()
+        };
+        d.add(&Space::Model, Common::default(), EntityKind::Image(i)).unwrap();
+    }
+    let host = dir.join("host.dxf");
+    std::fs::write(&host, cadcraft_io::write(&d, "host.dxf").unwrap()).unwrap();
+
+    for _ in 0..3 {
+        let mut s = Session::new();
+        open(&mut s, &host);
+        let doc = s.doc().unwrap();
+        assert_eq!(doc.rasters.len(), 48);
+        for n in 0..60u32 {
+            let loaded = doc.rasters.get(&format!("tile{n:02}.png")).map(|r| r.width());
+            assert_eq!(loaded, if matches!(n % 10, 3 | 7) { None } else { Some(n + 1) }, "tile {n}");
+        }
+        let notes: Vec<&String> = s.log.iter().filter(|l| l.starts_with("Image ")).collect();
+        assert_eq!(notes.len(), expected_notes.len(), "{notes:?}");
+        assert!(notes.iter().zip(&expected_notes).all(|(got, want)| got.starts_with(want.as_str())), "{notes:?}");
+        assert!(!s.state().unwrap().is_dirty());
+    }
+    let _ = std::fs::remove_dir_all(&dir);
+}

crates/engine/tests/image_decoder_panic.rs

@@ -0,0 +1,55 @@
+//! A raster image decoder that panics on a damaged file fails that image only (#956): the
+//! drawing it belongs to still opens, and IMAGEATTACH reports an error.
+
+use cadcraft_engine::Session;
+use cadcraft_engine::cmd::file::{IoHooks, base64_encode, set_image_decoder, set_io};
+use cadcraft_engine::doc::geom::{Vec2, Vec3};
+use cadcraft_engine::doc::{Common, Drawing, EntityKind, Image, Line, Space};
+use serde_json::json;
+
+fn hooks() {
+    set_io(IoHooks {
+        read: |b, name| cadcraft_io::read(b, name).map_err(|e| e.to_string()),
+        write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()),
+        plot: None,
+    });
+    set_image_decoder(|_| panic!("decoder bug"));
+}
+
+#[test]
+fn a_panicking_decoder_fails_the_image_not_the_drawing() {
+    hooks();
+    let dir = std::env::temp_dir().join(format!("cadcraft-image-panic-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("map.png"), b"anything").unwrap();
+    let mut d = Drawing::new_metric();
+    d.add(&Space::Model, Common::default(), EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(5.0, 5.0, 0.0) })).unwrap();
+    let i = Image {
+        u: Vec3::new(1.0, 0.0, 0.0),
+        v: Vec3::new(0.0, 1.0, 0.0),
+        size: Vec2::new(4.0, 2.0),
+        path: "map.png".into(),
+        name: "map".into(),
+        ..Image::default()
+    };
+    d.add(&Space::Model, Common::default(), EntityKind::Image(i)).unwrap();
+    let host = dir.join("host.dxf");
+    std::fs::write(&host, cadcraft_io::write(&d, "host.dxf").unwrap()).unwrap();
+
+    let mut s = Session::new();
+    s.execute("open", &json!({ "path": host.to_string_lossy() })).unwrap();
+    let doc = s.doc().unwrap();
+    assert_eq!(doc.model.len(), 2, "the drawing opened with everything in it");
+    assert!(doc.rasters.is_empty());
+    assert!(s.log.iter().any(|l| l.contains("map.png") && l.contains("damaged")), "{:?}", s.log);
+
+    let before = s.doc().unwrap().model.len();
+    let e = s.execute("imageattach", &json!({ "path": "other.png", "data": base64_encode(b"bytes") })).unwrap_err().to_string();
+    assert!(e.contains("damaged"), "{e}");
+    assert_eq!(s.doc().unwrap().model.len(), before);
+    // The session still works.
+    s.execute("line", &json!({ "points": [[0, 0], [1, 1]] })).unwrap();
+    assert_eq!(s.doc().unwrap().model.len(), before + 1);
+    let _ = std::fs::remove_dir_all(&dir);
+}

crates/engine/tests/insert_file.rs

@@ -40,6 +40,7 @@ fn read(bytes: &[u8], _name: &str) -> Result<Drawing, String> {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     };
     d.model.push(Entity::new(Handle(0x61), EntityKind::Insert(ins)));
     Ok(d)

crates/engine/tests/it/blockreplace.rs

@@ -40,6 +40,7 @@ fn drawing() -> (Session, Handle) {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     };
     s.doc_mut().unwrap().add(&Space::Paper("Layout1".into()), Common::default(), EntityKind::Insert(ins)).unwrap();
     (s, Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap())

crates/engine/tests/it/compare_export.rs

@@ -21,6 +21,7 @@ fn insert(block: &str) -> Insert {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     }
 }
 

crates/engine/tests/it/count.rs

@@ -20,6 +20,7 @@ fn insert(block: &str, x: f64, cols: u32, rows: u32) -> EntityKind {
         rows,
         col_spacing: 5.0,
         row_spacing: 5.0,
+        clip: None,
     })
 }
 

crates/engine/tests/it/followups_626.rs

@@ -135,9 +135,9 @@ fn mview_restore_puts_a_saved_configuration_on_a_layout() {
 fn mview_restore_ignores_unusable_tiles_from_files() {
     let (mut s, _) = two_tiles();
     let bad = [
-        VportTile { min: v(f64::NAN, 0.0), max: v(1.0, 1.0), center: v(0.0, 0.0), height: 1.0, aspect: 1.0 },
-        VportTile { min: v(0.5, 0.5), max: v(0.5, 0.9), center: v(0.0, 0.0), height: 1.0, aspect: 1.0 },
-        VportTile { min: v(-3.0, -3.0), max: v(9.0, 9.0), center: v(f64::INFINITY, 0.0), height: -1.0, aspect: f64::NAN },
+        VportTile { min: v(f64::NAN, 0.0), max: v(1.0, 1.0), center: v(0.0, 0.0), height: 1.0, aspect: 1.0, twist: 0.0 },
+        VportTile { min: v(0.5, 0.5), max: v(0.5, 0.9), center: v(0.0, 0.0), height: 1.0, aspect: 1.0, twist: 0.0 },
+        VportTile { min: v(-3.0, -3.0), max: v(9.0, 9.0), center: v(f64::INFINITY, 0.0), height: -1.0, aspect: f64::NAN, twist: 0.0 },
     ];
     if let Some(c) = s.doc_mut().unwrap().vports.iter_mut().find(|c| c.name == "Two") {
         c.tiles = bad.to_vec();

crates/engine/tests/it/main.rs

@@ -81,6 +81,7 @@ mod malformed_handles;
 mod matchprop;
 mod measure_distance_snapping;
 mod metric_linetypes;
+mod minsert;
 mod mirror_degenerate_line;
 mod mleader_content;
 mod mleader_remember;
@@ -164,6 +165,7 @@ mod viewport_clip;
 mod vplayer_prompts;
 mod vports;
 mod wipeout_grips;
+mod xclip;
 mod xdata_follows_entity;
 mod zoom_keywords;
 mod zoom_viewport;

crates/engine/tests/it/measure_distance_snapping.rs

@@ -27,6 +27,7 @@ fn drawing() -> (Drawing, Space) {
             layer_colors: Vec::new(),
             clip: None,
             on: true,
+            twist: 0.0,
         }),
     )
     .unwrap();
@@ -310,6 +311,7 @@ fn viewport_frozen_layers_apply_inside_nested_block_references() {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         })
     };
     let mut outer = Block::new("Outer");

crates/engine/tests/it/minsert.rs

@@ -0,0 +1,218 @@
+//! MINSERT, one block reference repeated in rows and columns, as AutoCAD 2024 makes and edits it
+//! (accoreconsole: the prompts, and `entget` of the reference after MINSERT, EXPLODE, MIRROR,
+//! SCALE and ROTATE).
+
+use std::f64::consts::PI;
+
+use cadcraft_engine::Session;
+use cadcraft_engine::doc::{EntityKind, Insert};
+use serde_json::{Value, json};
+
+fn handle(v: &Value) -> String {
+    v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap().to_owned()
+}
+
+/// A session with block B (a line from (0, 0) to (10, 0) and a circle of radius 3 round (5, 5),
+/// base point (0, 0)), after the AutoLISP `code`.
+fn run(code: &str) -> Session {
+    let mut s = Session::new();
+    let a = handle(&s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap());
+    let c = handle(&s.execute("circle", &json!({"center": [5, 5], "radius": 3})).unwrap());
+    s.execute("-block", &json!({"name": "B", "base": [0, 0], "handles": [a, c]})).unwrap();
+    s.cmdline(code).unwrap();
+    assert!(s.running.is_none(), "{}", s.prompt_text());
+    s
+}
+
+fn inserts(s: &Session) -> Vec<Insert> {
+    s.doc()
+        .unwrap()
+        .model
+        .iter()
+        .filter_map(|e| match &e.kind {
+            EntityKind::Insert(i) => Some(i.clone()),
+            _ => None,
+        })
+        .collect()
+}
+
+/// The grid as `entget` gives it: 70 columns, 71 rows, 44 between columns, 45 between rows (a
+/// plain reference, one row and one column, as 1/1/0/0).
+fn grid(i: &Insert) -> (u32, u32, f64, f64) {
+    (i.cols, i.rows, i.col_spacing, i.row_spacing)
+}
+
+fn near(a: f64, b: f64) -> bool {
+    (a - b).abs() < 1e-9
+}
+
+#[test]
+fn the_grid_is_stored_as_autocad_2024_stores_it() {
+    // (MINSERT's answers after the block name and insertion point, the grid AutoCAD stored.)
+    let cases = [
+        // One row: no distance between rows asked, and 0 stored for it.
+        ("1 \"\" 0 1 3 20.0", (3, 1, 20.0, 0.0)),
+        ("1 \"\" 0 3 1 15.0", (1, 3, 0.0, 15.0)),
+        // One of each: a plain reference.
+        ("1 \"\" 0 1 1", (1, 1, 0.0, 0.0)),
+        // A unit cell: its width between columns, its height between rows, signed.
+        ("1 \"\" 0 2 3 '(0.0 0.0) '(25.0 12.0)", (3, 2, 25.0, 12.0)),
+        ("1 \"\" 0 2 3 '(25.0 12.0) '(0.0 0.0)", (3, 2, -25.0, -12.0)),
+        // Its sides along the drawing's axes, the reference rotated or not.
+        ("1 \"\" 30 2 3 '(0.0 0.0) '(25.0 12.0)", (3, 2, 25.0, 12.0)),
+        // Typed distances are kept as typed, negative or 0 too.
+        ("1 \"\" 0 2 2 -15.0 -20.0", (2, 2, -20.0, -15.0)),
+        ("1 \"\" 0 2 2 0.0 20.0", (2, 2, 20.0, 0.0)),
+        // The distances are not scaled with the reference.
+        ("2 \"\" 30 2 2 15.0 20.0", (2, 2, 20.0, 15.0)),
+    ];
+    for (answers, want) in cases {
+        let s = run(&format!("(command \"_.MINSERT\" \"B\" '(20.0 10.0) {answers})"));
+        let [i] = inserts(&s).try_into().unwrap();
+        let got = grid(&i);
+        assert!(got.0 == want.0 && got.1 == want.1 && near(got.2, want.2) && near(got.3, want.3), "{answers}: {got:?}");
+        assert!(near(i.insert.x, 20.0) && near(i.insert.y, 10.0));
+    }
+    let s = run("(command \"_.MINSERT\" \"B\" '(20.0 10.0) 2 \"\" 30 2 2 15.0 20.0)");
+    let [i] = inserts(&s).try_into().unwrap();
+    assert!(near(i.scale.x, 2.0) && near(i.scale.y, 2.0) && near(i.rotation, PI / 6.0));
+}
+
+#[test]
+fn the_prompts_follow_autocad_2024() {
+    let mut s = Session::new();
+    let l = handle(&s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap());
+    s.execute("-block", &json!({"name": "B", "base": [0, 0], "handles": [l]})).unwrap();
+    // Each prompt, and what was written to the command line on the way to it.
+    let mut asked = Vec::new();
+    for input in ["minsert", "B", "20,10", "1", "", "0", "0", "2", "3", "x", "15", "20"] {
+        let logged = s.log.len();
+        s.cmdline(input).unwrap();
+        asked.extend(s.log.iter().skip(logged).filter(|l| l.starts_with("Requires")).cloned());
+        if let Some(p) = s.current_prompt() {
+            asked.push(p.display());
+        }
+    }
+    // The grid's prompts and messages are AutoCAD 2024's; the ones before are INSERT's.
+    assert_eq!(
+        asked,
+        [
+            "Enter block name or [?]:",
+            "Specify insertion point or [Basepoint/Scale/X/Y/Z/Rotate]:",
+            "Enter X scale factor, specify opposite corner or [Corner/XYZ] <1>:",
+            "Enter Y scale factor <use X scale factor>:",
+            "Specify rotation angle <0>:",
+            "Enter number of rows (---) <1>:",
+            "Requires an integer between 1 and 32767.",
+            "Enter number of rows (---) <1>:",
+            "Enter number of columns (|||) <1>:",
+            "Enter distance between rows or specify unit cell (---):",
+            "Requires a distance.",
+            "Enter distance between rows or specify unit cell (---):",
+            "Specify distance between columns (|||):",
+        ]
+    );
+    assert!(s.running.is_none());
+    let [i] = inserts(&s).try_into().unwrap();
+    assert_eq!(grid(&i), (3, 2, 20.0, 15.0));
+}
+
+#[test]
+fn counts_run_from_1_to_32767() {
+    // AutoCAD 2024: "Requires an integer between 1 and 32767."
+    let mut s = Session::new();
+    let l = handle(&s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap());
+    s.execute("-block", &json!({"name": "B", "base": [0, 0], "handles": [l]})).unwrap();
+    for input in ["minsert", "B", "0,0", "1", "", "0", "32768", "32767", "1", "2"] {
+        s.cmdline(input).unwrap();
+    }
+    assert!(s.running.is_none(), "{}", s.prompt_text());
+    assert_eq!(s.log.iter().filter(|l| l.starts_with("Requires an integer between 1 and 32767.")).count(), 1, "{:?}", s.log);
+    let [i] = inserts(&s).try_into().unwrap();
+    assert_eq!(grid(&i), (1, 32767, 0.0, 2.0));
+}
+
+#[test]
+fn attribute_values_are_asked_once_after_the_grid() {
+    let mut s = Session::new();
+    let l = handle(&s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap());
+    let a = handle(&s.execute("attdef", &json!({"tag": "TAG", "prompt": "Value", "at": [0, 2], "height": 1})).unwrap());
+    s.execute("-block", &json!({"name": "BA", "base": [0, 0], "handles": [l, a]})).unwrap();
+    for input in ["minsert", "BA", "0,700", "1", "", "0", "5", "4", "15", "20"] {
+        s.cmdline(input).unwrap();
+    }
+    // After the grid, with no "<>" for an empty default (AutoCAD 2024: "Value: hello").
+    assert_eq!(s.current_prompt().unwrap().display(), "Value:");
+    s.cmdline("hello").unwrap();
+    assert!(s.running.is_none());
+    let [i] = inserts(&s).try_into().unwrap();
+    assert_eq!(grid(&i), (4, 5, 20.0, 15.0));
+    assert_eq!(i.attribs.iter().map(|a| a.text.value.as_str()).collect::<Vec<_>>(), ["hello"]);
+}
+
+#[test]
+fn explode_leaves_a_grid_whole() {
+    let s = run("(progn (command \"_.MINSERT\" \"B\" '(20.0 10.0) 1 \"\" 0 2 2 15.0 20.0) (command \"_.EXPLODE\" (entlast) \"\"))");
+    let [i] = inserts(&s).try_into().unwrap();
+    assert_eq!(grid(&i), (2, 2, 20.0, 15.0));
+    assert_eq!(s.doc().unwrap().model.iter().count(), 1);
+    assert!(s.log.iter().any(|l| l.contains("The object is minserted.")), "{:?}", s.log);
+}
+
+#[test]
+fn edits_carry_the_grid_as_in_autocad_2024() {
+    let made = "(command \"_.MINSERT\" \"B\" '(20.0 10.0) 1 \"\" 0 2 2 15.0 20.0)";
+    // (the edit, the copy it leaves last: insertion point, X and Y scale, rotation, grid)
+    let cases = [
+        ("(command \"_.SCALE\" (entlast) \"\" '(20.0 10.0) 2)", ([20.0, 10.0], [2.0, 2.0], 0.0, (2, 2, 40.0, 30.0))),
+        ("(command \"_.ROTATE\" (entlast) \"\" '(20.0 10.0) 30)", ([20.0, 10.0], [1.0, 1.0], PI / 6.0, (2, 2, 20.0, 15.0))),
+        ("(command \"_.MOVE\" (entlast) \"\" '(20.0 10.0) '(25.0 13.0))", ([25.0, 13.0], [1.0, 1.0], 0.0, (2, 2, 20.0, 15.0))),
+        // Mirrored about the vertical through the insertion point, and about the horizontal: X
+        // scale -1, and the columns run the other way.
+        ("(command \"_.MIRROR\" (entlast) \"\" '(20.0 10.0) '(20.0 30.0) \"_N\")", ([20.0, 10.0], [-1.0, 1.0], 0.0, (2, 2, -20.0, 15.0))),
+        ("(command \"_.MIRROR\" (entlast) \"\" '(20.0 10.0) '(40.0 10.0) \"_N\")", ([20.0, 10.0], [-1.0, 1.0], PI, (2, 2, -20.0, 15.0))),
+    ];
+    for (edit, (at, scale, rot, want)) in cases {
+        let s = run(&format!("(progn {made} {edit})"));
+        let i = inserts(&s).pop().unwrap();
+        let got = grid(&i);
+        assert!(
+            near(i.insert.x, at[0])
+                && near(i.insert.y, at[1])
+                && near(i.scale.x, scale[0])
+                && near(i.scale.y, scale[1])
+                && near(i.rotation, rot)
+                && got.0 == want.0
+                && got.1 == want.1
+                && near(got.2, want.2)
+                && near(got.3, want.3),
+            "{edit}: {i:?}"
+        );
+    }
+}
+
+#[test]
+fn the_json_form_makes_the_same_grid() {
+    let mut s = Session::new();
+    let l = handle(&s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap());
+    s.execute("-block", &json!({"name": "B", "base": [0, 0], "handles": [l]})).unwrap();
+    s.execute("minsert", &json!({"name": "B", "at": [20, 10], "rows": 2, "columns": 3, "rowSpacing": 15, "columnSpacing": 20})).unwrap();
+    // One row: its distance is not kept.
+    s.execute("minsert", &json!({"name": "B", "at": [20, 100], "rows": 1, "columns": 3, "rowSpacing": 15, "columnSpacing": 20})).unwrap();
+    let got: Vec<_> = inserts(&s).iter().map(grid).collect();
+    assert_eq!(got, [(3, 2, 20.0, 15.0), (3, 1, 20.0, 0.0)]);
+    for bad in [
+        json!({"name": "B", "at": [0, 0], "rows": 0}),
+        json!({"name": "B", "at": [0, 0], "columns": 32768}),
+        json!({"name": "B", "at": [0, 0], "rows": 2.5}),
+        // A distance that is not a number is refused, not taken as 0.
+        json!({"name": "B", "at": [0, 0], "rows": 2, "rowSpacing": "15"}),
+        json!({"name": "B", "at": [0, 0], "columns": 2, "columnSpacing": true}),
+    ] {
+        assert!(s.execute("minsert", &bad).is_err(), "{bad}");
+    }
+    // A whole number written as 2.0 is a count; `explode` is INSERT's and leaves the grid made.
+    let r = s.execute("minsert", &json!({"name": "B", "at": [0, 200], "rows": 2.0, "rowSpacing": 15, "explode": true})).unwrap();
+    assert!(r["handle"].is_string(), "{r}");
+    assert_eq!(inserts(&s).last().map(grid), Some((1, 2, 0.0, 15.0)));
+}

crates/engine/tests/it/named_views.rs

@@ -46,7 +46,7 @@ fn typed_save_restore_list_delete() {
     // Saving is an undo step; a view change is not.
     set_view(&mut s, 0.0, 0.0, 500.0);
     typed(&mut s, &["view", "r", "front"]);
-    assert_eq!(view(&s), View { center: Vec2::new(10.0, 20.0), height: 30.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(10.0, 20.0), height: 30.0, twist: 0.0 });
     // Zoom Previous goes back to the view before the restore.
     s.execute("zoom.previous", &json!({})).unwrap();
     assert_eq!(view(&s).height, 500.0);
@@ -84,6 +84,20 @@ fn window_option_and_json_forms() {
     assert!(s.execute("view", &json!({ "option": "orthographic" })).is_err());
 }
 
+#[test]
+fn a_window_saved_in_a_twisted_view_restores_whole() {
+    let mut s = session();
+    s.execute("view.set", &json!({ "center": [0, 0], "height": 10, "twist": 45 })).unwrap();
+    s.execute("view", &json!({ "option": "window", "name": "Turned", "p1": [0, 0], "p2": [10, 10] })).unwrap();
+    let v = s.doc().unwrap().views.first().cloned().unwrap();
+    // A 10 x 10 world square seen at 45° is 10√2 across on screen.
+    assert!(close(v.width, 200f64.sqrt()) && close(v.height, 200f64.sqrt()), "{} x {}", v.width, v.height);
+    // Corners near the number limit overflow when turned: an error, and the saved view stays.
+    let huge = json!({ "option": "window", "name": "Turned", "p1": [1.4e308, 1.4e308], "p2": [1.5e308, 1.5e308] });
+    assert!(s.execute("view", &huge).is_err());
+    assert!(close(s.doc().unwrap().views.first().unwrap().width, 200f64.sqrt()));
+}
+
 #[test]
 fn layer_snapshot_restores_layers_and_the_setting_turns_it_off() {
     let mut s = session();
@@ -112,7 +126,7 @@ fn paper_space_view_switches_to_its_layout() {
     s.execute("layout.set", &json!({ "name": "Model" })).unwrap();
     s.execute("view", &json!({ "option": "restore", "name": "Sheet" })).unwrap();
     assert_eq!(s.layout_space(), Space::Paper(layout));
-    assert_eq!(view(&s), View { center: Vec2::new(5.0, 4.0), height: 6.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(5.0, 4.0), height: 6.0, twist: 0.0 });
 }
 
 #[test]
@@ -138,7 +152,7 @@ fn zoom_realtime_drags_and_enter_ends() {
     assert_eq!(view(&s).height, 100.0);
     // The JSON form zooms by a factor about the centre.
     s.execute("zoom.realtime", &json!({ "factor": 4 })).unwrap();
-    assert_eq!(view(&s), View { center: Vec2::ZERO, height: 25.0 });
+    assert_eq!(view(&s), View { center: Vec2::ZERO, height: 25.0, twist: 0.0 });
 }
 
 #[test]
@@ -158,10 +172,10 @@ fn zoom_dynamic_places_and_sizes_the_view_box() {
     assert!(close(v.height, 40.0), "{v:?}");
     // Zoom Previous skips the overview.
     s.execute("zoom.previous", &json!({})).unwrap();
-    assert_eq!(view(&s), View { center: Vec2::new(10.0, 10.0), height: 20.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(10.0, 10.0), height: 20.0, twist: 0.0 });
     // JSON: like Center.
     s.execute("zoom.dynamic", &json!({ "center": [1, 2], "height": 3 })).unwrap();
-    assert_eq!(view(&s), View { center: Vec2::new(1.0, 2.0), height: 3.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(1.0, 2.0), height: 3.0, twist: 0.0 });
 }
 
 #[test]

crates/engine/tests/it/purge_mlinestyles.rs

@@ -41,6 +41,7 @@ fn session() -> Session {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     };
     d.add(&Space::Model, Common::default(), EntityKind::Insert(ins)).unwrap();
     s

crates/engine/tests/it/refedit.rs

@@ -20,6 +20,7 @@ fn insert(s: &mut Session, block: &str, at: (f64, f64), scale: f64, rot_deg: f64
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     });
     s.doc_mut().unwrap().add(&Space::Model, Common::default(), kind).unwrap().hex()
 }
@@ -246,6 +247,7 @@ fn a_block_that_references_itself_in_a_file_does_not_hang() {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     });
     let d = s.doc_mut().unwrap();
     let hh = d.new_handle();

crates/engine/tests/it/snap_blocks.rs

@@ -31,6 +31,7 @@ fn insert(s: &mut Session, block: &str, at: (f64, f64), scale: (f64, f64), rotat
         rows: grid.1,
         col_spacing: grid.2,
         row_spacing: grid.3,
+        clip: None,
     });
     s.doc_mut().unwrap().add(&Space::Model, Common::default(), kind).unwrap().hex()
 }

crates/engine/tests/it/snap_tracking.rs

@@ -41,6 +41,7 @@ fn insert_block(s: &mut Session, name: &str, at: Vec2) -> String {
                 rows: 1,
                 col_spacing: 0.0,
                 row_spacing: 0.0,
+                clip: None,
             }),
         )
         .unwrap()

crates/engine/tests/it/vports.rs

@@ -46,15 +46,15 @@ fn split_activate_and_each_tile_keeps_its_view() {
     s.execute("-vports", &json!({ "option": "2", "arrangement": "vertical" })).unwrap();
     assert_eq!(rects(&s), vec![[0.0, 0.0, 0.5, 1.0], [0.5, 0.0, 1.0, 1.0]]);
     // Every new tile starts with the view that was split.
-    assert!(tiles(&s).iter().all(|t| t.view == View { center: Vec2::new(10.0, 10.0), height: 20.0 }));
+    assert!(tiles(&s).iter().all(|t| t.view == View { center: Vec2::new(10.0, 10.0), height: 20.0, twist: 0.0 }));
     let first = current(&s);
     let other = 1 - first;
     s.activate_tile(other).unwrap();
     assert_eq!(current(&s), other);
     s.execute("view.set", &json!({ "center": [50, 25], "height": 5 })).unwrap();
     s.execute("vports.activate", &json!({ "index": first + 1 })).unwrap();
-    assert_eq!(view(&s), View { center: Vec2::new(10.0, 10.0), height: 20.0 });
-    assert_eq!(tiles(&s)[other].view, View { center: Vec2::new(50.0, 25.0), height: 5.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(10.0, 10.0), height: 20.0, twist: 0.0 });
+    assert_eq!(tiles(&s)[other].view, View { center: Vec2::new(50.0, 25.0), height: 5.0, twist: 0.0 });
     // Switching tiles changes no drawing data; arranging them is an undo step.
     assert_eq!(s.state().unwrap().undo.len(), 2, "line + VPORTS");
     s.undo().unwrap();
@@ -82,7 +82,7 @@ fn typed_three_right_then_join_and_single() {
     s.click_tile(bottom).unwrap();
     assert!(s.running.is_none(), "{}", s.prompt_text());
     assert_eq!(rects(&s), vec![[0.0, 0.0, 0.5, 1.0], [0.5, 0.0, 1.0, 1.0]]);
-    assert_eq!(view(&s), View { center: Vec2::new(1.0, 2.0), height: 3.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(1.0, 2.0), height: 3.0, twist: 0.0 });
     // Tiles that don't make a rectangle can't be joined.
     s.execute("-vports", &json!({ "option": "3", "arrangement": "above" })).unwrap();
     let t = tiles(&s);
@@ -93,7 +93,7 @@ fn typed_three_right_then_join_and_single() {
     s.execute("view.set", &json!({ "center": [7, 7], "height": 7 })).unwrap();
     typed(&mut s, &["-vports", "si"]);
     assert!(tiles(&s).is_empty());
-    assert_eq!(view(&s), View { center: Vec2::new(7.0, 7.0), height: 7.0 });
+    assert_eq!(view(&s), View { center: Vec2::new(7.0, 7.0), height: 7.0, twist: 0.0 });
 }
 
 #[test]

crates/engine/tests/it/xclip.rs

@@ -0,0 +1,273 @@
+//! XCLIP and XCLIPFRAME: clipping block and xref references (gap F2).
+
+use cadcraft_engine::doc::{ClipBoundary, Common, EntityKind, Handle, Insert, Space};
+use cadcraft_engine::geom::{Vec2, Vec3};
+use cadcraft_engine::render::{self, Options};
+use cadcraft_engine::{Input, Session};
+use serde_json::{Value, json};
+
+fn h(v: &Value) -> String {
+    v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap().to_string()
+}
+
+fn insert(s: &mut Session, block: &str, at: (f64, f64), scale: f64, rot_deg: f64) -> String {
+    let kind = EntityKind::Insert(Insert {
+        block: block.into(),
+        insert: Vec3::new(at.0, at.1, 0.0),
+        scale: Vec3::new(scale, scale, scale),
+        rotation: rot_deg.to_radians(),
+        ..Insert::default()
+    });
+    s.doc_mut().unwrap().add(&Space::Model, Common::default(), kind).unwrap().hex()
+}
+
+/// Block B: a horizontal line (0,0)-(100,0) and a vertical one (50,-50)-(50,50); two references.
+fn setup() -> (Session, String, String) {
+    let mut s = Session::new();
+    let a = h(&s.execute("line", &json!({ "points": [[0, 0], [100, 0]] })).unwrap());
+    let b = h(&s.execute("line", &json!({ "points": [[50, -50], [50, 50]] })).unwrap());
+    s.execute("block", &json!({ "name": "B", "base": [0, 0], "handles": [a, b], "keep": "delete" })).unwrap();
+    let r1 = insert(&mut s, "B", (0.0, 0.0), 1.0, 0.0);
+    let r2 = insert(&mut s, "B", (1000.0, 0.0), 2.0, 90.0);
+    (s, r1, r2)
+}
+
+fn clip(s: &Session, hex: &str) -> Option<ClipBoundary> {
+    match &s.doc().unwrap().entity(Handle::parse_hex(hex).unwrap()).unwrap().kind {
+        EntityKind::Insert(i) => i.clip.clone(),
+        _ => None,
+    }
+}
+
+/// The x extent of what the drawing shows around reference 1 (x < 500).
+fn shown_x(s: &Session) -> (f64, f64) {
+    let list = render::build(s.doc().unwrap(), &Space::Model, &Options::default());
+    let xs: Vec<f64> = list.verts.iter().filter(|v| v.x < 500.0).map(|v| v.x).collect();
+    (xs.iter().copied().fold(f64::MAX, f64::min), xs.iter().copied().fold(f64::MIN, f64::max))
+}
+
+#[test]
+fn rectangular_clip_cuts_only_that_reference() {
+    let (mut s, r1, r2) = setup();
+    assert_eq!(shown_x(&s), (0.0, 100.0));
+    s.execute("setvar", &json!({ "name": "XCLIPFRAME", "value": 0 })).unwrap();
+    let out = s.execute("xclip", &json!({ "handle": r1, "rectangle": [[20, -10], [70, 10]] })).unwrap();
+    assert_eq!(out["option"], "new");
+    let c = clip(&s, &r1).unwrap();
+    assert!(c.enabled && !c.inverted && c.points.len() == 2);
+    let (lo, hi) = shown_x(&s);
+    assert!((lo - 20.0).abs() < 1e-9 && (hi - 70.0).abs() < 1e-9, "{lo} {hi}");
+    assert!(clip(&s, &r2).is_none(), "the other reference stays whole");
+    // The boundary follows its reference.
+    s.execute("move", &json!({ "handles": [r1], "delta": [5, 0] })).unwrap();
+    let (lo, hi) = shown_x(&s);
+    assert!((lo - 25.0).abs() < 1e-9 && (hi - 75.0).abs() < 1e-9, "{lo} {hi}");
+    // Its extents are the clipped part (ZOOM Extents).
+    let d = s.doc().unwrap();
+    let b = cadcraft_engine::doc::entity_bounds(d, d.entity(Handle::parse_hex(&r1).unwrap()).unwrap(), 0);
+    assert!((b.min.x - 25.0).abs() < 1e-9 && (b.max.x - 75.0).abs() < 1e-9 && b.max.y <= 10.0 + 1e-9, "{b:?}");
+    // Query reports it in drawing coordinates.
+    let q = s.execute("xclip", &json!({ "handle": r1, "option": "query" })).unwrap();
+    assert_eq!(q["clips"][0]["boundary"][0], json!([25.0, -10.0]));
+    // OFF shows everything, ON clips again, Delete removes it; undo brings it back.
+    s.execute("xclip", &json!({ "handle": r1, "option": "off" })).unwrap();
+    assert_eq!(shown_x(&s), (5.0, 105.0));
+    s.execute("xclip", &json!({ "handle": r1, "option": "on" })).unwrap();
+    assert!((shown_x(&s).0 - 25.0).abs() < 1e-9);
+    s.execute("xclip", &json!({ "handle": r1, "option": "delete" })).unwrap();
+    assert!(clip(&s, &r1).is_none());
+    s.execute("undo", &json!({})).unwrap();
+    assert!(clip(&s, &r1).is_some());
+}
+
+#[test]
+fn off_on_a_selection_with_an_unclipped_reference_changes_nothing() {
+    let (mut s, r1, r2) = setup();
+    s.execute("xclip", &json!({ "handle": r1, "rectangle": [[20, -10], [70, 10]] })).unwrap();
+    // r2 has no boundary: the command fails, and r1 keeps its clip on.
+    assert!(s.execute("xclip", &json!({ "handles": [r1, r2], "option": "off" })).is_err());
+    assert!(clip(&s, &r1).unwrap().enabled);
+    assert!(clip(&s, &r2).is_none());
+    // A reference named many times is turned off once, its boundary kept.
+    s.execute("xclip", &json!({ "handles": vec![r1.clone(); 1000], "option": "off" })).unwrap();
+    let c = clip(&s, &r1).unwrap();
+    assert!(!c.enabled && c.points.len() == 2);
+}
+
+#[test]
+fn a_clipped_reference_plots_its_contents_on_their_own_layers() {
+    let mut s = Session::new();
+    s.doc_mut().unwrap().layers.push(cadcraft_engine::doc::Layer { name: "Walls".into(), ..Default::default() });
+    let a = h(&s.execute("line", &json!({ "points": [[0, 0], [100, 0]] })).unwrap());
+    let b = h(&s.execute("line", &json!({ "points": [[50, -50], [50, 50]] })).unwrap());
+    s.doc_mut().unwrap().modify_entity(Handle::parse_hex(&a).unwrap(), |e| e.common.layer = "Walls".into()).unwrap();
+    s.execute("block", &json!({ "name": "B", "base": [0, 0], "handles": [a, b], "keep": "delete" })).unwrap();
+    let r = insert(&mut s, "B", (0.0, 0.0), 1.0, 0.0);
+    s.execute("setvar", &json!({ "name": "XCLIPFRAME", "value": 0 })).unwrap();
+    s.execute("xclip", &json!({ "handle": r, "rectangle": [[20, -10], [70, 10]] })).unwrap();
+    let d = s.doc().unwrap();
+    let index = |name: &str| d.layers.iter().position(|l| l.name == name).map(|i| i as u32);
+    let list = render::build_plot(d, &Space::Model, &Options::default());
+    assert_eq!(list.prim_layers.len(), list.prims.len());
+    // The horizontal line is on Walls, the vertical one (layer 0) takes the reference's layer.
+    assert!(list.prim_layers.contains(&index("Walls").unwrap()), "{:?}", list.prim_layers);
+    assert!(list.prim_layers.contains(&index("0").unwrap()), "{:?}", list.prim_layers);
+}
+
+#[test]
+fn extents_are_the_boundary_box_as_in_the_reference_app() {
+    let (mut s, r1, _) = setup();
+    let bounds = |s: &Session| {
+        let d = s.doc().unwrap();
+        cadcraft_engine::doc::entity_bounds(d, d.entity(Handle::parse_hex(&r1).unwrap()).unwrap(), 0)
+    };
+    // A boundary reaching past the block (0..100 x -50..50): its own box, not the overlap.
+    s.execute("xclip", &json!({ "handle": r1, "rectangle": [[50, -20], [150, 30]] })).unwrap();
+    let b = bounds(&s);
+    assert!((b.min - Vec2::new(50.0, -20.0)).len() < 1e-9 && (b.max - Vec2::new(150.0, 30.0)).len() < 1e-9, "{b:?}");
+    // One that misses the block entirely: still its box.
+    s.execute("xclip", &json!({ "handle": r1, "rectangle": [[200, 200], [300, 300]] })).unwrap();
+    let b = bounds(&s);
+    assert!((b.min - Vec2::new(200.0, 200.0)).len() < 1e-9 && (b.max - Vec2::new(300.0, 300.0)).len() < 1e-9, "{b:?}");
+}
+
+#[test]
+fn rotated_and_scaled_reference_gets_a_polygon_in_block_coordinates() {
+    let (mut s, _, r2) = setup();
+    // r2: scale 2, rotated 90 degrees at (1000, 0): the block's x axis points up.
+    s.execute("xclip", &json!({ "handle": r2, "rectangle": [[990, 10], [1010, 50]] })).unwrap();
+    let c = clip(&s, &r2).unwrap();
+    // A 90 degree rotation keeps the rectangle a rectangle: (5..25, -5..5) in the block.
+    let poly = c.polygon();
+    let xs: Vec<f64> = poly.iter().map(|p| p.x).collect();
+    assert!(xs.iter().any(|x| (x - 5.0).abs() < 1e-9) && xs.iter().any(|x| (x - 25.0).abs() < 1e-9), "{poly:?}");
+    // 30 degrees: kept as the four corners.
+    let r3 = insert(&mut s, "B", (2000.0, 0.0), 1.0, 30.0);
+    s.execute("xclip", &json!({ "handle": r3, "rectangle": [[1990, -10], [2010, 10]] })).unwrap();
+    assert_eq!(clip(&s, &r3).unwrap().points.len(), 4);
+}
+
+#[test]
+fn inverted_polygonal_and_polyline_boundaries() {
+    let (mut s, r1, _) = setup();
+    s.execute("setvar", &json!({ "name": "XCLIPFRAME", "value": 0 })).unwrap();
+    s.execute("xclip", &json!({ "handle": r1, "points": [[40, -10], [60, -10], [60, 10], [40, 10]], "invert": true })).unwrap();
+    assert!(clip(&s, &r1).unwrap().inverted);
+    let list = render::build(s.doc().unwrap(), &Space::Model, &Options::default());
+    // The middle of the horizontal line is hidden, both ends show.
+    assert!(!list.verts.iter().any(|v| v.x > 40.5 && v.x < 59.5 && v.y.abs() < 1e-9));
+    assert!(list.verts.iter().any(|v| v.x == 0.0) && list.verts.iter().any(|v| v.x == 100.0));
+    // A closed polyline as the boundary.
+    let pl = h(&s.execute("pline", &json!({ "vertices": [[10, -5], [30, -5], [30, 5], [10, 5]], "closed": true })).unwrap());
+    s.execute("xclip", &json!({ "handle": r1, "polyline": pl })).unwrap();
+    let c = clip(&s, &r1).unwrap();
+    assert!(!c.inverted && c.points.len() == 4);
+    // An open polyline is refused, a bad boundary changes nothing.
+    let open = h(&s.execute("pline", &json!({ "vertices": [[0, 0], [5, 5], [9, 0]] })).unwrap());
+    assert!(s.execute("xclip", &json!({ "handle": r1, "polyline": open })).is_err());
+    assert!(s.execute("xclip", &json!({ "handle": r1, "points": [[0, 0], [1, 1]] })).is_err());
+    assert!(s.execute("xclip", &json!({ "handle": r1, "rectangle": [[0, 0], [0, 10]] })).is_err());
+    assert_eq!(clip(&s, &r1), Some(c));
+    // Generate polyline makes the boundary an object.
+    let n = s.doc().unwrap().model.len();
+    let out = s.execute("xclip", &json!({ "handle": r1, "option": "polyline" })).unwrap();
+    assert_eq!(out["polylines"].as_array().unwrap().len(), 1);
+    assert_eq!(s.doc().unwrap().model.len(), n + 1);
+    // Clip depth has no effect in 2D.
+    assert_eq!(s.execute("xclip", &json!({ "handle": r1, "option": "clipdepth" })).unwrap()["ignored"], true);
+}
+
+#[test]
+fn hostile_params_never_panic() {
+    let (mut s, r1, _) = setup();
+    for p in [
+        json!({ "handle": r1, "points": "x" }),
+        json!({ "handle": r1, "points": [[1e308, 0], [-1e308, 0], [0, 1e308]] }),
+        json!({ "handle": r1, "rectangle": [[f64::MAX, 0]] }),
+        json!({ "handle": r1, "rectangle": 5 }),
+        json!({ "handle": r1, "polyline": "ZZZZ" }),
+        json!({ "handle": r1, "option": "bogus" }),
+        json!({ "handle": "nothex" }),
+        json!({ "handles": [] }),
+        json!({ "handle": r1, "points": vec![[0.0, 0.0]; 5000] }),
+    ] {
+        let _ = s.execute("xclip", &p);
+    }
+    assert!(s.execute("xclipframe", &json!({ "value": 7 })).is_err());
+    assert!(s.execute("xclip", &json!({ "handle": r1, "option": "on" })).is_err(), "no boundary to turn on");
+}
+
+#[test]
+fn typed_xclip_follows_the_prompts() {
+    let (mut s, r1, r2) = setup();
+    let pick = |hex: &str| Input::Pick(vec![Handle::parse_hex(hex).unwrap()]);
+    s.start("xclip").unwrap();
+    s.input(pick(&r1)).unwrap();
+    s.input(Input::Enter).unwrap();
+    assert!(s.prompt_text().contains("Enter clipping option"), "{}", s.prompt_text());
+    s.input(Input::Enter).unwrap(); // New
+    assert!(s.prompt_text().contains("Invert clip"), "{}", s.prompt_text());
+    s.input(Input::Keyword("Invert clip".into())).unwrap();
+    assert!(s.log.iter().any(|l| l.contains("Inside mode")));
+    s.input(Input::Keyword("Rectangular".into())).unwrap();
+    s.input(Input::Point(Vec2::new(10.0, -10.0))).unwrap();
+    s.input(Input::Point(Vec2::new(30.0, 10.0))).unwrap();
+    let c = clip(&s, &r1).unwrap();
+    assert!(c.inverted && c.points.len() == 2);
+    // Again on the clipped reference: "Delete old boundary(s)?", then a polygon.
+    s.cmdline("xclip").unwrap();
+    s.input(pick(&r1)).unwrap();
+    s.input(Input::Enter).unwrap();
+    s.cmdline("n").unwrap();
+    assert!(s.prompt_text().contains("Delete old boundary"), "{}", s.prompt_text());
+    s.cmdline("y").unwrap();
+    s.cmdline("p").unwrap();
+    for p in ["0,-5", "20,-5", "20,5"] {
+        s.cmdline(p).unwrap();
+    }
+    s.input(Input::Enter).unwrap();
+    let c = clip(&s, &r1).unwrap();
+    assert!(!c.inverted && c.points.len() == 3);
+    // OFF, then Delete on two references at once.
+    s.start("xclip").unwrap();
+    s.input(pick(&r1)).unwrap();
+    s.input(Input::Enter).unwrap();
+    s.cmdline("off").unwrap();
+    assert!(!clip(&s, &r1).unwrap().enabled);
+    s.execute("xclip", &json!({ "handle": r2, "rectangle": [[0, 0], [1, 1]] })).unwrap();
+    s.start("xclip").unwrap();
+    s.input(Input::Pick(vec![Handle::parse_hex(&r1).unwrap(), Handle::parse_hex(&r2).unwrap()])).unwrap();
+    s.input(Input::Enter).unwrap();
+    s.cmdline("d").unwrap();
+    assert!(clip(&s, &r1).is_none() && clip(&s, &r2).is_none());
+    // Delete with no boundary left says so and asks again.
+    s.start("xclip").unwrap();
+    s.input(pick(&r1)).unwrap();
+    s.input(Input::Enter).unwrap();
+    s.cmdline("d").unwrap();
+    assert!(s.log.iter().any(|l| l.contains("No clip boundary found.")), "{:?}", s.log);
+    assert!(s.prompt_text().contains("Enter clipping option"), "{}", s.prompt_text());
+    s.input(Input::Cancel).unwrap();
+    // XCLIPFRAME typed.
+    s.cmdline("xclipframe").unwrap();
+    s.cmdline("1").unwrap();
+    assert_eq!(s.execute("getvar", &json!({ "name": "XCLIPFRAME" })).unwrap()["value"], 1);
+}
+
+#[test]
+fn the_frame_shows_and_plots_as_xclipframe_says() {
+    let (mut s, r1, _) = setup();
+    s.execute("xclip", &json!({ "handle": r1, "rectangle": [[20, -10], [70, 10]] })).unwrap();
+    let frame_at = |s: &Session, plot: bool| {
+        let d = s.doc().unwrap();
+        let list =
+            if plot { render::build_plot(d, &Space::Model, &Options::default()) } else { render::build(d, &Space::Model, &Options::default()) };
+        list.verts.iter().any(|v| (v.y - 10.0).abs() < 1e-9 && (v.x - 20.0).abs() < 1e-9)
+    };
+    // Default 2: shown, not plotted.
+    assert!(frame_at(&s, false) && !frame_at(&s, true));
+    s.execute("xclipframe", &json!({ "value": 1 })).unwrap();
+    assert!(frame_at(&s, false) && frame_at(&s, true));
+    s.execute("xclipframe", &json!({ "value": 0 })).unwrap();
+    assert!(!frame_at(&s, false) && !frame_at(&s, true));
+}

crates/engine/tests/shx_beside_drawing.rs

@@ -0,0 +1,34 @@
+//! FF8: the SHX fonts a drawing's text styles name are found beside the drawing it opens. The
+//! font is compiled here from shape source written for the test.
+
+use cadcraft_engine::Session;
+use cadcraft_engine::cmd::file::{IoHooks, set_io};
+use cadcraft_engine::doc::{Drawing, TextStyle};
+use serde_json::json;
+
+#[test]
+fn opening_a_drawing_finds_the_shx_fonts_beside_it() {
+    set_io(IoHooks {
+        read: |b, name| cadcraft_io::read(b, name).map_err(|e| e.to_string()),
+        write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()),
+        plot: None,
+    });
+    let dir = std::env::temp_dir().join(format!("cadcraft-shx-beside-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let font = cadcraft_fonts::shx::compile("*0,4,beside\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n").unwrap();
+    std::fs::write(dir.join("cadcraft-beside-engine.shx"), font).unwrap();
+    let mut d = Drawing::new_imperial();
+    d.text_styles.push(TextStyle { name: "Beside".into(), font: "cadcraft-beside-engine.shx".into(), ..TextStyle::default() });
+    let path = dir.join("host.dxf");
+    std::fs::write(&path, cadcraft_io::write(&d, "host.dxf").unwrap()).unwrap();
+
+    assert!(!cadcraft_fonts::TextFont::resolve("cadcraft-beside-engine.shx").is_shx());
+    let mut s = Session::new();
+    s.execute("open", &json!({ "path": path.to_string_lossy() })).unwrap();
+    let style = s.doc().unwrap().text_style("Beside").cloned().unwrap();
+    let font = cadcraft_fonts::TextFont::resolve_style(&style.font, &style.big_font, style.vertical);
+    assert!(font.is_shx());
+    assert!((cadcraft_fonts::text_width(&font, "AA", 3.0, 1.0) - 6.0).abs() < 1e-9);
+    let _ = std::fs::remove_dir_all(&dir);
+}

crates/engine/tests/usage.rs

@@ -50,6 +50,7 @@ fn insert(handle: u64, block: &str, layer: &str) -> Entity {
             rows: 1,
             col_spacing: 0.0,
             row_spacing: 0.0,
+            clip: None,
         }),
     );
     e.common = Common { layer: layer.into(), ..Common::default() };

crates/engine/tests/view_twist.rs

@@ -0,0 +1,193 @@
+//! The view twist (VIEWTWIST): DVIEW TWist turns the Model tab's view, ZOOM Previous turns it
+//! back, each VPORTS tile keeps its own (DXF VPORT group 51), and VIEW Save/Restore keep it.
+
+use cadcraft_engine::geom::Vec2;
+use cadcraft_engine::{Session, View, sysvars};
+use serde_json::json;
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.viewport_px = (1200.0, 800.0);
+    s.execute("line", &json!({ "points": [[0, 0], [100, 50]] })).unwrap();
+    s.execute("view.set", &json!({ "center": [10, 10], "height": 20 })).unwrap();
+    s
+}
+
+fn typed(s: &mut Session, lines: &[&str]) {
+    for l in lines {
+        s.cmdline(l).unwrap();
+    }
+}
+
+fn view(s: &Session) -> View {
+    s.state().unwrap().view()
+}
+
+fn twist_deg(s: &Session) -> f64 {
+    view(s).twist.to_degrees()
+}
+
+fn near(a: f64, b: f64) -> bool {
+    (a - b).abs() < 1e-9
+}
+
+#[test]
+fn dview_twist_sets_viewtwist_and_zoom_previous_turns_it_back() {
+    let mut s = session();
+    assert_eq!(view(&s).twist, 0.0);
+    typed(&mut s, &["dview", "", "tw", "30", ""]);
+    assert!(near(twist_deg(&s), 30.0), "twist {}", twist_deg(&s));
+    let vt = sysvars::get(&s, "VIEWTWIST").and_then(|v| v.as_f64()).unwrap();
+    assert!(near(vt, 30.0), "VIEWTWIST {vt}");
+    // Only the twist changed; the view is not an undo step.
+    assert_eq!((view(&s).center, view(&s).height), (Vec2::new(10.0, 10.0), 20.0));
+    assert_eq!(s.state().unwrap().undo.len(), 1, "just the line");
+    // Zooming keeps the twist; ZOOM Previous steps back through it.
+    s.execute("zoom", &json!({ "mode": "in" })).unwrap();
+    assert!(near(twist_deg(&s), 30.0));
+    s.execute("zoom", &json!({ "mode": "previous" })).unwrap();
+    s.execute("zoom", &json!({ "mode": "previous" })).unwrap();
+    assert_eq!(view(&s).twist, 0.0);
+    assert!(sysvars::is_read_only("VIEWTWIST"));
+    // JSON form; negative angles wrap into 0..360.
+    s.execute("dview", &json!({ "twist": -90 })).unwrap();
+    assert!(near(twist_deg(&s), 270.0));
+    // The 3D options are not available yet; the command carries on.
+    typed(&mut s, &["dview", "", "ca", ""]);
+    assert!(s.current_prompt().is_none());
+    // Not in a layout.
+    let layout = s.doc().unwrap().layouts.first().map(|l| l.name.clone()).unwrap();
+    s.execute("layout.set", &json!({ "name": layout })).unwrap();
+    assert!(s.execute("dview", &json!({ "twist": 10 })).is_err());
+}
+
+const PAPER: &str = "This command is not available in Paper space.";
+
+#[test]
+fn dview_in_paper_space_says_it_is_not_available() {
+    let mut s = session();
+    let layout = s.doc().unwrap().layouts.first().map(|l| l.name.clone()).unwrap();
+    s.execute("layout.set", &json!({ "name": layout })).unwrap();
+    let e = s.execute("dview", &json!({ "twist": 10 })).unwrap_err();
+    assert_eq!(e.to_string(), PAPER);
+    // Typed, it is refused as it starts: no prompt is left open.
+    let e = s.cmdline("dview").unwrap_err();
+    assert_eq!(e.to_string(), PAPER);
+    assert!(s.current_prompt().is_none());
+    // view.set can't turn a layout's view either (an untwisted one is fine).
+    let e = s.execute("view.set", &json!({ "center": [0, 0], "height": 5, "twist": 15 })).unwrap_err();
+    assert_eq!(e.to_string(), PAPER);
+    s.execute("view.set", &json!({ "center": [0, 0], "height": 5 })).unwrap();
+    assert_eq!(view(&s).twist, 0.0);
+}
+
+#[test]
+fn a_single_untiled_view_keeps_its_twist_through_a_dxf_round_trip() {
+    let mut s = session();
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    assert!(s.model_tiles().len() <= 1, "untiled");
+    let dxf = cadcraft_io::write_dxf(s.doc().unwrap());
+    let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
+    let written = lines.windows(2).any(|w| w[0] == "51" && w[1].parse::<f64>().is_ok_and(|a| near(a, 30.0)));
+    assert!(written, "the lone *ACTIVE VPORT carries group 51");
+    let back = cadcraft_io::read_dxf(dxf.as_bytes()).unwrap();
+    let mut o = Session::new();
+    o.viewport_px = (1200.0, 800.0);
+    o.open_drawing(back.clone(), "single", None);
+    assert!(near(twist_deg(&o), 30.0), "twist {}", twist_deg(&o));
+    assert!(o.model_tiles().len() <= 1, "still untiled");
+    // And again: saved from the reopened session, it is still turned.
+    let again = cadcraft_io::read_dxf(cadcraft_io::write_dxf(o.doc().unwrap()).as_bytes()).unwrap();
+    let mut o2 = Session::new();
+    o2.viewport_px = (1200.0, 800.0);
+    o2.open_drawing(again, "again", None);
+    assert!(near(twist_deg(&o2), 30.0));
+    // Turned back (ZOOM Previous here), the drawing keeps no twist.
+    s.execute("zoom", &json!({ "mode": "previous" })).unwrap();
+    assert_eq!(view(&s).twist, 0.0);
+    let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
+    let mut o3 = Session::new();
+    o3.viewport_px = (1200.0, 800.0);
+    o3.open_drawing(back, "plain", None);
+    assert_eq!(view(&o3).twist, 0.0);
+}
+
+#[test]
+fn zoom_extents_fits_in_the_twisted_frame() {
+    let mut s = session();
+    s.execute("dview", &json!({ "twist": 90 })).unwrap();
+    s.execute("zoom", &json!({ "mode": "extents" })).unwrap();
+    let v = view(&s);
+    // Turned a quarter, the 100 x 50 line's box stands 100 high on screen.
+    assert!(near(v.twist.to_degrees(), 90.0));
+    assert!((v.center - Vec2::new(50.0, 25.0)).len() < 1e-6, "{:?}", v.center);
+    assert!(near(v.height, 105.0), "height {}", v.height);
+}
+
+#[test]
+fn each_tile_keeps_its_twist_through_a_dxf_round_trip() {
+    let mut s = session();
+    s.execute("-vports", &json!({ "option": "2", "arrangement": "vertical" })).unwrap();
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    let first = s.model_tiles().iter().position(|t| t.active).unwrap();
+    s.activate_tile(1 - first).unwrap();
+    assert_eq!(view(&s).twist, 0.0, "the other tile has its own twist");
+    s.execute("dview", &json!({ "twist": 60 })).unwrap();
+    let mut tw: Vec<f64> = s.model_tiles().iter().map(|t| t.view.twist.to_degrees()).collect();
+    tw.sort_by(f64::total_cmp);
+    assert!(near(tw[0], 30.0) && near(tw[1], 60.0), "{tw:?}");
+    // Switching back shows the first tile's twist again.
+    s.activate_tile(first).unwrap();
+    assert!(near(twist_deg(&s), 30.0));
+    // A saved configuration keeps both twists through DXF (VPORT group 51).
+    s.execute("-vports", &json!({ "option": "save", "name": "Pair" })).unwrap();
+    let dxf = cadcraft_io::write_dxf(s.doc().unwrap());
+    let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
+    let written = lines.windows(2).any(|w| w[0] == "51" && w[1].parse::<f64>().is_ok_and(|a| near(a, 30.0)));
+    assert!(written, "group 51 written");
+    let back = cadcraft_io::read_dxf(dxf.as_bytes()).unwrap();
+    let pair = back.vports.iter().find(|c| c.name == "Pair").unwrap();
+    let mut tw: Vec<f64> = pair.tiles.iter().map(|t| t.twist.to_degrees()).collect();
+    tw.sort_by(f64::total_cmp);
+    assert!(near(tw[0], 30.0) && near(tw[1], 60.0), "{tw:?}");
+    // Opened, restoring the configuration shows each tile turned as saved.
+    let mut o = Session::new();
+    o.viewport_px = (1200.0, 800.0);
+    o.open_drawing(back, "pair", None);
+    o.execute("-vports", &json!({ "option": "restore", "name": "Pair" })).unwrap();
+    let mut tw: Vec<f64> = o.model_tiles().iter().map(|t| t.view.twist.to_degrees()).collect();
+    tw.sort_by(f64::total_cmp);
+    assert!(near(tw[0], 30.0) && near(tw[1], 60.0), "{tw:?}");
+}
+
+#[test]
+fn opening_a_tiled_drawing_shows_the_current_tile_twisted() {
+    let mut s = session();
+    s.execute("dview", &json!({ "twist": 45 })).unwrap();
+    s.execute("-vports", &json!({ "option": "2" })).unwrap();
+    let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
+    let mut o = Session::new();
+    o.viewport_px = (1200.0, 800.0);
+    o.open_drawing(back, "tiled", None);
+    assert!(near(twist_deg(&o), 45.0), "twist {}", twist_deg(&o));
+}
+
+#[test]
+fn view_save_and_restore_keep_the_twist() {
+    let mut s = session();
+    s.execute("dview", &json!({ "twist": 30 })).unwrap();
+    s.execute("view", &json!({ "option": "save", "name": "Turned" })).unwrap();
+    let saved = s.doc().unwrap().views.iter().find(|v| v.name == "Turned").map(|v| v.twist.to_degrees()).unwrap();
+    assert!(near(saved, 30.0));
+    s.execute("dview", &json!({ "twist": 0 })).unwrap();
+    s.execute("view.set", &json!({ "center": [80, 40], "height": 3 })).unwrap();
+    assert_eq!(view(&s).twist, 0.0);
+    s.execute("view", &json!({ "option": "restore", "name": "Turned" })).unwrap();
+    assert!(near(twist_deg(&s), 30.0));
+    assert!((view(&s).center - Vec2::new(10.0, 10.0)).len() < 1e-9);
+    // view.set keeps the twist unless given one.
+    s.execute("view.set", &json!({ "center": [0, 0], "height": 5 })).unwrap();
+    assert!(near(twist_deg(&s), 30.0));
+    s.execute("view.set", &json!({ "center": [0, 0], "height": 5, "twist": 15 })).unwrap();
+    assert!(near(twist_deg(&s), 15.0));
+}

crates/engine/tests/xref.rs

@@ -52,6 +52,7 @@ fn insert(block: &str, x: f64) -> EntityKind {
         rows: 1,
         col_spacing: 0.0,
         row_spacing: 0.0,
+        clip: None,
     })
 }
 

crates/fonts/Cargo.toml

@@ -14,3 +14,4 @@ skrifa = { workspace = true }
 harfrust = { workspace = true }
 unicode-bidi = { workspace = true }
 icu_segmenter = { workspace = true }
+encoding_rs = { workspace = true }

crates/fonts/src/lib.rs

@@ -1,7 +1,8 @@
 //! CADCraft text layout.
 //!
 //! Turns TEXT and MTEXT into stroke polylines with the built-in single-stroke font
-//! ("CADCraft Stroke") or glyph outlines of installed TrueType fonts ([`ttf`]), with a
+//! ("CADCraft Stroke"), the user's SHX shape fonts and big fonts ([`shx`]) or glyph outlines
+//! of installed TrueType fonts ([`ttf`]), with a
 //! per-character fallback to installed fonts for characters the chosen font lacks. Handles the
 //! `%%` control codes, alignment modes, width factor, obliquing, MTEXT inline formatting
 //! (paragraphs, stacking, height changes), word wrap and attachment points.
@@ -18,6 +19,7 @@ pub mod bidi;
 mod complex;
 mod linebreak;
 mod mtext;
+pub mod shx;
 mod stroke;
 pub mod subset;
 pub mod ttf;
@@ -42,8 +44,8 @@ pub struct Run {
 }
 
 /// Replace `%%` control codes: `%%d` degree, `%%p` plus/minus, `%%c` diameter, `%%%` percent,
-/// `%%nnn` character code. Underline/overline toggles (`%%u`, `%%o`) are returned as flags
-/// per character.
+/// `%%nnn` character code, and `\U+XXXX` Unicode escapes. Underline/overline toggles (`%%u`,
+/// `%%o`) are returned as flags per character.
 pub fn decode_controls(s: &str) -> Vec<(char, bool, bool)> {
     let mut out = Vec::with_capacity(s.len());
     let mut under = false;
@@ -52,6 +54,14 @@ pub fn decode_controls(s: &str) -> Vec<(char, bool, bool)> {
     let mut i = 0;
     while i < chars.len() {
         let c = chars.get(i).copied().unwrap_or(' ');
+        // `\U+XXXX`: a Unicode character by its code.
+        if c == '\\'
+            && let Some(u) = unicode_escape(&chars, i)
+        {
+            out.push((u, under, over));
+            i += 7;
+            continue;
+        }
         if c == '%' && chars.get(i + 1) == Some(&'%') {
             let code = chars.get(i + 2).copied().unwrap_or(' ');
             match code.to_ascii_lowercase() {
@@ -83,6 +93,18 @@ pub fn decode_controls(s: &str) -> Vec<(char, bool, bool)> {
     out
 }
 
+/// The character of a `\U+XXXX` escape (four hex digits) starting at `chars[i]`.
+pub(crate) fn unicode_escape(chars: &[char], i: usize) -> Option<char> {
+    if chars.get(i) != Some(&'\\') || !matches!(chars.get(i + 1), Some('U' | 'u')) || chars.get(i + 2) != Some(&'+') {
+        return None;
+    }
+    let hex: String = chars.get(i + 3..i + 7)?.iter().collect();
+    if !hex.chars().all(|c| c.is_ascii_hexdigit()) {
+        return None;
+    }
+    char::from_u32(u32::from_str_radix(&hex, 16).ok()?)
+}
+
 /// Advance width of one character at height 1 and width factor 1.
 pub fn char_advance(c: char) -> f64 {
     match stroke::glyph(c) {
@@ -279,35 +301,65 @@ pub fn space_width(font: &TextFont, height: f64, width_factor: f64) -> f64 {
     {
         return w;
     }
+    if let TextFont::Shx(t) = font {
+        return shx::width(t, " ", height, width_factor);
+    }
     stroke_advance(' ', height, width_factor) + stroke::GAP / stroke::CAP * height * width_factor
 }
 
-/// The font a piece of text is set in: the built-in stroke font or an installed TrueType /
-/// OpenType face (outlines). Either way, characters the font lacks come from a fallback font.
+/// The font a piece of text is set in: the built-in stroke font, an installed TrueType /
+/// OpenType face (outlines) or the user's SHX fonts (a main font and a big font). Whichever,
+/// characters the font lacks come from a fallback font.
 #[derive(Clone, Debug, Default)]
 pub enum TextFont {
     #[default]
     Stroke,
     Outline(ttf::Face),
+    Shx(std::sync::Arc<shx::ShxText>),
 }
 
 impl TextFont {
-    /// Resolve a text style font name: an installed TTF/OTF/TTC when found; else, for a font we
-    /// can't find (an SHX file, a missing TTF), the FONTALT font ([`ttf::font_alt`]) when set;
-    /// else the stroke font.
+    /// Resolve a text style font name (no big font, horizontal): see [`TextFont::resolve_style`].
     pub fn resolve(name: &str) -> TextFont {
-        if let Some(f) = ttf::find(name) {
+        TextFont::resolve_style(name, "", false)
+    }
+
+    /// Resolve a text style's fonts: an installed TTF/OTF/TTC when `font` names one; else the
+    /// SHX font and big font when found ([`shx::find`]), a missing one replaced by the FONTALT
+    /// font ([`ttf::font_alt`], which may name both: `simplex.shx,bigfont.shx`); else FONTALT
+    /// as a TrueType font; else the stroke font (which also draws the characters a missing big
+    /// font would have). `vertical` is the style's vertical flag, honoured by fonts made for it.
+    pub fn resolve_style(font: &str, big_font: &str, vertical: bool) -> TextFont {
+        if let Some(f) = ttf::find(font) {
             return TextFont::Outline(f);
         }
-        let n = name.trim();
-        if n.is_empty() || n.eq_ignore_ascii_case(BUILTIN_FONT) {
+        let n = font.trim();
+        let builtin = n.is_empty() || n.eq_ignore_ascii_case(BUILTIN_FONT);
+        let alt = ttf::font_alt();
+        let (alt_main, alt_big) = alt.split_once(',').map_or((alt.as_str(), ""), |(a, b)| (a.trim(), b.trim()));
+        let main = if builtin { None } else { shx::find(n).or_else(|| shx::find(alt_main)) };
+        let (big, big_name) = match big_font.trim() {
+            "" => (None, ""),
+            b => match shx::find(b) {
+                Some(f) => (Some(f), b),
+                None => (shx::find(alt_big), alt_big),
+            },
+        };
+        if main.is_some() || big.is_some() {
+            return TextFont::Shx(std::sync::Arc::new(shx::ShxText::new(main, big, big_name, vertical)));
+        }
+        if builtin {
             return TextFont::Stroke;
         }
-        ttf::find(&ttf::font_alt()).map(TextFont::Outline).unwrap_or(TextFont::Stroke)
+        ttf::find(alt_main).map(TextFont::Outline).unwrap_or(TextFont::Stroke)
     }
     pub fn is_outline(&self) -> bool {
         matches!(self, TextFont::Outline(_))
     }
+    /// Whether the text is drawn with SHX fonts.
+    pub fn is_shx(&self) -> bool {
+        matches!(self, TextFont::Shx(_))
+    }
 }
 
 /// Shaped text in local or world coordinates: open strokes (stroke-font glyphs, underlines,
@@ -436,6 +488,9 @@ pub fn shape_line_dir(font: &TextFont, s: &str, height: f64, width_factor: f64,
     {
         return sh;
     }
+    if let TextFont::Shx(t) = font {
+        return shx::shape(t, s, height, width_factor, oblique);
+    }
     shape_stroke_dir(s, height, width_factor, oblique, base_rtl)
 }
 
@@ -450,6 +505,9 @@ pub fn text_width(font: &TextFont, s: &str, height: f64, width_factor: f64) -> f
     {
         return w;
     }
+    if let TextFont::Shx(t) = font {
+        return shx::width(t, s, height, width_factor);
+    }
     line_width(s, height, width_factor)
 }
 
@@ -529,7 +587,8 @@ pub fn baseline_start(font: &TextFont, s: &str, p: &TextParams) -> Vec2 {
 fn bottom_depth(font: &TextFont, height: f64) -> f64 {
     match font {
         TextFont::Outline(face) => ttf::descent_ratio(face).map_or(height / 3.0, |r| r * height),
-        TextFont::Stroke => height / 3.0,
+        // AutoCAD places it a third of the height down with SHX fonts.
+        TextFont::Stroke | TextFont::Shx(_) => height / 3.0,
     }
 }